diff --git a/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Arraylet.java b/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Arraylet.java
index 50b28bb..7eecfd8 100644
--- a/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Arraylet.java
+++ b/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Arraylet.java
@@ -12,165 +12,253 @@
  */
 
 class Arraylet<BaseType> extends ExtrememObject {
-  private final int length;         // Number of elements in Arraylet
-  private final int max_length;     // Max array length
-  private final int num_tiers;      // How may levels in fan-out structure?
-  private final int top_entry_span; // Each element of root spans this many
-  private final Object[] root;      // Root of fan-out structure
-  private int total_arrays;
-  private int total_array_elements;
+  // We use max_arraylet_length for the typical segment size and the typical index size.  We only truncate the
+  // last array segment and the last indexing segment at each indexing level.
+  private final int max_arraylet_length;
+  private final int length;               // Number of elements in Arraylet
+  private final int num_segments;         // Total number of array segments representing the elements of this Arraylet
+  private final int indexing_tiers;       // How many levels of indexing arrays, which is at least 1
+
+  private final int[] index_entry_span;
+  private final Object[] root_index;      // if max_arraylet_length > 0, points to root index
+  private final BaseType[] root_segment;  // if max_arraylet_length == 0, points to contiguous array representaiton
 
   Arraylet(ExtrememThread t, LifeSpan ls, int max_length, int length) {
     super(t, ls);
     Polarity Grow = Polarity.Expand;
+    Polarity Shrink = Polarity.Shrink;
     MemoryLog memory = t.memoryLog();
+    if ((max_length != 0) && (max_length < 4)) {
+      Exception x = new IllegalArgumentException(Integer.toString(max_length));
+      Util.fatalException("Maximum arraylet size must be >= 4)", x);
+    }
+    this.max_arraylet_length = max_length;
     this.length = length;
-    if (max_length == 0) {
-      this.max_length = length;
-      this.num_tiers = 1;
-      this.total_arrays = 2;
-      this.total_array_elements = length + 1;
-      Object[] array = new Object[length];
-      root = new Object[1];
-      root[0] = array;
-      this.top_entry_span = length;
-    } else {
-      this.max_length = max_length;
-      this.total_arrays = 0;
-      this.total_array_elements = 0;
-      int num_tiers = 1;
-      // At bottom tier of fan-out structure, each entry spans this
-      // many ArrayLet elements.
-      int span_of_entry = max_length;
-      while (span_of_entry * max_length < length) {
-        num_tiers++;
-        span_of_entry *= max_length;
-      }
-      this.num_tiers = num_tiers;
-      this.top_entry_span = span_of_entry;
-
-      int[] counts = new int[num_tiers];
-      Object[][] arrays = new Object[num_tiers][];
-
-      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Grow, 2);
-      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB,
-                        Grow, num_tiers * Util.SizeOfInt);
-      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference,
-                        Grow, num_tiers);
-
-      for (int i = 0; i < num_tiers; i++) {
-        arrays[i] = new Object[max_length];
-        this.total_arrays++;
-        this.total_array_elements += max_length;
-        if (i > 0) {
-          arrays[i-1][0] = arrays[i];
-          counts[i-1] = 1;
-        }
-      }
-      this.root = arrays[0];
-      int num_leaf_arrays = (length + max_length - 1) / max_length;
-      for (int i = 0; i < num_leaf_arrays; i++) {
-        Object[] element_array = new Object[max_length];
-        this.total_arrays++;
-        this.total_array_elements += max_length;
-        adjustForNewLeaf(counts, arrays);
-        arrays[num_tiers-1][counts[num_tiers-1]-1] = element_array;
+    if (max_arraylet_length != 0) {
+      // At bottom indexing tier, each index element represents max_arraylet_length number of array elements
+      // At second indexing tier, each index element represents max_arraylet_length * max_arraylet_length
+      // At level N (with bottom equal to zero), each index element represents max_arraylet_length * max_arraylet_length ^ N
+      int index_levels = 1;
+      long potential_span = max_arraylet_length * (long) max_arraylet_length;
+      while (potential_span < length) {
+        index_levels++;
+        potential_span *= max_arraylet_length;
       }
+      indexing_tiers = index_levels;
+      num_segments = (length + max_arraylet_length - 1) / max_arraylet_length;
+      index_entry_span = new int[indexing_tiers];
 
-      MemoryLog garbage = t.garbageLog();
-      garbage.accumulate(LifeSpan.Ephemeral,
-                         MemoryFlavor.ArrayObject, Grow, 2);
-      garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB,
-                         Grow, num_tiers * Util.SizeOfInt);
-      garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference,
-                         Grow, num_tiers);
-    }
-    // Account for 6 ints: length, max_length, num_tiers, top_entry_span,
-    // total_arrays, total_array_elements
-    memory.accumulate(ls, MemoryFlavor.ObjectRSB, Grow, 6 * Util.SizeOfInt);
-    // Account for root
-    memory.accumulate(ls, MemoryFlavor.ObjectReference, Grow, 1);
+      // index_entry_span
+      memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB, Grow, indexing_tiers * Util.SizeOfInt);
 
+      int[] initialized_segments = new int[indexing_tiers];
+      int[] initialized_indices = new int[indexing_tiers];
+      int[] index_segment_span = new int[indexing_tiers];
+      Object[][] initialization_index = new Object[indexing_tiers][];
 
-    memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, total_arrays);
-    memory.accumulate(ls, MemoryFlavor.ArrayReference,
-                      Grow, total_array_elements);
-  }
+      // initialization_index, initialized_segments, initialized_indices, index_segment_span 
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Grow, 4);
 
-  private final void adjustForNewLeaf(int[] counts, Object[][] arrays) {
-    int focus_level = num_tiers - 1;
-    if (counts[focus_level] < max_length) {
-      counts[focus_level]++;
-    } else {
-      while ((focus_level > 0) && (counts[focus_level] >= max_length)) {
-        arrays[focus_level] = new Object[max_length][];
-        this.total_arrays++;
-        this.total_array_elements += max_length;
-        counts[focus_level] = 1;
-        if (focus_level < num_tiers - 1)
-          arrays[focus_level][0] = arrays[focus_level+1];
-        focus_level--;
+      // initialization_index
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Grow, indexing_tiers);
+
+      // initialized_segments, initialized_indices, index_segment_span
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB, Grow, 3 * indexing_tiers * Util.SizeOfInt);
+
+      index_entry_span[0] = max_arraylet_length;
+      index_segment_span[0] = max_arraylet_length * max_arraylet_length;
+      initialized_segments[0] = 0;
+      initialized_indices[0] = 0;
+
+      for (int i = 1; i < indexing_tiers; i++) {
+        index_entry_span[i] = index_segment_span[i-1];
+        index_segment_span[i] = index_entry_span[i] * max_arraylet_length;
+        initialized_segments[i] = 0;
+        initialized_indices[i] = 0;
+        initialization_index[i] = null;
       }
-      if (focus_level < num_tiers - 1) {
-        arrays[focus_level][counts[focus_level]] = arrays[focus_level+1];
-        counts[focus_level]++;
+
+      int total_segment_span = 0;
+      for (int i = 0; i < num_segments; i++) {
+        if (total_segment_span >= length) {
+          // Do I want an assertion failure here?
+          break;
+        } else {
+          Object[] new_segment;
+          if (total_segment_span + max_arraylet_length < length) {
+            new_segment = new Object[max_arraylet_length];
+            total_segment_span += max_arraylet_length;
+          } else {
+            new_segment = new Object[length - total_segment_span];
+            total_segment_span = length;
+          }
+          // new_segment
+          memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+          memory.accumulate(ls, MemoryFlavor.ArrayReference, Grow, new_segment.length);
+      
+          if (initialized_indices[0] == 0) {
+            // Need to allocate the level-0 index segment
+            int unspanned = length - initialized_segments[0] * index_segment_span[0];
+            if (unspanned >= index_segment_span[0]) {
+              initialization_index[0] = new Object[max_arraylet_length];
+            } else {
+              int roundup = (unspanned + index_entry_span[0] - 1) / index_entry_span[0];
+              initialization_index[0] = new Object[roundup];
+            }
+            // new level-0 index segment
+            memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+            memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Grow, initialization_index[0].length);
+          }
+          initialization_index[0][initialized_indices[0]] = new_segment;
+          initialized_indices[0] += 1;
+          if (initialized_indices[0] >= max_arraylet_length) {
+            initialized_segments[0] += 1;
+            initialized_indices[0] = 0;
+          }
+
+          for (int update_tier = 1; update_tier < indexing_tiers; update_tier++) {
+            if (initialized_indices[update_tier - 1] != 1) {
+              // We only need to update parent indices if the lower level was just expanded
+              break;
+            }
+            if (initialized_indices[update_tier] == 0) {
+              // Need to allocate a new level-N index segment
+              int unspanned = length - initialized_segments[update_tier] * index_segment_span[update_tier];
+              if (unspanned >= index_segment_span[update_tier]) {
+                initialization_index[update_tier] = new Object[max_arraylet_length];
+              } else {
+                int roundup = (unspanned + index_entry_span[update_tier] - 1) / index_entry_span[update_tier];
+                initialization_index[update_tier] = new Object[roundup];
+              }
+              // new index segment at level update_tier
+              memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+              memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Grow, initialization_index[update_tier].length);
+            }
+            initialization_index[update_tier][initialized_indices[update_tier]] = initialization_index[update_tier - 1];
+            initialized_indices[update_tier] += 1;
+            if (initialized_indices[update_tier] >= max_arraylet_length) {
+              initialized_segments[update_tier] += 1;
+              initialized_indices[update_tier] = 0;
+            }
+          }
+        }
       }
+
+      // initialization_index,initialized_segments, initialized_indices, index_segment_span
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Shrink, 4);
+
+      // initialization_index
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Shrink, indexing_tiers);
+
+      // initialized_segments, initialized_indices, index_segment_span
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB, Shrink, 3 * indexing_tiers * Util.SizeOfInt);
+      root_index = initialization_index[indexing_tiers - 1];
+      root_segment = null;
+    } else {
+      num_segments = 1;
+      indexing_tiers = 0;
+      index_entry_span = null;
+      root_index = null;
+      root_segment = (BaseType[]) new Object[length];
+      // new root_segment
+      memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+      memory.accumulate(ls, MemoryFlavor.ArrayReference, Grow, length);
     }
+
+    // Account for 4 ints: length, max_arraylet_length, num_segments, indexing_tiers
+    memory.accumulate(ls, MemoryFlavor.ObjectRSB, Grow, 4 * Util.SizeOfInt);
+
+    // Account for root_index, root_segment, index_entry_span
+    memory.accumulate(ls, MemoryFlavor.ObjectReference, Grow, 3);
   }
 
   final BaseType get(int at) {
     if ((at < 0) || (at >= length)) {
       Exception x = new ArrayIndexOutOfBoundsException(at);
       Util.fatalException("Index out of bounds in Arraylet.get", x);
+      // Not reached
     }
-    Object[] fan_out_node = root;
-    int entry_span = top_entry_span;
-    for (int i = 1; i < num_tiers; i++) {
-      fan_out_node = (Object []) fan_out_node[at / entry_span];
-      at %= entry_span;
-      entry_span /= max_length;
+    if (max_arraylet_length == 0) {
+      return root_segment[at];
+    } else {
+      int tier = indexing_tiers - 1;
+      int index = at / index_entry_span[tier];
+      int remainder = at % index_entry_span[tier];
+      Object[] index_segment = root_index;
+      while (tier-- > 0) {
+        index_segment = (Object[]) index_segment[index];
+        index = remainder / index_entry_span[tier];
+        remainder = remainder % index_entry_span[tier];
+      }
+      BaseType[] data_segment = (BaseType[]) index_segment[index];
+      return data_segment[remainder];
     }
-    BaseType[] elements = (BaseType []) fan_out_node[at / max_length];
-    return elements[at % max_length];
   }
 
   final void set(int at, BaseType value) {
     if ((at < 0) || (at >= length)) {
       Exception x = new ArrayIndexOutOfBoundsException(at);
       Util.fatalException("Index out of bounds in Arraylet.get", x);
+    } else if (max_arraylet_length == 0) {
+      root_segment[at] = value;
+    } else {
+      int tier = indexing_tiers - 1;
+      int index = at / index_entry_span[tier];
+      int remainder = at % index_entry_span[tier];
+      Object[] index_segment = root_index;
+      while (tier-- > 0) {
+        index_segment = (Object[]) index_segment[index];
+        index = remainder / index_entry_span[tier];
+        remainder = remainder % index_entry_span[tier];
+      }
+      BaseType[] data_segment = (BaseType[]) index_segment[index];
+      data_segment[remainder] = value;
     }
-    Object[] fan_out_node = root;
-    int entry_span = top_entry_span;
-    for (int i = 1; i < num_tiers; i++) {
-      fan_out_node = (Object []) fan_out_node[at / entry_span];
-      at %= entry_span;
-      entry_span /= max_length;
-    }
-    BaseType[] elements = (BaseType[]) fan_out_node[at / max_length];
-    elements[at % max_length] = value;
   }
 
   final int length() {
     return length;
   }
 
+  private void helpTallyMemory(MemoryLog log, LifeSpan ls, Polarity p, Object[] index_segment, int tier) {
+    log.accumulate(ls, MemoryFlavor.ArrayObject, p, 1);
+    log.accumulate(ls, MemoryFlavor.ArrayReference, p, index_segment.length);
+
+    if (tier > 1) {
+      for (int i = 0; i < index_segment.length; i++) {
+        Object[] sub_index_segment = (Object[]) index_segment[i];
+        helpTallyMemory(log, ls, p, sub_index_segment, tier-1);
+      }
+    } else {
+      log.accumulate(ls, MemoryFlavor.ArrayObject, p, index_segment.length);;
+      for (int i = 0; i < index_segment.length; i++) {
+        BaseType[] data_segment = (BaseType[]) index_segment[i];
+        if (data_segment != null) {
+          log.accumulate(ls, MemoryFlavor.ArrayReference, p, data_segment.length);
+        }
+      }
+    }
+  }
+
   void tallyMemory(MemoryLog log, LifeSpan ls, Polarity p) {
     super.tallyMemory(log, ls, p);
 
-    // Account for 6 ints: length, max_length, num_tiers, top_entry_span,
-    // total_arrays, total_array_elements
-    log.accumulate(ls, MemoryFlavor.ObjectRSB, p, 6 * Util.SizeOfInt);
-    // Account for root
-    log.accumulate(ls, MemoryFlavor.ObjectReference, p, 1);
+    // Account for 4 ints: length, max_arraylet_length, num_segments, indexing_tiers
+    log.accumulate(ls, MemoryFlavor.ObjectRSB, p, 4 * Util.SizeOfInt);
 
+    // Account for root_index, root_segment, index_entry_span
+    log.accumulate(ls, MemoryFlavor.ObjectReference, p, 3);
 
-    log.accumulate(ls, MemoryFlavor.ArrayObject, p, this.total_arrays);
-    log.accumulate(ls, MemoryFlavor.ArrayReference,
-                   p, this.total_array_elements);
+    if (max_arraylet_length == 0) {
+      log.accumulate(ls, MemoryFlavor.ArrayObject, p, 1);
+      log.accumulate(ls, MemoryFlavor.ArrayReference, p, length);
+    } else {
+      helpTallyMemory(log, ls, p, root_index, indexing_tiers);
+    }
   }
 
   public static void main(String args[]) {
-    Trace.debug("Testing Arraylet with max size 4");
 
     // Instantiate but do not run the Bootstrap thread.  Just need a
     // a placeholder for memory accounting.
@@ -178,6 +266,7 @@ public static void main(String args[]) {
     Arraylet<Long> a;
 
     try {
+      Trace.debug("Testing Arraylet with max size 4");
       a = new Arraylet<Long>(t, LifeSpan.Ephemeral, 4, 56);
       for (int i = 0; i < 56; i++)
         a.set(i, new Long(-10 * i));
@@ -192,6 +281,7 @@ public static void main(String args[]) {
     }
 
     try {
+      Trace.debug("Testing Arraylet with max size 7");
       a = new Arraylet<Long>(t, LifeSpan.Ephemeral, 7, 61);
       for (int i = 0; i < 61; i++)
         a.set(i, new Long(-10 * i));
@@ -207,6 +297,7 @@ public static void main(String args[]) {
     }
 
     try {
+      Trace.debug("Testing Arraylet with max size 0");
       a = new Arraylet<Long>(t, LifeSpan.Ephemeral, 0, 61);
       for (int i = 0; i < 61; i++)
         a.set(i, new Long(-10 * i));
diff --git a/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/ArrayletOflong.java b/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/ArrayletOflong.java
index fb8beb4..ef26169 100644
--- a/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/ArrayletOflong.java
+++ b/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/ArrayletOflong.java
@@ -12,171 +12,254 @@
  */
 
 class ArrayletOflong extends ExtrememObject {
-  private final int length;         // Number of elements in Arraylet
-  private final int max_length;     // Max array length
-  private final int num_tiers;      // How may levels in fan-out structure?
-  private final int top_entry_span; // Each element of root spans this many
-  private final Object[] root;      // Root of fan-out structure
-  private int total_arrays;
-  private int total_array_ref_elements;
-  private int total_array_long_elements;
+  // We use max_arraylet_length for the typical segment size and the typical index size.  We only truncate the
+  // last array segment and the last indexing segment at each indexing level.
+  private final int max_arraylet_length;
+  private final int length;               // Number of elements in Arraylet
+  private final int num_segments;         // Total number of array segments representing the elements of this Arraylet
+  private final int indexing_tiers;       // How many levels of indexing arrays, which is at least 1
+
+  private final int[] index_entry_span;
+  private final Object[] root_index;      // if max_arraylet_length > 0, points to root index
+  private final long[] root_segment;      // if max_arraylet_length == 0, points to contiguous array representaiton
 
   ArrayletOflong (ExtrememThread t, LifeSpan ls, int max_length, int length) {
     super(t, ls);
     Polarity Grow = Polarity.Expand;
+    Polarity Shrink = Polarity.Shrink;
     MemoryLog memory = t.memoryLog();
+    if ((max_length != 0) && (max_length < 4)) {
+      Exception x = new IllegalArgumentException(Integer.toString(max_length));
+      Util.fatalException("Maximum arraylet size must be >= 4)", x);
+    }
+    this.max_arraylet_length = max_length;
     this.length = length;
-    if (max_length == 0) {
-      this.max_length = length;
-      this.num_tiers = 1;
-      this.total_arrays = 2;
-      this.total_array_ref_elements = 1;
-      this.total_array_long_elements = length;
-      long[] array = new long[length];
-      root = new Object[1];
-      root[0] = array;
-      this.top_entry_span = length;
-    } else {
-      this.max_length = max_length;
-      this.total_arrays = 0;
-      this.total_array_ref_elements = 0;
-      this.total_array_long_elements = 0;
-      int num_tiers = 1;
-      // At bottom tier of fan-out structure, each entry spans this
-      // many ArrayLet elements.
-      int span_of_entry = max_length;
-      while (span_of_entry * max_length < length) {
-        num_tiers++;
-        span_of_entry *= max_length;
+    if (max_arraylet_length != 0) {
+      // At bottom indexing tier, each index element represents max_arraylet_length number of array elements
+      // At second indexing tier, each index element represents max_arraylet_length * max_arraylet_length
+      // At level N (with bottom equal to zero), each index element represents max_arraylet_length * max_arraylet_length ^ N
+      int index_levels = 1;
+      long potential_span = max_arraylet_length * (long) max_arraylet_length;
+      while (potential_span < length) {
+        index_levels++;
+        potential_span *= max_arraylet_length;
       }
-      this.num_tiers = num_tiers;
-      this.top_entry_span = span_of_entry;
-
-      int[] counts = new int[num_tiers];
-      Object[][] arrays = new Object[num_tiers][];
-
-      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Grow, 2);
-      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB,
-                        Grow, num_tiers * Util.SizeOfInt);
-      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference,
-                        Grow, num_tiers);
-
-      for (int i = 0; i < num_tiers; i++) {
-        arrays[i] = new Object[max_length];
-        this.total_arrays++;
-        this.total_array_ref_elements += max_length;
-        if (i > 0) {
-          arrays[i-1][0] = arrays[i];
-          counts[i-1] = 1;
-        }
+      indexing_tiers = index_levels;
+      num_segments = (length + max_arraylet_length - 1) / max_arraylet_length;
+      index_entry_span = new int[indexing_tiers];
+
+      // index_entry_span
+      memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB, Grow, indexing_tiers * Util.SizeOfInt);
+
+      int[] initialized_segments = new int[indexing_tiers];
+      int[] initialized_indices = new int[indexing_tiers];
+      int[] index_segment_span = new int[indexing_tiers];
+      Object[][] initialization_index = new Object[indexing_tiers][];
+
+      // initialization_index, initialized_segments, initialized_indices, index_segment_span 
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Grow, 4);
+
+      // initialization_index
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Grow, indexing_tiers);
+
+      // initialized_segments, initialized_indices, index_segment_span
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB, Grow, 3 * indexing_tiers * Util.SizeOfInt);
+
+      index_entry_span[0] = max_arraylet_length;
+      index_segment_span[0] = max_arraylet_length * max_arraylet_length;
+      initialized_segments[0] = 0;
+      initialized_indices[0] = 0;
+
+      for (int i = 1; i < indexing_tiers; i++) {
+        index_entry_span[i] = index_segment_span[i-1];
+        index_segment_span[i] = index_entry_span[i] * max_arraylet_length;
+        initialized_segments[i] = 0;
+        initialized_indices[i] = 0;
+        initialization_index[i] = null;
       }
-      this.root = arrays[0];
-      int num_leaf_arrays = (length + max_length - 1) / max_length;
-      for (int i = 0; i < num_leaf_arrays; i++) {
-        long[] element_array = new long[max_length];
-        this.total_arrays++;
-        this.total_array_long_elements += max_length;
-        adjustForNewLeaf(counts, arrays);
-        arrays[num_tiers-1][counts[num_tiers-1]-1] = (Object) element_array;
+
+      int total_segment_span = 0;
+      for (int i = 0; i < num_segments; i++) {
+        if (total_segment_span >= length) {
+          // Do I want an assertion failure here?
+          break;
+        } else {
+          long[] new_segment;
+          if (total_segment_span + max_arraylet_length < length) {
+            new_segment = new long[max_arraylet_length];
+            total_segment_span += max_arraylet_length;
+          } else {
+            new_segment = new long[length - total_segment_span];
+            total_segment_span = length;
+          }
+          // new_segment
+          memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+          memory.accumulate(ls, MemoryFlavor.ArrayRSB, Grow, new_segment.length * Util.SizeOfLong);
+      
+          if (initialized_indices[0] == 0) {
+            // Need to allocate the level-0 index segment
+            int unspanned = length - initialized_segments[0] * index_segment_span[0];
+            if (unspanned >= index_segment_span[0]) {
+              initialization_index[0] = new Object[max_arraylet_length];
+            } else {
+              int roundup = (unspanned + index_entry_span[0] - 1) / index_entry_span[0];
+              initialization_index[0] = new Object[roundup];
+            }
+            // new level-0 index segment
+            memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+            memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Grow, initialization_index[0].length);
+          }
+          initialization_index[0][initialized_indices[0]] = new_segment;
+          initialized_indices[0] += 1;
+          if (initialized_indices[0] >= max_arraylet_length) {
+            initialized_segments[0] += 1;
+            initialized_indices[0] = 0;
+          }
+
+          for (int update_tier = 1; update_tier < indexing_tiers; update_tier++) {
+            if (initialized_indices[update_tier - 1] != 1) {
+              // We only need to update parent indices if the lower level was just expanded
+              break;
+            }
+            if (initialized_indices[update_tier] == 0) {
+              // Need to allocate a new level-N index segment
+              int unspanned = length - initialized_segments[update_tier] * index_segment_span[update_tier];
+              if (unspanned >= index_segment_span[update_tier]) {
+                initialization_index[update_tier] = new Object[max_arraylet_length];
+              } else {
+                int roundup = (unspanned + index_entry_span[update_tier] - 1) / index_entry_span[update_tier];
+                initialization_index[update_tier] = new Object[roundup];
+              }
+              // new index segment at level update_tier
+              memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+              memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Grow, initialization_index[update_tier].length);
+            }
+            initialization_index[update_tier][initialized_indices[update_tier]] = initialization_index[update_tier - 1];
+            initialized_indices[update_tier] += 1;
+            if (initialized_indices[update_tier] >= max_arraylet_length) {
+              initialized_segments[update_tier] += 1;
+              initialized_indices[update_tier] = 0;
+            }
+          }
+        }
       }
 
-      MemoryLog garbage = t.garbageLog();
-      garbage.accumulate(LifeSpan.Ephemeral,
-                         MemoryFlavor.ArrayObject, Grow, 2);
-      garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB,
-                         Grow, num_tiers * Util.SizeOfInt);
-      garbage.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference,
-                         Grow, num_tiers);
-    }
-    // Account for 7 ints: length, max_length, num_tiers, top_entry_span,
-    // total_arrays, total_array_ref_elements, total_array_long_elements
-    memory.accumulate(ls, MemoryFlavor.ObjectRSB, Grow, 7 * Util.SizeOfInt);
-    // Account for root
-    memory.accumulate(ls, MemoryFlavor.ObjectReference, Grow, 1);
-
-
-    memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, total_arrays);
-    memory.accumulate(ls, MemoryFlavor.ArrayReference,
-                      Grow, total_array_ref_elements);
-    memory.accumulate(ls, MemoryFlavor.ArrayRSB, Grow,
-                      this.total_array_long_elements * Util.SizeOfLong);
-  }
+      // initialization_index,initialized_segments, initialized_indices, index_segment_span
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayObject, Shrink, 4);
+
+      // initialization_index
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayReference, Shrink, indexing_tiers);
 
-  private final void adjustForNewLeaf(int[] counts, Object[][] arrays) {
-    int focus_level = num_tiers - 1;
-    if (counts[focus_level] < max_length) {
-      counts[focus_level]++;
+      // initialized_segments, initialized_indices, index_segment_span
+      memory.accumulate(LifeSpan.Ephemeral, MemoryFlavor.ArrayRSB, Shrink, 3 * indexing_tiers * Util.SizeOfInt);
+      root_index = initialization_index[indexing_tiers - 1];
+      root_segment = null;
     } else {
-      while ((focus_level > 0) && (counts[focus_level] >= max_length)) {
-        arrays[focus_level] = new Object[max_length];
-        this.total_arrays++;
-        this.total_array_ref_elements += max_length;
-        counts[focus_level] = 1;
-        if (focus_level < num_tiers - 1)
-          arrays[focus_level][0] = arrays[focus_level+1];
-        focus_level--;
-      }
-      if (focus_level < num_tiers - 1) {
-        arrays[focus_level][counts[focus_level]] = arrays[focus_level+1];
-        counts[focus_level]++;
-      }
+      num_segments = 1;
+      indexing_tiers = 0;
+      index_entry_span = null;
+      root_index = null;
+      root_segment = new long[length];
+      // new root_segment
+      memory.accumulate(ls, MemoryFlavor.ArrayObject, Grow, 1);
+      memory.accumulate(ls, MemoryFlavor.ArrayRSB, Grow, length * Util.SizeOfLong);
     }
+
+    // Account for 4 ints: length, max_arraylet_length, num_segments, indexing_tiers
+    memory.accumulate(ls, MemoryFlavor.ObjectRSB, Grow, 4 * Util.SizeOfInt);
+
+    // Account for root_index, root_segment, index_entry_span
+    memory.accumulate(ls, MemoryFlavor.ObjectReference, Grow, 3);
   }
+
   final long get(int at) {
     if ((at < 0) || (at >= length)) {
       Exception x = new ArrayIndexOutOfBoundsException(at);
       Util.fatalException("Index out of bounds in Arraylet.get", x);
+      // Not reached
     }
-    Object[] fan_out_node = root;
-    int entry_span = top_entry_span;
-    for (int i = 1; i < num_tiers; i++) {
-      fan_out_node = (Object []) fan_out_node[at / entry_span];
-      at %= entry_span;
-      entry_span /= max_length;
+    if (max_arraylet_length == 0) {
+      return root_segment[at];
+    } else {
+      int tier = indexing_tiers - 1;
+      int index = at / index_entry_span[tier];
+      int remainder = at % index_entry_span[tier];
+      Object[] index_segment = root_index;
+      while (tier-- > 0) {
+        index_segment = (Object[]) index_segment[index];
+        index = remainder / index_entry_span[tier];
+        remainder = remainder % index_entry_span[tier];
+      }
+      long[] data_segment = (long[]) index_segment[index];
+      return data_segment[remainder];
     }
-    long[] elements = (long []) fan_out_node[at / max_length];
-    return elements[at % max_length];
   }
 
+
   final void set(int at, long value) {
     if ((at < 0) || (at >= length)) {
       Exception x = new ArrayIndexOutOfBoundsException(at);
       Util.fatalException("Index out of bounds in Arraylet.get", x);
+    } else if (max_arraylet_length == 0) {
+      root_segment[at] = value;
+    } else {
+      int tier = indexing_tiers - 1;
+      int index = at / index_entry_span[tier];
+      int remainder = at % index_entry_span[tier];
+      Object[] index_segment = root_index;
+      while (tier-- > 0) {
+        index_segment = (Object[]) index_segment[index];
+        index = remainder / index_entry_span[tier];
+        remainder = remainder % index_entry_span[tier];
+      }
+      long[] data_segment = (long[]) index_segment[index];
+      data_segment[remainder] = value;
     }
-    Object[] fan_out_node = root;
-    int entry_span = top_entry_span;
-    for (int i = 1; i < num_tiers; i++) {
-      fan_out_node = (Object []) fan_out_node[at / entry_span];
-      at %= entry_span;
-      entry_span /= max_length;
-    }
-    long[] elements = (long []) fan_out_node[at / max_length];
-    elements[at % max_length] = value;
   }
 
   final int length() {
     return length;
   }
 
+  private void helpTallyMemory(MemoryLog log, LifeSpan ls, Polarity p, Object[] index_segment, int tier) {
+    log.accumulate(ls, MemoryFlavor.ArrayObject, p, 1);
+    log.accumulate(ls, MemoryFlavor.ArrayReference, p, index_segment.length);
+
+    if (tier > 1) {
+      for (int i = 0; i < index_segment.length; i++) {
+        Object[] sub_index_segment = (Object[]) index_segment[i];
+        helpTallyMemory(log, ls, p, sub_index_segment, tier-1);
+      }
+    } else {
+      log.accumulate(ls, MemoryFlavor.ArrayObject, p, index_segment.length);;
+      for (int i = 0; i < index_segment.length; i++) {
+        long[] data_segment = (long[]) index_segment[i];
+        if (data_segment != null) {
+          log.accumulate(ls, MemoryFlavor.ArrayRSB, p, data_segment.length * Util.SizeOfLong);
+        }
+      }
+    }
+  }
+
   void tallyMemory(MemoryLog log, LifeSpan ls, Polarity p) {
     super.tallyMemory(log, ls, p);
 
-    // Account for 7 ints: length, max_length, num_tiers, top_entry_span,
-    // total_arrays, total_array_ref_elements, total_array_long_elements
-    log.accumulate(ls, MemoryFlavor.ObjectRSB, p, 7 * Util.SizeOfInt);
-    // Account for root
-    log.accumulate(ls, MemoryFlavor.ObjectReference, p, 1);
+    // Account for 4 ints: length, max_arraylet_length, num_segments, indexing_tiers
+    log.accumulate(ls, MemoryFlavor.ObjectRSB, p, 4 * Util.SizeOfInt);
 
+    // Account for root_index, root_segment, index_entry_span
+    log.accumulate(ls, MemoryFlavor.ObjectReference, p, 3);
 
-    log.accumulate(ls, MemoryFlavor.ArrayObject, p, this.total_arrays);
-    log.accumulate(ls, MemoryFlavor.ArrayReference,
-                   p, this.total_array_ref_elements);
-    log.accumulate(ls, MemoryFlavor.ArrayRSB,
-                   p, this.total_array_long_elements);
+    if (max_arraylet_length == 0) {
+      log.accumulate(ls, MemoryFlavor.ArrayObject, p, 1);
+      log.accumulate(ls, MemoryFlavor.ArrayRSB, p, length * Util.SizeOfLong);
+    } else {
+      helpTallyMemory(log, ls, p, root_index, indexing_tiers);
+    }
   }
 
   public static void main(String args[]) {
-    Trace.debug("Testing Arraylet with max size 4");
 
     // Instantiate but do not run the Bootstrap thread.  Just need a
     // a placeholder for memory accounting.
@@ -184,6 +267,7 @@ public static void main(String args[]) {
     ArrayletOflong a;
 
     try {
+      Trace.debug("Testing Arraylet with max size 4");
       a = new ArrayletOflong(t, LifeSpan.Ephemeral, 4, 56);
       for (int i = 0; i < 56; i++)
         a.set(i, -10 * i);
@@ -199,6 +283,7 @@ public static void main(String args[]) {
     }
 
     try {
+      Trace.debug("Testing Arraylet with max size 7");
       a = new ArrayletOflong(t, LifeSpan.Ephemeral, 7, 61);
       for (int i = 0; i < 61; i++)
         a.set(i, -10 * i);
@@ -213,7 +298,25 @@ public static void main(String args[]) {
       Util.printException(x);
     }
 
+
+    try {
+      Trace.debug("Testing Small Arraylet with max size 7");
+      a = new ArrayletOflong(t, LifeSpan.Ephemeral, 7, 6);
+      for (int i = 0; i < 6; i++)
+        a.set(i, -10 * i);
+      for (int i = 5; i >= 0; i--) {
+        Long l = a.get(i);
+        String s1 = Integer.toString(i);
+        String s2 = Long.toString(l);
+        Trace.debug("Array element[", s1, "] holds ", s2);
+      }
+    } catch (Exception x) {
+      Trace.debug("caught exception during third batch");
+      Util.printException(x);
+    }
+
     try {
+      Trace.debug("Testing Arraylet with max size 0");
       a = new ArrayletOflong(t, LifeSpan.Ephemeral, 0, 61);
       for (int i = 0; i < 61; i++)
         a.set(i, -10 * i);
@@ -224,7 +327,7 @@ public static void main(String args[]) {
         Trace.debug("Array element[", s1, "] holds ", s2);
       }
     } catch (Exception x) {
-      Trace.debug("caught exception during third batch");
+      Trace.debug("caught exception during fourth batch");
       Util.printException(x);
     }
   }
diff --git a/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Configuration.java b/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Configuration.java
index a509adc..7e9fb4c 100644
--- a/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Configuration.java
+++ b/Extremem/src/main/java/com/amazon/corretto/benchmark/extremem/Configuration.java
@@ -1130,7 +1130,7 @@ void dump(ExtrememThread t) {
     Report.output("  Fine-grain locking of data base (FastAndFurious): ", FastAndFurious? "true": "false");
     Report.output("       Rebuild data base in phases (PhasedUpdates): ", PhasedUpdates? "true": "false");
     Report.output();
-    s = PhasedUpdateInterval.toString();
+    s = PhasedUpdateInterval.toString(t);
     l = s.length();
     Util.ephemeralString(t, l);
     Report.output("  Time between data rebuild (PhasedUpdateInterval): ", s);