// to yield.
  ReplaceRegionWithCall(GetName(while_op.getOperation(), "_cond"),
                        while_op.getCond(), false, num_loop_carried,
                        extern_values, types, while_op.getLoc());
  ReplaceRegionWithCall(GetName(while_op.getOperation(), "_body"),
                        while_op.getBody(), true, num_loop_carried,

  if (auto block_arg = mlir::dyn_cast<BlockArgument>(value))
    return block_arg.getOwner()->getParentOp();

  return value.getDefiningOp();
}

void TPUAnnotateDynamicShapeInputsPass::runOnOperation() {
  getOperation().walk([&](tf_device::ClusterFuncOp cluster_func_op) {
    Builder builder(cluster_func_op->getContext());
    // Skip non-tpu device cluster_func.
    auto cluster_id =

  // TODO: b/304003568 - Add TF_TransposeOp folding logic to tflite.
  target.addIllegalOp<mhlo::DotGeneralOp, mhlo::DotOp, mhlo::TransposeOp>();
  if (failed(applyPartialConversion(getOperation(), target,
                                    std::move(patterns)))) {
    getOperation().emitError("mhlo to TFLite legalization failed.");
    signalPassFailure();
  }
}
}  // namespace

    var_handle_op.erase();
  }
}

void QuantizeVariablesPass::runOnOperation() {
  ResourceIdMap resource_id_map;
  ResourceMap resource_map;

  // Collect all resource identities.
  getOperation().walk([&](TFL::VarHandleOp var_handle_op) {
    auto identity = std::make_pair(var_handle_op.getContainer().str(),
                                   var_handle_op.getSharedName().str());
    resource_id_map.insert(

    if (op.use_empty() &&
        (op.getIsStateless() ||
         (IsSideEffectFree(then_func) && IsSideEffectFree(else_func)))) {
      rewriter.eraseOp(op.getOperation());
      return success();
    }

    // Extract the constant cond value.
    DenseElementsAttr cond;
    if (!matchPattern(op.getCond(), m_Constant(&cond))) return failure();

    to_fetch = to_fetch.drop_back();
  }
  builder.create<tf_executor::FetchOp>(loc, to_fetch);
  // Build Island.
  island.getBody().push_back(new Block);
  island.getBody().front().getOperations().splice(
      island.getBody().front().begin(), body.getOperations(),
      copy_range.begin(), copy_range.end());
  builder.setInsertionPointToEnd(&island.getBody().front());
  builder.create<tf_executor::YieldOp>(loc, return_op.getOperands());

class SHLOSimplifyPass : public impl::SHLOSimplifyPassBase<SHLOSimplifyPass> {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(SHLOSimplifyPass)

  void runOnOperation() override {
    ModuleOp module = getOperation();
    RewritePatternSet patterns(&getContext());
    populateWithGenerated(patterns);
    PopulateFolderPatterns(patterns);
    if (failed(applyPatternsAndFoldGreedily(module, std::move(patterns)))) {

	if code > 600 {
		code = 600
	}
	m.webhookRequest.WithContext(ctx).WithLabelValues(name, stepType, string(attr.GetOperation()), strconv.Itoa(code), strconv.FormatBool(rejected)).Inc()
	m.webhook.observe(ctx, elapsed, name, stepType, string(attr.GetOperation()), strconv.FormatBool(rejected))
}

// ObserveWebhookRejection records admission related metrics for an admission webhook rejection.

      RemoveShardingCustomCallPass>::RemoveShardingCustomCallPassBase;

 private:
  void runOnOperation() override;
};

void RemoveShardingCustomCallPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  populateWithGenerated(patterns);

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

void PrintPass::runOnOperation() {
  llvm::sys::SmartScopedLock<true> instrumentationLock(mutex_);
  OpPrintingFlags flags =
      OpPrintingFlags().elideLargeElementsAttrs().enableDebugInfo(false);
  getOperation()->print(*os_, flags);
}
}  // namespace

std::unique_ptr<OperationPass<ModuleOp>> CreatePrintPass(raw_ostream* os) {
  return std::make_unique<PrintPass>(os);
}

}  // namespace TF