--- dyld/dyld-750.6/dyld3/shared-cache/mrm_shared_cache_builder.cpp
+++ dyld/dyld-733.8/dyld3/shared-cache/mrm_shared_cache_builder.cpp
@@ -23,7 +23,7 @@
  */
 
 #include "mrm_shared_cache_builder.h"
-#include "SharedCacheBuilder.h"
+#include "CacheBuilder.h"
 #include "ClosureFileSystem.h"
 #include "FileUtils.h"
 #include <pthread.h>
@@ -194,7 +194,7 @@
 
 struct BuildInstance {
     std::unique_ptr<DyldSharedCache::CreateOptions> options;
-    std::unique_ptr<SharedCacheBuilder>             builder;
+    std::unique_ptr<CacheBuilder>                   builder;
     std::vector<CacheBuilder::InputFile>            inputFiles;
     std::vector<const char*>                        errors;
     std::vector<const char*>                        warnings;
@@ -214,8 +214,8 @@
     uint64_t                                    size;
 };
 
-struct MRMSharedCacheBuilder {
-    MRMSharedCacheBuilder(const BuildOptions_v1* options);
+struct SharedCacheBuilder {
+    SharedCacheBuilder(const BuildOptions_v1* options);
     const BuildOptions_v1*          options;
     dyld3::closure::FileSystemMRM   fileSystem;
 
@@ -273,11 +273,11 @@
     }
 };
 
-MRMSharedCacheBuilder::MRMSharedCacheBuilder(const BuildOptions_v1* options) : options(options), lock(PTHREAD_MUTEX_INITIALIZER) {
-
-}
-
-void validiateBuildOptions(const BuildOptions_v1* options, MRMSharedCacheBuilder& builder) {
+SharedCacheBuilder::SharedCacheBuilder(const BuildOptions_v1* options) : options(options), lock(PTHREAD_MUTEX_INITIALIZER) {
+
+}
+
+void validiateBuildOptions(const BuildOptions_v1* options, SharedCacheBuilder& builder) {
     if (options->version < kMinBuildVersion) {
         builder.error("Builder version %llu is less than minimum supported version of %llu", options->version, kMinBuildVersion);
     }
@@ -330,8 +330,8 @@
     *minor = MinorVersion;
 }
 
-struct MRMSharedCacheBuilder* createSharedCacheBuilder(const BuildOptions_v1* options) {
-    MRMSharedCacheBuilder* builder = new MRMSharedCacheBuilder(options);
+struct SharedCacheBuilder* createSharedCacheBuilder(const BuildOptions_v1* options) {
+    SharedCacheBuilder* builder = new SharedCacheBuilder(options);
 
     // Check the option struct values are valid
     validiateBuildOptions(options, *builder);
@@ -339,10 +339,10 @@
     return builder;
 }
 
-bool addFile(struct MRMSharedCacheBuilder* builder, const char* path, uint8_t* data, uint64_t size, FileFlags fileFlags) {
+bool addFile(struct SharedCacheBuilder* builder, const char* path, uint8_t* data, uint64_t size, FileFlags fileFlags) {
     __block bool success = false;
     builder->runSync(^() {
-        if (builder->state != MRMSharedCacheBuilder::AcceptingFiles) {
+        if (builder->state != SharedCacheBuilder::AcceptingFiles) {
             builder->error("Cannot add file: '%s' as we have already started building", path);
             return;
         }
@@ -388,10 +388,10 @@
     return success;
 }
 
-bool addSymlink(struct MRMSharedCacheBuilder* builder, const char* fromPath, const char* toPath) {
+bool addSymlink(struct SharedCacheBuilder* builder, const char* fromPath, const char* toPath) {
     __block bool success = false;
     builder->runSync(^() {
-        if (builder->state != MRMSharedCacheBuilder::AcceptingFiles) {
+        if (builder->state != SharedCacheBuilder::AcceptingFiles) {
             builder->error("Cannot add file: '%s' as we have already started building", fromPath);
             return;
         }
@@ -481,14 +481,14 @@
     }
 }
 
-bool runSharedCacheBuilder(struct MRMSharedCacheBuilder* builder) {
+bool runSharedCacheBuilder(struct SharedCacheBuilder* builder) {
     __block bool success = false;
     builder->runSync(^() {
-        if (builder->state != MRMSharedCacheBuilder::AcceptingFiles) {
+        if (builder->state != SharedCacheBuilder::AcceptingFiles) {
             builder->error("Builder has already been run");
             return;
         }
-        builder->state = MRMSharedCacheBuilder::Building;
+        builder->state = SharedCacheBuilder::Building;
         if (builder->fileSystem.fileCount() == 0) {
             builder->error("Cannot run builder with no files");
         }
@@ -552,7 +552,7 @@
                 options->dylibOrdering = parseOrderFile(builder->dylibOrderFileData);
                 options->dirtyDataSegmentOrdering = parseOrderFile(builder->dirtyDataOrderFileData);
 
-                auto cacheBuilder = std::make_unique<SharedCacheBuilder>(*options.get(), builder->fileSystem);
+                auto cacheBuilder = std::make_unique<CacheBuilder>(*options.get(), builder->fileSystem);
                 builder->builders.emplace_back((BuildInstance) { std::move(options), std::move(cacheBuilder), inputFiles });
             }
         };
@@ -574,7 +574,7 @@
 
         // FIXME: This step can run in parallel.
         for (auto& buildInstance : builder->builders) {
-            SharedCacheBuilder* cacheBuilder = buildInstance.builder.get();
+            CacheBuilder* cacheBuilder = buildInstance.builder.get();
             cacheBuilder->build(buildInstance.inputFiles, aliases);
 
             // First put the warnings in to a vector to own them.
@@ -619,7 +619,7 @@
         // Now that we have run all of the builds, collect the results
         // First push file results for each of the shared caches we built
         for (auto& buildInstance : builder->builders) {
-            SharedCacheBuilder* cacheBuilder = buildInstance.builder.get();
+            CacheBuilder* cacheBuilder = buildInstance.builder.get();
 
             CacheResult cacheBuildResult;
             cacheBuildResult.version                = 1;
@@ -676,43 +676,43 @@
                 return;
         }
 
-        builder->state = MRMSharedCacheBuilder::FinishedBuilding;
+        builder->state = SharedCacheBuilder::FinishedBuilding;
         success = true;
     });
     return success;
 }
 
-const char* const* getErrors(const struct MRMSharedCacheBuilder* builder, uint64_t* errorCount) {
+const char* const* getErrors(const struct SharedCacheBuilder* builder, uint64_t* errorCount) {
     if (builder->errors.empty())
         return nullptr;
     *errorCount = builder->errors.size();
     return builder->errors.data();
 }
 
-const struct FileResult* const* getFileResults(struct MRMSharedCacheBuilder* builder, uint64_t* resultCount) {
+const struct FileResult* const* getFileResults(struct SharedCacheBuilder* builder, uint64_t* resultCount) {
     if (builder->fileResults.empty())
         return nullptr;
     *resultCount = builder->fileResults.size();
     return builder->fileResults.data();
 }
 
-const struct CacheResult* const* getCacheResults(struct MRMSharedCacheBuilder* builder, uint64_t* resultCount) {
+const struct CacheResult* const* getCacheResults(struct SharedCacheBuilder* builder, uint64_t* resultCount) {
     if (builder->cacheResults.empty())
         return nullptr;
     *resultCount = builder->cacheResults.size();
     return builder->cacheResults.data();
 }
 
-const char* const* getFilesToRemove(const struct MRMSharedCacheBuilder* builder, uint64_t* fileCount) {
+const char* const* getFilesToRemove(const struct SharedCacheBuilder* builder, uint64_t* fileCount) {
     if (builder->filesToRemove.empty())
         return nullptr;
     *fileCount = builder->filesToRemove.size();
     return builder->filesToRemove.data();
 }
 
-void destroySharedCacheBuilder(struct MRMSharedCacheBuilder* builder) {
+void destroySharedCacheBuilder(struct SharedCacheBuilder* builder) {
     for (auto& buildInstance : builder->builders) {
-        SharedCacheBuilder* cacheBuilder = buildInstance.builder.get();
+        CacheBuilder* cacheBuilder = buildInstance.builder.get();
         cacheBuilder->deleteBuffer();
     }
     for (auto &fileResult : builder->fileResultStorage) {