"FRINTMS",
	"FRINTND",
	"FRINTNS",
	"FRINTPD",
	"FRINTPS",
	"FRINTXD",
	"FRINTXS",
	"FRINTZD",
	"FRINTZS",
	"FSQRTD",
	"FSQRTS",
	"FSTPD",
	"FSTPQ",
	"FSTPS",
	"FSUBD",
	"FSUBS",
	"HINT",
	"HLT",
	"HVC",
	"IC",
	"ISB",
	"LDADDAB",
	"LDADDAD",
	"LDADDAH",
	"LDADDALB",
	"LDADDALD",
	"LDADDALH",
	"LDADDALW",
	"LDADDAW",
	"LDADDB",
	"LDADDD",

			if wg != nil {
				wg.Done()
			}
			// Clean up and de-register the subscriber
			ps.Lock()
			defer ps.Unlock()
			var remainTypes Mask
			for i, s := range ps.subs {
				if s == sub {
					ps.subs = append(ps.subs[:i], ps.subs[i+1:]...)
				} else {
					remainTypes.Merge(s.types)
				}
			}
			atomic.StoreUint64(&ps.types, uint64(remainTypes))
			atomic.AddInt32(&ps.numSubscribers, -1)
		}()

	eventtype := s.u.eventtype()
	switch mode {
	case 'r':
		*eventtype = eventtypeFdRead
		ridx = len(subs)
	case 'w':
		*eventtype = eventtypeFdWrite
		widx = len(subs)
	}

	if len(subs) == disarmed {
		throw("overflow")
	}

	pd.user = uint32(ridx)<<16 | uint32(widx)

	subs = append(subs, s)
	evts = append(evts, event{})

	unlock(&mtx)
}

	var bucketURL, urlSuffix string
	subs := kubeBucketPrefixes.FindAllStringSubmatch(version, 1)
	if len(subs) != 1 || len(subs[0]) != 4 {
		return "", "", errors.Errorf("invalid version %q", version)
	}

	switch {
	case strings.HasPrefix(subs[0][2], "ci"):
		// Just use whichever the user specified
		urlSuffix = subs[0][2]
		bucketURL = kubeCIBucketURL
	default:
		urlSuffix = "release"

	}

	cleanOutput := strings.TrimSpace(string(out))
	subs := kubeletVersionRegex.FindAllStringSubmatch(cleanOutput, -1)
	if len(subs) != 1 || len(subs[0]) < 2 {
		return nil, errors.Errorf("Unable to parse output from Kubelet: %q", cleanOutput)
	}
	return version.ParseSemantic(subs[0][1])

			addresses = updatedAddresses.IntersectInPlace(subs)
		}
	}

	if !w.Wildcard {
		// We only need this for on-demand. This allows us to subscribe the client to resources they
		// didn't explicitly request.
		// For wildcard, they subscribe to everything already.
		additional := e.Server.Env.ServiceDiscovery.AdditionalPodSubscriptions(proxy, addresses, subs)
		if addresses == nil {
			addresses = sets.New[string]()
		}

	b.StartTimer()
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		subs := re.FindSubmatch(s)
		if string(subs[0]) != wantSubs {
			b.Fatalf("FindSubmatch(%q)[0] = %q; want %q", s, subs[0], wantSubs)
		}
		if string(subs[1]) != "aab" {
			b.Fatalf("FindSubmatch(%q)[1] = %q; want %q", s, subs[1], "aab")
		}
	}
}

func BenchmarkFindStringSubmatch(b *testing.B) {
	b.StopTimer()

This is identifiable by the presence of the `gradlew` or `gradlew.bat` files in the root of the project:

[listing,subs=+macros]
----
.   // <1>
├── gradle
│   └── wrapper // <2>
├── gradlew         // <3>
├── gradlew.bat     // <3>
└── ⋮
----
<1> Project root directory.

[listing,subs=+attributes]
----
$ gradle wrapper --gradle-version {gradleVersion} --distribution-type all
include::{snippetsPath}/wrapper/simple/tests/wrapperCommandLine.out[]
----

As a result, you can find the desired information (the generated distribution URL) in the Wrapper properties file:

[source,properties,subs=+attributes]
----

		} else {
			// Merge adjacent qualifiers.  This case
			// happens with multi-dimensional array types.
			if qsub, ok := ret.(*TypeWithQualifiers); ok {
				q = mergeQualifiers(q, qsub.Qualifiers)
				ret = qsub.Base
			}
			ret = &TypeWithQualifiers{Base: ret, Qualifiers: q}
		}
		st.subs.add(ret)
	}

	return ret
}

// demangleCastTemplateArgs is for a rather hideous parse.  When we