         guard let tree = CoderTreeValue(bytes: bytes) else { throw CerealError.RootItemNotFound }
         self.init(tree: tree)
     }
-
-    private static func unpackItems(items: [CoderTreeValue]) -> [String: CoderTreeValue] {
-        var result = Dictionary<String, CoderTreeValue>(minimumCapacity: items.count)
-        for item in items {
-            if case let .PairValue(keyValue, value) = item, case let .StringValue(key) = keyValue {
-                result[key] = value
-            }
-        }
-        return result
-    }
     
     private init(tree: CoderTreeValue) {
         switch tree {
         case let .SubTree(array):
-            items = CerealDecoder.unpackItems(array)
+            items = array
+            let count = array.count - 1
+            reverseRange = count.stride(through: 0, by: -1)
         case let .IdentifyingTree(_, array):
-            items = CerealDecoder.unpackItems(array)
+            items = array
+            let count = array.count - 1
+            reverseRange = count.stride(through: 0, by: -1)
         default:
-            items = [:]
+            items = []
+            reverseRange = 0.stride(through: 0, by: -1)
             break
         }
-    }
-    private init(items: [CoderTreeValue]) {
-        self.items = CerealDecoder.unpackItems(items)
+
+        indexMap = nil
+    }
+    private init(items: [CoderTreeValue], map: [String: Int]) {
+        self.items = items
+        let count = items.count - 1
+        reverseRange = count.stride(through: 0, by: -1)
+        indexMap = map
     }
 
     // MARK: - Decoding

    - returns:      The instantiated object, or nil if no object was at the specified key.
    */
    public func decodeCereal<DecodedKeyType: protocol<CerealRepresentable, Hashable>, DecodedValueType: CerealType>(key: String) throws -> [DecodedKeyType: DecodedValueType]? {
        guard let data = items[key] else {
            return nil
        }


     - returns:      The instantiated object, or nil if no object was at the specified key.
     */
    public func decode<DecodedKeyType: protocol<RawRepresentable, CerealRepresentable, Hashable>, DecodedValueType: CerealRepresentable where DecodedKeyType.RawValue: CerealRepresentable>(key: String) throws -> [DecodedKeyType: [DecodedValueType]]? {
        guard let data = self.itemForKey(key), case let .ArrayValue(items) = data else {
            return nil
        }

