sclass PersistentManagedObjects_v1 {
  replace Addr with int.
  
  ManagedIntObjects_v1 objectManager;
  IF1<Addr, AbstractManagedObject> makeUserObject; // user needs to fill this
  
  final static
    TYPE_STRING = -1,
    TYPE_INTARRAY = -2,
    TYPE_ROOT = -3;
  
  class Root extends AbstractManagedObject {
    final static int
      ofs_type = 0,
      ofs_version = 1,
      ofs_freeListPtr = 2,
      ofs_userDataPtr = 3;
    final static int objectSize = ofs_userDataPtr+1;
    
    // initialize as wrapper for existing object
    *(Addr addr) { super(addr); }
    
    // initialize as new object
    *() { addr = mem.alloc(objectSize); type(TYPE_ROOT); version(1); }
    
    // getters + setters
    int type() { ret mem.get(addr+ofs_type); }
    void type(int x) { mem.set(addr+ofs_type, x); }
    int version() { ret mem.get(addr+ofs_version); }
    void version(int x) { mem.set(addr+ofs_version, x); }
    Addr freeListPtr() { ret mem.get(addr+ofs_freeListPtr); }
    void freeListPtr(Addr x) { mem.set(addr+ofs_freeListPtr, x); }
    Addr children_ptr() { ret mem.get(addr+ofs_children); }

    // GC handling
    public void scanForCollection(IManagedObjectCollector gc) {
      gc.noteObject(addr, objectSize, newAddr -> { addr = newAddr; });
      gc.notePointer(addr+ofs_freeListPtr);
      gc.notePointer(addr+ofs_freeDataPtr);
      gc.noteIntArray(freeListPtr());
      for (Node n : children())
        makeUser
    }
    
    // other methods
    
    L<Int> text(IntSuffixTree_managed tree) { ret subList(tree.fullText, from(), to()); }
    
    int lText() { ret to()-from(); }
    
    bool isTerminal(IntSuffixTree_managed tree) { ret to() == l(tree.fullText); }
    
    void setChildren(IntSuffixTree_managed tree, L<Node> nodes) {
      mem.freePointerArray(children_ptr());
      children(mem.newPointerArray(l(nodes));
      for i over nodes:
        children().set(i, nodes.get(i));
      sortInPlace(children(), tree.childComparator);
    }
    
    void addChild(IntSuffixTree_managed tree, Node n) {
      Addr oldChildren = children_ptr();
      int i = l(children());
      //print(children_ptr := children_ptr() + ", l=" + l(children()));
      children(mem.resizePointerArray(oldChildren, i+1);
      //print(children_ptr := children_ptr() + ", l=" + l(children()));
      mem.freePointerArray(oldChildren);
      children().set(i, n);
      sortInPlace(children(), tree.childComparator);
    }
    
    public int firstCharOrMinus1(IntSuffixTree_managed tree) {
      ret firstOrMinus1(text(tree));
    }
    
    Node getChild(IntSuffixTree_managed tree, int c) {
      L<Node> children = children();
      int i = generalizedBinarySearch2(children, n -> cmp(n.firstCharOrMinus1(tree), c));
      ret i >= 0 ? children.get(i) : null;
    }
    
    toString { ret "Node@" + addr + ", " + from() + "/" + lText() + ". " + nChildren(children()); }
  }

}