}

	b.Run("requested-none", func(b *testing.B) {
		b.ReportAllocs()
		b.ResetTimer()
		b.SetBytes(855) // number of versions...
		for b.Loop() {
			mergeXLV2Versions(8, false, 0, vers...)
		}
	})

	b.Run("requested-v1", func(b *testing.B) {
		b.ReportAllocs()
		b.ResetTimer()
		b.SetBytes(855) // number of versions...
		for b.Loop() {
			mergeXLV2Versions(8, false, 1, vers...)
		}
	})

		{name: "long", input: strings.Repeat("a/", 2000), want: false},
		{name: "long-fail", input: strings.Repeat("a/", 2000) + "../..", want: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(b *testing.B) {
			b.SetBytes(int64(len(tt.input)))
			b.ReportAllocs()
			for b.Loop() {
				if got := hasBadPathComponent(tt.input); got != tt.want {
					t.Fatalf("hasBadPathComponent() = %v, want %v", got, tt.want)
				}
			}
		})

	for _, n := range sizes {
		if isRaceBuilder && n > 4<<10 {
			continue
		}
		b.Run(valName(n), func(b *testing.B) {
			if len(bmbuf) < n {
				bmbuf = make([]byte, n)
			}
			b.SetBytes(int64(n))
			f(b, n)
		})
	}
}

var indexSizes = []int{10, 32, 4 << 10, 4 << 20, 64 << 20}

var isRaceBuilder = strings.HasSuffix(testenv.Builder(), "-race")

	content := make([]byte, size)

	for i := range dataDown {
		disks[i] = OfflineDisk
	}
	for i := data; i < data+parityDown; i++ {
		disks[i] = OfflineDisk
	}

	b.SetBytes(size)
	b.ReportAllocs()
	for b.Loop() {
		writers := make([]io.Writer, len(disks))
		for i, disk := range disks {
			if disk == OfflineDisk {
				continue
			}

a, m = m, a } if bytes.Compare(b, m) > 0 { b, m = m, b } M, err := NewModulus(m) if err != nil { t.Fatal(err) } A, err := NewNat().SetBytes(a, M) if err != nil { t.Fatal(err) } B, err := NewNat().SetBytes(b, M) if err != nil { t.Fatal(err) } A.Mul(B, M) ABytes := A.Bytes(M) mBig := new(big.Int).SetBytes(m) aBig := new(big.Int).SetBytes(a) bBig := new(big.Int).SetBytes(b) nBig := new(big.Int).Mul(aBig, bBig) nBig.Mod(nBig, mBig) nBigBytes := make([]byte, len(ABytes)) nBig.FillBytes(nBigBytes) if !bytes.Equal(ABytes,...

a, m = m, a } if bytes.Compare(b, m) > 0 { b, m = m, b } M, err := NewModulus(m) if err != nil { t.Fatal(err) } A, err := NewNat().SetBytes(a, M) if err != nil { t.Fatal(err) } B, err := NewNat().SetBytes(b, M) if err != nil { t.Fatal(err) } A.Mul(B, M) ABytes := A.Bytes(M) mBig := new(big.Int).SetBytes(m) aBig := new(big.Int).SetBytes(a) bBig := new(big.Int).SetBytes(b) nBig := new(big.Int).Mul(aBig, bBig) nBig.Mod(nBig, mBig) nBigBytes := make([]byte, len(ABytes)) nBig.FillBytes(nBigBytes) if !bytes.Equal(ABytes,...

		b.Fatalf("failed to create erasure test file: %v", err)
	}

	for i := range dataDown {
		writers[i] = nil
	}
	for i := data; i < data+parityDown; i++ {
		writers[i] = nil
	}

	b.SetBytes(size)
	b.ReportAllocs()
	for b.Loop() {
		bitrotReaders := make([]io.ReaderAt, len(disks))
		for index, disk := range disks {
			if writers[index] == nil {
				continue
			}

pkg math/big, method (*Int) Set(*Int) *Int
pkg math/big, method (*Int) SetBit(*Int, int, uint) *Int
pkg math/big, method (*Int) SetBits([]Word) *Int
pkg math/big, method (*Int) SetBytes([]uint8) *Int
pkg math/big, method (*Int) SetInt64(int64) *Int
pkg math/big, method (*Int) SetString(string, int) (*Int, bool)
pkg math/big, method (*Int) Sign() int
pkg math/big, method (*Int) String() string