diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+## 0.2.0.0 - 2026-09-12
+
+### Added
+
+- `rapidhashMicro` is now bound
+
+### Changed
+
+- **Breaking**: `RapidHashable` gains a required `rapidhashMicroWithSeed` method.
+  Hand-written instances must add it.
+- Small README reword
+
 ## 0.1.1.0 - 2026-07-26
 
 ### Added
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -45,8 +45,8 @@
 
 ## Status
 
-First release, but I consider the API stable. Used for change detection in
-[lithon](https://github.com/jtnuttall/lithon).
+Package is still fresh, but I consider the API stable. Used for change detection
+in [lithon](https://github.com/jtnuttall/lithon).
 
 This project follows the PVP. For stability, pin to the major (e.g., `^>= 0.1`).
 
@@ -69,13 +69,17 @@
 that stored digests get confused with the output of other hash algorithms,
 or of future rapidhash versions.
 
+The rapidhashMicro variant, `RapidHashMicro`, carries its own prefix
+(`rhmv3:`) and its own `Binary` tag. The two variants agree only up to 80
+bytes of input, so their digests are not interchangeable.
+
 The convention applies to every mechanism that produces string output:
 `Show`/`Read`, the `Text`/`ByteString` renderers and parsers, and the
 `text-builder-linear` builder. (`Binary` instead uses a compact tagged
 9-byte encoding.)
 
-The `RapidHash` constructor is exported wholesale; if the tagging doesn't
-fit your needs, rewrap the underlying `Word64` however you like.
+All hash newtype constructors are exported wholesale; if the tagging doesn't fit
+your needs, rewrap the underlying `Word64` however you like.
 
 ### Aeson
 
diff --git a/cbits/rapidhash_ext.h b/cbits/rapidhash_ext.h
--- a/cbits/rapidhash_ext.h
+++ b/cbits/rapidhash_ext.h
@@ -24,3 +24,22 @@
   return rapidhash_internal((const uint8_t *)key + offset, len, seed,
                             rapid_secret);
 }
+
+/*
+ *  rapidhashMicro seeded hash function.
+ *
+ *  @param key     Buffer to be hashed.
+ *  @param offset  Offset into the buffer, in bytes.
+ *  @param len     @key length, in bytes.
+ *  @param seed    64-bit seed used to alter the hash result predictably.
+ *
+ *  Calls rapidhashMicro_internal using provided parameters and default secrets.
+ *
+ *  Returns a 64-bit hash.
+ */
+RAPIDHASH_INLINE uint64_t
+rapidhashMicro_offset_withSeed(const void *key, size_t offset, size_t len,
+                               uint64_t seed) RAPIDHASH_NOEXCEPT {
+  return rapidhashMicro_internal((const uint8_t *)key + offset, len, seed,
+                                 rapid_secret);
+}
diff --git a/rapidhash.cabal b/rapidhash.cabal
--- a/rapidhash.cabal
+++ b/rapidhash.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           rapidhash
-version:        0.1.1.0
+version:        0.2.0.0
 synopsis:       rapidhash v3 - very fast, high-quality, non-cryptographic hashing
 description:    Zero-copy FFI bindings to rapidhash v3, a very fast, high-quality,
                 non-cryptographic hash. The upstream single-header C implementation is
diff --git a/src/Data/Hash/RapidHash.hs b/src/Data/Hash/RapidHash.hs
--- a/src/Data/Hash/RapidHash.hs
+++ b/src/Data/Hash/RapidHash.hs
@@ -38,41 +38,67 @@
 
   -- * Hashes
 
+  -- ** rapidhash
+
   --
 
-  -- | 'RapidHash' is a newtype that provides some affordances for ergonomic, efficient use.
+  -- |
+  -- The general-purpose rapidhash algorithm.
+  --
+  -- 'RapidHash' is a newtype that provides some affordances for ergonomic, efficient use.
   RapidHash (..),
 
-  -- * Serialization
+  -- *** Serialization
   rapidHashTextBuilder,
   showRapidHashText,
   showRapidHashBS,
 
-  -- * Parsing
+  -- *** Parsing
   parseRapidHashText,
   parseRapidHashBS,
 
-  -- * File hashing
+  -- *** File hashing
 
   --
 
   -- |
   -- These are simply useful helpers for hashing a file, assuming you don't need
-  -- to do anything else with the contents. They use strict 'Data.ByteString.ByteString'
-  -- under the hood, so beware very large files: besides residency, the hash
-  -- itself is a single @unsafe@ FFI call, which blocks garbage collection
-  -- across all capabilities for its duration (rapidhash processes tens of
-  -- GB/s, so this matters only for very large inputs).
+  -- to do anything else with the contents. Beware large files. These helpers
+  -- use strict 'Data.ByteString.ByteString' and will pause the capability and
+  -- garbage collector.
   rapidhashFileWithSeed,
   rapidhashFile,
 
-  -- * DerivingVia
+  -- *** DerivingVia
+  HashViaRapidHash (..),
 
+  -- ** rapidhashMicro
+
   --
 
-  -- | Helpers for deriving 'Data.Hashable.Hashable' and other useful classes.
-  HashViaRapidHash (..),
+  -- |
+  -- A variant of rapidhash tuned for small keys, aimed at workloads where cache
+  -- misses dominate. Upstream reports it faster than rapidhash for inputs up to
+  -- 512 bytes, and 15-20% slower above 1kb.
+  --
+  -- Digests are identical to 'rapidhash' for inputs of 80 bytes or fewer and
+  -- diverge from 81 bytes on, so the two are not interchangeable in storage.
+  -- Hence the separate type and tag.
+  rapidhashMicro,
+  RapidHashMicro (..),
 
+  -- *** Serialization
+  rapidhashMicroTextBuilder,
+  showRapidHashMicroBS,
+  showRapidHashMicroText,
+
+  -- *** Parsing
+  parseRapidHashMicroText,
+  parseRapidHashMicroBS,
+
+  -- *** DerivingVia
+  HashViaRapidHashMicro (..),
+
   -- * Re-exports
   Prim,
   Storable,
@@ -84,18 +110,26 @@
 
 import Data.Hash.RapidHash.Class (
   HashViaRapidHash (..),
+  HashViaRapidHashMicro (..),
   RapidHashable (..),
   rapidhash,
   rapidhashFile,
   rapidhashFileWithSeed,
+  rapidhashMicro,
  )
 import Data.Hash.RapidHash.Types (
   RapidHash (..),
+  RapidHashMicro (..),
   RapidSeed (..),
   parseRapidHashBS,
+  parseRapidHashMicroBS,
+  parseRapidHashMicroText,
   parseRapidHashText,
   rapidHashTextBuilder,
+  rapidhashMicroTextBuilder,
   showRapidHashBS,
+  showRapidHashMicroBS,
+  showRapidHashMicroText,
   showRapidHashText,
  )
 
diff --git a/src/Data/Hash/RapidHash/Aeson.hs b/src/Data/Hash/RapidHash/Aeson.hs
--- a/src/Data/Hash/RapidHash/Aeson.hs
+++ b/src/Data/Hash/RapidHash/Aeson.hs
@@ -1,8 +1,9 @@
 {-# LANGUAGE CPP #-}
 {-# OPTIONS_GHC -Wno-orphans #-}
 
--- | Orphan aeson instances for 'Data.Hash.RapidHash.Types.RapidHash', encoding
--- to and from the tagged hex form (e.g. @"rhv3:0123456789abcdef"@).
+-- | Orphan aeson instances for 'Data.Hash.RapidHash.Types.RapidHash' and
+-- 'Data.Hash.RapidHash.Types.RapidHashMicro', encoding to and from the tagged
+-- hex form (e.g. @"rhv3:0123456789abcdef"@, @"rhmv3:0123456789abcdef"@).
 --
 -- Opt-in with the @aeson@ flag; without it this module is empty and the
 -- instances do not exist.
@@ -32,5 +33,25 @@
 
 instance A.FromJSONKey RapidHash where
   fromJSONKey = A.FromJSONKeyTextParser \t -> either fail pure (parseRapidHashText t)
+  {-# INLINEABLE fromJSONKey #-}
+
+instance A.ToJSON RapidHashMicro where
+  toJSON = A.String . showRapidHashMicroText
+  {-# INLINEABLE toJSON #-}
+
+instance A.FromJSON RapidHashMicro where
+  parseJSON = A.withText "rapidhashMicrov3" \t -> case parseRapidHashMicroText t of
+    Right h -> pure h
+    Left err -> fail err
+  {-# INLINEABLE parseJSON #-}
+
+-- | Keys use the same tagged hex form as the value instances, so a map
+-- keyed by @RapidHashMicro@ serializes to a JSON object with @rhmv3:@-prefixed keys.
+instance A.ToJSONKey RapidHashMicro where
+  toJSONKey = A.toJSONKeyText showRapidHashMicroText
+  {-# INLINEABLE toJSONKey #-}
+
+instance A.FromJSONKey RapidHashMicro where
+  fromJSONKey = A.FromJSONKeyTextParser \t -> either fail pure (parseRapidHashMicroText t)
   {-# INLINEABLE fromJSONKey #-}
 #endif
diff --git a/src/Data/Hash/RapidHash/Class.hs b/src/Data/Hash/RapidHash/Class.hs
--- a/src/Data/Hash/RapidHash/Class.hs
+++ b/src/Data/Hash/RapidHash/Class.hs
@@ -16,8 +16,12 @@
   rapidhashFileWithSeed,
   rapidhashFile,
 
+  -- * rapidhashMicro
+  rapidhashMicro,
+
   -- * DerivingVia helpers
   HashViaRapidHash (..),
+  HashViaRapidHashMicro (..),
 ) where
 
 import Control.Monad.IO.Class (MonadIO (liftIO))
@@ -35,7 +39,12 @@
 import Prelude (Eq, FilePath, fromIntegral, (<$>))
 
 import Data.Hash.RapidHash.FFI
-import Data.Hash.RapidHash.Types (RapidHash (RapidHash), RapidSeed (RapidSeed), defaultSeed)
+import Data.Hash.RapidHash.Types (
+  RapidHash (RapidHash),
+  RapidHashMicro (..),
+  RapidSeed (RapidSeed),
+  defaultSeed,
+ )
 
 -- $setup
 -- >>> :set -XOverloadedStrings
@@ -61,51 +70,70 @@
 -- 2. Endianness - no real solution, although for common application development
 --    tasks you'll almost certainly know if this applies to you.
 class RapidHashable a where
-  -- | Run rapidhash with the given seed
+  -- | Run rapidhash with the given seed. This is usually what you want.
   rapidhashWithSeed :: RapidSeed -> a -> RapidHash
 
+  -- | Run rapidhashMicro with the given seed.
+  --
+  -- rapidhashMicro is tuned for small keys: upstream reports it faster than
+  -- rapidhash for inputs up to 512 bytes, and 15-20% slower above 1kb.
+  --
+  -- It has identical results to 'rapidhashWithSeed' for inputs of 80 bytes or
+  -- fewer; from 81 bytes on results diverge.
+  rapidhashMicroWithSeed :: RapidSeed -> a -> RapidHashMicro
+
 -- | This instance is stable across platforms.
 instance RapidHashable ByteArray where
   rapidhashWithSeed = coerce rapidhashWithSeed_ByteArray
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_ByteArray
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | This instance is stable across platforms.
 instance RapidHashable BS.ByteString where
   rapidhashWithSeed = coerce rapidhashWithSeed_ByteString
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_ByteString
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | This instance is stable across platforms.
 instance RapidHashable T.Text where
   rapidhashWithSeed = coerce rapidhashWithSeed_Text
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_Text
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | This instance is stable across platforms.
 instance RapidHashable ShortByteString where
   rapidhashWithSeed = coerce rapidhashWithSeed_ShortByteString
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_ShortByteString
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | This instance is __NOT__ stable across platforms.
 instance RapidHashable (PrimArray a) where
   rapidhashWithSeed = coerce rapidhashWithSeed_PrimArray
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_PrimArray
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | This instance is __NOT__ stable across platforms.
 instance (Prim a) => RapidHashable (PrimitiveVector.Vector a) where
   rapidhashWithSeed = coerce rapidhashWithSeed_PrimitiveVector
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_PrimitiveVector
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | This instance is __NOT__ stable across platforms.
 --
 -- __Warning__: element memory is hashed raw, so the element type's
--- 'Foreign.Storable.Storable' layout must have no padding (i.e.
--- 'Foreign.Storable.poke' must write every byte of
--- 'Foreign.Storable.sizeOf'). Padding bytes are uninitialized memory:
--- with a padded element type, @a == b@ does not imply equal hashes —
--- which also breaks lawful 'Data.Hashable.Hashable' use via
--- 'Data.Hash.RapidHash.HashViaRapidHash'.
+-- 'Foreign.Storable.Storable' layout must have no uninitialized bytes (padding or
+-- otherwise).
 instance (Storable a) => RapidHashable (StorableVector.Vector a) where
   rapidhashWithSeed = coerce rapidhashWithSeed_StorableVector
   {-# INLINE rapidhashWithSeed #-}
+  rapidhashMicroWithSeed = coerce rapidhashMicroWithSeed_StorableVector
+  {-# INLINE rapidhashMicroWithSeed #-}
 
 -- | Run rapidhash with its default seed
 rapidhash :: (RapidHashable a) => a -> RapidHash
@@ -123,6 +151,11 @@
 rapidhashFile = rapidhashFileWithSeed defaultSeed
 {-# INLINE rapidhashFile #-}
 
+-- | Run rapidhashMicro with its default seed
+rapidhashMicro :: (RapidHashable a) => a -> RapidHashMicro
+rapidhashMicro = rapidhashMicroWithSeed defaultSeed
+{-# INLINE rapidhashMicro #-}
+
 -- |
 -- Newtype wrapper implementing 'Hashable' via 'RapidHashable' - works only for
 -- types that already implement 'RapidHashable'. All such types should be efficiently
@@ -133,5 +166,16 @@
 instance (RapidHashable a, Eq a) => Hashable (HashViaRapidHash a) where
   hashWithSalt salt (HashViaRapidHash a) =
     let RapidHash h = rapidhashWithSeed (RapidSeed (fromIntegral salt)) a
+     in fromIntegral h
+  {-# INLINE hashWithSalt #-}
+
+-- |
+-- Like 'HashViaRapidHash', but uses 'rapidhashMicroWithSeed'
+newtype HashViaRapidHashMicro a = HashViaRapidHashMicro a
+  deriving newtype (Eq)
+
+instance (RapidHashable a, Eq a) => Hashable (HashViaRapidHashMicro a) where
+  hashWithSalt salt (HashViaRapidHashMicro a) =
+    let RapidHashMicro h = rapidhashMicroWithSeed (RapidSeed (fromIntegral salt)) a
      in fromIntegral h
   {-# INLINE hashWithSalt #-}
diff --git a/src/Data/Hash/RapidHash/FFI.hs b/src/Data/Hash/RapidHash/FFI.hs
--- a/src/Data/Hash/RapidHash/FFI.hs
+++ b/src/Data/Hash/RapidHash/FFI.hs
@@ -16,10 +16,13 @@
 -- All foreign calls in this module are @unsafe@, so they will briefly pause the capability and
 -- garbage collector.
 module Data.Hash.RapidHash.FFI (
+  -- * Shared aliases
   COffset,
   CSeed,
 
-  -- * Monomorphic wrappers around FFI
+  -- * rapidhash
+
+  -- ** Monomorphic wrappers around FFI
   rapidhashWithSeed_Text,
   rapidhashWithSeed_ShortByteString,
   rapidhashWithSeed_ByteString,
@@ -27,17 +30,39 @@
   rapidhashWithSeed_PrimitiveVector,
   rapidhashWithSeed_StorableVector,
 
-  -- * Bare 'unsafeDupablePerformIO' wrappers around FFI
+  -- ** Bare 'unsafeDupablePerformIO' wrappers around FFI
   rapidhashWithSeed_ByteArray,
 
-  -- ** Unlifted
+  -- *** Unlifted
   rapidhashOffsetWithSeed_ByteArray#,
   rapidhashWithSeed_ByteArray#,
 
-  -- ** Raw FFI
+  -- *** Raw FFI
   rapidhashOffsetWithSeedFFI_ByteArray#,
   rapidhashWithSeedFFI_ByteArray#,
   rapidhashWithSeedFFI_Ptr,
+
+  -- * rapidhashMicro
+
+  -- ** Monomorphic wrappers around FFI
+  rapidhashMicroWithSeed_Text,
+  rapidhashMicroWithSeed_ShortByteString,
+  rapidhashMicroWithSeed_ByteString,
+  rapidhashMicroWithSeed_PrimArray,
+  rapidhashMicroWithSeed_PrimitiveVector,
+  rapidhashMicroWithSeed_StorableVector,
+
+  -- ** Bare 'unsafeDupablePerformIO' wrappers around FFI
+  rapidhashMicroWithSeed_ByteArray,
+
+  -- *** Unlifted
+  rapidhashMicroOffsetWithSeed_ByteArray#,
+  rapidhashMicroWithSeed_ByteArray#,
+
+  -- *** Raw FFI
+  rapidhashMicroOffsetWithSeedFFI_ByteArray#,
+  rapidhashMicroWithSeedFFI_ByteArray#,
+  rapidhashMicroWithSeedFFI_Ptr,
 ) where
 
 import Data.Array.Byte (ByteArray (ByteArray))
@@ -126,7 +151,7 @@
 -- 'ByteArray#', which lets us do a zero-copy hash.
 rapidhashWithSeed_Text :: CSeed -> TI.Text -> Word64
 rapidhashWithSeed_Text seed (TI.Text (ByteArray ba#) off len) =
-  rapidhashOffsetWithSeed_ByteArray# seed ba# (CSize (fromIntegral off)) (CSize (fromIntegral len))
+  rapidhashOffsetWithSeed_ByteArray# seed ba# (int2CSize off) (int2CSize len)
 {-# INLINE rapidhashWithSeed_Text #-}
 
 ----------------------------------------------------------------------------------------------------
@@ -144,7 +169,7 @@
 rapidhashWithSeed_ByteString :: CSeed -> BS.ByteString -> Word64
 rapidhashWithSeed_ByteString seed bs = unsafeDupablePerformIO $
   BSUnsafe.unsafeUseAsCStringLen bs \(cstr, len) ->
-    rapidhashWithSeedFFI_Ptr (castPtr cstr) (CSize (fromIntegral len)) seed
+    rapidhashWithSeedFFI_Ptr (castPtr cstr) (int2CSize len) seed
 {-# INLINE rapidhashWithSeed_ByteString #-}
 
 ----------------------------------------------------------------------------------------------------
@@ -173,9 +198,130 @@
   :: forall a. (Storable a) => CSeed -> StorableVector.Vector a -> Word64
 rapidhashWithSeed_StorableVector seed v = unsafeDupablePerformIO $
   StorableVector.unsafeWith v \ptr ->
-    let len = CSize $ fromIntegral (StorableVector.length v * sizeOf @a (error "sizeOf evaluated"))
+    let len = int2CSize $ StorableVector.length v * sizeOf @a (error "sizeOf evaluated")
      in rapidhashWithSeedFFI_Ptr (castPtr ptr) len seed
 {-# INLINE rapidhashWithSeed_StorableVector #-}
+
+----------------------------------------------------------------------------------------------------
+-- rapidhashMicro
+----------------------------------------------------------------------------------------------------
+
+----------------------------------------------------------------------------------------------------
+-- FFI
+----------------------------------------------------------------------------------------------------
+
+foreign import capi unsafe "rapidhash_ext.h rapidhashMicro_offset_withSeed"
+  rapidhashMicroOffsetWithSeedFFI_ByteArray#
+    :: ByteArray#
+    -- ^ The buffer
+    -> COffset
+    -- ^ Offset into buffer, in bytes
+    -> CSize
+    -- ^ Length of buffer after offset, in bytes
+    -> CSeed
+    -> IO Word64
+
+-- |
+-- Binding to @rapidhash_ext.h rapidhashMicro_offset_withSeed@.
+--
+-- This is a small custom shim local to this library, which allows zero-copy hashing of
+-- anything wrapping a 'ByteArray#' with an offset, by offloading the offset math to C.
+rapidhashMicroOffsetWithSeed_ByteArray# :: CSeed -> ByteArray# -> COffset -> CSize -> Word64
+rapidhashMicroOffsetWithSeed_ByteArray# seed ba# off len =
+  unsafeDupablePerformIO $
+    rapidhashMicroOffsetWithSeedFFI_ByteArray# ba# off len seed
+{-# INLINE rapidhashMicroOffsetWithSeed_ByteArray# #-}
+
+foreign import capi unsafe "rapidhash.h rapidhashMicro_withSeed"
+  rapidhashMicroWithSeedFFI_ByteArray# :: ByteArray# -> CSize -> CSeed -> IO Word64
+
+-- |
+-- Direct binding to @rapidhash.h rapidhashMicro_withSeed@, for anything wrapping a 'ByteArray#'
+-- without an offset.
+rapidhashMicroWithSeed_ByteArray# :: CSeed -> ByteArray# -> Word64
+rapidhashMicroWithSeed_ByteArray# seed arr =
+  unsafeDupablePerformIO $
+    rapidhashMicroWithSeedFFI_ByteArray# arr (csizeofByteArray# arr) seed
+{-# INLINE rapidhashMicroWithSeed_ByteArray# #-}
+
+foreign import capi unsafe "rapidhash.h rapidhashMicro_withSeed"
+  rapidhashMicroWithSeedFFI_Ptr :: Ptr Void -> CSize -> CSeed -> IO Word64
+
+----------------------------------------------------------------------------------------------------
+-- Data.Array.Byte
+----------------------------------------------------------------------------------------------------
+
+-- |
+-- Lifted 'rapidhashMicroWithSeed_ByteArray#' for 'ByteArray'.
+rapidhashMicroWithSeed_ByteArray :: CSeed -> ByteArray -> Word64
+rapidhashMicroWithSeed_ByteArray seed (ByteArray ba#) = rapidhashMicroWithSeed_ByteArray# seed ba#
+{-# INLINE rapidhashMicroWithSeed_ByteArray #-}
+
+----------------------------------------------------------------------------------------------------
+-- Data.Text
+----------------------------------------------------------------------------------------------------
+
+-- |
+-- Lifted 'rapidhashMicroOffsetWithSeed_ByteArray#' for 'T.Text'.
+--
+-- This function reaches into 'T.Text'\'s internals to grab the offset and length into the underlying
+-- 'ByteArray#', which lets us do a zero-copy hash.
+rapidhashMicroWithSeed_Text :: CSeed -> TI.Text -> Word64
+rapidhashMicroWithSeed_Text seed (TI.Text (ByteArray ba#) off len) =
+  rapidhashMicroOffsetWithSeed_ByteArray#
+    seed
+    ba#
+    (int2CSize off)
+    (int2CSize len)
+{-# INLINE rapidhashMicroWithSeed_Text #-}
+
+----------------------------------------------------------------------------------------------------
+-- Data.ByteString
+----------------------------------------------------------------------------------------------------
+
+-- |
+-- Applied 'rapidhashMicroWithSeed_ByteArray' for 'SBS.ShortByteString'.
+rapidhashMicroWithSeed_ShortByteString :: CSeed -> SBS.ShortByteString -> Word64
+rapidhashMicroWithSeed_ShortByteString seed (SBS.ShortByteString ba) = rapidhashMicroWithSeed_ByteArray seed ba
+{-# INLINE rapidhashMicroWithSeed_ShortByteString #-}
+
+-- |
+-- Applied 'rapidhashMicroWithSeedFFI_Ptr' for 'BS.ByteString'
+rapidhashMicroWithSeed_ByteString :: CSeed -> BS.ByteString -> Word64
+rapidhashMicroWithSeed_ByteString seed bs = unsafeDupablePerformIO $
+  BSUnsafe.unsafeUseAsCStringLen bs \(cstr, len) ->
+    rapidhashMicroWithSeedFFI_Ptr (castPtr cstr) (int2CSize len) seed
+{-# INLINE rapidhashMicroWithSeed_ByteString #-}
+
+----------------------------------------------------------------------------------------------------
+-- Data.Primitive
+----------------------------------------------------------------------------------------------------
+
+rapidhashMicroWithSeed_PrimArray :: CSeed -> PrimArray a -> Word64
+rapidhashMicroWithSeed_PrimArray seed (PrimArray ba#) = rapidhashMicroWithSeed_ByteArray# seed ba#
+{-# INLINE rapidhashMicroWithSeed_PrimArray #-}
+
+----------------------------------------------------------------------------------------------------
+-- Data.Vector
+----------------------------------------------------------------------------------------------------
+
+rapidhashMicroWithSeed_PrimitiveVector
+  :: forall a. (Prim a) => CSeed -> PrimitiveVector.Vector a -> Word64
+rapidhashMicroWithSeed_PrimitiveVector seed (PrimitiveVector.Vector off len (ByteArray ba#)) =
+  rapidhashMicroOffsetWithSeed_ByteArray#
+    seed
+    ba#
+    (int2CSize (sizeOfType @a * off))
+    (int2CSize (sizeOfType @a * len))
+{-# INLINE rapidhashMicroWithSeed_PrimitiveVector #-}
+
+rapidhashMicroWithSeed_StorableVector
+  :: forall a. (Storable a) => CSeed -> StorableVector.Vector a -> Word64
+rapidhashMicroWithSeed_StorableVector seed v = unsafeDupablePerformIO $
+  StorableVector.unsafeWith v \ptr ->
+    let len = int2CSize $ StorableVector.length v * sizeOf @a (error "sizeOf evaluated")
+     in rapidhashMicroWithSeedFFI_Ptr (castPtr ptr) len seed
+{-# INLINE rapidhashMicroWithSeed_StorableVector #-}
 
 ----------------------------------------------------------------------------------------------------
 -- Utilities
diff --git a/src/Data/Hash/RapidHash/Types.hs b/src/Data/Hash/RapidHash/Types.hs
--- a/src/Data/Hash/RapidHash/Types.hs
+++ b/src/Data/Hash/RapidHash/Types.hs
@@ -1,17 +1,18 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE LinearTypes #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PatternSynonyms #-}
 
 module Data.Hash.RapidHash.Types (
-  -- * Seeds
+  -- * Shared
   RapidSeed (..),
   defaultSeed,
+  pattern RAPIDHASH_V3_HEX_LENGTH,
 
-  -- * Hashes
+  -- * rapidhash
   RapidHash (..),
   pattern RAPIDHASH_V3_PREFIX,
-  pattern RAPIDHASH_V3_HEX_LENGTH,
 
   -- ** Serializing
   rapidHashTextBuilder,
@@ -23,11 +24,27 @@
   parseRapidHashText,
   parseRapidHashBS,
   readsRapidHash,
+
+  -- * rapidhashMicro
+  RapidHashMicro (..),
+  pattern RAPIDHASH_MICRO_V3_PREFIX,
+
+  -- ** Serializing
+  rapidhashMicroTextBuilder,
+  showRapidHashMicroText,
+  showRapidHashMicroBS,
+  showsRapidHashMicro,
+
+  -- ** Deserializing
+  parseRapidHashMicroText,
+  parseRapidHashMicroBS,
+  readsRapidHashMicro,
 ) where
 
 import Control.DeepSeq (NFData)
 import Control.Monad (when)
 import Control.Monad.ST.Strict (ST)
+import Data.Bifunctor (first)
 import Data.Binary (Binary)
 import Data.Binary qualified as Binary
 import Data.Bits (Bits (shiftR, (.&.)))
@@ -36,7 +53,7 @@
 import Data.ByteString.Char8 qualified as BSC8
 import Data.ByteString.Lex.Integral qualified as BS
 import Data.Char (isSpace)
-import Data.Foldable (for_, length)
+import Data.Foldable (for_)
 import Data.Hashable (Hashable)
 import Data.List qualified as L
 import Data.Maybe (maybe)
@@ -48,8 +65,8 @@
 import Data.Text.Builder.Linear.Buffer qualified as TBuff
 import Data.Text.Builder.Linear.Core qualified as TB
 import Data.Text.Read qualified as T
-import Data.Word (Word64)
-import GHC.Exts (Int (I#), (>#))
+import Data.Word (Word64, Word8)
+import GHC.Exts (Addr#, Int (I#), (>#))
 import GHC.Generics (Generic)
 import Prelude (
   Applicative (pure),
@@ -65,10 +82,10 @@
   ShowS,
   String,
   fromIntegral,
+  map,
   otherwise,
   showString,
   ($),
-  (.),
   (<$>),
   (||),
  )
@@ -86,14 +103,32 @@
 defaultSeed :: RapidSeed
 defaultSeed = RapidSeed 0
 
+-- | The length of the hash part of a valid rapidhash.
+--
+-- Exported for convenience.
+--
+-- === __Total length__
+--
+-- >>> RAPIDHASH_V3_HEX_LENGTH + length (RAPIDHASH_V3_PREFIX :: String)
+-- 21
+--
+-- >>> RAPIDHASH_V3_HEX_LENGTH + length (RAPIDHASH_MICRO_V3_PREFIX :: String)
+-- 22
+pattern RAPIDHASH_V3_HEX_LENGTH :: (Num a, Eq a) => a
+pattern RAPIDHASH_V3_HEX_LENGTH = 16
+
+pattern ZERO_CHAR :: (Num a, Eq a) => a
+pattern ZERO_CHAR = 0x30
+
+----------------------------------------------------------------------------------------------------
+-- rapidhash
+----------------------------------------------------------------------------------------------------
+
 -- | A rapidhash v3 digest.
 --
 -- The textual form is @rhv3:@ followed by exactly 16 hex digits, always
--- rendered lowercase. Parsing accepts either case (normalizing on
--- re-render), but rejects any other prefix, length, or stray characters.
--- The version tag makes stored digests self-describing: a future
--- rapidhash version bump (which changes outputs) can never be mistaken
--- for a v3 digest.
+-- rendered lowercase. Parsing accepts either case, but rejects any other prefix,
+-- length, or stray characters.
 --
 -- === __Examples__
 -- >>> RapidHash 0xabc
@@ -113,23 +148,7 @@
 -- Exported for convenience.
 pattern RAPIDHASH_V3_PREFIX :: (IsString a, Eq a) => a
 pattern RAPIDHASH_V3_PREFIX = "rhv3:"
-
--- | The length of the hash part of a valid rapidhash.
---
--- Exported for convenience.
---
--- === __Total length__
---
--- >>> RAPIDHASH_V3_HEX_LENGTH + length (RAPIDHASH_V3_PREFIX :: String)
--- 21
-pattern RAPIDHASH_V3_HEX_LENGTH :: (Num a, Eq a) => a
-pattern RAPIDHASH_V3_HEX_LENGTH = 16
-
-pattern ZERO_CHAR :: (Num a, Eq a) => a
-pattern ZERO_CHAR = 0x30
-
-prefixLen :: Int
-prefixLen = length (RAPIDHASH_V3_PREFIX :: String)
+#define RAPIDHASH_V3_PREFIX_ADDR "rhv3:"#
 
 instance Show RapidHash where
   showsPrec _ = showsRapidHash
@@ -143,26 +162,25 @@
 instance Read RapidHash where
   readsPrec _ = readsRapidHash
 
+pattern RAPIDHASH_V3_MAGIC_TAG :: Word8
+pattern RAPIDHASH_V3_MAGIC_TAG = 3
+
 -- |
 -- Efficient binary serialization and deserialization, with a just-good-enough tag.
 --
 -- Encodes in 9 bytes: One byte for the tag, 8 for the 'Word64'.
 instance Binary RapidHash where
   put (RapidHash h) = do
-    Binary.putWord8 3
+    Binary.putWord8 RAPIDHASH_V3_MAGIC_TAG
     Binary.put h
   {-# INLINE put #-}
   get = do
     tag <- Binary.getWord8
     case tag of
-      3 -> RapidHash <$> Binary.get
-      _ -> fail "did not find magic tag for rapidhash"
+      RAPIDHASH_V3_MAGIC_TAG -> RapidHash <$> Binary.get
+      _ -> fail $ "did not find magic tag (" <> show RAPIDHASH_V3_MAGIC_TAG <> ") for rapidhash"
   {-# INLINE get #-}
 
-----------------------------------------------------------------------------------------------------
--- Serializing
-----------------------------------------------------------------------------------------------------
-
 -- |
 -- Efficiently render a 'RapidHash' as a 'TB.Builder'
 --
@@ -182,16 +200,16 @@
 -- >>> RAPIDHASH_V3_PREFIX `T.isPrefixOf` showRapidHashText (RapidHash 0x0)
 -- True
 rapidHashTextBuilder :: RapidHash -> TB.Builder
-rapidHashTextBuilder h = TB.Builder \b -> appendPaddedHashHexBuf (b TBuff.|># "rhv3:"#) h
-{-# INLINEABLE rapidHashTextBuilder #-}
+rapidHashTextBuilder (RapidHash h) = hashTextBuilder RAPIDHASH_V3_PREFIX_ADDR h
+{-# INLINE rapidHashTextBuilder #-}
 
 -- |
 -- Efficiently render a 'RapidHash' as 'Text'.
 --
 -- Prefer 'rapidHashTextBuilder' when composing.
 showRapidHashText :: RapidHash -> Text
-showRapidHashText = TB.runBuilder . rapidHashTextBuilder
-{-# INLINEABLE showRapidHashText #-}
+showRapidHashText (RapidHash h) = showHashText RAPIDHASH_V3_PREFIX_ADDR h
+{-# INLINE showRapidHashText #-}
 
 -- |
 -- Efficiently render a 'RapidHash' as 'ByteString'. If your text blob is utf-8, it may be worth
@@ -201,55 +219,15 @@
 --
 -- See 'rapidHashTextBuilder'
 showRapidHashBS :: RapidHash -> ByteString
-showRapidHashBS = TB.runBuilderBS . rapidHashTextBuilder
-{-# INLINEABLE showRapidHashBS #-}
+showRapidHashBS (RapidHash h) = showHashBS RAPIDHASH_V3_PREFIX_ADDR h
+{-# INLINE showRapidHashBS #-}
 
 -- |
 -- Somewhat inefficiently render a 'RapidHash' as a 'String'.
 --
 -- Present for debugging purposes. Goes through 'rapidHashTextBuilder'
 showsRapidHash :: RapidHash -> ShowS
-showsRapidHash h = showString $ T.unpack (showRapidHashText h)
-
--- |
--- This is a specialized reimplementation of 'TBuff.|>&' from Andrew Lelechenko's
--- text-builder-linear that additionally pads with zeros.
-appendPaddedHashHexBuf :: TBuff.Buffer %1 -> RapidHash -> TBuff.Buffer
-appendPaddedHashHexBuf buffer (RapidHash h) =
-  -- appendBounded function preallocates a given length, and takes a callback that
-  -- mutates the array and returns how many characters it wrote.
-  TB.appendBounded
-    RAPIDHASH_V3_HEX_LENGTH
-    ( \dst off -> do
-        endOff <- unsafeAppendHexW64 dst (off + RAPIDHASH_V3_HEX_LENGTH - 1) h
-
-        -- Core lowering here is consistently fused, but if there's a regression I'd
-        -- look here first.
-        for_ @[] [off .. endOff] \i ->
-          A.unsafeWrite dst i ZERO_CHAR
-
-        pure RAPIDHASH_V3_HEX_LENGTH
-    )
-    buffer
-{-# INLINEABLE appendPaddedHashHexBuf #-}
-
-unsafeAppendHexW64 :: A.MArray s -> Int -> Word64 -> ST s Int
-unsafeAppendHexW64 marr = go
- where
-  go !off = \case
-    0 -> pure off
-    m -> do
-      let nibble = m .&. 0x0F
-      A.unsafeWrite marr off $ hex (fromIntegral nibble)
-      unsafeAppendHexW64 marr (off - 1) (m `shiftR` 4)
-
-  -- Vendored from text-builder-linear - branchless conversion
-  hex n@(I# n#) = fromIntegral $ ZERO_CHAR + n + I# (n# ># 9#) * (0x60 - 0x39)
-{-# INLINEABLE unsafeAppendHexW64 #-}
-
-----------------------------------------------------------------------------------------------------
--- Deserializing
-----------------------------------------------------------------------------------------------------
+showsRapidHash (RapidHash h) = showsHash RAPIDHASH_V3_PREFIX_ADDR h
 
 -- |
 -- Efficiently parse a 'RapidHash' from a 'Text'.
@@ -260,13 +238,13 @@
 -- Right rhv3:deadbeefdeadbeef
 --
 -- >>> parseRapidHashText "rhv3:abracadabratoomany"
--- Left "rapidhash hashes should have a length of exactly 16, but found length 18"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 18"
 --
 -- >>> parseRapidHashText "rhv3:nothexnothexnoth"
 -- Left "input does not start with a hexadecimal digit"
 --
 -- >>> parseRapidHashText "rhv3:tooshort"
--- Left "rapidhash hashes should have a length of exactly 16, but found length 8"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 8"
 --
 -- >>> parseRapidHashText "noprefix"
 -- Left "missing required prefix \"rhv3:\": \"noprefix\""
@@ -277,16 +255,8 @@
 -- >>> parseRapidHashText "rhv3:0xadbeefdeadbeef"
 -- Left "input does not start with a hexadecimal digit"
 parseRapidHashText :: Text -> Either String RapidHash
-parseRapidHashText t = do
-  mhash <- guardPrefix (T.splitAt prefixLen t)
-  guardLength (T.length mhash)
-  -- T.hexadecimal helpfully strips 0x/0X, which is not so helpful for our purposes
-  let pre = T.take 2 mhash
-  when (pre == "0x" || pre == "0X") $ Left "input does not start with a hexadecimal digit"
-  (hash, rest) <- T.hexadecimal mhash
-  guardLeftovers rest
-  pure $ RapidHash hash
-{-# INLINEABLE parseRapidHashText #-}
+parseRapidHashText t = RapidHash <$> parseHashText RAPIDHASH_V3_PREFIX t
+{-# INLINE parseRapidHashText #-}
 
 -- |
 -- Efficiently parse a 'RapidHash' from a 'ByteString'.
@@ -297,13 +267,13 @@
 -- Right rhv3:deadbeefdeadbeef
 --
 -- >>> parseRapidHashBS "rhv3:abracadabratoomany"
--- Left "rapidhash hashes should have a length of exactly 16, but found length 18"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 18"
 --
 -- >>> parseRapidHashBS "rhv3:nothexnothexnoth"
 -- Left "Could not parse hexadecimal from \"nothexnothexnoth\""
 --
 -- >>> parseRapidHashBS "rhv3:tooshort"
--- Left "rapidhash hashes should have a length of exactly 16, but found length 8"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 8"
 --
 -- >>> parseRapidHashBS "noprefix"
 -- Left "missing required prefix \"rhv3:\": \"noprefix\""
@@ -314,15 +284,8 @@
 -- >>> parseRapidHashBS "rhv3:0xadbeefdeadbeef"
 -- Left "leftovers after parsing hash: \"xadbeefdeadbeef\""
 parseRapidHashBS :: ByteString -> Either String RapidHash
-parseRapidHashBS b = do
-  mhash <- guardPrefix (BS.splitAt prefixLen b)
-  guardLength (BS.length mhash)
-  (hash, rest) <- maybe (badHex mhash) Right (BS.readHexadecimal mhash)
-  guardLeftovers rest
-  pure $ RapidHash hash
- where
-  badHex mhash = Left $ "Could not parse hexadecimal from \"" <> BSC8.unpack mhash <> "\""
-{-# INLINEABLE parseRapidHashBS #-}
+parseRapidHashBS b = RapidHash <$> parseHashBS RAPIDHASH_V3_PREFIX b
+{-# INLINE parseRapidHashBS #-}
 
 -- |
 -- Somewhat inefficiently parse a 'RapidHash' from a 'String'.
@@ -334,16 +297,294 @@
 -- >>> readsRapidHash "rhv3:0000000000000abcdagk"
 -- [(rhv3:0000000000000abc,"dagk")]
 readsRapidHash :: ReadS RapidHash
-readsRapidHash s =
-  let (this, rest) = L.splitAt (prefixLen + RAPIDHASH_V3_HEX_LENGTH) (L.dropWhile isSpace s)
-   in case parseRapidHashText (T.pack this) of
+readsRapidHash s = map (first RapidHash) $ readsHash RAPIDHASH_V3_PREFIX s
+
+----------------------------------------------------------------------------------------------------
+-- rapidhashmicro
+----------------------------------------------------------------------------------------------------
+
+-- | A rapidhashMicro v3 digest.
+--
+-- rapidhashMicro is tuned for small keys: upstream reports it faster than rapidhash
+-- for inputs up to 512 bytes, and 15-20% slower above 1kb. Results are identical to
+-- 'RapidHash' for inputs of 80 bytes or fewer; from 81 bytes on they diverge.
+--
+-- The textual form is @rhmv3:@ followed by exactly 16 hex digits, always
+-- rendered lowercase. Parsing accepts either case, but rejects any other prefix,
+-- length, or stray characters.
+--
+-- === __Examples__
+-- >>> RapidHashMicro 0xabc
+-- rhmv3:0000000000000abc
+--
+-- >>> Prelude.read "rhmv3:0000000000000abc" :: RapidHashMicro
+-- rhmv3:0000000000000abc
+newtype RapidHashMicro = RapidHashMicro Word64
+  deriving stock (Generic)
+  deriving newtype (Eq, Hashable, NFData, Ord)
+
+-- |
+-- The prefix used during serialization and deserialization. This is not a universal
+-- convention, but an identifier that should help prevent confusing these hashes
+-- with others.
+--
+-- Exported for convenience.
+pattern RAPIDHASH_MICRO_V3_PREFIX :: (IsString a, Eq a) => a
+pattern RAPIDHASH_MICRO_V3_PREFIX = "rhmv3:"
+#define RAPIDHASH_MICRO_V3_PREFIX_ADDR "rhmv3:"#
+
+instance Show RapidHashMicro where
+  showsPrec _ = showsRapidHashMicro
+
+-- |
+--
+-- === __Examples__
+--
+-- >>> Prelude.read (show (Prelude.Just (RapidHashMicro 0x1234))) :: Prelude.Maybe RapidHashMicro
+-- Just rhmv3:0000000000001234
+instance Read RapidHashMicro where
+  readsPrec _ = readsRapidHashMicro
+
+pattern RAPIDHASH_MICRO_V3_MAGIC_TAG :: Word8
+pattern RAPIDHASH_MICRO_V3_MAGIC_TAG = 31
+
+-- |
+-- Efficient binary serialization and deserialization, with a just-good-enough tag.
+--
+-- Encodes in 9 bytes: One byte for the tag, 8 for the 'Word64'.
+instance Binary RapidHashMicro where
+  put (RapidHashMicro h) = do
+    Binary.putWord8 RAPIDHASH_MICRO_V3_MAGIC_TAG
+    Binary.put h
+  {-# INLINE put #-}
+  get = do
+    tag <- Binary.getWord8
+    case tag of
+      RAPIDHASH_MICRO_V3_MAGIC_TAG -> RapidHashMicro <$> Binary.get
+      _ -> fail $ "did not find magic tag (" <> show RAPIDHASH_MICRO_V3_MAGIC_TAG <> ") for rapidhashMicro"
+  {-# INLINE get #-}
+
+-- |
+-- Efficiently render a 'RapidHashMicro' as a 'TB.Builder'
+--
+-- === __Examples__
+--
+-- >>> rapidhashMicroTextBuilder (RapidHashMicro 0x0)
+-- "rhmv3:0000000000000000"
+--
+-- >>> rapidhashMicroTextBuilder (RapidHashMicro 0xabcd3)
+-- "rhmv3:00000000000abcd3"
+--
+-- >>> rapidhashMicroTextBuilder (RapidHashMicro 0xfffff2381)
+-- "rhmv3:0000000fffff2381"
+--
+-- === __Prefixing__
+--
+-- >>> RAPIDHASH_MICRO_V3_PREFIX `T.isPrefixOf` showRapidHashMicroText (RapidHashMicro 0x0)
+-- True
+rapidhashMicroTextBuilder :: RapidHashMicro -> TB.Builder
+rapidhashMicroTextBuilder (RapidHashMicro h) = hashTextBuilder RAPIDHASH_MICRO_V3_PREFIX_ADDR h
+{-# INLINE rapidhashMicroTextBuilder #-}
+
+-- |
+-- Efficiently render a 'RapidHashMicro' as 'Text'.
+--
+-- Prefer 'rapidhashMicroTextBuilder' when composing.
+showRapidHashMicroText :: RapidHashMicro -> Text
+showRapidHashMicroText (RapidHashMicro h) = showHashText RAPIDHASH_MICRO_V3_PREFIX_ADDR h
+{-# INLINE showRapidHashMicroText #-}
+
+-- |
+-- Efficiently render a 'RapidHashMicro' as 'ByteString'. If your text blob is utf-8, it may be worth
+-- composing using 'TB.Builder' and extracting with 'TB.runBuilderBS' yourself.
+--
+-- The resulting 'ByteString' is utf-8 encoded, using 'TB.runBuilderBS'
+--
+-- See 'rapidhashMicroTextBuilder'
+showRapidHashMicroBS :: RapidHashMicro -> ByteString
+showRapidHashMicroBS (RapidHashMicro h) = showHashBS RAPIDHASH_MICRO_V3_PREFIX_ADDR h
+{-# INLINE showRapidHashMicroBS #-}
+
+-- |
+-- Somewhat inefficiently render a 'RapidHashMicro' as a 'String'.
+--
+-- Present for debugging purposes. Goes through 'rapidhashMicroTextBuilder'
+showsRapidHashMicro :: RapidHashMicro -> ShowS
+showsRapidHashMicro (RapidHashMicro h) = showsHash RAPIDHASH_MICRO_V3_PREFIX_ADDR h
+
+-- |
+-- Efficiently parse a 'RapidHashMicro' from a 'Text'.
+--
+-- == __Examples__
+--
+-- >>> parseRapidHashMicroText "rhmv3:deadbeefdeadbeef"
+-- Right rhmv3:deadbeefdeadbeef
+--
+-- >>> parseRapidHashMicroText "rhmv3:abracadabratoomany"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 18"
+--
+-- >>> parseRapidHashMicroText "rhmv3:nothexnothexnoth"
+-- Left "input does not start with a hexadecimal digit"
+--
+-- >>> parseRapidHashMicroText "rhmv3:tooshort"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 8"
+--
+-- >>> parseRapidHashMicroText "noprefix"
+-- Left "missing required prefix \"rhmv3:\": \"noprefix\""
+--
+-- >>> parseRapidHashMicroText "rhmv3:abcdefabcdefabcg"
+-- Left "leftovers after parsing hash: \"g\""
+--
+-- >>> parseRapidHashMicroText "rhmv3:0xadbeefdeadbeef"
+-- Left "input does not start with a hexadecimal digit"
+parseRapidHashMicroText :: Text -> Either String RapidHashMicro
+parseRapidHashMicroText t = RapidHashMicro <$> parseHashText RAPIDHASH_MICRO_V3_PREFIX t
+{-# INLINE parseRapidHashMicroText #-}
+
+-- |
+-- Efficiently parse a 'RapidHashMicro' from a 'ByteString'.
+--
+-- == __Examples__
+--
+-- >>> parseRapidHashMicroBS "rhmv3:deadbeefdeadbeef"
+-- Right rhmv3:deadbeefdeadbeef
+--
+-- >>> parseRapidHashMicroBS "rhmv3:abracadabratoomany"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 18"
+--
+-- >>> parseRapidHashMicroBS "rhmv3:nothexnothexnoth"
+-- Left "Could not parse hexadecimal from \"nothexnothexnoth\""
+--
+-- >>> parseRapidHashMicroBS "rhmv3:tooshort"
+-- Left "rapidhash hashes should have an exact, constant length per variant. Expected 16, but found length 8"
+--
+-- >>> parseRapidHashMicroBS "noprefix"
+-- Left "missing required prefix \"rhmv3:\": \"noprefix\""
+--
+-- >>> parseRapidHashMicroBS "rhmv3:abcdefabcdefabcg"
+-- Left "leftovers after parsing hash: \"g\""
+--
+-- >>> parseRapidHashMicroBS "rhmv3:0xadbeefdeadbeef"
+-- Left "leftovers after parsing hash: \"xadbeefdeadbeef\""
+parseRapidHashMicroBS :: ByteString -> Either String RapidHashMicro
+parseRapidHashMicroBS b = RapidHashMicro <$> parseHashBS RAPIDHASH_MICRO_V3_PREFIX b
+{-# INLINE parseRapidHashMicroBS #-}
+
+-- |
+-- Somewhat inefficiently parse a 'RapidHashMicro' from a 'String'.
+--
+-- Present for debugging purposes. Goes through 'parseRapidHashMicroText'. Unlike the other
+-- parse functions, this allows trailing characters.
+--
+-- === __Examples__
+-- >>> readsRapidHashMicro "rhmv3:0000000000000abcdagk"
+-- [(rhmv3:0000000000000abc,"dagk")]
+readsRapidHashMicro :: ReadS RapidHashMicro
+readsRapidHashMicro s = map (first RapidHashMicro) $ readsHash RAPIDHASH_MICRO_V3_PREFIX s
+
+----------------------------------------------------------------------------------------------------
+-- Hash-agnostic
+----------------------------------------------------------------------------------------------------
+
+-- | Efficiently render a hash as a 'TB.Builder'
+hashTextBuilder :: Addr# -> Word64 -> TB.Builder
+hashTextBuilder prefix h = TB.Builder \b -> appendPaddedHashHexBuf (b TBuff.|># prefix) h
+{-# INLINEABLE hashTextBuilder #-}
+
+-- | Efficiently render a hash as 'Text'.
+showHashText :: Addr# -> Word64 -> Text
+showHashText prefix h = TB.runBuilder (hashTextBuilder prefix h)
+{-# INLINEABLE showHashText #-}
+
+-- |
+-- Efficiently render a hash as 'ByteString'.
+--
+-- The resulting 'ByteString' is utf-8 encoded, using 'TB.runBuilderBS'
+showHashBS :: Addr# -> Word64 -> ByteString
+showHashBS prefix h = TB.runBuilderBS (hashTextBuilder prefix h)
+{-# INLINEABLE showHashBS #-}
+
+-- |
+-- Somewhat inefficiently render a hash as a 'String'.
+--
+-- Present for debugging purposes. Goes through 'hashTextBuilder'
+showsHash :: Addr# -> Word64 -> ShowS
+showsHash prefix h = showString $ T.unpack (showHashText prefix h)
+
+-- |
+-- This is a specialized reimplementation of 'TBuff.|>&' from Andrew Lelechenko's
+-- text-builder-linear that additionally pads with zeros.
+appendPaddedHashHexBuf :: TBuff.Buffer %1 -> Word64 -> TBuff.Buffer
+appendPaddedHashHexBuf buffer h =
+  -- appendBounded function preallocates a given length, and takes a callback that
+  -- mutates the array and returns how many characters it wrote.
+  TB.appendBounded
+    RAPIDHASH_V3_HEX_LENGTH
+    ( \dst off -> do
+        endOff <- unsafeAppendHexW64 dst (off + RAPIDHASH_V3_HEX_LENGTH - 1) h
+
+        -- Core lowering here is consistently fused, but if there's a regression I'd
+        -- look here first.
+        for_ @[] [off .. endOff] \i ->
+          A.unsafeWrite dst i ZERO_CHAR
+
+        pure RAPIDHASH_V3_HEX_LENGTH
+    )
+    buffer
+{-# INLINEABLE appendPaddedHashHexBuf #-}
+
+unsafeAppendHexW64 :: A.MArray s -> Int -> Word64 -> ST s Int
+unsafeAppendHexW64 marr = go
+ where
+  go !off = \case
+    0 -> pure off
+    m -> do
+      let nibble = m .&. 0x0F
+      A.unsafeWrite marr off $ hex (fromIntegral nibble)
+      unsafeAppendHexW64 marr (off - 1) (m `shiftR` 4)
+
+  -- Vendored from text-builder-linear - branchless conversion
+  hex n@(I# n#) = fromIntegral $ ZERO_CHAR + n + I# (n# ># 9#) * (0x60 - 0x39)
+{-# INLINEABLE unsafeAppendHexW64 #-}
+
+-- | Efficiently parse a hash from a 'Text'.
+parseHashText :: Text -> Text -> Either String Word64
+parseHashText prefix t = do
+  mhash <- guardPrefix prefix (T.splitAt (T.length prefix) t)
+  guardLength (T.length mhash)
+  -- T.hexadecimal helpfully strips 0x/0X, which is not so helpful for our purposes
+  let pre = T.take 2 mhash
+  when (pre == "0x" || pre == "0X") $ Left "input does not start with a hexadecimal digit"
+  (hash, rest) <- T.hexadecimal mhash
+  guardLeftovers rest
+  pure hash
+{-# INLINEABLE parseHashText #-}
+
+-- | Efficiently parse a hash from a 'ByteString'.
+parseHashBS :: ByteString -> ByteString -> Either String Word64
+parseHashBS prefix b = do
+  mhash <- guardPrefix prefix (BS.splitAt (BS.length prefix) b)
+  guardLength (BS.length mhash)
+  (hash, rest) <- maybe (badHex mhash) Right (BS.readHexadecimal mhash)
+  guardLeftovers rest
+  pure hash
+ where
+  badHex mhash = Left $ "Could not parse hexadecimal from \"" <> BSC8.unpack mhash <> "\""
+{-# INLINEABLE parseHashBS #-}
+
+-- | Somewhat inefficiently parse a hash from a 'String'.
+readsHash :: Text -> ReadS Word64
+readsHash prefix s =
+  let (this, rest) = L.splitAt (T.length prefix + RAPIDHASH_V3_HEX_LENGTH) (L.dropWhile isSpace s)
+   in case parseHashText prefix (T.pack this) of
         Right parsed -> [(parsed, rest)]
         Left _ -> []
 
-guardPrefix :: (IsString a, Show a, Semigroup a, Eq a) => (a, a) -> Either String a
-guardPrefix = \case
-  (RAPIDHASH_V3_PREFIX, mhash) -> Right mhash
-  (pre, post) -> Left $ "missing required prefix \"" <> RAPIDHASH_V3_PREFIX <> "\": " <> show (pre <> post)
+guardPrefix :: (Show a, Semigroup a, Eq a) => a -> (a, a) -> Either String a
+guardPrefix prefix (prefixMay, hash)
+  | prefixMay == prefix = Right hash
+  | otherwise = Left $ "missing required prefix " <> show prefix <> ": " <> show (prefixMay <> hash)
+{-# INLINE guardPrefix #-}
 
 guardLength :: (Show a, Eq a, Num a) => a -> Either String ()
 guardLength len
@@ -351,7 +592,7 @@
   | otherwise = Left badLength
  where
   badLength =
-    "rapidhash hashes should have a length of exactly "
+    "rapidhash hashes should have an exact, constant length per variant. Expected "
       <> show @Int RAPIDHASH_V3_HEX_LENGTH
       <> ", but found length "
       <> show len
diff --git a/test/RapidHashTest.hs b/test/RapidHashTest.hs
--- a/test/RapidHashTest.hs
+++ b/test/RapidHashTest.hs
@@ -1,6 +1,7 @@
 module RapidHashTest where
 
 import Control.Monad (forM_)
+import Data.Binary qualified as Binary
 import Data.ByteString qualified as BS
 import Data.ByteString.Short qualified as SBS
 import Data.Primitive.PrimArray (primArrayFromList)
@@ -17,27 +18,91 @@
 
 import Data.Hash.RapidHash (
   RapidHash (RapidHash),
+  RapidHashMicro (RapidHashMicro),
   RapidSeed (RapidSeed),
   rapidhash,
+  rapidhashMicro,
+  rapidhashMicroWithSeed,
   rapidhashWithSeed,
  )
 
 unit_showIsTaggedPaddedHex :: Assertion
-unit_showIsTaggedPaddedHex =
+unit_showIsTaggedPaddedHex = do
   show (RapidHash 0xabc) @?= "rhv3:0000000000000abc"
+  show (RapidHashMicro 0xabc) @?= "rhmv3:0000000000000abc"
 
 unit_readRejectsForeignTags :: Assertion
 unit_readRejectsForeignTags = do
   reads @RapidHash "rhv4:0000000000000abc" @?= [] -- future
   reads @RapidHash "fnv1a64:0000000000000abc" @?= [] -- other hash
   reads @RapidHash "rhv3:abc" @?= [] -- invalid hash length
+  reads @RapidHashMicro "rhmv4:0000000000000abc" @?= []
+  reads @RapidHashMicro "fnv1a64:0000000000000abc" @?= []
+  reads @RapidHashMicro "rhmv3:abc" @?= []
 
+-- | The two variants disagree above 80 bytes, so a digest of one must never
+-- read back as the other — that is the whole point of the distinct tags.
+unit_variantTagsDoNotCrossParse :: Assertion
+unit_variantTagsDoNotCrossParse = do
+  reads @RapidHash (show (RapidHashMicro 0xabc)) @?= []
+  reads @RapidHashMicro (show (RapidHash 0xabc)) @?= []
+
+-- | Same, for the compact 9-byte @Binary@ encoding: the leading magic tag must
+-- keep the two variants apart.
+unit_binaryTagsDoNotCrossDecode :: Assertion
+unit_binaryTagsDoNotCrossDecode = do
+  let encoded = Binary.encode (RapidHash 0x1234)
+      encodedMicro = Binary.encode (RapidHashMicro 0x1234)
+  assertBool "micro bytes rejected as RapidHash" $
+    isLeft (Binary.decodeOrFail @RapidHash encodedMicro)
+  assertBool "rapidhash bytes rejected as RapidHashMicro" $
+    isLeft (Binary.decodeOrFail @RapidHashMicro encoded)
+  Binary.decode encoded @?= RapidHash 0x1234
+  Binary.decode encodedMicro @?= RapidHashMicro 0x1234
+ where
+  isLeft = either (const True) (const False)
+
 hprop_showReadRoundtrip :: Property
 hprop_showReadRoundtrip = property do
   w <- forAll (Gen.word64 Range.linearBounded)
   let h = RapidHash w
   read (show h) === h
 
+-- | Rendering goes through the @Addr#@ prefix literal while parsing goes through
+-- the prefix pattern synonym, so this property is what keeps the two definitions
+-- of @rhmv3:@ in agreement.
+hprop_microShowReadRoundtrip :: Property
+hprop_microShowReadRoundtrip = property do
+  w <- forAll (Gen.word64 Range.linearBounded)
+  let h = RapidHashMicro w
+  read (show h) === h
+
+-- | rapidhashMicro's block loop only kicks in above 80 bytes, so up to and
+-- including 80 it must agree with rapidhash exactly, at any seed. This pins the
+-- boundary the haddocks document.
+hprop_microAgreesWithRapidhashThrough80 :: Property
+hprop_microAgreesWithRapidhashThrough80 = property do
+  len <- forAll (Gen.int (Range.linear 0 80))
+  s <- forAll (Gen.word64 Range.linearBounded)
+  let bs = bufBS len
+      seed = RapidSeed s
+      RapidHash expected = rapidhashWithSeed seed bs
+      RapidHashMicro actual = rapidhashMicroWithSeed seed bs
+  actual === expected
+  let RapidHash expected' = rapidhash bs
+      RapidHashMicro actual' = rapidhashMicro bs
+  actual' === expected'
+
+-- | The other side of the boundary: from 81 bytes on the variants must diverge,
+-- otherwise the separate type and tag would be pointless.
+unit_microDivergesFrom81 :: Assertion
+unit_microDivergesFrom81 =
+  forM_ [81, 82, 112, 113, 256, 1024] \len -> do
+    let bs = bufBS len
+        RapidHash expected = rapidhash bs
+        RapidHashMicro actual = rapidhashMicro bs
+    assertBool ("variants diverge at length " <> show len) (actual /= expected)
+
 -- | The Text entry hashes the UTF-8 payload in place; it must agree with
 -- hashing the encoded bytes (and the ShortByteString copy of them) — at
 -- the default seed, at a random seed (pinning the seed plumbing of the
@@ -55,6 +120,14 @@
   rapidhashWithSeed seed (SBS.toShort bytes) === rapidhashWithSeed seed bytes
   let t' = T.drop 1 t
   rapidhash t' === rapidhash (TE.encodeUtf8 t')
+  -- Same again for the micro variant, which has its own set of FFI wrappers and
+  -- its own offset shim.
+  rapidhashMicro t === rapidhashMicro bytes
+  rapidhashMicro (SBS.toShort bytes) === rapidhashMicro bytes
+  rapidhashMicro (BS.copy bytes) === rapidhashMicro bytes
+  rapidhashMicroWithSeed seed t === rapidhashMicroWithSeed seed bytes
+  rapidhashMicroWithSeed seed (SBS.toShort bytes) === rapidhashMicroWithSeed seed bytes
+  rapidhashMicro t' === rapidhashMicro (TE.encodeUtf8 t')
 
 hprop_vectorInstancesAgreeWithBytes :: Property
 hprop_vectorInstancesAgreeWithBytes = property do
@@ -69,6 +142,11 @@
   rapidhash sv === rapidhash pv
   rapidhash (primArrayFromList ws) === rapidhash pv
   rapidhash pvSlice === rapidhash (pvBytes pvSlice)
+  rapidhashMicro sv === rapidhashMicro (SV.unsafeCast sv :: SV.Vector Word8)
+  rapidhashMicro pv === rapidhashMicro (pvBytes pv)
+  rapidhashMicro sv === rapidhashMicro pv
+  rapidhashMicro (primArrayFromList ws) === rapidhashMicro pv
+  rapidhashMicro pvSlice === rapidhashMicro (pvBytes pvSlice)
 
 -- | Known-answer vectors generated from the vendored upstream header by
 -- @test/pin/pin.c@ (verify or regenerate with @scripts/rapidhash-pin.sh@
@@ -84,12 +162,18 @@
     ["withSeed", lenS, seedS, hashS] ->
       assertEqual line (RapidHash (hex hashS)) $
         rapidhashWithSeed (RapidSeed (hex seedS)) (bufBS (read lenS))
-    ["offset", offS, lenS, seedS, hashS] -> do
-      let off = read offS
-          len = read lenS
-          slice = PV.drop off (PV.fromList (bufBytes (off + len)) :: PV.Vector Word8)
+    ["offset", offS, lenS, seedS, hashS] ->
       assertEqual line (RapidHash (hex hashS)) $
-        rapidhashWithSeed (RapidSeed (hex seedS)) slice
+        rapidhashWithSeed (RapidSeed (hex seedS)) (sliceOf (read offS) (read lenS))
+    ["micro", lenS, hashS] ->
+      assertEqual line (RapidHashMicro (hex hashS)) $
+        rapidhashMicro (bufBS (read lenS))
+    ["microWithSeed", lenS, seedS, hashS] ->
+      assertEqual line (RapidHashMicro (hex hashS)) $
+        rapidhashMicroWithSeed (RapidSeed (hex seedS)) (bufBS (read lenS))
+    ["microOffset", offS, lenS, seedS, hashS] ->
+      assertEqual line (RapidHashMicro (hex hashS)) $
+        rapidhashMicroWithSeed (RapidSeed (hex seedS)) (sliceOf (read offS) (read lenS))
     _ -> assertFailure ("unparseable golden line: " <> line)
  where
   hex :: String -> Word64
@@ -97,9 +181,13 @@
     [(v, "")] -> v
     _ -> error ("bad hex field in golden file: " <> s)
 
-  -- Deterministic filler; mirrors byte_at in test/pin/pin.c.
-  bufBytes :: Int -> [Word8]
-  bufBytes n = [fromIntegral (i * 167 + 13) | i <- [0 .. n - 1]]
+  -- A sliced Vector, to drive the offset shim rather than a pre-cut buffer.
+  sliceOf :: Int -> Int -> PV.Vector Word8
+  sliceOf off len = PV.drop off (PV.fromList (bufBytes (off + len)))
 
-  bufBS :: Int -> BS.ByteString
-  bufBS = BS.pack . bufBytes
+-- | Deterministic filler; mirrors byte_at in test/pin/pin.c.
+bufBytes :: Int -> [Word8]
+bufBytes n = [fromIntegral (i * 167 + 13) | i <- [0 .. n - 1]]
+
+bufBS :: Int -> BS.ByteString
+bufBS = BS.pack . bufBytes
diff --git a/test/pin/pin.c b/test/pin/pin.c
--- a/test/pin/pin.c
+++ b/test/pin/pin.c
@@ -2,7 +2,8 @@
  * Known-answer vector generator for the rapidhash Haskell binding.
  *
  * Compiled against the vendored upstream header (cbits/rapidhash.h) and the
- * local shim (cbits/rapidhash_ext.h), it prints reference digests to stdout.
+ * local shim (cbits/rapidhash_ext.h), it prints reference digests for both the
+ * rapidhash and rapidhashMicro variants to stdout.
  * The committed golden file (test/pin/rapidhash-v3-pin.txt) is this program's
  * output; the Haskell test suite recomputes every line through the binding's
  * ByteString entrypoint (and the sliced Vector path for the offset shim).
@@ -61,6 +62,24 @@
                offset_lengths[li], offset_seeds[si],
                rapidhash_offset_withSeed(buf, offsets[oi], offset_lengths[li],
                                          offset_seeds[si]));
+
+  for (size_t li = 0; li < COUNT(lengths); li++)
+    printf("micro %zu %016" PRIx64 "\n", lengths[li],
+           rapidhashMicro(buf, lengths[li]));
+
+  for (size_t li = 0; li < COUNT(lengths); li++)
+    for (size_t si = 0; si < COUNT(seeds); si++)
+      printf("microWithSeed %zu %016" PRIx64 " %016" PRIx64 "\n", lengths[li],
+             seeds[si], rapidhashMicro_withSeed(buf, lengths[li], seeds[si]));
+
+  for (size_t oi = 0; oi < COUNT(offsets); oi++)
+    for (size_t li = 0; li < COUNT(offset_lengths); li++)
+      for (size_t si = 0; si < COUNT(offset_seeds); si++)
+        printf("microOffset %zu %zu %016" PRIx64 " %016" PRIx64 "\n",
+               offsets[oi], offset_lengths[li], offset_seeds[si],
+               rapidhashMicro_offset_withSeed(buf, offsets[oi],
+                                              offset_lengths[li],
+                                              offset_seeds[si]));
 
   free(buf);
   return 0;
diff --git a/test/pin/rapidhash-v3-pin.txt b/test/pin/rapidhash-v3-pin.txt
--- a/test/pin/rapidhash-v3-pin.txt
+++ b/test/pin/rapidhash-v3-pin.txt
@@ -382,3 +382,387 @@
 offset 17 64 00000000deadbeef 15c05b7fa243027f
 offset 17 257 0000000000000000 4bd9fa46f08c671b
 offset 17 257 00000000deadbeef 858abb96791bc043
+micro 0 0338dc4be2cecdae
+micro 1 e8d3b882671125a6
+micro 2 72f646f85991e6ff
+micro 3 c76c8514de0eb9f0
+micro 4 54ceab033b17ed48
+micro 5 927048267a1e0e6c
+micro 6 8a479b23d49ea8c0
+micro 7 6c91739e11166758
+micro 8 cb1c61491fd8ed0c
+micro 9 c8c920654ad0a214
+micro 10 1c197f92a46cd6a8
+micro 11 ed353bd1078d750d
+micro 12 a7d066f68974928b
+micro 13 784066c84e806ea5
+micro 14 4ae43dd7c228e5d0
+micro 15 cf0671c9f0e79123
+micro 16 51cf6b59dc9af20b
+micro 17 d72787ae7a2963b8
+micro 31 9e168ae2c0b51969
+micro 32 0214629041803a0c
+micro 33 c8c2c6562d2ec99b
+micro 47 d86d732eb077836d
+micro 48 5f31b4484305dbe9
+micro 49 842be8c228f50882
+micro 63 fd8fc3f2f5223ee6
+micro 64 44d70d4c8b15579f
+micro 65 f6bbae844d4d4181
+micro 79 58026c3618a2a508
+micro 80 df336fbf7f62d83b
+micro 81 082807afd7b12fb2
+micro 111 c647d4353ec1d7e6
+micro 112 612fb9039abc2b24
+micro 113 0310109732a00c86
+micro 127 da335cdf507c6503
+micro 128 55f26763c2d4f434
+micro 129 4dd46b82a5c01d10
+micro 191 0c8368fd78d8d79b
+micro 192 4d48c4b4acf26329
+micro 193 85b09015f8cdb7b4
+micro 223 1bae47622466c8ea
+micro 224 8bd5ea592b313576
+micro 225 175100fa9e5867cc
+micro 255 03a1de4052fad3fc
+micro 256 e17dc92420e21643
+micro 257 13b2f99222a3143d
+micro 447 31168fbd47b630c2
+micro 448 bce8c898ef125347
+micro 449 fefc51f9c37a8840
+micro 511 1e1480ba4aa269d6
+micro 512 015ac81805fd6c96
+micro 1023 4ffdb20b18464bec
+micro 1024 20030530f6314046
+micro 4096 8c34b5dcd4aa3e13
+micro 65535 9d82472e94cd1a74
+micro 65536 94258402d3266410
+micro 300007 f6a75558d6bc767e
+microWithSeed 0 0000000000000000 0338dc4be2cecdae
+microWithSeed 0 0000000000000001 ad700ecdf353d5ca
+microWithSeed 0 00000000deadbeef 842e1a82b8ea7243
+microWithSeed 0 123456789abcdef0 66db63b3916becf4
+microWithSeed 0 ffffffffffffffff 9a9c59147a213be8
+microWithSeed 1 0000000000000000 e8d3b882671125a6
+microWithSeed 1 0000000000000001 ab407ce6511467c4
+microWithSeed 1 00000000deadbeef 6129164d197e499c
+microWithSeed 1 123456789abcdef0 6833d7e3e8065a9f
+microWithSeed 1 ffffffffffffffff af19bbe1857eda2b
+microWithSeed 2 0000000000000000 72f646f85991e6ff
+microWithSeed 2 0000000000000001 2eee397c4532100e
+microWithSeed 2 00000000deadbeef caac963ed10e31e5
+microWithSeed 2 123456789abcdef0 f22714f0fdf61dde
+microWithSeed 2 ffffffffffffffff c4b1f8698f1cdd9a
+microWithSeed 3 0000000000000000 c76c8514de0eb9f0
+microWithSeed 3 0000000000000001 fa3c53e10185181c
+microWithSeed 3 00000000deadbeef f5f25d77cd27c8c3
+microWithSeed 3 123456789abcdef0 e7da94088e9d352a
+microWithSeed 3 ffffffffffffffff d72c2937bcd00a14
+microWithSeed 4 0000000000000000 54ceab033b17ed48
+microWithSeed 4 0000000000000001 4986b01041f8f9d8
+microWithSeed 4 00000000deadbeef 9de3be9cd249d4d3
+microWithSeed 4 123456789abcdef0 403fbc89ba50a3e0
+microWithSeed 4 ffffffffffffffff 572e595c91494030
+microWithSeed 5 0000000000000000 927048267a1e0e6c
+microWithSeed 5 0000000000000001 5193f513a7783e25
+microWithSeed 5 00000000deadbeef b7e5650ac2a5170e
+microWithSeed 5 123456789abcdef0 0787592e5c0f371e
+microWithSeed 5 ffffffffffffffff f832cd04e84e96b0
+microWithSeed 6 0000000000000000 8a479b23d49ea8c0
+microWithSeed 6 0000000000000001 6f87e160ee3f0d00
+microWithSeed 6 00000000deadbeef a522b82d7180e9f4
+microWithSeed 6 123456789abcdef0 856349c2ac3dec25
+microWithSeed 6 ffffffffffffffff 62a7140fe38a9f23
+microWithSeed 7 0000000000000000 6c91739e11166758
+microWithSeed 7 0000000000000001 11017bb55c556f75
+microWithSeed 7 00000000deadbeef 5ff42368a57cfc48
+microWithSeed 7 123456789abcdef0 7b321310e63b13c5
+microWithSeed 7 ffffffffffffffff f57e96782b26e319
+microWithSeed 8 0000000000000000 cb1c61491fd8ed0c
+microWithSeed 8 0000000000000001 4221eaa066d079a0
+microWithSeed 8 00000000deadbeef a43716be5754d9c8
+microWithSeed 8 123456789abcdef0 69e33dd175f91269
+microWithSeed 8 ffffffffffffffff 3e021c1802c19e61
+microWithSeed 9 0000000000000000 c8c920654ad0a214
+microWithSeed 9 0000000000000001 d3cda3b2b3fb361a
+microWithSeed 9 00000000deadbeef b1606a4eb9d49c12
+microWithSeed 9 123456789abcdef0 80d7ad6b0f34c372
+microWithSeed 9 ffffffffffffffff 454f767d1e729858
+microWithSeed 10 0000000000000000 1c197f92a46cd6a8
+microWithSeed 10 0000000000000001 f4aaa18c11b1880a
+microWithSeed 10 00000000deadbeef 2335184b7457b759
+microWithSeed 10 123456789abcdef0 d00ed7c6ccf3b1c9
+microWithSeed 10 ffffffffffffffff 51333ee955674cdb
+microWithSeed 11 0000000000000000 ed353bd1078d750d
+microWithSeed 11 0000000000000001 c0aaf8ec129962df
+microWithSeed 11 00000000deadbeef 5e3ba7f5376e28c2
+microWithSeed 11 123456789abcdef0 7316224e1217eeda
+microWithSeed 11 ffffffffffffffff 1501e404ed0c8173
+microWithSeed 12 0000000000000000 a7d066f68974928b
+microWithSeed 12 0000000000000001 18fa41a627de8ae6
+microWithSeed 12 00000000deadbeef d0df8a7a79a40a40
+microWithSeed 12 123456789abcdef0 d488a65dd82b12e0
+microWithSeed 12 ffffffffffffffff 451c70f6b6907acf
+microWithSeed 13 0000000000000000 784066c84e806ea5
+microWithSeed 13 0000000000000001 99fa1f10497a31db
+microWithSeed 13 00000000deadbeef e1ec8947c089c530
+microWithSeed 13 123456789abcdef0 b344d1bd2e98f286
+microWithSeed 13 ffffffffffffffff d225da173586c005
+microWithSeed 14 0000000000000000 4ae43dd7c228e5d0
+microWithSeed 14 0000000000000001 d09aa54913bc8b20
+microWithSeed 14 00000000deadbeef 1cb5455fc4da65d4
+microWithSeed 14 123456789abcdef0 3958ad503597c1e4
+microWithSeed 14 ffffffffffffffff b59881651749ae07
+microWithSeed 15 0000000000000000 cf0671c9f0e79123
+microWithSeed 15 0000000000000001 ffcd5b7587b3e03b
+microWithSeed 15 00000000deadbeef e5337aa3e048c6fb
+microWithSeed 15 123456789abcdef0 eea33d3c96cdbc23
+microWithSeed 15 ffffffffffffffff d33d8734a2b79584
+microWithSeed 16 0000000000000000 51cf6b59dc9af20b
+microWithSeed 16 0000000000000001 84ab3e852806f36a
+microWithSeed 16 00000000deadbeef a9762803b339f0fd
+microWithSeed 16 123456789abcdef0 e4be0a162a51e769
+microWithSeed 16 ffffffffffffffff 2ea6a93e9ce31a37
+microWithSeed 17 0000000000000000 d72787ae7a2963b8
+microWithSeed 17 0000000000000001 9093dae1bd413ea0
+microWithSeed 17 00000000deadbeef d6c07c2008ef78d7
+microWithSeed 17 123456789abcdef0 46a516c54320aa5c
+microWithSeed 17 ffffffffffffffff b4e97bd9a73141f0
+microWithSeed 31 0000000000000000 9e168ae2c0b51969
+microWithSeed 31 0000000000000001 8f2391580911c9e4
+microWithSeed 31 00000000deadbeef 80275fc3bfac3335
+microWithSeed 31 123456789abcdef0 7634b61596605b71
+microWithSeed 31 ffffffffffffffff 8603fa15b02d472d
+microWithSeed 32 0000000000000000 0214629041803a0c
+microWithSeed 32 0000000000000001 082341b09271e938
+microWithSeed 32 00000000deadbeef 1074a288def125c8
+microWithSeed 32 123456789abcdef0 c58c04deaced7e90
+microWithSeed 32 ffffffffffffffff ee2301861ae63206
+microWithSeed 33 0000000000000000 c8c2c6562d2ec99b
+microWithSeed 33 0000000000000001 52ce883d43df49e3
+microWithSeed 33 00000000deadbeef 5963dad2db66368b
+microWithSeed 33 123456789abcdef0 f8d6ffc1efd49dcf
+microWithSeed 33 ffffffffffffffff 70a8eea0202f83dd
+microWithSeed 47 0000000000000000 d86d732eb077836d
+microWithSeed 47 0000000000000001 a98da65e2ac325c6
+microWithSeed 47 00000000deadbeef 65f7976f3bc306f8
+microWithSeed 47 123456789abcdef0 8270fa92c75b6810
+microWithSeed 47 ffffffffffffffff 144281ea7877c5f2
+microWithSeed 48 0000000000000000 5f31b4484305dbe9
+microWithSeed 48 0000000000000001 5a6418ef65972d4f
+microWithSeed 48 00000000deadbeef e53b01b9b393c510
+microWithSeed 48 123456789abcdef0 c7959121472d055a
+microWithSeed 48 ffffffffffffffff d88f445b35e4715b
+microWithSeed 49 0000000000000000 842be8c228f50882
+microWithSeed 49 0000000000000001 1de81b8817a8f2ca
+microWithSeed 49 00000000deadbeef cac1555db0979cbf
+microWithSeed 49 123456789abcdef0 a809d1335aa96fef
+microWithSeed 49 ffffffffffffffff d59cc76de50d9c53
+microWithSeed 63 0000000000000000 fd8fc3f2f5223ee6
+microWithSeed 63 0000000000000001 0318cd1daf57d224
+microWithSeed 63 00000000deadbeef d2cd6e2634856170
+microWithSeed 63 123456789abcdef0 644ce15944af559a
+microWithSeed 63 ffffffffffffffff a2e3a95ec415bbee
+microWithSeed 64 0000000000000000 44d70d4c8b15579f
+microWithSeed 64 0000000000000001 7c2b184ad7a6be12
+microWithSeed 64 00000000deadbeef 06abbe2cf54b915e
+microWithSeed 64 123456789abcdef0 2e200f15432403d2
+microWithSeed 64 ffffffffffffffff 8393fe721236a9bc
+microWithSeed 65 0000000000000000 f6bbae844d4d4181
+microWithSeed 65 0000000000000001 08a7b7d8e1e46e8a
+microWithSeed 65 00000000deadbeef 8838e9a62419e83e
+microWithSeed 65 123456789abcdef0 567fedbbdf09484e
+microWithSeed 65 ffffffffffffffff 428ac41664fa5e19
+microWithSeed 79 0000000000000000 58026c3618a2a508
+microWithSeed 79 0000000000000001 70311e9471ead990
+microWithSeed 79 00000000deadbeef ebb07db8ea173c54
+microWithSeed 79 123456789abcdef0 f9a2970aed707e73
+microWithSeed 79 ffffffffffffffff 2dd5b590dda181c6
+microWithSeed 80 0000000000000000 df336fbf7f62d83b
+microWithSeed 80 0000000000000001 a62239ae33152fd6
+microWithSeed 80 00000000deadbeef 547ceac21c5de14f
+microWithSeed 80 123456789abcdef0 8463e1bbfaf437d0
+microWithSeed 80 ffffffffffffffff 5978ffc6cd7c56d1
+microWithSeed 81 0000000000000000 082807afd7b12fb2
+microWithSeed 81 0000000000000001 354c9fd7534c3c8a
+microWithSeed 81 00000000deadbeef 8858c66d7a436cb9
+microWithSeed 81 123456789abcdef0 59071631a5f09137
+microWithSeed 81 ffffffffffffffff 77875953d208e4e1
+microWithSeed 111 0000000000000000 c647d4353ec1d7e6
+microWithSeed 111 0000000000000001 7c4c2c2d3fa83a76
+microWithSeed 111 00000000deadbeef 222bdd3c21f0e941
+microWithSeed 111 123456789abcdef0 e00c08156b240957
+microWithSeed 111 ffffffffffffffff 4e067c8c54320471
+microWithSeed 112 0000000000000000 612fb9039abc2b24
+microWithSeed 112 0000000000000001 0f246a8e569dc4d3
+microWithSeed 112 00000000deadbeef 44524c221f57506a
+microWithSeed 112 123456789abcdef0 a393253de76c168f
+microWithSeed 112 ffffffffffffffff fc50425a51dd18fe
+microWithSeed 113 0000000000000000 0310109732a00c86
+microWithSeed 113 0000000000000001 4da9861e252ae801
+microWithSeed 113 00000000deadbeef 2ed0e5bdc6619928
+microWithSeed 113 123456789abcdef0 7820b994d1b9b805
+microWithSeed 113 ffffffffffffffff 9b2a119afe1aeb01
+microWithSeed 127 0000000000000000 da335cdf507c6503
+microWithSeed 127 0000000000000001 1f0ed9c24e32c48e
+microWithSeed 127 00000000deadbeef 4584d77137d6b3df
+microWithSeed 127 123456789abcdef0 2fa8e0c79df28ce5
+microWithSeed 127 ffffffffffffffff 0d267edbd29b41db
+microWithSeed 128 0000000000000000 55f26763c2d4f434
+microWithSeed 128 0000000000000001 a3f412e9368d52db
+microWithSeed 128 00000000deadbeef 9e04a11a1bbd7ff6
+microWithSeed 128 123456789abcdef0 055220527020b661
+microWithSeed 128 ffffffffffffffff 1c5e76b4a502d6fa
+microWithSeed 129 0000000000000000 4dd46b82a5c01d10
+microWithSeed 129 0000000000000001 c824191550708db0
+microWithSeed 129 00000000deadbeef 16ea5a4a90fdfad1
+microWithSeed 129 123456789abcdef0 4ceeab827796a2cf
+microWithSeed 129 ffffffffffffffff 8785f66fec4f62a2
+microWithSeed 191 0000000000000000 0c8368fd78d8d79b
+microWithSeed 191 0000000000000001 0cdf2e678b638e97
+microWithSeed 191 00000000deadbeef 6610064176919381
+microWithSeed 191 123456789abcdef0 b1380fa9a0f99500
+microWithSeed 191 ffffffffffffffff 6afa2ebbfaa80cc1
+microWithSeed 192 0000000000000000 4d48c4b4acf26329
+microWithSeed 192 0000000000000001 185dc2129ddd89a6
+microWithSeed 192 00000000deadbeef f9335a1b2a6a20cb
+microWithSeed 192 123456789abcdef0 dde407b46f3db6b7
+microWithSeed 192 ffffffffffffffff 845b19b178bdb8d0
+microWithSeed 193 0000000000000000 85b09015f8cdb7b4
+microWithSeed 193 0000000000000001 ef3b4c33aa95beb1
+microWithSeed 193 00000000deadbeef 278228e61b3c8d2e
+microWithSeed 193 123456789abcdef0 7da960cf7a2b989b
+microWithSeed 193 ffffffffffffffff a92eab4230764aa2
+microWithSeed 223 0000000000000000 1bae47622466c8ea
+microWithSeed 223 0000000000000001 f5057cf8956a44fc
+microWithSeed 223 00000000deadbeef 233a780bb2f956c4
+microWithSeed 223 123456789abcdef0 298ea5e810cc9fd5
+microWithSeed 223 ffffffffffffffff 4d97a7496172296e
+microWithSeed 224 0000000000000000 8bd5ea592b313576
+microWithSeed 224 0000000000000001 48f1f3b59057c1af
+microWithSeed 224 00000000deadbeef dcead34099eccf47
+microWithSeed 224 123456789abcdef0 e00fe9d70bd404dd
+microWithSeed 224 ffffffffffffffff b7c1608f4a2d3821
+microWithSeed 225 0000000000000000 175100fa9e5867cc
+microWithSeed 225 0000000000000001 a82831e5f4df54da
+microWithSeed 225 00000000deadbeef 542319cd90a4444a
+microWithSeed 225 123456789abcdef0 0c7ba34e8a1a20a5
+microWithSeed 225 ffffffffffffffff c409bf1b8296e06b
+microWithSeed 255 0000000000000000 03a1de4052fad3fc
+microWithSeed 255 0000000000000001 92e79ded6e629341
+microWithSeed 255 00000000deadbeef e4890f66b4e01b72
+microWithSeed 255 123456789abcdef0 db4af919d8ff5c2b
+microWithSeed 255 ffffffffffffffff 1297ae1a1dbcf3b9
+microWithSeed 256 0000000000000000 e17dc92420e21643
+microWithSeed 256 0000000000000001 ab7f2e74969c2fea
+microWithSeed 256 00000000deadbeef fbca3edc7fc6d268
+microWithSeed 256 123456789abcdef0 d411f79b64bc9376
+microWithSeed 256 ffffffffffffffff 2207c0617ee89d84
+microWithSeed 257 0000000000000000 13b2f99222a3143d
+microWithSeed 257 0000000000000001 2a8e6290bae4b399
+microWithSeed 257 00000000deadbeef 466b591f465c5e5e
+microWithSeed 257 123456789abcdef0 533934608ecabf8e
+microWithSeed 257 ffffffffffffffff 5f969aac99056257
+microWithSeed 447 0000000000000000 31168fbd47b630c2
+microWithSeed 447 0000000000000001 7781a1eea0ee0f75
+microWithSeed 447 00000000deadbeef ea89d984f315370c
+microWithSeed 447 123456789abcdef0 a432aaf11870d617
+microWithSeed 447 ffffffffffffffff 717e22c920e018bf
+microWithSeed 448 0000000000000000 bce8c898ef125347
+microWithSeed 448 0000000000000001 01265d1a300b5531
+microWithSeed 448 00000000deadbeef b6f4f97c1890e305
+microWithSeed 448 123456789abcdef0 1b565c7b9e43a64d
+microWithSeed 448 ffffffffffffffff 3a81438dc0d37e9c
+microWithSeed 449 0000000000000000 fefc51f9c37a8840
+microWithSeed 449 0000000000000001 a5753c3964ffeac9
+microWithSeed 449 00000000deadbeef 857713cb2e4bdb59
+microWithSeed 449 123456789abcdef0 5a8a4518d18a443b
+microWithSeed 449 ffffffffffffffff ae67d0fcc7fa9230
+microWithSeed 511 0000000000000000 1e1480ba4aa269d6
+microWithSeed 511 0000000000000001 6364b390ea4ceef7
+microWithSeed 511 00000000deadbeef c0f3524a5f614dec
+microWithSeed 511 123456789abcdef0 eb6d693b8b4157b0
+microWithSeed 511 ffffffffffffffff a141bcfd26a61242
+microWithSeed 512 0000000000000000 015ac81805fd6c96
+microWithSeed 512 0000000000000001 d1dbeaca2ae2cf3b
+microWithSeed 512 00000000deadbeef 65f913dabf1c0799
+microWithSeed 512 123456789abcdef0 35c97e2519f499d2
+microWithSeed 512 ffffffffffffffff 50416c80dd62a6df
+microWithSeed 1023 0000000000000000 4ffdb20b18464bec
+microWithSeed 1023 0000000000000001 9515a02652597893
+microWithSeed 1023 00000000deadbeef 26680c9f357f77f0
+microWithSeed 1023 123456789abcdef0 e4f860e0aa2f34ca
+microWithSeed 1023 ffffffffffffffff 5550c24acff28af8
+microWithSeed 1024 0000000000000000 20030530f6314046
+microWithSeed 1024 0000000000000001 4b44b0f7d70e6c99
+microWithSeed 1024 00000000deadbeef 2375c4a0bb64b263
+microWithSeed 1024 123456789abcdef0 e996fce3abe50dde
+microWithSeed 1024 ffffffffffffffff 3118132114e9be18
+microWithSeed 4096 0000000000000000 8c34b5dcd4aa3e13
+microWithSeed 4096 0000000000000001 742724861cd01b73
+microWithSeed 4096 00000000deadbeef c3998e7b15384797
+microWithSeed 4096 123456789abcdef0 24747da00cf7dfe8
+microWithSeed 4096 ffffffffffffffff 673b3377e214632f
+microWithSeed 65535 0000000000000000 9d82472e94cd1a74
+microWithSeed 65535 0000000000000001 94c43af7820805b5
+microWithSeed 65535 00000000deadbeef b69360397c74f3a2
+microWithSeed 65535 123456789abcdef0 6172fc82e3318070
+microWithSeed 65535 ffffffffffffffff 43b6259dd190ae45
+microWithSeed 65536 0000000000000000 94258402d3266410
+microWithSeed 65536 0000000000000001 60ac141ec805c71d
+microWithSeed 65536 00000000deadbeef d35954764df3d7bb
+microWithSeed 65536 123456789abcdef0 38be0ac62addfa3f
+microWithSeed 65536 ffffffffffffffff 9338701d80fd3b5f
+microWithSeed 300007 0000000000000000 f6a75558d6bc767e
+microWithSeed 300007 0000000000000001 d843f116cd402cf8
+microWithSeed 300007 00000000deadbeef a9ab2293b1029809
+microWithSeed 300007 123456789abcdef0 8f06292f653a488e
+microWithSeed 300007 ffffffffffffffff da16c13a44b13331
+microOffset 1 0 0000000000000000 0338dc4be2cecdae
+microOffset 1 0 00000000deadbeef 842e1a82b8ea7243
+microOffset 1 7 0000000000000000 f7854b11f9682cd0
+microOffset 1 7 00000000deadbeef ecdfba4a43fe7737
+microOffset 1 16 0000000000000000 17aeb00945b41c70
+microOffset 1 16 00000000deadbeef 0d2fbc3c4cbaa6e9
+microOffset 1 63 0000000000000000 1599640c41715038
+microOffset 1 63 00000000deadbeef ef83c73a68443ad6
+microOffset 1 64 0000000000000000 55023c50907b1303
+microOffset 1 64 00000000deadbeef 39f2097c2146e40d
+microOffset 1 257 0000000000000000 9ee1b579ae9f8773
+microOffset 1 257 00000000deadbeef 7c387b32393994f1
+microOffset 3 0 0000000000000000 0338dc4be2cecdae
+microOffset 3 0 00000000deadbeef 842e1a82b8ea7243
+microOffset 3 7 0000000000000000 da92d24f8013069c
+microOffset 3 7 00000000deadbeef 1bd08cb2b539f027
+microOffset 3 16 0000000000000000 ad13b6d5232be413
+microOffset 3 16 00000000deadbeef c20ae581e6351fee
+microOffset 3 63 0000000000000000 a39e7ab833156c09
+microOffset 3 63 00000000deadbeef 3073dc0f20034461
+microOffset 3 64 0000000000000000 c807fd33c06b1a8c
+microOffset 3 64 00000000deadbeef ec371bd0069403cf
+microOffset 3 257 0000000000000000 9fa2b82cca3e9468
+microOffset 3 257 00000000deadbeef 4f87a47665d67b44
+microOffset 8 0 0000000000000000 0338dc4be2cecdae
+microOffset 8 0 00000000deadbeef 842e1a82b8ea7243
+microOffset 8 7 0000000000000000 2129ff6a4225f316
+microOffset 8 7 00000000deadbeef 38f3d3ad12f181ce
+microOffset 8 16 0000000000000000 25ec3172c4972990
+microOffset 8 16 00000000deadbeef 706eb2d1bb3e0469
+microOffset 8 63 0000000000000000 705ee8c91cc34e14
+microOffset 8 63 00000000deadbeef 7b109ede278365db
+microOffset 8 64 0000000000000000 4b9b56e6ba4f60c9
+microOffset 8 64 00000000deadbeef 149c32c6cc8d70d1
+microOffset 8 257 0000000000000000 3f7fb08ee5c752c0
+microOffset 8 257 00000000deadbeef dd2c9ef2bdc28e4e
+microOffset 17 0 0000000000000000 0338dc4be2cecdae
+microOffset 17 0 00000000deadbeef 842e1a82b8ea7243
+microOffset 17 7 0000000000000000 5023d7ddd4325e35
+microOffset 17 7 00000000deadbeef 704bf26ff2d3c989
+microOffset 17 16 0000000000000000 e193e06a17813552
+microOffset 17 16 00000000deadbeef 54d2b9ee93de7b87
+microOffset 17 63 0000000000000000 4d37066d271a344d
+microOffset 17 63 00000000deadbeef 25baa3dcd571ef7c
+microOffset 17 64 0000000000000000 583de726b937be09
+microOffset 17 64 00000000deadbeef 15c05b7fa243027f
+microOffset 17 257 0000000000000000 0d90c36e754d26b3
+microOffset 17 257 00000000deadbeef 57d54fe4913213dc