UID: types.UID("bravo"),
				},
			},
			dependents: map[*node]struct{}{
				alphaNode(): {},
			},
		}
	}
	charlieNode = func() *node {
		return &node{
			identity: objectReference{
				OwnerReference: metav1.OwnerReference{
					UID: types.UID("charlie"),
				},
			},
			dependents: map[*node]struct{}{
				alphaNode(): {},
			},
		}
	}
	deltaNode = func() *node {
		return &node{

}

func BenchmarkGlyphOver(b *testing.B) {
	bench(b, color.RGBAModel, nil, color.AlphaModel, Over)
}

func BenchmarkRGBAMaskOver(b *testing.B) {
	bench(b, color.RGBAModel, color.RGBAModel, color.AlphaModel, Over)
}

func BenchmarkGrayMaskOver(b *testing.B) {
	bench(b, color.RGBAModel, color.GrayModel, color.AlphaModel, Over)
}

func BenchmarkRGBA64ImageMaskOver(b *testing.B) {

var (
	RGBAModel    Model = ModelFunc(rgbaModel)
	RGBA64Model  Model = ModelFunc(rgba64Model)
	NRGBAModel   Model = ModelFunc(nrgbaModel)
	NRGBA64Model Model = ModelFunc(nrgba64Model)
	AlphaModel   Model = ModelFunc(alphaModel)
	Alpha16Model Model = ModelFunc(alpha16Model)
	GrayModel    Model = ModelFunc(grayModel)
	Gray16Model  Model = ModelFunc(gray16Model)
)

func rgbaModel(c Color) Color {

		} else {
			e.cb = cbP8
		}
	} else {
		switch m.ColorModel() {
		case color.GrayModel:
			e.cb = cbG8
		case color.Gray16Model:
			e.cb = cbG16
		case color.RGBAModel, color.NRGBAModel, color.AlphaModel:
			if opaque(m) {
				e.cb = cbTC8
			} else {
				e.cb = cbTCA8
			}
		default:
			if opaque(m) {
				e.cb = cbTC16
			} else {
				e.cb = cbTCA16
			}
		}
	}

	Pix []uint8
	// Stride is the Pix stride (in bytes) between vertically adjacent pixels.
	Stride int
	// Rect is the image's bounds.
	Rect Rectangle
}

func (p *Alpha) ColorModel() color.Model { return color.AlphaModel }

func (p *Alpha) Bounds() Rectangle { return p.Rect }

func (p *Alpha) At(x, y int) color.Color {
	return p.AlphaAt(x, y)
}

func (p *Alpha) RGBA64At(x, y int) color.RGBA64 {

func sng(w io.WriteCloser, filename string, png image.Image) {
	defer w.Close()
	bounds := png.Bounds()
	cm := png.ColorModel()
	var bitdepth int
	switch cm {
	case color.RGBAModel, color.NRGBAModel, color.AlphaModel, color.GrayModel:
		bitdepth = 8
	default:
		bitdepth = 16
	}
	cpm, _ := cm.(color.Palette)
	var paletted *image.Paletted
	if cpm != nil {
		switch {
		case len(cpm) <= 2:
			bitdepth = 1

		{"(RGBA64).RGBA", Method, 0},
		{"(YCbCr).RGBA", Method, 0},
		{"Alpha", Type, 0},
		{"Alpha.A", Field, 0},
		{"Alpha16", Type, 0},
		{"Alpha16.A", Field, 0},
		{"Alpha16Model", Var, 0},
		{"AlphaModel", Var, 0},
		{"Black", Var, 0},
		{"CMYK", Type, 5},
		{"CMYK.C", Field, 5},
		{"CMYK.K", Field, 5},
		{"CMYK.M", Field, 5},
		{"CMYK.Y", Field, 5},
		{"CMYKModel", Var, 5},

pkg image/color, type YCbCr struct, Cb uint8
pkg image/color, type YCbCr struct, Cr uint8
pkg image/color, type YCbCr struct, Y uint8
pkg image/color, var Alpha16Model Model
pkg image/color, var AlphaModel Model
pkg image/color, var Black Gray16
pkg image/color, var Gray16Model Model
pkg image/color, var GrayModel Model
pkg image/color, var NRGBA64Model Model
pkg image/color, var NRGBAModel Model