if (auto qtype = quant::QuantizedType::getQuantizedElementType(
              q.getInput().getType())) {
        rewriter.setInsertionPoint(op);
        rewriter.replaceOpWithNewOp<DequantizeOp>(op, op.getOutput().getType(),
                                                  q.getInput());
        return success();
      }

      op.replaceAllUsesWith(q.getInput());

                                tensorflow::TensorShape(result_shape));
      auto attr_or = tensorflow::ConvertTensor(tensor, &rewriter);
      if (!attr_or.ok()) return failure();
      rewriter.replaceOpWithNewOp<TF::ConstOp>(op, attr_or.value());
      return success();
    }

    // Extract individual tensor list element and combine them using the tf.Pack
    // op.
    Location loc = op.getLoc();

        symbol_table.lookup(GetEntryFunctionName(op)));
    if (!entry_func_op) return failure();

    // Replace the XlaCallModuleOp with a new CallOp.
    rewriter.replaceOpWithNewOp<func::CallOp>(op, entry_func_op, op.getArgs());
    return success();
  }
};

void XlaCallModuleToCallPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext* ctx = module_op.getContext();

      if (IsIotaAttr(inserted_window_dims, indices_type.getShape().back()) &&
          IsIotaAttr(scatter_dims_to_operand_dims,
                     indices_type.getShape().back())) {
        rewriter.replaceOpWithNewOp<TfOp>(scatter_op,
                                          scatter_op.getResult(0).getType(),
                                          operands[0], indices, new_updates);
        return success();
      }

    std::string equation("...mk,...kn->...mn");
    if (op.getAdjX()) std::swap(equation[3], equation[4]);
    if (op.getAdjY()) std::swap(equation[6 + 3], equation[6 + 4]);

    rewriter.replaceOpWithNewOp<TF::EinsumOp>(
        op, op.getType(),
        /*inputs=*/ValueRange({input_lhs, input_rhs}),
        /*equation=*/equation);

    return success();
  }
};

#define GEN_PASS_DEF_BATCHMATMULTOEINSUMPASS

      const Value output = rewriter.create<mlir::stablehlo::BitcastConvertOp>(
          op->getLoc(), op.getResult().getType(), adaptor.getOperand());
      rewriter.replaceOpWithNewOp<mlir::stablehlo::ConvertOp>(
          op, getTypeConverter()->convertType(op.getResult().getType()),
          output);
    } else if (is_output_legal) {

      {qbarrier.getArg().getDefiningOp()->getLoc(), qbarrier.getLoc()});
  auto newConstOp = rewriter.create<arith::ConstantOp>(
      fusedLoc, newConstValueType, cast<TypedAttr>(newConstValue));
  rewriter.replaceOpWithNewOp<StorageCastOp>(qbarrier, qbarrier.getType(),
                                             newConstOp);
  return success();
}

void ConvertConstPass::runOnOperation() {

      auto new_tfr_cast = rewriter.create<TFR::CastOp>(
          cast_op.getLoc(),
          output_tensor_type.clone(input_tensor_type.getElementType()),
          cast_op.getArg());
      rewriter.replaceOpWithNewOp<TF::CastOp>(cast_op, output_type,
                                              new_tfr_cast);
      return success();
    }

    // If the two types are the same, the back-to-back tfr.cast ops can be

      if (auto qtype =
              QuantizedType::getQuantizedElementType(q.getArg().getType())) {
        rewriter.setInsertionPoint(op);
        rewriter.replaceOpWithNewOp<quantfork::DequantizeCastOp>(
            op, op.getResult().getType(), q.getArg());
        return success();
      }

      op.replaceAllUsesWith(q.getArg());
      return success();
    }

      return failure();
    }
    res.push_back(signed_lhs_val / signed_rhs_val);
  }

  auto res_attr = DenseElementsAttr::get(
      const_oprs[0].getType().cast<RankedTensorType>(), res);
  rewriter.replaceOpWithNewOp<stablehlo::ConstantOp>(adaptor.value().Op(),
                                                     res_attr);
  return success();
}

static LogicalResult FoldDivOp(stablehlo::DivOp op, PatternRewriter& rewriter) {