// CHECK-LABEL: einsum_with_runtime_outputshape1
// CHECK-DAG: %[[cst:.*]] = arith.constant dense<[0, 1, 3, 2]> : tensor<4xi32>
// CHECK-DAG: %[[cst_0:.*]] = arith.constant dense<[-1, 36, 1, 32]> : tensor<4xi64>
// CHECK-DAG: %[[cst_1:.*]] = arith.constant dense<[0, 1]> : tensor<2xi32>
// CHECK-DAG: %[[cst_2:.*]] = arith.constant dense<2> : tensor<1xi32>

  %cst = arith.constant dense<0.000000e+00> : tensor<4x2xf32>
  %cst_0 = arith.constant dense<0.000000e+00> : tensor<8xf32>
  %cst_1 = arith.constant dense<[1, 0, 2]> : tensor<3xi32>
  %cst_2 = arith.constant dense<0.000000e+00> : tensor<4x4x2xf32>
  %cst_3 = arith.constant dense<4> : tensor<i32>
  %cst_4 = arith.constant dense<1.000000e+00> : tensor<f32>
  %cst_5 = arith.constant dense<1> : tensor<i32>

// CHECK-NEXT:  [[NEG_ONE:%.*]] = arith.constant dense<-1> : tensor<1xi32>
// CHECK-NEXT:  [[ZERO:%.*]] = arith.constant dense<0> : tensor<i32>
// CHECK-NEXT:  [[ONE:%.*]] = arith.constant dense<1> : tensor<1xi32>
// CHECK-NEXT:  [[ELEM_SHAPE:%.*]] = "tf.Slice"([[SHAPE]], [[ONE]], [[NEG_ONE]]) : (tensor<?xi32>, tensor<1xi32>, tensor<1xi32>) -> tensor<?xi32>
// CHECK-NEXT:  [[ZERO_1:%.*]] = arith.constant dense<0> : tensor<i32>

  %perm = arith.constant dense<[3, 0, 1, 2]> : tensor<4xi32>
  %0 = "tfl.transpose"(%arg0, %perm) : (tensor<2x3x4x5xf32>, tensor<4xi32>) -> tensor<5x2x3x4xf32>
  %cst = arith.constant dense<1.0> : tensor<5x2x3x4xf32>
  %1 = tfl.add %0, %cst { fused_activation_function = "NONE" } : tensor<5x2x3x4xf32>
  func.return %1 : tensor<5x2x3x4xf32>
}

// CHECK: %cst = arith.constant dense<[3, 0, 1, 2]> : tensor<4xi32>

### Allowed values for STANDARD storage class

`STANDARD` storage class implies more parity than `REDUCED_REDUNDANCY` class. So, `STANDARD` parity drives should be

- Greater than or equal to 2, if `REDUCED_REDUNDANCY` parity is not set.
- Greater than `REDUCED_REDUNDANCY` parity, if it is set.

Parity blocks can not be higher than data blocks, so `STANDARD` storage class parity can not be higher than N/2. (N being total number of drives)

  %0 = arith.constant dense<0.00000e+00> : tensor<10x10xf32>
  %1 = arith.constant dense<1.00000e+00> : tensor<1000x1000xf32>
  func.return %0, %1 : tensor<10x10xf32>, tensor<1000x1000xf32>

  // CHECK-DAG: %cst = arith.constant dense<0.000000e+00> : tensor<10x10xf32>
  // CHECK-DAG: %cst_0 = arith.constant dense<1000> : tensor<2xi64>
  // CHECK-DAG: %cst_1 = arith.constant dense<1.000000e+00> : tensor<f32>

  %cst = arith.constant dense<1.5> : tensor<32xf32>
  %cst_0 = arith.constant dense<[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0]> : tensor<16xf32>
  %cst_1 = arith.constant dense<[1, 64, 84, 32]> : tensor<4xi32>
  %cst_2 = arith.constant dense<1.0> : tensor<32x4x4x128xf32>

// CHECK-LABEL: fuseMulIntoPerTensorConv2dWithQDQs
func.func @fuseMulIntoPerTensorConv2dWithQDQs(%arg0: tensor<256x32x32x3xf32>) -> tensor<256x8x7x3xf32> {
  %cst = arith.constant dense<1.5> : tensor<3xf32>
  %cst_0 = arith.constant dense<[1.0, 2.0, 3.0]> : tensor<3xf32>
  %w = arith.constant dense<2.0> : tensor<3x3x3x3xf32>

      CHECK-NEXT: %{{.*}} = arith.cmpi "eq", %x, %y : i64
      CHECK-NEXT: %{{.*}} = arith.cmpi "ult", %x, %y : i64
      CHECK-NEXT: %{{.*}} = arith.cmpi "ule", %x, %y : i64
      CHECK-NEXT: %{{.*}} = arith.cmpi "ugt", %x, %y : i64
      CHECK-NEXT: %{{.*}} = arith.cmpi "uge", %x, %y : i64
      CHECK-NEXT: %{{.*}} = arith.cmpi "ne", %x, %y : i64
      CHECK-NEXT: %{{.*}} = arith.addi %x, %y : i64

			Standard: StorageClass{
				Parity: 8,
			},
			RRS: StorageClass{
				Parity: 2,
			},
			initialized: true,
		}
		// Set env var for test case 4
		if i+1 == 4 {
			scfg.RRS.Parity = 7
		}
		// Set env var for test case 5
		if i+1 == 5 {
			scfg.Standard.Parity = 6
		}
		// Set env var for test case 6
		if i+1 == 6 {
			scfg.Standard.Parity = 7
		}