diff --git a/src/LoopVectorization.jl b/src/LoopVectorization.jl
index 42481b454..59d205b1b 100644
--- a/src/LoopVectorization.jl
+++ b/src/LoopVectorization.jl
@@ -53,7 +53,6 @@ const VECTORWIDTHSYMBOL, ELTYPESYMBOL = Symbol("##Wvecwidth##"), Symbol("##Tloop
 include("vectorizationbase_compat/contract_pass.jl")
 include("vectorizationbase_compat/subsetview.jl")
 include("getconstindexes.jl")
-# include("vectorizationbase_extensions.jl")
 include("predicates.jl")
 include("map.jl")
 include("filter.jl")
diff --git a/src/vectorizationbase_compat/contract_pass.jl b/src/vectorizationbase_compat/contract_pass.jl
index cec188cd5..e075c714a 100644
--- a/src/vectorizationbase_compat/contract_pass.jl
+++ b/src/vectorizationbase_compat/contract_pass.jl
@@ -1,15 +1,4 @@
 
-
-
-function check_negative(x)
-    x isa Expr || return false
-    x.head === :call || return false
-    length(x.args) == 2 || return false
-    a = first(x.args)
-    return (a === :(-) || a == :(Base.FastMath.sub_fast))
-end
-
-
 mulexprcost(::Number) = 0
 mulexprcost(::Symbol) = 1
 function mulexprcost(ex::Expr)
@@ -72,7 +61,6 @@ function recursive_muladd_search!(call, argv, cnmul::Bool = false, csub::Bool =
             f = first(exa)
             exav = @view(exa[2:end])
             if f === :* || f === :vmul! || f === :vmul || f == :(Base.FastMath.mul_fast)
-                # isnmul = any(check_negative, exav)
                 a, b = mulexpr(exav)
                 call.args[2] = a
                 call.args[3] = b
diff --git a/src/vectorizationbase_extensions.jl b/src/vectorizationbase_extensions.jl
deleted file mode 100644
index d365ed5a4..000000000
--- a/src/vectorizationbase_extensions.jl
+++ /dev/null
@@ -1,62 +0,0 @@
-
-# Rename file to offsetarrays?
-
-# If ndim(::OffsetArray) == 1, we can convert to a regular strided pointer and offset.
-@inline VectorizationBase.stridedpointer(a::OffsetArrays.OffsetArray{<:Any,1}) = gesp(stridedpointer(parent(a)), (-@inbounds(a.offsets[1]),))
-
-struct OffsetStridedPointer{T, N, P <: VectorizationBase.AbstractStridedPointer{T}} <: VectorizationBase.AbstractStridedPointer{T}
-    ptr::P
-    offsets::NTuple{N,Int}
-end
-# if ndim(A::OffsetArray) ≥ 2, then eachindex(A) isa Base.OneTo, index starting at 1.
-# but multiple indexing is calculated using offsets, so we need a special type to express this.
-@inline function VectorizationBase.stridedpointer(A::OffsetArrays.OffsetArray)
-    OffsetStridedPointer(stridedpointer(parent(A)), A.offsets)
-end
-
-@inline function VectorizationBase.stridedpointer(
-    B::Adjoint{T,A}
-) where {T,A<:OffsetArrays.OffsetArray{T}}
-    Boff = parent(B)
-    OffsetStridedPointer(
-        stridedpointer(parent(Boff)'),
-        Boff.offsets
-    )
-end
-
-@inline function VectorizationBase.stridedpointer_for_broadcast(A::OffsetArrays.OffsetArray)
-    OffsetStridedPointer(
-        VectorizationBase.stridedpointer_for_broadcast(parent(A)),
-        VectorizationBase.staticmul(T, VectorizationBase.filter_strides_by_dimequal1(Base.tail(size(A)), VectorizationBase.tailstrides(A)))
-    )
-end
-@inline function Base.transpose(A::OffsetStridedPointer)
-    OffsetStridedPointer(
-        transpose(A.ptr), A.offsets
-    )
-end
-# Tuple of length == 1, use ind directly.
-# @inline VectorizationBase.offset(ptr::OffsetStridedPointer, ind::Tuple{I}) where {I} = VectorizationBase.offset(ptr.ptr, ind)
-# Tuple of length > 1, subtract offsets.
-# @inline VectorizationBase.offset(ptr::OffsetStridedPointer{<:Any,N}, ind::Tuple) where {N} = VectorizationBase.offset(ptr.ptr, ntuple(n -> ind[n] + ptr.offsets[n], Val{N}()))
-@inline VectorizationBase.stride1offset(ptr::OffsetStridedPointer, ind::Tuple{I}) where {I} = VectorizationBase.stride1offset(ptr.ptr, ind)
-@inline VectorizationBase.stridedoffset(ptr::OffsetStridedPointer, ind::Tuple{I}) where {I} = VectorizationBase.stridedoffset(ptr.ptr, ind)
-# Tuple of length > 1, subtract offsets.
-@inline VectorizationBase.stride1offset(ptr::OffsetStridedPointer{<:Any,N}, ind::Tuple) where {N} = VectorizationBase.stride1offset(ptr.ptr, ntuple(n -> vsub(ind[n], ptr.offsets[n]), Val{N}()))
-@inline VectorizationBase.stridedoffset(ptr::OffsetStridedPointer{<:Any,N}, ind::Tuple) where {N} = VectorizationBase.stridedoffset(ptr.ptr, ntuple(n -> vsub(ind[n], ptr.offsets[n]), Val{N}()))
-@inline Base.similar(p::OffsetStridedPointer, ptr::Ptr) = OffsetStridedPointer(similar(p.ptr, ptr), p.offsets)
-@inline Base.pointer(p::OffsetStridedPointer) = pointer(p.ptr)
-@inline VectorizationBase.gesp(p::OffsetStridedPointer, i) = similar(p.ptr, gep(p, i))
-# @inline VectorizationBase.gesp(p::OffsetStridedPointer, i) = similar(p, gep(p.ptr, i))
-# If an OffsetArray is getting indexed by a (loop-)constant value, then this particular vptr object cannot also be eachindexed, so we can safely return a stridedpointer
-@inline function VectorizationBase.subsetview(ptr::OffsetStridedPointer{<:Any,N}, ::Val{I}, i) where {I,N}
-    subsetview(gesp(ptr.ptr, ntuple(n -> 0 - @inbounds(ptr.offsets[n]), Val{N}())), Val{I}(), i)
-end
-
-@inline function VectorizationBase.stride1offset(ptr::OffsetStridedPointer{<:Any,<:Any,<:VectorizationBase.AbstractBitPointer}, ind::Tuple{I}) where {I}
-    VectorizationBase.stride1offset(ptr.ptr, (vsub(ind[1], ptr.offsets[1]),))
-end
-@inline function VectorizationBase.stridedoffset(ptr::OffsetStridedPointer{<:Any,<:Any,<:VectorizationBase.AbstractBitPointer}, ind::Tuple{I}) where {I}
-    VectorizationBase.stridedoffset(ptr.ptr, (vsub(ind[1], ptr.offsets[1]),))
-end
-@inline VectorizationBase.gesp(ptr::VectorizationBase.AbstractBitPointer, i) = OffsetStridedPointer(ptr, vsub.(-1, unwrap.(i)))