if forwardTo == nil {
		return nil, nil, nil
	}

	weights := []int{}
	action := []k8s.BackendRef{}
	for _, w := range forwardTo {
		wt := int(ptr.OrDefault(w.Weight, 1))
		if wt == 0 {
			continue
		}
		action = append(action, w)
		weights = append(weights, wt)
	}
	if len(weights) == 1 {
		weights = []int{0}
	}

	var invalidBackendErr *ConfigError

    (binaryOp (TFL_TransposeConvOp:$output $output_shape, $weights, $input,
                (Arith_ConstantOp FloatElementsAttr:$bias), $padding,
                $stride_h, $stride_w, TFL_AF_None),
              (Arith_ConstantOp FloatElementsAttr:$value), $act_fn),
    (TFL_TransposeConvOp $output_shape, $weights, $input,
      (binaryOp (Arith_ConstantOp $bias),
         (Arith_ConstantOp $value), TFL_AF_None),

                                    enable_per_channel_quantization_));

  // Apply activation-weight quantization.
  if (quantization_method_ ==
      tensorflow::quantization::QuantizationMethod::METHOD_STATIC_RANGE_INT8) {
    // For XLA case, weight quantization will be applied for the remaining f32
    // weights even in SRQ.
    pm.addNestedPass<func::FuncOp>(

		// encountered, let the individual Score weight take precedence.
		if _, ok := f.scorePluginWeight[e.Name]; ok {
			continue
		}
		// a weight of zero is not permitted, plugins can be disabled explicitly
		// when configured.
		f.scorePluginWeight[e.Name] = int(e.Weight)
		if f.scorePluginWeight[e.Name] == 0 {
			f.scorePluginWeight[e.Name] = 1
		}

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,

			Address: netutils.ParseIPSloppy(ip),
			Port:    uint16(portNum),
			Weight:  1,
		}

		if curEndpoints.Has(ep) {
			// if we are syncing for the first time, loop through all current destinations and
			// reset their weight.
			if proxier.initialSync {
				for _, dest := range curDests {
					if dest.Weight != newDest.Weight {
						err = proxier.ipvs.UpdateRealServer(appliedVirtualServer, newDest)

}

// -----

// Tests that basic convolution is properly quantized. In this example, the
// convolution is always per-tensor quantized (even if
// enable-per-channel-quantized-weights=true), according to
// `_quantization_method`.

// CHECK-LABEL: quantize_conv_fn_per_tensor
func.func @quantize_conv_fn_per_tensor(%arg0: tensor<1x3x4x3xf32>) -> tensor<1x3x4x2xf32> {

						Destination: &networking.Destination{
							Host:   "c-weighted.extsvc.com",
							Subset: "v2",
						},
						Weight: 100,
					},
				},
			},
			{
				Route: []*networking.HTTPRouteDestination{
					{
						Destination: &networking.Destination{
							Host:   "c-weighted.extsvc.com",
							Subset: "v1",
						},
						Weight: 100,
					},
				},
			},
		},
	},

	} else {
		weighted := make([]*route.WeightedCluster_ClusterWeight, 0)
		for _, dst := range in.Route {
			if dst.Weight == 0 {
				// Ignore 0 weighted clusters if there are other clusters in the route.
				continue
			}
			destinationweight, hostname := processWeightedDestination(dst, serviceRegistry, listenerPort, hashByDestination, action)
			weighted = append(weighted, destinationweight)

	border-width: 1px 0 0;
	clear: both;
	margin: 1.25em 0 1.1875em;
	height: 0;
}

/* Helpful Typography Defaults */
em,
i {
	font-style: italic;
	line-height: inherit;
}

strong,
b {
	font-weight: bold;
	line-height: inherit;
}

small {
	font-size: 60%;
	line-height: inherit;
}

code {
	font-family: "Droid Sans Mono", "DejaVu Sans Mono", monospace;