for i := 0; i < 64; i++ {
		a[i] = "aaaa"
		c[i] = "cccc"
	}

	for j := 0; j < b.N; j++ {
		_ = a == c
	}
}

func BenchmarkEqArrayOfStrings1024(b *testing.B) {
	var a [1024]string
	var c [1024]string

	for i := 0; i < 1024; i++ {
		a[i] = "aaaa"
		c[i] = "cccc"
	}

	for j := 0; j < b.N; j++ {
		_ = a == c
	}
}

func BenchmarkEqArrayOfFloats5(b *testing.B) {
	var a [5]float32

		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}

func Add1024[T integer](s []T) {
	for i, v := range s {
		s[i] = v + 1024 // ERROR "cannot convert 1024 (untyped int constant) to type T"
	}
}

func f[T interface{ int8 }]() {
	println(T(1024 /* ERROR "cannot convert 1024 (untyped int value) to type T" */))

import javax.annotation.Nullable;
import java.util.Locale;

public class MemoryAmount {
    private static final long KILO_FACTOR = 1024;
    private static final long MEGA_FACTOR = KILO_FACTOR * 1024;
    private static final long GIGA_FACTOR = MEGA_FACTOR * 1024;
    private static final long TERA_FACTOR = GIGA_FACTOR * 1024;

    public static MemoryAmount of(long bytes) {
        return new MemoryAmount(bytes, String.valueOf(bytes));
    }

  private Platform() {}

  /** Returns a thread-local 1024-char array. */
  static char[] charBufferFromThreadLocal() {
    // requireNonNull accommodates Android's @RecentlyNullable annotation on ThreadLocal.get
    return requireNonNull(DEST_TL.get());
  }

  /**
   * A thread-local destination buffer to keep us from creating new buffers. The starting size is

	case AAMOMINW:
		return &inst{0x2f, 0x2, 0x0, -2048, 0x40}
	case AAMOMINUD:
		return &inst{0x2f, 0x3, 0x0, -1024, 0x60}
	case AAMOMINUW:
		return &inst{0x2f, 0x2, 0x0, -1024, 0x60}
	case AAMOORD:
		return &inst{0x2f, 0x3, 0x0, 1024, 0x20}
	case AAMOORW:
		return &inst{0x2f, 0x2, 0x0, 1024, 0x20}
	case AAMOSWAPD:
		return &inst{0x2f, 0x3, 0x0, 128, 0x4}
	case AAMOSWAPW:
		return &inst{0x2f, 0x2, 0x0, 128, 0x4}

package p

// This type and the following one will share the same GC shape and size.
type Pointery struct {
	p *Pointery
	x [1024]int
}

type Pointery2 struct {
	p *Pointery2
	x [1024]int
}

// This type and the following one will have the same size.
type Vanilla struct {
	np uintptr
	x  [1024]int
}

type Vanilla2 struct {
	np uintptr
	x  [1023]int
	y  int
}

type Single struct {
	np uintptr

	}

	var iovecs []syscall.Iovec
	if fd.iovecs != nil {
		iovecs = *fd.iovecs
	}
	// TODO: read from sysconf(_SC_IOV_MAX)? The Linux default is
	// 1024 and this seems conservative enough for now. Darwin's
	// UIO_MAXIOV also seems to be 1024.
	maxVec := 1024
	if runtime.GOOS == "aix" || runtime.GOOS == "solaris" {
		// IOV_MAX is set to XOPEN_IOV_MAX on AIX and Solaris.
		maxVec = 16
	}

	var n int64
	var err error

	}
	if err := quick.Check(f1, quickCheckConfig(1024)); err != nil {
		t.Errorf("failed bytes->scalar->bytes round-trip: %v", err)
	}

	f2 := func(sc1, sc2 Scalar) bool {
		if _, err := sc2.SetCanonicalBytes(sc1.Bytes()); err != nil {
			return false
		}
		return sc1 == sc2
	}
	if err := quick.Check(f2, quickCheckConfig(1024)); err != nil {
		t.Errorf("failed scalar->bytes->scalar round-trip: %v", err)
	}

)

func BenchmarkRingBuffer_Sync(b *testing.B) {
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		rb.Write(data)
		rb.Read(buf)
	}
}

func BenchmarkRingBuffer_AsyncRead(b *testing.B) {
	// Pretty useless benchmark, but it's here for completeness.
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

                @Input
                Long fileSize = 1024

                @OutputFile
                File outputFile

                @TaskAction
                void createFile() {
                    outputFile.withOutputStream { OutputStream out ->
                        def random = new Random()
                        def buffer = new byte[1024]
                        for (def count = 0; count < fileSize; count++) {