diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -11,8 +11,8 @@
 Get Rattletrap by downloading and unpacking [the latest release][] for your
 platform.
 
-To build Rattletrap from source, install [Stack][]. Then download this
-repository and run `stack --install-ghc install`.
+To build Rattletrap from source, install [Stack][]. Then run
+`stack --resolver nightly install rattletrap`.
 
 ## Replays
 
@@ -65,7 +65,7 @@
 
 [Rattletrap]: https://github.com/tfausak/rattletrap
 [Version badge]: https://www.stackage.org/package/rattletrap/badge/nightly?label=version
-[version]: https://www.stackage.org/nightly/package/rattletrap
+[version]: https://www.stackage.org/package/rattletrap
 [Windows build badge]: https://ci.appveyor.com/api/projects/status/github/tfausak/rattletrap?branch=master&svg=true
 [windows build]: https://ci.appveyor.com/project/TaylorFausak/rattletrap
 [Build badge]: https://travis-ci.org/tfausak/rattletrap.svg?branch=master
diff --git a/executable/Main.hs b/executable/Main.hs
--- a/executable/Main.hs
+++ b/executable/Main.hs
@@ -53,72 +53,77 @@
     [i, o] -> pure (ByteString.readFile i, ByteString.writeFile o)
     _ -> fail ("unexpected arguments " ++ show files)
 
-$(Monad.foldM
-    (\declarations name -> do
-       let options =
-             Casing.aesonDrop (length (TH.nameBase name)) Casing.snakeCase
-       newDeclarations <- Aeson.deriveJSON options name
-       pure (newDeclarations ++ declarations))
-    []
-    [ ''Attribute
-    , ''AttributeMapping
-    , ''AttributeValue
-    , ''BooleanAttributeValue
-    , ''ByteAttributeValue
-    , ''Cache
-    , ''CamSettingsAttributeValue
-    , ''ClassMapping
-    , ''ClubColorsAttributeValue
-    , ''CompressedWord
-    , ''CompressedWordVector
-    , ''Content
-    , ''DemolishAttributeValue
-    , ''DestroyedReplicationValue
-    , ''Dictionary
-    , ''EnumAttributeValue
-    , ''ExplosionAttributeValue
-    , ''FlaggedIntAttributeValue
-    , ''Float32
-    , ''FloatAttributeValue
-    , ''Frame
-    , ''GameModeAttributeValue
-    , ''Header
-    , ''Initialization
-    , ''Int32
-    , ''Int8
-    , ''Int8Vector
-    , ''IntAttributeValue
-    , ''KeyFrame
-    , ''List
-    , ''LoadoutAttributeValue
-    , ''LoadoutOnlineAttributeValue
-    , ''LoadoutsAttributeValue
-    , ''LoadoutsOnlineAttributeValue
-    , ''LocationAttributeValue
-    , ''Mark
-    , ''Message
-    , ''MusicStingerAttributeValue
-    , ''PartyLeaderAttributeValue
-    , ''PickupAttributeValue
-    , ''PrivateMatchSettingsAttributeValue
-    , ''Property
-    , ''PropertyValue
-    , ''QWordAttributeValue
-    , ''RemoteId
-    , ''Replay
-    , ''Replication
-    , ''ReplicationValue
-    , ''ReservationAttributeValue
-    , ''RigidBodyStateAttributeValue
-    , ''SpawnedReplicationValue
-    , ''StringAttributeValue
-    , ''TeamPaintAttributeValue
-    , ''Text
-    , ''UniqueIdAttributeValue
-    , ''UpdatedReplicationValue
-    , ''Vector
-    , ''WeldedInfoAttributeValue
-    , ''Word32
-    , ''Word64
-    , ''Word8
-    ])
+$(let optionsFor name =
+        (Casing.aesonDrop (length (TH.nameBase name)) Casing.snakeCase)
+        { Aeson.constructorTagModifier = Casing.snakeCase
+        , Aeson.omitNothingFields = True
+        , Aeson.sumEncoding = Aeson.ObjectWithSingleField
+        , Aeson.unwrapUnaryRecords = True
+        }
+      deriveJSON declarations name = do
+        newDeclarations <- Aeson.deriveJSON (optionsFor name) name
+        pure (newDeclarations ++ declarations)
+      names =
+        [ ''Attribute
+        , ''AttributeMapping
+        , ''AttributeValue
+        , ''BooleanAttributeValue
+        , ''ByteAttributeValue
+        , ''Cache
+        , ''CamSettingsAttributeValue
+        , ''ClassMapping
+        , ''ClubColorsAttributeValue
+        , ''CompressedWord
+        , ''CompressedWordVector
+        , ''Content
+        , ''DemolishAttributeValue
+        , ''DestroyedReplicationValue
+        , ''Dictionary
+        , ''EnumAttributeValue
+        , ''ExplosionAttributeValue
+        , ''FlaggedIntAttributeValue
+        , ''Float32
+        , ''FloatAttributeValue
+        , ''Frame
+        , ''GameModeAttributeValue
+        , ''Header
+        , ''Initialization
+        , ''Int32
+        , ''Int8
+        , ''Int8Vector
+        , ''IntAttributeValue
+        , ''KeyFrame
+        , ''List
+        , ''LoadoutAttributeValue
+        , ''LoadoutOnlineAttributeValue
+        , ''LoadoutsAttributeValue
+        , ''LoadoutsOnlineAttributeValue
+        , ''LocationAttributeValue
+        , ''Mark
+        , ''Message
+        , ''MusicStingerAttributeValue
+        , ''PartyLeaderAttributeValue
+        , ''PickupAttributeValue
+        , ''PrivateMatchSettingsAttributeValue
+        , ''Property
+        , ''PropertyValue
+        , ''QWordAttributeValue
+        , ''RemoteId
+        , ''Replay
+        , ''Replication
+        , ''ReplicationValue
+        , ''ReservationAttributeValue
+        , ''RigidBodyStateAttributeValue
+        , ''SpawnedReplicationValue
+        , ''StringAttributeValue
+        , ''TeamPaintAttributeValue
+        , ''Text
+        , ''UniqueIdAttributeValue
+        , ''UpdatedReplicationValue
+        , ''Vector
+        , ''WeldedInfoAttributeValue
+        , ''Word32
+        , ''Word64
+        , ''Word8
+        ]
+  in Monad.foldM deriveJSON [] names)
diff --git a/library/Rattletrap.hs b/library/Rattletrap.hs
--- a/library/Rattletrap.hs
+++ b/library/Rattletrap.hs
@@ -1,42 +1,79 @@
 module Rattletrap
-  ( module Export
+  ( module Rattletrap.ActorMap
+  , module Rattletrap.Attribute
+  , module Rattletrap.AttributeMapping
+  , module Rattletrap.AttributeValue
+  , module Rattletrap.AttributeValueType
+  , module Rattletrap.Cache
+  , module Rattletrap.ClassAttributeMap
+  , module Rattletrap.ClassMapping
+  , module Rattletrap.CompressedWord
+  , module Rattletrap.CompressedWordVector
+  , module Rattletrap.Content
+  , module Rattletrap.Crc
+  , module Rattletrap.Data
+  , module Rattletrap.Dictionary
+  , module Rattletrap.Float32
+  , module Rattletrap.Frame
+  , module Rattletrap.Header
+  , module Rattletrap.Initialization
+  , module Rattletrap.Int32
+  , module Rattletrap.Int8
+  , module Rattletrap.Int8Vector
+  , module Rattletrap.KeyFrame
+  , module Rattletrap.List
+  , module Rattletrap.Mark
+  , module Rattletrap.Message
+  , module Rattletrap.Property
+  , module Rattletrap.PropertyValue
+  , module Rattletrap.RemoteId
+  , module Rattletrap.Replay
+  , module Rattletrap.Replication
+  , module Rattletrap.ReplicationValue
+  , module Rattletrap.Text
+  , module Rattletrap.Utility
+  , module Rattletrap.Vector
+  , module Rattletrap.Version
+  , module Rattletrap.Word32
+  , module Rattletrap.Word64
+  , module Rattletrap.Word8
   ) where
 
-import Rattletrap.ActorMap as Export
-import Rattletrap.Attribute as Export
-import Rattletrap.AttributeMapping as Export
-import Rattletrap.AttributeValue as Export
-import Rattletrap.AttributeValueType as Export
-import Rattletrap.Cache as Export
-import Rattletrap.ClassAttributeMap as Export
-import Rattletrap.ClassMapping as Export
-import Rattletrap.CompressedWord as Export
-import Rattletrap.CompressedWordVector as Export
-import Rattletrap.Content as Export
-import Rattletrap.Crc as Export
-import Rattletrap.Data as Export
-import Rattletrap.Dictionary as Export
-import Rattletrap.Float32 as Export
-import Rattletrap.Frame as Export
-import Rattletrap.Header as Export
-import Rattletrap.Initialization as Export
-import Rattletrap.Int32 as Export
-import Rattletrap.Int8 as Export
-import Rattletrap.Int8Vector as Export
-import Rattletrap.KeyFrame as Export
-import Rattletrap.List as Export
-import Rattletrap.Mark as Export
-import Rattletrap.Message as Export
-import Rattletrap.Property as Export
-import Rattletrap.PropertyValue as Export
-import Rattletrap.RemoteId as Export
-import Rattletrap.Replay as Export
-import Rattletrap.Replication as Export
-import Rattletrap.ReplicationValue as Export
-import Rattletrap.Text as Export
-import Rattletrap.Utility as Export
-import Rattletrap.Vector as Export
-import Rattletrap.Version as Export
-import Rattletrap.Word32 as Export
-import Rattletrap.Word64 as Export
-import Rattletrap.Word8 as Export
+import Rattletrap.ActorMap
+import Rattletrap.Attribute
+import Rattletrap.AttributeMapping
+import Rattletrap.AttributeValue
+import Rattletrap.AttributeValueType
+import Rattletrap.Cache
+import Rattletrap.ClassAttributeMap
+import Rattletrap.ClassMapping
+import Rattletrap.CompressedWord
+import Rattletrap.CompressedWordVector
+import Rattletrap.Content
+import Rattletrap.Crc
+import Rattletrap.Data
+import Rattletrap.Dictionary
+import Rattletrap.Float32
+import Rattletrap.Frame
+import Rattletrap.Header
+import Rattletrap.Initialization
+import Rattletrap.Int32
+import Rattletrap.Int8
+import Rattletrap.Int8Vector
+import Rattletrap.KeyFrame
+import Rattletrap.List
+import Rattletrap.Mark
+import Rattletrap.Message
+import Rattletrap.Property
+import Rattletrap.PropertyValue
+import Rattletrap.RemoteId
+import Rattletrap.Replay
+import Rattletrap.Replication
+import Rattletrap.ReplicationValue
+import Rattletrap.Text
+import Rattletrap.Utility
+import Rattletrap.Vector
+import Rattletrap.Version
+import Rattletrap.Word32
+import Rattletrap.Word64
+import Rattletrap.Word8
diff --git a/library/Rattletrap/AttributeValue.hs b/library/Rattletrap/AttributeValue.hs
--- a/library/Rattletrap/AttributeValue.hs
+++ b/library/Rattletrap/AttributeValue.hs
@@ -1,36 +1,61 @@
 module Rattletrap.AttributeValue
   ( module Rattletrap.AttributeValue
-  , module Export
+  , module Rattletrap.AttributeValue.Boolean
+  , module Rattletrap.AttributeValue.Byte
+  , module Rattletrap.AttributeValue.CamSettings
+  , module Rattletrap.AttributeValue.ClubColors
+  , module Rattletrap.AttributeValue.Demolish
+  , module Rattletrap.AttributeValue.Enum
+  , module Rattletrap.AttributeValue.Explosion
+  , module Rattletrap.AttributeValue.FlaggedInt
+  , module Rattletrap.AttributeValue.Float
+  , module Rattletrap.AttributeValue.GameMode
+  , module Rattletrap.AttributeValue.Int
+  , module Rattletrap.AttributeValue.Loadout
+  , module Rattletrap.AttributeValue.LoadoutOnline
+  , module Rattletrap.AttributeValue.Loadouts
+  , module Rattletrap.AttributeValue.LoadoutsOnline
+  , module Rattletrap.AttributeValue.Location
+  , module Rattletrap.AttributeValue.MusicStinger
+  , module Rattletrap.AttributeValue.PartyLeader
+  , module Rattletrap.AttributeValue.Pickup
+  , module Rattletrap.AttributeValue.PrivateMatchSettings
+  , module Rattletrap.AttributeValue.QWord
+  , module Rattletrap.AttributeValue.Reservation
+  , module Rattletrap.AttributeValue.RigidBodyState
+  , module Rattletrap.AttributeValue.String
+  , module Rattletrap.AttributeValue.TeamPaint
+  , module Rattletrap.AttributeValue.UniqueId
+  , module Rattletrap.AttributeValue.WeldedInfo
   ) where
 
-import Rattletrap.AttributeValue.Boolean as Export
-import Rattletrap.AttributeValue.Byte as Export
-import Rattletrap.AttributeValue.CamSettings as Export
-import Rattletrap.AttributeValue.ClubColors as Export
-import Rattletrap.AttributeValue.Demolish as Export
-import Rattletrap.AttributeValue.Enum as Export
-import Rattletrap.AttributeValue.Explosion as Export
-import Rattletrap.AttributeValue.FlaggedInt as Export
-import Rattletrap.AttributeValue.Float as Export
-import Rattletrap.AttributeValue.GameMode as Export
-import Rattletrap.AttributeValue.Int as Export
-import Rattletrap.AttributeValue.Loadout as Export
-import Rattletrap.AttributeValue.LoadoutOnline as Export
-import Rattletrap.AttributeValue.Loadouts as Export
-import Rattletrap.AttributeValue.LoadoutsOnline as Export
-import Rattletrap.AttributeValue.Location as Export
-import Rattletrap.AttributeValue.MusicStinger as Export
-import Rattletrap.AttributeValue.PartyLeader as Export
-import Rattletrap.AttributeValue.Pickup as Export
-import Rattletrap.AttributeValue.PrivateMatchSettings as Export
-import Rattletrap.AttributeValue.QWord as Export
-import Rattletrap.AttributeValue.Reservation as Export
-import Rattletrap.AttributeValue.RigidBodyState as Export
-import Rattletrap.AttributeValue.String as Export
-import Rattletrap.AttributeValue.TeamPaint as Export
-import Rattletrap.AttributeValue.UniqueId as Export
-import Rattletrap.AttributeValue.WeldedInfo as Export
-
+import Rattletrap.AttributeValue.Boolean
+import Rattletrap.AttributeValue.Byte
+import Rattletrap.AttributeValue.CamSettings
+import Rattletrap.AttributeValue.ClubColors
+import Rattletrap.AttributeValue.Demolish
+import Rattletrap.AttributeValue.Enum
+import Rattletrap.AttributeValue.Explosion
+import Rattletrap.AttributeValue.FlaggedInt
+import Rattletrap.AttributeValue.Float
+import Rattletrap.AttributeValue.GameMode
+import Rattletrap.AttributeValue.Int
+import Rattletrap.AttributeValue.Loadout
+import Rattletrap.AttributeValue.LoadoutOnline
+import Rattletrap.AttributeValue.Loadouts
+import Rattletrap.AttributeValue.LoadoutsOnline
+import Rattletrap.AttributeValue.Location
+import Rattletrap.AttributeValue.MusicStinger
+import Rattletrap.AttributeValue.PartyLeader
+import Rattletrap.AttributeValue.Pickup
+import Rattletrap.AttributeValue.PrivateMatchSettings
+import Rattletrap.AttributeValue.QWord
+import Rattletrap.AttributeValue.Reservation
+import Rattletrap.AttributeValue.RigidBodyState
+import Rattletrap.AttributeValue.String
+import Rattletrap.AttributeValue.TeamPaint
+import Rattletrap.AttributeValue.UniqueId
+import Rattletrap.AttributeValue.WeldedInfo
 import Rattletrap.AttributeValueType
 import Rattletrap.Data
 import Rattletrap.Text
diff --git a/library/Rattletrap/ClassAttributeMap.hs b/library/Rattletrap/ClassAttributeMap.hs
--- a/library/Rattletrap/ClassAttributeMap.hs
+++ b/library/Rattletrap/ClassAttributeMap.hs
@@ -6,9 +6,9 @@
 import Rattletrap.ClassMapping
 import Rattletrap.CompressedWord
 import Rattletrap.Data
+import Rattletrap.Int32
 import Rattletrap.List
 import Rattletrap.Text
-import Rattletrap.Utility
 import Rattletrap.Word32
 
 import qualified Data.Bimap as Bimap
@@ -16,17 +16,15 @@
 import qualified Data.Map as Map
 import qualified Data.Maybe as Maybe
 import qualified Data.Set as Set
+import qualified Data.Text as Text
 
 data ClassAttributeMap = ClassAttributeMap
-  { classAttributeMapObjectMap :: Bimap.Bimap Word32 Text
+  { classAttributeMapObjectMap :: Map.Map Word32 Text
   , classAttributeMapClassMap :: Bimap.Bimap Word32 Text
-  , classAttributeMapValue :: Map.Map Word32 (Bimap.Bimap Word32 Word32)
+  , classAttributeMapValue :: Map.Map Word32 (Map.Map Word32 Word32)
   } deriving (Eq, Show)
 
-makeClassAttributeMap :: List Text
-                      -> List ClassMapping
-                      -> List Cache
-                      -> ClassAttributeMap
+makeClassAttributeMap :: List Text -> List ClassMapping -> List Cache -> ClassAttributeMap
 makeClassAttributeMap objects classMappings caches =
   let objectMap = makeObjectMap objects
       classCache = makeClassCache classMappings caches
@@ -37,22 +35,22 @@
         Map.fromList
           (map
              (\classId ->
-                let ownAttributes =
-                      Maybe.fromMaybe
-                        Bimap.empty
-                        (Map.lookup classId attributeMap)
-                    parentsAttributes =
-                      case Map.lookup classId parentMap of
-                        Nothing -> []
-                        Just parentClassIds ->
-                          map
-                            (\parentClassId ->
-                               Maybe.fromMaybe
-                                 Bimap.empty
-                                 (Map.lookup parentClassId attributeMap))
-                            parentClassIds
-                    attributes = ownAttributes : parentsAttributes
-                in (classId, Bimap.fromList (concatMap Bimap.toList attributes)))
+                 let ownAttributes =
+                       Maybe.fromMaybe
+                         Map.empty
+                         (Map.lookup classId attributeMap)
+                     parentsAttributes =
+                       case Map.lookup classId parentMap of
+                         Nothing -> []
+                         Just parentClassIds ->
+                           map
+                             (\parentClassId ->
+                                 Maybe.fromMaybe
+                                   Map.empty
+                                   (Map.lookup parentClassId attributeMap))
+                             parentClassIds
+                     attributes = ownAttributes : parentsAttributes
+                 in (classId, Map.fromList (concatMap Map.toList attributes)))
              classIds)
   in ClassAttributeMap
      { classAttributeMapObjectMap = objectMap
@@ -67,11 +65,11 @@
   let classMap = makeClassMap classMappings
   in map
        (\cache ->
-          let classId = cacheClassId cache
-          in ( Bimap.lookup classId classMap
-             , classId
-             , cacheCacheId cache
-             , cacheParentCacheId cache))
+           let classId = cacheClassId cache
+           in ( Bimap.lookup classId classMap
+              , classId
+              , cacheCacheId cache
+              , cacheParentCacheId cache))
        (listValue caches)
 
 makeClassMap :: List ClassMapping -> Bimap.Bimap Word32 Text
@@ -79,21 +77,21 @@
   Bimap.fromList
     (map
        (\classMapping ->
-          (classMappingStreamId classMapping, classMappingName classMapping))
+           (classMappingStreamId classMapping, classMappingName classMapping))
        (listValue classMappings))
 
-makeAttributeMap :: List Cache -> Map.Map Word32 (Bimap.Bimap Word32 Word32)
+makeAttributeMap :: List Cache -> Map.Map Word32 (Map.Map Word32 Word32)
 makeAttributeMap caches =
   Map.fromList
     (map
        (\cache ->
-          ( cacheClassId cache
-          , Bimap.fromList
-              (map
-                 (\attributeMapping ->
-                    ( attributeMappingStreamId attributeMapping
-                    , attributeMappingObjectId attributeMapping))
-                 (listValue (cacheAttributeMappings cache)))))
+           ( cacheClassId cache
+           , Map.fromList
+               (map
+                  (\attributeMapping ->
+                      ( attributeMappingStreamId attributeMapping
+                      , attributeMappingObjectId attributeMapping))
+                  (listValue (cacheAttributeMappings cache)))))
        (listValue caches))
 
 makeShallowParentMap :: List ClassMapping -> List Cache -> Map.Map Word32 Word32
@@ -102,27 +100,23 @@
   in Map.fromList
        (Maybe.mapMaybe
           (\xs ->
-             case xs of
-               [] -> Nothing
-               (maybeClassName, classId, _, parentCacheId):rest -> do
-                 parentClassId <-
-                   getParentClass maybeClassName parentCacheId rest
-                 pure (classId, parentClassId))
+              case xs of
+                [] -> Nothing
+                (maybeClassName, classId, _, parentCacheId):rest -> do
+                  parentClassId <- getParentClass maybeClassName parentCacheId rest
+                  pure (classId, parentClassId))
           (List.tails (reverse classCache)))
 
 makeParentMap :: List ClassMapping -> List Cache -> Map.Map Word32 [Word32]
 makeParentMap classMappings caches =
   let shallowParentMap = makeShallowParentMap classMappings caches
-  in Map.mapWithKey
-       (\classId _ -> getParentClasses shallowParentMap classId)
-       shallowParentMap
+  in Map.mapWithKey (\classId _ -> getParentClasses shallowParentMap classId) shallowParentMap
 
 getParentClasses :: Map.Map Word32 Word32 -> Word32 -> [Word32]
 getParentClasses shallowParentMap classId =
   case Map.lookup classId shallowParentMap of
     Nothing -> []
-    Just parentClassId ->
-      parentClassId : getParentClasses shallowParentMap parentClassId
+    Just parentClassId -> parentClassId : getParentClasses shallowParentMap parentClassId
 
 getParentClass :: Maybe Text
                -> Word32
@@ -161,8 +155,7 @@
               (filter
                  (\(_, _, cacheId, _) -> cacheId == parentCacheId)
                  (filter
-                    (\(maybeClassName, _, _, _) ->
-                       maybeClassName == Just parentClassName)
+                    (\(maybeClassName, _, _, _) -> maybeClassName == Just parentClassName)
                     xs))))
 
 parentClasses :: Map.Map Text Text
@@ -171,28 +164,37 @@
     stringToText
     (Map.mapKeys stringToText (Map.fromList rawParentClasses))
 
-makeObjectMap :: List Text -> Bimap.Bimap Word32 Text
+makeObjectMap :: List Text -> Map.Map Word32 Text
 makeObjectMap objects =
-  Bimap.fromList (zip (map Word32 [0 ..]) (listValue objects))
+  Map.fromAscList (zip (map Word32 [0 ..]) (listValue objects))
 
 getObjectName :: ClassAttributeMap -> Word32 -> Maybe Text
 getObjectName classAttributeMap objectId =
-  Bimap.lookup objectId (classAttributeMapObjectMap classAttributeMap)
+  Map.lookup objectId (classAttributeMapObjectMap classAttributeMap)
 
 getClassName :: Text -> Maybe Text
-getClassName rawObjectName =
-  Map.lookup (normalizeObjectName rawObjectName) objectClasses
+getClassName rawObjectName = Map.lookup (normalizeObjectName rawObjectName) objectClasses
 
 normalizeObjectName :: Text -> Text
 normalizeObjectName objectName =
-  stringToText
-    (replace
-       "_[0-9]+$"
-       ""
-       (replace
-          "^[A-Z_a-z0-9]+[.]TheWorld:"
-          "TheWorld:"
-          (textToString objectName)))
+  let name = textValue objectName
+      crowdActor = Text.pack "TheWorld:PersistentLevel.CrowdActor_TA"
+      crowdManager = Text.pack "TheWorld:PersistentLevel.CrowdManager_TA"
+      boostPickup = Text.pack "TheWorld:PersistentLevel.VehiclePickup_Boost_TA"
+      mapScoreboard = Text.pack "TheWorld:PersistentLevel.InMapScoreboard_TA"
+      toText text =
+        Text
+          (Int32 (fromIntegral (Text.length text + 1)))
+          (Text.snoc text '\x00')
+  in if Text.isInfixOf crowdActor name
+       then toText crowdActor
+       else if Text.isInfixOf crowdManager name
+              then toText crowdManager
+              else if Text.isInfixOf boostPickup name
+                     then toText boostPickup
+                     else if Text.isInfixOf mapScoreboard name
+                            then toText mapScoreboard
+                            else objectName
 
 objectClasses :: Map.Map Text Text
 objectClasses =
@@ -218,7 +220,7 @@
                     -> Maybe Word
 getAttributeIdLimit classAttributeMap actorMap actorId = do
   attributeMap <- getAttributeMap classAttributeMap actorMap actorId
-  let streamIds = Bimap.keys attributeMap
+  let streamIds = Map.keys attributeMap
   let maxStreamId = maximum (Word32 0 : streamIds)
   let limit = fromIntegral (word32Value maxStreamId)
   pure limit
@@ -231,15 +233,14 @@
 getAttributeName classAttributeMap actorMap actorId streamId = do
   attributeMap <- getAttributeMap classAttributeMap actorMap actorId
   let key = Word32 (fromIntegral (compressedWordValue streamId))
-  attributeId <- Bimap.lookup key attributeMap
+  attributeId <- Map.lookup key attributeMap
   let objectMap = classAttributeMapObjectMap classAttributeMap
-  Bimap.lookup attributeId objectMap
+  Map.lookup attributeId objectMap
 
-getAttributeMap
-  :: ClassAttributeMap
-  -> ActorMap
-  -> CompressedWord
-  -> Maybe (Bimap.Bimap Word32 Word32)
+getAttributeMap :: ClassAttributeMap
+                -> ActorMap
+                -> CompressedWord
+                -> Maybe (Map.Map Word32 Word32)
 getAttributeMap classAttributeMap actorMap actorId = do
   objectId <- Map.lookup actorId actorMap
   objectName <- getObjectName classAttributeMap objectId
diff --git a/library/Rattletrap/ReplicationValue.hs b/library/Rattletrap/ReplicationValue.hs
--- a/library/Rattletrap/ReplicationValue.hs
+++ b/library/Rattletrap/ReplicationValue.hs
@@ -1,15 +1,16 @@
 module Rattletrap.ReplicationValue
   ( module Rattletrap.ReplicationValue
-  , module Export
+  , module Rattletrap.ReplicationValue.Destroyed
+  , module Rattletrap.ReplicationValue.Spawned
+  , module Rattletrap.ReplicationValue.Updated
   ) where
 
-import Rattletrap.ReplicationValue.Destroyed as Export
-import Rattletrap.ReplicationValue.Spawned as Export
-import Rattletrap.ReplicationValue.Updated as Export
-
 import Rattletrap.ActorMap
 import Rattletrap.ClassAttributeMap
 import Rattletrap.CompressedWord
+import Rattletrap.ReplicationValue.Destroyed
+import Rattletrap.ReplicationValue.Spawned
+import Rattletrap.ReplicationValue.Updated
 
 import qualified Data.Binary.Bits.Get as BinaryBit
 import qualified Data.Binary.Bits.Put as BinaryBit
@@ -37,12 +38,7 @@
             getSpawnedReplicationValue classAttributeMap actorMap actorId
           pure (SpawnedReplication x, newActorMap)
         else do
-          x <-
-            getUpdatedReplicationValue
-              version
-              classAttributeMap
-              actorMap
-              actorId
+          x <- getUpdatedReplicationValue version classAttributeMap actorMap actorId
           pure (UpdatedReplication x, actorMap)
     else do
       x <- getDestroyedReplicationValue
diff --git a/library/Rattletrap/Utility.hs b/library/Rattletrap/Utility.hs
--- a/library/Rattletrap/Utility.hs
+++ b/library/Rattletrap/Utility.hs
@@ -4,7 +4,6 @@
 import qualified Data.Bits as Bits
 import qualified Data.ByteString.Lazy as ByteString
 import qualified Data.Word as Word
-import qualified Text.Regex as Regex
 
 getRemainingBits :: BinaryBit.BitGet [Bool]
 getRemainingBits = do
@@ -24,10 +23,6 @@
     [ bytes
     , ByteString.replicate (fromIntegral size - ByteString.length bytes) 0x00
     ]
-
-replace :: String -> String -> String -> String
-replace needle replacement haystack =
-  Regex.subRegex (Regex.mkRegex needle) haystack replacement
 
 reverseByte :: Word.Word8 -> Word.Word8
 reverseByte byte =
diff --git a/rattletrap.cabal b/rattletrap.cabal
--- a/rattletrap.cabal
+++ b/rattletrap.cabal
@@ -3,7 +3,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           rattletrap
-version:        0.1.7
+version:        0.2.0
 synopsis:       Parse and generate Rocket League replays.
 description:    Rattletrap parses and generates Rocket League replays.
 category:       Game
@@ -85,7 +85,6 @@
     , bytestring >=0.10 && <0.11
     , containers >=0.5 && <0.6
     , data-binary-ieee754 >=0.4 && <0.5
-    , regex-compat >=0.95 && <0.96
     , text >=1.2 && <1.3
     , vector >=0.11 && <0.12
   exposed-modules: