}
};

// Rewrites quantized `stablehlo.constant` to `tfl.pseudo_qconst`.
class RewriteQuantizedConstantOp
    : public OpRewritePattern<stablehlo::ConstantOp> {
 public:
  using OpRewritePattern<stablehlo::ConstantOp>::OpRewritePattern;

  LogicalResult match(stablehlo::ConstantOp op) const override {
    return success(IsQuantizedTensorType(op.getOutput().getType()));
  }

			return
		}

		// if both arguments are constants, the result is a constant
		if x.mode == constant_ && y.mode == constant_ {
			x.val = constant.BinaryOp(constant.ToFloat(x.val), token.ADD, constant.MakeImag(constant.ToFloat(y.val)))
		} else {
			x.mode = value
		}

		if check.recordTypes() && x.mode != constant_ {
			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ))
		}

std::unique_ptr<OperationPass<func::FuncOp>> createConvertSimulatedQuantPass();

/// Creates a pass that converts constants followed by a qbarrier to a
/// constant whose value is quantized. This is typically one of the last
/// passes done when lowering to express actual quantized arithmetic in a
/// low level representation. Because it modifies the constant, it is
/// destructive and cannot be undone.

    // Fold the constant value by transposing the values according to the
    // `TransposeOp`'s permutation attribute.
    const DenseElementsTransposer transposer(original_shape,
                                             op.getPermutation());
    SmallVector<float> transposed_values =
        transposer.TransposeValues(original_values);

    // Create a new constant op with the transposed values.

					cause = check.sprintf("constant %s overflows %s (in %s)", x.val, u, T)
				} else {
					cause = check.sprintf("cannot convert %s to type %s (in %s)", x, u, T)
				}
				return false
			}
			return true
		})
		x.mode = value // type parameters are not constants
	case x.convertibleTo(check, T, &cause):
		// non-constant conversion
		ok = true
		x.mode = value
	}

	if !ok {

      the second argument is the zero point constant (element type: int) and
      the third argument is the inverse scale constant (element type: float).
    * A tensor is dequantized using a `func::FuncOp` whose name contains
      "uniform_dequantize". The first argument is the tensor to be quantized,
      the second argument is the zero point constant (element type: int) and

  auto one_cst =
      rewriter.create<stablehlo::ConstantOp>(rewriter.getUnknownLoc(), one_val);

  auto half_val = DenseElementsAttr::get(type, kHalf);
  auto half_cst =
      rewriter.create<stablehlo::ConstantOp>(one_cst.getLoc(), half_val);

  auto one_over_root2_val = DenseElementsAttr::get(type, kOneOverRoot2);
  auto one_over_root2_cst = rewriter.create<stablehlo::ConstantOp>(
      half_cst.getLoc(), one_over_root2_val);

// TODO(b/329300758): add file check back after the cl is fixed | FileCheck %s
// Check a few basic properties of the import-export,
// including constants retaining their shape
// and the module including the TFLite version.

func.func @main(tensor<3x2xi32>) -> tensor<3x2xi32> {
^bb0(%arg0: tensor<3x2xi32>):
  // CHECK: module attributes

			return
		}

		// if both arguments are constants, the result is a constant
		if x.mode == constant_ && y.mode == constant_ {
			x.val = constant.BinaryOp(constant.ToFloat(x.val), token.ADD, constant.MakeImag(constant.ToFloat(y.val)))
		} else {
			x.mode = value
		}

		if check.recordTypes() && x.mode != constant_ {
			check.recordBuiltinType(call.Fun, makeSig(resTyp, x.typ, x.typ))
		}

    // Cannot use the pattern rewriter because the driver applies folders by
    // default.
    module.walk([&](mhlo::ConstantOp const_op) {
      UnfoldSplatConstant(&op_builder, const_op);
    });
  }

 private:
  void UnfoldSplatConstant(mlir::OpBuilder* op_builder,
                           mhlo::ConstantOp const_op) const {
    auto splat_elements_attr =
        mlir::dyn_cast<SplatElementsAttr>(const_op.getValue());