sclass PersistentManagedObjects_v1<A extends IManagedObject> {
  replace Addr with int.
  replace BoxedAddr with Int.
  
  ManagedIntObjects_v1 mem;
  IF2<ManagedIntObjects_v1, BoxedAddr, A> makeUserObject; // user needs to fill this
  Root root;
  
  final static int
    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;
    
    ManagedIntObjects_v1 mem() { ret PersistentManagedObjects_v1.this.mem; }
    
    // initialize as wrapper for existing object
    // or create new when addr == 0
    *(Addr addr) {
      super(PersistentManagedObjects_v1.this.mem);
      if (addr != 0)
        setAddr(addr);  
      else
        create();
    }
    
    // initialize as new object
    *() {
      super(PersistentManagedObjects_v1.this.mem);
      create();
    }
    
    void create { setAddr(mem.alloc(objectSize)); init(); }
    
    void init { 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);
      print("Free list moved to " + x + " (length=" + (x == 0 ? 0 : mem.get(x)) + ")");
    }
    Addr userDataPtr() { ret mem.get(addr+ofs_userDataPtr); }
    void userDataPtr(Addr x) { mem.set(addr+ofs_userDataPtr, x); }
    A userData() {
      ret makeUserObject.get(mem, userDataPtr());
    }
    void userData(A userData) { userDataPtr(userData == null ? 0 : userData.addr()); }
    
    public void setAddr(Addr newAddr) {
      addr = newAddr; mem.setRootField(addr);
    }

    // GC handling
    public void scanForCollection(IManagedObjectCollector gc) {
      deb()?.printVars("scanForCollection", +this, +addr, +objectSize);
      gc.noteObject(0, 1, null);
      gc.noteRootPointer(0);
      gc.noteObject(addr, objectSize, lambda1 setAddr);
      //print("note freeList");
      //gc.notePointer(addr+ofs_freeListPtr);
      //gc.noteIntArray(freeListPtr()); // we're dropping it anyway (it's a compaction)
      
      print("note userDataPtr");
      gc.notePointer(addr+ofs_userDataPtr);
      var userData = userData();
      deb()?.printVars("note", +userData);
      userData?.scanForCollection(gc);
    }
  }
  
  // makes a new int[] based storage
  *(IF2<ManagedIntObjects_v1, BoxedAddr, A> makeUserObject) {
    this(new ManagedIntObjects_v1, makeUserObject);
  }
  
  *(ManagedIntObjects_v1 *mem, IF2<ManagedIntObjects_v1, BoxedAddr, A> *makeUserObject) {
    Addr rootPtr = mem.getRootField();
    print(+rootPtr);
    root = new Root(rootPtr);
    mem.freeList = FreeList.fromIntArray(mem.readIntArray(root.freeListPtr()));
  }
  
  void flush {
    if (mem.freeList.changed)
      saveFreeList();
  }
  
  void saveFreeList {
    print("Freeing old free list at " + root.freeListPtr());
    mem.freeIntArray(root.freeListPtr());
    int arraySize = (mem.freeList.size()+1)*2; // reserve space for one more entry made in the upcoming freeIntArray() call
    int sizeNeeded = 1+arraySize;
    deb()?.printVars(+arraySize, +sizeNeeded);
    Addr ptr = mem.alloc(sizeNeeded);
    deb()?.printVars(+ptr);
    mem.set(ptr, arraySize); // set length

    // now all the allocs and frees are done and we can persist
    // the FreeList
    int[] data = mem.freeList.toIntArray();
    mem.freeList.changed = false;
    
    for i to arraySize:
      mem.set(ptr+1+i, i < data.length ? data[i] : 0); // pad with zeros
    root.freeListPtr(ptr);
    print("Made new free list at " + root.freeListPtr() + " (l=" + mem.read(root.freeListPtr()) + ")");
  }
  
  A get aka getUserData() {
    ret root.userData();
  }
  
  void set aka setUserData(A userData) {
    root.userData(userData);
  }

  PersistentManagedObjects_v1<A> rotate() {
    flush();
    ret new PersistentManagedObjects_v1(mem.rotate(), makeUserObject);
  }
  
  void collectAndCompact {
    ManagedIntObjects_v1_Collector collector = new(mem);
    collector.startAddress = 0;
    mem.collectAndCompact(root, collector);
    print("Resetting freeListPtr");
    root.freeListPtr(0);
  }
}