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) {

          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>(

    }

    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.