Warning: session_start(): open(/var/lib/php/sessions/sess_nvur2bhcmuccpcgiabighlvaf4, O_RDWR) failed: No space left on device (28) in /var/www/tb-usercake/models/config.php on line 51

Warning: session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in /var/www/tb-usercake/models/config.php on line 51
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 java.text.NumberFormat; import javax.net.ssl.*; import java.security.SecureRandom; import java.security.cert.X509Certificate; import java.text.SimpleDateFormat; import javax.imageio.metadata.*; import javax.imageio.stream.*; import javax.swing.undo.UndoManager; import java.awt.datatransfer.StringSelection; import java.text.*; import java.util.TimeZone; class main { // see: https://en.wikipedia.org/wiki/Order_statistic_tree // based on: https://algs4.cs.princeton.edu/33balanced/RedBlackBST.java.html final static class LogNArray extends RandomAccessAbstractList { // A symbol table implemented using a left-leaning red-black BST. // This is the 2-3 version. private static final boolean RED = true; private static final boolean BLACK = false; private Node root; // root of the BST // BST helper node data type private final static class Node { private Value val; // associated data private Node left, right; // links to left and right subtrees private int sizeAndColor; // subtree count + color (highest bit) Node() {} Node(Value val, boolean color, int size) { this.val = val; sizeAndColor = size | (color ? 0x80000000 : 0); } int size() { return sizeAndColor & 0x7FFFFFFF; } boolean color() { return sizeAndColor < 0; } void setSize(int size) { sizeAndColor = sizeAndColor & 0x80000000 | size; } void setColor(boolean color) { sizeAndColor = size() | (color ? 0x80000000 : 0); } } // is node x red; false if x is null ? private boolean isRed(Node x) { if (x == null) return false; return x.color() == RED; } // number of node in subtree rooted at x; 0 if x is null private int size(Node x) { if (x == null) return 0; return x.size(); } public int size() { return size(root); } public boolean isEmpty() { return root == null; } public void add(int idx, Value val) { if (idx < 0 || idx > size()) throw new IndexOutOfBoundsException(idx + " / " + size()); root = add(root, idx, val); root.setColor(BLACK); } // insert the value pair in index k of subtree rooted at h private Node add(Node h, int k, Value val) { if (h == null) return new Node(val, RED, 1); int t = size(h.left); if (k < t) // replace / fit in left child h.left = add(h.left, k, val); else if (k == t) { // move value to right child, replace value h.right = add(h.right, 0, h.val); h.val = val; } else // replace / fit in right child h.right = add(h.right, k-t-1, val); // fix-up any right-leaning links if (isRed(h.right) && !isRed(h.left)) h = rotateLeft(h); if (isRed(h.left) && isRed(h.left.left)) h = rotateRight(h); if (isRed(h.left) && isRed(h.right)) flipColors(h); h.setSize(size(h.left) + size(h.right) + 1); return h; } public Value remove(int idx) { Value oldValue = get(idx); // if both children of root are black, set root to red if (!isRed(root.left) && !isRed(root.right)) root.setColor(RED); root = remove(root, idx); if (root != null) root.setColor(BLACK); return oldValue; } private Node remove(Node h, int k) { int t = size(h.left); if (k < t) { // remove from left child if (!isRed(h.left) && !isRed(h.left.left)) h = moveRedLeft(h); h.left = remove(h.left, k); } else { // remove from center or right child if (isRed(h.left)) { h = rotateRight(h); t = size(h.left); } if (h.right == null) return null; // drop whole node if (!isRed(h.right) && !isRed(h.right.left)) { h = moveRedRight(h); t = size(h.left); } if (k == t) { // replace center value with min of right child h.val = nodeAtIndex(h.right, 0).val; h.right = remove(h.right, 0); } else h.right = remove(h.right, k-t-1); } return balance(h); } // make a left-leaning link lean to the right private Node rotateRight(Node h) { // assert (h != null) && isRed(h.left); Node x = h.left; h.left = x.right; x.right = h; x.setColor(x.right.color()); x.right.setColor(RED); x.setSize(h.size()); h.setSize(size(h.left) + size(h.right) + 1); return x; } // make a right-leaning link lean to the left private Node rotateLeft(Node h) { // assert (h != null) && isRed(h.right); Node x = h.right; h.right = x.left; x.left = h; x.setColor(x.left.color()); x.left.setColor(RED); x.setSize(h.size()); h.setSize(size(h.left) + size(h.right) + 1); return x; } // flip the colors of a node and its two children private void flipColors(Node h) { // h must have opposite color of its two children // assert (h != null) && (h.left != null) && (h.right != null); // assert (!isRed(h) && isRed(h.left) && isRed(h.right)) // || (isRed(h) && !isRed(h.left) && !isRed(h.right)); h.setColor(!h.color()); h.left.setColor(!h.left.color()); h.right.setColor(!h.right.color()); } // Assuming that h is red and both h.left and h.left.left // are black, make h.left or one of its children red. private Node moveRedLeft(Node h) { // assert (h != null); // assert isRed(h) && !isRed(h.left) && !isRed(h.left.left); flipColors(h); if (isRed(h.right.left)) { h.right = rotateRight(h.right); h = rotateLeft(h); flipColors(h); } return h; } // Assuming that h is red and both h.right and h.right.left // are black, make h.right or one of its children red. private Node moveRedRight(Node h) { // assert (h != null); // assert isRed(h) && !isRed(h.right) && !isRed(h.right.left); flipColors(h); if (isRed(h.left.left)) { h = rotateRight(h); flipColors(h); } return h; } // restore red-black tree invariant private Node balance(Node h) { // assert (h != null); if (isRed(h.right)) h = rotateLeft(h); if (isRed(h.left) && isRed(h.left.left)) h = rotateRight(h); if (isRed(h.left) && isRed(h.right)) flipColors(h); h.setSize(size(h.left) + size(h.right) + 1); return h; } /** * Returns the height of the BST (for debugging). * @return the height of the BST (a 1-node tree has height 0) */ public int height() { return height(root); } private int height(Node x) { if (x == null) return -1; return 1 + Math.max(height(x.left), height(x.right)); } public Value get(int k) { return nodeAtIndex(k).val; } public Value set(int k, Value val) { Node n = nodeAtIndex(k); Value oldValue = n.val; n.val = val; return oldValue; } public Node nodeAtIndex(int k) { if (k < 0 || k >= size()) { throw new IndexOutOfBoundsException(k + " / " + size()); } return nodeAtIndex(root, k); } // the key of rank k in the subtree rooted at x private Node nodeAtIndex(Node x, int k) { // assert x != null; // assert k >= 0 && k < size(x); int t = size(x.left); if (t > k) return nodeAtIndex(x.left, k); else if (t < k) return nodeAtIndex(x.right, k-t-1); else return x; } private boolean check() { if (!isSizeConsistent()) println("Subtree counts not consistent"); if (!is23()) println("Not a 2-3 tree"); if (!isBalanced()) println("Not balanced"); return isSizeConsistent() && is23() && isBalanced(); } // are the size fields correct? private boolean isSizeConsistent() { return isSizeConsistent(root); } private boolean isSizeConsistent(Node x) { if (x == null) return true; if (x.size() != size(x.left) + size(x.right) + 1) return false; return isSizeConsistent(x.left) && isSizeConsistent(x.right); } // Does the tree have no red right links, and at most one (left) // red links in a row on any path? private boolean is23() { return is23(root); } private boolean is23(Node x) { if (x == null) return true; if (isRed(x.right)) return false; if (x != root && isRed(x) && isRed(x.left)) return false; return is23(x.left) && is23(x.right); } // do all paths from root to leaf have same number of black edges? private boolean isBalanced() { int black = 0; // number of black links on path from root to min Node x = root; while (x != null) { if (!isRed(x)) black++; x = x.left; } return isBalanced(root, black); } // does every path from the root to a leaf have the given number of black links? private boolean isBalanced(Node x, int black) { if (x == null) return black == 0; if (!isRed(x)) black--; return isBalanced(x.left, black) && isBalanced(x.right, black); } public void clear() { root = null; } } public static void main(final String[] args) throws Exception { pExperiment(); LogNArray a = new LogNArray(); int n = 5000000; int[] random = new int[n]; for (int i = 0; i < n; i++) random[i] = random(n); for (int __twice = 0; __twice < 2; __twice++) { { long _startTime_2 = sysNow(); try { a.clear(); for (int i = 0; i < n; i++) a.add(random[i]); } finally { _startTime_2 = sysNow()-_startTime_2; saveTiming(_startTime_2); } }} printBenchResult("Adding", n); for (int __twice = 0; __twice < 2; __twice++) { { long _startTime_3 = sysNow(); try { for (int i = 0; i < n; i++) a.get(i); } finally { _startTime_3 = sysNow()-_startTime_3; saveTiming(_startTime_3); } }} printBenchResult("Accessing in order", n); for (int __twice = 0; __twice < 2; __twice++) { { long _startTime_4 = sysNow(); try { for (int i = 0; i < n; i++) a.get(random[i]); } finally { _startTime_4 = sysNow()-_startTime_4; saveTiming(_startTime_4); } }} printBenchResult("Accessing in random order", n); /*twice*/ { { long _startTime_5 = sysNow(); try { for (int i = 0; i < n; i++) { a.remove(mod(random[i], l(a))); } } finally { _startTime_5 = sysNow()-_startTime_5; saveTiming(_startTime_5); } }} printBenchResult("Removing in random order (without warm-up)", n); } static void add(BitSet bs, int i) { bs.set(i); } static boolean add(Collection c, A a) { return c != null && c.add(a); } static void add(Container c, Component x) { addToContainer(c, x); } static void remove(List l, int i) { if (l != null && i >= 0 && i < l(l)) l.remove(i); } static void remove(Collection l, A a) { if (l != null) l.remove(a); } // get purpose 1: access a list/array/map (safer version of x.get(y)) static A get(List l, int idx) { return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null; } // seems to conflict with other signatures /*static B get(Map map, A key) { ret map != null ? map.get(key) : null; }*/ static A get(A[] l, int idx) { return idx >= 0 && idx < l(l) ? l[idx] : null; } // default to false static boolean get(boolean[] l, int idx) { return idx >= 0 && idx < l(l) ? l[idx] : false; } // get purpose 2: access a field by reflection or a map static Object get(Object o, String field) { try { if (o == null) return null; if (o instanceof Class) return get((Class) o, field); if (o instanceof Map) return ((Map) o).get(field); Field f = getOpt_findField(o.getClass(), field); if (f != null) { f.setAccessible(true); return f.get(o); } if (o instanceof DynamicObject) return ((DynamicObject) o).fieldValues.get(field); } catch (Exception e) { throw asRuntimeException(e); } throw new RuntimeException("Field '" + field + "' not found in " + o.getClass().getName()); } static Object get_raw(Object o, String field) { try { Field f = get_findField(o.getClass(), field); f.setAccessible(true); return f.get(o); } catch (Exception e) { throw new RuntimeException(e); } } static Object get(Class c, String field) { try { Field f = get_findStaticField(c, field); f.setAccessible(true); return f.get(null); } catch (Exception e) { throw new RuntimeException(e); } } static Field get_findStaticField(Class c, String field) { Class _c = c; do { for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0) return f; _c = _c.getSuperclass(); } while (_c != null); throw new RuntimeException("Static field '" + field + "' not found in " + c.getName()); } static Field get_findField(Class c, String field) { Class _c = c; do { for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field)) return f; _c = _c.getSuperclass(); } while (_c != null); throw new RuntimeException("Field '" + field + "' not found in " + c.getName()); } static Object get(String field, Object o) { return get(o, field); } static A set(A o, String field, Object value) { if (o == null) return null; if (o instanceof Class) set((Class) o, field, value); else try { Field f = set_findField(o.getClass(), field); f.setAccessible(true); smartSet(f, o, value); } catch (Exception e) { throw new RuntimeException(e); } return o; } static void set(Class c, String field, Object value) { if (c == null) return; try { Field f = set_findStaticField(c, field); f.setAccessible(true); smartSet(f, null, value); } catch (Exception e) { throw new RuntimeException(e); } } static Field set_findStaticField(Class c, String field) { Class _c = c; do { for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0) return f; _c = _c.getSuperclass(); } while (_c != null); throw new RuntimeException("Static field '" + field + "' not found in " + c.getName()); } static Field set_findField(Class c, String field) { Class _c = c; do { for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field)) return f; _c = _c.getSuperclass(); } while (_c != null); throw new RuntimeException("Field '" + field + "' not found in " + c.getName()); } static A println(A a) { return print(a); } static void pExperiment() { if (!isMain()) return; //substance(); autoRestart(5); experimentIcon(); centerHigherConsole(); tt(); } static Random random_random = new Random(); static int random(int n) { return random(random_random, n); } static int random(Random r, int n) { return n <= 0 ? 0 : r.nextInt(n); } static double random(double max) { return random()*max; } static double random() { return random_random.nextInt(100001)/100000.0; } static double random(double min, double max) { return min+random()*(max-min); } // min <= value < max static int random(int min, int max) { return min+random(max-min); } static int random(Random r, int min, int max) { return min+random(r, max-min); } static A random(List l) { return oneOf(l); } static A random(Collection c) { if (c instanceof List) return random((List ) c); int i = random(l(c)); return collectionGet(c, i); } static long sysNow() { ping(); return System.nanoTime()/1000000; } static ThreadLocal saveTiming_last = new ThreadLocal(); static void saveTiming(long ms) { print(ms + " ms"); saveTiming_noPrint(ms); } static void saveTiming_noPrint(long ms) { saveTiming_last.set(ms); } static void printBenchResult(long repetitions) { printBenchResult(lastTiming(), repetitions); } static void printBenchResult(long time, long repetitions) { printBenchResult("", time, repetitions); } static void printBenchResult(String msg, long repetitions) { printBenchResult(msg, lastTiming(), repetitions); } static void printBenchResult(String msg, long time, long repetitions) { double secs = toSeconds(time)/repetitions; String s = (empty(msg) ? "" : msg + ": ") + n2(repetitions, "step") + ". Each step took: "; if (secs >= 1) { print(s + formatDouble(secs, 3) + " s"); return; } double ms = secs*1000; if (ms >= 1) { print(s + formatDouble(ms, 3) + " ms"); return; } double us = ms*1000; if (us >= 1) { print(s + formatDouble(us, 3) + " µs"); return; } double ns = us*1000; print(s + iround(ns) + " ns"); } // better modulo that gives positive numbers always static int mod(int n, int m) { return (n % m + m) % m; } static long mod(long n, long m) { return (n % m + m) % m; } static BigInteger mod(BigInteger n, int m) { return n.mod(bigint(m)); } static double mod(double n, double m) { return (n % m + m) % m; } static int l(Object[] a) { return a == null ? 0 : a.length; } static int l(boolean[] a) { return a == null ? 0 : a.length; } static int l(byte[] a) { return a == null ? 0 : a.length; } static int l(short[] a) { return a == null ? 0 : a.length; } static int l(long[] a) { return a == null ? 0 : a.length; } static int l(int[] a) { return a == null ? 0 : a.length; } static int l(float[] a) { return a == null ? 0 : a.length; } static int l(double[] a) { return a == null ? 0 : a.length; } static int l(char[] a) { return a == null ? 0 : a.length; } static int l(Collection c) { return c == null ? 0 : c.size(); } static int l(Map m) { return m == null ? 0 : m.size(); } static int l(CharSequence s) { return s == null ? 0 : s.length(); } static long l(File f) { return f == null ? 0 : f.length(); } static int l(Object o) { return o == null ? 0 : o instanceof String ? l((String) o) : o instanceof Map ? l((Map) o) : o instanceof Collection ? l((Collection) o) : o instanceof Object[] ? l((Object[]) o) : o instanceof boolean[] ? l((boolean[]) o) : o instanceof byte[] ? l((byte[]) o) : o instanceof char[] ? l((char[]) o) : o instanceof short[] ? l((short[]) o) : o instanceof int[] ? l((int[]) o) : o instanceof float[] ? l((float[]) o) : o instanceof double[] ? l((double[]) o) : o instanceof long[] ? l((long[]) o) : (Integer) call(o, "size"); } static int l(MultiSet ms) { return ms == null ? 0 : ms.size(); } static void addToContainer(final Container a, final Component b) { if (a != null && b != null) { swing(new Runnable() { public void run() { try { a.add(b); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "a.add(b);"; }}); } } static Field getOpt_findField(Class c, String field) { Class _c = c; do { for (Field f : _c.getDeclaredFields()) if (f.getName().equals(field)) return f; _c = _c.getSuperclass(); } while (_c != null); return null; } static RuntimeException asRuntimeException(Throwable t) { if (t instanceof Error) _handleError((Error) t); return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t); } static void smartSet(Field f, Object o, Object value) throws Exception { try { f.set(o, value); } catch (Exception e) { Class type = f.getType(); // take care of common case (long to int) if (type == int.class && value instanceof Long) value = ((Long) value).intValue(); if (type == LinkedHashMap.class && value instanceof Map) { f.set(o, asLinkedHashMap((Map) value)); return; } try { if (f.getType() == Concept.Ref.class) { f.set(o, ((Concept) o).new Ref((Concept) value)); return; } if (o instanceof Concept.Ref) { f.set(o, ((Concept.Ref) o).get()); return; } } catch (Throwable _e) {} throw 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