@Override
 public DynamicType.Unloaded<T> make() {
   MethodRegistry.Compiled compiledMethodRegistry =
       constructorStrategy
           .inject(methodRegistry, defaultMethodAttributeAppenderFactory)
           .prepare(
               applyConstructorStrategy(
                   new InstrumentedType.Default(
                       namingStrategy.name(
                           new NamingStrategy.UnnamedType.Default(
                               targetType, interfaceTypes, modifiers, classFileVersion)),
                       modifiers,
                       Collections.<GenericTypeDescription>emptyList(),
                       targetType,
                       interfaceTypes,
                       fieldTokens,
                       methodTokens,
                       Collections.<AnnotationDescription>emptyList(),
                       InstrumentedType.TypeInitializer.None.INSTANCE,
                       LoadedTypeInitializer.NoOp.INSTANCE)),
               methodGraphCompiler,
               new InstrumentableMatcher(ignoredMethods))
           .compile(
               new SubclassImplementationTarget.Factory(
                   SubclassImplementationTarget.OriginTypeResolver.SUPER_TYPE));
   return TypeWriter.Default.<T>forCreation(
           compiledMethodRegistry,
           fieldRegistry.compile(compiledMethodRegistry.getInstrumentedType()),
           auxiliaryTypeNamingStrategy,
           implementationContextFactory,
           classVisitorWrapper,
           attributeAppender,
           classFileVersion)
       .make();
 }
 @Override
 public boolean equals(Object other) {
   return this == other
       || !(other == null || getClass() != other.getClass())
           && super.equals(other)
           && constructorStrategy.equals(
               ((SubclassDynamicTypeBuilder<?>) other).constructorStrategy);
 }
 /**
  * Applies this builder's constructor strategy to the given instrumented type.
  *
  * @param instrumentedType The instrumented type to apply the constructor onto.
  * @return The instrumented type with the constructor strategy applied onto.
  */
 private InstrumentedType applyConstructorStrategy(InstrumentedType instrumentedType) {
   if (instrumentedType.isInterface()) {
     return instrumentedType;
   }
   for (MethodDescription.Token methodToken :
       constructorStrategy.extractConstructors(instrumentedType)) {
     instrumentedType = instrumentedType.withMethod(methodToken);
   }
   return instrumentedType;
 }
 @Override
 public int hashCode() {
   return 31 * super.hashCode() + constructorStrategy.hashCode();
 }