t.Log("skipping gold test")
				break
			}
			t.Fatalf("building hello binary: %v", err)
		}
		id, err = buildid.ReadFile(tg.path("hello3.exe"))
		if err != nil {
			t.Fatalf("reading build ID from hello binary (linkmode=external -extldflags=-fuse-ld=gold): %v", err)
		}
		if id != buildID {
			t.Fatalf("buildID in hello binary = %q, want %q (linkmode=external -extldflags=-fuse-ld=gold)", id, buildID)
		}
	}

				if !isPowerOf2(words) {
					t.Errorf("read %d 8-byte words, but each write is a power-of-2 number of words", words)
					return chunk, nil
				}

				u := binary.LittleEndian.Uint64(data)
				for i := 1; i < words; i++ {
					next := binary.LittleEndian.Uint64(data[i*8:])
					if next != u+1 {
						t.Errorf("wrote sequential integers, but read integer out of sequence at offset %d", i)
						return chunk, nil
					}

	}
	pos := len(e.stringTable)
	e.strings[s] = pos
	e.Int(pos)
	e.stringTable = binary.AppendUvarint(e.stringTable, uint64(len(s)))
	e.stringTable = append(e.stringTable, s...)
}

func (e *encoder) Bool(b bool) {
	if b {
		e.Uint32(1)
	} else {
		e.Uint32(0)
	}
}

func (e *encoder) Uint32(n uint32) {
	e.b = binary.LittleEndian.AppendUint32(e.b, n)
}

	"cmd/go/internal/base"
	"cmd/go/internal/gover"
)

var CmdVersion = &base.Command{
	UsageLine: "go version [-m] [-v] [file ...]",
	Short:     "print Go version",
	Long: `Version prints the build information for Go binary files.

Go version reports the Go version used to build each of the named files.

If no files are named on the command line, go version prints its own
version information.

// encoding. Unlike octal encoding, base-256 encoding does not require that the
// string ends with a NUL character. Thus, all n bytes are available for output.
//
// If operating in binary mode, this assumes strict GNU binary mode; which means
// that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
// equivalent to the sign bit in two's complement form.
func fitsInBase256(n int, x int64) bool {

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

//go:build cmd_go_bootstrap

// This code is compiled only into the bootstrap 'go' binary.
// These stubs avoid importing packages with large dependency
// trees that potentially require C linking,
// like the use of "net/http" in vcs.go.

package web

import (
	"errors"
	urlpkg "net/url"
)

// that serves the (non-HTTP) 'svn' protocol. The test binary can retrieve the
// URL for that port by sending an HTTP request with the query parameter
// "vcwebsvn=1".
//
// We take this approach because the 'svn' protocol is implemented by a
// lightweight 'svnserve' binary that is usually packaged along with the 'svn'
// client binary, whereas only known implementation of the Subversion HTTP

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Buildid displays or updates the build ID stored in a Go package or binary.

Usage:

	go tool buildid [-w] file

By default, buildid prints the build ID found in the named file.
If the -w option is given, buildid rewrites the build ID found in

// We don't keep a parse tree, just the value of the expression.
type val bool

// exprToken describes a single token in the input.
// Prefix operators define a prefix func that parses the
// upcoming value. Binary operators define an infix func
// that combines two values according to the operator.
// In that case, the parsing loop parses the two values.
type exprToken struct {
	tok    string
	prec   int

(package-scope instrumentation is enabled via "-pkgcfg" option).

When generated instrumented code, the cover tool computes approximate
basic block information by studying the source. It is thus more
portable than binary-rewriting coverage tools, but also a little less
capable. For instance, it does not probe inside && and || expressions,
and can be mildly confused by single statements with multiple function
literals.