return []string{}
	}

	c.muTree.Lock()
	defer c.muTree.Unlock()
	serviceCIDRs := []string{}
	// walk the tree to get all the ServiceCIDRs that contain this IP address
	prefixes := c.tree.GetHostIPPrefixMatches(address)
	for _, v := range prefixes {
		serviceCIDRs = append(serviceCIDRs, v.UnsortedList()...)
	}

	return serviceCIDRs
}

func (c *Controller) worker(ctx context.Context) {

		name    string
		cidrs   []*networkingapiv1alpha1.ServiceCIDR
		actions [][]string // verb and resource
	}{
		{
			name:    "no existing service CIDRs",
			actions: [][]string{{"create", "servicecidrs"}, {"patch", "servicecidrs"}},
		},
		{
			name: "existing default service CIDR update Ready condition",
			cidrs: []*networkingapiv1alpha1.ServiceCIDR{
				{
					ObjectMeta: metav1.ObjectMeta{

		}}
}
func startServiceCIDRsController(ctx context.Context, controllerContext ControllerContext, controllerName string) (controller.Interface, bool, error) {
	go servicecidrs.NewController(
		ctx,
		controllerContext.InformerFactory.Networking().V1alpha1().ServiceCIDRs(),
		controllerContext.InformerFactory.Networking().V1alpha1().IPAddresses(),
		controllerContext.ClientBuilder.ClientOrDie("service-cidrs-controller"),
	).Run(ctx, 5)

			actions:    [][]string{{"patch", "servicecidrs", ""}, {"patch", "servicecidrs", "status"}},
		},
		{
			name: "service CIDR must have finalizer",
			cidrs: []*networkingapiv1alpha1.ServiceCIDR{
				makeServiceCIDR("no-finalizer", "192.168.0.0/24", "2001:db2::/64"),
			},
			cidrSynced: "no-finalizer",
			actions:    [][]string{{"patch", "servicecidrs", ""}, {"patch", "servicecidrs", "status"}},
		},
		{

        "delete",
        "deletecollection",
        "get",
        "list",
        "patch",
        "update",
        "watch"
      ]
    },
    {
      "kind": "ServiceCIDR",
      "name": "servicecidrs",
      "namespaced": false,
      "singularName": "servicecidr",
      "storageVersionHash": "3cDF5hqTkLY=",
      "verbs": [
        "create",
        "delete",
        "deletecollection",
        "get",

	serviceCIDRInformer := informerFactory.Networking().V1alpha1().ServiceCIDRs()
	serviceCIDRStore := serviceCIDRInformer.Informer().GetIndexer()
	serviceCIDRInformer.Informer().HasSynced()
	ipInformer := informerFactory.Networking().V1alpha1().IPAddresses()
	ipStore := ipInformer.Informer().GetIndexer()

	client.PrependReactor("create", "servicecidrs", k8stesting.ReactionFunc(func(action k8stesting.Action) (bool, runtime.Object, error) {

		ipAddressStorage, err := ipaddressstore.NewREST(restOptionsGetter)
		if err != nil {
			return storage, err
		}
		storage[resource] = ipAddressStorage
	}

	// servicecidrs
	if resource := "servicecidrs"; apiResourceConfigSource.ResourceEnabled(networkingapiv1alpha1.SchemeGroupVersion.WithResource(resource)) {
		serviceCIDRStorage, serviceCIDRStatusStorage, err := servicecidrstore.NewREST(restOptionsGetter)

		ObjectMeta: metav1.ObjectMeta{
			Name: DefaultServiceCIDRName,
		},
		Spec: networkingapiv1alpha1.ServiceCIDRSpec{
			CIDRs: c.cidrs,
		},
	}
	serviceCIDR, err = c.client.NetworkingV1alpha1().ServiceCIDRs().Create(context.Background(), serviceCIDR, metav1.CreateOptions{})
	if err != nil && !apierrors.IsAlreadyExists(err) {

	defer func() {
		klog.V(2).Infof("Finished sync for CIDRs took %v", time.Since(now))
	}()

	serviceCIDRs, err := c.serviceCIDRLister.List(labels.Everything())
	if err != nil {
		return err
	}

	cidrsSet := sets.New[string]()
	cidrReady := map[string]bool{}
	for _, serviceCIDR := range serviceCIDRs {
		ready := true
		if !isReady(serviceCIDR) || !serviceCIDR.DeletionTimestamp.IsZero() {
			ready = false

		NewFunc:                   func() runtime.Object { return &networking.ServiceCIDR{} },
		NewListFunc:               func() runtime.Object { return &networking.ServiceCIDRList{} },
		DefaultQualifiedResource:  networking.Resource("servicecidrs"),
		SingularQualifiedResource: networking.Resource("servicecidr"),

		CreateStrategy:      servicecidr.Strategy,
		UpdateStrategy:      servicecidr.Strategy,
		DeleteStrategy:      servicecidr.Strategy,