--- dyld/dyld-1284.13/cache_builder/IMPCaches.cpp
+++ dyld/dyld-1122.1/cache_builder/IMPCaches.cpp
@@ -730,7 +730,7 @@
            (trackedArray.find(classNameStr) != trackedArray.end());
 }
 
-bool IMPCachesBuilder::addMethod(IMPCaches::ClassData* classDataPtr, std::string_view methodName, std::string_view installName, std::string_view className, std::string_view catName, bool inlined, bool fromFlattening) {
+void IMPCachesBuilder::addMethod(IMPCaches::ClassData* classDataPtr, std::string_view methodName, std::string_view installName, std::string_view className, std::string_view catName, bool inlined, bool fromFlattening) {
     std::string_view methodNameView(methodName);
 
     auto [selectorIterator, success] = selectors.map.try_emplace(methodNameView, std::make_unique<Selector>());
@@ -763,8 +763,6 @@
         thisSelectorData->classes.push_back(classDataPtr);
         classDataPtr->methods.push_back(m);
     }
-
-    return !exists;
 }
 
 void IMPCachesBuilder::inlineMethodIfNeeded(IMPCaches::ClassData* classToInlineIn, std::string_view classToInlineFrom, std::string_view catToInlineFrom, std::string_view installNameToInlineFrom, std::string_view name, std::set<Selector*>& seenSelectors, bool isFlattening) {
@@ -871,13 +869,10 @@
         thisData->isMetaclass = theClass.isMetaClass;
         thisData->shouldGenerateImpCache = interesting;
 
-        bool duplicateMethod = false;
         for ( const imp_caches::Method& objcMethod : objcClass.methods ) {
             const bool inlined = false;
             const bool fromFlattening = false;
-            bool added = addMethod(thisDataPtr, objcMethod.name, dylib.inputDylib->installName, theClass.className, "", inlined, fromFlattening);
-            if ( !added )
-                duplicateMethod = true;
+            addMethod(thisDataPtr, objcMethod.name, dylib.inputDylib->installName, theClass.className, "", inlined, fromFlattening);
         }
 
         ClassKey key {
@@ -886,7 +881,7 @@
         };
         assert(dylib.impCachesClassData.find(key) == dylib.impCachesClassData.end());
 
-        if (duplicateMethod || (duplicateClasses.find(key) != duplicateClasses.end()) ) {
+        if (duplicateClasses.find(key) != duplicateClasses.end()) {
             // We can't just set shouldGenerateImpCache to false ; we do it later
             // when we have built the flattening hierarchies in order to drop
             // any related classes as well.
@@ -1261,20 +1256,20 @@
     }
 }
 
-const std::string * IMPCachesBuilder::nameAndIsMetaclassPairFromNode(const json::Node & node, bool* metaclass) {
-    const json::Node& metaclassNode = json::getRequiredValue(_diagnostics, node, "metaclass");
+const std::string * IMPCachesBuilder::nameAndIsMetaclassPairFromNode(const dyld3::json::Node & node, bool* metaclass) {
+    const dyld3::json::Node& metaclassNode = dyld3::json::getRequiredValue(_diagnostics, node, "metaclass");
     if (_diagnostics.hasError()) return nullptr;
 
-    if (metaclass != nullptr) *metaclass  = json::parseRequiredInt(_diagnostics, metaclassNode) != 0;
-    const json::Node& nameNode = json::getRequiredValue(_diagnostics, node, "name");
+    if (metaclass != nullptr) *metaclass  = dyld3::json::parseRequiredInt(_diagnostics, metaclassNode) != 0;
+    const dyld3::json::Node& nameNode = dyld3::json::getRequiredValue(_diagnostics, node, "name");
     if (_diagnostics.hasError()) return nullptr;
 
-    return &(json::parseRequiredString(_diagnostics, nameNode));
+    return &(dyld3::json::parseRequiredString(_diagnostics, nameNode));
 }
 
 IMPCachesBuilder::IMPCachesBuilder(Diagnostics& diag, TimeRecorder& timeRecorder,
                                    const std::vector<imp_caches::Dylib>& inputDylibs,
-                                   const json::Node& optimizerConfiguration)
+                                   const dyld3::json::Node& optimizerConfiguration)
     : _diagnostics(diag), _timeRecorder(timeRecorder)
 {
     // Add one DylibState for every input dylib
@@ -1285,19 +1280,19 @@
         this->dylibs.push_back(std::move(d));
     }
 
-    const json::Node * version = json::getOptionalValue(diag, optimizerConfiguration, "version");
-    int64_t versionInt = (version != NULL) ? json::parseRequiredInt(diag, *version) : 1;
+    const dyld3::json::Node * version = dyld3::json::getOptionalValue(diag, optimizerConfiguration, "version");
+    int64_t versionInt = (version != NULL) ? dyld3::json::parseRequiredInt(diag, *version) : 1;
     if (versionInt == 2) {
         // v2 has a single neededClasses array, with a key to know if it's a metaclass
         // or class. This lets us order them by importance so that we handle the important
         // cases first in the algorithm, while it's still easy to place things (as we process
         // more classes, constraints build up and we risk dropping difficult classes)
 
-        const json::Node& classes = json::getRequiredValue(diag, optimizerConfiguration, "neededClasses");
+        const dyld3::json::Node& classes = dyld3::json::getRequiredValue(diag, optimizerConfiguration, "neededClasses");
         if (diag.hasError()) return;
 
         int i = 0;
-        for (const json::Node& n : classes.array) {
+        for (const dyld3::json::Node& n : classes.array) {
             bool metaclass = false;
             const std::string *name = nameAndIsMetaclassPairFromNode(n, &metaclass);
             if (name != nullptr) {
@@ -1316,7 +1311,7 @@
         int i = 0;
 
         if (metaclasses != optimizerConfiguration.map.cend()) {
-            for (const json::Node& n : metaclasses->second.array) {
+            for (const dyld3::json::Node& n : metaclasses->second.array) {
                 neededMetaclasses[n.value] = i++;
             }
         }
@@ -1324,7 +1319,7 @@
         auto classes = optimizerConfiguration.map.find("neededClasses");
 
         if (classes != optimizerConfiguration.map.cend()) {
-            for (const json::Node& n : classes->second.array) {
+            for (const dyld3::json::Node& n : classes->second.array) {
                 neededClasses[n.value] = i++;
             }
         }
@@ -1334,14 +1329,14 @@
     if (sels != optimizerConfiguration.map.cend()) {
         // TODO: The emitter for this isn't implemented yet
         assert(sels->second.array.empty());
-        for (const json::Node& n : sels->second.array) {
+        for (const dyld3::json::Node& n : sels->second.array) {
             selectorsToInline.insert(n.value);
         }
     }
 
-    const json::Node* classHierarchiesToFlattenNode = json::getOptionalValue(diag, optimizerConfiguration, "flatteningRoots");
+    const dyld3::json::Node* classHierarchiesToFlattenNode = dyld3::json::getOptionalValue(diag, optimizerConfiguration, "flatteningRoots");
     if (classHierarchiesToFlattenNode != nullptr) {
-        for (const json::Node& n : classHierarchiesToFlattenNode->array) {
+        for (const dyld3::json::Node& n : classHierarchiesToFlattenNode->array) {
             bool metaclass = false;
             const std::string *name = nameAndIsMetaclassPairFromNode(n, &metaclass);
             if (metaclass) {
@@ -2020,7 +2015,7 @@
 namespace imp_caches
 {
 
-Builder::Builder(const std::vector<Dylib>& dylibs, const json::Node& objcOptimizations)
+Builder::Builder(const std::vector<Dylib>& dylibs, const dyld3::json::Node& objcOptimizations)
     : diags(verbose), dylibs(dylibs), objcOptimizations(objcOptimizations)
 {
 }