pkg image, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At }
pkg image, type RGBA64Image interface, At(int, int) color.Color
pkg image, type RGBA64Image interface, Bounds() Rectangle
pkg image, type RGBA64Image interface, ColorModel() color.Model
pkg image, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
pkg image/draw, type RGBA64Image interface { At, Bounds, ColorModel, RGBA64At, Set, SetRGBA64 }

	image.Image
	Set(x, y int, c color.Color)
}

// RGBA64Image extends both the [Image] and [image.RGBA64Image] interfaces with a
// SetRGBA64 method to change a single pixel. SetRGBA64 is equivalent to
// calling Set, but it can avoid allocations from converting concrete color
// types to the [color.Color] interface type.
type RGBA64Image interface {
	image.RGBA64Image
	Set(x, y int, c color.Color)
	SetRGBA64(x, y int, c color.RGBA64)

			t.Errorf("could not initialize pixels for %T", tc)
			continue
		}

		// Check that RGBA64At(x, y) is equivalent to At(x, y).RGBA().
		rgba64Image, ok := tc.(RGBA64Image)
		if !ok {
			t.Errorf("%T is not an RGBA64Image", tc)
			continue
		}
		got := rgba64Image.RGBA64At(1, 1)
		wantR, wantG, wantB, wantA := tc.At(1, 1).RGBA()
		if (uint32(got.R) != wantR) || (uint32(got.G) != wantG) ||

	}
}

func init() {
	var p any = (*slowestRGBA)(nil)
	if _, ok := p.(RGBA64Image); ok {
		panic("slowestRGBA should not be an RGBA64Image")
	}
}

// slowerRGBA is a draw.Image like image.RGBA but it is a different type and
// therefore does not trigger the draw.go fastest code paths.
//
// Unlike slowestRGBA, it still implements the draw.RGBA64Image interface.
type slowerRGBA struct {
	Pix    []uint8
	Stride int

// At implements the [Image] interface.
func (r Rectangle) At(x, y int) color.Color {
	if (Point{x, y}).In(r) {
		return color.Opaque
	}
	return color.Transparent
}

// RGBA64At implements the [RGBA64Image] interface.
func (r Rectangle) RGBA64At(x, y int) color.RGBA64 {
	if (Point{x, y}).In(r) {
		return color.RGBA64{0xffff, 0xffff, 0xffff, 0xffff}
	}
	return color.RGBA64{}
}

	// At(Bounds().Max.X-1, Bounds().Max.Y-1) returns the lower-right one.
	At(x, y int) color.Color
}

// RGBA64Image is an [Image] whose pixels can be converted directly to a
// color.RGBA64.
type RGBA64Image interface {
	// RGBA64At returns the RGBA64 color of the pixel at (x, y). It is
	// equivalent to calling At(x, y).RGBA() and converting the resulting

		{"RGBA.Pix", Field, 0},
		{"RGBA.Rect", Field, 0},
		{"RGBA.Stride", Field, 0},
		{"RGBA64", Type, 0},
		{"RGBA64.Pix", Field, 0},
		{"RGBA64.Rect", Field, 0},
		{"RGBA64.Stride", Field, 0},
		{"RGBA64Image", Type, 17},
		{"Rect", Func, 0},
		{"Rectangle", Type, 0},
		{"Rectangle.Max", Field, 0},
		{"Rectangle.Min", Field, 0},
		{"RegisterFormat", Func, 0},
		{"Transparent", Var, 0},