diff --git a/bench_test.go b/bench_test.go
index 7e5f770..83ae9b4 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -7,12 +7,11 @@ import (
 	_ "embed"
 	"flag"
 	"fmt"
-	"maps"
+	"math/rand/v2"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
-	"slices"
 	"strconv"
 	"strings"
 	"testing"
@@ -170,18 +169,28 @@ func BenchmarkBuild(b *testing.B) {
 }
 
 func BenchmarkAbiRealName(b *testing.B) {
-	// Benchmark two thousand obfuscated names in _nameMap
+	// Benchmark two thousand obfuscated names in _realNamePairs
 	// and a variety of input strings to reverse.
 	// As an example, the cmd/go binary ends up with about 2200 entries
-	// in _nameMap as of November 2024, so it's a realistic figure.
+	// in _realNamePairs as of November 2024, so it's a realistic figure.
 	// Structs with tens of fields are also relatively normal.
 	salt := []byte("some salt bytes")
 	for n := range 2000 {
 		name := fmt.Sprintf("name_%d", n)
 		garbled := hashWithCustomSalt(salt, name)
-		_nameMap[garbled] = name
+		_realNamePairs = append(_realNamePairs, [2]string{garbled, name})
 	}
-	chosen := slices.Sorted(maps.Keys(_nameMap))[:20]
+	// Pick twenty names at random to use as inputs below.
+	// Use a deterministic random source so it's stable between benchmark runs.
+	rnd := rand.New(rand.NewPCG(1, 2))
+	var chosen []string
+	for _, pair := range _realNamePairs {
+		chosen = append(chosen, pair[0])
+	}
+	rnd.Shuffle(len(chosen), func(i, j int) {
+		chosen[i], chosen[j] = chosen[j], chosen[i]
+	})
+	chosen = chosen[:20]
 
 	inputs := []string{
 		// non-obfuscated names and types
@@ -214,5 +223,5 @@ func BenchmarkAbiRealName(b *testing.B) {
 			}
 		}
 	})
-	_nameMap = map[string]string{}
+	_realNamePairs = [][2]string{}
 }
diff --git a/reflect_abi_code.go b/reflect_abi_code.go
index dab25ec..ce90d8d 100644
--- a/reflect_abi_code.go
+++ b/reflect_abi_code.go
@@ -39,7 +39,9 @@ func _realName(name string) string {
 		}
 		remLen := len(name[i:])
 		found := false
-		for obfName, real := range _nameMap {
+		for _, pair := range _realNamePairs {
+			obfName := pair[0]
+			real := pair[1]
 			keyLen := len(obfName)
 			if remLen < keyLen {
 				continue
@@ -58,4 +60,4 @@ func _realName(name string) string {
 	return name
 }
 
-var _nameMap = map[string]string{}
+var _realNamePairs = [][2]string{}
diff --git a/reflect_abi_patch.go b/reflect_abi_patch.go
index 0856547..731b47b 100644
--- a/reflect_abi_patch.go
+++ b/reflect_abi_patch.go
@@ -58,13 +58,13 @@ func reflectMainPrePatch(path string) ([]byte, error) {
 // reflectMainPostPatch populates the name mapping with the final obfuscated->real name
 // mappings after all packages have been analyzed.
 func reflectMainPostPatch(file []byte, lpkg *listedPackage, pkg pkgCache) []byte {
-	obfMapName := hashWithPackage(lpkg, "_nameMap")
-	nameMap := fmt.Sprintf("%s = map[string]string{", obfMapName)
+	obfVarName := hashWithPackage(lpkg, "_realNamePairs")
+	nameMap := fmt.Sprintf("%s = [][2]string{", obfVarName)
 
 	var b strings.Builder
 	keys := slices.Sorted(maps.Keys(pkg.ReflectObjectNames))
 	for _, obf := range keys {
-		b.WriteString(fmt.Sprintf(`"%s": "%s",`, obf, pkg.ReflectObjectNames[obf]))
+		b.WriteString(fmt.Sprintf("{%q, %q},", obf, pkg.ReflectObjectNames[obf]))
 	}
 
 	return bytes.Replace(file, []byte(nameMap), []byte(nameMap+b.String()), 1)