diff --git a/draw/gen.go b/draw/gen.go
index 0d98f68..06080d8 100644
--- a/draw/gen.go
+++ b/draw/gen.go
@@ -181,7 +181,7 @@
 		default:
 			return ";"
 		case "*image.RGBA":
-			return "d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))"
+			return "d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))"
 		}
 
 	case "preKernelInner":
@@ -189,7 +189,7 @@
 		default:
 			return ";"
 		case "*image.RGBA":
-			return "d := dst.PixOffset(dp.X+int(dx), dp.Y+dr.Min.Y)"
+			return "d := dst.PixOffset(dp.X+int(dx), dp.Y+adr.Min.Y)"
 		}
 
 	case "blend":
@@ -411,29 +411,29 @@
 			if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 {
 				return
 			}
-			// dr is the affected destination pixels, relative to dp.
-			dr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
-			if dr.Empty() {
+			// adr is the affected destination pixels, relative to dp.
+			adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
+			if adr.Empty() {
 				return
 			}
 			// sr is the source pixels. If it extends beyond the src bounds,
 			// we cannot use the type-specific fast paths, as they access
 			// the Pix fields directly without bounds checking.
 			if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) {
-				z.scale_Image_Image(dst, dp, dr, src, sp)
+				z.scale_Image_Image(dst, dp, adr, src, sp)
 			} else {
-				$switch z.scale_$dTypeRN_$sTypeRN(dst, dp, dr, src, sp)
+				$switch z.scale_$dTypeRN_$sTypeRN(dst, dp, adr, src, sp)
 			}
 		}
 	`
 
 	codeNNLeaf = `
-		func (z *nnScaler) scale_$dTypeRN_$sTypeRN(dst $dType, dp image.Point, dr image.Rectangle, src $sType, sp image.Point) {
+		func (z *nnScaler) scale_$dTypeRN_$sTypeRN(dst $dType, dp image.Point, adr image.Rectangle, src $sType, sp image.Point) {
 			$preOuter
-			for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 				sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
 				$preInner
-				for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+				for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 					sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 					p := $srcu[sx, sy]
 					$outputu[dx, dy, p]
@@ -443,11 +443,11 @@
 	`
 
 	codeABLLeaf = `
-		func (z *ablScaler) scale_$dTypeRN_$sTypeRN(dst $dType, dp image.Point, dr image.Rectangle, src $sType, sp image.Point) {
+		func (z *ablScaler) scale_$dTypeRN_$sTypeRN(dst $dType, dp image.Point, adr image.Rectangle, src $sType, sp image.Point) {
 			yscale := float64(z.sh) / float64(z.dh)
 			xscale := float64(z.sw) / float64(z.dw)
 			$preOuter
-			for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+			for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 				sy := (float64(dy)+0.5)*yscale - 0.5
 				sy0 := int32(sy)
 				yFrac0 := sy - float64(sy0)
@@ -461,7 +461,7 @@
 					yFrac0, yFrac1 = 1, 0
 				}
 				$preInner
-				for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+				for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 					sx := (float64(dx)+0.5)*xscale - 0.5
 					sx0 := int32(sx)
 					xFrac0 := sx - float64(sx0)
@@ -492,9 +492,9 @@
 			if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 {
 				return
 			}
-			// dr is the affected destination pixels, relative to dp.
-			dr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
-			if dr.Empty() {
+			// adr is the affected destination pixels, relative to dp.
+			adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
+			if adr.Empty() {
 				return
 			}
 			// Create a temporary buffer:
@@ -512,7 +512,7 @@
 				$switchS z.scaleX_$sTypeRN(tmp, src, sp)
 			}
 
-			$switchD z.scaleY_$dTypeRN(dst, dp, dr, tmp)
+			$switchD z.scaleY_$dTypeRN(dst, dp, adr, tmp)
 		}
 	`
 
@@ -538,11 +538,11 @@
 	`
 
 	codeKernelLeafY = `
-		func (z *kernelScaler) scaleY_$dTypeRN(dst $dType, dp image.Point, dr image.Rectangle, tmp [][4]float64) {
+		func (z *kernelScaler) scaleY_$dTypeRN(dst $dType, dp image.Point, adr image.Rectangle, tmp [][4]float64) {
 			$preOuter
-			for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+			for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 				$preKernelInner
-				$tweakDy for dy, s := range z.vertical.sources[dr.Min.Y:dr.Max.Y] {
+				$tweakDy for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] {
 					var pr, pg, pb, pa float64
 					for _, c := range z.vertical.contribs[s.i:s.j] {
 						p := &tmp[c.coord*z.dw+dx]
@@ -551,7 +551,7 @@
 						pb += p[2] * c.weight
 						pa += p[3] * c.weight
 					}
-					$outputf[dx, dr.Min.Y+dy, p, s.invTotalWeight]
+					$outputf[dx, adr.Min.Y+dy, p, s.invTotalWeight]
 				}
 			}
 		}
diff --git a/draw/impl.go b/draw/impl.go
index 9a2fbf5..ccc0632 100644
--- a/draw/impl.go
+++ b/draw/impl.go
@@ -11,47 +11,47 @@
 	if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 {
 		return
 	}
-	// dr is the affected destination pixels, relative to dp.
-	dr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
-	if dr.Empty() {
+	// adr is the affected destination pixels, relative to dp.
+	adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
+	if adr.Empty() {
 		return
 	}
 	// sr is the source pixels. If it extends beyond the src bounds,
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) {
-		z.scale_Image_Image(dst, dp, dr, src, sp)
+		z.scale_Image_Image(dst, dp, adr, src, sp)
 	} else {
 		switch dst := dst.(type) {
 		case *image.RGBA:
 			switch src := src.(type) {
 			case *image.Gray:
-				z.scale_RGBA_Gray(dst, dp, dr, src, sp)
+				z.scale_RGBA_Gray(dst, dp, adr, src, sp)
 			case *image.NRGBA:
-				z.scale_RGBA_NRGBA(dst, dp, dr, src, sp)
+				z.scale_RGBA_NRGBA(dst, dp, adr, src, sp)
 			case *image.RGBA:
-				z.scale_RGBA_RGBA(dst, dp, dr, src, sp)
+				z.scale_RGBA_RGBA(dst, dp, adr, src, sp)
 			case *image.Uniform:
-				z.scale_RGBA_Uniform(dst, dp, dr, src, sp)
+				z.scale_RGBA_Uniform(dst, dp, adr, src, sp)
 			case *image.YCbCr:
-				z.scale_RGBA_YCbCr(dst, dp, dr, src, sp)
+				z.scale_RGBA_YCbCr(dst, dp, adr, src, sp)
 			default:
-				z.scale_RGBA_Image(dst, dp, dr, src, sp)
+				z.scale_RGBA_Image(dst, dp, adr, src, sp)
 			}
 		default:
 			switch src := src.(type) {
 			default:
-				z.scale_Image_Image(dst, dp, dr, src, sp)
+				z.scale_Image_Image(dst, dp, adr, src, sp)
 			}
 		}
 	}
 }
 
-func (z *nnScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.Gray, sp image.Point) {
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+func (z *nnScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Gray, sp image.Point) {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA()
 			dst.Pix[d+0] = uint8(uint32(pr) >> 8)
@@ -63,11 +63,11 @@
 	}
 }
 
-func (z *nnScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.NRGBA, sp image.Point) {
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+func (z *nnScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.NRGBA, sp image.Point) {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA()
 			dst.Pix[d+0] = uint8(uint32(pr) >> 8)
@@ -79,11 +79,11 @@
 	}
 }
 
-func (z *nnScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.RGBA, sp image.Point) {
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+func (z *nnScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.RGBA, sp image.Point) {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pi := src.PixOffset(sp.X+int(sx), sp.Y+int(sy))
 			pr := uint32(src.Pix[pi+0]) * 0x101
@@ -99,11 +99,11 @@
 	}
 }
 
-func (z *nnScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.Uniform, sp image.Point) {
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+func (z *nnScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Uniform, sp image.Point) {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA()
 			dst.Pix[d+0] = uint8(uint32(pr) >> 8)
@@ -115,11 +115,11 @@
 	}
 }
 
-func (z *nnScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.YCbCr, sp image.Point) {
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+func (z *nnScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.YCbCr, sp image.Point) {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA()
 			dst.Pix[d+0] = uint8(uint32(pr) >> 8)
@@ -131,11 +131,11 @@
 	}
 }
 
-func (z *nnScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, dr image.Rectangle, src image.Image, sp image.Point) {
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+func (z *nnScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA()
 			dst.Pix[d+0] = uint8(uint32(pr) >> 8)
@@ -147,12 +147,12 @@
 	}
 }
 
-func (z *nnScaler) scale_Image_Image(dst Image, dp image.Point, dr image.Rectangle, src image.Image, sp image.Point) {
+func (z *nnScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) {
 	dstColorRGBA64 := &color.RGBA64{}
 	dstColor := color.Color(dstColorRGBA64)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (2*uint64(dy) + 1) * uint64(z.sh) / (2 * uint64(z.dh))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (2*uint64(dx) + 1) * uint64(z.sw) / (2 * uint64(z.dw))
 			pr, pg, pb, pa := src.At(sp.X+int(sx), sp.Y+int(sy)).RGBA()
 			dstColorRGBA64.R = uint16(pr)
@@ -168,46 +168,46 @@
 	if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 {
 		return
 	}
-	// dr is the affected destination pixels, relative to dp.
-	dr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
-	if dr.Empty() {
+	// adr is the affected destination pixels, relative to dp.
+	adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
+	if adr.Empty() {
 		return
 	}
 	// sr is the source pixels. If it extends beyond the src bounds,
 	// we cannot use the type-specific fast paths, as they access
 	// the Pix fields directly without bounds checking.
 	if sr := (image.Rectangle{sp, sp.Add(image.Point{int(z.sw), int(z.sh)})}); !sr.In(src.Bounds()) {
-		z.scale_Image_Image(dst, dp, dr, src, sp)
+		z.scale_Image_Image(dst, dp, adr, src, sp)
 	} else {
 		switch dst := dst.(type) {
 		case *image.RGBA:
 			switch src := src.(type) {
 			case *image.Gray:
-				z.scale_RGBA_Gray(dst, dp, dr, src, sp)
+				z.scale_RGBA_Gray(dst, dp, adr, src, sp)
 			case *image.NRGBA:
-				z.scale_RGBA_NRGBA(dst, dp, dr, src, sp)
+				z.scale_RGBA_NRGBA(dst, dp, adr, src, sp)
 			case *image.RGBA:
-				z.scale_RGBA_RGBA(dst, dp, dr, src, sp)
+				z.scale_RGBA_RGBA(dst, dp, adr, src, sp)
 			case *image.Uniform:
-				z.scale_RGBA_Uniform(dst, dp, dr, src, sp)
+				z.scale_RGBA_Uniform(dst, dp, adr, src, sp)
 			case *image.YCbCr:
-				z.scale_RGBA_YCbCr(dst, dp, dr, src, sp)
+				z.scale_RGBA_YCbCr(dst, dp, adr, src, sp)
 			default:
-				z.scale_RGBA_Image(dst, dp, dr, src, sp)
+				z.scale_RGBA_Image(dst, dp, adr, src, sp)
 			}
 		default:
 			switch src := src.(type) {
 			default:
-				z.scale_Image_Image(dst, dp, dr, src, sp)
+				z.scale_Image_Image(dst, dp, adr, src, sp)
 			}
 		}
 	}
 }
 
-func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.Gray, sp image.Point) {
+func (z *ablScaler) scale_RGBA_Gray(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Gray, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -220,8 +220,8 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -275,10 +275,10 @@
 	}
 }
 
-func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.NRGBA, sp image.Point) {
+func (z *ablScaler) scale_RGBA_NRGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.NRGBA, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -291,8 +291,8 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -346,10 +346,10 @@
 	}
 }
 
-func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.RGBA, sp image.Point) {
+func (z *ablScaler) scale_RGBA_RGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.RGBA, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -362,8 +362,8 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -433,10 +433,10 @@
 	}
 }
 
-func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.Uniform, sp image.Point) {
+func (z *ablScaler) scale_RGBA_Uniform(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.Uniform, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -449,8 +449,8 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -504,10 +504,10 @@
 	}
 }
 
-func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, dr image.Rectangle, src *image.YCbCr, sp image.Point) {
+func (z *ablScaler) scale_RGBA_YCbCr(dst *image.RGBA, dp image.Point, adr image.Rectangle, src *image.YCbCr, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -520,8 +520,8 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -575,10 +575,10 @@
 	}
 }
 
-func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, dr image.Rectangle, src image.Image, sp image.Point) {
+func (z *ablScaler) scale_RGBA_Image(dst *image.RGBA, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -591,8 +591,8 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		d := dst.PixOffset(dp.X+dr.Min.X, dp.Y+int(dy))
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+adr.Min.X, dp.Y+int(dy))
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -646,12 +646,12 @@
 	}
 }
 
-func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, dr image.Rectangle, src image.Image, sp image.Point) {
+func (z *ablScaler) scale_Image_Image(dst Image, dp image.Point, adr image.Rectangle, src image.Image, sp image.Point) {
 	yscale := float64(z.sh) / float64(z.dh)
 	xscale := float64(z.sw) / float64(z.dw)
 	dstColorRGBA64 := &color.RGBA64{}
 	dstColor := color.Color(dstColorRGBA64)
-	for dy := int32(dr.Min.Y); dy < int32(dr.Max.Y); dy++ {
+	for dy := int32(adr.Min.Y); dy < int32(adr.Max.Y); dy++ {
 		sy := (float64(dy)+0.5)*yscale - 0.5
 		sy0 := int32(sy)
 		yFrac0 := sy - float64(sy0)
@@ -664,7 +664,7 @@
 			sy1 = sy0
 			yFrac0, yFrac1 = 1, 0
 		}
-		for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
+		for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
 			sx := (float64(dx)+0.5)*xscale - 0.5
 			sx0 := int32(sx)
 			xFrac0 := sx - float64(sx0)
@@ -722,9 +722,9 @@
 	if z.dw <= 0 || z.dh <= 0 || z.sw <= 0 || z.sh <= 0 {
 		return
 	}
-	// dr is the affected destination pixels, relative to dp.
-	dr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
-	if dr.Empty() {
+	// adr is the affected destination pixels, relative to dp.
+	adr := dst.Bounds().Sub(dp).Intersect(image.Rectangle{Max: image.Point{int(z.dw), int(z.dh)}})
+	if adr.Empty() {
 		return
 	}
 	// Create a temporary buffer:
@@ -757,9 +757,9 @@
 
 	switch dst := dst.(type) {
 	case *image.RGBA:
-		z.scaleY_RGBA(dst, dp, dr, tmp)
+		z.scaleY_RGBA(dst, dp, adr, tmp)
 	default:
-		z.scaleY_Image(dst, dp, dr, tmp)
+		z.scaleY_Image(dst, dp, adr, tmp)
 	}
 }
 
@@ -905,10 +905,10 @@
 	}
 }
 
-func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dp image.Point, dr image.Rectangle, tmp [][4]float64) {
-	for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
-		d := dst.PixOffset(dp.X+int(dx), dp.Y+dr.Min.Y)
-		for _, s := range z.vertical.sources[dr.Min.Y:dr.Max.Y] {
+func (z *kernelScaler) scaleY_RGBA(dst *image.RGBA, dp image.Point, adr image.Rectangle, tmp [][4]float64) {
+	for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
+		d := dst.PixOffset(dp.X+int(dx), dp.Y+adr.Min.Y)
+		for _, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] {
 			var pr, pg, pb, pa float64
 			for _, c := range z.vertical.contribs[s.i:s.j] {
 				p := &tmp[c.coord*z.dw+dx]
@@ -926,11 +926,11 @@
 	}
 }
 
-func (z *kernelScaler) scaleY_Image(dst Image, dp image.Point, dr image.Rectangle, tmp [][4]float64) {
+func (z *kernelScaler) scaleY_Image(dst Image, dp image.Point, adr image.Rectangle, tmp [][4]float64) {
 	dstColorRGBA64 := &color.RGBA64{}
 	dstColor := color.Color(dstColorRGBA64)
-	for dx := int32(dr.Min.X); dx < int32(dr.Max.X); dx++ {
-		for dy, s := range z.vertical.sources[dr.Min.Y:dr.Max.Y] {
+	for dx := int32(adr.Min.X); dx < int32(adr.Max.X); dx++ {
+		for dy, s := range z.vertical.sources[adr.Min.Y:adr.Max.Y] {
 			var pr, pg, pb, pa float64
 			for _, c := range z.vertical.contribs[s.i:s.j] {
 				p := &tmp[c.coord*z.dw+dx]
@@ -943,7 +943,7 @@
 			dstColorRGBA64.G = ftou(pg * s.invTotalWeight)
 			dstColorRGBA64.B = ftou(pb * s.invTotalWeight)
 			dstColorRGBA64.A = ftou(pa * s.invTotalWeight)
-			dst.Set(dp.X+int(dx), dp.Y+int(dr.Min.Y+dy), dstColor)
+			dst.Set(dp.X+int(dx), dp.Y+int(adr.Min.Y+dy), dstColor)
 		}
 	}
 }