template <typename V, typename T>
void read_from_rntuple_view(T* buffer, V& view, int64_t& offset, int64_t length) {
  int64_t current = 0;
  while (current < length) {
    T* data = (T*)view.fField.Map(offset + current);
    int32_t num = view.fField.fPrincipalColumn->fCurrentPage.GetNElements();
    int32_t skipped = (offset + current) - view.fField.fPrincipalColumn->fCurrentPage.GetGlobalRangeFirst();
    int32_t remaining = num - skipped;
    if (current + remaining > length) {
      remaining = length - current;
    }
    if (remaining > 0) {
      std::memcpy(&buffer[current], data, remaining*sizeof(T));
    }
    current += remaining;
  }
  offset += current;
}

auto ntuple = RNTupleReader::Open(std::move(model), "rntuple", filename);
auto view3 = ntuple->GetViewCollection("field");
auto view2 = view3.GetViewCollection("std::vector<std::vector<float>>");
auto view1 = view2.GetViewCollection("std::vector<float>");
auto view0 = view1.GetView<float>("float");

int64_t offset3 = 0;
int64_t offset2 = 0;
int64_t offset1 = 0;
int64_t offset0 = 0;

for (int64_t entry = 0;  entry < num_entries_in_file;  entry += num_entries_in_cluster) {
  int64_t length = num_entries_in_cluster;
  if (entry + length > num_entries_in_file) {
    length = num_entries_in_file - entry;   // trim for last cluster
  }

  int32_t* buffer_offset3 = allocate_output_offsets<int32_t>(length + 1);
  buffer_offsets3[0] = 0; // Awkward Array and Arrow offsets are a "fencepost" around the items they contain.
                          // For RNTuple input, which has no "dead space" before the first entry,
                          // they always start at zero. As a "fencepost," buffer_offsets.size() == length + 1.
  read_from_rntuple_view(&buffer_offsets3[1], view3, offset3, length);

  length = buffer_offsets3[length];   // now "length" is the length of the second level
  int32_t* buffer_offsets2 = allocate_output_offsets<int32_t>(length + 1);
  buffer_offsets2[0] = 0;
  read_from_rntuple_view(&buffer_offsets2[1], view2, offset2, length);

  length = buffer_offsets2[length];
  int32_t* buffer_offsets1 = allocate_output_offsets<int32_t>(length + 1);
  buffer_offsets1[0] = 0;
  read_from_rntuple_view(&buffer_offsets1[1], view1, offset1, length);

  length = buffer_offsets1[length];
  float* buffer_content = allocate_output_content<float>(length);   // content is different from offsets
  read_from_rntuple_view(buffer_content, view0, offset0, length);

  return somehow_pack_together(buffer_offset3, buffer_offset2, buffer_offset1, buffer_content);
}