{"(*Int).Rem", Method, 0},
		{"(*Int).Rsh", Method, 0},
		{"(*Int).Scan", Method, 0},
		{"(*Int).Set", Method, 0},
		{"(*Int).SetBit", Method, 0},
		{"(*Int).SetBits", Method, 0},
		{"(*Int).SetBytes", Method, 0},
		{"(*Int).SetInt64", Method, 0},
		{"(*Int).SetString", Method, 0},
		{"(*Int).SetUint64", Method, 1},
		{"(*Int).Sign", Method, 0},
		{"(*Int).Sqrt", Method, 8},

	svcKey := service.Key()
	for port, inst := range instances {
		if _, exists := ps.ServiceIndex.instancesByPort[svcKey]; !exists {
			ps.ServiceIndex.instancesByPort[svcKey] = make(map[int][]*IstioEndpoint)
		}
		ps.ServiceIndex.instancesByPort[svcKey][port] = append(ps.ServiceIndex.instancesByPort[svcKey][port], inst...)
	}
}

type xcoffStringTable struct {
	strings    []string
	stringsLen int
}

// size returns size of string table t.
func (t *xcoffStringTable) size() int {
	// string table starts with 4-byte length at the beginning
	return t.stringsLen + 4
}

// add adds string str to string table t.
func (t *xcoffStringTable) add(str string) int {
	off := t.size()
	t.strings = append(t.strings, str)

must not already exist.

Init accepts one optional argument, the module path for the new module. If the
module path argument is omitted, init will attempt to infer the module path
using import comments in .go files, vendoring tool configuration files (like
Gopkg.lock), and the current directory (if in GOPATH).

See https://golang.org/ref/mod#go-mod-init for more about 'go mod init'.
`,
	Run: runInit,
}

func init() {

// initialized when the provided function returns nil.

// Init represents the structure.
type Init struct {
	done uint32
	m    sync.Mutex
}

// Do is similar to sync.Once.Do - makes one successful
// call to the function. ie, it invokes the function
// if it is not successful yet.
func (l *Init) Do(f func() error) error {
	if atomic.LoadUint32(&l.done) == 0 {
		return l.do(f)
	}

// calling Init and Enabled, the main package can call this function.
func WillBeEnabled() bool {
	if modRoots != nil || cfg.ModulesEnabled {
		// Already enabled.
		return true
	}
	if initialized {
		// Initialized, not enabled.
		return false
	}

	// Keep in sync with Init. Init does extra validation and prints warnings or
	// exits, so it can't call this function directly.

// license that can be found in the LICENSE file.

// Verify that erroneous use of init is detected.
// Does not compile.

package main

func init() {
}

func main() {
	init()         // ERROR "undefined.*init"
	runtime.init() // ERROR "undefined.*runtime\.init|reference to undefined name|undefined: runtime"
	var _ = init   // ERROR "undefined.*init"

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package init

import "os"

func init() {
	// All MinIO operations must be under UTC.
	os.Setenv("TZ", "UTC")

// go work init

package workcmd

import (
	"context"
	"path/filepath"

	"cmd/go/internal/base"
	"cmd/go/internal/fsys"
	"cmd/go/internal/gover"
	"cmd/go/internal/modload"

	"golang.org/x/mod/modfile"
)

var cmdInit = &base.Command{
	UsageLine: "go work init [moddirs]",
	Short:     "initialize workspace file",
	Long: `Init initializes and writes a new go.work file in the

	skipCRIDetect           bool
}

const (
	// CoreDNSPhase is the name of CoreDNS subphase in "kubeadm init"
	coreDNSPhase = "addon/coredns"

	// KubeProxyPhase is the name of kube-proxy subphase during "kubeadm init"
	kubeProxyPhase = "addon/kube-proxy"

	// AddonPhase is the name of addon phase during "kubeadm init"
	addonPhase = "addon"
)

// compile-time assert that the local data object satisfies the phases data interface.