type: integer
                          weight:
                            default: 1
                            description: |-
                              Weight specifies the proportion of requests forwarded to the referenced
                              backend. This is computed as weight/(sum of all weights in this

                        if a sidecar is present in the workload.
                      type: string
                    weight:
                      description: The load balancing weight associated with the endpoint.
                      type: integer
                  type: object
                type: array
              exportTo:

spec:
  hosts:
    - {{.Host0}}
  http:
    - route:
        - destination:
            host: {{.Host0}}
          weight: {{.Weight0}}
        - destination:
            host: {{.Host1}}
          weight: {{.Weight1}}
        - destination:
            host: {{.Host2}}

        `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]
}

          host: c-weighted.extsvc.com
          subset: v1
        weight: 75
      - destination:
          host: c-weighted.extsvc.com
          subset: v2

}

// 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,