// contain zero scale for zero values.
  llvm::SmallVector<double> scales;
  for (float scale : quant_params.scale) {
    if (scale == 0) {
      scales.push_back(std::numeric_limits<float>::min());
      continue;
    }
    scales.push_back(scale);
  }

  // Scale size can't be zero as it is checked before.
  if (quant_params.scale.size() != 1) {

// CHECK-DAG: %[[SCALE:.*]] = "tf.Const"() <{value = dense<0.00866141729> : tensor<f32>}> : () -> tensor<f32>

// CHECK-LABEL: func private @composite_dequantize_uniform_
// CHECK-DAG: %[[SCALE:.*]] = "tf.Const"() <{value = dense<0.00866141729> : tensor<f32>}> : () -> tensor<f32>

// CHECK-LABEL: func private @composite_dequantize_uniform

      } else {
        new_output_types.push_back(result.getType());
      }
    }

    // Remove this rescale op.
    rewriter.replaceOp(op, {pre_quantized});

    // Replace the output scale of the preceding op.
    rewriter.setInsertionPointAfter(def);
    OperationState new_state(def->getLoc(), def->getName().getStringRef(),
                             def->getOperands(), new_output_types,

  namespace: kube-system
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
rules:
  - apiGroups: [""]
    resources: ["configmaps"]
    verbs: ["get"]
  - apiGroups: ["apps"]
    resources: ["deployments/scale"]

)

// ValidateScale validates a Scale and returns an ErrorList with any errors.
func ValidateScale(scale *autoscaling.Scale) field.ErrorList {
	allErrs := field.ErrorList{}
	allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&scale.ObjectMeta, true, apimachineryvalidation.NameIsDNSSubdomain, field.NewPath("metadata"))...)

	if scale.Spec.Replicas < 0 {

// needed to construct the operands for the fused op. The caller provides the
// containing FuncOp as input with arguments specifying the input, weight,
// projection, bias and layer norm scale. The weight, projection, bias and
// layer norm scale all need to be RankedTensorType.
// This class overrides the layer norm coefficient setters from the base class.
class ConvertLayerNormalizedLSTMCellSimpleToFusedLSTM

  constexpr absl::string_view kModuleCode = R"mlir(
    module {
      func.func @test_fold_constant() -> (tensor<1024x24x24x3xf32>) {
        %zp = "tf.Const"() {value = dense<2> : tensor<i32>} : () -> tensor<i32>
        %scale = "tf.Const"() {value = dense<2.0> : tensor<f32>} : () -> tensor<f32>
        %weight = "tf.Const"() {value = dense<1> : tensor<1024x24x24x3xi8>} : () -> tensor<1024x24x24x3xi8>

    }
    return success(changed);
  }

 private:
  // Checks whether the operation is connected with a composite function.
  // If not, the same-scale op will not be quantized. This decision is based
  // on the current assumption that the performance gain of the same-scale
  // op itself could not beat the overhead of the quantize and dequantize
  // routines need to be added around that op. When the assumption changes,

            "reason": "reasonValue",
            "fieldPath": "fieldPathValue",
            "optionalOldSelf": true
          }
        ]
      }
    },
    "subresources": {
      "status": {},
      "scale": {
        "specReplicasPath": "specReplicasPathValue",
        "statusReplicasPath": "statusReplicasPathValue",
        "labelSelectorPath": "labelSelectorPathValue"
      }
    },
    "versions": [
      {

# CHECK:       quantization: {
# CHECK:         scale: [ 0.093635 ],
# CHECK:         zero_point: [ 22 ]
# CHECK:       }
# CHECK:     }, {
# CHECK:       shape: [ 1, 6, 31 ],
# CHECK:       type: INT8,
# CHECK:       buffer: 6,
# CHECK:       name: "output",
# CHECK:       quantization: {
# CHECK:         scale: [ 0.093635 ],
# CHECK:         zero_point: [ 22 ]
# CHECK:       }