}
		}
		pkgDotName := base.Ctxt.Pkgpath + "." + nameOptABI
		printssa = nameOptABI == ssaDump || // "(*Reader).Reset"
			pkgDotName == ssaDump || // "compress/gzip.(*Reader).Reset"
			strings.HasSuffix(pkgDotName, ssaDump) && strings.HasSuffix(pkgDotName, "/"+ssaDump) // "gzip.(*Reader).Reset"
	}

	var astBuf *bytes.Buffer
	if printssa {
		astBuf = &bytes.Buffer{}
		ir.FDumpList(astBuf, "buildssa-body", fn.Body)

		jType := retrieveListenerType(verifiedListeners[j])
		return iType < jType
	})

	printStr := "ADDRESSES\tPORT"
	if includeConfigType {
		printStr = "NAME\t" + printStr
	}
	if filter.Verbose {
		printStr += "\tMATCH\tDESTINATION"
	} else {
		printStr += "\tTYPE"
	}
	fmt.Fprintln(w, printStr)
	for _, l := range verifiedListeners {
		addresses := []string{retrieveListenerAddress(l)}

	if gp == nil || gp.writebuf == nil || gp.m.dying > 0 {
		writeErr(b)
		return
	}

	n := copy(gp.writebuf[len(gp.writebuf):cap(gp.writebuf)], b)
	gp.writebuf = gp.writebuf[:len(gp.writebuf)+n]
}

func printsp() {
	printstring(" ")
}

func printnl() {
	printstring("\n")
}

func printbool(v bool) {
	if v {
		printstring("true")
	} else {
		printstring("false")
	}
}

	}

	strippedAPIEndpoints := stripStandardPorts(apiEndpoints, globalMinioHost)

	// Prints credential, region and browser access.
	printServerCommonMsg(strippedAPIEndpoints)

	// Prints `mc` cli configuration message chooses
	// first endpoint as default.
	printCLIAccessMsg(strippedAPIEndpoints[0], "myminio")

	// Prints documentation message.
	printObjectAPIMsg()
}

// Returns true if input is IPv6

//
//   // Prints value using the type inferred by the compiler.  The difference
//   // from UniversalTersePrint() is that this function prints both the
//   // pointer and the NUL-terminated string for a (const or not) char pointer.
//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
//
//   // Prints the fields of a tuple tersely to a string vector, one

[!fuzz-instrumented] skip
[short] skip
env GOCACHE=$WORK/cache

# Test that fuzzing a target with a failure in f.Add prints the crash
# and doesn't write anything to testdata/fuzz
! go test -fuzz=FuzzWithAdd -run=FuzzWithAdd -fuzztime=1x
! stdout ^ok
! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
stdout FAIL

# Test that fuzzing a target with a success in f.Add and a fuzztime of only
# 1 does not produce a crash.

// limitations under the License.

package sdscompare

import (
	"encoding/json"
	"fmt"
	"io"
	"strings"
	"text/tabwriter"
)

// SDSWriter takes lists of SecretItem or SecretItemDiff and prints them through supplied output writer
type SDSWriter interface {
	PrintSecretItems([]SecretItem) error
	PrintDiffs([]SecretItemDiff) error
}

type Format int

const (
	JSON Format = iota
	TABULAR
)

	parserMode parser.Mode
)

func initParserMode() {
	if *allErrors {
		parserMode |= parser.AllErrors
	}
	if *printAST {
		sequential = true
	}
	if *printTrace {
		parserMode |= parser.Trace
		sequential = true
	}
	if *parseComments && (*printAST || *printTrace) {
		parserMode |= parser.ParseComments
	}
}

const usageString = `usage: gotype [flags] [path ...]

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

package main

func main() {
	var b1 []byte;
	s1 := string(b1);
	println(len(s1));  // prints 0

	b2 := ([]byte)(nil);
	s2 := string(b2);
	println(len(s2));  // prints 0

	s3 := string(([]byte)(nil));  // does not compile (literal substitution of b2)
	println(len(s3));
}

/*
bug149.go:14: cannot convert []uint8 constant to string

//
//   // Prints value using the type inferred by the compiler.  The difference
//   // from UniversalTersePrint() is that this function prints both the
//   // pointer and the NUL-terminated string for a (const or not) char pointer.
//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
//
//   // Prints the fields of a tuple tersely to a string vector, one