if err != nil {
		return result, fmt.Errorf("failed to create temp dir: %v", err)
	}

	fs := pflag.NewFlagSet("test", pflag.PanicOnError)

	opts := options.NewOptions()
	nfs := opts.Flags
	for _, f := range nfs.FlagSets {
		fs.AddFlagSet(f)
	}
	fs.Parse(customFlags)

	if opts.SecureServing.BindPort != 0 {
		opts.SecureServing.Listener, opts.SecureServing.BindPort, err = createListenerOnFreePort()

	// Short is the short description shown in the 'go help' output.
	Short string

	// Long is the long message shown in the 'go help <this-command>' output.
	Long string

	// Flag is a set of flags specific to this command.
	Flag flag.FlagSet

	// CustomFlags indicates that the command will do its own
	// flag parsing.
	CustomFlags bool

	// Commands lists the available commands and help topics.

        } else if (event.getCategory().equals(ProgressStartEvent.TASK_CATEGORY)) {
            flags |= CATEGORY_IS_TASK;
        } else {
            flags |= CATEGORY_NAME;
        }

        encoder.writeSmallInt(flags);

        encoder.writeSmallLong(event.getProgressOperationId().getId());
        if (parentProgressOperationId != null) {

			}
			set(val)
		}
	}

	if regabiAlwaysOn {
		flags.RegabiWrappers = true
		flags.RegabiArgs = true
	}
	// regabi is only supported on amd64, arm64, loong64, riscv64, ppc64 and ppc64le.
	if !regabiSupported {
		flags.RegabiWrappers = false
		flags.RegabiArgs = false
	}
	// Check regabi dependencies.
	if flags.RegabiArgs && !flags.RegabiWrappers {

[short] skip
[!cgo] skip

env GOCACHE=$WORK/gocache  # Looking for compile flags, so need a clean cache.
go build -x -n main.go
stderr '"-I[^"]+c flags"' # find quoted c flags
! stderr '"-I[^"]+c flags".*"-I[^"]+c flags"' # don't find too many quoted c flags per line
stderr '"-L[^"]+ld flags"' # find quoted ld flags
! stderr '"-L[^"]+c flags".*"-L[^"]+c flags"' # don't find too many quoted ld flags per line

-- main.go --
package main

        flag.systemPropertyName >> "prop"

        expect:
        !flags.isEnabled(flag)
        !flags.isEnabledWithApi(flag)
    }

    def "can explicitly enable flag"() {
        def flag = Stub(FeatureFlag)
        flag.systemPropertyName >> null
        flags.enable(flag)

        expect:
        flags.isEnabled(flag)
        flags.isEnabledWithApi(flag)
    }

	a := x - y  // generate flags
	if z == 0 { // create basic block that does not clobber flags
		return a
	}
	if a > 0 { // use flags in different basic block
		return y
	}
	return x
}

func f3(x, y float32, z int) float32 {
	a := x + y  // generate flags
	if z == 0 { // create basic block that does not clobber flags
		return a
	}
	if a > 0 { // use flags in different basic block
		return y
	}
	return x
}

	{
		args: []string{"net/...=-S", "-m"},
		pkgs: []ppfTestPackage{
			{path: "net", cmdline: true, flags: []string{"-m"}},
			{path: "math", cmdline: true, flags: []string{"-m"}},
			{path: "net", cmdline: false, flags: []string{"-S"}},
			{path: "net/http", flags: []string{"-S"}},
			{path: "math", flags: []string{}},
		},
	},

	// relative path patterns

	if err != nil {
		return TestServer{}, err
	}
	all, disabled, aliases := app.KnownControllers(), app.ControllersDisabledByDefault(), app.ControllerAliases()
	namedFlagSets := s.Flags(all, disabled, aliases)
	for _, f := range namedFlagSets.FlagSets {
		fs.AddFlagSet(f)
	}
	fs.Parse(customFlags)

	if s.SecureServing.BindPort != 0 {
		s.SecureServing.Listener, s.SecureServing.BindPort, err = createListenerOnFreePort()

func (f *PerPackageFlag) Present() bool {
	return f.present
}

// For returns the flags to use for the given package.
func (f *PerPackageFlag) For(p *Package) []string {
	flags := []string{}
	for _, v := range f.values {
		if v.match(p) {
			flags = v.flags
		}
	}
	return flags