}

// -----

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

}

// The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
type WeightedPodAffinityTerm struct {
	// weight associated with matching the corresponding podAffinityTerm,
	// in the range 1-100.
	Weight int32 `json:"weight" protobuf:"varint,1,opt,name=weight"`

          },
          "weight": {
            "default": 0,
            "description": "Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.",
            "format": "int32",
            "type": "integer"
          }
        },
        "required": [
          "weight",
          "preference"
        ],

		if route.Weight > 0 {
			clusterName := istioroute.GetDestinationCluster(route.Destination, service, port.Port)
			clusterSpecifier.WeightedClusters.Clusters = append(clusterSpecifier.WeightedClusters.Clusters, &tcp.TcpProxy_WeightedCluster_ClusterWeight{
				Name:   clusterName,
				Weight: uint32(route.Weight),
			})
		}
	}

// (if any) and will cause a nonzero final exit code.
func (s *sequencer) Add(weight int64, f func(*reporter) error) {
	if weight < 0 || weight > s.maxWeight {
		weight = s.maxWeight
	}
	if err := s.sem.Acquire(context.TODO(), weight); err != nil {
		// Change the task from "execute f" to "report err".
		weight = 0
		f = func(*reporter) error { return err }
	}

	r := &reporter{prev: s.prev}

		if len(f) < 6 {
			continue
		}
		port, _, portOk := dtoi(f[4])
		priority, _, priorityOk := dtoi(f[3])
		weight, _, weightOk := dtoi(f[2])
		if !(portOk && priorityOk && weightOk) {
			continue
		}
		addrs = append(addrs, &SRV{absDomainName(f[5]), uint16(port), uint16(priority), uint16(weight)})
		cname = absDomainName(f[0])
	}
	byPriorityWeight(addrs).sort()
	return
}

						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)

			{Name: names.TaintToleration, Weight: 3},
			{Name: names.NodeAffinity, Weight: 2},
			{Name: names.NodePorts},
			{Name: names.NodeResourcesFit, Weight: 1},
			{Name: names.VolumeRestrictions},
			{Name: names.NodeVolumeLimits},
			{Name: names.VolumeBinding},
			{Name: names.VolumeZone},
			{Name: names.PodTopologySpread, Weight: 2},
			{Name: names.InterPodAffinity, Weight: 2},
			{Name: names.DefaultPreemption},

						{Name: names.PodTopologySpread, Weight: ptr.To[int32](2)},
						{Name: names.InterPodAffinity, Weight: ptr.To[int32](2)},
						{Name: names.DefaultPreemption},
						{Name: names.NodeResourcesBalancedAllocation, Weight: ptr.To[int32](1)},
						{Name: names.ImageLocality, Weight: ptr.To[int32](1)},
						{Name: names.DefaultBinder},
					},
				},
			},
		},
		{
			name: "Feature gate DynamicResourceAllocation enabled",