From 6be976405f4b98ed2fa3a92547bc1ec73d2303fd Mon Sep 17 00:00:00 2001
From: thesyncim <thesyncim@gmail.com>
Date: Sun, 1 Nov 2026 20:13:47 +0000
Subject: [PATCH 1/2] internal/rewrite: make the overlap check small enough to
 inline

Every rewritten loop with two or more slices calls _loopvecOverlap for
each pair before it runs. The helper took the windows as ...int and
inlining it cost 114, over the compiler's budget of 80, so each call was
a real call: AddFloat32s made two before it loaded anything, which for
a short loop costs about as much as the loop.

The helper now takes the windows as four plain arguments, and a whole
slice is passed as 0 and its length. It inlines (cost 55), and the
comparison is the same.
---
 internal/rewrite/rewriter.go     | 18 ++++++++----------
 testdata/overlap_helper_once.txt |  2 +-
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/internal/rewrite/rewriter.go b/internal/rewrite/rewriter.go
index 25fb69c..5583ddc 100644
--- a/internal/rewrite/rewriter.go
+++ b/internal/rewrite/rewriter.go
@@ -241,7 +241,7 @@ func wrapWithOverlapCheck(plan *loopir.Plan, origText, simdText string) string {
 		if plan.Bound == "" && plan.Start == "0" {
 			// The loop runs over whole slices, so comparing whole slices covers
 			// every element it touches.
-			fmt.Fprintf(&cond, "_loopvecOverlap(%s, %s)", pair[0].Name, pair[1].Name)
+			fmt.Fprintf(&cond, "_loopvecOverlap(%[1]s, %[2]s, 0, len(%[1]s), 0, len(%[2]s))", pair[0].Name, pair[1].Name)
 			continue
 		}
 		aLo, aHi := window(plan, pair[0])
@@ -285,22 +285,20 @@ func offsetText(v int) string {
 }
 
 // overlapHelperSrc is _loopvecOverlap's source, appended once per rewritten
-// file that needs it.
+// file that needs it. It reports whether a[aLo:aHi] and b[bLo:bHi] share
+// memory. It takes the windows as plain arguments, a whole slice as 0 and its
+// length, so that it is small enough to inline: every rewritten loop with two
+// slices calls it before it runs, and a call costs a short loop as much as
+// the loop itself.
 const overlapHelperSrc = `
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 `
 
diff --git a/testdata/overlap_helper_once.txt b/testdata/overlap_helper_once.txt
index 4849a8c..cf13176 100644
--- a/testdata/overlap_helper_once.txt
+++ b/testdata/overlap_helper_once.txt
@@ -6,7 +6,7 @@ loopvec -split .
 grep -count=1 'func _loopvecOverlap' a_simd.go
 ! grep 'func _loopvecOverlap' b_simd.go
 ! grep '"unsafe"' b_simd.go
-grep '_loopvecOverlap\(dst, a\)' b_simd.go
+grep '_loopvecOverlap\(dst, a, 0, len\(dst\), 0, len\(a\)\)' b_simd.go
 
 env GOEXPERIMENT=simd
 exec go run ./testmain

From 23ff9ab3589d343b93f9ab3073009280e4659eed Mon Sep 17 00:00:00 2001
From: thesyncim <thesyncim@gmail.com>
Date: Sun, 1 Nov 2026 20:13:47 +0000
Subject: [PATCH 2/2] testdata: update the goldens for the new overlap call

Regenerated with make test-update. The -d scripts (flag_diff.txt,
readme_patterns.txt) also check the size of the generated hunk, which
shrinks by six lines.
---
 bench/ops_simd.go                        | 56 +++++++++++-------------
 testdata/abs_sqrt.txt                    | 18 +++-----
 testdata/activation_functions.txt        | 16 +++----
 testdata/activation_temp.txt             | 22 ++++------
 testdata/add_float32.txt                 | 12 ++---
 testdata/add_int32.txt                   | 12 ++---
 testdata/andnot.txt                      | 18 +++-----
 testdata/axpy_float32.txt                | 12 ++---
 testdata/bound_constant.txt              | 10 +----
 testdata/bound_other_slice.txt           | 10 +----
 testdata/bound_range_int.txt             | 10 +----
 testdata/bound_variable.txt              | 10 +----
 testdata/copy_loop.txt                   | 14 ++----
 testdata/daxpy_float32.txt               | 12 ++---
 testdata/daxpy_int32.txt                 | 12 ++---
 testdata/daxpy_sub_float32.txt           | 12 ++---
 testdata/default_stdout.txt              | 12 ++---
 testdata/div_float32.txt                 | 12 ++---
 testdata/div_float64.txt                 | 12 ++---
 testdata/dotdotdot_skips_unbuildable.txt | 12 ++---
 testdata/field_slice.txt                 | 16 +++----
 testdata/flag_diff.txt                   |  2 +-
 testdata/flag_methods.txt                | 12 ++---
 testdata/flag_methods_ice.txt            | 12 ++---
 testdata/flag_methods_tip.txt            | 12 ++---
 testdata/flag_precedence.txt             | 12 ++---
 testdata/flag_write.txt                  | 12 ++---
 testdata/index_scalar_no_rewrite.txt     | 12 ++---
 testdata/induction.txt                   | 10 +----
 testdata/inplace_add.txt                 | 12 ++---
 testdata/invariant_call.txt              | 12 ++---
 testdata/let_temporary.txt               | 14 ++----
 testdata/loop_shape.txt                  | 16 +++----
 testdata/min_max_int.txt                 | 16 +++----
 testdata/mix_float32.txt                 | 12 ++---
 testdata/multi_store.txt                 | 10 +----
 testdata/multiple_files.txt              | 16 +++----
 testdata/named_slice_type.txt            | 12 ++---
 testdata/neg_float32.txt                 | 12 ++---
 testdata/neg_signed_and_float_types.txt  | 22 ++++------
 testdata/not_int32.txt                   | 12 ++---
 testdata/not_integer_types.txt           | 26 +++++------
 testdata/offset_read.txt                 | 14 ++----
 testdata/offset_stored.txt               | 10 +----
 testdata/paren_operands.txt              | 16 +++----
 testdata/range_value_multiplier.txt      | 10 +----
 testdata/range_value_sum.txt             | 10 +----
 testdata/readme_example.txt              | 12 ++---
 testdata/readme_patterns.txt             | 38 +++++-----------
 testdata/reduce_int.txt                  | 12 ++---
 testdata/reverse_no_dependence.txt       | 12 ++---
 testdata/scalar_mul_range_value.txt      | 10 +----
 testdata/shift.txt                       | 18 +++-----
 testdata/split_generated_header.txt      | 12 ++---
 testdata/split_idempotent.txt            | 12 ++---
 testdata/wide_expression.txt             | 18 +++-----
 56 files changed, 229 insertions(+), 571 deletions(-)

diff --git a/bench/ops_simd.go b/bench/ops_simd.go
index a5dce54..5cf91a3 100644
--- a/bench/ops_simd.go
+++ b/bench/ops_simd.go
@@ -9,7 +9,7 @@ import (
 )
 
 func AddFloat32s(dst, a, b []float32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -54,7 +54,7 @@ func AddFloat32s(dst, a, b []float32) {
 }
 
 func MulFloat32s(dst, a, b []float32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] * b[i]
 		}
@@ -129,7 +129,7 @@ func ScalFloat32s(x []float32, c float32) {
 
 func AxpyFloat32s(dst, a []float32, alpha float32, b []float32) {
 	_vcAFloat32s3 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i]*alpha + b[i]
 		}
@@ -176,7 +176,7 @@ func AxpyFloat32s(dst, a []float32, alpha float32, b []float32) {
 func MixFloat32s(dst, a, b []float32, alpha, beta float32) {
 	_vcAFloat32s4 := simd.BroadcastFloat32s(alpha)
 	_vcBFloat32s4 := simd.BroadcastFloat32s(beta)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i]*alpha + b[i]*beta
 		}
@@ -221,7 +221,7 @@ func MixFloat32s(dst, a, b []float32, alpha, beta float32) {
 }
 
 func NegFloat32s(dst, src []float32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := range dst {
 			dst[i] = -src[i]
 		}
@@ -259,7 +259,7 @@ func NegFloat32s(dst, src []float32) {
 }
 
 func DivFloat32s(dst, a, b []float32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] / b[i]
 		}
@@ -305,7 +305,7 @@ func DivFloat32s(dst, a, b []float32) {
 
 func DaxpyFloat32s(dst, a []float32, alpha float32) {
 	_vcAFloat32s7 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] += a[i] * alpha
 		}
@@ -396,7 +396,7 @@ func FillUint8s(dst []byte) {
 
 func ReverseIncFloat32s(dst, src []float32) {
 	_vcFloat32s10 := simd.BroadcastFloat32s(1)
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := len(dst) - 1; i >= 0; i-- {
 			dst[i] = src[i] + 1
 		}
@@ -434,7 +434,7 @@ func ReverseIncFloat32s(dst, src []float32) {
 }
 
 func CopyFloat32s(dst, src []float32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := range dst {
 			dst[i] = src[i]
 		}
@@ -447,7 +447,7 @@ func CopyFloat32s(dst, src []float32) {
 }
 
 func AndNotUint64s(dst, a, b []uint64) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] &^ b[i]
 		}
@@ -492,7 +492,7 @@ func AndNotUint64s(dst, a, b []uint64) {
 }
 
 func AbsFloat32s(dst, a []float32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = float32(math.Abs(float64(a[i])))
 		}
@@ -530,7 +530,7 @@ func AbsFloat32s(dst, a []float32) {
 }
 
 func SqrtFloat32s(dst, a []float32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = float32(math.Sqrt(float64(a[i])))
 		}
@@ -570,7 +570,7 @@ func SqrtFloat32s(dst, a []float32) {
 func ClampInt32s(dst, a []int32, lo, hi int32) {
 	_vcAInt32s15 := simd.BroadcastInt32s(lo)
 	_vcBInt32s15 := simd.BroadcastInt32s(hi)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = min(max(a[i], lo), hi)
 		}
@@ -608,7 +608,7 @@ func ClampInt32s(dst, a []int32, lo, hi int32) {
 }
 
 func ShrInt32s(dst, a []int32, n uint) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] >> n
 		}
@@ -646,7 +646,7 @@ func ShrInt32s(dst, a []int32, n uint) {
 }
 
 func ShlUint32s(dst, a []uint32, n uint) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] << n
 		}
@@ -818,7 +818,7 @@ func ChainInt32s(a, b, c, e []int32) {
 func WideInt32s(dst, a, b, c []int32, k, m int32) {
 	_vcInt32s20_1 := simd.BroadcastInt32s(k)
 	_vcInt32s20_2 := simd.BroadcastInt32s(k * m)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) || _loopvecOverlap(dst, c) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) || _loopvecOverlap(dst, c, 0, len(dst), 0, len(c)) {
 		for i := range dst {
 			dst[i] = a[i]*b[i] + c[i]*k + (k*m - a[i])
 		}
@@ -1405,7 +1405,7 @@ func SmoothInt32s(dst, a []int32) {
 
 func ShiftInt32s(dst, a []int32, off int) {
 	_vcInt32s33 := simd.BroadcastInt32s(3)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i+off] * 3
 		}
@@ -1443,7 +1443,7 @@ func ShiftInt32s(dst, a []int32, off int) {
 }
 
 func AccumRowInt32s(work, a []int32, row, lda int) {
-	if _loopvecOverlap(work, a) {
+	if _loopvecOverlap(work, a, 0, len(work), 0, len(a)) {
 		for j := range work {
 			work[j] += a[row*lda+j]
 		}
@@ -1644,7 +1644,7 @@ func ReLUFloat32s(x []float32) {
 func LeakyReLUFloat32s(dst, x []float32, alpha float32) {
 	_vcAFloat32s38 := simd.BroadcastFloat32s(0)
 	_vcBFloat32s38 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, x) {
+	if _loopvecOverlap(dst, x, 0, len(dst), 0, len(x)) {
 		for i := range dst {
 			if x[i] > 0 {
 				dst[i] = x[i]
@@ -1719,7 +1719,7 @@ func SignFloat32s(dst, x []float32) {
 	_vcFloat32s40_1 := simd.BroadcastFloat32s(0)
 	_vcFloat32s40_2 := simd.BroadcastFloat32s(1)
 	_vcFloat32s40_4 := simd.BroadcastFloat32s(-1)
-	if _loopvecOverlap(dst, x) {
+	if _loopvecOverlap(dst, x, 0, len(dst), 0, len(x)) {
 		for i := range dst {
 			if x[i] > 0 {
 				dst[i] = 1
@@ -1825,7 +1825,7 @@ func ScaleFieldFloat32s(v *Vec, a float32) {
 func AddFieldFloat32s(dst, a *Vec) {
 	if len(dst.Values) > 0 {
 		_sdst_Values, _sa_Values := dst.Values, a.Values
-		if _loopvecOverlap(_sdst_Values, _sa_Values) {
+		if _loopvecOverlap(_sdst_Values, _sa_Values, 0, len(_sdst_Values), 0, len(_sa_Values)) {
 			for i := range dst.Values {
 				dst.Values[i] += a.Values[i]
 			}
@@ -1873,7 +1873,7 @@ func HardSwishFloat32s(dst, x []float32) {
 	_vcFloat32s44_1 := simd.BroadcastFloat32s(3)
 	_vcFloat32s44_2 := simd.BroadcastFloat32s(0)
 	_vcFloat32s44_4 := simd.BroadcastFloat32s(6)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			t := x[i] + 3
 			if t < 0 {
@@ -1932,7 +1932,7 @@ func HardSigmoidFloat32s(dst, x []float32) {
 	_vcFloat32s45_1 := simd.BroadcastFloat32s(3)
 	_vcFloat32s45_2 := simd.BroadcastFloat32s(0)
 	_vcFloat32s45_4 := simd.BroadcastFloat32s(6)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			t := x[i] + 3
 			if t < 0 {
@@ -1994,18 +1994,12 @@ func HardSigmoidFloat32s(dst, x []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
diff --git a/testdata/abs_sqrt.txt b/testdata/abs_sqrt.txt
index ef991d3..00cccdc 100644
--- a/testdata/abs_sqrt.txt
+++ b/testdata/abs_sqrt.txt
@@ -76,7 +76,7 @@ import (
 )
 
 func Abs64(dst, a []float64) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = math.Abs(a[i])
 		}
@@ -114,7 +114,7 @@ func Abs64(dst, a []float64) {
 }
 
 func Abs32(dst, a []float32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = float32(math.Abs(float64(a[i])))
 		}
@@ -152,7 +152,7 @@ func Abs32(dst, a []float32) {
 }
 
 func Sqrt32(dst, a []float32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = float32(math.Sqrt(float64(a[i])))
 		}
@@ -247,7 +247,7 @@ func InvSqrt(a []float64) {
 }
 
 func AbsDiff(dst, a, b []float64) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = math.Abs(a[i] - b[i])
 		}
@@ -291,20 +291,14 @@ func AbsDiff(dst, a, b []float64) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/activation_functions.txt b/testdata/activation_functions.txt
index 2542b74..eb9686a 100644
--- a/testdata/activation_functions.txt
+++ b/testdata/activation_functions.txt
@@ -177,7 +177,7 @@ func ReLU(x []float32) {
 func LeakyReLU(dst, x []float32, alpha float32) {
 	_vcAFloat32s1 := simd.BroadcastFloat32s(0)
 	_vcBFloat32s1 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, x) {
+	if _loopvecOverlap(dst, x, 0, len(dst), 0, len(x)) {
 		for i := range dst {
 			if x[i] > 0 {
 				dst[i] = x[i]
@@ -312,7 +312,7 @@ func Sign(dst, x []float32) {
 	_vcFloat32s5_1 := simd.BroadcastFloat32s(0)
 	_vcFloat32s5_2 := simd.BroadcastFloat32s(1)
 	_vcFloat32s5_4 := simd.BroadcastFloat32s(-1)
-	if _loopvecOverlap(dst, x) {
+	if _loopvecOverlap(dst, x, 0, len(dst), 0, len(x)) {
 		for i := range dst {
 			if x[i] > 0 {
 				dst[i] = 1
@@ -359,7 +359,7 @@ func Step(dst, x []float32, threshold float32) {
 	_vcFloat32s6_1 := simd.BroadcastFloat32s(threshold)
 	_vcFloat32s6_2 := simd.BroadcastFloat32s(1)
 	_vcFloat32s6_3 := simd.BroadcastFloat32s(0)
-	if _loopvecOverlap(dst, x) {
+	if _loopvecOverlap(dst, x, 0, len(dst), 0, len(x)) {
 		for i := range dst {
 			if x[i] >= threshold {
 				dst[i] = 1
@@ -549,20 +549,14 @@ func NaNToZero(x []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/activation_temp.txt b/testdata/activation_temp.txt
index a5bc6c5..e28b3eb 100644
--- a/testdata/activation_temp.txt
+++ b/testdata/activation_temp.txt
@@ -116,7 +116,7 @@ func HardSwish(dst, x []float32) {
 	_vcFloat32s0_1 := simd.BroadcastFloat32s(3)
 	_vcFloat32s0_2 := simd.BroadcastFloat32s(0)
 	_vcFloat32s0_4 := simd.BroadcastFloat32s(6)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			t := x[i] + 3
 			if t < 0 {
@@ -175,7 +175,7 @@ func HardSigmoid(dst, x []float32) {
 	_vcFloat32s1_1 := simd.BroadcastFloat32s(3)
 	_vcFloat32s1_2 := simd.BroadcastFloat32s(0)
 	_vcFloat32s1_4 := simd.BroadcastFloat32s(6)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			t := x[i] + 3
 			if t < 0 {
@@ -240,7 +240,7 @@ func HardSigmoid(dst, x []float32) {
 func ClampInt(dst, x []int32, lo, hi int32) {
 	_vcInt32s2_1 := simd.BroadcastInt32s(lo)
 	_vcInt32s2_3 := simd.BroadcastInt32s(hi)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			t := x[i]
 			if t < lo {
@@ -303,7 +303,7 @@ func SiLUSoftsign(dst, x []float32) {
 	_vcFloat32s3_1 := simd.BroadcastFloat32s(0)
 	_vcFloat32s3_2 := simd.BroadcastFloat32s(0.5)
 	_vcFloat32s3_3 := simd.BroadcastFloat32s(1)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			a := x[i]
 			if a < 0 {
@@ -362,7 +362,7 @@ func SiLUCubic(dst, x []float32) {
 	_vcFloat32s4_5 := simd.BroadcastFloat32s(48)
 	_vcFloat32s4_6 := simd.BroadcastFloat32s(4)
 	_vcFloat32s4_7 := simd.BroadcastFloat32s(0.5)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			c := x[i]
 			if c < -2 {
@@ -431,7 +431,7 @@ func Mixed(dst, x []float64) {
 	_vcFloat64s5_3 := simd.BroadcastFloat64s(10)
 	_vcFloat64s5_4 := simd.BroadcastFloat64s(100)
 	_vcFloat64s5_5 := simd.BroadcastFloat64s(-10)
-	if _loopvecOverlap(x, dst) {
+	if _loopvecOverlap(x, dst, 0, len(x), 0, len(dst)) {
 		for i := range dst {
 			a := x[i] * 2
 			b := a + 1
@@ -493,20 +493,14 @@ func Mixed(dst, x []float64) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/add_float32.txt b/testdata/add_float32.txt
index 73c3d4c..30ed88f 100644
--- a/testdata/add_float32.txt
+++ b/testdata/add_float32.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func AddFloat32s(dst, a, b []float32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := 0; i < len(dst); i++ {
 			dst[i] = a[i] + b[i]
 		}
@@ -83,20 +83,14 @@ func AddFloat32s(dst, a, b []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/add_int32.txt b/testdata/add_int32.txt
index debac16..768e827 100644
--- a/testdata/add_int32.txt
+++ b/testdata/add_int32.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -83,20 +83,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/andnot.txt b/testdata/andnot.txt
index 5fd64fd..8954c8c 100644
--- a/testdata/andnot.txt
+++ b/testdata/andnot.txt
@@ -63,7 +63,7 @@ import (
 type Colors []uint64
 
 func AndNotUint64s(dst, a, b []uint64) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] &^ b[i]
 		}
@@ -108,7 +108,7 @@ func AndNotUint64s(dst, a, b []uint64) {
 }
 
 func AndNotInPlace(dst []int32, mask []int32) {
-	if _loopvecOverlap(dst, mask) {
+	if _loopvecOverlap(dst, mask, 0, len(dst), 0, len(mask)) {
 		for i := range dst {
 			dst[i] &^= mask[i]
 		}
@@ -153,7 +153,7 @@ func AndNotInPlace(dst []int32, mask []int32) {
 
 func AndNotScalar(dst, a []byte, mask byte) {
 	_vcUint8s2 := simd.BroadcastUint8s(mask)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] &^ mask
 		}
@@ -191,7 +191,7 @@ func AndNotScalar(dst, a []byte, mask byte) {
 }
 
 func Feasible(feasible, used, adjacent Colors) {
-	if _loopvecOverlap(feasible, used) || _loopvecOverlap(feasible, adjacent) {
+	if _loopvecOverlap(feasible, used, 0, len(feasible), 0, len(used)) || _loopvecOverlap(feasible, adjacent, 0, len(feasible), 0, len(adjacent)) {
 		for w := range feasible {
 			feasible[w] = used[w] &^ adjacent[w]
 		}
@@ -235,20 +235,14 @@ func Feasible(feasible, used, adjacent Colors) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/axpy_float32.txt b/testdata/axpy_float32.txt
index b3e467f..ceaf036 100644
--- a/testdata/axpy_float32.txt
+++ b/testdata/axpy_float32.txt
@@ -40,7 +40,7 @@ import (
 
 func AxpyFloat32s(dst, a []float32, alpha float32, b []float32) {
 	_vcAFloat32s0 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i]*alpha + b[i]
 		}
@@ -84,20 +84,14 @@ func AxpyFloat32s(dst, a []float32, alpha float32, b []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/bound_constant.txt b/testdata/bound_constant.txt
index d4716cb..7d046f5 100644
--- a/testdata/bound_constant.txt
+++ b/testdata/bound_constant.txt
@@ -80,20 +80,14 @@ func Saxpy16(a float32, x, y []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/bound_other_slice.txt b/testdata/bound_other_slice.txt
index e527e09..0097e4e 100644
--- a/testdata/bound_other_slice.txt
+++ b/testdata/bound_other_slice.txt
@@ -78,20 +78,14 @@ func Scale(dst, src []float32, f float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/bound_range_int.txt b/testdata/bound_range_int.txt
index 51818f7..3a642e2 100644
--- a/testdata/bound_range_int.txt
+++ b/testdata/bound_range_int.txt
@@ -81,20 +81,14 @@ func SaxpyN(n int, a float32, x, y []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/bound_variable.txt b/testdata/bound_variable.txt
index a5ee9a5..baf1787 100644
--- a/testdata/bound_variable.txt
+++ b/testdata/bound_variable.txt
@@ -84,20 +84,14 @@ func SaxpyN(n int, a float32, x, y []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/copy_loop.txt b/testdata/copy_loop.txt
index 99c35b1..e319438 100644
--- a/testdata/copy_loop.txt
+++ b/testdata/copy_loop.txt
@@ -63,7 +63,7 @@ package test
 import "unsafe"
 
 func Copy(dst, src []float32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := range dst {
 			dst[i] = src[i]
 		}
@@ -104,7 +104,7 @@ func CopyBounded(dst, src []byte, n int) {
 }
 
 func CopyReverse(dst, src []uint16) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := len(dst) - 1; i >= 0; i-- {
 			dst[i] = src[i]
 		}
@@ -116,20 +116,14 @@ func CopyReverse(dst, src []uint16) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/daxpy_float32.txt b/testdata/daxpy_float32.txt
index fc24664..5abe545 100644
--- a/testdata/daxpy_float32.txt
+++ b/testdata/daxpy_float32.txt
@@ -40,7 +40,7 @@ import (
 
 func DaxpyFloat32s(dst, a []float32, alpha float32) {
 	_vcAFloat32s0 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] += a[i] * alpha
 		}
@@ -83,20 +83,14 @@ func DaxpyFloat32s(dst, a []float32, alpha float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/daxpy_int32.txt b/testdata/daxpy_int32.txt
index 14d8f5b..fad6cef 100644
--- a/testdata/daxpy_int32.txt
+++ b/testdata/daxpy_int32.txt
@@ -40,7 +40,7 @@ import (
 
 func DaxpyInt32s(dst, a []int32) {
 	_vcAInt32s0 := simd.BroadcastInt32s(3)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] += a[i] * 3
 		}
@@ -83,20 +83,14 @@ func DaxpyInt32s(dst, a []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/daxpy_sub_float32.txt b/testdata/daxpy_sub_float32.txt
index b1e855e..46d3f11 100644
--- a/testdata/daxpy_sub_float32.txt
+++ b/testdata/daxpy_sub_float32.txt
@@ -38,7 +38,7 @@ import (
 
 func SubScaledFloat32s(dst, a []float32, alpha float32) {
 	_vcAFloat32s0 := simd.BroadcastFloat32s(alpha)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] -= a[i] * alpha
 		}
@@ -81,20 +81,14 @@ func SubScaledFloat32s(dst, a []float32, alpha float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/default_stdout.txt b/testdata/default_stdout.txt
index 4c79019..f279d79 100644
--- a/testdata/default_stdout.txt
+++ b/testdata/default_stdout.txt
@@ -35,7 +35,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -79,20 +79,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/div_float32.txt b/testdata/div_float32.txt
index 754dbd2..fb0c591 100644
--- a/testdata/div_float32.txt
+++ b/testdata/div_float32.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func DivFloat32s(dst, a, b []float32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] / b[i]
 		}
@@ -83,20 +83,14 @@ func DivFloat32s(dst, a, b []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/div_float64.txt b/testdata/div_float64.txt
index 5073145..f32887e 100644
--- a/testdata/div_float64.txt
+++ b/testdata/div_float64.txt
@@ -36,7 +36,7 @@ import (
 )
 
 func DivFloat64s(dst, a, b []float64) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] / b[i]
 		}
@@ -80,20 +80,14 @@ func DivFloat64s(dst, a, b []float64) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/dotdotdot_skips_unbuildable.txt b/testdata/dotdotdot_skips_unbuildable.txt
index 7c8db92..8c62d37 100644
--- a/testdata/dotdotdot_skips_unbuildable.txt
+++ b/testdata/dotdotdot_skips_unbuildable.txt
@@ -36,7 +36,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -80,20 +80,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/sub/ops.go
diff --git a/testdata/field_slice.txt b/testdata/field_slice.txt
index 9684c05..4939040 100644
--- a/testdata/field_slice.txt
+++ b/testdata/field_slice.txt
@@ -125,7 +125,7 @@ func Scale(v *Vec, a float32) {
 func Add(dst, a *Vec) {
 	if len(dst.Values) > 0 {
 		_sdst_Values, _sa_Values := dst.Values, a.Values
-		if _loopvecOverlap(_sdst_Values, _sa_Values) {
+		if _loopvecOverlap(_sdst_Values, _sa_Values, 0, len(_sdst_Values), 0, len(_sa_Values)) {
 			for i := range dst.Values {
 				dst.Values[i] += a.Values[i]
 			}
@@ -215,7 +215,7 @@ func Nested(v *Vec, n int) {
 func Copy(dst, src *Vec) {
 	if len(dst.Values) > 0 {
 		_sdst_Values, _ssrc_Values := dst.Values, src.Values
-		if _loopvecOverlap(_sdst_Values, _ssrc_Values) {
+		if _loopvecOverlap(_sdst_Values, _ssrc_Values, 0, len(_sdst_Values), 0, len(_ssrc_Values)) {
 			for i := range dst.Values {
 				dst.Values[i] = src.Values[i]
 			}
@@ -275,7 +275,7 @@ func Mixed(dst *Vec, src []float32) {
 	_vcFloat32s5 := simd.BroadcastFloat32s(1)
 	if len(dst.Values) > 0 {
 		_sdst_Values := dst.Values
-		if _loopvecOverlap(_sdst_Values, src) {
+		if _loopvecOverlap(_sdst_Values, src, 0, len(_sdst_Values), 0, len(src)) {
 			for i := range dst.Values {
 				dst.Values[i] = src[i] + 1
 			}
@@ -313,20 +313,14 @@ func Mixed(dst *Vec, src []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/flag_diff.txt b/testdata/flag_diff.txt
index 41d92be..92d82cd 100644
--- a/testdata/flag_diff.txt
+++ b/testdata/flag_diff.txt
@@ -6,7 +6,7 @@ loopvec -d .
 cmpenv stderr stderr.want
 stdout -count=1 '^--- \S+/ops\.go\t\S+ \S+ [+-][0-9]{4}$'
 stdout -count=1 '^\+\+\+ \S+/ops\.go\t\S+ \S+ [+-][0-9]{4}$'
-stdout -count=1 '^@@ -1,7 \+1,69 @@$'
+stdout -count=1 '^@@ -1,7 \+1,63 @@$'
 stdout -count=1 '^\+//go:build goexperiment.simd$'
 stdout -count=1 '^\+import \($'
 stdout -count=1 '^-	for i := range dst \{$'
diff --git a/testdata/flag_methods.txt b/testdata/flag_methods.txt
index ca7224c..6e0da6c 100644
--- a/testdata/flag_methods.txt
+++ b/testdata/flag_methods.txt
@@ -35,7 +35,7 @@ import (
 type T struct{}
 
 func (T) AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -79,20 +79,14 @@ func (T) AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/flag_methods_ice.txt b/testdata/flag_methods_ice.txt
index 5e77748..fc689f1 100644
--- a/testdata/flag_methods_ice.txt
+++ b/testdata/flag_methods_ice.txt
@@ -51,7 +51,7 @@ import (
 type T struct{}
 
 func (T) AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -95,20 +95,14 @@ func (T) AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/flag_methods_tip.txt b/testdata/flag_methods_tip.txt
index e2fabc5..9457f36 100644
--- a/testdata/flag_methods_tip.txt
+++ b/testdata/flag_methods_tip.txt
@@ -42,7 +42,7 @@ import (
 type T struct{}
 
 func (T) AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -86,20 +86,14 @@ func (T) AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/flag_precedence.txt b/testdata/flag_precedence.txt
index 64502c9..a5eadf5 100644
--- a/testdata/flag_precedence.txt
+++ b/testdata/flag_precedence.txt
@@ -77,7 +77,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -121,20 +121,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- a.stderr --
 loopvec: rewrote 1 loop(s) in $WORK/a/ops.go
diff --git a/testdata/flag_write.txt b/testdata/flag_write.txt
index 827194d..774dfd8 100644
--- a/testdata/flag_write.txt
+++ b/testdata/flag_write.txt
@@ -31,7 +31,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -75,20 +75,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/index_scalar_no_rewrite.txt b/testdata/index_scalar_no_rewrite.txt
index d587eb7..2ac9f81 100644
--- a/testdata/index_scalar_no_rewrite.txt
+++ b/testdata/index_scalar_no_rewrite.txt
@@ -43,7 +43,7 @@ func AddIndex(dst, a []int32) {
 
 func MulIdx(dst, a []int32, n int32) {
 	_vcInt32s0 := simd.BroadcastInt32s(n)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] * n
 		}
@@ -80,20 +80,14 @@ func MulIdx(dst, a []int32, n int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/induction.txt b/testdata/induction.txt
index 5328da0..76bfb99 100644
--- a/testdata/induction.txt
+++ b/testdata/induction.txt
@@ -458,20 +458,14 @@ func SumInner(a []int32) int32 {
 	return s
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/inplace_add.txt b/testdata/inplace_add.txt
index a8a0bf6..ecb491e 100644
--- a/testdata/inplace_add.txt
+++ b/testdata/inplace_add.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func AddInplace(dst, src []int32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := range dst {
 			dst[i] += src[i]
 		}
@@ -82,20 +82,14 @@ func AddInplace(dst, src []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/invariant_call.txt b/testdata/invariant_call.txt
index 595f190..c4e9020 100644
--- a/testdata/invariant_call.txt
+++ b/testdata/invariant_call.txt
@@ -189,7 +189,7 @@ func FillBits32(out []float32, bits uint32) {
 
 func ScaleByInf(dst, a []float64) {
 	_vcFloat64s5 := simd.BroadcastFloat64s(math.Inf(1))
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] * math.Inf(1)
 		}
@@ -226,20 +226,14 @@ func ScaleByInf(dst, a []float64) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/let_temporary.txt b/testdata/let_temporary.txt
index 1a3f7d1..6c55050 100644
--- a/testdata/let_temporary.txt
+++ b/testdata/let_temporary.txt
@@ -60,7 +60,7 @@ import (
 )
 
 func Define(a, b, c []int32) {
-	if _loopvecOverlap(b, a) || _loopvecOverlap(c, a) {
+	if _loopvecOverlap(b, a, 0, len(b), 0, len(a)) || _loopvecOverlap(c, a, 0, len(c), 0, len(a)) {
 		for i := range a {
 			s := b[i] + c[i]
 			a[i] = s * s
@@ -114,7 +114,7 @@ func Define(a, b, c []int32) {
 func Outer(a, b, c []int32) {
 	var s int32
 	_vcInt32s1_1 := simd.BroadcastInt32s(3)
-	if _loopvecOverlap(b, a) || _loopvecOverlap(c, a) {
+	if _loopvecOverlap(b, a, 0, len(b), 0, len(a)) || _loopvecOverlap(c, a, 0, len(c), 0, len(a)) {
 		for i := range a {
 			s = b[i] - c[i]
 			a[i] = s ^ 3
@@ -239,20 +239,14 @@ func Chain(a, b, c, e []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/loop_shape.txt b/testdata/loop_shape.txt
index ca63c04..1430cdd 100644
--- a/testdata/loop_shape.txt
+++ b/testdata/loop_shape.txt
@@ -90,7 +90,7 @@ import (
 // Two statements and a temporary.
 func Mix(dst, a, b []int32, k int32) {
 	_vcInt32s0_1 := simd.BroadcastInt32s(k)
-	if _loopvecOverlap(a, dst) || _loopvecOverlap(b, dst) {
+	if _loopvecOverlap(a, dst, 0, len(a), 0, len(dst)) || _loopvecOverlap(b, dst, 0, len(b), 0, len(dst)) {
 		for i := range dst {
 			t := a[i]*k + b[i]
 			dst[i] = t ^ (t >> 3)
@@ -145,7 +145,7 @@ func Mix(dst, a, b []int32, k int32) {
 func Clamp(dst, a []float32, lo, hi float32) {
 	_vcFloat32s1_1 := simd.BroadcastFloat32s(lo)
 	_vcFloat32s1_3 := simd.BroadcastFloat32s(hi)
-	if _loopvecOverlap(a, dst) {
+	if _loopvecOverlap(a, dst, 0, len(a), 0, len(dst)) {
 		for i := range dst {
 			v := a[i]
 			if v < lo {
@@ -249,7 +249,7 @@ func Ahead(a, b []int32) {
 
 // Bytes: 64 lanes on AVX-512.
 func XorAdd(dst, a, b []uint8) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = (a[i] ^ b[i]) + a[i]
 		}
@@ -374,20 +374,14 @@ func XorHalves(a []uint16) uint16 {
 	return x
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/min_max_int.txt b/testdata/min_max_int.txt
index 2148504..573ec07 100644
--- a/testdata/min_max_int.txt
+++ b/testdata/min_max_int.txt
@@ -60,7 +60,7 @@ import (
 
 func ReluInt32s(dst, a []int32) {
 	_vcInt32s0 := simd.BroadcastInt32s(0)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = max(a[i], 0)
 		}
@@ -100,7 +100,7 @@ func ReluInt32s(dst, a []int32) {
 func ClampInt32s(dst, a []int32, lo, hi int32) {
 	_vcAInt32s1 := simd.BroadcastInt32s(lo)
 	_vcBInt32s1 := simd.BroadcastInt32s(hi)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = min(max(a[i], lo), hi)
 		}
@@ -138,7 +138,7 @@ func ClampInt32s(dst, a []int32, lo, hi int32) {
 }
 
 func MinUint8s(dst, a, b []uint8) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = min(a[i], b[i])
 		}
@@ -211,20 +211,14 @@ func FloorInt16s(a []int16, floor int16) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/mix_float32.txt b/testdata/mix_float32.txt
index afc1644..ab594ce 100644
--- a/testdata/mix_float32.txt
+++ b/testdata/mix_float32.txt
@@ -41,7 +41,7 @@ import (
 func MixFloat32s(dst, a, b []float32, alpha, beta float32) {
 	_vcAFloat32s0 := simd.BroadcastFloat32s(alpha)
 	_vcBFloat32s0 := simd.BroadcastFloat32s(beta)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i]*alpha + b[i]*beta
 		}
@@ -85,20 +85,14 @@ func MixFloat32s(dst, a, b []float32, alpha, beta float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/multi_store.txt b/testdata/multi_store.txt
index a9467ef..14ffa3f 100644
--- a/testdata/multi_store.txt
+++ b/testdata/multi_store.txt
@@ -219,20 +219,14 @@ func Fill(a, b, x []float64, n int) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/multiple_files.txt b/testdata/multiple_files.txt
index bd983fa..130c8ca 100644
--- a/testdata/multiple_files.txt
+++ b/testdata/multiple_files.txt
@@ -56,7 +56,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -100,20 +100,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 //go:build goexperiment.simd
 
@@ -122,7 +116,7 @@ package test
 import "simd"
 
 func MulInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] * b[i]
 		}
@@ -167,7 +161,7 @@ func MulInt32s(dst, a, b []int32) {
 }
 
 func SubInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] - b[i]
 		}
diff --git a/testdata/named_slice_type.txt b/testdata/named_slice_type.txt
index 1e42460..d43136d 100644
--- a/testdata/named_slice_type.txt
+++ b/testdata/named_slice_type.txt
@@ -72,7 +72,7 @@ func Ones(v Values) {
 }
 
 func AddValues(dst, a, b Values) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -116,20 +116,14 @@ func AddValues(dst, a, b Values) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/neg_float32.txt b/testdata/neg_float32.txt
index 89b6c14..343b3ae 100644
--- a/testdata/neg_float32.txt
+++ b/testdata/neg_float32.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func NegFloat32s(dst, src []float32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := range dst {
 			dst[i] = -src[i]
 		}
@@ -76,20 +76,14 @@ func NegFloat32s(dst, src []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/neg_signed_and_float_types.txt b/testdata/neg_signed_and_float_types.txt
index d7ae24e..c4c80e4 100644
--- a/testdata/neg_signed_and_float_types.txt
+++ b/testdata/neg_signed_and_float_types.txt
@@ -66,7 +66,7 @@ import (
 )
 
 func NegInt8s(dst, a []int8) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = -a[i]
 		}
@@ -104,7 +104,7 @@ func NegInt8s(dst, a []int8) {
 }
 
 func NegInt16s(dst, a []int16) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = -a[i]
 		}
@@ -142,7 +142,7 @@ func NegInt16s(dst, a []int16) {
 }
 
 func NegInt32s(dst, a []int32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = -a[i]
 		}
@@ -180,7 +180,7 @@ func NegInt32s(dst, a []int32) {
 }
 
 func NegInt64s(dst, a []int64) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = -a[i]
 		}
@@ -218,7 +218,7 @@ func NegInt64s(dst, a []int64) {
 }
 
 func NegFloat32s(dst, a []float32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = -a[i]
 		}
@@ -256,7 +256,7 @@ func NegFloat32s(dst, a []float32) {
 }
 
 func NegFloat64s(dst, a []float64) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = -a[i]
 		}
@@ -293,20 +293,14 @@ func NegFloat64s(dst, a []float64) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 6 loop(s) in $WORK/ops.go
diff --git a/testdata/not_int32.txt b/testdata/not_int32.txt
index 3c3c6b1..6fce7fc 100644
--- a/testdata/not_int32.txt
+++ b/testdata/not_int32.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func NotInt32s(dst, src []int32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := range dst {
 			dst[i] = ^src[i]
 		}
@@ -76,20 +76,14 @@ func NotInt32s(dst, src []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/not_integer_types.txt b/testdata/not_integer_types.txt
index 6770e06..4469baa 100644
--- a/testdata/not_integer_types.txt
+++ b/testdata/not_integer_types.txt
@@ -78,7 +78,7 @@ import (
 )
 
 func NotInt8s(dst, a []int8) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -116,7 +116,7 @@ func NotInt8s(dst, a []int8) {
 }
 
 func NotInt16s(dst, a []int16) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -154,7 +154,7 @@ func NotInt16s(dst, a []int16) {
 }
 
 func NotInt32s(dst, a []int32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -192,7 +192,7 @@ func NotInt32s(dst, a []int32) {
 }
 
 func NotInt64s(dst, a []int64) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -230,7 +230,7 @@ func NotInt64s(dst, a []int64) {
 }
 
 func NotUint8s(dst, a []uint8) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -268,7 +268,7 @@ func NotUint8s(dst, a []uint8) {
 }
 
 func NotUint16s(dst, a []uint16) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -306,7 +306,7 @@ func NotUint16s(dst, a []uint16) {
 }
 
 func NotUint32s(dst, a []uint32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -344,7 +344,7 @@ func NotUint32s(dst, a []uint32) {
 }
 
 func NotUint64s(dst, a []uint64) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = ^a[i]
 		}
@@ -381,20 +381,14 @@ func NotUint64s(dst, a []uint64) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 8 loop(s) in $WORK/ops.go
diff --git a/testdata/offset_read.txt b/testdata/offset_read.txt
index 306118b..7d7568b 100644
--- a/testdata/offset_read.txt
+++ b/testdata/offset_read.txt
@@ -184,7 +184,7 @@ func Smooth(dst, a []int32) {
 // The offset is a variable.
 func Shift(dst, a []int32, off int) {
 	_vcInt32s2 := simd.BroadcastInt32s(2)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := 0; i < len(dst); i++ {
 			dst[i] = a[i+off] * 2
 		}
@@ -223,7 +223,7 @@ func Shift(dst, a []int32, off int) {
 
 // A copy from an offset.
 func CopyShift(dst, src []int32) {
-	if _loopvecOverlap(dst, src) {
+	if _loopvecOverlap(dst, src, 0, len(dst), 0, len(src)) {
 		for i := 0; i < len(dst); i++ {
 			dst[i] = src[i+1]
 		}
@@ -298,20 +298,14 @@ func SumPairs(a []int32) int32 {
 	return s
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/offset_stored.txt b/testdata/offset_stored.txt
index 4986e61..bea91ed 100644
--- a/testdata/offset_stored.txt
+++ b/testdata/offset_stored.txt
@@ -323,20 +323,14 @@ func AddHalf(b, xx, a []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/paren_operands.txt b/testdata/paren_operands.txt
index 3efa13c..dc47dbf 100644
--- a/testdata/paren_operands.txt
+++ b/testdata/paren_operands.txt
@@ -52,7 +52,7 @@ import (
 func Normalize(dst, a []float64, mean, inv float64) {
 	_vcAFloat64s0 := simd.BroadcastFloat64s(mean)
 	_vcBFloat64s0 := simd.BroadcastFloat64s(inv)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = (a[i] - mean) * inv
 		}
@@ -91,7 +91,7 @@ func Normalize(dst, a []float64, mean, inv float64) {
 
 func SumScaled(dst, a, b []float32, k float32) {
 	_vcBFloat32s1 := simd.BroadcastFloat32s(k)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = (a[i] + b[i]) * k
 		}
@@ -136,7 +136,7 @@ func SumScaled(dst, a, b []float32, k float32) {
 }
 
 func Parens(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = (a[i]) + (b[i])
 		}
@@ -180,20 +180,14 @@ func Parens(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 3 loop(s) in $WORK/ops.go
diff --git a/testdata/range_value_multiplier.txt b/testdata/range_value_multiplier.txt
index 36e183c..b56b72a 100644
--- a/testdata/range_value_multiplier.txt
+++ b/testdata/range_value_multiplier.txt
@@ -103,20 +103,14 @@ func Mix(dst, a, b []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/range_value_sum.txt b/testdata/range_value_sum.txt
index c3ead5b..e3dbd7a 100644
--- a/testdata/range_value_sum.txt
+++ b/testdata/range_value_sum.txt
@@ -109,20 +109,14 @@ func IncrAdd(a, b, incr []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/readme_example.txt b/testdata/readme_example.txt
index 1128c93..b550e22 100644
--- a/testdata/readme_example.txt
+++ b/testdata/readme_example.txt
@@ -39,7 +39,7 @@ import (
 )
 
 func AddFloat32s(dst, a, b []float32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -83,20 +83,14 @@ func AddFloat32s(dst, a, b []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/readme_patterns.txt b/testdata/readme_patterns.txt
index 5f74f58..d0685f7 100644
--- a/testdata/readme_patterns.txt
+++ b/testdata/readme_patterns.txt
@@ -14,7 +14,7 @@ stdout -count=1 '^--- \S+/a/ops\.go\t'
 stdout -count=1 '^\+\+\+ \S+/a/ops\.go\t'
 stdout -count=1 '^--- \S+/b/ops\.go\t'
 stdout -count=1 '^\+\+\+ \S+/b/ops\.go\t'
-stdout -count=2 '^@@ -1,7 \+1,69 @@$'
+stdout -count=2 '^@@ -1,7 \+1,63 @@$'
 cmpenv stderr both.stderr
 cmp a/ops.go a/ops.go.orig
 cmp b/ops.go b/ops.go.orig
@@ -93,7 +93,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -137,20 +137,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stdout.want --
 //go:build goexperiment.simd
@@ -163,7 +157,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -207,20 +201,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 //go:build goexperiment.simd
 
@@ -232,7 +220,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -276,20 +264,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- both.stderr --
 loopvec: rewrote 1 loop(s) in $WORK/a/ops.go
diff --git a/testdata/reduce_int.txt b/testdata/reduce_int.txt
index 78bf266..97f60a2 100644
--- a/testdata/reduce_int.txt
+++ b/testdata/reduce_int.txt
@@ -516,7 +516,7 @@ func SumReverse(a []int16) int16 {
 func SumAndScale(dst, a []int32) int32 {
 	var sum int32
 	_vcInt32s9_1 := simd.BroadcastInt32s(3)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] * 3
 			sum += dst[i]
@@ -617,20 +617,14 @@ func SumValues(a []int32) int32 {
 	return sum
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/reverse_no_dependence.txt b/testdata/reverse_no_dependence.txt
index 0f033c0..acc0927 100644
--- a/testdata/reverse_no_dependence.txt
+++ b/testdata/reverse_no_dependence.txt
@@ -41,7 +41,7 @@ import (
 
 func FillFromReverse(a, b []float32) {
 	_vcFloat32s0 := simd.BroadcastFloat32s(1)
-	if _loopvecOverlap(a, b) {
+	if _loopvecOverlap(a, b, 0, len(a), 0, len(b)) {
 		for i := len(a) - 1; i >= 0; i-- {
 			a[i] = b[i] + 1
 		}
@@ -78,20 +78,14 @@ func FillFromReverse(a, b []float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/scalar_mul_range_value.txt b/testdata/scalar_mul_range_value.txt
index d1f71bb..5504dc5 100644
--- a/testdata/scalar_mul_range_value.txt
+++ b/testdata/scalar_mul_range_value.txt
@@ -78,20 +78,14 @@ func ScalFloat32s(dst, src []float32, f float32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/shift.txt b/testdata/shift.txt
index 2c850db..62f9c6e 100644
--- a/testdata/shift.txt
+++ b/testdata/shift.txt
@@ -66,7 +66,7 @@ import (
 )
 
 func ShlConst(dst, a []uint32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] << 3
 		}
@@ -104,7 +104,7 @@ func ShlConst(dst, a []uint32) {
 }
 
 func ShlWide(dst, a []uint32) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] << 40
 		}
@@ -142,7 +142,7 @@ func ShlWide(dst, a []uint32) {
 }
 
 func ShrVar(dst, a []int32, n uint) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] >> n
 		}
@@ -208,7 +208,7 @@ func ShlAssign(a []uint16) {
 }
 
 func ShrUint64(dst, a []uint64, n uint8) {
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = a[i] >> n
 		}
@@ -245,20 +245,14 @@ func ShrUint64(dst, a []uint64, n uint8) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main
diff --git a/testdata/split_generated_header.txt b/testdata/split_generated_header.txt
index 70e4da0..b4e6d6a 100644
--- a/testdata/split_generated_header.txt
+++ b/testdata/split_generated_header.txt
@@ -45,7 +45,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -89,20 +89,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- stderr.want --
 loopvec: rewrote 1 loop(s) in $WORK/ops.go
diff --git a/testdata/split_idempotent.txt b/testdata/split_idempotent.txt
index 1bc3b7f..c7a1816 100644
--- a/testdata/split_idempotent.txt
+++ b/testdata/split_idempotent.txt
@@ -35,7 +35,7 @@ import (
 )
 
 func AddInt32s(dst, a, b []int32) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = a[i] + b[i]
 		}
@@ -79,20 +79,14 @@ func AddInt32s(dst, a, b []int32) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- ops.go.guarded --
 //go:build !goexperiment.simd
diff --git a/testdata/wide_expression.txt b/testdata/wide_expression.txt
index 572cea2..8568056 100644
--- a/testdata/wide_expression.txt
+++ b/testdata/wide_expression.txt
@@ -70,7 +70,7 @@ import (
 
 // Depth 4: the histogram merge shape.
 func Merge(h, h0, h1, h2, h3 []uint16) {
-	if _loopvecOverlap(h, h0) || _loopvecOverlap(h, h1) || _loopvecOverlap(h, h2) || _loopvecOverlap(h, h3) {
+	if _loopvecOverlap(h, h0, 0, len(h), 0, len(h0)) || _loopvecOverlap(h, h1, 0, len(h), 0, len(h1)) || _loopvecOverlap(h, h2, 0, len(h), 0, len(h2)) || _loopvecOverlap(h, h3, 0, len(h), 0, len(h3)) {
 		for i := range h {
 			h[i] += h0[i] + h1[i] + h2[i] + h3[i]
 		}
@@ -138,7 +138,7 @@ func Merge(h, h0, h1, h2, h3 []uint16) {
 func Poly(dst, a, b, c []int32, k, m int32) {
 	_vcInt32s1_1 := simd.BroadcastInt32s(k)
 	_vcInt32s1_2 := simd.BroadcastInt32s(k * m)
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) || _loopvecOverlap(dst, c) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) || _loopvecOverlap(dst, c, 0, len(dst), 0, len(c)) {
 		for i := range dst {
 			dst[i] = a[i]*b[i] + c[i]*k + (k*m - a[i])
 		}
@@ -192,7 +192,7 @@ func Poly(dst, a, b, c []int32, k, m int32) {
 // A scalar on the left of a subtraction is not swapped.
 func SubFrom(dst, a []float64, k float64) {
 	_vcFloat64s2 := simd.BroadcastFloat64s(k)
-	if _loopvecOverlap(dst, a) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) {
 		for i := range dst {
 			dst[i] = k - a[i]
 		}
@@ -253,7 +253,7 @@ func FillVar(dst []float64, k float64) {
 }
 
 func ShiftSum(dst, a, b []uint32, n uint) {
-	if _loopvecOverlap(dst, a) || _loopvecOverlap(dst, b) {
+	if _loopvecOverlap(dst, a, 0, len(dst), 0, len(a)) || _loopvecOverlap(dst, b, 0, len(dst), 0, len(b)) {
 		for i := range dst {
 			dst[i] = (a[i] + b[i]) << n
 		}
@@ -297,20 +297,14 @@ func ShiftSum(dst, a, b []uint32, n uint) {
 	}
 }
 
-func _loopvecOverlap[T any](a, b []T, window ...int) bool {
-	aLo, aHi, bLo, bHi := 0, len(a), 0, len(b)
-	if len(window) == 4 {
-		aLo, aHi, bLo, bHi = window[0], window[1], window[2], window[3]
-	}
+func _loopvecOverlap[T any](a, b []T, aLo, aHi, bLo, bHi int) bool {
 	if aLo >= aHi || bLo >= bHi {
 		return false
 	}
 	size := unsafe.Sizeof(a[0])
 	aBase := uintptr(unsafe.Pointer(unsafe.SliceData(a)))
 	bBase := uintptr(unsafe.Pointer(unsafe.SliceData(b)))
-	aStart, aEnd := aBase+uintptr(aLo)*size, aBase+uintptr(aHi)*size
-	bStart, bEnd := bBase+uintptr(bLo)*size, bBase+uintptr(bHi)*size
-	return aStart < bEnd && bStart < aEnd
+	return aBase+uintptr(aLo)*size < bBase+uintptr(bHi)*size && bBase+uintptr(bLo)*size < aBase+uintptr(aHi)*size
 }
 -- testmain/main.go --
 package main