sclass SortedStringMap_managed extends AbstractManagedObject {

  replace Addr with int.

  new TreeMap<S, Entry> map;

  int physicalLength; // total array length is twice this. data is: String *key, String *value, ...

  int size; // our actual length

  // it's actually a union

  class Entry {

    int index; // also when not loaded

    S value;   // only when loaded

    *(int *index) {}

    *(int *index, S *value) {}

    S value() {

      if (value == null)

        value = mem.readString(valueAddr(index));

      ret value;

    }

  }

  int size() { ret l(map); }

  int arrayStart() { ret addr+2; }

  int keyAddr(int i) { ret arrayStart()+i*2; }

  int valueAddr(int i) { ret arrayStart()+i*2+1; }

  // read from memory

  *(ManagedIntObjects_v1 *mem, Addr *addr) {

    physicalLength = mem.get(addr);

    size = mem.get(addr+1);

    for i to size:

      map.put(mem.readString(keyAddr(i)), new Entry(valueAddr(i)));

  }

  *(ManagedIntObjects_v1 *mem, SS initialData) {

    SS sorted;

    if (initialData instanceof TreeMap) {

      map.setComparator(initialData.comparator());

      sorted = initialData;

    } else

      sorted = new TreeMap(unnull(initialData), map.comparator());

    physicalLength = l(sorted);

    alloc(objectSize());

    mem.set(addr, physicalLength);

    int i = 0;

    for (S key, S value : sorted)

      map.put(key, new Entry(i++, value));

    flush();

  }

  void flush {

    ensureCapacityInternal(size());

    mem.set(addr+1, size());

    int i = 0;

    for (S key, Entry entry : map) {

      int keyPtr = mem.get(keyAddr(i));

      if (!eq(mem.readString(keyPtr), key)) {

        mem.freeString(keyAddr(i)); // strings belong to map

        mem.set(keyAddr(i), mem.newString(key));

      }

      int valuePtr = mem.get(valueAddr(i));

      if (entry.index != i

        || entry.value != null && !eq(entry.value

      if (!eq(mem.readString(valuePtr), entry.value())) {

        mem.freeString(valueAddr(i)); // strings belong to map

        mem.set(valueAddr(i), mem.newString(key));

      }

      map.put(key, new Entry(i++, value));

    }

  }

  void ensureCapacityInternal(int minCapacity) {

    if (physicalLength < minCapacity) grow(minCapacity);

  }

  private void grow(int minCapacity) {

    int oldCapacity = physicalLength;

    int newCapacity = oldCapacity + (oldCapacity >> 1);

    if (newCapacity - minCapacity < 0)

      newCapacity = minCapacity;

    long oldAddr = addr, oldSize = objectSize();

    physicalLength = newCapacity;

    setAddr(mem.alloc(objectSize()));

    for (int i = 1; i < oldSize; i++)

      mem.set(addr+i, mem.get(oldAddr+i));

    mem.free(oldAddr, oldSize);

    mem.set(addr, physicalLength);

  }

  // GC handling

  public void scanForCollection(IManagedObjectCollector gc) {

    gc.noteObject(addr, objectSize());

  } 

  int objectSize() { ret 2+physicalLength*2; }

}