import javax.imageio.*;
import java.awt.image.*;
import java.awt.event.*;
import java.awt.*;
import java.security.NoSuchAlgorithmException;
import java.security.MessageDigest;
import java.lang.management.*;
import java.lang.ref.*;
import java.lang.reflect.*;
import java.net.*;
import java.io.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.*;
import java.util.regex.*;
import java.util.List;
import java.util.zip.*;
import java.util.*;


public class main {
    // a Lisp-like form
  static class Lisp implements Iterable<Lisp> {
    String head;
    List<Lisp> args = new ArrayList<Lisp>();
    
    Lisp() {}
    Lisp(String head) {
  this.head = head;}
    
    public String toString() {
      if (args.isEmpty())
        return quoteIfNotIdentifier(head);
      List<String> bla = new ArrayList<String>();
      for (Lisp a : args)
        bla.add(a.toString());
      String inner = join(", ", bla);
      if (head.equals(""))
        return "{" + inner + "}"; // list
      else
        return quoteIfNotIdentifier(head) + "(" + inner + ")";
    }
    
    void add(Lisp l) {
      args.add(l);
    }
    
    void add(String s) {
      args.add(new Lisp(s));
    }
    
    int size() {
      return args.size();
    }
    
    boolean isEmpty() {
      return args.isEmpty();
    }
    
    Lisp get(int i) {
      return args.get(i);
    }
    
    String getString(int i) {
      return get(i).head;
    }
    
    boolean is(String... heads) {
      return asList(heads).contains(head);
    }
    
    public Iterator<Lisp> iterator() {
      return args.iterator();
    }
    
    Lisp subList(int fromIndex, int toIndex) {
      Lisp l = new Lisp(head);
      l.args.addAll(args.subList(fromIndex, toIndex)); // better to copy here I guess - safe
      return l;
    }
  }
  
  // make a lisp form
  static Lisp lisp(String head, Object... args) {
    Lisp l = new Lisp(head);
    for (Object o : args)
      if (o instanceof String)
        l.args.add(new Lisp((String) o));
      else if (o instanceof Lisp)
        l.args.add((Lisp) o);
      else
        fail("Bad argument type: " + o);
    return l;
  }
  
  static Lisp lisplist(Object... x) { return lisp("", x); }
  static Lisp enter(Object... x) { return lisp("enter", x); }
  static Lisp answer(Object... x) { return lisp("answer", x); }
  static Lisp or(Object... x) { return lisp("or", x); }
 // Lisp

static class SList {
  List<String> data = new ArrayList<String>(); // don't access this from outside
  
  // these are ok to access (but not change) from outside
  final String id = randomID(8);
  final List<Lisp> history = synchroList();
  
  public synchronized void add(String a) {
    data.add(a);
    history.add(lisp("add", a));
  }
  
  public synchronized void clear() {
    data.clear();
    history.add(lisp("clear"));
  }
  
  public synchronized void remove(int i) {
    data.remove(i);
    history.add(lisp("remove", "" + i));
  }
  
  public synchronized void remove(String s) {
    int i = data.indexOf(s);
    if (i >= 0) remove(i);
  }
  
  public synchronized int indexOf(String s) {
    return data.indexOf(s);
  }
  
  public synchronized String get(int i) {
    return data.get(i);
  }
  
  public String getID() {
    return id;
  }
} // SList
  
  public static void main(String[] args) throws Exception {
    SList l = new SList();
    l.add("hello");
    l.add("world");
    print("List ID: " + l.getID());
    print("History: " + structure(l.history));
  }

static String quoteIfNotIdentifier(String s) {
  if (s == null) return null;
  return isJavaIdentifier(s) ? s : quote(s);
}

static <A> List<A> synchroList() {
  return Collections.synchronizedList(new ArrayList<A>());
}

static <A> List<A> synchroList(List<A> l) {
  return Collections.synchronizedList(l);
}


static <A> ArrayList<A> asList(A[] a) {
  return new ArrayList<A>(Arrays.asList(a));
}

static ArrayList<Integer> asList(int[] a) {
  ArrayList<Integer> l = new ArrayList<Integer>();
  for (int i : a) l.add(i);
  return l;
}

static <A> ArrayList<A> asList(Set<A> s) {
  return new ArrayList<A>(s);
}

static String randomID(int length) {
  return makeRandomID(length);
}

static void print() {
  System.out.println();
}

static void print(Object o) {
  System.out.println(o);
}

static void print(long i) {
  System.out.println(i);
}

  public static String join(String glue, Iterable<String> strings) {
    StringBuilder buf = new StringBuilder();
    Iterator<String> i = strings.iterator();
    if (i.hasNext()) {
      buf.append(i.next());
      while (i.hasNext())
        buf.append(glue).append(i.next());
    }
    return buf.toString();
  }
  
  public static String join(String glue, String[] strings) {
    return join(glue, Arrays.asList(strings));
  }
  
  public static String join(Iterable<String> strings) {
    return join("", strings);
  }
  
  public static String join(String[] strings) {
    return join("", strings);
  }


  static RuntimeException fail() {
    throw new RuntimeException("fail");
  }
  
  static RuntimeException fail(Object msg) {
    throw new RuntimeException(String.valueOf(msg));
  }

static Object get(Object o, String field) {
  if (o instanceof Class) return get((Class) o, 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) {
  for (Field f : c.getDeclaredFields())
    if (f.getName().equals(field) && (f.getModifiers() & Modifier.STATIC) != 0)
      return f;
  throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}

static Field get_findField(Class<?> c, String field) {
  for (Field f : c.getDeclaredFields())
    if (f.getName().equals(field))
      return f;
  throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}

static String structure(Object o) {
  return structure(o, 0);
}

// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;
  
static String structure(Object o, int stringSizeLimit) {
  if (o == null) return "null";
  String name = o.getClass().getName();
  
  StringBuilder buf = new StringBuilder();
  
  if (o instanceof Collection) { // TODO: store the type (e.g. HashSet/TreeSet)
    for (Object x : (Collection) o) {
      if (buf.length() != 0) buf.append(", ");
      buf.append(structure(x, stringSizeLimit));
    }
    return "[" + buf + "]";
  }
  
  if (o instanceof Map) {
    for (Object e : ((Map) o).entrySet()) {
      if (buf.length() != 0) buf.append(", ");
      buf.append(structure(((Map.Entry) e).getKey(), stringSizeLimit));
      buf.append("=");
      buf.append(structure(((Map.Entry) e).getValue(), stringSizeLimit));
    }
    return "{" + buf + "}";
  }
  
  if (o.getClass().isArray()) {
    int n = Array.getLength(o);
    for (int i = 0; i < n; i++) {
      if (buf.length() != 0) buf.append(", ");
      buf.append(structure(Array.get(o, i), stringSizeLimit));
    }
    return "array{" + buf + "}";
  }

  if (o instanceof String)
    return quote(stringSizeLimit != 0 ? shorten((String) o, stringSizeLimit) : (String) o);
  
  // Need more cases? This should cover all library classes...
  if (name.startsWith("java.") || name.startsWith("javax."))
    return String.valueOf(o);
    
  String shortName = o.getClass().getName().replaceAll("^main\\$", "");
  
  int numFields = 0;
  String fieldName = "";
  if (shortName.equals("DynamicObject")) {
    shortName = (String) get(o, "className");
    Map<String, Object> fieldValues = (Map) get(o, "fieldValues");
    
    for (String _fieldName : fieldValues.keySet()) {
      fieldName = _fieldName;
      Object value = fieldValues.get(fieldName);
      if (value != null) {
        if (buf.length() != 0) buf.append(", ");
        buf.append(fieldName + "=" + structure(value, stringSizeLimit));
      }
      ++numFields;
   }
  } else {
    // regular class
    // TODO: go to superclasses too
    Field[] fields = o.getClass().getDeclaredFields();
    for (Field field : fields) {
      if ((field.getModifiers() & Modifier.STATIC) != 0)
        continue;
      Object value;
      try {
        field.setAccessible(true);
        value = field.get(o);
      } catch (Exception e) {
        value = "?";
      }
      
      fieldName = field.getName();
      
      // put special cases here...
  
      if (value != null) {
        if (buf.length() != 0) buf.append(", ");
        buf.append(fieldName + "=" + structure(value, stringSizeLimit));
      }
      ++numFields;
    }
  }
  
  String b = buf.toString();
  
  if (numFields == 1 && structure_allowShortening)
    b = b.replaceAll("^" + fieldName + "=", ""); // drop field name if only one
  String s = shortName;
  if (buf.length() != 0)
    s += "(" + b + ")";
  return s;
}

  static String quote(String s) {
    if (s == null) return "null";
    return "\"" + s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\r", "\\r").replace("\n", "\\n") + "\"";
  }
  
  static String quote(long l) {
    return quote("" + l);
  }


static boolean isJavaIdentifier(String s) {
  if (s.length() == 0 || !Character.isJavaIdentifierStart(s.charAt(0)))
    return false;
  for (int i = 1; i < s.length(); i++)
    if (!Character.isJavaIdentifierPart(s.charAt(i)))
      return false;
  return true;
}

static String makeRandomID(int length) {
  Random random = new Random();
  char[] id = new char[length];
  for (int i = 0; i < id.length; i++)
    id[i] = (char) ((int) 'a' + random.nextInt(26));
  return new String(id);
}

static String shorten(String s, int max) {
  return s.length() <= max ? s : s.substring(0, Math.min(s.length(), max)) + "...";
}
}