return (Class) lookup.defineClass(classBytes);
                } else {
                    return defineClass(classLoader, className, classBytes);
                }
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        public <T> Class<T> defineClass(ClassLoader classLoader, String className, byte[] classBytes) {

    Class generated
    ClassLoader target

    void call(ClassVisitor classVisitor, ClassNode classNode) {
        def bytes = ((ClassWriter) classVisitor).toByteArray();
        generated = target.defineClass(classNode.getName(), bytes, 0, bytes.length)
    }

        URL url = findResource(resource)
        if (url == null) {
            throw new ClassNotFoundException("Could not find class '${name}'")
        }
        def byteCode = url.bytes
        return defineClass(name, byteCode, 0, byteCode.length)
    }

        visitor.visitEnd();
        return visitor.toByteArray();
    }

    /**
     * Injects the interfaces into an arbitrary classloader via
     * {@link ClassLoader#defineClass(String, byte[], int, int)}.
     */
    @Override
    public void injectEmptyInterfacesIntoClassLoader(ClassLoader classLoader) {
        try {
            for (String name : syntheticClasses) {

        @SuppressWarnings("deprecation") Package p = getPackage(packageName);
        if (p == null) {
            definePackage(packageName, null, null, null, null, null, null, null);
        }
        return defineClass(name, bytes, 0, bytes.length, codeSource);
    }

    @Nullable
    protected byte[] generateMissingClass(String name) {
        return null;
    }

            }
            def byteCode = url.bytes
            CodeSource codeSource = new CodeSource(getCodeBaseUrl(url, resource), null as Certificate[])
            return defineClass(name, byteCode, 0, byteCode.length, new ProtectionDomain(codeSource, new Permissions(), this, null))
        }

        URL getCodeBaseUrl(URL url, String resource) {
            def uri = url.toURI().toString()

                emptyWriter.visitEnd();
                byte[] emptyBytecode = emptyWriter.toByteArray();
                defineClass(detector.interfaceName, emptyBytecode, 0, emptyBytecode.length);
            }

            ClassWriter classWriter = new ClassWriter(0);

        ApiClassLoader() {
            super(new URL[0], systemClassLoader.parent)
        }

        Class<?> loadClassFromBytes(byte[] bytes) {
            defineClass(null, bytes, 0, bytes.length)
        }
    }

    @CompileStatic
    static class ApiContainer {
        private final ApiClassLoader apiClassLoader = new ApiClassLoader()

    }
}


private
class BytesClassLoader : URLClassLoader(arrayOf(), getSystemClassLoader()) {
    fun loadClassFromBytes(bytes: ByteArray): Class<*> =
        defineClass(null, bytes, 0, bytes.size)

        }

        @Override
        public DefinesClass definesClass(VirtualFile classpathEntry) {
            if (classpathEntry.name().equals("rt.jar")) {
                return className -> false;
            }
            return analysis(classpathEntry)
                .map(a -> a instanceof Analysis ? (Analysis) a : null)
                .<DefinesClass>map(AnalysisBakedDefineClass::new)