docs: public Map<TypeDescription, Class<?>> load(ClassLoader classLoader, Map<TypeDescription, byte[]> types) {
          Map<String, Class<?>> availableTypes = new HashMap<String, Class<?>>(preregisteredTypes);
          for (Class<?> type : instrumentation.getInitiatedClasses(classLoader)) {
              availableTypes.put(TypeDescription.ForLoadedType.getName(type), type);
          }
          Map<Class<?>, ClassDefinition> classDefinitions = new ConcurrentHashMap<Class<?>, ClassDefinition>();
          Map<TypeDescription, Class<?>> loadedClasses = new HashMap<TypeDescription, Class<?>>();
          Map<TypeDescription, byte[]> unloadedClasses = new LinkedHashMap<TypeDescription, byte[]>();
          for (Map.Entry<TypeDescription, byte[]> entry : types.entrySet()) {
              Class<?> type = availableTypes.get(entry.getKey().getName());
              if (type != null) {
                  classDefinitions.put(type, new ClassDefinition(type, entry.getValue()));
                  loadedClasses.put(entry.getKey(), type);
              } else {
                  unloadedClasses.put(entry.getKey(), entry.getValue());
              }
          }
          try {
              strategy.apply(instrumentation, classDefinitions);
              if (!unloadedClasses.isEmpty()) {
                  loadedClasses.putAll((classLoader == null
                          ? bootstrapInjection.make(instrumentation)
                          : new ClassInjector.UsingReflection(classLoader)).inject(unloadedClasses));
              }
          } catch (ClassNotFoundException exception) {
              throw new IllegalArgumentException("Could not locate classes for redefinition", exception);
          } catch (UnmodifiableClassException exception) {
              throw new IllegalStateException("Cannot redefine specified class", exception);
          }
          return loadedClasses;
      }