rewrite the go.mod file. The only time this flag is needed is if no other
flags are specified, as in 'go work edit -fmt'.

The -godebug=key=value flag adds a godebug key=value line,
replacing any existing godebug lines with the given key.

The -dropgodebug=key flag drops any existing godebug lines
with the given key.

The -use=path and -dropuse=path flags
add and drop a use directive from the go.work file's set of module directories.

//
// The output is a sequence of stanzas, one for each package or module
// name on the command line, separated by blank lines. Each stanza begins
// with a comment line "# package" or "# module" giving the target
// package or module. Subsequent lines give a path through the import
// graph, one package per line. If the package or module is not
// referenced from the main module, the stanza will display a single

	b, err = cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("go tool cover -func failed: %v", err)
	}

	lines := strings.Split(string(b), "\n")
	nfound := 0
	bad := false
	for _, line := range lines {
		f := strings.Fields(line)
		if len(f) == 0 {
			continue
		}
		// We're only interested in the specific function "large" for

    private static final GsonBuilder GSON_BUILDER = createGsonBuilder();

    public static List<? extends Problem> parseMessageList(String lines) {
        Gson gson = GSON_BUILDER.create();
        Type type = new TypeToken<List<DefaultProblem>>() {}.getType();
        return gson.<List<DefaultProblem>>fromJson(lines, type);
    }

    public static GsonBuilder createGsonBuilder() {
        GsonBuilder gsonBuilder = new GsonBuilder();

	if hasEmbed {
		var line []byte
		for first := true; r.findEmbed(first); first = false {
			line = line[:0]
			pos := r.pos
			for {
				c := r.readByteNoBuf()
				if c == '\n' || r.err != nil || r.eof {
					break
				}
				line = append(line, c)
			}
			// Add args if line is well-formed.
			// Ignore badly-formed lines - the compiler will report them when it finds them,

	if h.closed {
		return 0, errors.New("encoding/hex: dumper closed")
	}

	// Output lines look like:
	// 00000010  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
	// ^ offset                          ^ extra space              ^ ASCII of line.
	for i := range data {
		if h.used == 0 {
			// At the beginning of a line we print the current
			// offset in hex.
			h.buf[0] = byte(h.n >> 24)

			echo.ResponseHeaderField.WriteKeyValueForRequest(outBuffer, requestID, key, value)
		}
	}

	// Write the lines of the body to the output buffer.
	for _, line := range strings.Split(string(data), "\n") {
		if line != "" {
			echo.WriteBodyLine(outBuffer, requestID, line)
		}
	}
	return nil
}

func (c *httpProtocol) Close() error {
	return nil

	_, _, err := c.cmd(221, "QUIT")
	if err != nil {
		return err
	}
	return c.Text.Close()
}

// validateLine checks to see if a line has CR or LF as per RFC 5321.
func validateLine(line string) error {
	if strings.ContainsAny(line, "\n\r") {
		return errors.New("smtp: A line must not contain CR or LF")
	}
	return nil

            org.gradle.util.internal.LimitedDescription description = new org.gradle.util.internal.LimitedDescription(maxLines);
            String line = reader.readLine();
            while (line != null) {
                description.append(line);
                line = reader.readLine();
            }
            return description.toString();
        } catch (Exception e) {

                    buffer = new char[16 * 1024];
                }
                int nread;
                try {
                    // Read input as text rather than bytes, so that readAndForwardText() below can also read lines of text
                    nread = reader.read(buffer);
                } catch (IOException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
                if (nread < 0) {