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.*;
class main {
public static void main(final String[] args) throws Exception {
assertEqualsVerbose("Microtheory", snippetTypeName(50));
}
static String snippetTypeName_data = "\r\n \r\n";
static Map snippetTypeName_map;
static String snippetTypeName(int type) {
if (snippetTypeName_map == null)
snippetTypeName_map = mapKeys("parseInt", pairsToMap(map("listToPair",regexpAllGroups(">\\[(\\d+)\\] ([^>]+)<", snippetTypeName_data))));
return snippetTypeName_map.get(type);
}
static Map _registerThread_threads = newWeakHashMap();
static Thread _registerThread(Thread t) {
_registerThread_threads.put(t, true);
return t;
}
static void _registerThread() { _registerThread(Thread.currentThread()); }
static void assertEqualsVerbose(Object x, Object y) {
assertEqualsVerbose((String) null, x, y);
}
static void assertEqualsVerbose(String msg, Object x, Object y) {
if (!eq(x, y)) {
if (x instanceof String && y instanceof String && (containsNewLine((String) x) || containsNewLine((String) y)))
nlPrintNL(unidiff((String) x, (String) y));
throw fail((msg != null ? msg + ": " : "") + sfu(y) + " != " + sfu(x));
} else
print("OK: " + sfu(x));
}
static boolean containsNewLine(String s) {
return contains(s, '\n'); // screw \r, nobody needs it
}
static String sfu(Object o) { return structureForUser(o); }
static HashMap pairsToMap(Collection extends Pair> l) {
HashMap map = new HashMap();
if (l != null) for (Pair p : l)
map.put(p.a, p.b);
return map;
}
static Map newWeakHashMap() {
return _registerWeakMap(synchroMap(new WeakHashMap()));
}
static Map mapKeys(Object func, Map map) {
Map m = similarEmptyMap(map);
for (Object key : keys(map))
m.put(callF(func, key), map.get(key));
return m;
}
static Map mapKeys(Map map, Object func) {
return mapKeys(func, map);
}
static boolean eq(Object a, Object b) {
return a == null ? b == null : a == b || a.equals(b);
}
static int parseInt(String s) {
return empty(s) ? 0 : Integer.parseInt(s);
}
static int parseInt(char c) {
return Integer.parseInt(str(c));
}
static void nlPrintNL(Object o) {
print_doubleNL(o);
}
static String unidiff(String a, String b) {
int contextSize = 1;
return fromLines(BlockDiffer.generateUniDiff(toLines(a), toLines(b), contextSize));
}
static RuntimeException fail() { throw new RuntimeException("fail"); }
static RuntimeException fail(Throwable e) { throw asRuntimeException(e); }
static RuntimeException fail(Object msg) { throw new RuntimeException(String.valueOf(msg)); }
static RuntimeException fail(String msg) { throw new RuntimeException(msg == null ? "" : msg); }
static RuntimeException fail(String msg, Throwable innerException) { throw new RuntimeException(msg, innerException); }
static volatile StringBuffer local_log = new StringBuffer(); // not redirected
static volatile StringBuffer 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 int print_maxLineLength = 0; // 0 = unset
static boolean print_silent; // total mute if set
static Object print_byThread_lock = new Object();
static volatile ThreadLocal