import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.math.*;
import javax.net.ssl.*;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.text.SimpleDateFormat;
import java.text.NumberFormat;
import javax.swing.border.*;
import java.awt.datatransfer.StringSelection;
import javax.swing.event.AncestorListener;
import javax.swing.event.AncestorEvent;
import javax.swing.Timer;
import javax.swing.undo.UndoManager;
import javax.imageio.metadata.*;
import javax.imageio.stream.*;
import java.awt.geom.*;
import java.text.*;
import java.util.TimeZone;
import net.bytebuddy.*;
import net.bytebuddy.dynamic.*;
class main {
// ByteBuddy
static class TestByteBuddy extends DynPrintLog {
void start() { try { super.start(); startThread("Start", new Runnable() { public void run() { try { AutoCloseable __1 = enter(); try { try {
String className = "main$NewClass1";
DynamicType.Unloaded maker = new ByteBuddy()
.subclass(Concept.class)
.name(className)
.make();
byte[] classData = (byte[]) (_get("binaryRepresentation",maker));
//ClassLoader cl = module().getClass().getClassLoader();
File jar = programFile("dynamic.jar");
createZipFileWithSingleBinaryFile(jar, className + ".class", classData);
addLibraryToCurrentProgram(jar);
Class extends Concept> c = classForName(className);
print(c);
Concept cc = nu(c);
print("Got concept: " + cc);
} catch (Throwable __e) { _handleException(__e); }} finally { _close(__1); }
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "AutoCloseable __1 = enter(); try { try {\r\n String className = \"main$NewCla..."; }});} catch (Exception __e) { throw rethrow(__e); } }
}
static boolean _moduleClass_TestByteBuddy = true;
static Thread startThread(Object runnable) {
return startThread(defaultThreadName(), runnable);
}
static Thread startThread(String name, Object runnable) {
runnable = wrapAsActivity(runnable);
return startThread(newThread(toRunnable(runnable), name));
}
static Thread startThread(Thread t) {
_registerThread(t);
t.start();
return t;
}
static A _get(List l, int idx) {
return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
}
static Object _get(Object o, String field) {
return get(o, field);
}
static Object _get(String field, Object o) {
return get(o, field);
}
static A _get(A[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : null;
}
static File programFile(String name) {
return prepareProgramFile(name);
}
static File programFile(String progID, String name) {
return prepareProgramFile(progID, name);
}
static File createZipFileWithSingleBinaryFile(File zipFile, String name, byte[] data) {
ZipOutputStream outZip = newZipOutputStream(zipFile); try {
zip_addBinaryFile(outZip, name, data);
return zipFile;
} finally { _close(outZip); }}
static boolean addLibraryToCurrentProgram(String libID) {
return addLibraryToCurrentProgram(loadLibrary(libID));
}
static boolean addLibraryToCurrentProgram(File f) { try {
if (f == null || currentProgramHasLibrary(f)) return false;
ClassLoader cl = myClassLoader();
List files = (List) (get(cl, "files"));
synchronized(cl) {
files.add(f);
call(cl, "addURL", f.toURI().toURL());
}
return true;
} catch (Exception __e) { throw rethrow(__e); } }
static Map classForName_cache = synchroHashMap();
static Class classForName(String name) { try {
if (classForName_cache == null) return Class.forName(name); // in class init
Class c = classForName_cache.get(name);
if (c == null)
classForName_cache.put(name, c = Class.forName(name));
return c;
} catch (Exception __e) { throw rethrow(__e); } }
static volatile StringBuffer local_log = new StringBuffer(); // not redirected
static volatile Appendable print_log = local_log; // might be redirected, e.g. to main bot
// in bytes - will cut to half that
static volatile int print_log_max = 1024*1024;
static volatile int local_log_max = 100*1024;
static boolean print_silent = false; // total mute if set
static Object print_byThread_lock = new Object();
static volatile ThreadLocal