return failure();
    }

    // Update the results.
    SmallVector<Type, 4> new_results;
    if (failed(getTypeConverter()->convertTypes(op->getResultTypes(),
                                                new_results)))
      return failure();

    // Update the regions. The dialect conversion framework wants new regions to

        Value new_result = new_op_mapper.lookup(return_value);

        call_result.replaceAllUsesWith(new_result);
      }
      continue;
    }

    Operation& new_op = *builder.clone(op, arg_mapper);
    for (auto [result, new_result] :
         llvm::zip_equal(op.getResults(), new_op.getResults())) {
      new_op_mapper.map(result, new_result);
    }
  }

  call_op.erase();

          req_op.getLoc(), rewriter.getF32FloatAttr(6));
      new_result = rewriter.create<mlir::stablehlo::ClampOp>(
          req_op.getLoc(), min, new_result, max);
    } else if (func_name.contains("_relu_")) {
      auto min = rewriter.create<mlir::stablehlo::ConstantOp>(
          req_op.getLoc(), rewriter.getF32FloatAttr(0));
      new_result = rewriter.create<mlir::chlo::BroadcastMaxOp>(

    return mlir::failure();

  int64_t num_results = 0;
  if (succeeded(parser.parseOptionalColon())) {
    mlir::IntegerAttr attr;
    mlir::NamedAttrList attrs;
    if (failed(parser.parseAttribute(attr, "num_results", attrs)))
      return mlir::failure();
    num_results = attr.getValue().getSExtValue();
  }
  if (num_results < 0) return mlir::failure();

    }

    auto newResults = rewriter
                          .create<SrcOp>(loc, newResultTys, newOperands,
                                         op->getAttrDictionary().getValue())
                          .getOperation()
                          ->getResults();

    SmallVector<Value> replaceResults;
    for (int i = 0; i < newResults.size(); i++) {
      Value result = newResults[i];

      auto result_type = result.getType();

      Value new_result = new_op->getResult(i);
      if (IsQI8Type(result_type) || IsQUI8Type(result_type)) {
        builder->setInsertionPoint(op);
        TFL::QuantizeOp quant_op = builder->create<TFL::QuantizeOp>(
            op->getLoc(), result_type, new_result, TypeAttr::get(result_type));
        new_result = quant_op.getResult();
      }

      // Rewire the outputs.

  auto rhs_vals = const_oprs[1].getValues<ResultType>();
  const auto num_results = std::max(lhs_vals.size(), rhs_vals.size());
  std::vector<ResultType> res;
  res.reserve(num_results);

  auto lhs_start = lhs_vals.begin();
  auto rhs_start = rhs_vals.begin();

  for (int i = 0; i < num_results; ++i) {
    auto lhs_val = lhs_splat ? *lhs_start : *(lhs_start++);

        PerformanceTestJvmOptions.normalizeJvmOptions(jvmOptions)
    }

    abstract R newResult()

    R run() {
        assert !specs.empty
        assert testId

        Assume.assumeTrue(TestScenarioSelector.shouldRun(testId))
        TestProjects.validateTestProject(testProject)

        def results = newResult()

        try {
            runAllSpecifications(results)
        } catch (Exception e) {

     *
     * @param model
     * @param problems
     */
    public static <T> Result<T> newResult(T model, Iterable<? extends ModelProblem> problems) {
        return new Result<>(hasErrors(problems), model, problems);
    }

    /**
     * New result consisting of given result and new problem. Convenience for newResult(result.get(),
     * concat(result.getProblems(),problems)).
     *
     * @param result

     *
     * @param model
     * @param problems
     */
    public static <T> Result<T> newResult(T model, Iterable<? extends ModelProblem> problems) {
        return new Result<>(hasErrors(problems), model, problems);
    }

    /**
     * New result consisting of given result and new problem. Convenience for newResult(result.get(),
     * concat(result.getProblems(),problems)).
     *
     * @param result