"a\tb\t\td\n" + // hard tabs - do not discard column
			"a\tb\t\td\te\n" +
			"a\n" +
			"a\tb\tc\td\n" +
			"a\tb\tc\td\te\n",

		"a\tb\t\td\n" +
			"a\tb\t\td\te\n" +
			"a\n" +
			"a\tb\tc\td\n" +
			"a\tb\tc\td\te\n",
	},

	{
		"16c debug",
		100, 100, 0, '\t', DiscardEmptyColumns | Debug,
		"a\tb\t\td\n" + // hard tabs - do not discard column
			"a\tb\t\td\te\n" +
			"a\n" +

import (
	"io"
	"os"
)

func g[T any](...T) {}

// Interface and non-interface types do not match.
func _() {
	var file *os.File
	g(file, io /* ERROR "type io.Writer of io.Discard does not match inferred type *os.File for T" */ .Discard)
	g(file, os.Stdout)
}

func _() {
	var a *os.File
	var b any
	g(a, a)
	g(a, b /* ERROR "type any of b does not match inferred type *os.File for T" */)
}

		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}

	b.SetBytes(1)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		err := msgp.Encode(io.Discard, &v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkEncodeDiskInfoGOB(b *testing.B) {
	v := DiskInfo{
		Total:     1000,
		Free:      1000,
		Used:      1000,

	for _, tc := range benchTestCases() {
		b.Run(tc.name, func(b *testing.B) {
			b.ReportAllocs()
			for n := 0; n < b.N; n++ {
				err := target.Encode(tc.obj, ioutil.Discard)
				if err != nil {
					b.Fatal(err)
				}
			}
		})
	}
}

func benchmarkEncodeWithAllocatorFor(b *testing.B, target runtime.EncoderWithAllocator) {
	for _, tc := range benchTestCases() {

# Test that [GOEXPERIMENT:x] is accepted.
# Here fieldtrack is picked arbitrarily.

[GOEXPERIMENT:nofieldtrack] env

[GOEXPERIMENT:fieldtrack] env

			if len(buf0) > n-i {
				buf0 = buf0[:n-i]
			}
			copy(buf1[i:], buf0)
		}
		buf0 = nil
		w, err := NewWriter(io.Discard, level)
		if err != nil {
			b.Fatal(err)
		}
		runtime.GC()
		b.StartTimer()
		for i := 0; i < b.N; i++ {
			w.Reset(io.Discard)
			w.Write(buf1)
			w.Close()
		}
	})
}

// errorWriter is a writer that fails after N writes.
type errorWriter struct {
	N int

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

package main

import (
	"io"
	"runtime/pprof"
)

import "C"

//export go_start_profile
func go_start_profile() {
	pprof.StartCPUProfile(io.Discard)
}

//export go_stop_profile
func go_stop_profile() {
	pprof.StopCPUProfile()
}

func main() {

	IMULL	AX
	IMULL	$4, CX
	IMULL	AX, BX

// LTYPEXC spec9	{ outcode(int($1), &$2); }
	CMPPD	X0, X1, 4
	CMPPD	foo+4(SB), X1, 4

// LTYPEX spec10	{ outcode(int($1), &$2); }
	PINSRD	$1, (AX), X0
	PINSRD	$2, foo+4(FP), X0

// Was bug: LOOP is a branch instruction.
	JCS	2(PC)
loop:
	LOOP	loop // LOOP

// Tests for TLS reference.
	MOVL    (TLS), AX
	MOVL    8(TLS), DX

    /**
     * Sets the value of the property to the given value, replacing whatever value the property already had.
     *
     * <p>
     * This method can also be used to discard the value of the property, by passing it {@code null}. When the
     * value is discarded (or has never been set in the first place), the convention (default value) for this

                        }
                    }
                    // 'Subproject_with_preferProjectModules' config DOES NOT influence this dependency
                    // and hence the higher version is picked from repo
                    edge("project :ModuleC", "myorg:ModuleC:2.0")
                }
                module("myorg:ModuleB:1.0")
                edge("project :ModuleC", "myorg:ModuleC:2.0")
            }