static Object unstructure(String text) {

  ret unstructure(text, false);

}

static Object unstructure(String text, final boolean allDynamic) {

  ret unstructure(text, allDynamic, null);

}

static int structure_internStringsLongerThan = 50;

// classFinder: func(name) -> class (optional)

static Object unstructure(String text, final boolean allDynamic,

  final O classFinder) {

  if (text == null) ret null;

  final L<S> tok = javaTokC(text);

  final boolean debug = unstructure_debug;

  class X {

    int i = 0;

    new HashMap<Integer, O> refs;

    new HashMap<Integer, O> tokrefs;

    new HashSet<S> concepts;

    new HashMap<S, Class> classesMap;

    Object parse() {

      String t = tok.get(i);

      int refID = 0;

      if (structure_isMarker(t, 0, l(t))) {

        refID = parseInt(t.substring(1));

        i++;

      }

      // if (debug) print("parse: " + quote(t));

      int tokIndex = i;  

      O o = parse_inner(refID, tokIndex);

      if (refID != 0)

        refs.put(refID, o);

      if (o != null)

        tokrefs.put(tokIndex, o);

      ret o;

    }

    O parse_inner(int refID, int tokIndex) {

      String t = tok.get(i);

      // if (debug) print("parse_inner: " + quote(t));

      Class c = classesMap.get(t);

      if (c == null) {

        if (t.startsWith("\"")) {

          String s = internIfLongerThan(unquote(tok.get(i)), structure_internStringsLongerThan);

          i++;

          return s;

        }

        if (t.startsWith("'"))

          ret unquoteCharacter(tok.get(i++));

        if (t.equals("bigint"))

          return parseBigInt();

        if (t.equals("d"))

          return parseDouble();

        if (t.equals("fl"))

          return parseFloat();

        if (t.equals("false") || t.equals("f")) {

          i++; return false;

        }

        if (t.equals("true") || t.equals("t")) {

          i++; return true;

        }

        if (t.equals("-")) {

          t = tok.get(i+1);

          i += 2;

          ret isLongConstant(t) ? (O) (-parseLong(t)) : (O) (-parseInt(t));

        }

        if (isInteger(t) || isLongConstant(t)) {

          i++;

          //if (debug) print("isLongConstant " + quote(t) + " => " + isLongConstant(t));

          if (isLongConstant(t)) ret parseLong(t);

          long l = parseLong(t);

          bool isInt = l == (int) l;

          if (debug)

            print("l=" + l + ", isInt: " + isInt);

          ret isInt ? (O) new Integer((int) l) : (O) new Long(l);

        }

        if (t.equals("File")) {

          File f = new File(unquote(tok.get(i+1)));

          i += 2;

          ret f;

        }

        if (t.startsWith("r") && isInteger(t.substring(1))) {

          i++;

          int ref = Integer.parseInt(t.substring(1));

          O o = refs.get(ref);

          if (o == null)

            print("Warning: unsatisfied back reference " + ref);

          ret o;

        }

        if (t.startsWith("t") && isInteger(t.substring(1))) {

          i++;

          int ref = Integer.parseInt(t.substring(1));

          O o = tokrefs.get(ref);

          if (o == null)

            print("Warning: unsatisfied token reference " + ref);

          ret o;

        }

        if (t.equals("hashset"))

          return parseHashSet();

        if (t.equals("treeset"))

          return parseTreeSet();

        if (eqOneOf(t, "hashmap", "hm"))

          return parseHashMap();

        if (t.equals("{"))

          return parseMap();

        if (t.equals("["))

          return parseList();

        if (t.equals("bitset"))

          return parseBitSet();

        if (t.equals("array") || t.equals("intarray"))

          return parseArray();

        if (t.equals("ba")) {

          S hex = unquote(tok.get(i+1));

          i += 2;

          ret hexToBytes(hex);

        }

        if (t.equals("boolarray")) {

          int n = parseInt(tok.get(i+1));

          S hex = unquote(tok.get(i+2));

          i += 6;

          ret boolArrayFromBytes(hexToBytes(hex), n);

        }

        if (t.equals("class"))

          return parseClass();

        if (t.equals("l"))

          return parseLisp();

        if (t.equals("null")) {

          i++; return null;

        }

        /* in dev.

        if (!allDynamic && t.equals("run")) {

          S snippetID = unquote(t.get(i+1));

          i += 2;

          run(

        }

        */

        if (eq(t, "c")) {

          consume("c");

          t = tok.get(i);

          assertTrue(isJavaIdentifier(t));

          concepts.add(t);

        }

      }

      if (c == null && !isJavaIdentifier(t))

        throw new RuntimeException("Unknown token " + (i+1) + ": " + t);

      // any other class name

      if (c == null) {

        // First, find class

        if (allDynamic) c = null;

        else if (classFinder != null)

          c = (Class) callF(classFinder, t);

        else

          c = findClass(t);

        if (c != null)

          classesMap.put(t, c);

      }

      // Check if it has an outer reference

      i++;

      bool hasOuter = eq(get(tok, i), "(") && eq(get(tok, i+1), "this$1");

      DynamicObject dO = null;

      O o = null;

      if (c != null)

        o = hasOuter ? nuStubInnerObject(c) : nuEmptyObject(c);

      else {

        if (concepts.contains(t) && (c = findClass("Concept")) != null)

          o = dO = (DynamicObject) nuEmptyObject(c);

        else

          dO = new DynamicObject;

        dO.className = t;

        if (debug) print("Made dynamic object " + t + " " + shortClassName(dO));

      }

      // Save in references list early because contents of object

      // might link back to main object

      if (refID != 0)

        refs.put(refID, o != null ? o : dO);

      tokrefs.put(tokIndex, o != null ? o : dO);

      // NOW parse the fields!

      new Map<S, O> fields;

      if (i < tok.size() && tok.get(i).equals("(")) {

        consume("(");

        while (!tok.get(i).equals(")")) {

          String key = unquote(tok.get(i));

          i++;

          consume("=");

          Object value = parse();

          fields.put(key, value);

          if (tok.get(i).equals(",")) i++;

        }

        consume(")");

      }

      if (o != null)

        if (dO != null) {

          if (debug)

            printStructure("setOptAllDyn", fields);

          setOptAllDyn(dO, fields);

        } else

          setOptAll(o, fields);

      else for (S field : keys(fields))

        dO.fieldValues.put(field.intern(), fields.get(field));

      if (o != null)

        pcallOpt_noArgs(o, "_doneLoading");

      return o != null ? o : dO;

    }

    Object parseSet(Set set) {

      set.addAll((L) parseList());

      return set;

    }

    Object parseLisp() {

      consume("l");

      consume("(");

      new ArrayList list;

      while (!tok.get(i).equals(")")) {

        list.add(parse());

        if (tok.get(i).equals(",")) i++;

      }

      consume(")");

      return newObject("main$Lisp", (S) list.get(0), subList(list, 1));

    }

    Object parseBitSet() {

      consume("bitset");

      consume("{");

      new BitSet bs;

      while (!tok.get(i).equals("}")) {

        bs.set((Integer) parse());

        if (tok.get(i).equals(",")) i++;

      }

      consume("}");

      return bs;

    }

    Object parseList() {

      consume("[");

      new ArrayList list;

      while (!tok.get(i).equals("]")) {

        O o = parse();

        //if (debug) print("List element type: " + getClassName(o));

        list.add(o);

        if (tok.get(i).equals(",")) i++;

      }

      consume("]");

      return list;

    }

    Object parseArray() {

      S type = tok.get(i);

      i++;

      consume("{");

      List list = new ArrayList;

      while (!tok.get(i).equals("}")) {

        list.add(parse());

        if (tok.get(i).equals(",")) i++;

      }

      consume("}");

      if (type.equals("intarray"))

        return toIntArray(list);

      return list.toArray();

    }

    Object parseClass() {

      consume("class");

      consume("(");

      S name = tok.get(i);

      i++;

      consume(")");

      Class c = allDynamic ? null : findClass(name);

      if (c != null) ret c;

      new DynamicObject dO;

      dO.className = "java.lang.Class";

      dO.fieldValues.put("name", name);

      ret dO;

    }

    Object parseBigInt() {

      consume("bigint");

      consume("(");

      S val = tok.get(i);

      i++;

      if (eq(val, "-")) {

        val = "-" + tok.get(i);

        i++;

      }

      consume(")");

      ret new BigInteger(val);

    }

    Object parseDouble() {

      consume("d");

      consume("(");

      S val = unquote(tok.get(i));

      i++;

      consume(")");

      ret Double.parseDouble(val);

    }

    Object parseFloat() {

      consume("fl");

      S val;

      if (eq(tok.get(i), "(")) {

        consume("(");

        val = unquote(tok.get(i));

        i++;

        consume(")");

      } else {

        val = unquote(tok.get(i));

        i++;

      }

      ret Float.parseFloat(val);

    }

    Object parseHashMap() {

      i++;

      return parseMap(new HashMap);

    }

    Object parseHashSet() {

      consume("hashset");

      return parseSet(new HashSet);

    }

    Object parseTreeSet() {

      consume("treeset");

      return parseSet(new TreeSet);

    }

    Object parseMap() {

      return parseMap(new TreeMap);

    }

    Object parseMap(Map map) {

      consume("{");

      while (!tok.get(i).equals("}")) {

        O key = parse();

        consume("=");

        Object value = parse();

        map.put(key, value);

        if (tok.get(i).equals(",")) i++;

      }

      consume("}");

      return map;

    }

    void consume(String s) {

      if (!tok.get(i).equals(s)) {

        S prevToken = i-1 >= 0 ? tok.get(i-1) : "";

        S nextTokens = join(tok.subList(i, Math.min(i+2, tok.size())));

        fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")");

      }

      i++;

    }

  }

  return new X().parse();

}

static boolean unstructure_debug;