// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Generic sort function, tested with two different pointer types.

package mysort

import (
	"fmt"
)

type LessConstraint[T any] interface {
	Less(T) bool
}

//go:noinline
func Sort[T LessConstraint[T]](x []T) {
	n := len(x)
	for i := 1; i < n; i++ {

// make sure only one instantiation is created.

import (
	"fmt"

	"cmd/compile/internal/test/testdata/mysort"
)

type MyString struct {
	string
}

func (a *MyString) Less(b *MyString) bool {
	return a.string < b.string
}

func main() {
	mysort.F()

	sl1 := []*mysort.MyInt{{7}, {1}, {4}, {6}}
	mysort.Sort(sl1)
	fmt.Printf("%v %v %v %v\n", sl1[0], sl1[1], sl1[2], sl1[3])

		SecretTTL:                      secretTTLEnv,
		FileDebounceDuration:           fileDebounceDuration,
		SecretRotationGracePeriodRatio: secretRotationGracePeriodRatioEnv,
		STSPort:                        stsPort,
		CertSigner:                     certSigner.Get(),
		CARootPath:                     cafile.CACertFilePath,
		CertChainFilePath:              security.DefaultCertChainFilePath,

		opts = append(opts, option.GCPProjectNumber(projectNumber))
	}

	if cfg.Metadata.StsPort != "" {
		stsPort, err := strconv.Atoi(cfg.Metadata.StsPort)
		if err == nil && stsPort > 0 {
			opts = append(opts,
				option.STSEnabled(true),
				option.STSPort(stsPort))
			md := cfg.Metadata.PlatformMetadata
			if projectID, found := md[platform.GCPProject]; found {

	re(`-pthread`),
	re(`-?-std=([^@\-].*)`),
	re(`-?-stdlib=([^@\-].*)`),
	re(`--sysroot=([^@\-].*)`),
	re(`-w`),
	re(`-x([^@\-].*)`),
	re(`-v`),
}

var validCompilerFlagsWithNextArg = []string{
	"-arch",
	"-D",
	"-U",
	"-I",
	"-F",
	"-framework",
	"-include",
	"-isysroot",
	"-isystem",
	"--sysroot",
	"-target",
	"-x",
}

var invalidLinkerFlags = []*lazyregexp.Regexp{

            System.out.println("test" + i);
        }
        final long sysout = System.currentTimeMillis() - start;
        start = System.currentTimeMillis();
        for (int i = 0; i < num; i++) {
            logger.fatal("test" + i);
        }
        final long logger = System.currentTimeMillis() - start;
        System.out.println("System.out:" + sysout);
        System.out.println("logger:" + logger);
    }

    /**

package options

import (
	istioagent "istio.io/istio/pkg/istio-agent"
)

// ProxyArgs provides all of the configuration parameters for the Pilot proxy.
type ProxyArgs struct {
	istioagent.Proxy

	StsPort            int
	TokenManagerPlugin string

	MeshConfigFile string

	// proxy config flags (named identically)
	ServiceCluster         string
	ProxyLogLevel          string
	ProxyComponentLogLevel string

			"PROXY_CONFIG environment variable or proxy.istio.io/config annotation.")
	proxyCmd.PersistentFlags().IntVar(&proxyArgs.StsPort, "stsPort", 0,
		"HTTP Port on which to serve Security Token Service (STS). If zero, STS service will not be provided.")
	proxyCmd.PersistentFlags().StringVar(&proxyArgs.TokenManagerPlugin, "tokenManagerPlugin", "",

    rm -rf "libstdc++6_4.8.1-10ubuntu8_arm64.deb" "libstdc++6_4.8.1-10ubuntu8_arm64"

mkdir -p "${TARGET}-src"
cd "${TARGET}-src"

# Build a devtoolset cross-compiler based on our glibc 2.12/glibc 2.17 sysroot setup.
case "${VERSION}" in
devtoolset-9)
  wget --retry-connrefused --waitretry=1 --read-timeout=20 --timeout=15 --tries=5 "https://vault.centos.org/centos/7/sclo/Source/rh/devtoolset-9-gcc-9.3.1-2.2.el7.src.rpm"

// Sort is used for multiple pointer types across two packages.
func TestInst(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveGoRun(t)

	// Build ptrsort.go, which uses package mysort.
	var output []byte
	var err error
	filename := "ptrsort.go"
	exename := "ptrsort"
	outname := "ptrsort.out"
	gotool := testenv.GoToolPath(t)
	dest := filepath.Join(t.TempDir(), exename)