`tf.keras.mixed_precision.experimental.LossScaleOptimizer`, the weights
        of the `DynanmicLossScale` are copied into the `LossScaleOptimizer`
        instead of being reused. This means modifying the weights of the
        `DynamicLossScale` will no longer affect the weights of the
        LossScaleOptimizer, and vice versa.

            // input. Only int8 weight is supported for now.
            inputs.push_back(dq_op.getOperand());
            is_operand_or_result_modified = true;
          } else {
            // Otherwise, it's the case where the operand is activations or the
            // quantizing_op is non-supported/weight-only.
            inputs.push_back(operand);
          }
        } else {

	adscConn := s.Connect(nil, nil, watchEds)
	endpoints := adscConn.GetEndpoints()
	lbe, f := endpoints["outbound|80||weighted.static.svc.cluster.local"]
	if !f || len(lbe.Endpoints) == 0 {
		t.Fatalf("No lb endpoints for %v, %v", "outbound|80||weighted.static.svc.cluster.local", adscConn.EndpointsJSON())
	}
	expected := map[string]uint32{

        value: /get
    backendRefs:
      - name: httpbin
        port: 80
        weight: 2
      - name: httpbin-other
        port: 8080
        weight: 3
      - name: httpbin-zero
        port: 8080
        weight: 0
  - matches:
    - path:
        type: PathPrefix
        value: /weighted-100
    backendRefs:
    - filters:
      - requestHeaderModifier:
          add:

		helper: network2.NewConnectionHelper(name),
	}
}

func (lb *weightedConnections) AllWeightsEqual() bool {
	if len(lb.conns) == 0 {
		return true
	}

	weight := lb.conns[0].Weight
	for _, conn := range lb.conns {
		if conn.Weight != weight {
			return false
		}
	}
	return true
}

func (lb *weightedConnections) get(index int) *WeightedConnection {
	return lb.conns[index]
}

}

// Returns the quantized type for the
// input_type/min/max/storag_type_width/narrow_range.
// This is entry point to the Quant dialect and used for both quantizing
// activations and weights.
Type GetQuantizedType(Builder builder, const Type input_type,
                      const ArrayRef<double> min, const ArrayRef<double> max,
                      const int quant_dim, const int storage_type_width,

    name: default.http.0
    route:
    - destination:
        host: httpbin.default.svc.domain.suffix
        port:
          number: 80
      weight: 2
    - destination:
        host: httpbin-other.default.svc.domain.suffix
        port:
          number: 8080
      weight: 3
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  annotations:
    internal.istio.io/parents: TCPRoute/tcp.default

format which contains three 1D tensors.
  }];

  let arguments = (ins
    TF_Int32Tensor:$indices_or_row_splits,
    TF_Int32Tensor:$values,
    TF_Float32Tensor:$weights,

    ConfinedAttr<I64Attr, [IntMinValue<1>]>:$sample_count,
    StrAttr:$combiner
  );

  let results = (outs
    TF_Int32Tensor:$row_ids,
    TF_Int32Tensor:$col_ids,

// RUN: tf-quant-opt %s -split-input-file -quant-quantize-weights | FileCheck %s

module {
  func.func @not_quantize_const() -> (tensor<2x1024xf32>) {
    // Nothing happens if not connected wiht quantizable op.
    %cst_0 = "tf.Const"() {value = dense<2.000000e+00> : tensor<2x1024xf32>} : () -> tensor<2x1024xf32>
    func.return %cst_0: tensor<2x1024xf32>
  }

// CHECK-LABEL: func @not_quantize_const

  }];

  let description = [{
Outputs a vector with length `size` and the same dtype as `weights`. If
`weights` are empty, then index `i` stores the number of times the value `i` is
counted in `arr`. If `weights` are non-empty, then index `i` stores the sum of
the value in `weights` at each index where the corresponding value in `arr` is
`i`.

Values in `arr` outside of the range [0, size) are ignored.