SmallVectorImpl<int64_t>& result_shape) {
        if (shape_x.size() < 2 || shape_y.size() < 2) {
          return false;
        }

        // Checks outer dimensions (i.e., the dimensions higher than 2D) are
        // broadcastable. If true, then get the broadcasted shape for outer
        // dimension.
        if (!OpTrait::util::getBroadcastedShape(
                shape_x.drop_back(2), shape_y.drop_back(2), result_shape)) {

	kvs := map[string]any{}
	c.traces.Range(func(key, value any) bool {
		kvs[key.(string)] = value
		return true
	})
	outer := map[string]any{
		fmt.Sprintf("suite/%s", c.settings.TestID): kvs,
	}
	d, _ := yaml.Marshal(outer)
	return d

};

template <typename ExecutableType>
std::optional<typename DeviceCompilationCache<ExecutableType>::Value>
DeviceCompilationCache<ExecutableType>::Lookup(const Key& key) const {
  // The outer lock protects the existence of the cache entry. It does not
  // protect the contents of the cache entry.
  Entry* entry;
  {
    mutex_lock lock(compile_cache_mu_);
    // Find cache entry.

        val errors = result.errors
        assertEquals(2, errors.size)
        assertTrue { errors.all { it.errorReason is ErrorReason.AccessOnCurrentReceiverOnlyViolation } }
    }

    @Test
    fun `access on an outer receiver is not allowed`() {
        val result = schema.resolve(
            """
            inner {
                nested {
                    x = 1
                    y = 1
                    f()

    if (!island_op)
      return op.emitOpError()
             << "is not supported for lifting out of tf_executor.graph, "
                "expected tf_executor.island";

    // Move inner ops in island to before the outer graph.
    auto& island_body = island_op.GetBody().getOperations();
    parent_block->getOperations().splice(graph_position, island_body,
                                         island_body.begin(),

 * <p>
 * Generally, one regular Gradle invocation is conceptually a session.
 * However, the GradleBuild task is currently implemented in such a way that it uses a discrete session.
 * Having the GradleBuild task reuse the outer session is complicated because it <a href="https://github.com/gradle/gradle/issues/4559">may use a different Gradle user home</a>.
 * <p>
 * This set of services is added as a parent of each build session scope.
 */

  bool form_clusters = false;
  // If `unfold_batch_matmul` is true, the tf.BatchMatMul is unfolded to a set
  // of tfl.fully_connected ops.
  bool unfold_batch_matmul = true;
  // Whether to outline WhileOp at the end of the pipeline.
  bool outline_tf_while = false;
  // Whether to do shape inference.
  bool shape_inference = true;
  // Whether to do TFLite runtime verification.
  bool runtime_verification = true;

// compilation device type.
inline constexpr llvm::StringRef kCompileDeviceTypeAttr =
    "_xla_compile_device_type";
// The attribute value speicifes the preferred outlined function name in
// ClusterOutliningPass.
inline constexpr llvm::StringRef kClusterOutlinedFunctionNameAttr =
    "_cluster_outlined_function_name";
// Marks a node for replication. The attribute value indicates the replication

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(QuantizeVariablesPass)
  explicit QuantizeVariablesPass() = default;

  void runOnOperation() override;

 private:
  // Outlines the regions of the WhileOp's cond and body and insert function
  // calls instead.
  void QuantizeVariable(OpBuilder &builder,
                        const std::vector<VarHandleOp> &var_handle_op);
};

  rewriter.create<func::ReturnOp>(output_mul_op.getLoc(),
                                  output_mul_op.getResult());
  rewriter.clearInsertionPoint();
  return new_func;
}

// Outlines non-approximate GELU into a stablehlo composite.
//
//    -> mul 1/sqrt(2) -> erf -> add 1 ->
// in                                    mul
//    ---------> mul 0.5 --------------->
//