HTTPStatusCode: http.StatusBadRequest,
	},
	ErrParseCastArity: {
		Code:           "ParseCastArity",
		Description:    "The SQL expression CAST has incorrect arity.",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrParseInvalidTypeParam: {
		Code:           "ParseInvalidTypeParam",
		Description:    "The SQL expression contains an invalid parameter value.",

  func.return %0 : tensor<2x1x7x8x1xf32>

  // CHECK-DAG: %[[BEGIN:.*]] = arith.constant dense<0> : tensor<5xi32>
  // CHECK-DAG: %[[END:.*]] = arith.constant dense<[2, 3, 0, 0, 5]> : tensor<5xi32>
  // CHECK-DAG: %[[STEP:.*]] = arith.constant dense<1> : tensor<5xi32>
  // CHECK-DAG: %[[NEW_DIMS:.*]] = arith.constant dense<[6, 1, 7, 8, 1]> : tensor<5xi32>

  %cst = arith.constant dense<25.4> : tensor<2x3xf32>
  func.return %cst : tensor<2x3xf32>

// CHECK-NEXT:  %[[cst:.*]] = arith.constant dense<2.540000e+01> : tensor<2x3xf32>
// CHECK-NEXT:  "tfl.quantize"(%[[cst]]) <{qtype = tensor<2x3x!quant.uniform<u8:f32, 0.099607841641295186>>}> {volatile}
}

// CHECK-LABEL: QuantizePositiveScalar
func.func @QuantizePositiveScalar() -> tensor<f32> {

      %cst_4 = arith.constant dense<[0, 0, 1, 1, 1]> : tensor<5xi32>
      %cst_5 = arith.constant dense<[0, 1, 0, 1, 1]> : tensor<5xi32>
      %cst_6 = arith.constant dense<2> : tensor<i32>
      %cst_7 = arith.constant dense<"*"> : tensor<!tf_type.string>
      %cst_8 = arith.constant dense<-1> : tensor<1xi32>
      %cst_9 = arith.constant dense<-1> : tensor<i32>

    auto begin_op =
        rewriter.create<arith::ConstantOp>(op->getLoc(), type, begin_attr);
    auto end_attr = DenseElementsAttr::get<int32_t>(type, padded_end);
    auto end_op =
        rewriter.create<arith::ConstantOp>(op->getLoc(), type, end_attr);
    auto stride_attr = DenseElementsAttr::get<int32_t>(type, padded_stride);
    auto stride_op =
        rewriter.create<arith::ConstantOp>(op->getLoc(), type, stride_attr);

    %cst_2 = "tfl.no_value"() {value = unit} : () -> none
    %cst_3 = arith.constant dense<1.0> : tensor<20x20xf32>
    %cst_7 = arith.constant dense<1.0> : tensor<20xf32>
    %cst_11 = arith.constant dense<1.0> : tensor<20x28xf32>
    %recurrent_input = arith.constant dense<1.0> : tensor<1x20xf32>

#include "llvm/Support/Casting.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "mlir/Dialect/Affine/Analysis/LoopAnalysis.h"  // from @llvm-project
#include "mlir/Dialect/Arith/IR/Arith.h"  // from @llvm-project
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project
#include "mlir/Dialect/Quant/QuantOps.h"  // from @llvm-project
#include "mlir/IR/Attributes.h"  // from @llvm-project

	if m.IsValid() {
		tags["size"] = m.Size
		tags["mtime"] = m.ModTime.Format(http.TimeFormat)
		tags["data"] = m.Erasure.DataBlocks
		tags["parity"] = m.Erasure.ParityBlocks
	} else {
		tags["invalid-meta"] = true
		tags["data"] = er.setDriveCount - er.defaultParityCount
		tags["parity"] = er.defaultParityCount
	}

	// count the number of offline disks
	offline := 0
	for i := 0; i < len(errs); i++ {
		var found bool

		// If storage class is not set during startup, default values are used
		// -- Default for Reduced Redundancy Storage class is, parity = 2
		// -- Default for Standard Storage class is, parity = 2 - disks 4, 5
		// -- Default for Standard Storage class is, parity = 3 - disks 6, 7
		// -- Default for Standard Storage class is, parity = 4 - disks 8 to 16
		if commonParityDrives == 0 {
			commonParityDrives, err = ecDrivesNoConfig(ep.DrivesPerSet)

#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/Analysis/AssumeBundleQueries.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/FormatVariadic.h"
#include "mlir/Dialect/Arith/IR/Arith.h"  // from @llvm-project
#include "mlir/Dialect/Func/Extensions/AllExtensions.h"  // from @llvm-project
#include "mlir/Dialect/Func/IR/FuncOps.h"  // from @llvm-project