auto rhs_type = mlir::dyn_cast<RankedTensorType>(rhs.getType());
    if (!lhs_type || !rhs_type) return failure();
    if (mlir::isa<ComplexType>(lhs_type.getElementType()) && op.getAdjX()) {
      lhs = rewriter.create<TF::ConjOp>(op.getLoc(), lhs_type, lhs);
    }
    if (mlir::isa<ComplexType>(rhs_type.getElementType()) && op.getAdjY()) {
      rhs = rewriter.create<TF::ConjOp>(op.getLoc(), rhs_type, rhs);
    }

		{"(*CharType).String", Method, 0},
		{"(*CommonType).Common", Method, 0},
		{"(*CommonType).Size", Method, 0},
		{"(*ComplexType).Basic", Method, 0},
		{"(*ComplexType).Common", Method, 0},
		{"(*ComplexType).Size", Method, 0},
		{"(*ComplexType).String", Method, 0},
		{"(*Data).AddSection", Method, 14},
		{"(*Data).AddTypes", Method, 3},
		{"(*Data).LineReader", Method, 5},

      Type typeOfElementsInY = getElementTypeOrSelf(y.getType());
      ElementsAttr attr = yDefOp.getValue();
      bool yHasComplexElements = mlir::isa<ComplexType>(typeOfElementsInY);

      // If `y` is a splat constant, then the op will definitely get replaced.
      // We check for a splat constant first, in order to optimize the

		switch c {
		case 'O':
			ret = &RvalueReferenceType{Base: t}
		case 'P':
			ret = &PointerType{Base: t}
		case 'R':
			ret = &ReferenceType{Base: t}
		case 'C':
			ret = &ComplexType{Base: t}
		case 'G':
			ret = &ImaginaryType{Base: t}
		}
	case 'U':
		if len(st.str) < 2 {
			st.fail("expected source name or unnamed type")
		}
		switch st.str[1] {
		case 'l':

    return tflite::TensorType_STRING;
  } else if (mlir::isa<mlir::TF::Quint8Type>(type)) {
    return tflite::TensorType_UINT8;
  } else if (auto complex_type = mlir::dyn_cast<mlir::ComplexType>(type)) {
    auto ftype = complex_type.getElementType();
    if (ftype.isF32()) {
      return tflite::TensorType_COMPLEX64;
    }
    if (ftype.isF64()) {
      return tflite::TensorType_COMPLEX128;
    }

  if (IsI32Type(element_type) || IsUI32Type(element_type) ||
      IsI64Type(element_type) || IsQI16Type(element_type) ||
      IsI16Type(element_type) || element_type.isa<ComplexType>() ||
      element_type.isF32()) {
    return VerifyOperandsHaveSameShapesOrBroadcastableShape(
        /*op=*/op.getOperation(), /*indices=*/ArrayRef<unsigned>{0, 1},
        /*max_bcast_rank=*/6);
  }