}

void LocalizeVarHandlesPass::runOnOperation() {
  auto module = getOperation();

  DataFlowSolver solver;
  solver.load<dataflow::DeadCodeAnalysis>();
  solver.load<dataflow::SparseConstantPropagation>();
  TF::LoadResourceDataflowAnalysis(solver);
  if (failed(solver.initializeAndRun(module))) return signalPassFailure();

  OpBuilder globalBuilder(module.getBodyRegion());

  module.walk(

  }
  void runOnOperation() override {
    auto module = getOperation();

    DataFlowSolver solver;
    solver.load<dataflow::DeadCodeAnalysis>();
    solver.load<dataflow::SparseConstantPropagation>();
    TF::LoadResourceDataflowAnalysis(solver);
    if (failed(solver.initializeAndRun(module))) return signalPassFailure();

    SymbolTable symbol_table(module);

  auto module = getOperation();
  if (!tf_saved_model::HasTfSavedModelSemantics(module)) return;

  DataFlowSolver solver;
  solver.load<dataflow::DeadCodeAnalysis>();
  solver.load<dataflow::SparseConstantPropagation>();
  TF::LoadResourceDataflowAnalysis(solver);
  if (failed(solver.initializeAndRun(module))) return signalPassFailure();

  DenseSet<GlobalTensorOp> remaining_global_tensor_ops;
  {

  Operation *module = getOperation();

  SymbolTableCollection symbolTables;

  DataFlowSolver solver;
  solver.load<dataflow::DeadCodeAnalysis>();
  solver.load<dataflow::SparseConstantPropagation>();
  solver.load<DeviceDataflowAnalysis>(symbolTables);
  if (failed(solver.initializeAndRun(module))) return signalPassFailure();

  module->walk([&](TF::TPUCopyWithDynamicShapeOp op) {

			// sorts them by Timestamps if they have the same Pod Priority).
			// Using a fake clock for the queue and incrementing it after each added Pod will
			// solve this issue on Windows unit test runs.
			// For more details on the Windows clock resolution issue, see: https://github.com/golang/go/issues/8687
			for _, p := range test.initialPods {
				q.Add(logger, p)

    setAllToEntryStates(results);
  }
  ~IsCompositeDataflowAnalysis() override = default;
};

void LoadResourceDataflowAnalysis(DataFlowSolver &solver) {
  solver.load<ResourceDataflowAnalysis>();
}

void LoadIsCompositeDataflowAnalysis(DataFlowSolver &solver) {
  solver.load<IsCompositeDataflowAnalysis>();
}

}  // namespace TF

  }
}

void ConvertControlToDataOutputsPass::runOnOperation() {
  ModuleOp module = getOperation();

  DataFlowSolver solver;
  solver.load<dataflow::DeadCodeAnalysis>();
  solver.load<dataflow::SparseConstantPropagation>();
  TF::LoadIsCompositeDataflowAnalysis(solver);
  if (failed(solver.initializeAndRun(module))) return signalPassFailure();

  // This pass assumes that all functions are suitable for export i.e., each

        as in the back prop though `tf.gather` into a dense embedding). See
        issue [39751](https://github.com/tensorflow/tensorflow/issues/39751)
        which this change addresses, but does not solve. This exception-throwing
        behavior can be disabled by setting the environment variable
        `TF_DISABLE_SEGMENT_REDUCTION_OP_DETERMINISM_EXCEPTIONS` to `"true"` or

};

typedef dataflow::Lattice<ResourceConstructingOps> ResourceDataflowState;
typedef dataflow::Lattice<IsComposite> IsCompositeDataflowState;

void LoadResourceDataflowAnalysis(DataFlowSolver &solver);
void LoadIsCompositeDataflowAnalysis(DataFlowSolver &solver);

}  // namespace TF
}  // namespace mlir

    implementation("org.codenarc:CodeNarc") {
        exclude(group = "org.apache.groovy")
        exclude(group = "org.codehaus.groovy")
    }
    implementation("com.github.javaparser:javaparser-symbol-solver-core") {
        exclude(group = "com.google.guava")
    }
    implementation("org.gradle.kotlin:gradle-kotlin-dsl-conventions")
    implementation(kotlin("gradle-plugin"))