/*Truncate=*/builder->getBoolAttr(false));
    }
    operands.push_back(val);
  }
  return builder->create<func::CallOp>(loc, fn, operands).getOperation();
}

// Prepares for jump to the given block by introducing necessary tensor_cast
// operations and returning Values of types required by the block.
//

    }
  }
}

void TpuV1BridgeExecutorIslandCoarsening::runOnOperation() {
  SymbolTable symbol_table(getOperation());

  // Map tpu cluster names to the functions that contain operations for this
  // cluster.
  DenseMap<StringRef, DenseSet<func::FuncOp>> tpu_funcs;
  for (func::FuncOp func_op : getOperation().getOps<func::FuncOp>()) {
    func_op.walk([&](Operation* op) {

    func.getAllResultAttrs(tmp);

    for (const auto& res : tmp) {
      result_attrs.push_back(res.getValue().vec());
    }
  }

  mlir::Builder builder(func.getOperation());

  for (OpOperand& operand : fetch.getOperation()->getOpOperands()) {
    if (mlir::isa<tf_executor::ControlType>(operand.get().getType())) break;
    auto it = value_to_device.find(operand.get());
    if (it != value_to_device.end()) {

  auto parallel_execute = llvm::dyn_cast<tf_device::ParallelExecuteOp>(
      execute_launch->getParentOp());
  Operation* execute_parent =
      parallel_execute ? parallel_execute.getOperation() : execute_launch;
  // Collect all operands of `execute` whose defining ops are variable reads
  // that might get merged, and add relevant information to `var_access_info`.

						// Ignore context cancelled from webhook metrics
						if !errors.Is(err.Reason, context.Canceled) {
							admissionmetrics.Metrics.ObserveWebhookRejection(ctx, hook.Name, "validating", string(versionedAttr.Attributes.GetOperation()), admissionmetrics.WebhookRejectionCallingWebhookError, int(err.Status.ErrStatus.Code))
						}
					}

        new_ewise_op->getLoc(), op->getResult(0).getType(),
        new_ewise_op->getResults()[0], perm);
    rewriter.replaceOp(op, out_tpose_op.getOperation());
    return success();
  }
};

void PushTransposeThroughEwisePass::runOnOperation() {
  auto module = getOperation();
  RewritePatternSet patterns(&getContext());

  patterns.add<CommuteTransposeWithEwiseOps>(&getContext());

  // 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 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.

  mlir::tf_device::LaunchOp launch = CreateLaunchForBlock(
      builder, cluster, /*before=*/false, launch_block, host_device);

  auto operand_not_in_launch = [&](mlir::OpOperand& operand) {
    return !launch.getOperation()->isProperAncestor(operand.getOwner());
  };
  for (auto result : llvm::zip(launch.GetBody().getTerminator()->getOperands(),
                               launch.getResults()))

  auto stats_op = b.create<quantfork::StatisticsOp>(
      b.getUnknownLoc(), res, layer_stats, axis_stats, axis);
  res.replaceAllUsesWith(stats_op);
  stats_op.getOperation()->replaceUsesOfWith(stats_op, res);
}

void ImportQuantStatsPass::ImportAsStatsOps(OpBuilder b, Operation *op,
                                            int index,