diff --git a/internal/ailego/math/Makefile b/internal/ailego/math/Makefile
new file mode 100644
index 0000000..887dde3
--- /dev/null
+++ b/internal/ailego/math/Makefile
@@ -0,0 +1,29 @@
+GO ?= go
+GOAT ?= $(GO) tool goat
+GOAT_TARGET_AMD64 ?= amd64
+GOAT_TARGET_ARM64 ?= arm64
+GOAT_OUTPUT_DIR ?= .goat/mathutil
+MV ?= mv
+
+.PHONY: generate avx2 avx512 neon clean
+
+generate: avx2 avx512 neon clean
+
+avx2:
+	mkdir -p $(GOAT_OUTPUT_DIR)
+	$(GOAT) src/fht_avx2.c --target $(GOAT_TARGET_AMD64) -O3 -mavx2 -o $(GOAT_OUTPUT_DIR)
+	$(MV) $(GOAT_OUTPUT_DIR)/fht_avx2.go $(GOAT_OUTPUT_DIR)/fht_avx2.s .
+
+avx512:
+	mkdir -p $(GOAT_OUTPUT_DIR)
+	$(GOAT) src/fht_avx512.c --target $(GOAT_TARGET_AMD64) -O3 -mavx512f -mavx512dq -o $(GOAT_OUTPUT_DIR)
+	$(MV) $(GOAT_OUTPUT_DIR)/fht_avx512.go $(GOAT_OUTPUT_DIR)/fht_avx512.s .
+
+neon:
+	mkdir -p $(GOAT_OUTPUT_DIR)
+	$(GOAT) src/fht_neon.c --target $(GOAT_TARGET_ARM64) -O3 -o $(GOAT_OUTPUT_DIR)
+	$(MV) $(GOAT_OUTPUT_DIR)/fht_neon.go $(GOAT_OUTPUT_DIR)/fht_neon.s .
+
+clean:
+	$(RM) src/*.o src/*.s
+	$(RM) -r .goat
diff --git a/internal/ailego/math/fht.go b/internal/ailego/math/fht.go
index 5307dea..5313b18 100644
--- a/internal/ailego/math/fht.go
+++ b/internal/ailego/math/fht.go
@@ -24,16 +24,29 @@ var (
 	ErrShortSignBits    = errors.New("ailego: sign-bit buffer is too short")
 )
 
+type fhtUnaryKernel func(data []float32)
+type fhtFlipSignsKernel func(signs []byte, data []float32)
+
+type fhtKernels struct {
+	flipSigns      fhtFlipSignsKernel
+	kacWalk        fhtUnaryKernel
+	inverseKacWalk fhtUnaryKernel
+	inPlace        fhtUnaryKernel
+}
+
+var activeFHTKernels = fhtKernels{
+	flipSigns:      fhtFlipSignsScalar,
+	kacWalk:        fhtKacWalkScalar,
+	inverseKacWalk: fhtInverseKacWalkScalar,
+	inPlace:        fhtInPlaceScalar,
+}
+
 // FHTFlipSigns negates elements selected by the little-endian bits in signs.
 func FHTFlipSigns(signs []byte, data []float32) error {
 	if len(signs) < (len(data)+7)/8 {
 		return ErrShortSignBits
 	}
-	for index := range data {
-		if signs[index/8]&(1<<uint(index%8)) != 0 {
-			data[index] = -data[index]
-		}
-	}
+	activeFHTKernels.flipSigns(signs, data)
 	return nil
 }
 
@@ -42,6 +55,45 @@ func FHTInPlace(data []float32) error {
 	if len(data) == 0 || len(data)&(len(data)-1) != 0 {
 		return ErrInvalidFHTLength
 	}
+	activeFHTKernels.inPlace(data)
+	return nil
+}
+
+// FHTKacWalk performs the baseline pairwise Kac reduction for an arbitrary
+// non-empty length.
+func FHTKacWalk(data []float32) error {
+	if len(data) == 0 {
+		return ErrInvalidFHTLength
+	}
+	activeFHTKernels.kacWalk(data)
+	return nil
+}
+
+// FHTInverseKacWalk reverses FHTKacWalk.
+func FHTInverseKacWalk(data []float32) error {
+	if len(data) == 0 {
+		return ErrInvalidFHTLength
+	}
+	activeFHTKernels.inverseKacWalk(data)
+	return nil
+}
+
+// ScaleFloat32 multiplies data in place.
+func ScaleFloat32(data []float32, factor float32) {
+	for index := range data {
+		data[index] *= factor
+	}
+}
+
+func fhtFlipSignsScalar(signs []byte, data []float32) {
+	for index := range data {
+		if signs[index/8]&(1<<uint(index%8)) != 0 {
+			data[index] = -data[index]
+		}
+	}
+}
+
+func fhtInPlaceScalar(data []float32) {
 	for width := 1; width < len(data); width <<= 1 {
 		for block := 0; block < len(data); block += width << 1 {
 			for index := block; index < block+width; index++ {
@@ -51,15 +103,9 @@ func FHTInPlace(data []float32) error {
 			}
 		}
 	}
-	return nil
 }
 
-// FHTKacWalk performs the baseline pairwise Kac reduction for an arbitrary
-// non-empty length.
-func FHTKacWalk(data []float32) error {
-	if len(data) == 0 {
-		return ErrInvalidFHTLength
-	}
+func fhtKacWalkScalar(data []float32) {
 	half := len(data) / 2
 	base := len(data) % 2
 	offset := base + half
@@ -71,14 +117,9 @@ func FHTKacWalk(data []float32) error {
 	if base != 0 {
 		data[half] *= float32(math.Sqrt(2))
 	}
-	return nil
 }
 
-// FHTInverseKacWalk reverses FHTKacWalk.
-func FHTInverseKacWalk(data []float32) error {
-	if len(data) == 0 {
-		return ErrInvalidFHTLength
-	}
+func fhtInverseKacWalkScalar(data []float32) {
 	half := len(data) / 2
 	base := len(data) % 2
 	offset := base + half
@@ -90,12 +131,4 @@ func FHTInverseKacWalk(data []float32) error {
 		data[index] = (left + right) * .5
 		data[index+offset] = (left - right) * .5
 	}
-	return nil
-}
-
-// ScaleFloat32 multiplies data in place.
-func ScaleFloat32(data []float32, factor float32) {
-	for index := range data {
-		data[index] *= factor
-	}
 }
diff --git a/internal/ailego/math/fht_amd64.go b/internal/ailego/math/fht_amd64.go
new file mode 100644
index 0000000..0c0f2b8
--- /dev/null
+++ b/internal/ailego/math/fht_amd64.go
@@ -0,0 +1,121 @@
+//go:build !noasm && amd64
+
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mathutil
+
+import (
+	"math"
+	"unsafe"
+
+	"golang.org/x/sys/cpu"
+)
+
+//go:generate make avx2 avx512
+
+func init() {
+	switch {
+	case cpu.X86.HasAVX512F && cpu.X86.HasAVX512DQ:
+		activeFHTKernels = fhtKernels{
+			flipSigns:      fhtFlipSignsAVX512,
+			kacWalk:        fhtKacWalkAVX512,
+			inverseKacWalk: fhtInverseKacWalkAVX512,
+			inPlace:        fhtInPlaceAVX512,
+		}
+	case cpu.X86.HasAVX2:
+		activeFHTKernels = fhtKernels{
+			flipSigns:      fhtFlipSignsAVX2,
+			kacWalk:        fhtKacWalkAVX2,
+			inverseKacWalk: fhtInverseKacWalkAVX2,
+			inPlace:        fhtInPlaceAVX2,
+		}
+	}
+}
+
+func fhtFlipSignsAVX2(signs []byte, data []float32) {
+	if len(data) < 8 {
+		fhtFlipSignsScalar(signs, data)
+		return
+	}
+	xvec_avx2_fht_flip_signs(unsafe.Pointer(&signs[0]), unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtKacWalkAVX2(data []float32) {
+	if len(data)/2 < 8 {
+		fhtKacWalkScalar(data)
+		return
+	}
+	xvec_avx2_fht_kac_walk(unsafe.Pointer(&data[0]), int64(len(data)))
+	if len(data)%2 != 0 {
+		data[len(data)/2] *= float32(math.Sqrt2)
+	}
+}
+
+func fhtInverseKacWalkAVX2(data []float32) {
+	if len(data)/2 < 8 {
+		fhtInverseKacWalkScalar(data)
+		return
+	}
+	if len(data)%2 != 0 {
+		data[len(data)/2] *= float32(math.Sqrt(.5))
+	}
+	xvec_avx2_fht_inverse_kac_walk(unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtInPlaceAVX2(data []float32) {
+	if len(data) < 16 {
+		fhtInPlaceScalar(data)
+		return
+	}
+	xvec_avx2_fht_in_place(unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtFlipSignsAVX512(signs []byte, data []float32) {
+	if len(data) < 16 {
+		fhtFlipSignsScalar(signs, data)
+		return
+	}
+	xvec_avx512_fht_flip_signs(unsafe.Pointer(&signs[0]), unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtKacWalkAVX512(data []float32) {
+	if len(data)/2 < 16 {
+		fhtKacWalkScalar(data)
+		return
+	}
+	xvec_avx512_fht_kac_walk(unsafe.Pointer(&data[0]), int64(len(data)))
+	if len(data)%2 != 0 {
+		data[len(data)/2] *= float32(math.Sqrt2)
+	}
+}
+
+func fhtInverseKacWalkAVX512(data []float32) {
+	if len(data)/2 < 16 {
+		fhtInverseKacWalkScalar(data)
+		return
+	}
+	if len(data)%2 != 0 {
+		data[len(data)/2] *= float32(math.Sqrt(.5))
+	}
+	xvec_avx512_fht_inverse_kac_walk(unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtInPlaceAVX512(data []float32) {
+	if len(data) < 32 {
+		fhtInPlaceScalar(data)
+		return
+	}
+	xvec_avx512_fht_in_place(unsafe.Pointer(&data[0]), int64(len(data)))
+}
diff --git a/internal/ailego/math/fht_amd64_test.go b/internal/ailego/math/fht_amd64_test.go
new file mode 100644
index 0000000..c43fdc9
--- /dev/null
+++ b/internal/ailego/math/fht_amd64_test.go
@@ -0,0 +1,82 @@
+//go:build !noasm && amd64
+
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mathutil
+
+import (
+	"slices"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"golang.org/x/sys/cpu"
+)
+
+func TestFHTAVX2(t *testing.T) {
+	if !cpu.X86.HasAVX2 {
+		t.Skip("AVX2 is not supported")
+	}
+	testFHTKernels(t, fhtKernels{
+		flipSigns:      fhtFlipSignsAVX2,
+		kacWalk:        fhtKacWalkAVX2,
+		inverseKacWalk: fhtInverseKacWalkAVX2,
+		inPlace:        fhtInPlaceAVX2,
+	})
+}
+
+func TestFHTAVX512ScalarFallback(t *testing.T) {
+	signs := []byte{0b10100101, 0b01011010}
+	input := []float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
+	wantSigns := slices.Clone(input)
+	fhtFlipSignsScalar(signs, wantSigns)
+	gotSigns := slices.Clone(input)
+	fhtFlipSignsAVX512(signs, gotSigns)
+	require.Equal(t, wantSigns, gotSigns)
+
+	walkInput := make([]float32, 31)
+	for index := range walkInput {
+		walkInput[index] = float32(index + 1)
+	}
+	wantWalk := slices.Clone(walkInput)
+	fhtKacWalkScalar(wantWalk)
+	gotWalk := slices.Clone(walkInput)
+	fhtKacWalkAVX512(gotWalk)
+	require.Equal(t, wantWalk, gotWalk)
+
+	wantInverse := slices.Clone(wantWalk)
+	fhtInverseKacWalkScalar(wantInverse)
+	gotInverse := slices.Clone(gotWalk)
+	fhtInverseKacWalkAVX512(gotInverse)
+	require.Equal(t, wantInverse, gotInverse)
+
+	inPlaceInput := walkInput[:16]
+	wantInPlace := slices.Clone(inPlaceInput)
+	fhtInPlaceScalar(wantInPlace)
+	gotInPlace := slices.Clone(inPlaceInput)
+	fhtInPlaceAVX512(gotInPlace)
+	require.Equal(t, wantInPlace, gotInPlace)
+}
+
+func TestFHTAVX512(t *testing.T) {
+	if !cpu.X86.HasAVX512F || !cpu.X86.HasAVX512DQ {
+		t.Skip("AVX-512F and AVX-512DQ are not supported")
+	}
+	testFHTKernels(t, fhtKernels{
+		flipSigns:      fhtFlipSignsAVX512,
+		kacWalk:        fhtKacWalkAVX512,
+		inverseKacWalk: fhtInverseKacWalkAVX512,
+		inPlace:        fhtInPlaceAVX512,
+	})
+}
diff --git a/internal/ailego/math/fht_arm64.go b/internal/ailego/math/fht_arm64.go
new file mode 100644
index 0000000..194fdf6
--- /dev/null
+++ b/internal/ailego/math/fht_arm64.go
@@ -0,0 +1,75 @@
+//go:build !noasm && arm64
+
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mathutil
+
+import (
+	"math"
+	"unsafe"
+
+	"golang.org/x/sys/cpu"
+)
+
+//go:generate make neon
+
+func init() {
+	if cpu.ARM64.HasASIMD {
+		activeFHTKernels = fhtKernels{
+			flipSigns:      fhtFlipSignsNEON,
+			kacWalk:        fhtKacWalkNEON,
+			inverseKacWalk: fhtInverseKacWalkNEON,
+			inPlace:        fhtInPlaceNEON,
+		}
+	}
+}
+
+func fhtFlipSignsNEON(signs []byte, data []float32) {
+	if len(data) < 4 {
+		fhtFlipSignsScalar(signs, data)
+		return
+	}
+	xvec_neon_fht_flip_signs(unsafe.Pointer(&signs[0]), unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtKacWalkNEON(data []float32) {
+	if len(data)/2 < 4 {
+		fhtKacWalkScalar(data)
+		return
+	}
+	xvec_neon_fht_kac_walk(unsafe.Pointer(&data[0]), int64(len(data)))
+	if len(data)%2 != 0 {
+		data[len(data)/2] *= float32(math.Sqrt2)
+	}
+}
+
+func fhtInverseKacWalkNEON(data []float32) {
+	if len(data)/2 < 4 {
+		fhtInverseKacWalkScalar(data)
+		return
+	}
+	if len(data)%2 != 0 {
+		data[len(data)/2] *= float32(math.Sqrt(.5))
+	}
+	xvec_neon_fht_inverse_kac_walk(unsafe.Pointer(&data[0]), int64(len(data)))
+}
+
+func fhtInPlaceNEON(data []float32) {
+	if len(data) < 8 {
+		fhtInPlaceScalar(data)
+		return
+	}
+	xvec_neon_fht_in_place(unsafe.Pointer(&data[0]), int64(len(data)))
+}
diff --git a/internal/ailego/math/fht_arm64_test.go b/internal/ailego/math/fht_arm64_test.go
new file mode 100644
index 0000000..52d5c43
--- /dev/null
+++ b/internal/ailego/math/fht_arm64_test.go
@@ -0,0 +1,35 @@
+//go:build !noasm && arm64
+
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mathutil
+
+import (
+	"testing"
+
+	"golang.org/x/sys/cpu"
+)
+
+func TestFHTNEON(t *testing.T) {
+	if !cpu.ARM64.HasASIMD {
+		t.Skip("NEON is not supported")
+	}
+	testFHTKernels(t, fhtKernels{
+		flipSigns:      fhtFlipSignsNEON,
+		kacWalk:        fhtKacWalkNEON,
+		inverseKacWalk: fhtInverseKacWalkNEON,
+		inPlace:        fhtInPlaceNEON,
+	})
+}
diff --git a/internal/ailego/math/fht_avx2.go b/internal/ailego/math/fht_avx2.go
new file mode 100644
index 0000000..d06d7e8
--- /dev/null
+++ b/internal/ailego/math/fht_avx2.go
@@ -0,0 +1,23 @@
+//go:build !noasm && amd64
+// Code generated by GoAT. DO NOT EDIT.
+// versions:
+// 	clang   21.1.8 (6ubuntu1)
+// 	objdump 2.46
+// flags: -mavx2 -O3
+// source: src/fht_avx2.c
+
+package mathutil
+
+import "unsafe"
+
+//go:noescape
+func xvec_avx2_fht_flip_signs(signs, data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_avx2_fht_kac_walk(data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_avx2_fht_inverse_kac_walk(data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_avx2_fht_in_place(data unsafe.Pointer, size int64)
diff --git a/internal/ailego/math/fht_avx2.s b/internal/ailego/math/fht_avx2.s
new file mode 100644
index 0000000..85d8e18
--- /dev/null
+++ b/internal/ailego/math/fht_avx2.s
@@ -0,0 +1,880 @@
+//go:build !noasm && amd64
+// Code generated by GoAT. DO NOT EDIT.
+// versions:
+// 	clang   21.1.8 (6ubuntu1)
+// 	objdump 2.46
+// flags: -mavx2 -O3
+// source: src/fht_avx2.c
+
+TEXT ·xvec_avx2_fht_flip_signs(SB), $0-24
+	MOVQ signs+0(FP), DI
+	MOVQ data+8(FP), SI
+	MOVQ size+16(FP), DX
+	BYTE $0x55                             // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5               // movq	%rsp, %rbp
+	WORD $0x5741                           // pushq	%r15
+	WORD $0x5641                           // pushq	%r14
+	WORD $0x5541                           // pushq	%r13
+	WORD $0x5441                           // pushq	%r12
+	BYTE $0x53                             // pushq	%rbx
+	LONG $0xf8e48348                       // andq	$-8, %rsp
+	LONG $0x58ec8348                       // subq	$88, %rsp
+	LONG $0x247c8948; BYTE $0x28           // movq	%rdi, 40(%rsp)                  # 8-byte Spill
+	WORD $0x8949; BYTE $0xd1               // movq	%rdx, %r9
+	LONG $0xe0e18349                       // andq	$-32, %r9
+	LONG $0x24548948; BYTE $0x30           // movq	%rdx, 48(%rsp)                  # 8-byte Spill
+	LONG $0x20fa8348                       // cmpq	$32, %rdx
+	JL   LBB0_3
+	WORD $0x3145; BYTE $0xc0               // xorl	%r8d, %r8d
+	LONG $0x24448b48; BYTE $0x28           // movq	40(%rsp), %rax                  # 8-byte Reload
+	LONG $0x244c894c; BYTE $0x38           // movq	%r9, 56(%rsp)                   # 8-byte Spill
+	LONG $0x24348948                       // movq	%rsi, (%rsp)                    # 8-byte Spill
+	QUAD $0x000000000000bc49; WORD $0x8000 // movabsq	$-9223372036854775808, %r12     # imm = 0x8000000000000000
+
+LBB0_2:
+	LONG $0x24448948; BYTE $0x50               // movq	%rax, 80(%rsp)                  # 8-byte Spill
+	WORD $0x8b44; BYTE $0x38                   // movl	(%rax), %r15d
+	WORD $0x894c; BYTE $0xf8                   // movq	%r15, %rax
+	WORD $0x8944; BYTE $0xfa                   // movl	%r15d, %edx
+	WORD $0x894d; BYTE $0xfa                   // movq	%r15, %r10
+	WORD $0x8945; BYTE $0xfe                   // movl	%r15d, %r14d
+	WORD $0x894c; BYTE $0xff                   // movq	%r15, %rdi
+	WORD $0x8945; BYTE $0xf9                   // movl	%r15d, %r9d
+	WORD $0x894d; BYTE $0xfd                   // movq	%r15, %r13
+	WORD $0x8945; BYTE $0xfb                   // movl	%r15d, %r11d
+	WORD $0x8944; BYTE $0xf9                   // movl	%r15d, %ecx
+	WORD $0x8944; BYTE $0xfe                   // movl	%r15d, %esi
+	LONG $0x24748948; BYTE $0x48               // movq	%rsi, 72(%rsp)                  # 8-byte Spill
+	LONG $0x24748948; BYTE $0x40               // movq	%rsi, 64(%rsp)                  # 8-byte Spill
+	WORD $0xe6c1; BYTE $0x1f                   // shll	$31, %esi
+	LONG $0x3ee0c148                           // shlq	$62, %rax
+	WORD $0x214c; BYTE $0xe0                   // andq	%r12, %rax
+	WORD $0x0948; BYTE $0xf0                   // orq	%rsi, %rax
+	WORD $0x8944; BYTE $0xfb                   // movl	%r15d, %ebx
+	WORD $0xe283; BYTE $0xfc                   // andl	$-4, %edx
+	LONG $0x3ce2c149                           // shlq	$60, %r10
+	WORD $0xe2c1; BYTE $0x1d                   // shll	$29, %edx
+	WORD $0x214d; BYTE $0xe2                   // andq	%r12, %r10
+	WORD $0x0949; BYTE $0xd2                   // orq	%rdx, %r10
+	WORD $0x8944; BYTE $0xfa                   // movl	%r15d, %edx
+	LONG $0x24448948; BYTE $0x20               // movq	%rax, 32(%rsp)
+	WORD $0x8944; BYTE $0xfe                   // movl	%r15d, %esi
+	LONG $0xf0e68341                           // andl	$-16, %r14d
+	LONG $0x3ae7c148                           // shlq	$58, %rdi
+	LONG $0x1be6c141                           // shll	$27, %r14d
+	WORD $0x214c; BYTE $0xe7                   // andq	%r12, %rdi
+	WORD $0x094c; BYTE $0xf7                   // orq	%r14, %rdi
+	WORD $0x8944; BYTE $0xf8                   // movl	%r15d, %eax
+	LONG $0x2454894c; BYTE $0x18               // movq	%r10, 24(%rsp)
+	WORD $0x8945; BYTE $0xfa                   // movl	%r15d, %r10d
+	LONG $0xc0e18341                           // andl	$-64, %r9d
+	LONG $0x38e5c149                           // shlq	$56, %r13
+	LONG $0x19e1c141                           // shll	$25, %r9d
+	WORD $0x214d; BYTE $0xe5                   // andq	%r12, %r13
+	WORD $0x094d; BYTE $0xcd                   // orq	%r9, %r13
+	WORD $0x8945; BYTE $0xf9                   // movl	%r15d, %r9d
+	LONG $0x247c8948; BYTE $0x10               // movq	%rdi, 16(%rsp)
+	LONG $0x08ebc141                           // shrl	$8, %r11d
+	WORD $0x8944; BYTE $0xdf                   // movl	%r11d, %edi
+	WORD $0xe7c1; BYTE $0x1f                   // shll	$31, %edi
+	LONG $0x246c894c; BYTE $0x08               // movq	%r13, 8(%rsp)
+	WORD $0x894d; BYTE $0xdd                   // movq	%r11, %r13
+	LONG $0x3ee5c149                           // shlq	$62, %r13
+	WORD $0x214d; BYTE $0xe5                   // andq	%r12, %r13
+	WORD $0x0949; BYTE $0xfd                   // orq	%rdi, %r13
+	WORD $0xe1c1; BYTE $0x15                   // shll	$21, %ecx
+	LONG $0x0000e181; WORD $0x8000             // andl	$-2147483648, %ecx              # imm = 0x80000000
+	WORD $0x894d; BYTE $0xde                   // movq	%r11, %r14
+	LONG $0x3ce6c149                           // shlq	$60, %r14
+	WORD $0x214d; BYTE $0xe6                   // andq	%r12, %r14
+	WORD $0x0949; BYTE $0xce                   // orq	%rcx, %r14
+	QUAD $0x00000000fd0c8d42                   // leal	(,%r15,8), %ecx
+	LONG $0x4410fbc5; WORD $0x0824             // vmovsd	8(%rsp), %xmm0                  # xmm0 = mem[0],zero
+	LONG $0x4c10fbc5; WORD $0x1024             // vmovsd	16(%rsp), %xmm1                 # xmm1 = mem[0],zero
+	LONG $0x5410fbc5; WORD $0x1824             // vmovsd	24(%rsp), %xmm2                 # xmm2 = mem[0],zero
+	LONG $0x5c10fbc5; WORD $0x2024             // vmovsd	32(%rsp), %xmm3                 # xmm3 = mem[0],zero
+	LONG $0xc016f0c5                           // vmovlhps	%xmm0, %xmm1, %xmm0             # xmm0 = xmm1[0],xmm0[0]
+	LONG $0xca16e0c5                           // vmovlhps	%xmm2, %xmm3, %xmm1             # xmm1 = xmm3[0],xmm2[0]
+	LONG $0x1875e3c4; WORD $0x01c0             // vinsertf128	$1, %xmm0, %ymm1, %ymm0
+	LONG $0x243c8b48                           // movq	(%rsp), %rdi                    # 8-byte Reload
+	LONG $0x577ca1c4; WORD $0x8704             // vxorps	(%rdi,%r8,4), %ymm0, %ymm0
+	LONG $0x3f3c8d43                           // leal	(%r15,%r15), %edi
+	LONG $0x243c8b4c                           // movq	(%rsp), %r15                    # 8-byte Reload
+	LONG $0x117c81c4; WORD $0x8704             // vmovups	%ymm0, (%r15,%r8,4)
+	LONG $0x247c8b4c; BYTE $0x48               // movq	72(%rsp), %r15                  # 8-byte Reload
+	LONG $0x13e7c141                           // shll	$19, %r15d
+	LONG $0x246c894c; BYTE $0x20               // movq	%r13, 32(%rsp)
+	LONG $0x00e78141; WORD $0x0000; BYTE $0x80 // andl	$-2147483648, %r15d             # imm = 0x80000000
+	WORD $0x894d; BYTE $0xfd                   // movq	%r15, %r13
+	WORD $0x894d; BYTE $0xdf                   // movq	%r11, %r15
+	LONG $0x3ae7c149                           // shlq	$58, %r15
+	WORD $0x214d; BYTE $0xe7                   // andq	%r12, %r15
+	WORD $0x094d; BYTE $0xef                   // orq	%r13, %r15
+	LONG $0x246c8b4c; BYTE $0x40               // movq	64(%rsp), %r13                  # 8-byte Reload
+	LONG $0x11e5c141                           // shll	$17, %r13d
+	LONG $0x00e58141; WORD $0x0000; BYTE $0x80 // andl	$-2147483648, %r13d             # imm = 0x80000000
+	LONG $0x2474894c; BYTE $0x18               // movq	%r14, 24(%rsp)
+	LONG $0x38e3c149                           // shlq	$56, %r11
+	WORD $0x214d; BYTE $0xe3                   // andq	%r12, %r11
+	WORD $0x094d; BYTE $0xeb                   // orq	%r13, %r11
+	LONG $0x247c894c; BYTE $0x10               // movq	%r15, 16(%rsp)
+	LONG $0x245c894c; BYTE $0x08               // movq	%r11, 8(%rsp)
+	LONG $0x4410fbc5; WORD $0x0824             // vmovsd	8(%rsp), %xmm0                  # xmm0 = mem[0],zero
+	LONG $0x4c10fbc5; WORD $0x1024             // vmovsd	16(%rsp), %xmm1                 # xmm1 = mem[0],zero
+	LONG $0xc016f0c5                           // vmovlhps	%xmm0, %xmm1, %xmm0             # xmm0 = xmm1[0],xmm0[0]
+	LONG $0x4c10fbc5; WORD $0x1824             // vmovsd	24(%rsp), %xmm1                 # xmm1 = mem[0],zero
+	LONG $0x5410fbc5; WORD $0x2024             // vmovsd	32(%rsp), %xmm2                 # xmm2 = mem[0],zero
+	LONG $0xc916e8c5                           // vmovlhps	%xmm1, %xmm2, %xmm1             # xmm1 = xmm2[0],xmm1[0]
+	LONG $0x1875e3c4; WORD $0x01c0             // vinsertf128	$1, %xmm0, %ymm1, %ymm0
+	LONG $0x241c8b4c                           // movq	(%rsp), %r11                    # 8-byte Reload
+	LONG $0x577c81c4; WORD $0x8344; BYTE $0x20 // vxorps	32(%r11,%r8,4), %ymm0, %ymm0
+	WORD $0xebc1; BYTE $0x10                   // shrl	$16, %ebx
+	WORD $0x8941; BYTE $0xdb                   // movl	%ebx, %r11d
+	LONG $0x1fe3c141                           // shll	$31, %r11d
+	WORD $0x8949; BYTE $0xde                   // movq	%rbx, %r14
+	LONG $0x3ee6c149                           // shlq	$62, %r14
+	WORD $0x214d; BYTE $0xe6                   // andq	%r12, %r14
+	WORD $0xe2c1; BYTE $0x0d                   // shll	$13, %edx
+	LONG $0x0000e281; WORD $0x8000             // andl	$-2147483648, %edx              # imm = 0x80000000
+	WORD $0x8949; BYTE $0xdf                   // movq	%rbx, %r15
+	WORD $0x094d; BYTE $0xde                   // orq	%r11, %r14
+	LONG $0x3ce7c149                           // shlq	$60, %r15
+	WORD $0x214d; BYTE $0xe7                   // andq	%r12, %r15
+	WORD $0x0949; BYTE $0xd7                   // orq	%rdx, %r15
+	LONG $0x24148b48                           // movq	(%rsp), %rdx                    # 8-byte Reload
+	LONG $0x117ca1c4; WORD $0x8244; BYTE $0x20 // vmovups	%ymm0, 32(%rdx,%r8,4)
+	WORD $0xe6c1; BYTE $0x0b                   // shll	$11, %esi
+	LONG $0x0000e681; WORD $0x8000             // andl	$-2147483648, %esi              # imm = 0x80000000
+	WORD $0x8948; BYTE $0xda                   // movq	%rbx, %rdx
+	LONG $0x2474894c; BYTE $0x20               // movq	%r14, 32(%rsp)
+	LONG $0x3ae2c148                           // shlq	$58, %rdx
+	WORD $0x214c; BYTE $0xe2                   // andq	%r12, %rdx
+	WORD $0x0948; BYTE $0xf2                   // orq	%rsi, %rdx
+	LONG $0x247c894c; BYTE $0x18               // movq	%r15, 24(%rsp)
+	WORD $0xe0c1; BYTE $0x09                   // shll	$9, %eax
+	LONG $0x00000025; BYTE $0x80               // andl	$-2147483648, %eax              # imm = 0x80000000
+	LONG $0x38e3c148                           // shlq	$56, %rbx
+	LONG $0x24548948; BYTE $0x10               // movq	%rdx, 16(%rsp)
+	WORD $0x214c; BYTE $0xe3                   // andq	%r12, %rbx
+	WORD $0x0948; BYTE $0xc3                   // orq	%rax, %rbx
+	LONG $0x245c8948; BYTE $0x08               // movq	%rbx, 8(%rsp)
+	LONG $0x4410fbc5; WORD $0x0824             // vmovsd	8(%rsp), %xmm0                  # xmm0 = mem[0],zero
+	LONG $0x4c10fbc5; WORD $0x1024             // vmovsd	16(%rsp), %xmm1                 # xmm1 = mem[0],zero
+	LONG $0x5410fbc5; WORD $0x1824             // vmovsd	24(%rsp), %xmm2                 # xmm2 = mem[0],zero
+	LONG $0x5c10fbc5; WORD $0x2024             // vmovsd	32(%rsp), %xmm3                 # xmm3 = mem[0],zero
+	LONG $0xc016f0c5                           // vmovlhps	%xmm0, %xmm1, %xmm0             # xmm0 = xmm1[0],xmm0[0]
+	LONG $0xca16e0c5                           // vmovlhps	%xmm2, %xmm3, %xmm1             # xmm1 = xmm3[0],xmm2[0]
+	LONG $0x1875e3c4; WORD $0x01c0             // vinsertf128	$1, %xmm0, %ymm1, %ymm0
+	LONG $0x24048b48                           // movq	(%rsp), %rax                    # 8-byte Reload
+	LONG $0x577ca1c4; WORD $0x8044; BYTE $0x40 // vxorps	64(%rax,%r8,4), %ymm0, %ymm0
+	LONG $0x18eac141                           // shrl	$24, %r10d
+	WORD $0x8944; BYTE $0xd0                   // movl	%r10d, %eax
+	WORD $0x894c; BYTE $0xd2                   // movq	%r10, %rdx
+	WORD $0xe0c1; BYTE $0x1f                   // shll	$31, %eax
+	LONG $0x3ee2c148                           // shlq	$62, %rdx
+	LONG $0x05e1c141                           // shll	$5, %r9d
+	LONG $0x00e18141; WORD $0x0000; BYTE $0x80 // andl	$-2147483648, %r9d              # imm = 0x80000000
+	WORD $0x214c; BYTE $0xe2                   // andq	%r12, %rdx
+	WORD $0x894c; BYTE $0xd6                   // movq	%r10, %rsi
+	LONG $0x3ce6c148                           // shlq	$60, %rsi
+	WORD $0x214c; BYTE $0xe6                   // andq	%r12, %rsi
+	WORD $0x0948; BYTE $0xc2                   // orq	%rax, %rdx
+	WORD $0x094c; BYTE $0xce                   // orq	%r9, %rsi
+	LONG $0x244c8b4c; BYTE $0x38               // movq	56(%rsp), %r9                   # 8-byte Reload
+	LONG $0x24048b48                           // movq	(%rsp), %rax                    # 8-byte Reload
+	LONG $0x117ca1c4; WORD $0x8044; BYTE $0x40 // vmovups	%ymm0, 64(%rax,%r8,4)
+	LONG $0x0000e181; WORD $0x8000             // andl	$-2147483648, %ecx              # imm = 0x80000000
+	LONG $0x24548948; BYTE $0x20               // movq	%rdx, 32(%rsp)
+	WORD $0x894c; BYTE $0xd0                   // movq	%r10, %rax
+	LONG $0x3ae0c148                           // shlq	$58, %rax
+	WORD $0x214c; BYTE $0xe0                   // andq	%r12, %rax
+	LONG $0x24748948; BYTE $0x18               // movq	%rsi, 24(%rsp)
+	WORD $0x0948; BYTE $0xc8                   // orq	%rcx, %rax
+	LONG $0x0000e781; WORD $0x8000             // andl	$-2147483648, %edi              # imm = 0x80000000
+	LONG $0x38e2c149                           // shlq	$56, %r10
+	LONG $0x24448948; BYTE $0x10               // movq	%rax, 16(%rsp)
+	LONG $0x24448b48; BYTE $0x50               // movq	80(%rsp), %rax                  # 8-byte Reload
+	LONG $0x24348b48                           // movq	(%rsp), %rsi                    # 8-byte Reload
+	WORD $0x214d; BYTE $0xe2                   // andq	%r12, %r10
+	WORD $0x0949; BYTE $0xfa                   // orq	%rdi, %r10
+	LONG $0x2454894c; BYTE $0x08               // movq	%r10, 8(%rsp)
+	LONG $0x4410fbc5; WORD $0x0824             // vmovsd	8(%rsp), %xmm0                  # xmm0 = mem[0],zero
+	LONG $0x4c10fbc5; WORD $0x1024             // vmovsd	16(%rsp), %xmm1                 # xmm1 = mem[0],zero
+	LONG $0x5410fbc5; WORD $0x1824             // vmovsd	24(%rsp), %xmm2                 # xmm2 = mem[0],zero
+	LONG $0x5c10fbc5; WORD $0x2024             // vmovsd	32(%rsp), %xmm3                 # xmm3 = mem[0],zero
+	LONG $0xc016f0c5                           // vmovlhps	%xmm0, %xmm1, %xmm0             # xmm0 = xmm1[0],xmm0[0]
+	LONG $0xca16e0c5                           // vmovlhps	%xmm2, %xmm3, %xmm1             # xmm1 = xmm3[0],xmm2[0]
+	LONG $0x1875e3c4; WORD $0x01c0             // vinsertf128	$1, %xmm0, %ymm1, %ymm0
+	LONG $0x577ca1c4; WORD $0x8644; BYTE $0x60 // vxorps	96(%rsi,%r8,4), %ymm0, %ymm0
+	LONG $0x117ca1c4; WORD $0x8644; BYTE $0x60 // vmovups	%ymm0, 96(%rsi,%r8,4)
+	LONG $0x20c08349                           // addq	$32, %r8
+	LONG $0x04c08348                           // addq	$4, %rax
+	WORD $0x394d; BYTE $0xc8                   // cmpq	%r9, %r8
+	JL   LBB0_2
+
+LBB0_3:
+	LONG $0x24548b4c; BYTE $0x30 // movq	48(%rsp), %r10                  # 8-byte Reload
+	WORD $0x394d; BYTE $0xd1     // cmpq	%r10, %r9
+	LONG $0x24448b4c; BYTE $0x28 // movq	40(%rsp), %r8                   # 8-byte Reload
+	JNE  LBB0_4
+
+LBB0_8:
+	LONG $0xd8658d48         // leaq	-40(%rbp), %rsp
+	BYTE $0x5b               // popq	%rbx
+	WORD $0x5c41             // popq	%r12
+	WORD $0x5d41             // popq	%r13
+	WORD $0x5e41             // popq	%r14
+	WORD $0x5f41             // popq	%r15
+	BYTE $0x5d               // popq	%rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
+
+LBB0_4:
+	WORD $0x8948; BYTE $0xf7 // movq	%rsi, %rdi
+	JMP  LBB0_5
+
+LBB0_7:
+	WORD $0xff49; BYTE $0xc1 // incq	%r9
+	WORD $0x394d; BYTE $0xd1 // cmpq	%r10, %r9
+	JGE  LBB0_8
+
+LBB0_5:
+	LONG $0x07418d49               // leaq	7(%r9), %rax
+	WORD $0x854d; BYTE $0xc9       // testq	%r9, %r9
+	LONG $0xc1490f49               // cmovnsq	%r9, %rax
+	LONG $0x03f8c148               // sarq	$3, %rax
+	LONG $0x0cb60f41; BYTE $0x00   // movzbl	(%r8,%rax), %ecx
+	WORD $0xe0c1; BYTE $0x03       // shll	$3, %eax
+	WORD $0x8944; BYTE $0xca       // movl	%r9d, %edx
+	WORD $0xc229                   // subl	%eax, %edx
+	WORD $0xa30f; BYTE $0xd1       // btl	%edx, %ecx
+	JAE  LBB0_7
+	LONG $0x8f748042; WORD $0x8003 // xorb	$-128, 3(%rdi,%r9,4)
+	JMP  LBB0_7
+
+TEXT ·xvec_avx2_fht_kac_walk(SB), $0-16
+	MOVQ data+0(FP), DI
+	MOVQ size+8(FP), SI
+	WORD $0x8948; BYTE $0xf0 // movq	%rsi, %rax
+	LONG $0x3fe8c148         // shrq	$63, %rax
+	WORD $0x0148; BYTE $0xf0 // addq	%rsi, %rax
+	WORD $0xd148; BYTE $0xf8 // sarq	%rax
+	WORD $0x8948; BYTE $0xc2 // movq	%rax, %rdx
+	LONG $0xf8e28348         // andq	$-8, %rdx
+	LONG $0x10fe8348         // cmpq	$16, %rsi
+	JL   LBB1_3
+	QUAD $0x0000000085048d4c // leaq	(,%rax,4), %r8
+	LONG $0xb70c8d48         // leaq	(%rdi,%rsi,4), %rcx
+	WORD $0x294c; BYTE $0xc1 // subq	%r8, %rcx
+	WORD $0x3145; BYTE $0xc0 // xorl	%r8d, %r8d
+
+LBB1_2:
+	LONG $0x107ca1c4; WORD $0x8704 // vmovups	(%rdi,%r8,4), %ymm0
+	LONG $0x107ca1c4; WORD $0x810c // vmovups	(%rcx,%r8,4), %ymm1
+	LONG $0xd158fcc5               // vaddps	%ymm1, %ymm0, %ymm2
+	LONG $0x117ca1c4; WORD $0x8714 // vmovups	%ymm2, (%rdi,%r8,4)
+	LONG $0xc15cfcc5               // vsubps	%ymm1, %ymm0, %ymm0
+	LONG $0x117ca1c4; WORD $0x8104 // vmovups	%ymm0, (%rcx,%r8,4)
+	LONG $0x08c08349               // addq	$8, %r8
+	WORD $0x3949; BYTE $0xd0       // cmpq	%rdx, %r8
+	JL   LBB1_2
+
+LBB1_3:
+	WORD $0x3948; BYTE $0xc2               // cmpq	%rax, %rdx
+	JE   LBB1_16
+	BYTE $0x55                             // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5               // movq	%rsp, %rbp
+	BYTE $0x53                             // pushq	%rbx
+	LONG $0xf8e48348                       // andq	$-8, %rsp
+	WORD $0x8949; BYTE $0xd1               // movq	%rdx, %r9
+	LONG $0x01c98349                       // orq	$1, %r9
+	WORD $0x394c; BYTE $0xc8               // cmpq	%r9, %rax
+	WORD $0x894d; BYTE $0xc8               // movq	%r9, %r8
+	LONG $0xc04f0f4c                       // cmovgq	%rax, %r8
+	WORD $0x894c; BYTE $0xc1               // movq	%r8, %rcx
+	WORD $0x2948; BYTE $0xd1               // subq	%rdx, %rcx
+	LONG $0x03f98348                       // cmpq	$3, %rcx
+	JBE  LBB1_5
+	LONG $0x97148d4c                       // leaq	(%rdi,%rdx,4), %r10
+	WORD $0x394c; BYTE $0xc8               // cmpq	%r9, %rax
+	LONG $0xc84f0f4c                       // cmovgq	%rax, %r9
+	LONG $0x0e1c8d4e                       // leaq	(%rsi,%r9), %r11
+	WORD $0x2949; BYTE $0xc3               // subq	%rax, %r11
+	LONG $0x9f1c8d4e                       // leaq	(%rdi,%r11,4), %r11
+	WORD $0x394d; BYTE $0xda               // cmpq	%r11, %r10
+	JAE  LBB1_10
+	LONG $0x8f0c8d4e                       // leaq	(%rdi,%r9,4), %r9
+	QUAD $0xfffffffffff8ba49; WORD $0x3fff // movabsq	$4611686018427387896, %r10      # imm = 0x3FFFFFFFFFFFFFF8
+	WORD $0x2149; BYTE $0xc2               // andq	%rax, %r10
+	WORD $0x0149; BYTE $0xf2               // addq	%rsi, %r10
+	WORD $0x2949; BYTE $0xc2               // subq	%rax, %r10
+	LONG $0x97148d4e                       // leaq	(%rdi,%r10,4), %r10
+	WORD $0x394d; BYTE $0xca               // cmpq	%r9, %r10
+	JAE  LBB1_10
+
+LBB1_5:
+	WORD $0x8948; BYTE $0xd1 // movq	%rdx, %rcx
+
+LBB1_6:
+	QUAD $0x0000000085048d4c // leaq	(,%rax,4), %r8
+	LONG $0xb7148d48         // leaq	(%rdi,%rsi,4), %rdx
+	WORD $0x294c; BYTE $0xc2 // subq	%r8, %rdx
+
+LBB1_7:
+	LONG $0x0410fac5; BYTE $0x8f // vmovss	(%rdi,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x0c10fac5; BYTE $0x8a // vmovss	(%rdx,%rcx,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5             // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x1411fac5; BYTE $0x8f // vmovss	%xmm2, (%rdi,%rcx,4)
+	LONG $0xc15cfac5             // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x0411fac5; BYTE $0x8a // vmovss	%xmm0, (%rdx,%rcx,4)
+	WORD $0xff48; BYTE $0xc1     // incq	%rcx
+	WORD $0x3948; BYTE $0xc1     // cmpq	%rax, %rcx
+	JL   LBB1_7
+
+LBB1_15:
+	LONG $0xf8658d48 // leaq	-8(%rbp), %rsp
+	BYTE $0x5b       // popq	%rbx
+	BYTE $0x5d       // popq	%rbp
+
+LBB1_16:
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
+
+LBB1_10:
+	LONG $0x10f98348         // cmpq	$16, %rcx
+	JAE  LBB1_17
+	WORD $0x3145; BYTE $0xc9 // xorl	%r9d, %r9d
+	JMP  LBB1_12
+
+LBB1_17:
+	WORD $0x8949; BYTE $0xc9 // movq	%rcx, %r9
+	LONG $0xf0e18349         // andq	$-16, %r9
+	QUAD $0x00000000851c8d4c // leaq	(,%rax,4), %r11
+	QUAD $0x00000000b5148d4c // leaq	(,%rsi,4), %r10
+	WORD $0x294d; BYTE $0xda // subq	%r11, %r10
+	LONG $0xe0e38349         // andq	$-32, %r11
+	WORD $0x0149; BYTE $0xfb // addq	%rdi, %r11
+	LONG $0x20c38349         // addq	$32, %r11
+	WORD $0x894c; BYTE $0xcb // movq	%r9, %rbx
+
+LBB1_18:
+	LONG $0x107cc1c4; WORD $0xe043             // vmovups	-32(%r11), %ymm0
+	LONG $0x107cc1c4; BYTE $0x0b               // vmovups	(%r11), %ymm1
+	LONG $0x107c81c4; WORD $0x1354; BYTE $0xe0 // vmovups	-32(%r11,%r10), %ymm2
+	LONG $0x107c81c4; WORD $0x131c             // vmovups	(%r11,%r10), %ymm3
+	LONG $0xe258fcc5                           // vaddps	%ymm2, %ymm0, %ymm4
+	LONG $0xeb58f4c5                           // vaddps	%ymm3, %ymm1, %ymm5
+	LONG $0x117cc1c4; WORD $0xe063             // vmovups	%ymm4, -32(%r11)
+	LONG $0x117cc1c4; BYTE $0x2b               // vmovups	%ymm5, (%r11)
+	LONG $0xc25cfcc5                           // vsubps	%ymm2, %ymm0, %ymm0
+	LONG $0xcb5cf4c5                           // vsubps	%ymm3, %ymm1, %ymm1
+	LONG $0x117c81c4; WORD $0x1344; BYTE $0xe0 // vmovups	%ymm0, -32(%r11,%r10)
+	LONG $0x117c81c4; WORD $0x130c             // vmovups	%ymm1, (%r11,%r10)
+	LONG $0x40c38349                           // addq	$64, %r11
+	LONG $0xf0c38348                           // addq	$-16, %rbx
+	JNE  LBB1_18
+	WORD $0x394c; BYTE $0xc9                   // cmpq	%r9, %rcx
+	JE   LBB1_15
+	WORD $0xc1f6; BYTE $0x0c                   // testb	$12, %cl
+	JE   LBB1_21
+
+LBB1_12:
+	WORD $0x8945; BYTE $0xc2 // movl	%r8d, %r10d
+	LONG $0x03e28341         // andl	$3, %r10d
+	WORD $0x294c; BYTE $0xd1 // subq	%r10, %rcx
+	WORD $0x0148; BYTE $0xd1 // addq	%rdx, %rcx
+	QUAD $0x00000000851c8d48 // leaq	(,%rax,4), %rbx
+	QUAD $0x00000000b51c8d4c // leaq	(,%rsi,4), %r11
+	WORD $0x2949; BYTE $0xdb // subq	%rbx, %r11
+	LONG $0xe0e38348         // andq	$-32, %rbx
+	LONG $0x8b1c8d4a         // leaq	(%rbx,%r9,4), %rbx
+	WORD $0x0148; BYTE $0xfb // addq	%rdi, %rbx
+	WORD $0x294d; BYTE $0xc8 // subq	%r9, %r8
+	WORD $0x294d; BYTE $0xd0 // subq	%r10, %r8
+	WORD $0x2949; BYTE $0xd0 // subq	%rdx, %r8
+
+LBB1_13:
+	LONG $0x0310f8c5               // vmovups	(%rbx), %xmm0
+	LONG $0x1078a1c4; WORD $0x1b0c // vmovups	(%rbx,%r11), %xmm1
+	LONG $0xd158f8c5               // vaddps	%xmm1, %xmm0, %xmm2
+	LONG $0x1311f8c5               // vmovups	%xmm2, (%rbx)
+	LONG $0xc15cf8c5               // vsubps	%xmm1, %xmm0, %xmm0
+	LONG $0x1178a1c4; WORD $0x1b04 // vmovups	%xmm0, (%rbx,%r11)
+	LONG $0x10c38348               // addq	$16, %rbx
+	LONG $0xfcc08349               // addq	$-4, %r8
+	JNE  LBB1_13
+	WORD $0x854d; BYTE $0xd2       // testq	%r10, %r10
+	JNE  LBB1_6
+	JMP  LBB1_15
+
+LBB1_21:
+	WORD $0x014c; BYTE $0xca // addq	%r9, %rdx
+	JMP  LBB1_5
+
+TEXT ·xvec_avx2_fht_inverse_kac_walk(SB), $0-16
+	MOVQ data+0(FP), DI
+	MOVQ size+8(FP), SI
+	BYTE $0x55                                 // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5                   // movq	%rsp, %rbp
+	LONG $0xf8e48348                           // andq	$-8, %rsp
+	LONG $0x10ec8348                           // subq	$16, %rsp
+	WORD $0x8948; BYTE $0xf0                   // movq	%rsi, %rax
+	LONG $0x3fe8c148                           // shrq	$63, %rax
+	WORD $0x0148; BYTE $0xf0                   // addq	%rsi, %rax
+	WORD $0xd148; BYTE $0xf8                   // sarq	%rax
+	WORD $0x8948; BYTE $0xc1                   // movq	%rax, %rcx
+	LONG $0xf8e18348                           // andq	$-8, %rcx
+	QUAD $0x3f0000000c2444c7                   // movl	$1056964608, 12(%rsp)           # imm = 0x3F000000
+	LONG $0x187de2c4; WORD $0x2444; BYTE $0x0c // vbroadcastss	12(%rsp), %ymm0
+	LONG $0xb7148d48                           // leaq	(%rdi,%rsi,4), %rdx
+	LONG $0x10fe8348                           // cmpq	$16, %rsi
+	JL   LBB2_3
+	QUAD $0x0000000085048d4c                   // leaq	(,%rax,4), %r8
+	WORD $0x8948; BYTE $0xd6                   // movq	%rdx, %rsi
+	WORD $0x294c; BYTE $0xc6                   // subq	%r8, %rsi
+	WORD $0x3145; BYTE $0xc0                   // xorl	%r8d, %r8d
+
+LBB2_2:
+	LONG $0x107ca1c4; WORD $0x870c // vmovups	(%rdi,%r8,4), %ymm1
+	LONG $0x107ca1c4; WORD $0x8614 // vmovups	(%rsi,%r8,4), %ymm2
+	LONG $0xda58f4c5               // vaddps	%ymm2, %ymm1, %ymm3
+	LONG $0xdb59fcc5               // vmulps	%ymm3, %ymm0, %ymm3
+	LONG $0x117ca1c4; WORD $0x871c // vmovups	%ymm3, (%rdi,%r8,4)
+	LONG $0xca5cf4c5               // vsubps	%ymm2, %ymm1, %ymm1
+	LONG $0xc959fcc5               // vmulps	%ymm1, %ymm0, %ymm1
+	LONG $0x117ca1c4; WORD $0x860c // vmovups	%ymm1, (%rsi,%r8,4)
+	LONG $0x08c08349               // addq	$8, %r8
+	WORD $0x3949; BYTE $0xc8       // cmpq	%rcx, %r8
+	JL   LBB2_2
+
+LBB2_3:
+	WORD $0x3948; BYTE $0xc1 // cmpq	%rax, %rcx
+	JE   LBB2_6
+	QUAD $0x0000000085348d48 // leaq	(,%rax,4), %rsi
+	WORD $0x2948; BYTE $0xf2 // subq	%rsi, %rdx
+
+LBB2_5:
+	LONG $0x0410fac5; BYTE $0x8f   // vmovss	(%rdi,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x0c10fac5; BYTE $0x8a   // vmovss	(%rdx,%rcx,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5               // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x5459eac5; WORD $0x0c24 // vmulss	12(%rsp), %xmm2, %xmm2
+	LONG $0x1411fac5; BYTE $0x8f   // vmovss	%xmm2, (%rdi,%rcx,4)
+	LONG $0xc15cfac5               // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x4459fac5; WORD $0x0c24 // vmulss	12(%rsp), %xmm0, %xmm0
+	LONG $0x0411fac5; BYTE $0x8a   // vmovss	%xmm0, (%rdx,%rcx,4)
+	WORD $0xff48; BYTE $0xc1       // incq	%rcx
+	WORD $0x3948; BYTE $0xc1       // cmpq	%rax, %rcx
+	JL   LBB2_5
+
+LBB2_6:
+	WORD $0x8948; BYTE $0xec // movq	%rbp, %rsp
+	BYTE $0x5d               // popq	%rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
+
+TEXT ·xvec_avx2_fht_in_place(SB), $0-16
+	MOVQ data+0(FP), DI
+	MOVQ size+8(FP), SI
+	BYTE $0x55                             // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5               // movq	%rsp, %rbp
+	WORD $0x5741                           // pushq	%r15
+	WORD $0x5641                           // pushq	%r14
+	WORD $0x5541                           // pushq	%r13
+	WORD $0x5441                           // pushq	%r12
+	BYTE $0x53                             // pushq	%rbx
+	LONG $0xf8e48348                       // andq	$-8, %rsp
+	LONG $0x78ec8348                       // subq	$120, %rsp
+	LONG $0x247c8948; BYTE $0x20           // movq	%rdi, 32(%rsp)                  # 8-byte Spill
+	LONG $0x24748948; BYTE $0x10           // movq	%rsi, 16(%rsp)                  # 8-byte Spill
+	LONG $0x02fe8348                       // cmpq	$2, %rsi
+	JL   LBB3_40
+	QUAD $0xfffffffffff8b948; WORD $0x3fff // movabsq	$4611686018427387896, %rcx      # imm = 0x3FFFFFFFFFFFFFF8
+	LONG $0x24448b48; BYTE $0x20           // movq	32(%rsp), %rax                  # 8-byte Reload
+	LONG $0x20c08348                       // addq	$32, %rax
+	LONG $0x24448948; BYTE $0x48           // movq	%rax, 72(%rsp)                  # 8-byte Spill
+	LONG $0x0001bb41; WORD $0x0000         // movl	$1, %r11d
+	LONG $0x06418d48                       // leaq	6(%rcx), %rax
+	LONG $0x24448948; BYTE $0x50           // movq	%rax, 80(%rsp)                  # 8-byte Spill
+	JMP  LBB3_2
+
+LBB3_39:
+	LONG $0x245c3b4c; BYTE $0x10 // cmpq	16(%rsp), %r11                  # 8-byte Folded Reload
+	JGE  LBB3_40
+
+LBB3_2:
+	WORD $0x894d; BYTE $0xda               // movq	%r11, %r10
+	WORD $0x014d; BYTE $0xdb               // addq	%r11, %r11
+	WORD $0x894d; BYTE $0xd1               // movq	%r10, %r9
+	LONG $0xf8e18349                       // andq	$-8, %r9
+	LONG $0x08fa8349                       // cmpq	$8, %r10
+	LONG $0x245c894c; BYTE $0x40           // movq	%r11, 64(%rsp)                  # 8-byte Spill
+	JL   LBB3_6
+	QUAD $0x0000000095348d4e               // leaq	(,%r10,4), %r14
+	LONG $0x2474894c; BYTE $0x08           // movq	%r14, 8(%rsp)                   # 8-byte Spill
+	LONG $0xe0e68349                       // andq	$-32, %r14
+	LONG $0x247c8b48; BYTE $0x20           // movq	32(%rsp), %rdi                  # 8-byte Reload
+	LONG $0x373c8d4e                       // leaq	(%rdi,%r14), %r15
+	QUAD $0x00000000d5248d4e               // leaq	(,%r10,8), %r12
+	LONG $0x244c8b48; BYTE $0x10           // movq	16(%rsp), %rcx                  # 8-byte Reload
+	WORD $0x394c; BYTE $0xd9               // cmpq	%r11, %rcx
+	WORD $0x894c; BYTE $0xd8               // movq	%r11, %rax
+	LONG $0xc14f0f48                       // cmovgq	%rcx, %rax
+	WORD $0xff48; BYTE $0xc8               // decq	%rax
+	WORD $0x894c; BYTE $0xcb               // movq	%r9, %rbx
+	LONG $0x01cb8348                       // orq	$1, %rbx
+	WORD $0x3949; BYTE $0xda               // cmpq	%rbx, %r10
+	LONG $0xda4f0f49                       // cmovgq	%r10, %rbx
+	WORD $0x894c; BYTE $0xd1               // movq	%r10, %rcx
+	QUAD $0xfffffffffff8ba48; WORD $0x3fff // movabsq	$4611686018427387896, %rdx      # imm = 0x3FFFFFFFFFFFFFF8
+	WORD $0x2148; BYTE $0xd1               // andq	%rdx, %rcx
+	WORD $0x014c; BYTE $0xd1               // addq	%r10, %rcx
+	LONG $0x8f0c8d48                       // leaq	(%rdi,%rcx,4), %rcx
+	LONG $0x240c8948                       // movq	%rcx, (%rsp)                    # 8-byte Spill
+	LONG $0x1a348d49                       // leaq	(%r10,%rbx), %rsi
+	WORD $0x8949; BYTE $0xdd               // movq	%rbx, %r13
+	WORD $0x294d; BYTE $0xcd               // subq	%r9, %r13
+	LONG $0xff418d4d                       // leaq	-1(%r9), %r8
+	WORD $0x894c; BYTE $0xca               // movq	%r9, %rdx
+	WORD $0x894d; BYTE $0xc1               // movq	%r8, %r9
+	LONG $0x03e9c149                       // shrq	$3, %r9
+	WORD $0xff49; BYTE $0xc1               // incq	%r9
+	LONG $0xbc0f49f3; BYTE $0xcb           // rep		bsfq	%r11, %rcx
+	WORD $0xd348; BYTE $0xe8               // shrq	%cl, %rax
+	LONG $0x244c234c; BYTE $0x50           // andq	80(%rsp), %r9                   # 8-byte Folded Reload
+	LONG $0x244c894c; BYTE $0x38           // movq	%r9, 56(%rsp)                   # 8-byte Spill
+	WORD $0x8949; BYTE $0xd1               // movq	%rdx, %r9
+	LONG $0xc4af0f49                       // imulq	%r12, %rax
+	WORD $0x0148; BYTE $0xf8               // addq	%rdi, %rax
+	LONG $0x980c8d48                       // leaq	(%rax,%rbx,4), %rcx
+	LONG $0xb0048d48                       // leaq	(%rax,%rsi,4), %rax
+	WORD $0x3949; BYTE $0xc7               // cmpq	%rax, %r15
+	WORD $0x920f; BYTE $0xc0               // setb	%al
+	LONG $0x240c3948                       // cmpq	%rcx, (%rsp)                    # 8-byte Folded Reload
+	WORD $0x920f; BYTE $0xc1               // setb	%cl
+	WORD $0xc120                           // andb	%al, %cl
+	WORD $0x854d; BYTE $0xe4               // testq	%r12, %r12
+	WORD $0x980f; BYTE $0xc0               // sets	%al
+	WORD $0xc808                           // orb	%cl, %al
+	LONG $0x30244488                       // movb	%al, 48(%rsp)                   # 1-byte Spill
+	LONG $0x242c894c                       // movq	%r13, (%rsp)                    # 8-byte Spill
+	LONG $0xf0e58349                       // andq	$-16, %r13
+	WORD $0xd889                           // movl	%ebx, %eax
+	WORD $0xe083; BYTE $0x03               // andl	$3, %eax
+	LONG $0x24448948; BYTE $0x70           // movq	%rax, 112(%rsp)                 # 8-byte Spill
+	LONG $0xfce38348                       // andq	$-4, %rbx
+	LONG $0x245c8948; BYTE $0x28           // movq	%rbx, 40(%rsp)                  # 8-byte Spill
+	LONG $0x24448b48; BYTE $0x48           // movq	72(%rsp), %rax                  # 8-byte Reload
+	WORD $0x0149; BYTE $0xc6               // addq	%rax, %r14
+	LONG $0x014a8d48                       // leaq	1(%rdx), %rcx
+	WORD $0x3949; BYTE $0xca               // cmpq	%rcx, %r10
+	LONG $0xca4f0f49                       // cmovgq	%r10, %rcx
+	WORD $0x8948; BYTE $0xca               // movq	%rcx, %rdx
+	WORD $0x294c; BYTE $0xca               // subq	%r9, %rdx
+	LONG $0xf0e28348                       // andq	$-16, %rdx
+	LONG $0x24548948; BYTE $0x60           // movq	%rdx, 96(%rsp)                  # 8-byte Spill
+	LONG $0xfce18348                       // andq	$-4, %rcx
+	WORD $0x294c; BYTE $0xc9               // subq	%r9, %rcx
+	LONG $0x244c8948; BYTE $0x68           // movq	%rcx, 104(%rsp)                 # 8-byte Spill
+	LONG $0x246c894c; BYTE $0x18           // movq	%r13, 24(%rsp)                  # 8-byte Spill
+	LONG $0x290c8d4b                       // leaq	(%r9,%r13), %rcx
+	LONG $0x244c8948; BYTE $0x58           // movq	%rcx, 88(%rsp)                  # 8-byte Spill
+	WORD $0xc931                           // xorl	%ecx, %ecx
+	JMP  LBB3_4
+
+LBB3_28:
+	LONG $0x245c8b4c; BYTE $0x40 // movq	64(%rsp), %r11                  # 8-byte Reload
+	WORD $0x014c; BYTE $0xd9     // addq	%r11, %rcx
+	WORD $0x014c; BYTE $0xe0     // addq	%r12, %rax
+	WORD $0x014d; BYTE $0xe6     // addq	%r12, %r14
+	WORD $0x014d; BYTE $0xe7     // addq	%r12, %r15
+	WORD $0x014c; BYTE $0xe7     // addq	%r12, %rdi
+	LONG $0x244c3b48; BYTE $0x10 // cmpq	16(%rsp), %rcx                  # 8-byte Folded Reload
+	JGE  LBB3_39
+
+LBB3_4:
+	LONG $0x07f88349 // cmpq	$7, %r8
+	JNE  LBB3_11
+	WORD $0xd231     // xorl	%edx, %edx
+	JMP  LBB3_13
+
+LBB3_11:
+	LONG $0x24548b48; BYTE $0x08 // movq	8(%rsp), %rdx                   # 8-byte Reload
+	LONG $0x101c8d4c             // leaq	(%rax,%rdx), %r11
+	LONG $0x24748b48; BYTE $0x38 // movq	56(%rsp), %rsi                  # 8-byte Reload
+	WORD $0xd231                 // xorl	%edx, %edx
+
+LBB3_12:
+	LONG $0x4410fcc5; WORD $0xe090             // vmovups	-32(%rax,%rdx,4), %ymm0
+	LONG $0x107cc1c4; WORD $0x934c; BYTE $0xe0 // vmovups	-32(%r11,%rdx,4), %ymm1
+	LONG $0xd158fcc5                           // vaddps	%ymm1, %ymm0, %ymm2
+	LONG $0x5411fcc5; WORD $0xe090             // vmovups	%ymm2, -32(%rax,%rdx,4)
+	LONG $0xc15cfcc5                           // vsubps	%ymm1, %ymm0, %ymm0
+	LONG $0x117cc1c4; WORD $0x9344; BYTE $0xe0 // vmovups	%ymm0, -32(%r11,%rdx,4)
+	LONG $0x0410fcc5; BYTE $0x90               // vmovups	(%rax,%rdx,4), %ymm0
+	LONG $0x107cc1c4; WORD $0x930c             // vmovups	(%r11,%rdx,4), %ymm1
+	LONG $0xd158fcc5                           // vaddps	%ymm1, %ymm0, %ymm2
+	LONG $0x1411fcc5; BYTE $0x90               // vmovups	%ymm2, (%rax,%rdx,4)
+	LONG $0xc15cfcc5                           // vsubps	%ymm1, %ymm0, %ymm0
+	LONG $0x117cc1c4; WORD $0x9304             // vmovups	%ymm0, (%r11,%rdx,4)
+	LONG $0x10c28348                           // addq	$16, %rdx
+	LONG $0xfec68348                           // addq	$-2, %rsi
+	JNE  LBB3_12
+
+LBB3_13:
+	LONG $0x08c0f641               // testb	$8, %r8b
+	JNE  LBB3_15
+	LONG $0x24748b48; BYTE $0x20   // movq	32(%rsp), %rsi                  # 8-byte Reload
+	LONG $0x8e348d48               // leaq	(%rsi,%rcx,4), %rsi
+	LONG $0x961c8d4c               // leaq	(%rsi,%rdx,4), %r11
+	LONG $0x0410fcc5; BYTE $0x96   // vmovups	(%rsi,%rdx,4), %ymm0
+	LONG $0x107c81c4; WORD $0x930c // vmovups	(%r11,%r10,4), %ymm1
+	LONG $0xd158fcc5               // vaddps	%ymm1, %ymm0, %ymm2
+	LONG $0x1411fcc5; BYTE $0x96   // vmovups	%ymm2, (%rsi,%rdx,4)
+	LONG $0xc15cfcc5               // vsubps	%ymm1, %ymm0, %ymm0
+	LONG $0x117c81c4; WORD $0x9304 // vmovups	%ymm0, (%r11,%r10,4)
+
+LBB3_15:
+	WORD $0x394d; BYTE $0xd1     // cmpq	%r10, %r9
+	JE   LBB3_28
+	LONG $0x243c8348; BYTE $0x04 // cmpq	$4, (%rsp)                      # 8-byte Folded Reload
+	LONG $0xc6920f40             // setb	%sil
+	LONG $0x24740a40; BYTE $0x30 // orb	48(%rsp), %sil                  # 1-byte Folded Reload
+	WORD $0x894c; BYTE $0xca     // movq	%r9, %rdx
+	LONG $0x01c6f640             // testb	$1, %sil
+	JNE  LBB3_17
+	LONG $0x243c8348; BYTE $0x10 // cmpq	$16, (%rsp)                     # 8-byte Folded Reload
+	JAE  LBB3_21
+	WORD $0xdb31                 // xorl	%ebx, %ebx
+	JMP  LBB3_25
+
+LBB3_21:
+	LONG $0x24548b48; BYTE $0x60 // movq	96(%rsp), %rdx                  # 8-byte Reload
+	WORD $0x894c; BYTE $0xf6     // movq	%r14, %rsi
+
+LBB3_22:
+	LONG $0x4610fcc5; BYTE $0xe0               // vmovups	-32(%rsi), %ymm0
+	LONG $0x0e10fcc5                           // vmovups	(%rsi), %ymm1
+	LONG $0x107ca1c4; WORD $0x9654; BYTE $0xe0 // vmovups	-32(%rsi,%r10,4), %ymm2
+	LONG $0x107ca1c4; WORD $0x961c             // vmovups	(%rsi,%r10,4), %ymm3
+	LONG $0xe258fcc5                           // vaddps	%ymm2, %ymm0, %ymm4
+	LONG $0xeb58f4c5                           // vaddps	%ymm3, %ymm1, %ymm5
+	LONG $0x6611fcc5; BYTE $0xe0               // vmovups	%ymm4, -32(%rsi)
+	LONG $0x2e11fcc5                           // vmovups	%ymm5, (%rsi)
+	LONG $0xc25cfcc5                           // vsubps	%ymm2, %ymm0, %ymm0
+	LONG $0xcb5cf4c5                           // vsubps	%ymm3, %ymm1, %ymm1
+	LONG $0x117ca1c4; WORD $0x9644; BYTE $0xe0 // vmovups	%ymm0, -32(%rsi,%r10,4)
+	LONG $0x117ca1c4; WORD $0x960c             // vmovups	%ymm1, (%rsi,%r10,4)
+	LONG $0x40c68348                           // addq	$64, %rsi
+	LONG $0xf0c28348                           // addq	$-16, %rdx
+	JNE  LBB3_22
+	LONG $0x24548b48; BYTE $0x18               // movq	24(%rsp), %rdx                  # 8-byte Reload
+	LONG $0x24143948                           // cmpq	%rdx, (%rsp)                    # 8-byte Folded Reload
+	JE   LBB3_28
+	LONG $0x24548b48; BYTE $0x58               // movq	88(%rsp), %rdx                  # 8-byte Reload
+	LONG $0x245c8b48; BYTE $0x18               // movq	24(%rsp), %rbx                  # 8-byte Reload
+	LONG $0x0c2404f6                           // testb	$12, (%rsp)                     # 1-byte Folded Reload
+	JE   LBB3_17
+
+LBB3_25:
+	LONG $0x9f148d49             // leaq	(%r15,%rbx,4), %rdx
+	LONG $0x24748b48; BYTE $0x08 // movq	8(%rsp), %rsi                   # 8-byte Reload
+	WORD $0x0148; BYTE $0xd6     // addq	%rdx, %rsi
+	LONG $0x245c8b4c; BYTE $0x68 // movq	104(%rsp), %r11                 # 8-byte Reload
+	WORD $0x2949; BYTE $0xdb     // subq	%rbx, %r11
+	WORD $0xdb31                 // xorl	%ebx, %ebx
+
+LBB3_26:
+	LONG $0x0410f8c5; BYTE $0x9a   // vmovups	(%rdx,%rbx,4), %xmm0
+	LONG $0x0c10f8c5; BYTE $0x9e   // vmovups	(%rsi,%rbx,4), %xmm1
+	LONG $0xd158f8c5               // vaddps	%xmm1, %xmm0, %xmm2
+	LONG $0x1411f8c5; BYTE $0x9a   // vmovups	%xmm2, (%rdx,%rbx,4)
+	LONG $0xc15cf8c5               // vsubps	%xmm1, %xmm0, %xmm0
+	LONG $0x0411f8c5; BYTE $0x9e   // vmovups	%xmm0, (%rsi,%rbx,4)
+	LONG $0x04c38348               // addq	$4, %rbx
+	WORD $0x3949; BYTE $0xdb       // cmpq	%rbx, %r11
+	JNE  LBB3_26
+	LONG $0x24548b48; BYTE $0x28   // movq	40(%rsp), %rdx                  # 8-byte Reload
+	LONG $0x247c8348; WORD $0x0070 // cmpq	$0, 112(%rsp)                   # 8-byte Folded Reload
+	JE   LBB3_28
+
+LBB3_17:
+	LONG $0x97348d48             // leaq	(%rdi,%rdx,4), %rsi
+	LONG $0x245c8b4c; BYTE $0x08 // movq	8(%rsp), %r11                   # 8-byte Reload
+	WORD $0x0149; BYTE $0xf3     // addq	%rsi, %r11
+	WORD $0xdb31                 // xorl	%ebx, %ebx
+
+LBB3_18:
+	LONG $0x0410fac5; BYTE $0x9e   // vmovss	(%rsi,%rbx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x107ac1c4; WORD $0x9b0c // vmovss	(%r11,%rbx,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5               // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x1411fac5; BYTE $0x9e   // vmovss	%xmm2, (%rsi,%rbx,4)
+	LONG $0xc15cfac5               // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x117ac1c4; WORD $0x9b04 // vmovss	%xmm0, (%r11,%rbx,4)
+	LONG $0x1a2c8d4c               // leaq	(%rdx,%rbx), %r13
+	WORD $0xff49; BYTE $0xc5       // incq	%r13
+	WORD $0xff48; BYTE $0xc3       // incq	%rbx
+	WORD $0x394d; BYTE $0xd5       // cmpq	%r10, %r13
+	JL   LBB3_18
+	JMP  LBB3_28
+
+LBB3_6:
+	WORD $0x394d; BYTE $0xd1                   // cmpq	%r10, %r9
+	JE   LBB3_39
+	QUAD $0x0000000095048d4a                   // leaq	(,%r10,4), %rax
+	WORD $0x8948; BYTE $0xc2                   // movq	%rax, %rdx
+	LONG $0xe0e28348                           // andq	$-32, %rdx
+	LONG $0x246c8b4c; BYTE $0x20               // movq	32(%rsp), %r13                  # 8-byte Reload
+	LONG $0x2a3c8d4a                           // leaq	(%rdx,%r13), %rdi
+	LONG $0x244c8b48; BYTE $0x10               // movq	16(%rsp), %rcx                  # 8-byte Reload
+	WORD $0x394c; BYTE $0xd9                   // cmpq	%r11, %rcx
+	WORD $0x894d; BYTE $0xd8                   // movq	%r11, %r8
+	LONG $0xc14f0f4c                           // cmovgq	%rcx, %r8
+	WORD $0xff49; BYTE $0xc8                   // decq	%r8
+	WORD $0x894d; BYTE $0xcf                   // movq	%r9, %r15
+	LONG $0x01cf8349                           // orq	$1, %r15
+	WORD $0x394d; BYTE $0xfa                   // cmpq	%r15, %r10
+	LONG $0xfa4f0f4d                           // cmovgq	%r10, %r15
+	QUAD $0x00000000d51c8d4a                   // leaq	(,%r10,8), %rbx
+	WORD $0x894c; BYTE $0xd1                   // movq	%r10, %rcx
+	QUAD $0xfffffffffff8be48; WORD $0x3fff     // movabsq	$4611686018427387896, %rsi      # imm = 0x3FFFFFFFFFFFFFF8
+	WORD $0x2148; BYTE $0xf1                   // andq	%rsi, %rcx
+	WORD $0x014c; BYTE $0xd1                   // addq	%r10, %rcx
+	QUAD $0x000000008d348d48                   // leaq	(,%rcx,4), %rsi
+	WORD $0x014c; BYTE $0xee                   // addq	%r13, %rsi
+	LONG $0x3a1c8d4f                           // leaq	(%r10,%r15), %r11
+	WORD $0x894d; BYTE $0xfe                   // movq	%r15, %r14
+	LONG $0xbc0f48f3; WORD $0x244c; BYTE $0x40 // rep		bsfq	64(%rsp), %rcx          # 8-byte Folded Reload
+	WORD $0xd349; BYTE $0xe8                   // shrq	%cl, %r8
+	WORD $0x294d; BYTE $0xce                   // subq	%r9, %r14
+	LONG $0xc3af0f4c                           // imulq	%rbx, %r8
+	WORD $0x014d; BYTE $0xe8                   // addq	%r13, %r8
+	LONG $0xb80c8d4b                           // leaq	(%r8,%r15,4), %rcx
+	LONG $0x98048d4f                           // leaq	(%r8,%r11,4), %r8
+	WORD $0x394c; BYTE $0xc7                   // cmpq	%r8, %rdi
+	LONG $0xc0920f41                           // setb	%r8b
+	WORD $0x3948; BYTE $0xce                   // cmpq	%rcx, %rsi
+	LONG $0xc6920f40                           // setb	%sil
+	WORD $0x2044; BYTE $0xc6                   // andb	%r8b, %sil
+	WORD $0x8548; BYTE $0xdb                   // testq	%rbx, %rbx
+	WORD $0x980f; BYTE $0xc1                   // sets	%cl
+	WORD $0x0840; BYTE $0xf1                   // orb	%sil, %cl
+	LONG $0x08244c88                           // movb	%cl, 8(%rsp)                    # 1-byte Spill
+	WORD $0x894c; BYTE $0xf1                   // movq	%r14, %rcx
+	LONG $0xf0e18348                           // andq	$-16, %rcx
+	LONG $0x240c8948                           // movq	%rcx, (%rsp)                    # 8-byte Spill
+	WORD $0x014c; BYTE $0xc9                   // addq	%r9, %rcx
+	LONG $0x244c8948; BYTE $0x28               // movq	%rcx, 40(%rsp)                  # 8-byte Spill
+	WORD $0x8944; BYTE $0xf9                   // movl	%r15d, %ecx
+	WORD $0xe183; BYTE $0x03                   // andl	$3, %ecx
+	LONG $0x244c8948; BYTE $0x30               // movq	%rcx, 48(%rsp)                  # 8-byte Spill
+	LONG $0xfce78349                           // andq	$-4, %r15
+	LONG $0x247c894c; BYTE $0x38               // movq	%r15, 56(%rsp)                  # 8-byte Spill
+	LONG $0x24540348; BYTE $0x48               // addq	72(%rsp), %rdx                  # 8-byte Folded Reload
+	LONG $0x01498d49                           // leaq	1(%r9), %rcx
+	WORD $0x3949; BYTE $0xca                   // cmpq	%rcx, %r10
+	LONG $0xca4f0f49                           // cmovgq	%r10, %rcx
+	LONG $0xfce18348                           // andq	$-4, %rcx
+	WORD $0x294c; BYTE $0xc9                   // subq	%r9, %rcx
+	LONG $0x244c8948; BYTE $0x18               // movq	%rcx, 24(%rsp)                  # 8-byte Spill
+	WORD $0x3145; BYTE $0xc0                   // xorl	%r8d, %r8d
+	JMP  LBB3_8
+
+LBB3_38:
+	LONG $0x245c8b4c; BYTE $0x40 // movq	64(%rsp), %r11                  # 8-byte Reload
+	WORD $0x014d; BYTE $0xd8     // addq	%r11, %r8
+	WORD $0x0148; BYTE $0xda     // addq	%rbx, %rdx
+	WORD $0x0148; BYTE $0xdf     // addq	%rbx, %rdi
+	WORD $0x0149; BYTE $0xdd     // addq	%rbx, %r13
+	LONG $0x24443b4c; BYTE $0x10 // cmpq	16(%rsp), %r8                   # 8-byte Folded Reload
+	JGE  LBB3_39
+
+LBB3_8:
+	LONG $0x04fe8349             // cmpq	$4, %r14
+	LONG $0xc6920f40             // setb	%sil
+	LONG $0x24740a40; BYTE $0x08 // orb	8(%rsp), %sil                   # 1-byte Folded Reload
+	WORD $0x894d; BYTE $0xcb     // movq	%r9, %r11
+	LONG $0x01c6f640             // testb	$1, %sil
+	JNE  LBB3_36
+	LONG $0x10fe8349             // cmpq	$16, %r14
+	JAE  LBB3_29
+	WORD $0x3145; BYTE $0xff     // xorl	%r15d, %r15d
+	JMP  LBB3_33
+
+LBB3_29:
+	LONG $0x24348b48         // movq	(%rsp), %rsi                    # 8-byte Reload
+	WORD $0x8949; BYTE $0xd3 // movq	%rdx, %r11
+
+LBB3_30:
+	LONG $0x107cc1c4; WORD $0xe043             // vmovups	-32(%r11), %ymm0
+	LONG $0x107cc1c4; BYTE $0x0b               // vmovups	(%r11), %ymm1
+	LONG $0x107cc1c4; WORD $0x0354; BYTE $0xe0 // vmovups	-32(%r11,%rax), %ymm2
+	LONG $0x107cc1c4; WORD $0x031c             // vmovups	(%r11,%rax), %ymm3
+	LONG $0xe258fcc5                           // vaddps	%ymm2, %ymm0, %ymm4
+	LONG $0xeb58f4c5                           // vaddps	%ymm3, %ymm1, %ymm5
+	LONG $0x117cc1c4; WORD $0xe063             // vmovups	%ymm4, -32(%r11)
+	LONG $0x117cc1c4; BYTE $0x2b               // vmovups	%ymm5, (%r11)
+	LONG $0xc25cfcc5                           // vsubps	%ymm2, %ymm0, %ymm0
+	LONG $0xcb5cf4c5                           // vsubps	%ymm3, %ymm1, %ymm1
+	LONG $0x117cc1c4; WORD $0x0344; BYTE $0xe0 // vmovups	%ymm0, -32(%r11,%rax)
+	LONG $0x117cc1c4; WORD $0x030c             // vmovups	%ymm1, (%r11,%rax)
+	LONG $0x40c38349                           // addq	$64, %r11
+	LONG $0xf0c68348                           // addq	$-16, %rsi
+	JNE  LBB3_30
+	LONG $0x24343b4c                           // cmpq	(%rsp), %r14                    # 8-byte Folded Reload
+	JE   LBB3_38
+	LONG $0x243c8b4c                           // movq	(%rsp), %r15                    # 8-byte Reload
+	LONG $0x245c8b4c; BYTE $0x28               // movq	40(%rsp), %r11                  # 8-byte Reload
+	LONG $0x0cc6f641                           // testb	$12, %r14b
+	JE   LBB3_36
+
+LBB3_33:
+	LONG $0xbf348d4a             // leaq	(%rdi,%r15,4), %rsi
+	LONG $0x061c8d4c             // leaq	(%rsi,%rax), %r11
+	LONG $0x24648b4c; BYTE $0x18 // movq	24(%rsp), %r12                  # 8-byte Reload
+	WORD $0x294d; BYTE $0xfc     // subq	%r15, %r12
+	WORD $0x3145; BYTE $0xff     // xorl	%r15d, %r15d
+
+LBB3_34:
+	LONG $0x1078a1c4; WORD $0xbe04 // vmovups	(%rsi,%r15,4), %xmm0
+	LONG $0x107881c4; WORD $0xbb0c // vmovups	(%r11,%r15,4), %xmm1
+	LONG $0xd158f8c5               // vaddps	%xmm1, %xmm0, %xmm2
+	LONG $0x1178a1c4; WORD $0xbe14 // vmovups	%xmm2, (%rsi,%r15,4)
+	LONG $0xc15cf8c5               // vsubps	%xmm1, %xmm0, %xmm0
+	LONG $0x117881c4; WORD $0xbb04 // vmovups	%xmm0, (%r11,%r15,4)
+	LONG $0x04c78349               // addq	$4, %r15
+	WORD $0x394d; BYTE $0xfc       // cmpq	%r15, %r12
+	JNE  LBB3_34
+	LONG $0x245c8b4c; BYTE $0x38   // movq	56(%rsp), %r11                  # 8-byte Reload
+	LONG $0x247c8348; WORD $0x0030 // cmpq	$0, 48(%rsp)                    # 8-byte Folded Reload
+	JE   LBB3_38
+
+LBB3_36:
+	QUAD $0x000000009d348d4a // leaq	(,%r11,4), %rsi
+	WORD $0x014c; BYTE $0xee // addq	%r13, %rsi
+	LONG $0x06248d4c         // leaq	(%rsi,%rax), %r12
+	WORD $0x3145; BYTE $0xff // xorl	%r15d, %r15d
+
+LBB3_37:
+	LONG $0x107aa1c4; WORD $0xbe04 // vmovss	(%rsi,%r15,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x107a81c4; WORD $0xbc0c // vmovss	(%r12,%r15,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5               // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x117aa1c4; WORD $0xbe14 // vmovss	%xmm2, (%rsi,%r15,4)
+	LONG $0xc15cfac5               // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x117a81c4; WORD $0xbc04 // vmovss	%xmm0, (%r12,%r15,4)
+	LONG $0x3b0c8d4b               // leaq	(%r11,%r15), %rcx
+	WORD $0xff48; BYTE $0xc1       // incq	%rcx
+	WORD $0xff49; BYTE $0xc7       // incq	%r15
+	WORD $0x394c; BYTE $0xd1       // cmpq	%r10, %rcx
+	JL   LBB3_37
+	JMP  LBB3_38
+
+LBB3_40:
+	LONG $0xd8658d48         // leaq	-40(%rbp), %rsp
+	BYTE $0x5b               // popq	%rbx
+	WORD $0x5c41             // popq	%r12
+	WORD $0x5d41             // popq	%r13
+	WORD $0x5e41             // popq	%r14
+	WORD $0x5f41             // popq	%r15
+	BYTE $0x5d               // popq	%rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
diff --git a/internal/ailego/math/fht_avx512.go b/internal/ailego/math/fht_avx512.go
new file mode 100644
index 0000000..bcc02bb
--- /dev/null
+++ b/internal/ailego/math/fht_avx512.go
@@ -0,0 +1,23 @@
+//go:build !noasm && amd64
+// Code generated by GoAT. DO NOT EDIT.
+// versions:
+// 	clang   21.1.8 (6ubuntu1)
+// 	objdump 2.46
+// flags: -mavx512f -mavx512dq -O3
+// source: src/fht_avx512.c
+
+package mathutil
+
+import "unsafe"
+
+//go:noescape
+func xvec_avx512_fht_flip_signs(signs, data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_avx512_fht_kac_walk(data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_avx512_fht_inverse_kac_walk(data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_avx512_fht_in_place(data unsafe.Pointer, size int64)
diff --git a/internal/ailego/math/fht_avx512.s b/internal/ailego/math/fht_avx512.s
new file mode 100644
index 0000000..192cf4e
--- /dev/null
+++ b/internal/ailego/math/fht_avx512.s
@@ -0,0 +1,768 @@
+//go:build !noasm && amd64
+// Code generated by GoAT. DO NOT EDIT.
+// versions:
+// 	clang   21.1.8 (6ubuntu1)
+// 	objdump 2.46
+// flags: -mavx512f -mavx512dq -O3
+// source: src/fht_avx512.c
+
+TEXT ·xvec_avx512_fht_flip_signs(SB), $0-24
+	MOVQ signs+0(FP), DI
+	MOVQ data+8(FP), SI
+	MOVQ size+16(FP), DX
+	BYTE $0x55                     // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5       // movq	%rsp, %rbp
+	LONG $0xf8e48348               // andq	$-8, %rsp
+	LONG $0x10ec8348               // subq	$16, %rsp
+	WORD $0x8948; BYTE $0xd0       // movq	%rdx, %rax
+	LONG $0xc0e08348               // andq	$-64, %rax
+	QUAD $0x800000000c2444c7       // movl	$-2147483648, 12(%rsp)          # imm = 0x80000000
+	LONG $0x0c244c8b               // movl	12(%rsp), %ecx
+	LONG $0x40fa8348               // cmpq	$64, %rdx
+	JL   LBB0_3
+	LONG $0x487df262; WORD $0xc17c // vpbroadcastd	%ecx, %zmm0
+	WORD $0xc931                   // xorl	%ecx, %ecx
+	WORD $0x8949; BYTE $0xf8       // movq	%rdi, %r8
+
+LBB0_2:
+	WORD $0x8b4d; BYTE $0x08                   // movq	(%r8), %r9
+	LONG $0x9278c1c4; BYTE $0xc9               // kmovw	%r9d, %k1
+	LONG $0x48fef162; WORD $0x0c6f; BYTE $0x8e // vmovdqu64	(%rsi,%rcx,4), %zmm1
+	QUAD $0x018e546f48fef162                   // vmovdqu64	64(%rsi,%rcx,4), %zmm2
+	QUAD $0x028e5c6f48fef162                   // vmovdqu64	128(%rsi,%rcx,4), %zmm3
+	QUAD $0x038e646f48fef162                   // vmovdqu64	192(%rsi,%rcx,4), %zmm4
+	LONG $0x497df162; WORD $0xc9ef             // vpxord	%zmm1, %zmm0, %zmm1 {%k1}
+	LONG $0x48fef162; WORD $0x0c7f; BYTE $0x8e // vmovdqu64	%zmm1, (%rsi,%rcx,4)
+	WORD $0x8945; BYTE $0xca                   // movl	%r9d, %r10d
+	LONG $0x10eac141                           // shrl	$16, %r10d
+	LONG $0x9278c1c4; BYTE $0xca               // kmovw	%r10d, %k1
+	LONG $0x497df162; WORD $0xd2ef             // vpxord	%zmm2, %zmm0, %zmm2 {%k1}
+	QUAD $0x018e547f48fef162                   // vmovdqu64	%zmm2, 64(%rsi,%rcx,4)
+	WORD $0x894d; BYTE $0xca                   // movq	%r9, %r10
+	LONG $0x20eac149                           // shrq	$32, %r10
+	LONG $0x9278c1c4; BYTE $0xca               // kmovw	%r10d, %k1
+	LONG $0x497df162; WORD $0xdbef             // vpxord	%zmm3, %zmm0, %zmm3 {%k1}
+	QUAD $0x028e5c7f48fef162                   // vmovdqu64	%zmm3, 128(%rsi,%rcx,4)
+	LONG $0x30e9c149                           // shrq	$48, %r9
+	LONG $0x9278c1c4; BYTE $0xc9               // kmovw	%r9d, %k1
+	LONG $0x497df162; WORD $0xe4ef             // vpxord	%zmm4, %zmm0, %zmm4 {%k1}
+	QUAD $0x038e647f48fef162                   // vmovdqu64	%zmm4, 192(%rsi,%rcx,4)
+	LONG $0x40c18348                           // addq	$64, %rcx
+	LONG $0x08c08349                           // addq	$8, %r8
+	WORD $0x3948; BYTE $0xc1                   // cmpq	%rax, %rcx
+	JL   LBB0_2
+
+LBB0_3:
+	WORD $0x3948; BYTE $0xd0 // cmpq	%rdx, %rax
+	JNE  LBB0_4
+
+LBB0_7:
+	WORD $0x8948; BYTE $0xec // movq	%rbp, %rsp
+	BYTE $0x5d               // popq	%rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
+
+LBB0_6:
+	WORD $0xff48; BYTE $0xc0 // incq	%rax
+	WORD $0x3948; BYTE $0xd0 // cmpq	%rdx, %rax
+	JGE  LBB0_7
+
+LBB0_4:
+	LONG $0x07488d48             // leaq	7(%rax), %rcx
+	WORD $0x8548; BYTE $0xc0     // testq	%rax, %rax
+	LONG $0xc8490f48             // cmovnsq	%rax, %rcx
+	LONG $0x03f9c148             // sarq	$3, %rcx
+	LONG $0x04b60f44; BYTE $0x0f // movzbl	(%rdi,%rcx), %r8d
+	WORD $0xe1c1; BYTE $0x03     // shll	$3, %ecx
+	WORD $0x8941; BYTE $0xc1     // movl	%eax, %r9d
+	WORD $0x2941; BYTE $0xc9     // subl	%ecx, %r9d
+	LONG $0xc8a30f45             // btl	%r9d, %r8d
+	JAE  LBB0_6
+	LONG $0x03867480; BYTE $0x80 // xorb	$-128, 3(%rsi,%rax,4)
+	JMP  LBB0_6
+
+TEXT ·xvec_avx512_fht_kac_walk(SB), $0-16
+	MOVQ data+0(FP), DI
+	MOVQ size+8(FP), SI
+	WORD $0x8948; BYTE $0xf0 // movq	%rsi, %rax
+	LONG $0x3fe8c148         // shrq	$63, %rax
+	WORD $0x0148; BYTE $0xf0 // addq	%rsi, %rax
+	WORD $0xd148; BYTE $0xf8 // sarq	%rax
+	WORD $0x8948; BYTE $0xc2 // movq	%rax, %rdx
+	LONG $0xf0e28348         // andq	$-16, %rdx
+	LONG $0x20fe8348         // cmpq	$32, %rsi
+	JL   LBB1_3
+	QUAD $0x0000000085048d4c // leaq	(,%rax,4), %r8
+	LONG $0xb70c8d48         // leaq	(%rdi,%rsi,4), %rcx
+	WORD $0x294c; BYTE $0xc1 // subq	%r8, %rcx
+	WORD $0x3145; BYTE $0xc0 // xorl	%r8d, %r8d
+
+LBB1_2:
+	LONG $0x487cb162; WORD $0x0410; BYTE $0x87 // vmovups	(%rdi,%r8,4), %zmm0
+	LONG $0x487cb162; WORD $0x0c10; BYTE $0x81 // vmovups	(%rcx,%r8,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	LONG $0x487cb162; WORD $0x1411; BYTE $0x87 // vmovups	%zmm2, (%rdi,%r8,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	LONG $0x487cb162; WORD $0x0411; BYTE $0x81 // vmovups	%zmm0, (%rcx,%r8,4)
+	LONG $0x10c08349                           // addq	$16, %r8
+	WORD $0x3949; BYTE $0xd0                   // cmpq	%rdx, %r8
+	JL   LBB1_2
+
+LBB1_3:
+	WORD $0x3948; BYTE $0xc2               // cmpq	%rax, %rdx
+	JE   LBB1_16
+	BYTE $0x55                             // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5               // movq	%rsp, %rbp
+	BYTE $0x53                             // pushq	%rbx
+	LONG $0xf8e48348                       // andq	$-8, %rsp
+	WORD $0x8949; BYTE $0xd1               // movq	%rdx, %r9
+	LONG $0x01c98349                       // orq	$1, %r9
+	WORD $0x394c; BYTE $0xc8               // cmpq	%r9, %rax
+	WORD $0x894d; BYTE $0xc8               // movq	%r9, %r8
+	LONG $0xc04f0f4c                       // cmovgq	%rax, %r8
+	WORD $0x894c; BYTE $0xc1               // movq	%r8, %rcx
+	WORD $0x2948; BYTE $0xd1               // subq	%rdx, %rcx
+	LONG $0x03f98348                       // cmpq	$3, %rcx
+	JBE  LBB1_5
+	LONG $0x97148d4c                       // leaq	(%rdi,%rdx,4), %r10
+	WORD $0x394c; BYTE $0xc8               // cmpq	%r9, %rax
+	LONG $0xc84f0f4c                       // cmovgq	%rax, %r9
+	LONG $0x0e1c8d4e                       // leaq	(%rsi,%r9), %r11
+	WORD $0x2949; BYTE $0xc3               // subq	%rax, %r11
+	LONG $0x9f1c8d4e                       // leaq	(%rdi,%r11,4), %r11
+	WORD $0x394d; BYTE $0xda               // cmpq	%r11, %r10
+	JAE  LBB1_10
+	LONG $0x8f0c8d4e                       // leaq	(%rdi,%r9,4), %r9
+	QUAD $0xfffffffffff0ba49; WORD $0x3fff // movabsq	$4611686018427387888, %r10      # imm = 0x3FFFFFFFFFFFFFF0
+	WORD $0x2149; BYTE $0xc2               // andq	%rax, %r10
+	WORD $0x0149; BYTE $0xf2               // addq	%rsi, %r10
+	WORD $0x2949; BYTE $0xc2               // subq	%rax, %r10
+	LONG $0x97148d4e                       // leaq	(%rdi,%r10,4), %r10
+	WORD $0x394d; BYTE $0xca               // cmpq	%r9, %r10
+	JAE  LBB1_10
+
+LBB1_5:
+	WORD $0x8948; BYTE $0xd1 // movq	%rdx, %rcx
+
+LBB1_6:
+	QUAD $0x0000000085048d4c // leaq	(,%rax,4), %r8
+	LONG $0xb7148d48         // leaq	(%rdi,%rsi,4), %rdx
+	WORD $0x294c; BYTE $0xc2 // subq	%r8, %rdx
+
+LBB1_7:
+	LONG $0x0410fac5; BYTE $0x8f // vmovss	(%rdi,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x0c10fac5; BYTE $0x8a // vmovss	(%rdx,%rcx,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5             // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x1411fac5; BYTE $0x8f // vmovss	%xmm2, (%rdi,%rcx,4)
+	LONG $0xc15cfac5             // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x0411fac5; BYTE $0x8a // vmovss	%xmm0, (%rdx,%rcx,4)
+	WORD $0xff48; BYTE $0xc1     // incq	%rcx
+	WORD $0x3948; BYTE $0xc1     // cmpq	%rax, %rcx
+	JL   LBB1_7
+
+LBB1_15:
+	LONG $0xf8658d48 // leaq	-8(%rbp), %rsp
+	BYTE $0x5b       // popq	%rbx
+	BYTE $0x5d       // popq	%rbp
+
+LBB1_16:
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
+
+LBB1_10:
+	LONG $0x20f98348         // cmpq	$32, %rcx
+	JAE  LBB1_17
+	WORD $0x3145; BYTE $0xc9 // xorl	%r9d, %r9d
+	JMP  LBB1_12
+
+LBB1_17:
+	WORD $0x8949; BYTE $0xc9 // movq	%rcx, %r9
+	LONG $0xe0e18349         // andq	$-32, %r9
+	QUAD $0x00000000851c8d4c // leaq	(,%rax,4), %r11
+	QUAD $0x00000000b5148d4c // leaq	(,%rsi,4), %r10
+	WORD $0x294d; BYTE $0xda // subq	%r11, %r10
+	LONG $0xc0e38349         // andq	$-64, %r11
+	WORD $0x0149; BYTE $0xfb // addq	%rdi, %r11
+	LONG $0x40c38349         // addq	$64, %r11
+	WORD $0x894c; BYTE $0xcb // movq	%r9, %rbx
+
+LBB1_18:
+	LONG $0x487cd162; WORD $0x4310; BYTE $0xff // vmovups	-64(%r11), %zmm0
+	LONG $0x487cd162; WORD $0x0b10             // vmovups	(%r11), %zmm1
+	QUAD $0xff135410487c9162                   // vmovups	-64(%r11,%r10), %zmm2
+	LONG $0x487c9162; WORD $0x1c10; BYTE $0x13 // vmovups	(%r11,%r10), %zmm3
+	LONG $0x487cf162; WORD $0xe258             // vaddps	%zmm2, %zmm0, %zmm4
+	LONG $0x4874f162; WORD $0xeb58             // vaddps	%zmm3, %zmm1, %zmm5
+	LONG $0x487cd162; WORD $0x6311; BYTE $0xff // vmovups	%zmm4, -64(%r11)
+	LONG $0x487cd162; WORD $0x2b11             // vmovups	%zmm5, (%r11)
+	LONG $0x487cf162; WORD $0xc25c             // vsubps	%zmm2, %zmm0, %zmm0
+	LONG $0x4874f162; WORD $0xcb5c             // vsubps	%zmm3, %zmm1, %zmm1
+	QUAD $0xff134411487c9162                   // vmovups	%zmm0, -64(%r11,%r10)
+	LONG $0x487c9162; WORD $0x0c11; BYTE $0x13 // vmovups	%zmm1, (%r11,%r10)
+	LONG $0x80eb8349                           // subq	$-128, %r11
+	LONG $0xe0c38348                           // addq	$-32, %rbx
+	JNE  LBB1_18
+	WORD $0x394c; BYTE $0xc9                   // cmpq	%r9, %rcx
+	JE   LBB1_15
+	WORD $0xc1f6; BYTE $0x1c                   // testb	$28, %cl
+	JE   LBB1_21
+
+LBB1_12:
+	WORD $0x8945; BYTE $0xc2 // movl	%r8d, %r10d
+	LONG $0x03e28341         // andl	$3, %r10d
+	WORD $0x294c; BYTE $0xd1 // subq	%r10, %rcx
+	WORD $0x0148; BYTE $0xd1 // addq	%rdx, %rcx
+	QUAD $0x00000000851c8d48 // leaq	(,%rax,4), %rbx
+	QUAD $0x00000000b51c8d4c // leaq	(,%rsi,4), %r11
+	WORD $0x2949; BYTE $0xdb // subq	%rbx, %r11
+	LONG $0xc0e38348         // andq	$-64, %rbx
+	LONG $0x8b1c8d4a         // leaq	(%rbx,%r9,4), %rbx
+	WORD $0x0148; BYTE $0xfb // addq	%rdi, %rbx
+	WORD $0x294d; BYTE $0xc8 // subq	%r9, %r8
+	WORD $0x294d; BYTE $0xd0 // subq	%r10, %r8
+	WORD $0x2949; BYTE $0xd0 // subq	%rdx, %r8
+
+LBB1_13:
+	LONG $0x0310f8c5               // vmovups	(%rbx), %xmm0
+	LONG $0x1078a1c4; WORD $0x1b0c // vmovups	(%rbx,%r11), %xmm1
+	LONG $0xd158f8c5               // vaddps	%xmm1, %xmm0, %xmm2
+	LONG $0x1311f8c5               // vmovups	%xmm2, (%rbx)
+	LONG $0xc15cf8c5               // vsubps	%xmm1, %xmm0, %xmm0
+	LONG $0x1178a1c4; WORD $0x1b04 // vmovups	%xmm0, (%rbx,%r11)
+	LONG $0x10c38348               // addq	$16, %rbx
+	LONG $0xfcc08349               // addq	$-4, %r8
+	JNE  LBB1_13
+	WORD $0x854d; BYTE $0xd2       // testq	%r10, %r10
+	JNE  LBB1_6
+	JMP  LBB1_15
+
+LBB1_21:
+	WORD $0x014c; BYTE $0xca // addq	%r9, %rdx
+	JMP  LBB1_5
+
+TEXT ·xvec_avx512_fht_inverse_kac_walk(SB), $0-16
+	MOVQ data+0(FP), DI
+	MOVQ size+8(FP), SI
+	BYTE $0x55               // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5 // movq	%rsp, %rbp
+	LONG $0xf8e48348         // andq	$-8, %rsp
+	LONG $0x10ec8348         // subq	$16, %rsp
+	WORD $0x8948; BYTE $0xf0 // movq	%rsi, %rax
+	LONG $0x3fe8c148         // shrq	$63, %rax
+	WORD $0x0148; BYTE $0xf0 // addq	%rsi, %rax
+	WORD $0xd148; BYTE $0xf8 // sarq	%rax
+	WORD $0x8948; BYTE $0xc1 // movq	%rax, %rcx
+	LONG $0xf0e18348         // andq	$-16, %rcx
+	QUAD $0x3f0000000c2444c7 // movl	$1056964608, 12(%rsp)           # imm = 0x3F000000
+	QUAD $0x03244418487df262 // vbroadcastss	12(%rsp), %zmm0
+	LONG $0xb7148d48         // leaq	(%rdi,%rsi,4), %rdx
+	LONG $0x20fe8348         // cmpq	$32, %rsi
+	JL   LBB2_3
+	QUAD $0x0000000085048d4c // leaq	(,%rax,4), %r8
+	WORD $0x8948; BYTE $0xd6 // movq	%rdx, %rsi
+	WORD $0x294c; BYTE $0xc6 // subq	%r8, %rsi
+	WORD $0x3145; BYTE $0xc0 // xorl	%r8d, %r8d
+
+LBB2_2:
+	LONG $0x487cb162; WORD $0x0c10; BYTE $0x87 // vmovups	(%rdi,%r8,4), %zmm1
+	LONG $0x487cb162; WORD $0x1410; BYTE $0x86 // vmovups	(%rsi,%r8,4), %zmm2
+	LONG $0x4874f162; WORD $0xda58             // vaddps	%zmm2, %zmm1, %zmm3
+	LONG $0x487cf162; WORD $0xdb59             // vmulps	%zmm3, %zmm0, %zmm3
+	LONG $0x487cb162; WORD $0x1c11; BYTE $0x87 // vmovups	%zmm3, (%rdi,%r8,4)
+	LONG $0x4874f162; WORD $0xca5c             // vsubps	%zmm2, %zmm1, %zmm1
+	LONG $0x487cf162; WORD $0xc959             // vmulps	%zmm1, %zmm0, %zmm1
+	LONG $0x487cb162; WORD $0x0c11; BYTE $0x86 // vmovups	%zmm1, (%rsi,%r8,4)
+	LONG $0x10c08349                           // addq	$16, %r8
+	WORD $0x3949; BYTE $0xc8                   // cmpq	%rcx, %r8
+	JL   LBB2_2
+
+LBB2_3:
+	WORD $0x3948; BYTE $0xc1 // cmpq	%rax, %rcx
+	JE   LBB2_6
+	QUAD $0x0000000085348d48 // leaq	(,%rax,4), %rsi
+	WORD $0x2948; BYTE $0xf2 // subq	%rsi, %rdx
+
+LBB2_5:
+	LONG $0x0410fac5; BYTE $0x8f   // vmovss	(%rdi,%rcx,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x0c10fac5; BYTE $0x8a   // vmovss	(%rdx,%rcx,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5               // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x5459eac5; WORD $0x0c24 // vmulss	12(%rsp), %xmm2, %xmm2
+	LONG $0x1411fac5; BYTE $0x8f   // vmovss	%xmm2, (%rdi,%rcx,4)
+	LONG $0xc15cfac5               // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x4459fac5; WORD $0x0c24 // vmulss	12(%rsp), %xmm0, %xmm0
+	LONG $0x0411fac5; BYTE $0x8a   // vmovss	%xmm0, (%rdx,%rcx,4)
+	WORD $0xff48; BYTE $0xc1       // incq	%rcx
+	WORD $0x3948; BYTE $0xc1       // cmpq	%rax, %rcx
+	JL   LBB2_5
+
+LBB2_6:
+	WORD $0x8948; BYTE $0xec // movq	%rbp, %rsp
+	BYTE $0x5d               // popq	%rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
+
+TEXT ·xvec_avx512_fht_in_place(SB), $0-16
+	MOVQ data+0(FP), DI
+	MOVQ size+8(FP), SI
+	BYTE $0x55                     // pushq	%rbp
+	WORD $0x8948; BYTE $0xe5       // movq	%rsp, %rbp
+	WORD $0x5741                   // pushq	%r15
+	WORD $0x5641                   // pushq	%r14
+	WORD $0x5541                   // pushq	%r13
+	WORD $0x5441                   // pushq	%r12
+	BYTE $0x53                     // pushq	%rbx
+	LONG $0xf8e48348               // andq	$-8, %rsp
+	LONG $0x78ec8348               // subq	$120, %rsp
+	LONG $0x247c8948; BYTE $0x20   // movq	%rdi, 32(%rsp)                  # 8-byte Spill
+	LONG $0x24748948; BYTE $0x18   // movq	%rsi, 24(%rsp)                  # 8-byte Spill
+	LONG $0x02fe8348               // cmpq	$2, %rsi
+	JL   LBB3_28
+	LONG $0x24448b48; BYTE $0x20   // movq	32(%rsp), %rax                  # 8-byte Reload
+	LONG $0x40c08348               // addq	$64, %rax
+	LONG $0x24448948; BYTE $0x30   // movq	%rax, 48(%rsp)                  # 8-byte Spill
+	LONG $0x0001b941; WORD $0x0000 // movl	$1, %r9d
+	JMP  LBB3_2
+
+LBB3_27:
+	LONG $0x244c3b4c; BYTE $0x18 // cmpq	24(%rsp), %r9                   # 8-byte Folded Reload
+	JGE  LBB3_28
+
+LBB3_2:
+	WORD $0x894d; BYTE $0xca               // movq	%r9, %r10
+	WORD $0x014d; BYTE $0xc9               // addq	%r9, %r9
+	WORD $0x894d; BYTE $0xd3               // movq	%r10, %r11
+	LONG $0xf0e38349                       // andq	$-16, %r11
+	LONG $0x0ffa8349                       // cmpq	$15, %r10
+	LONG $0x244c894c; BYTE $0x50           // movq	%r9, 80(%rsp)                   # 8-byte Spill
+	JLE  LBB3_3
+	WORD $0x394d; BYTE $0xd3               // cmpq	%r10, %r11
+	JNE  LBB3_29
+	LONG $0xff428d49                       // leaq	-1(%r10), %rax
+	WORD $0x8948; BYTE $0xc1               // movq	%rax, %rcx
+	LONG $0x04e9c148                       // shrq	$4, %rcx
+	WORD $0xff48; BYTE $0xc1               // incq	%rcx
+	QUAD $0xfffffffffffeba48; WORD $0x1fff // movabsq	$2305843009213693950, %rdx      # imm = 0x1FFFFFFFFFFFFFFE
+	WORD $0x2148; BYTE $0xd1               // andq	%rdx, %rcx
+	QUAD $0x00000000d5148d4a               // leaq	(,%r10,8), %rdx
+	QUAD $0x00000000953c8d4a               // leaq	(,%r10,4), %rdi
+	LONG $0x24448b4c; BYTE $0x30           // movq	48(%rsp), %r8                   # 8-byte Reload
+	WORD $0x3145; BYTE $0xdb               // xorl	%r11d, %r11d
+	JMP  LBB3_10
+
+LBB3_16:
+	WORD $0x014d; BYTE $0xcb     // addq	%r9, %r11
+	WORD $0x0149; BYTE $0xd0     // addq	%rdx, %r8
+	LONG $0x245c3b4c; BYTE $0x18 // cmpq	24(%rsp), %r11                  # 8-byte Folded Reload
+	JGE  LBB3_27
+
+LBB3_10:
+	LONG $0x10f88348 // cmpq	$16, %rax
+	JAE  LBB3_12
+	WORD $0xdb31     // xorl	%ebx, %ebx
+	JMP  LBB3_14
+
+LBB3_12:
+	LONG $0x38348d49         // leaq	(%r8,%rdi), %rsi
+	WORD $0x8949; BYTE $0xce // movq	%rcx, %r14
+	WORD $0xdb31             // xorl	%ebx, %ebx
+
+LBB3_13:
+	QUAD $0xff984410487cd162                   // vmovups	-64(%r8,%rbx,4), %zmm0
+	QUAD $0xff9e4c10487cf162                   // vmovups	-64(%rsi,%rbx,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	QUAD $0xff985411487cd162                   // vmovups	%zmm2, -64(%r8,%rbx,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	QUAD $0xff9e4411487cf162                   // vmovups	%zmm0, -64(%rsi,%rbx,4)
+	LONG $0x487cd162; WORD $0x0410; BYTE $0x98 // vmovups	(%r8,%rbx,4), %zmm0
+	LONG $0x487cf162; WORD $0x0c10; BYTE $0x9e // vmovups	(%rsi,%rbx,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	LONG $0x487cd162; WORD $0x1411; BYTE $0x98 // vmovups	%zmm2, (%r8,%rbx,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	LONG $0x487cf162; WORD $0x0411; BYTE $0x9e // vmovups	%zmm0, (%rsi,%rbx,4)
+	LONG $0x20c38348                           // addq	$32, %rbx
+	LONG $0xfec68349                           // addq	$-2, %r14
+	JNE  LBB3_13
+
+LBB3_14:
+	WORD $0x10a8                               // testb	$16, %al
+	JNE  LBB3_16
+	LONG $0x24748b48; BYTE $0x20               // movq	32(%rsp), %rsi                  # 8-byte Reload
+	LONG $0x9e348d4a                           // leaq	(%rsi,%r11,4), %rsi
+	LONG $0x9e348d4c                           // leaq	(%rsi,%rbx,4), %r14
+	LONG $0x487cf162; WORD $0x0410; BYTE $0x9e // vmovups	(%rsi,%rbx,4), %zmm0
+	LONG $0x487c9162; WORD $0x0c10; BYTE $0x96 // vmovups	(%r14,%r10,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	LONG $0x487cf162; WORD $0x1411; BYTE $0x9e // vmovups	%zmm2, (%rsi,%rbx,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	LONG $0x487c9162; WORD $0x0411; BYTE $0x96 // vmovups	%zmm0, (%r14,%r10,4)
+	JMP  LBB3_16
+
+LBB3_3:
+	LONG $0x245c894c; BYTE $0x10           // movq	%r11, 16(%rsp)                  # 8-byte Spill
+	WORD $0x394d; BYTE $0xd3               // cmpq	%r10, %r11
+	JE   LBB3_27
+	QUAD $0x0000000095048d4a               // leaq	(,%r10,4), %rax
+	WORD $0x8949; BYTE $0xc4               // movq	%rax, %r12
+	LONG $0xc0e48349                       // andq	$-64, %r12
+	LONG $0x246c8b4c; BYTE $0x20           // movq	32(%rsp), %r13                  # 8-byte Reload
+	LONG $0x2c3c8d4b                       // leaq	(%r12,%r13), %rdi
+	LONG $0x244c8b48; BYTE $0x18           // movq	24(%rsp), %rcx                  # 8-byte Reload
+	WORD $0x394c; BYTE $0xc9               // cmpq	%r9, %rcx
+	WORD $0x894d; BYTE $0xc8               // movq	%r9, %r8
+	LONG $0xc14f0f4c                       // cmovgq	%rcx, %r8
+	WORD $0xff49; BYTE $0xc8               // decq	%r8
+	LONG $0x245c8b4c; BYTE $0x10           // movq	16(%rsp), %r11                  # 8-byte Reload
+	WORD $0x894d; BYTE $0xdf               // movq	%r11, %r15
+	LONG $0x01cf8349                       // orq	$1, %r15
+	WORD $0x394d; BYTE $0xfa               // cmpq	%r15, %r10
+	LONG $0xfa4f0f4d                       // cmovgq	%r10, %r15
+	QUAD $0x00000000d51c8d4a               // leaq	(,%r10,8), %rbx
+	WORD $0x894c; BYTE $0xd1               // movq	%r10, %rcx
+	QUAD $0xfffffffffff0ba48; WORD $0x3fff // movabsq	$4611686018427387888, %rdx      # imm = 0x3FFFFFFFFFFFFFF0
+	WORD $0x2148; BYTE $0xd1               // andq	%rdx, %rcx
+	WORD $0x014c; BYTE $0xd1               // addq	%r10, %rcx
+	QUAD $0x000000008d148d48               // leaq	(,%rcx,4), %rdx
+	WORD $0x014c; BYTE $0xea               // addq	%r13, %rdx
+	LONG $0x3a348d4b                       // leaq	(%r10,%r15), %rsi
+	WORD $0x894d; BYTE $0xfe               // movq	%r15, %r14
+	LONG $0xbc0f49f3; BYTE $0xc9           // rep		bsfq	%r9, %rcx
+	WORD $0xd349; BYTE $0xe8               // shrq	%cl, %r8
+	WORD $0x294d; BYTE $0xde               // subq	%r11, %r14
+	LONG $0xc3af0f4c                       // imulq	%rbx, %r8
+	WORD $0x014d; BYTE $0xe8               // addq	%r13, %r8
+	LONG $0xb80c8d4b                       // leaq	(%r8,%r15,4), %rcx
+	LONG $0xb0348d49                       // leaq	(%r8,%rsi,4), %rsi
+	WORD $0x3948; BYTE $0xf7               // cmpq	%rsi, %rdi
+	LONG $0xc6920f40                       // setb	%sil
+	WORD $0x3948; BYTE $0xca               // cmpq	%rcx, %rdx
+	WORD $0x920f; BYTE $0xc2               // setb	%dl
+	WORD $0x2040; BYTE $0xf2               // andb	%sil, %dl
+	WORD $0x8548; BYTE $0xdb               // testq	%rbx, %rbx
+	WORD $0x980f; BYTE $0xc1               // sets	%cl
+	WORD $0xd108                           // orb	%dl, %cl
+	WORD $0x894c; BYTE $0xf2               // movq	%r14, %rdx
+	LONG $0xe0e28348                       // andq	$-32, %rdx
+	LONG $0x24548948; BYTE $0x08           // movq	%rdx, 8(%rsp)                   # 8-byte Spill
+	WORD $0x014c; BYTE $0xda               // addq	%r11, %rdx
+	LONG $0x24548948; BYTE $0x38           // movq	%rdx, 56(%rsp)                  # 8-byte Spill
+	WORD $0x8944; BYTE $0xfa               // movl	%r15d, %edx
+	WORD $0xe283; BYTE $0x03               // andl	$3, %edx
+	LONG $0x24548948; BYTE $0x40           // movq	%rdx, 64(%rsp)                  # 8-byte Spill
+	LONG $0xfce78349                       // andq	$-4, %r15
+	LONG $0x247c894c; BYTE $0x48           // movq	%r15, 72(%rsp)                  # 8-byte Spill
+	LONG $0x2464034c; BYTE $0x30           // addq	48(%rsp), %r12                  # 8-byte Folded Reload
+	LONG $0x01538d49                       // leaq	1(%r11), %rdx
+	WORD $0x3949; BYTE $0xd2               // cmpq	%rdx, %r10
+	LONG $0xd24f0f49                       // cmovgq	%r10, %rdx
+	LONG $0xfce28348                       // andq	$-4, %rdx
+	WORD $0x294c; BYTE $0xda               // subq	%r11, %rdx
+	LONG $0x24548948; BYTE $0x28           // movq	%rdx, 40(%rsp)                  # 8-byte Spill
+	WORD $0x3145; BYTE $0xc0               // xorl	%r8d, %r8d
+	JMP  LBB3_5
+
+LBB3_26:
+	LONG $0x244c8b4c; BYTE $0x50 // movq	80(%rsp), %r9                   # 8-byte Reload
+	WORD $0x014d; BYTE $0xc8     // addq	%r9, %r8
+	WORD $0x0149; BYTE $0xdc     // addq	%rbx, %r12
+	WORD $0x0148; BYTE $0xdf     // addq	%rbx, %rdi
+	WORD $0x0149; BYTE $0xdd     // addq	%rbx, %r13
+	LONG $0x24443b4c; BYTE $0x18 // cmpq	24(%rsp), %r8                   # 8-byte Folded Reload
+	JGE  LBB3_27
+
+LBB3_5:
+	LONG $0x04fe8349             // cmpq	$4, %r14
+	WORD $0x920f; BYTE $0xc2     // setb	%dl
+	WORD $0xca08                 // orb	%cl, %dl
+	LONG $0x245c8b4c; BYTE $0x10 // movq	16(%rsp), %r11                  # 8-byte Reload
+	WORD $0xc2f6; BYTE $0x01     // testb	$1, %dl
+	JNE  LBB3_24
+	LONG $0x20fe8349             // cmpq	$32, %r14
+	JAE  LBB3_17
+	WORD $0xf631                 // xorl	%esi, %esi
+	JMP  LBB3_21
+
+LBB3_17:
+	LONG $0x245c8b4c; BYTE $0x08 // movq	8(%rsp), %r11                   # 8-byte Reload
+	WORD $0x894c; BYTE $0xe2     // movq	%r12, %rdx
+
+LBB3_18:
+	LONG $0x487cf162; WORD $0x4210; BYTE $0xff // vmovups	-64(%rdx), %zmm0
+	LONG $0x487cf162; WORD $0x0a10             // vmovups	(%rdx), %zmm1
+	QUAD $0xff025410487cf162                   // vmovups	-64(%rdx,%rax), %zmm2
+	LONG $0x487cf162; WORD $0x1c10; BYTE $0x02 // vmovups	(%rdx,%rax), %zmm3
+	LONG $0x487cf162; WORD $0xe258             // vaddps	%zmm2, %zmm0, %zmm4
+	LONG $0x4874f162; WORD $0xeb58             // vaddps	%zmm3, %zmm1, %zmm5
+	LONG $0x487cf162; WORD $0x6211; BYTE $0xff // vmovups	%zmm4, -64(%rdx)
+	LONG $0x487cf162; WORD $0x2a11             // vmovups	%zmm5, (%rdx)
+	LONG $0x487cf162; WORD $0xc25c             // vsubps	%zmm2, %zmm0, %zmm0
+	LONG $0x4874f162; WORD $0xcb5c             // vsubps	%zmm3, %zmm1, %zmm1
+	QUAD $0xff024411487cf162                   // vmovups	%zmm0, -64(%rdx,%rax)
+	LONG $0x487cf162; WORD $0x0c11; BYTE $0x02 // vmovups	%zmm1, (%rdx,%rax)
+	LONG $0x80ea8348                           // subq	$-128, %rdx
+	LONG $0xe0c38349                           // addq	$-32, %r11
+	JNE  LBB3_18
+	LONG $0x24743b4c; BYTE $0x08               // cmpq	8(%rsp), %r14                   # 8-byte Folded Reload
+	JE   LBB3_26
+	LONG $0x24748b48; BYTE $0x08               // movq	8(%rsp), %rsi                   # 8-byte Reload
+	LONG $0x245c8b4c; BYTE $0x38               // movq	56(%rsp), %r11                  # 8-byte Reload
+	LONG $0x1cc6f641                           // testb	$28, %r14b
+	JE   LBB3_24
+
+LBB3_21:
+	LONG $0xb7148d48             // leaq	(%rdi,%rsi,4), %rdx
+	LONG $0x021c8d4c             // leaq	(%rdx,%rax), %r11
+	LONG $0x247c8b4c; BYTE $0x28 // movq	40(%rsp), %r15                  # 8-byte Reload
+	WORD $0x2949; BYTE $0xf7     // subq	%rsi, %r15
+	WORD $0xf631                 // xorl	%esi, %esi
+
+LBB3_22:
+	LONG $0x0410f8c5; BYTE $0xb2   // vmovups	(%rdx,%rsi,4), %xmm0
+	LONG $0x1078c1c4; WORD $0xb30c // vmovups	(%r11,%rsi,4), %xmm1
+	LONG $0xd158f8c5               // vaddps	%xmm1, %xmm0, %xmm2
+	LONG $0x1411f8c5; BYTE $0xb2   // vmovups	%xmm2, (%rdx,%rsi,4)
+	LONG $0xc15cf8c5               // vsubps	%xmm1, %xmm0, %xmm0
+	LONG $0x1178c1c4; WORD $0xb304 // vmovups	%xmm0, (%r11,%rsi,4)
+	LONG $0x04c68348               // addq	$4, %rsi
+	WORD $0x3949; BYTE $0xf7       // cmpq	%rsi, %r15
+	JNE  LBB3_22
+	LONG $0x245c8b4c; BYTE $0x48   // movq	72(%rsp), %r11                  # 8-byte Reload
+	LONG $0x247c8348; WORD $0x0040 // cmpq	$0, 64(%rsp)                    # 8-byte Folded Reload
+	JE   LBB3_26
+
+LBB3_24:
+	QUAD $0x000000009d148d4a // leaq	(,%r11,4), %rdx
+	WORD $0x014c; BYTE $0xea // addq	%r13, %rdx
+	LONG $0x023c8d4c         // leaq	(%rdx,%rax), %r15
+	WORD $0xf631             // xorl	%esi, %esi
+
+LBB3_25:
+	LONG $0x0410fac5; BYTE $0xb2   // vmovss	(%rdx,%rsi,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x107ac1c4; WORD $0xb70c // vmovss	(%r15,%rsi,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5               // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x1411fac5; BYTE $0xb2   // vmovss	%xmm2, (%rdx,%rsi,4)
+	LONG $0xc15cfac5               // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x117ac1c4; WORD $0xb704 // vmovss	%xmm0, (%r15,%rsi,4)
+	LONG $0x330c8d4d               // leaq	(%r11,%rsi), %r9
+	WORD $0xff49; BYTE $0xc1       // incq	%r9
+	WORD $0xff48; BYTE $0xc6       // incq	%rsi
+	WORD $0x394d; BYTE $0xd1       // cmpq	%r10, %r9
+	JL   LBB3_25
+	JMP  LBB3_26
+
+LBB3_29:
+	QUAD $0x0000000095348d4e               // leaq	(,%r10,4), %r14
+	LONG $0x2474894c; BYTE $0x08           // movq	%r14, 8(%rsp)                   # 8-byte Spill
+	LONG $0xc0e68349                       // andq	$-64, %r14
+	LONG $0x24448b4c; BYTE $0x20           // movq	32(%rsp), %r8                   # 8-byte Reload
+	LONG $0x303c8d4f                       // leaq	(%r8,%r14), %r15
+	QUAD $0x00000000d5248d4e               // leaq	(,%r10,8), %r12
+	LONG $0x244c8b48; BYTE $0x18           // movq	24(%rsp), %rcx                  # 8-byte Reload
+	WORD $0x394c; BYTE $0xc9               // cmpq	%r9, %rcx
+	WORD $0x894c; BYTE $0xce               // movq	%r9, %rsi
+	LONG $0xf14f0f48                       // cmovgq	%rcx, %rsi
+	WORD $0xff48; BYTE $0xce               // decq	%rsi
+	WORD $0x894c; BYTE $0xdb               // movq	%r11, %rbx
+	LONG $0x01cb8348                       // orq	$1, %rbx
+	WORD $0x3949; BYTE $0xda               // cmpq	%rbx, %r10
+	LONG $0xda4f0f49                       // cmovgq	%r10, %rbx
+	WORD $0x894c; BYTE $0xd1               // movq	%r10, %rcx
+	QUAD $0xfffffffffff0ba48; WORD $0x3fff // movabsq	$4611686018427387888, %rdx      # imm = 0x3FFFFFFFFFFFFFF0
+	WORD $0x2148; BYTE $0xd1               // andq	%rdx, %rcx
+	WORD $0x014c; BYTE $0xd1               // addq	%r10, %rcx
+	LONG $0x88048d49                       // leaq	(%r8,%rcx,4), %rax
+	LONG $0x24448948; BYTE $0x10           // movq	%rax, 16(%rsp)                  # 8-byte Spill
+	LONG $0x1a3c8d49                       // leaq	(%r10,%rbx), %rdi
+	WORD $0x8949; BYTE $0xdd               // movq	%rbx, %r13
+	WORD $0x294d; BYTE $0xdd               // subq	%r11, %r13
+	LONG $0xff538d49                       // leaq	-1(%r11), %rdx
+	WORD $0x8948; BYTE $0xd0               // movq	%rdx, %rax
+	LONG $0x04e8c148                       // shrq	$4, %rax
+	WORD $0xff48; BYTE $0xc0               // incq	%rax
+	LONG $0xbc0f49f3; BYTE $0xc9           // rep		bsfq	%r9, %rcx
+	WORD $0xd348; BYTE $0xee               // shrq	%cl, %rsi
+	QUAD $0xfffffffffffeb948; WORD $0x1fff // movabsq	$2305843009213693950, %rcx      # imm = 0x1FFFFFFFFFFFFFFE
+	WORD $0x2148; BYTE $0xc8               // andq	%rcx, %rax
+	LONG $0x24448948; BYTE $0x40           // movq	%rax, 64(%rsp)                  # 8-byte Spill
+	LONG $0xf4af0f49                       // imulq	%r12, %rsi
+	WORD $0x014c; BYTE $0xc6               // addq	%r8, %rsi
+	LONG $0x9e0c8d48                       // leaq	(%rsi,%rbx,4), %rcx
+	LONG $0xbe048d48                       // leaq	(%rsi,%rdi,4), %rax
+	WORD $0x3949; BYTE $0xc7               // cmpq	%rax, %r15
+	WORD $0x920f; BYTE $0xc0               // setb	%al
+	LONG $0x244c3948; BYTE $0x10           // cmpq	%rcx, 16(%rsp)                  # 8-byte Folded Reload
+	WORD $0x920f; BYTE $0xc1               // setb	%cl
+	WORD $0xc120                           // andb	%al, %cl
+	WORD $0x854d; BYTE $0xe4               // testq	%r12, %r12
+	WORD $0x980f; BYTE $0xc0               // sets	%al
+	WORD $0xc808                           // orb	%cl, %al
+	LONG $0x48244488                       // movb	%al, 72(%rsp)                   # 1-byte Spill
+	WORD $0x894c; BYTE $0xe9               // movq	%r13, %rcx
+	LONG $0xe0e18348                       // andq	$-32, %rcx
+	WORD $0xd889                           // movl	%ebx, %eax
+	WORD $0xe083; BYTE $0x03               // andl	$3, %eax
+	LONG $0x24448948; BYTE $0x70           // movq	%rax, 112(%rsp)                 # 8-byte Spill
+	LONG $0xfce38348                       // andq	$-4, %rbx
+	LONG $0x245c8948; BYTE $0x38           // movq	%rbx, 56(%rsp)                  # 8-byte Spill
+	LONG $0x24448b48; BYTE $0x30           // movq	48(%rsp), %rax                  # 8-byte Reload
+	WORD $0x0149; BYTE $0xc6               // addq	%rax, %r14
+	LONG $0x01738d49                       // leaq	1(%r11), %rsi
+	WORD $0x3949; BYTE $0xf2               // cmpq	%rsi, %r10
+	LONG $0xf24f0f49                       // cmovgq	%r10, %rsi
+	WORD $0x8948; BYTE $0xf7               // movq	%rsi, %rdi
+	WORD $0x294c; BYTE $0xdf               // subq	%r11, %rdi
+	LONG $0xe0e78348                       // andq	$-32, %rdi
+	LONG $0x247c8948; BYTE $0x60           // movq	%rdi, 96(%rsp)                  # 8-byte Spill
+	LONG $0xfce68348                       // andq	$-4, %rsi
+	WORD $0x294c; BYTE $0xde               // subq	%r11, %rsi
+	LONG $0x24748948; BYTE $0x68           // movq	%rsi, 104(%rsp)                 # 8-byte Spill
+	LONG $0x245c894c; BYTE $0x10           // movq	%r11, 16(%rsp)                  # 8-byte Spill
+	LONG $0x244c8948; BYTE $0x28           // movq	%rcx, 40(%rsp)                  # 8-byte Spill
+	WORD $0x014c; BYTE $0xd9               // addq	%r11, %rcx
+	LONG $0x244c8948; BYTE $0x58           // movq	%rcx, 88(%rsp)                  # 8-byte Spill
+	WORD $0x894c; BYTE $0xc7               // movq	%r8, %rdi
+	WORD $0x3145; BYTE $0xc0               // xorl	%r8d, %r8d
+	JMP  LBB3_30
+
+LBB3_48:
+	LONG $0x244c8b4c; BYTE $0x50 // movq	80(%rsp), %r9                   # 8-byte Reload
+	WORD $0x014d; BYTE $0xc8     // addq	%r9, %r8
+	WORD $0x014c; BYTE $0xe0     // addq	%r12, %rax
+	WORD $0x014d; BYTE $0xe6     // addq	%r12, %r14
+	WORD $0x014d; BYTE $0xe7     // addq	%r12, %r15
+	WORD $0x014c; BYTE $0xe7     // addq	%r12, %rdi
+	LONG $0x24443b4c; BYTE $0x18 // cmpq	24(%rsp), %r8                   # 8-byte Folded Reload
+	JGE  LBB3_27
+
+LBB3_30:
+	LONG $0x0ffa8348 // cmpq	$15, %rdx
+	JNE  LBB3_32
+	WORD $0xc931     // xorl	%ecx, %ecx
+	JMP  LBB3_34
+
+LBB3_32:
+	LONG $0x244c8b48; BYTE $0x08 // movq	8(%rsp), %rcx                   # 8-byte Reload
+	LONG $0x081c8d4c             // leaq	(%rax,%rcx), %r11
+	LONG $0x245c8b48; BYTE $0x40 // movq	64(%rsp), %rbx                  # 8-byte Reload
+	WORD $0xc931                 // xorl	%ecx, %ecx
+
+LBB3_33:
+	QUAD $0xff884410487cf162                   // vmovups	-64(%rax,%rcx,4), %zmm0
+	QUAD $0xff8b4c10487cd162                   // vmovups	-64(%r11,%rcx,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	QUAD $0xff885411487cf162                   // vmovups	%zmm2, -64(%rax,%rcx,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	QUAD $0xff8b4411487cd162                   // vmovups	%zmm0, -64(%r11,%rcx,4)
+	LONG $0x487cf162; WORD $0x0410; BYTE $0x88 // vmovups	(%rax,%rcx,4), %zmm0
+	LONG $0x487cd162; WORD $0x0c10; BYTE $0x8b // vmovups	(%r11,%rcx,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	LONG $0x487cf162; WORD $0x1411; BYTE $0x88 // vmovups	%zmm2, (%rax,%rcx,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	LONG $0x487cd162; WORD $0x0411; BYTE $0x8b // vmovups	%zmm0, (%r11,%rcx,4)
+	LONG $0x20c18348                           // addq	$32, %rcx
+	LONG $0xfec38348                           // addq	$-2, %rbx
+	JNE  LBB3_33
+
+LBB3_34:
+	WORD $0xc2f6; BYTE $0x10                   // testb	$16, %dl
+	JNE  LBB3_36
+	LONG $0x24748b48; BYTE $0x20               // movq	32(%rsp), %rsi                  # 8-byte Reload
+	LONG $0x86348d4a                           // leaq	(%rsi,%r8,4), %rsi
+	LONG $0x8e0c8d4c                           // leaq	(%rsi,%rcx,4), %r9
+	LONG $0x487cf162; WORD $0x0410; BYTE $0x8e // vmovups	(%rsi,%rcx,4), %zmm0
+	LONG $0x487c9162; WORD $0x0c10; BYTE $0x91 // vmovups	(%r9,%r10,4), %zmm1
+	LONG $0x487cf162; WORD $0xd158             // vaddps	%zmm1, %zmm0, %zmm2
+	LONG $0x487cf162; WORD $0x1411; BYTE $0x8e // vmovups	%zmm2, (%rsi,%rcx,4)
+	LONG $0x487cf162; WORD $0xc15c             // vsubps	%zmm1, %zmm0, %zmm0
+	LONG $0x487c9162; WORD $0x0411; BYTE $0x91 // vmovups	%zmm0, (%r9,%r10,4)
+
+LBB3_36:
+	LONG $0x04fd8349             // cmpq	$4, %r13
+	LONG $0xc6920f40             // setb	%sil
+	LONG $0x24740a40; BYTE $0x48 // orb	72(%rsp), %sil                  # 1-byte Folded Reload
+	LONG $0x244c8b48; BYTE $0x10 // movq	16(%rsp), %rcx                  # 8-byte Reload
+	LONG $0x01c6f640             // testb	$1, %sil
+	JNE  LBB3_37
+	LONG $0x20fd8349             // cmpq	$32, %r13
+	JAE  LBB3_41
+	WORD $0xf631                 // xorl	%esi, %esi
+	JMP  LBB3_45
+
+LBB3_41:
+	LONG $0x244c8b48; BYTE $0x60 // movq	96(%rsp), %rcx                  # 8-byte Reload
+	WORD $0x894d; BYTE $0xf3     // movq	%r14, %r11
+
+LBB3_42:
+	LONG $0x487cd162; WORD $0x4310; BYTE $0xff // vmovups	-64(%r11), %zmm0
+	LONG $0x487cd162; WORD $0x0b10             // vmovups	(%r11), %zmm1
+	QUAD $0xff935410487c9162                   // vmovups	-64(%r11,%r10,4), %zmm2
+	LONG $0x487c9162; WORD $0x1c10; BYTE $0x93 // vmovups	(%r11,%r10,4), %zmm3
+	LONG $0x487cf162; WORD $0xe258             // vaddps	%zmm2, %zmm0, %zmm4
+	LONG $0x4874f162; WORD $0xeb58             // vaddps	%zmm3, %zmm1, %zmm5
+	LONG $0x487cd162; WORD $0x6311; BYTE $0xff // vmovups	%zmm4, -64(%r11)
+	LONG $0x487cd162; WORD $0x2b11             // vmovups	%zmm5, (%r11)
+	LONG $0x487cf162; WORD $0xc25c             // vsubps	%zmm2, %zmm0, %zmm0
+	LONG $0x4874f162; WORD $0xcb5c             // vsubps	%zmm3, %zmm1, %zmm1
+	QUAD $0xff934411487c9162                   // vmovups	%zmm0, -64(%r11,%r10,4)
+	LONG $0x487c9162; WORD $0x0c11; BYTE $0x93 // vmovups	%zmm1, (%r11,%r10,4)
+	LONG $0x80eb8349                           // subq	$-128, %r11
+	LONG $0xe0c18348                           // addq	$-32, %rcx
+	JNE  LBB3_42
+	LONG $0x246c3b4c; BYTE $0x28               // cmpq	40(%rsp), %r13                  # 8-byte Folded Reload
+	JE   LBB3_48
+	LONG $0x244c8b48; BYTE $0x58               // movq	88(%rsp), %rcx                  # 8-byte Reload
+	LONG $0x24748b48; BYTE $0x28               // movq	40(%rsp), %rsi                  # 8-byte Reload
+	LONG $0x1cc5f641                           // testb	$28, %r13b
+	JE   LBB3_37
+
+LBB3_45:
+	LONG $0xb70c8d49             // leaq	(%r15,%rsi,4), %rcx
+	LONG $0x244c8b4c; BYTE $0x08 // movq	8(%rsp), %r9                    # 8-byte Reload
+	LONG $0x091c8d4e             // leaq	(%rcx,%r9), %r11
+	LONG $0x245c8b48; BYTE $0x68 // movq	104(%rsp), %rbx                 # 8-byte Reload
+	WORD $0x2948; BYTE $0xf3     // subq	%rsi, %rbx
+	WORD $0xf631                 // xorl	%esi, %esi
+
+LBB3_46:
+	LONG $0x0410f8c5; BYTE $0xb1   // vmovups	(%rcx,%rsi,4), %xmm0
+	LONG $0x1078c1c4; WORD $0xb30c // vmovups	(%r11,%rsi,4), %xmm1
+	LONG $0xd158f8c5               // vaddps	%xmm1, %xmm0, %xmm2
+	LONG $0x1411f8c5; BYTE $0xb1   // vmovups	%xmm2, (%rcx,%rsi,4)
+	LONG $0xc15cf8c5               // vsubps	%xmm1, %xmm0, %xmm0
+	LONG $0x1178c1c4; WORD $0xb304 // vmovups	%xmm0, (%r11,%rsi,4)
+	LONG $0x04c68348               // addq	$4, %rsi
+	WORD $0x3948; BYTE $0xf3       // cmpq	%rsi, %rbx
+	JNE  LBB3_46
+	LONG $0x244c8b48; BYTE $0x38   // movq	56(%rsp), %rcx                  # 8-byte Reload
+	LONG $0x247c8348; WORD $0x0070 // cmpq	$0, 112(%rsp)                   # 8-byte Folded Reload
+	JE   LBB3_48
+
+LBB3_37:
+	LONG $0x8f1c8d4c             // leaq	(%rdi,%rcx,4), %r11
+	LONG $0x24748b48; BYTE $0x08 // movq	8(%rsp), %rsi                   # 8-byte Reload
+	LONG $0x331c8d49             // leaq	(%r11,%rsi), %rbx
+	WORD $0xf631                 // xorl	%esi, %esi
+
+LBB3_38:
+	LONG $0x107ac1c4; WORD $0xb304 // vmovss	(%r11,%rsi,4), %xmm0            # xmm0 = mem[0],zero,zero,zero
+	LONG $0x0c10fac5; BYTE $0xb3   // vmovss	(%rbx,%rsi,4), %xmm1            # xmm1 = mem[0],zero,zero,zero
+	LONG $0xd158fac5               // vaddss	%xmm1, %xmm0, %xmm2
+	LONG $0x117ac1c4; WORD $0xb314 // vmovss	%xmm2, (%r11,%rsi,4)
+	LONG $0xc15cfac5               // vsubss	%xmm1, %xmm0, %xmm0
+	LONG $0x0411fac5; BYTE $0xb3   // vmovss	%xmm0, (%rbx,%rsi,4)
+	LONG $0x310c8d4c               // leaq	(%rcx,%rsi), %r9
+	WORD $0xff49; BYTE $0xc1       // incq	%r9
+	WORD $0xff48; BYTE $0xc6       // incq	%rsi
+	WORD $0x394d; BYTE $0xd1       // cmpq	%r10, %r9
+	JL   LBB3_38
+	JMP  LBB3_48
+
+LBB3_28:
+	LONG $0xd8658d48         // leaq	-40(%rbp), %rsp
+	BYTE $0x5b               // popq	%rbx
+	WORD $0x5c41             // popq	%r12
+	WORD $0x5d41             // popq	%r13
+	WORD $0x5e41             // popq	%r14
+	WORD $0x5f41             // popq	%r15
+	BYTE $0x5d               // popq	%rbp
+	WORD $0xf8c5; BYTE $0x77 // vzeroupper
+	RET
diff --git a/internal/ailego/math/fht_neon.go b/internal/ailego/math/fht_neon.go
new file mode 100644
index 0000000..b6cdf25
--- /dev/null
+++ b/internal/ailego/math/fht_neon.go
@@ -0,0 +1,23 @@
+//go:build !noasm && arm64
+// Code generated by GoAT. DO NOT EDIT.
+// versions:
+// 	clang   21.1.8 (6ubuntu1)
+// 	objdump 2.46
+// flags: -O3
+// source: src/fht_neon.c
+
+package mathutil
+
+import "unsafe"
+
+//go:noescape
+func xvec_neon_fht_flip_signs(signs, data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_neon_fht_kac_walk(data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_neon_fht_inverse_kac_walk(data unsafe.Pointer, size int64)
+
+//go:noescape
+func xvec_neon_fht_in_place(data unsafe.Pointer, size int64)
diff --git a/internal/ailego/math/fht_neon.s b/internal/ailego/math/fht_neon.s
new file mode 100644
index 0000000..759fbc2
--- /dev/null
+++ b/internal/ailego/math/fht_neon.s
@@ -0,0 +1,515 @@
+//go:build !noasm && arm64
+// Code generated by GoAT. DO NOT EDIT.
+// versions:
+// 	clang   21.1.8 (6ubuntu1)
+// 	objdump 2.46
+// flags: -O3
+// source: src/fht_neon.c
+
+TEXT ·xvec_neon_fht_flip_signs(SB), $0-24
+	MOVD signs+0(FP), R0
+	MOVD data+8(FP), R1
+	MOVD size+16(FP), R2
+	WORD $0xd10043ff     // sub	sp, sp, #16
+	WORD $0xf100105f     // cmp	x2, #4
+	WORD $0x927ef448     // and	x8, x2, #0xfffffffffffffffc
+	BLT  LBB0_5
+	WORD $0x91001c4a     // add	x10, x2, #7
+	WORD $0xaa1f03e9     // mov	x9, xzr
+	WORD $0x910003eb     // mov	x11, sp
+	WORD $0xd343fd4a     // lsr	x10, x10, #3
+	WORD $0xaa0103ec     // mov	x12, x1
+	B    LBB0_3
+
+LBB0_2:
+	WORD $0x12003dad // and	w13, w13, #0xffff
+	WORD $0x927e012e // and	x14, x9, #0x4
+	WORD $0x91001129 // add	x9, x9, #4
+	WORD $0x1ace25ad // lsr	w13, w13, w14
+	WORD $0xeb08013f // cmp	x9, x8
+	WORD $0x121f01af // and	w15, w13, #0x2
+	WORD $0x530101ae // lsl	w14, w13, #31
+	WORD $0x530309b0 // lsl	w16, w13, #29
+	WORD $0x121d01ad // and	w13, w13, #0x8
+	WORD $0xd341fdef // lsr	x15, x15, #1
+	WORD $0xd343fdad // lsr	x13, x13, #3
+	WORD $0xb34101ee // bfi	x14, x15, #63, #1
+	WORD $0x1201020f // and	w15, w16, #0x80000000
+	WORD $0xb34101af // bfi	x15, x13, #63, #1
+	WORD $0xf90007ee // str	x14, [sp, #8]
+	WORD $0xf90003ef // str	x15, [sp]
+	WORD $0xfd4007e0 // ldr	d0, [sp, #8]
+	WORD $0x4d408560 // ld1	{ v0.d }[1], [x11]
+	WORD $0x3dc00181 // ldr	q1, [x12]
+	WORD $0x6e201c20 // eor	v0.16b, v1.16b, v0.16b
+	WORD $0x3c810580 // str	q0, [x12], #16
+	BGE  LBB0_5
+
+LBB0_3:
+	WORD $0xd343fd2d // lsr	x13, x9, #3
+	WORD $0x910005ae // add	x14, x13, #1
+	WORD $0x386d680d // ldrb	w13, [x0, x13]
+	WORD $0xeb0a01df // cmp	x14, x10
+	BHS  LBB0_2
+	WORD $0x386e680e // ldrb	w14, [x0, x14]
+	WORD $0x2a0e21ad // orr	w13, w13, w14, lsl #8
+	B    LBB0_2
+
+LBB0_5:
+	WORD $0xeb02011f // cmp	x8, x2
+	BNE  LBB0_8
+
+LBB0_6:
+	WORD $0x910043ff // add	sp, sp, #16
+	RET
+
+LBB0_7:
+	WORD $0x91000508 // add	x8, x8, #1
+	WORD $0xeb02011f // cmp	x8, x2
+	BGE  LBB0_6
+
+LBB0_8:
+	WORD $0x91001d09 // add	x9, x8, #7
+	WORD $0xf100011f // cmp	x8, #0
+	WORD $0x9a88b129 // csel	x9, x9, x8, lt
+	WORD $0x9343fd29 // asr	x9, x9, #3
+	WORD $0x3869680a // ldrb	w10, [x0, x9]
+	WORD $0x4b090d09 // sub	w9, w8, w9, lsl #3
+	WORD $0x1ac92549 // lsr	w9, w10, w9
+	WORD $0x3607fec9 // tbz	w9, #0, .LBB0_7
+	WORD $0xbc687820 // ldr	s0, [x1, x8, lsl #2]
+	WORD $0x1e214000 // fneg	s0, s0
+	WORD $0xbc287820 // str	s0, [x1, x8, lsl #2]
+	B    LBB0_7
+
+TEXT ·xvec_neon_fht_kac_walk(SB), $0-16
+	MOVD data+0(FP), R0
+	MOVD size+8(FP), R1
+	WORD $0x8b41fc28    // add	x8, x1, x1, lsr #63
+	WORD $0xf100203f    // cmp	x1, #8
+	WORD $0x9341fd08    // asr	x8, x8, #1
+	WORD $0x927ef509    // and	x9, x8, #0xfffffffffffffffc
+	BLT  LBB1_3
+	WORD $0xd37ef42b    // lsl	x11, x1, #2
+	WORD $0xaa1f03ea    // mov	x10, xzr
+	WORD $0xaa0003ec    // mov	x12, x0
+	WORD $0xcb08096b    // sub	x11, x11, x8, lsl #2
+
+LBB1_2:
+	WORD $0x3dc00180 // ldr	q0, [x12]
+	WORD $0x3ceb6981 // ldr	q1, [x12, x11]
+	WORD $0x9100114a // add	x10, x10, #4
+	WORD $0xeb09015f // cmp	x10, x9
+	WORD $0x4e21d402 // fadd	v2.4s, v0.4s, v1.4s
+	WORD $0x4ea1d400 // fsub	v0.4s, v0.4s, v1.4s
+	WORD $0x3d800182 // str	q2, [x12]
+	WORD $0x3cab6980 // str	q0, [x12, x11]
+	WORD $0x9100418c // add	x12, x12, #16
+	BLT  LBB1_2
+
+LBB1_3:
+	WORD $0xeb08013f // cmp	x9, x8
+	BEQ  LBB1_11
+	WORD $0xb240012b // orr	x11, x9, #0x1
+	WORD $0xeb0b011f // cmp	x8, x11
+	WORD $0x9a89c50a // csinc	x10, x8, x9, gt
+	WORD $0xcb09014a // sub	x10, x10, x9
+	WORD $0xf100415f // cmp	x10, #16
+	BLO  LBB1_9
+	WORD $0xeb0b011f // cmp	x8, x11
+	WORD $0xd342fd0c // lsr	x12, x8, #2
+	WORD $0x927eed0d // and	x13, x8, #0x3ffffffffffffffc
+	WORD $0x9a89c50b // csinc	x11, x8, x9, gt
+	WORD $0x8b0d002d // add	x13, x1, x13
+	WORD $0x8b0b002e // add	x14, x1, x11
+	WORD $0x8b0c100c // add	x12, x0, x12, lsl #4
+	WORD $0xcb0801ad // sub	x13, x13, x8
+	WORD $0xcb0801ce // sub	x14, x14, x8
+	WORD $0x8b0b080b // add	x11, x0, x11, lsl #2
+	WORD $0x8b0d080d // add	x13, x0, x13, lsl #2
+	WORD $0x8b0e080e // add	x14, x0, x14, lsl #2
+	WORD $0xeb0e019f // cmp	x12, x14
+	WORD $0xfa4b31a2 // ccmp	x13, x11, #2, lo
+	BLO  LBB1_9
+	WORD $0xd37ef50d // lsl	x13, x8, #2
+	WORD $0xd37ef42e // lsl	x14, x1, #2
+	WORD $0x927df14b // and	x11, x10, #0xfffffffffffffff8
+	WORD $0x8b0b0129 // add	x9, x9, x11
+	WORD $0x927cedac // and	x12, x13, #0xfffffffffffffff0
+	WORD $0xcb0d01cd // sub	x13, x14, x13
+	WORD $0xaa0b03ee // mov	x14, x11
+	WORD $0x8b00018c // add	x12, x12, x0
+	WORD $0x9100418c // add	x12, x12, #16
+
+LBB1_7:
+	WORD $0x8b0d018f // add	x15, x12, x13
+	WORD $0xad7f8981 // ldp	q1, q2, [x12, #-16]
+	WORD $0xad7f8de0 // ldp	q0, q3, [x15, #-16]
+	WORD $0xf10021ce // subs	x14, x14, #8
+	WORD $0x4e20d424 // fadd	v4.4s, v1.4s, v0.4s
+	WORD $0x4e23d445 // fadd	v5.4s, v2.4s, v3.4s
+	WORD $0x4ea0d420 // fsub	v0.4s, v1.4s, v0.4s
+	WORD $0x4ea3d441 // fsub	v1.4s, v2.4s, v3.4s
+	WORD $0xad3f9584 // stp	q4, q5, [x12, #-16]
+	WORD $0x9100818c // add	x12, x12, #32
+	WORD $0xad3f85e0 // stp	q0, q1, [x15, #-16]
+	BNE  LBB1_7
+	WORD $0xeb0b015f // cmp	x10, x11
+	BEQ  LBB1_11
+
+LBB1_9:
+	WORD $0xcb08080a // sub	x10, x0, x8, lsl #2
+	WORD $0x8b01094a // add	x10, x10, x1, lsl #2
+
+LBB1_10:
+	WORD $0xbc697800 // ldr	s0, [x0, x9, lsl #2]
+	WORD $0xbc697941 // ldr	s1, [x10, x9, lsl #2]
+	WORD $0x1e212802 // fadd	s2, s0, s1
+	WORD $0x1e213800 // fsub	s0, s0, s1
+	WORD $0xbc297802 // str	s2, [x0, x9, lsl #2]
+	WORD $0xbc297940 // str	s0, [x10, x9, lsl #2]
+	WORD $0x91000529 // add	x9, x9, #1
+	WORD $0xeb08013f // cmp	x9, x8
+	BLT  LBB1_10
+
+LBB1_11:
+	RET
+
+TEXT ·xvec_neon_fht_inverse_kac_walk(SB), $0-16
+	MOVD data+0(FP), R0
+	MOVD size+8(FP), R1
+	WORD $0x8b41fc28    // add	x8, x1, x1, lsr #63
+	WORD $0xf100203f    // cmp	x1, #8
+	WORD $0x9341fd08    // asr	x8, x8, #1
+	WORD $0x927ef509    // and	x9, x8, #0xfffffffffffffffc
+	BLT  LBB2_3
+	WORD $0xd37ef42b    // lsl	x11, x1, #2
+	WORD $0x4f0167e0    // movi	v0.4s, #63, lsl #24
+	WORD $0xaa1f03ea    // mov	x10, xzr
+	WORD $0xaa0003ec    // mov	x12, x0
+	WORD $0xcb08096b    // sub	x11, x11, x8, lsl #2
+
+LBB2_2:
+	WORD $0x3dc00181 // ldr	q1, [x12]
+	WORD $0x3ceb6982 // ldr	q2, [x12, x11]
+	WORD $0x9100114a // add	x10, x10, #4
+	WORD $0xeb09015f // cmp	x10, x9
+	WORD $0x4e22d423 // fadd	v3.4s, v1.4s, v2.4s
+	WORD $0x4ea2d421 // fsub	v1.4s, v1.4s, v2.4s
+	WORD $0x6e20dc62 // fmul	v2.4s, v3.4s, v0.4s
+	WORD $0x6e20dc21 // fmul	v1.4s, v1.4s, v0.4s
+	WORD $0x3d800182 // str	q2, [x12]
+	WORD $0x3cab6981 // str	q1, [x12, x11]
+	WORD $0x9100418c // add	x12, x12, #16
+	BLT  LBB2_2
+
+LBB2_3:
+	WORD $0xeb08013f // cmp	x9, x8
+	BEQ  LBB2_11
+	WORD $0xb240012c // orr	x12, x9, #0x1
+	WORD $0xeb0c011f // cmp	x8, x12
+	WORD $0x9a89c50a // csinc	x10, x8, x9, gt
+	WORD $0xcb09014b // sub	x11, x10, x9
+	WORD $0xf100317f // cmp	x11, #12
+	BLO  LBB2_9
+	WORD $0xeb0c011f // cmp	x8, x12
+	WORD $0xd342fd0d // lsr	x13, x8, #2
+	WORD $0x927eed0e // and	x14, x8, #0x3ffffffffffffffc
+	WORD $0x9a89c50c // csinc	x12, x8, x9, gt
+	WORD $0x8b0e002e // add	x14, x1, x14
+	WORD $0x8b0c002f // add	x15, x1, x12
+	WORD $0x8b0d100d // add	x13, x0, x13, lsl #4
+	WORD $0xcb0801ce // sub	x14, x14, x8
+	WORD $0xcb0801ef // sub	x15, x15, x8
+	WORD $0x8b0c080c // add	x12, x0, x12, lsl #2
+	WORD $0x8b0e080e // add	x14, x0, x14, lsl #2
+	WORD $0x8b0f080f // add	x15, x0, x15, lsl #2
+	WORD $0xeb0f01bf // cmp	x13, x15
+	WORD $0xfa4c31c2 // ccmp	x14, x12, #2, lo
+	BLO  LBB2_9
+	WORD $0xd37ef42d // lsl	x13, x1, #2
+	WORD $0x4f0167e0 // movi	v0.4s, #63, lsl #24
+	WORD $0x9240054a // and	x10, x10, #0x3
+	WORD $0xcb0a016b // sub	x11, x11, x10
+	WORD $0x8b09080c // add	x12, x0, x9, lsl #2
+	WORD $0xcb0809ad // sub	x13, x13, x8, lsl #2
+	WORD $0x8b0b0129 // add	x9, x9, x11
+
+LBB2_7:
+	WORD $0x3dc00181 // ldr	q1, [x12]
+	WORD $0x3ced6982 // ldr	q2, [x12, x13]
+	WORD $0xf100116b // subs	x11, x11, #4
+	WORD $0x4e22d423 // fadd	v3.4s, v1.4s, v2.4s
+	WORD $0x4ea2d421 // fsub	v1.4s, v1.4s, v2.4s
+	WORD $0x6e20dc62 // fmul	v2.4s, v3.4s, v0.4s
+	WORD $0x6e20dc21 // fmul	v1.4s, v1.4s, v0.4s
+	WORD $0x3cad6981 // str	q1, [x12, x13]
+	WORD $0x3c810582 // str	q2, [x12], #16
+	BNE  LBB2_7
+	WORD $0xb40001ea // cbz	x10, .LBB2_11
+
+LBB2_9:
+	WORD $0xcb08080a // sub	x10, x0, x8, lsl #2
+	WORD $0x1e2c1000 // fmov	s0, #0.50000000
+	WORD $0x8b01094a // add	x10, x10, x1, lsl #2
+
+LBB2_10:
+	WORD $0xbc697801 // ldr	s1, [x0, x9, lsl #2]
+	WORD $0xbc697942 // ldr	s2, [x10, x9, lsl #2]
+	WORD $0x1e222823 // fadd	s3, s1, s2
+	WORD $0x1e223821 // fsub	s1, s1, s2
+	WORD $0x1e200862 // fmul	s2, s3, s0
+	WORD $0x1e200821 // fmul	s1, s1, s0
+	WORD $0xbc297802 // str	s2, [x0, x9, lsl #2]
+	WORD $0xbc297941 // str	s1, [x10, x9, lsl #2]
+	WORD $0x91000529 // add	x9, x9, #1
+	WORD $0xeb08013f // cmp	x9, x8
+	BLT  LBB2_10
+
+LBB2_11:
+	RET
+
+TEXT ·xvec_neon_fht_in_place(SB), $0-16
+	MOVD data+0(FP), R0
+	MOVD size+8(FP), R1
+	WORD $0xf100083f    // cmp	x1, #2
+	BLT  LBB3_29
+	WORD $0xf81e0ff5    // str	x21, [sp, #-32]!
+	WORD $0x91004008    // add	x8, x0, #16
+	WORD $0x52800029    // mov	w9, #1
+	WORD $0xa9014ff4    // stp	x20, x19, [sp, #16]
+	B    LBB3_3
+
+LBB3_2:
+	WORD $0xeb01015f // cmp	x10, x1
+	WORD $0xaa0a03e9 // mov	x9, x10
+	BGE  LBB3_28
+
+LBB3_3:
+	WORD $0xd37ff92a // lsl	x10, x9, #1
+	WORD $0xf1000d3f // cmp	x9, #3
+	WORD $0x927ef52b // and	x11, x9, #0xfffffffffffffffc
+	BLE  LBB3_9
+	WORD $0xeb09017f // cmp	x11, x9
+	BNE  LBB3_18
+	WORD $0xd37df12c // lsl	x12, x9, #3
+	WORD $0xd37ef52d // lsl	x13, x9, #2
+	WORD $0xaa1f03eb // mov	x11, xzr
+	WORD $0xaa0003ee // mov	x14, x0
+
+LBB3_6:
+	WORD $0xaa1f03ef // mov	x15, xzr
+	WORD $0xaa0e03f0 // mov	x16, x14
+
+LBB3_7:
+	WORD $0x3dc00200 // ldr	q0, [x16]
+	WORD $0x3ced6a01 // ldr	q1, [x16, x13]
+	WORD $0x910011ef // add	x15, x15, #4
+	WORD $0xeb0901ff // cmp	x15, x9
+	WORD $0x4e21d402 // fadd	v2.4s, v0.4s, v1.4s
+	WORD $0x4ea1d400 // fsub	v0.4s, v0.4s, v1.4s
+	WORD $0x3d800202 // str	q2, [x16]
+	WORD $0x3cad6a00 // str	q0, [x16, x13]
+	WORD $0x91004210 // add	x16, x16, #16
+	BLT  LBB3_7
+	WORD $0x8b0a016b // add	x11, x11, x10
+	WORD $0x8b0c01ce // add	x14, x14, x12
+	WORD $0xeb01017f // cmp	x11, x1
+	BLT  LBB3_6
+	B    LBB3_2
+
+LBB3_9:
+	WORD $0xeb09017f // cmp	x11, x9
+	BEQ  LBB3_2
+	WORD $0xeb0a003f // cmp	x1, x10
+	WORD $0xdac0014d // rbit	x13, x10
+	WORD $0x927eed31 // and	x17, x9, #0x3ffffffffffffffc
+	WORD $0x9a8ac02e // csel	x14, x1, x10, gt
+	WORD $0x8b110131 // add	x17, x9, x17
+	WORD $0xaa1f03ec // mov	x12, xzr
+	WORD $0xd10005ce // sub	x14, x14, #1
+	WORD $0xdac011af // clz	x15, x13
+	WORD $0xd37df12d // lsl	x13, x9, #3
+	WORD $0x9acf25ce // lsr	x14, x14, x15
+	WORD $0x8b110811 // add	x17, x0, x17, lsl #2
+	WORD $0x9b0e01af // madd	x15, x13, x14, x0
+	WORD $0xb240016e // orr	x14, x11, #0x1
+	WORD $0xeb0e013f // cmp	x9, x14
+	WORD $0xd37ef52e // lsl	x14, x9, #2
+	WORD $0x9a8bc530 // csinc	x16, x9, x11, gt
+	WORD $0x8b100122 // add	x2, x9, x16
+	WORD $0x927cedc3 // and	x3, x14, #0xfffffffffffffff0
+	WORD $0x8b030004 // add	x4, x0, x3
+	WORD $0x8b030103 // add	x3, x8, x3
+	WORD $0x8b0209e2 // add	x2, x15, x2, lsl #2
+	WORD $0x8b1009ef // add	x15, x15, x16, lsl #2
+	WORD $0xeb02009f // cmp	x4, x2
+	WORD $0xaa0003e4 // mov	x4, x0
+	WORD $0xfa4f3222 // ccmp	x17, x15, #2, lo
+	WORD $0xcb0b020f // sub	x15, x16, x11
+	WORD $0xfa4029a8 // ccmp	x13, #0, #8, hs
+	WORD $0x927df1f0 // and	x16, x15, #0xfffffffffffffff8
+	WORD $0x1a9fa7f1 // cset	w17, lt
+	WORD $0x8b100162 // add	x2, x11, x16
+	B    LBB3_12
+
+LBB3_11:
+	WORD $0x8b0a018c // add	x12, x12, x10
+	WORD $0x8b0d0063 // add	x3, x3, x13
+	WORD $0x8b0d0084 // add	x4, x4, x13
+	WORD $0xeb01019f // cmp	x12, x1
+	BGE  LBB3_2
+
+LBB3_12:
+	WORD $0xf10021ff // cmp	x15, #8
+	WORD $0x1a9f27e5 // cset	w5, lo
+	WORD $0x2a1100a6 // orr	w6, w5, w17
+	WORD $0xaa0b03e5 // mov	x5, x11
+	WORD $0x37000246 // tbnz	w6, #0, .LBB3_16
+	WORD $0xaa0303e5 // mov	x5, x3
+	WORD $0xaa1003e6 // mov	x6, x16
+
+LBB3_14:
+	WORD $0x8b0e00a7 // add	x7, x5, x14
+	WORD $0xad7f88a1 // ldp	q1, q2, [x5, #-16]
+	WORD $0xad7f8ce0 // ldp	q0, q3, [x7, #-16]
+	WORD $0xf10020c6 // subs	x6, x6, #8
+	WORD $0x4e20d424 // fadd	v4.4s, v1.4s, v0.4s
+	WORD $0x4e23d445 // fadd	v5.4s, v2.4s, v3.4s
+	WORD $0x4ea0d420 // fsub	v0.4s, v1.4s, v0.4s
+	WORD $0x4ea3d441 // fsub	v1.4s, v2.4s, v3.4s
+	WORD $0xad3f94a4 // stp	q4, q5, [x5, #-16]
+	WORD $0x910080a5 // add	x5, x5, #32
+	WORD $0xad3f84e0 // stp	q0, q1, [x7, #-16]
+	BNE  LBB3_14
+	WORD $0xeb1001ff // cmp	x15, x16
+	WORD $0xaa0203e5 // mov	x5, x2
+	BEQ  LBB3_11
+
+LBB3_16:
+	WORD $0x8b050887 // add	x7, x4, x5, lsl #2
+	WORD $0xaa1f03e6 // mov	x6, xzr
+	WORD $0x8b0e00f3 // add	x19, x7, x14
+
+LBB3_17:
+	WORD $0xbc6678e0 // ldr	s0, [x7, x6, lsl #2]
+	WORD $0xbc667a61 // ldr	s1, [x19, x6, lsl #2]
+	WORD $0x1e212802 // fadd	s2, s0, s1
+	WORD $0x1e213800 // fsub	s0, s0, s1
+	WORD $0xbc2678e2 // str	s2, [x7, x6, lsl #2]
+	WORD $0xbc267a60 // str	s0, [x19, x6, lsl #2]
+	WORD $0x910004c6 // add	x6, x6, #1
+	WORD $0x8b0600b4 // add	x20, x5, x6
+	WORD $0xeb09029f // cmp	x20, x9
+	BLT  LBB3_17
+	B    LBB3_11
+
+LBB3_18:
+	WORD $0xeb0a003f // cmp	x1, x10
+	WORD $0xdac0014d // rbit	x13, x10
+	WORD $0x927eed31 // and	x17, x9, #0x3ffffffffffffffc
+	WORD $0x9a8ac02e // csel	x14, x1, x10, gt
+	WORD $0x8b110131 // add	x17, x9, x17
+	WORD $0xaa1f03ec // mov	x12, xzr
+	WORD $0xd10005ce // sub	x14, x14, #1
+	WORD $0xdac011af // clz	x15, x13
+	WORD $0xd37df12d // lsl	x13, x9, #3
+	WORD $0x9acf25ce // lsr	x14, x14, x15
+	WORD $0x8b110811 // add	x17, x0, x17, lsl #2
+	WORD $0xaa0003e5 // mov	x5, x0
+	WORD $0x9b0e01af // madd	x15, x13, x14, x0
+	WORD $0xb240016e // orr	x14, x11, #0x1
+	WORD $0xeb0e013f // cmp	x9, x14
+	WORD $0xd37ef52e // lsl	x14, x9, #2
+	WORD $0x9a8bc530 // csinc	x16, x9, x11, gt
+	WORD $0x8b100122 // add	x2, x9, x16
+	WORD $0x927cedc4 // and	x4, x14, #0xfffffffffffffff0
+	WORD $0x8b040003 // add	x3, x0, x4
+	WORD $0x8b040104 // add	x4, x8, x4
+	WORD $0x8b0209e2 // add	x2, x15, x2, lsl #2
+	WORD $0x8b1009ef // add	x15, x15, x16, lsl #2
+	WORD $0xeb02007f // cmp	x3, x2
+	WORD $0xfa4f3222 // ccmp	x17, x15, #2, lo
+	WORD $0x91000571 // add	x17, x11, #1
+	WORD $0xcb0b020f // sub	x15, x16, x11
+	WORD $0xfa4029a8 // ccmp	x13, #0, #8, hs
+	WORD $0x1a9fa7f0 // cset	w16, lt
+	WORD $0xeb11013f // cmp	x9, x17
+	WORD $0x927df1f1 // and	x17, x15, #0xfffffffffffffff8
+	WORD $0x9a8bc523 // csinc	x3, x9, x11, gt
+	WORD $0x8b110162 // add	x2, x11, x17
+	WORD $0xcb0b0063 // sub	x3, x3, x11
+	WORD $0x927df063 // and	x3, x3, #0xfffffffffffffff8
+	B    LBB3_20
+
+LBB3_19:
+	WORD $0x8b0a018c // add	x12, x12, x10
+	WORD $0x8b0d00a5 // add	x5, x5, x13
+	WORD $0x8b0d0084 // add	x4, x4, x13
+	WORD $0xeb01019f // cmp	x12, x1
+	BGE  LBB3_2
+
+LBB3_20:
+	WORD $0xaa1f03e6 // mov	x6, xzr
+	WORD $0xaa0503e7 // mov	x7, x5
+
+LBB3_21:
+	WORD $0x3dc000e0 // ldr	q0, [x7]
+	WORD $0x3cee68e1 // ldr	q1, [x7, x14]
+	WORD $0x910010c6 // add	x6, x6, #4
+	WORD $0xeb0b00df // cmp	x6, x11
+	WORD $0x4e21d402 // fadd	v2.4s, v0.4s, v1.4s
+	WORD $0x4ea1d400 // fsub	v0.4s, v0.4s, v1.4s
+	WORD $0x3d8000e2 // str	q2, [x7]
+	WORD $0x3cae68e0 // str	q0, [x7, x14]
+	WORD $0x910040e7 // add	x7, x7, #16
+	BLT  LBB3_21
+	WORD $0xf10021ff // cmp	x15, #8
+	WORD $0x1a9f27e6 // cset	w6, lo
+	WORD $0x2a1000c7 // orr	w7, w6, w16
+	WORD $0xaa0b03e6 // mov	x6, x11
+	WORD $0x37000247 // tbnz	w7, #0, .LBB3_26
+	WORD $0xaa0403e6 // mov	x6, x4
+	WORD $0xaa0303e7 // mov	x7, x3
+
+LBB3_24:
+	WORD $0x8b0e00d3 // add	x19, x6, x14
+	WORD $0xad7f88c1 // ldp	q1, q2, [x6, #-16]
+	WORD $0xad7f8e60 // ldp	q0, q3, [x19, #-16]
+	WORD $0xf10020e7 // subs	x7, x7, #8
+	WORD $0x4e20d424 // fadd	v4.4s, v1.4s, v0.4s
+	WORD $0x4e23d445 // fadd	v5.4s, v2.4s, v3.4s
+	WORD $0x4ea0d420 // fsub	v0.4s, v1.4s, v0.4s
+	WORD $0x4ea3d441 // fsub	v1.4s, v2.4s, v3.4s
+	WORD $0xad3f94c4 // stp	q4, q5, [x6, #-16]
+	WORD $0x910080c6 // add	x6, x6, #32
+	WORD $0xad3f8660 // stp	q0, q1, [x19, #-16]
+	BNE  LBB3_24
+	WORD $0xeb1101ff // cmp	x15, x17
+	WORD $0xaa0203e6 // mov	x6, x2
+	BEQ  LBB3_19
+
+LBB3_26:
+	WORD $0x8b0608b3 // add	x19, x5, x6, lsl #2
+	WORD $0xaa1f03e7 // mov	x7, xzr
+	WORD $0x8b0e0274 // add	x20, x19, x14
+
+LBB3_27:
+	WORD $0xbc677a60 // ldr	s0, [x19, x7, lsl #2]
+	WORD $0xbc677a81 // ldr	s1, [x20, x7, lsl #2]
+	WORD $0x1e212802 // fadd	s2, s0, s1
+	WORD $0x1e213800 // fsub	s0, s0, s1
+	WORD $0xbc277a62 // str	s2, [x19, x7, lsl #2]
+	WORD $0xbc277a80 // str	s0, [x20, x7, lsl #2]
+	WORD $0x910004e7 // add	x7, x7, #1
+	WORD $0x8b0700d5 // add	x21, x6, x7
+	WORD $0xeb0902bf // cmp	x21, x9
+	BLT  LBB3_27
+	B    LBB3_19
+
+LBB3_28:
+	WORD $0xa9414ff4 // ldp	x20, x19, [sp, #16]
+	WORD $0xf84207f5 // ldr	x21, [sp], #32
+
+LBB3_29:
+	RET
diff --git a/internal/ailego/math/fht_test.go b/internal/ailego/math/fht_test.go
index 55fb64d..efad955 100644
--- a/internal/ailego/math/fht_test.go
+++ b/internal/ailego/math/fht_test.go
@@ -15,12 +15,61 @@
 package mathutil
 
 import (
+	"math/rand/v2"
 	"slices"
+	"strconv"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 )
 
+func testFHTKernels(t *testing.T, kernels fhtKernels) {
+	t.Helper()
+
+	for _, size := range []int{1, 2, 3, 7, 8, 15, 16, 31, 32, 63, 64, 65, 127, 128} {
+		t.Run(strconv.Itoa(size), func(t *testing.T) {
+			input := make([]float32, size)
+			for index := range input {
+				input[index] = rand.Float32()*20 - 10
+			}
+
+			signs := make([]byte, (size+7)/8)
+			for index := range signs {
+				signs[index] = byte(rand.Uint32())
+			}
+			wantSigns := slices.Clone(input)
+			fhtFlipSignsScalar(signs, wantSigns)
+			gotSigns := slices.Clone(input)
+			kernels.flipSigns(signs, gotSigns)
+			require.Equal(t, wantSigns, gotSigns)
+
+			wantWalk := slices.Clone(input)
+			fhtKacWalkScalar(wantWalk)
+			gotWalk := slices.Clone(input)
+			kernels.kacWalk(gotWalk)
+			require.Equal(t, wantWalk, gotWalk)
+
+			wantInverse := slices.Clone(wantWalk)
+			fhtInverseKacWalkScalar(wantInverse)
+			gotInverse := slices.Clone(gotWalk)
+			kernels.inverseKacWalk(gotInverse)
+			require.Equal(t, wantInverse, gotInverse)
+		})
+	}
+
+	for _, size := range []int{1, 2, 4, 8, 16, 32, 64, 128, 256} {
+		input := make([]float32, size)
+		for index := range input {
+			input[index] = rand.Float32()*20 - 10
+		}
+		want := slices.Clone(input)
+		fhtInPlaceScalar(want)
+		got := slices.Clone(input)
+		kernels.inPlace(got)
+		require.Equal(t, want, got)
+	}
+}
+
 func TestFHTInPlace(t *testing.T) {
 	t.Parallel()
 	data := []float32{1, 2, 3, 4}
@@ -71,7 +120,7 @@ func TestFHTKacWalkRoundTrip(t *testing.T) {
 	}
 }
 
-func TestFHTValidation(t *testing.T) {
+func TestValidation(t *testing.T) {
 	t.Parallel()
 	for _, data := range [][]float32{nil, {1, 2, 3}} {
 		{
@@ -88,3 +137,19 @@ func TestFHTValidation(t *testing.T) {
 		require.ErrorIs(t, err, ErrInvalidFHTLength)
 	}
 }
+
+func BenchmarkFHTInPlace(b *testing.B) {
+	data := make([]float32, 1024)
+	b.ReportAllocs()
+	for b.Loop() {
+		_ = FHTInPlace(data)
+	}
+}
+
+func BenchmarkFHTKacWalk(b *testing.B) {
+	data := make([]float32, 1024)
+	b.ReportAllocs()
+	for b.Loop() {
+		_ = FHTKacWalk(data)
+	}
+}
diff --git a/internal/ailego/math/src/.gitignore b/internal/ailego/math/src/.gitignore
new file mode 100644
index 0000000..d897b56
--- /dev/null
+++ b/internal/ailego/math/src/.gitignore
@@ -0,0 +1,2 @@
+*.o
+*.s
diff --git a/internal/ailego/math/src/fht_avx2.c b/internal/ailego/math/src/fht_avx2.c
new file mode 100644
index 0000000..f7afd5d
--- /dev/null
+++ b/internal/ailego/math/src/fht_avx2.c
@@ -0,0 +1,102 @@
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <immintrin.h>
+#include <stdint.h>
+
+void xvec_avx2_fht_flip_signs(uint8_t *signs, float *data, int64_t size) {
+    int64_t simd_end = size & ~31LL;
+    for (int64_t index = 0; index < simd_end; index += 32) {
+        uint32_t bits;
+        __builtin_memcpy(&bits, signs + index / 8, sizeof(bits));
+        for (int64_t block = 0; block < 4; block++) {
+            uint64_t byte = (bits >> (block * 8)) & 0xff;
+            volatile uint64_t mask0 = ((byte & 0x01) << 31) | ((byte & 0x02) << 62);
+            volatile uint64_t mask1 = ((byte & 0x04) << 29) | ((byte & 0x08) << 60);
+            volatile uint64_t mask2 = ((byte & 0x10) << 27) | ((byte & 0x20) << 58);
+            volatile uint64_t mask3 = ((byte & 0x40) << 25) | ((byte & 0x80) << 56);
+            __m256i mask = _mm256_set_epi64x(mask3, mask2, mask1, mask0);
+            __m256 values = _mm256_loadu_ps(data + index + block * 8);
+            values = _mm256_xor_ps(values, _mm256_castsi256_ps(mask));
+            _mm256_storeu_ps(data + index + block * 8, values);
+        }
+    }
+    for (int64_t index = simd_end; index < size; index++) {
+        if (signs[index / 8] & (1u << (index % 8))) {
+            data[index] = -data[index];
+        }
+    }
+}
+
+void xvec_avx2_fht_kac_walk(float *data, int64_t size) {
+    int64_t half = size / 2;
+    int64_t base = size % 2;
+    int64_t offset = base + half;
+    int64_t simd_end = half & ~7LL;
+    for (int64_t index = 0; index < simd_end; index += 8) {
+        __m256 left = _mm256_loadu_ps(data + index);
+        __m256 right = _mm256_loadu_ps(data + index + offset);
+        _mm256_storeu_ps(data + index, _mm256_add_ps(left, right));
+        _mm256_storeu_ps(data + index + offset, _mm256_sub_ps(left, right));
+    }
+    for (int64_t index = simd_end; index < half; index++) {
+        float left = data[index];
+        float right = data[index + offset];
+        data[index] = left + right;
+        data[index + offset] = left - right;
+    }
+
+}
+
+void xvec_avx2_fht_inverse_kac_walk(float *data, int64_t size) {
+    int64_t half = size / 2;
+    int64_t base = size % 2;
+    int64_t offset = base + half;
+    int64_t simd_end = half & ~7LL;
+    volatile float scale_scalar = 0.5f;
+    const __m256 scale = _mm256_set1_ps(scale_scalar);
+    for (int64_t index = 0; index < simd_end; index += 8) {
+        __m256 left = _mm256_loadu_ps(data + index);
+        __m256 right = _mm256_loadu_ps(data + index + offset);
+        _mm256_storeu_ps(data + index, _mm256_mul_ps(_mm256_add_ps(left, right), scale));
+        _mm256_storeu_ps(data + index + offset, _mm256_mul_ps(_mm256_sub_ps(left, right), scale));
+    }
+    for (int64_t index = simd_end; index < half; index++) {
+        float left = data[index];
+        float right = data[index + offset];
+        data[index] = (left + right) * scale_scalar;
+        data[index + offset] = (left - right) * scale_scalar;
+    }
+}
+
+void xvec_avx2_fht_in_place(float *data, int64_t size) {
+    for (int64_t width = 1; width < size; width <<= 1) {
+        int64_t step = width << 1;
+        int64_t simd_end = width & ~7LL;
+        for (int64_t block = 0; block < size; block += step) {
+            for (int64_t index = 0; index < simd_end; index += 8) {
+                __m256 left = _mm256_loadu_ps(data + block + index);
+                __m256 right = _mm256_loadu_ps(data + block + index + width);
+                _mm256_storeu_ps(data + block + index, _mm256_add_ps(left, right));
+                _mm256_storeu_ps(data + block + index + width, _mm256_sub_ps(left, right));
+            }
+            for (int64_t index = simd_end; index < width; index++) {
+                float left = data[block + index];
+                float right = data[block + index + width];
+                data[block + index] = left + right;
+                data[block + index + width] = left - right;
+            }
+        }
+    }
+}
diff --git a/internal/ailego/math/src/fht_avx512.c b/internal/ailego/math/src/fht_avx512.c
new file mode 100644
index 0000000..694e14c
--- /dev/null
+++ b/internal/ailego/math/src/fht_avx512.c
@@ -0,0 +1,99 @@
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <immintrin.h>
+#include <stdint.h>
+
+void xvec_avx512_fht_flip_signs(uint8_t *signs, float *data, int64_t size) {
+    int64_t simd_end = size & ~63LL;
+    volatile int32_t sign = (int32_t)0x80000000u;
+    const __m512 sign_bit = _mm512_castsi512_ps(_mm512_set1_epi32(sign));
+    for (int64_t index = 0; index < simd_end; index += 64) {
+        uint64_t bits;
+        __builtin_memcpy(&bits, signs + index / 8, sizeof(bits));
+        for (int64_t block = 0; block < 4; block++) {
+            __mmask16 mask = (__mmask16)(bits >> (block * 16));
+            __m512 values = _mm512_loadu_ps(data + index + block * 16);
+            values = _mm512_mask_xor_ps(values, mask, values, sign_bit);
+            _mm512_storeu_ps(data + index + block * 16, values);
+        }
+    }
+    for (int64_t index = simd_end; index < size; index++) {
+        if (signs[index / 8] & (1u << (index % 8))) {
+            data[index] = -data[index];
+        }
+    }
+}
+
+void xvec_avx512_fht_kac_walk(float *data, int64_t size) {
+    int64_t half = size / 2;
+    int64_t base = size % 2;
+    int64_t offset = base + half;
+    int64_t simd_end = half & ~15LL;
+    for (int64_t index = 0; index < simd_end; index += 16) {
+        __m512 left = _mm512_loadu_ps(data + index);
+        __m512 right = _mm512_loadu_ps(data + index + offset);
+        _mm512_storeu_ps(data + index, _mm512_add_ps(left, right));
+        _mm512_storeu_ps(data + index + offset, _mm512_sub_ps(left, right));
+    }
+    for (int64_t index = simd_end; index < half; index++) {
+        float left = data[index];
+        float right = data[index + offset];
+        data[index] = left + right;
+        data[index + offset] = left - right;
+    }
+
+}
+
+void xvec_avx512_fht_inverse_kac_walk(float *data, int64_t size) {
+    int64_t half = size / 2;
+    int64_t base = size % 2;
+    int64_t offset = base + half;
+    int64_t simd_end = half & ~15LL;
+    volatile float scale_scalar = 0.5f;
+    const __m512 scale = _mm512_set1_ps(scale_scalar);
+    for (int64_t index = 0; index < simd_end; index += 16) {
+        __m512 left = _mm512_loadu_ps(data + index);
+        __m512 right = _mm512_loadu_ps(data + index + offset);
+        _mm512_storeu_ps(data + index, _mm512_mul_ps(_mm512_add_ps(left, right), scale));
+        _mm512_storeu_ps(data + index + offset, _mm512_mul_ps(_mm512_sub_ps(left, right), scale));
+    }
+    for (int64_t index = simd_end; index < half; index++) {
+        float left = data[index];
+        float right = data[index + offset];
+        data[index] = (left + right) * scale_scalar;
+        data[index + offset] = (left - right) * scale_scalar;
+    }
+}
+
+void xvec_avx512_fht_in_place(float *data, int64_t size) {
+    for (int64_t width = 1; width < size; width <<= 1) {
+        int64_t step = width << 1;
+        int64_t simd_end = width & ~15LL;
+        for (int64_t block = 0; block < size; block += step) {
+            for (int64_t index = 0; index < simd_end; index += 16) {
+                __m512 left = _mm512_loadu_ps(data + block + index);
+                __m512 right = _mm512_loadu_ps(data + block + index + width);
+                _mm512_storeu_ps(data + block + index, _mm512_add_ps(left, right));
+                _mm512_storeu_ps(data + block + index + width, _mm512_sub_ps(left, right));
+            }
+            for (int64_t index = simd_end; index < width; index++) {
+                float left = data[block + index];
+                float right = data[block + index + width];
+                data[block + index] = left + right;
+                data[block + index + width] = left - right;
+            }
+        }
+    }
+}
diff --git a/internal/ailego/math/src/fht_neon.c b/internal/ailego/math/src/fht_neon.c
new file mode 100644
index 0000000..7112dba
--- /dev/null
+++ b/internal/ailego/math/src/fht_neon.c
@@ -0,0 +1,101 @@
+// Copyright 2026-present the xvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <arm_neon.h>
+#include <stdint.h>
+
+void xvec_neon_fht_flip_signs(uint8_t *signs, float *data, int64_t size) {
+    int64_t simd_end = size & ~3LL;
+    for (int64_t index = 0; index < simd_end; index += 4) {
+        uint16_t bits = signs[index / 8];
+        if (index / 8 + 1 < (size + 7) / 8) {
+            bits |= (uint16_t)signs[index / 8 + 1] << 8;
+        }
+        bits >>= index % 8;
+        volatile uint64_t mask0 = ((uint64_t)(bits & 0x01) << 31) |
+                                  ((uint64_t)(bits & 0x02) << 62);
+        volatile uint64_t mask1 = ((uint64_t)(bits & 0x04) << 29) |
+                                  ((uint64_t)(bits & 0x08) << 60);
+        uint64x2_t mask64 = vcombine_u64(vcreate_u64(mask0), vcreate_u64(mask1));
+        uint32x4_t values = vreinterpretq_u32_f32(vld1q_f32(data + index));
+        vst1q_f32(data + index, vreinterpretq_f32_u32(veorq_u32(values, vreinterpretq_u32_u64(mask64))));
+    }
+    for (int64_t index = simd_end; index < size; index++) {
+        if (signs[index / 8] & (1u << (index % 8))) {
+            data[index] = -data[index];
+        }
+    }
+}
+
+void xvec_neon_fht_kac_walk(float *data, int64_t size) {
+    int64_t half = size / 2;
+    int64_t base = size % 2;
+    int64_t offset = base + half;
+    int64_t simd_end = half & ~3LL;
+    for (int64_t index = 0; index < simd_end; index += 4) {
+        float32x4_t left = vld1q_f32(data + index);
+        float32x4_t right = vld1q_f32(data + index + offset);
+        vst1q_f32(data + index, vaddq_f32(left, right));
+        vst1q_f32(data + index + offset, vsubq_f32(left, right));
+    }
+    for (int64_t index = simd_end; index < half; index++) {
+        float left = data[index];
+        float right = data[index + offset];
+        data[index] = left + right;
+        data[index + offset] = left - right;
+    }
+
+}
+
+void xvec_neon_fht_inverse_kac_walk(float *data, int64_t size) {
+    int64_t half = size / 2;
+    int64_t base = size % 2;
+    int64_t offset = base + half;
+
+    int64_t simd_end = half & ~3LL;
+    const float32x4_t scale = vdupq_n_f32(0.5f);
+    for (int64_t index = 0; index < simd_end; index += 4) {
+        float32x4_t left = vld1q_f32(data + index);
+        float32x4_t right = vld1q_f32(data + index + offset);
+        vst1q_f32(data + index, vmulq_f32(vaddq_f32(left, right), scale));
+        vst1q_f32(data + index + offset, vmulq_f32(vsubq_f32(left, right), scale));
+    }
+    for (int64_t index = simd_end; index < half; index++) {
+        float left = data[index];
+        float right = data[index + offset];
+        data[index] = (left + right) * 0.5f;
+        data[index + offset] = (left - right) * 0.5f;
+    }
+}
+
+void xvec_neon_fht_in_place(float *data, int64_t size) {
+    for (int64_t width = 1; width < size; width <<= 1) {
+        int64_t step = width << 1;
+        int64_t simd_end = width & ~3LL;
+        for (int64_t block = 0; block < size; block += step) {
+            for (int64_t index = 0; index < simd_end; index += 4) {
+                float32x4_t left = vld1q_f32(data + block + index);
+                float32x4_t right = vld1q_f32(data + block + index + width);
+                vst1q_f32(data + block + index, vaddq_f32(left, right));
+                vst1q_f32(data + block + index + width, vsubq_f32(left, right));
+            }
+            for (int64_t index = simd_end; index < width; index++) {
+                float left = data[block + index];
+                float right = data[block + index + width];
+                data[block + index] = left + right;
+                data[block + index + width] = left - right;
+            }
+        }
+    }
+}