patterns.add<QuantizeWeight>(ctx, quantization_component_spec_);

  FrozenRewritePatternSet frozen_patterns(std::move(patterns));

  if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
    signalPassFailure();
  }
}

}  // namespace

// Creates an instance of the StableHLO dialect Quantize Weight pass.
std::unique_ptr<OperationPass<func::FuncOp>> CreateQuantizeWeightPass(

                << "Failed at " << nestedOp->getName().getStringRef().str()
                << " op",
            tflite::metrics::ConverterErrorData::ERROR_NEEDS_FLEX_OPS);
      }
    });
    signalPassFailure();
  };
};

absl::StatusOr<OwningOpRef<mlir::ModuleOp>> LoadModule(
    MLIRContext* context, const std::string& file_name) {
  std::string error_message;

    patterns = std::move(pattern_list);
    return success();
  }

  void runOnOperation() override {
    auto func = getOperation();
    if (failed(applyPatternsAndFoldGreedily(func, patterns)))
      signalPassFailure();
  }

  FrozenRewritePatternSet patterns;
};

}  // namespace

void CreateTFStandardPipeline(OpPassManager &pm,
                              const StandardPipelineOptions &options) {

  }
};

class AlwaysFailPass
    : public mlir::PassWrapper<AlwaysFailPass, mlir::OperationPass<>> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(AlwaysFailPass)

  void runOnOperation() override { signalPassFailure(); }
};

}  // namespace debug_test

namespace {

using ::testing::HasSubstr;
using ::testing::IsEmpty;
using ::testing::Not;
using namespace tensorflow::debug_test;

  pattern_list.add<HandleIf>(&getContext());
  FrozenRewritePatternSet patterns(std::move(pattern_list));

  if (failed(applyPatternsAndFoldGreedily(module, patterns))) {
    signalPassFailure();
  }
}
}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateDecomposeOptionalsPass() {
  return std::make_unique<DecomposeOptionalsPass>();
}

}  // namespace TF

  // Get runtime devices information from the closest parent module.
  auto module = getOperation();
  if (failed(CheckPreconditions(module))) signalPassFailure();

  mlir::TF::RuntimeDevices devices;
  if (failed(tensorflow::GetDevicesFromOp(module, &devices)))
    return signalPassFailure();

  llvm::SmallVector<mlir::tf_device::ParallelExecuteOp, 4>
      tmp_parallel_execute_ops;
  std::optional<bool> is_map_oc;

    mlir::RewritePatternSet patterns(context);
    AddLiftTfliteFlexOpsPatterns(context, patterns);
    if (failed(applyPatternsAndFoldGreedily(func, std::move(patterns)))) {
      signalPassFailure();
      return;
    }
  }
};

}  // namespace

void AddLiftTfliteFlexOpsPatterns(MLIRContext* context,
                                  RewritePatternSet& patterns) {

    patterns.add<UnfuseBatchNormInferencePattern>(&getContext());
    if (failed(applyPatternsAndFoldGreedily(getOperation(),
                                            std::move(patterns)))) {
      return signalPassFailure();
    }
  }
};

std::unique_ptr<Pass> createUnfuseBatchNormPass() {
  return std::make_unique<UnfuseMhloBatchNormPass>();
}

static PassRegistration<UnfuseMhloBatchNormPass> pass;

                                          op))) {
        return WalkResult::interrupt();
      }
      return WalkResult::advance();
    });
    if (result.wasInterrupted()) {
      return signalPassFailure();
    }
  }
};

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateXlaCallModuleDeserializationPass() {
  return std::make_unique<XlaCallModuleDeserializationPass>();
}

  // parallel.
  for (auto func : module_op.getOps<func::FuncOp>()) {
    if (failed(applyPatternsAndFoldGreedily(func, frozen_patterns))) {
      func.emitError() << "quant-quantize-weights failed.";
      signalPassFailure();
    }
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreateQuantizeWeightsPass(
    const tensorflow::quantization::QuantizationOptions& quant_options) {