input.getDefiningOp())) {
        // Tensors with derived scale are biases, and handled in propagation.
        if (tensor_property.use_derived_scale) continue;
        // For weights, use quantization scale inferred from the values.
        if (failed(processConstantOp(op, input.getDefiningOp(), index,
                                     tensor_property, rewriter))) {
          return failure();

                     "Uses TF Uniform Quantized ops"))};

  Option<int64_t> min_num_elements_for_weights_{
      *this, "min-num-elements-for-weights", llvm::cl::init(0),
      llvm::cl::desc("The minimum required number of elements in a weight "
                     "array to apply quantization.")};

  Option<QuantMethod> quantization_method_{
      *this, "quantization-method",

    LOG(INFO) << quantized_tensor->name()->str() << " "
              << float_tensor->name()->str();
    if (ExpectEqualTensor(quantized_tensor, float_tensor)) {
      if (quantized && quantized_tensor->name()->str().find("weights")) {
        // If tensor is quantized, data type and buffer contents can be
        // different between float and quantized tensors. So do those tests
        // separately in the test body without checking them here.

    $constant_operand_indices are the indices of the inputs that are constant to the TPU program (e.g. weights in inference), the rest of the inputs are input tensors.
    constant_operand_indices is sorted in ascending order.
    $operands_with_static_shape are indices of operands that are tagged with a maximum static shape.

    }
    storage_type = mlir::cast<mlir::IntegerType>(raw_elem_type);
  }

  // TFlite uses narrow-range [u]int8 for constant buffers of quantized weights.
  // Since we don't know which ones are weights, we represent this optimization
  // as a change in the storage bounds for the type for all constants of this
  // type.
  const int bitwidth = storage_type.getIntOrFloatBitWidth();

			continue
		}

		entry, weight := split(entry, ';')

		// Scan the language.
		t, err := Parse(entry)
		if err != nil {
			id, ok := acceptFallback[entry]
			if !ok {
				return nil, nil, err
			}
			t = makeTag(language.Tag{LangID: id})
		}

		// Scan the optional weight.
		w := 1.0
		if weight != "" {
			weight = consume(weight, 'q')
			weight = consume(weight, '=')

						Port:   &networking.PortSelector{Number: 443},
						Subset: "prod",
					},
					Weight: 75,
				},
				{
					Destination: &networking.Destination{
						Host:   "example-canary.com",
						Port:   &networking.PortSelector{Number: 443},
						Subset: "canary",
					},
					Weight: 25,
				},
			},
		},
	}

	for _, tt := range cases {
		t.Run(tt.name, func(t *testing.T) {

  OpSet op_set_;

  Option<bool> enable_per_channel_quantization_{
      *this, "enable-per-channel-quantization", llvm::cl::init(false),
      llvm::cl::desc("Whether enable per-channel quantized weights.")};
};

// If the weight is applicable to dynamic range quantization, insert Quantize
// and Dequantize ops with per-tensor scale.
class PrepareDRQQuantizableOp : public OpRewritePattern<arith::ConstantOp> {
 public:

  SPARSE = 1,
  DENSE = 2,
}

table LSHProjectionOptions {
  type: LSHProjectionType;
}

table SVDFOptions {
  rank:int;
  fused_activation_function:ActivationFunctionType;
  // For weights-only quantization, use asymmetric quantization for non
  // constant inputs at evaluation time.
  asymmetric_quantize_inputs:bool;
}

// An implementation of TensorFlow RNNCell.
table RNNOptions {

  // NoFusing-LABEL: FuseMulWithFullyConnectedNoBias
  // NoFusing-DAG: %[[MWEIGHTS:.*]] = arith.constant dense<2.000000e+00> : tensor<512xf32>
  // NoFusing-DAG: %[[WEIGHTS:.*]] = arith.constant dense<3.000000e+00> : tensor<1024x512xf32>
  // NoFusing-DAG: %[[BIAS:.*]] = "tfl.no_value"() <{value}> : () -> none