[PATCH v3 00/25] iomap/xfs folio patches

[PATCH v3 00/25] iomap/xfs folio patches

[Matthew Wilcox (Oracle)]

This patchset converts XFS & iomap to use folios, and gets them to a
state where they can handle multi-page folios.  Applying these patches
is not yet sufficient to actually start using multi-page folios for
XFS; more page cache changes are needed.  I don't anticipate needing to
touch XFS again until we're at the point where we want to convert the
aops to be type-safe.  It completes an xfstests run with no unexpected
failures.

I think everything here has been posted before, but I want to get
acks/reviews on patch 15 in particular.  I'll send a pull request
for these patches tomorrow.

v3:
 - Rebased to -rc5, which removes the first four patches from v2.
 - Fixed passing lengths > PAGE_SIZE to iomap_write_begin().
v2:
 - Added review tags from Jens, Darrick & Christoph (thanks!)
 - Added folio_zero_* wrappers around zero_user_*()
 - Added a patch to rename AS_THP_SUPPORT
 - Added a patch to convert __block_write_begin_int() to take a folio
 - Split the iomap_add_to_ioend() patch into three
 - Updated changelog of bio_add_folio() (Jens)
 - Adjusted whitespace of bio patches (Christoph, Jens)
 - Improved changelog of readahead conversion to explain why the put_page()
   disappeared (Christoph)
 - Add a patch to zero an entire folio at a time, instead of limiting to
   a page
 - Switch pos & end_pos back to being u64 from loff_t
 - Call block_write_end() and ->page_done with the head page of the folio,
   as that's what those functions expect.

Matthew Wilcox (Oracle) (25):
  block: Add bio_add_folio()
  block: Add bio_for_each_folio_all()
  fs/buffer: Convert __block_write_begin_int() to take a folio
  iomap: Convert to_iomap_page to take a folio
  iomap: Convert iomap_page_create to take a folio
  iomap: Convert iomap_page_release to take a folio
  iomap: Convert iomap_releasepage to use a folio
  iomap: Add iomap_invalidate_folio
  iomap: Pass the iomap_page into iomap_set_range_uptodate
  iomap: Convert bio completions to use folios
  iomap: Use folio offsets instead of page offsets
  iomap: Convert iomap_read_inline_data to take a folio
  iomap: Convert readahead and readpage to use a folio
  iomap: Convert iomap_page_mkwrite to use a folio
  iomap: Allow iomap_write_begin() to be called with the full length
  iomap: Convert __iomap_zero_iter to use a folio
  iomap: Convert iomap_write_begin() and iomap_write_end() to folios
  iomap: Convert iomap_write_end_inline to take a folio
  iomap,xfs: Convert ->discard_page to ->discard_folio
  iomap: Simplify iomap_writepage_map()
  iomap: Simplify iomap_do_writepage()
  iomap: Convert iomap_add_to_ioend() to take a folio
  iomap: Convert iomap_migrate_page() to use folios
  iomap: Support large folios in invalidatepage
  xfs: Support large folios

 Documentation/core-api/kernel-api.rst |   1 +
 block/bio.c                           |  22 ++
 fs/buffer.c                           |  23 +-
 fs/internal.h                         |   2 +-
 fs/iomap/buffered-io.c                | 518 +++++++++++++-------------
 fs/xfs/xfs_aops.c                     |  24 +-
 fs/xfs/xfs_icache.c                   |   2 +
 include/linux/bio.h                   |  56 ++-
 include/linux/iomap.h                 |   3 +-
 9 files changed, 373 insertions(+), 278 deletions(-)

-- 
2.33.0

[PATCH v3 01/25] block: Add bio_add_folio()

[Matthew Wilcox (Oracle)]

This is a thin wrapper around bio_add_page().  The main advantage here
is the documentation that folios larger than 2GiB are not supported.
It's not currently possible to allocate folios that large, but if it
ever becomes possible, this function will fail gracefully instead of
doing I/O to the wrong bytes.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Jens Axboe <axboe@kernel.dk>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 block/bio.c         | 22 ++++++++++++++++++++++
 include/linux/bio.h |  3 ++-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/block/bio.c b/block/bio.c
index 15ab0d6d1c06..4b3087e20d51 100644
--- a/block/bio.c
+++ b/block/bio.c
@@ -1033,6 +1033,28 @@ int bio_add_page(struct bio *bio, struct page *page,
 }
 EXPORT_SYMBOL(bio_add_page);
 
+/**
+ * bio_add_folio - Attempt to add part of a folio to a bio.
+ * @bio: BIO to add to.
+ * @folio: Folio to add.
+ * @len: How many bytes from the folio to add.
+ * @off: First byte in this folio to add.
+ *
+ * Filesystems that use folios can call this function instead of calling
+ * bio_add_page() for each page in the folio.  If @off is bigger than
+ * PAGE_SIZE, this function can create a bio_vec that starts in a page
+ * after the bv_page.  BIOs do not support folios that are 4GiB or larger.
+ *
+ * Return: Whether the addition was successful.
+ */
+bool bio_add_folio(struct bio *bio, struct folio *folio, size_t len,
+		   size_t off)
+{
+	if (len > UINT_MAX || off > UINT_MAX)
+		return 0;
+	return bio_add_page(bio, &folio->page, len, off) > 0;
+}
+
 void __bio_release_pages(struct bio *bio, bool mark_dirty)
 {
 	struct bvec_iter_all iter_all;
diff --git a/include/linux/bio.h b/include/linux/bio.h
index fe6bdfbbef66..a783cac49978 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -409,7 +409,8 @@ extern void bio_uninit(struct bio *);
 extern void bio_reset(struct bio *);
 void bio_chain(struct bio *, struct bio *);
 
-extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
+int bio_add_page(struct bio *, struct page *, unsigned len, unsigned off);
+bool bio_add_folio(struct bio *, struct folio *, size_t len, size_t off);
 extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
 			   unsigned int, unsigned int);
 int bio_add_zone_append_page(struct bio *bio, struct page *page,
-- 
2.33.0

[PATCH v3 02/25] block: Add bio_for_each_folio_all()

[Matthew Wilcox (Oracle)]

Allow callers to iterate over each folio instead of each page.  The
bio need not have been constructed using folios originally.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Jens Axboe <axboe@kernel.dk>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 Documentation/core-api/kernel-api.rst |  1 +
 include/linux/bio.h                   | 53 ++++++++++++++++++++++++++-
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/Documentation/core-api/kernel-api.rst b/Documentation/core-api/kernel-api.rst
index 2e7186805148..7f0cb604b6ab 100644
--- a/Documentation/core-api/kernel-api.rst
+++ b/Documentation/core-api/kernel-api.rst
@@ -279,6 +279,7 @@ Accounting Framework
 Block Devices
 =============
 
+.. kernel-doc:: include/linux/bio.h
 .. kernel-doc:: block/blk-core.c
    :export:
 
diff --git a/include/linux/bio.h b/include/linux/bio.h
index a783cac49978..e3c9e8207f12 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -166,7 +166,7 @@ static inline void bio_advance(struct bio *bio, unsigned int nbytes)
  */
 #define bio_for_each_bvec_all(bvl, bio, i)		\
 	for (i = 0, bvl = bio_first_bvec_all(bio);	\
-	     i < (bio)->bi_vcnt; i++, bvl++)		\
+	     i < (bio)->bi_vcnt; i++, bvl++)
 
 #define bio_iter_last(bvec, iter) ((iter).bi_size == (bvec).bv_len)
 
@@ -260,6 +260,57 @@ static inline struct bio_vec *bio_last_bvec_all(struct bio *bio)
 	return &bio->bi_io_vec[bio->bi_vcnt - 1];
 }
 
+/**
+ * struct folio_iter - State for iterating all folios in a bio.
+ * @folio: The current folio we're iterating.  NULL after the last folio.
+ * @offset: The byte offset within the current folio.
+ * @length: The number of bytes in this iteration (will not cross folio
+ *	boundary).
+ */
+struct folio_iter {
+	struct folio *folio;
+	size_t offset;
+	size_t length;
+	/* private: for use by the iterator */
+	size_t _seg_count;
+	int _i;
+};
+
+static inline void bio_first_folio(struct folio_iter *fi, struct bio *bio,
+				   int i)
+{
+	struct bio_vec *bvec = bio_first_bvec_all(bio) + i;
+
+	fi->folio = page_folio(bvec->bv_page);
+	fi->offset = bvec->bv_offset +
+			PAGE_SIZE * (bvec->bv_page - &fi->folio->page);
+	fi->_seg_count = bvec->bv_len;
+	fi->length = min(folio_size(fi->folio) - fi->offset, fi->_seg_count);
+	fi->_i = i;
+}
+
+static inline void bio_next_folio(struct folio_iter *fi, struct bio *bio)
+{
+	fi->_seg_count -= fi->length;
+	if (fi->_seg_count) {
+		fi->folio = folio_next(fi->folio);
+		fi->offset = 0;
+		fi->length = min(folio_size(fi->folio), fi->_seg_count);
+	} else if (fi->_i + 1 < bio->bi_vcnt) {
+		bio_first_folio(fi, bio, fi->_i + 1);
+	} else {
+		fi->folio = NULL;
+	}
+}
+
+/**
+ * bio_for_each_folio_all - Iterate over each folio in a bio.
+ * @fi: struct folio_iter which is updated for each folio.
+ * @bio: struct bio to iterate over.
+ */
+#define bio_for_each_folio_all(fi, bio)				\
+	for (bio_first_folio(&fi, bio, 0); fi.folio; bio_next_folio(&fi, bio))
+
 enum bip_flags {
 	BIP_BLOCK_INTEGRITY	= 1 << 0, /* block layer owns integrity data */
 	BIP_MAPPED_INTEGRITY	= 1 << 1, /* ref tag has been remapped */
-- 
2.33.0

[PATCH v3 03/25] fs/buffer: Convert __block_write_begin_int() to take a folio

[Matthew Wilcox (Oracle)]

There are no plans to convert buffer_head infrastructure to use large
folios, but __block_write_begin_int() is called from iomap, and it's
more convenient and less error-prone if we pass in a folio from iomap.
It also has a nice saving of almost 200 bytes of code from removing
repeated calls to compound_head().

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/buffer.c            | 23 ++++++++++++-----------
 fs/internal.h          |  2 +-
 fs/iomap/buffered-io.c |  7 +++++--
 3 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/fs/buffer.c b/fs/buffer.c
index 46bc589b7a03..8e112b6bd371 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1969,34 +1969,34 @@ iomap_to_bh(struct inode *inode, sector_t block, struct buffer_head *bh,
 	}
 }
 
-int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
+int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,
 		get_block_t *get_block, const struct iomap *iomap)
 {
 	unsigned from = pos & (PAGE_SIZE - 1);
 	unsigned to = from + len;
-	struct inode *inode = page->mapping->host;
+	struct inode *inode = folio->mapping->host;
 	unsigned block_start, block_end;
 	sector_t block;
 	int err = 0;
 	unsigned blocksize, bbits;
 	struct buffer_head *bh, *head, *wait[2], **wait_bh=wait;
 
-	BUG_ON(!PageLocked(page));
+	BUG_ON(!folio_test_locked(folio));
 	BUG_ON(from > PAGE_SIZE);
 	BUG_ON(to > PAGE_SIZE);
 	BUG_ON(from > to);
 
-	head = create_page_buffers(page, inode, 0);
+	head = create_page_buffers(&folio->page, inode, 0);
 	blocksize = head->b_size;
 	bbits = block_size_bits(blocksize);
 
-	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
+	block = (sector_t)folio->index << (PAGE_SHIFT - bbits);
 
 	for(bh = head, block_start = 0; bh != head || !block_start;
 	    block++, block_start=block_end, bh = bh->b_this_page) {
 		block_end = block_start + blocksize;
 		if (block_end <= from || block_start >= to) {
-			if (PageUptodate(page)) {
+			if (folio_test_uptodate(folio)) {
 				if (!buffer_uptodate(bh))
 					set_buffer_uptodate(bh);
 			}
@@ -2016,20 +2016,20 @@ int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
 
 			if (buffer_new(bh)) {
 				clean_bdev_bh_alias(bh);
-				if (PageUptodate(page)) {
+				if (folio_test_uptodate(folio)) {
 					clear_buffer_new(bh);
 					set_buffer_uptodate(bh);
 					mark_buffer_dirty(bh);
 					continue;
 				}
 				if (block_end > to || block_start < from)
-					zero_user_segments(page,
+					folio_zero_segments(folio,
 						to, block_end,
 						block_start, from);
 				continue;
 			}
 		}
-		if (PageUptodate(page)) {
+		if (folio_test_uptodate(folio)) {
 			if (!buffer_uptodate(bh))
 				set_buffer_uptodate(bh);
 			continue; 
@@ -2050,14 +2050,15 @@ int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
 			err = -EIO;
 	}
 	if (unlikely(err))
-		page_zero_new_buffers(page, from, to);
+		page_zero_new_buffers(&folio->page, from, to);
 	return err;
 }
 
 int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 		get_block_t *get_block)
 {
-	return __block_write_begin_int(page, pos, len, get_block, NULL);
+	return __block_write_begin_int(page_folio(page), pos, len, get_block,
+				       NULL);
 }
 EXPORT_SYMBOL(__block_write_begin);
 
diff --git a/fs/internal.h b/fs/internal.h
index 7979ff8d168c..8590c973c2f4 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -37,7 +37,7 @@ static inline int emergency_thaw_bdev(struct super_block *sb)
 /*
  * buffer.c
  */
-int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
+int __block_write_begin_int(struct folio *folio, loff_t pos, unsigned len,
 		get_block_t *get_block, const struct iomap *iomap);
 
 /*
diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 71a36ae120ee..ecb65167715b 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -603,6 +603,7 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 	const struct iomap_page_ops *page_ops = iter->iomap.page_ops;
 	const struct iomap *srcmap = iomap_iter_srcmap(iter);
 	struct page *page;
+	struct folio *folio;
 	int status = 0;
 
 	BUG_ON(pos + len > iter->iomap.offset + iter->iomap.length);
@@ -624,11 +625,12 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 		status = -ENOMEM;
 		goto out_no_page;
 	}
+	folio = page_folio(page);
 
 	if (srcmap->type == IOMAP_INLINE)
 		status = iomap_write_begin_inline(iter, page);
 	else if (srcmap->flags & IOMAP_F_BUFFER_HEAD)
-		status = __block_write_begin_int(page, pos, len, NULL, srcmap);
+		status = __block_write_begin_int(folio, pos, len, NULL, srcmap);
 	else
 		status = __iomap_write_begin(iter, pos, len, page);
 
@@ -960,11 +962,12 @@ EXPORT_SYMBOL_GPL(iomap_truncate_page);
 static loff_t iomap_page_mkwrite_iter(struct iomap_iter *iter,
 		struct page *page)
 {
+	struct folio *folio = page_folio(page);
 	loff_t length = iomap_length(iter);
 	int ret;
 
 	if (iter->iomap.flags & IOMAP_F_BUFFER_HEAD) {
-		ret = __block_write_begin_int(page, iter->pos, length, NULL,
+		ret = __block_write_begin_int(folio, iter->pos, length, NULL,
 					      &iter->iomap);
 		if (ret)
 			return ret;
-- 
2.33.0

[PATCH v3 04/25] iomap: Convert to_iomap_page to take a folio

[Matthew Wilcox (Oracle)]

The big comment about only using a head page can go away now that
it takes a folio argument.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index ecb65167715b..101d5b0754e9 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -22,8 +22,8 @@
 #include "../internal.h"
 
 /*
- * Structure allocated for each page or THP when block size < page size
- * to track sub-page uptodate status and I/O completions.
+ * Structure allocated for each folio when block size < folio size
+ * to track sub-folio uptodate status and I/O completions.
  */
 struct iomap_page {
 	atomic_t		read_bytes_pending;
@@ -32,17 +32,10 @@ struct iomap_page {
 	unsigned long		uptodate[];
 };
 
-static inline struct iomap_page *to_iomap_page(struct page *page)
+static inline struct iomap_page *to_iomap_page(struct folio *folio)
 {
-	/*
-	 * per-block data is stored in the head page.  Callers should
-	 * not be dealing with tail pages, and if they are, they can
-	 * call thp_head() first.
-	 */
-	VM_BUG_ON_PGFLAGS(PageTail(page), page);
-
-	if (page_has_private(page))
-		return (struct iomap_page *)page_private(page);
+	if (folio_test_private(folio))
+		return folio_get_private(folio);
 	return NULL;
 }
 
@@ -51,7 +44,8 @@ static struct bio_set iomap_ioend_bioset;
 static struct iomap_page *
 iomap_page_create(struct inode *inode, struct page *page)
 {
-	struct iomap_page *iop = to_iomap_page(page);
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = to_iomap_page(folio);
 	unsigned int nr_blocks = i_blocks_per_page(inode, page);
 
 	if (iop || nr_blocks <= 1)
@@ -144,7 +138,8 @@ iomap_adjust_read_range(struct inode *inode, struct iomap_page *iop,
 static void
 iomap_iop_set_range_uptodate(struct page *page, unsigned off, unsigned len)
 {
-	struct iomap_page *iop = to_iomap_page(page);
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = to_iomap_page(folio);
 	struct inode *inode = page->mapping->host;
 	unsigned first = off >> inode->i_blkbits;
 	unsigned last = (off + len - 1) >> inode->i_blkbits;
@@ -173,7 +168,8 @@ static void
 iomap_read_page_end_io(struct bio_vec *bvec, int error)
 {
 	struct page *page = bvec->bv_page;
-	struct iomap_page *iop = to_iomap_page(page);
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = to_iomap_page(folio);
 
 	if (unlikely(error)) {
 		ClearPageUptodate(page);
@@ -438,7 +434,8 @@ int
 iomap_is_partially_uptodate(struct page *page, unsigned long from,
 		unsigned long count)
 {
-	struct iomap_page *iop = to_iomap_page(page);
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = to_iomap_page(folio);
 	struct inode *inode = page->mapping->host;
 	unsigned len, first, last;
 	unsigned i;
@@ -1012,7 +1009,8 @@ static void
 iomap_finish_page_writeback(struct inode *inode, struct page *page,
 		int error, unsigned int len)
 {
-	struct iomap_page *iop = to_iomap_page(page);
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = to_iomap_page(folio);
 
 	if (error) {
 		SetPageError(page);
-- 
2.33.0

[PATCH v3 05/25] iomap: Convert iomap_page_create to take a folio

[Matthew Wilcox (Oracle)]

This function already assumed it was being passed a head page, so
just formalise that.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 101d5b0754e9..d7823610da5c 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -42,11 +42,10 @@ static inline struct iomap_page *to_iomap_page(struct folio *folio)
 static struct bio_set iomap_ioend_bioset;
 
 static struct iomap_page *
-iomap_page_create(struct inode *inode, struct page *page)
+iomap_page_create(struct inode *inode, struct folio *folio)
 {
-	struct folio *folio = page_folio(page);
 	struct iomap_page *iop = to_iomap_page(folio);
-	unsigned int nr_blocks = i_blocks_per_page(inode, page);
+	unsigned int nr_blocks = i_blocks_per_folio(inode, folio);
 
 	if (iop || nr_blocks <= 1)
 		return iop;
@@ -54,9 +53,9 @@ iomap_page_create(struct inode *inode, struct page *page)
 	iop = kzalloc(struct_size(iop, uptodate, BITS_TO_LONGS(nr_blocks)),
 			GFP_NOFS | __GFP_NOFAIL);
 	spin_lock_init(&iop->uptodate_lock);
-	if (PageUptodate(page))
+	if (folio_test_uptodate(folio))
 		bitmap_fill(iop->uptodate, nr_blocks);
-	attach_page_private(page, iop);
+	folio_attach_private(folio, iop);
 	return iop;
 }
 
@@ -213,6 +212,7 @@ struct iomap_readpage_ctx {
 static int iomap_read_inline_data(const struct iomap_iter *iter,
 		struct page *page)
 {
+	struct folio *folio = page_folio(page);
 	const struct iomap *iomap = iomap_iter_srcmap(iter);
 	size_t size = i_size_read(iter->inode) - iomap->offset;
 	size_t poff = offset_in_page(iomap->offset);
@@ -229,7 +229,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 	if (WARN_ON_ONCE(size > iomap->length))
 		return -EIO;
 	if (poff > 0)
-		iomap_page_create(iter->inode, page);
+		iomap_page_create(iter->inode, folio);
 
 	addr = kmap_local_page(page) + poff;
 	memcpy(addr, iomap->inline_data, size);
@@ -256,6 +256,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 	loff_t pos = iter->pos + offset;
 	loff_t length = iomap_length(iter) - offset;
 	struct page *page = ctx->cur_page;
+	struct folio *folio = page_folio(page);
 	struct iomap_page *iop;
 	loff_t orig_pos = pos;
 	unsigned poff, plen;
@@ -265,7 +266,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 		return iomap_read_inline_data(iter, page);
 
 	/* zero post-eof blocks as the page may be mapped */
-	iop = iomap_page_create(iter->inode, page);
+	iop = iomap_page_create(iter->inode, folio);
 	iomap_adjust_read_range(iter->inode, iop, &pos, length, &poff, &plen);
 	if (plen == 0)
 		goto done;
@@ -547,8 +548,9 @@ iomap_read_page_sync(loff_t block_start, struct page *page, unsigned poff,
 static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 		unsigned len, struct page *page)
 {
+	struct folio *folio = page_folio(page);
 	const struct iomap *srcmap = iomap_iter_srcmap(iter);
-	struct iomap_page *iop = iomap_page_create(iter->inode, page);
+	struct iomap_page *iop = iomap_page_create(iter->inode, folio);
 	loff_t block_size = i_blocksize(iter->inode);
 	loff_t block_start = round_down(pos, block_size);
 	loff_t block_end = round_up(pos + len, block_size);
@@ -1296,7 +1298,8 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 		struct writeback_control *wbc, struct inode *inode,
 		struct page *page, u64 end_offset)
 {
-	struct iomap_page *iop = iomap_page_create(inode, page);
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = iomap_page_create(inode, folio);
 	struct iomap_ioend *ioend, *next;
 	unsigned len = i_blocksize(inode);
 	u64 file_offset; /* file offset of page */
-- 
2.33.0

[PATCH v3 06/25] iomap: Convert iomap_page_release to take a folio

[Matthew Wilcox (Oracle)]

iomap_page_release() was also assuming that it was being passed a
head page.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index d7823610da5c..16604f605357 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -59,18 +59,18 @@ iomap_page_create(struct inode *inode, struct folio *folio)
 	return iop;
 }
 
-static void
-iomap_page_release(struct page *page)
+static void iomap_page_release(struct folio *folio)
 {
-	struct iomap_page *iop = detach_page_private(page);
-	unsigned int nr_blocks = i_blocks_per_page(page->mapping->host, page);
+	struct iomap_page *iop = folio_detach_private(folio);
+	struct inode *inode = folio->mapping->host;
+	unsigned int nr_blocks = i_blocks_per_folio(inode, folio);
 
 	if (!iop)
 		return;
 	WARN_ON_ONCE(atomic_read(&iop->read_bytes_pending));
 	WARN_ON_ONCE(atomic_read(&iop->write_bytes_pending));
 	WARN_ON_ONCE(bitmap_full(iop->uptodate, nr_blocks) !=
-			PageUptodate(page));
+			folio_test_uptodate(folio));
 	kfree(iop);
 }
 
@@ -462,6 +462,8 @@ EXPORT_SYMBOL_GPL(iomap_is_partially_uptodate);
 int
 iomap_releasepage(struct page *page, gfp_t gfp_mask)
 {
+	struct folio *folio = page_folio(page);
+
 	trace_iomap_releasepage(page->mapping->host, page_offset(page),
 			PAGE_SIZE);
 
@@ -472,7 +474,7 @@ iomap_releasepage(struct page *page, gfp_t gfp_mask)
 	 */
 	if (PageDirty(page) || PageWriteback(page))
 		return 0;
-	iomap_page_release(page);
+	iomap_page_release(folio);
 	return 1;
 }
 EXPORT_SYMBOL_GPL(iomap_releasepage);
@@ -480,6 +482,8 @@ EXPORT_SYMBOL_GPL(iomap_releasepage);
 void
 iomap_invalidatepage(struct page *page, unsigned int offset, unsigned int len)
 {
+	struct folio *folio = page_folio(page);
+
 	trace_iomap_invalidatepage(page->mapping->host, offset, len);
 
 	/*
@@ -489,7 +493,7 @@ iomap_invalidatepage(struct page *page, unsigned int offset, unsigned int len)
 	if (offset == 0 && len == PAGE_SIZE) {
 		WARN_ON_ONCE(PageWriteback(page));
 		cancel_dirty_page(page);
-		iomap_page_release(page);
+		iomap_page_release(folio);
 	}
 }
 EXPORT_SYMBOL_GPL(iomap_invalidatepage);
-- 
2.33.0

[PATCH v3 07/25] iomap: Convert iomap_releasepage to use a folio

[Matthew Wilcox (Oracle)]

This is an address_space operation, so its argument must remain as a
struct page, but we can use a folio internally.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 16604f605357..b0192b148c9f 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -464,15 +464,15 @@ iomap_releasepage(struct page *page, gfp_t gfp_mask)
 {
 	struct folio *folio = page_folio(page);
 
-	trace_iomap_releasepage(page->mapping->host, page_offset(page),
-			PAGE_SIZE);
+	trace_iomap_releasepage(folio->mapping->host, folio_pos(folio),
+			folio_size(folio));
 
 	/*
 	 * mm accommodates an old ext3 case where clean pages might not have had
 	 * the dirty bit cleared. Thus, it can send actual dirty pages to
 	 * ->releasepage() via shrink_active_list(); skip those here.
 	 */
-	if (PageDirty(page) || PageWriteback(page))
+	if (folio_test_dirty(folio) || folio_test_writeback(folio))
 		return 0;
 	iomap_page_release(folio);
 	return 1;
-- 
2.33.0

[PATCH v3 08/25] iomap: Add iomap_invalidate_folio

[Matthew Wilcox (Oracle)]

Keep iomap_invalidatepage around as a wrapper for use in address_space
operations.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 20 ++++++++++++--------
 include/linux/iomap.h  |  1 +
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index b0192b148c9f..de7ce1909527 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -479,23 +479,27 @@ iomap_releasepage(struct page *page, gfp_t gfp_mask)
 }
 EXPORT_SYMBOL_GPL(iomap_releasepage);
 
-void
-iomap_invalidatepage(struct page *page, unsigned int offset, unsigned int len)
+void iomap_invalidate_folio(struct folio *folio, size_t offset, size_t len)
 {
-	struct folio *folio = page_folio(page);
-
-	trace_iomap_invalidatepage(page->mapping->host, offset, len);
+	trace_iomap_invalidatepage(folio->mapping->host, offset, len);
 
 	/*
 	 * If we're invalidating the entire page, clear the dirty state from it
 	 * and release it to avoid unnecessary buildup of the LRU.
 	 */
-	if (offset == 0 && len == PAGE_SIZE) {
-		WARN_ON_ONCE(PageWriteback(page));
-		cancel_dirty_page(page);
+	if (offset == 0 && len == folio_size(folio)) {
+		WARN_ON_ONCE(folio_test_writeback(folio));
+		folio_cancel_dirty(folio);
 		iomap_page_release(folio);
 	}
 }
+EXPORT_SYMBOL_GPL(iomap_invalidate_folio);
+
+void iomap_invalidatepage(struct page *page, unsigned int offset,
+		unsigned int len)
+{
+	iomap_invalidate_folio(page_folio(page), offset, len);
+}
 EXPORT_SYMBOL_GPL(iomap_invalidatepage);
 
 #ifdef CONFIG_MIGRATION
diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index 6d1b08d0ae93..29491fb9c5ba 100644
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -225,6 +225,7 @@ void iomap_readahead(struct readahead_control *, const struct iomap_ops *ops);
 int iomap_is_partially_uptodate(struct page *page, unsigned long from,
 		unsigned long count);
 int iomap_releasepage(struct page *page, gfp_t gfp_mask);
+void iomap_invalidate_folio(struct folio *folio, size_t offset, size_t len);
 void iomap_invalidatepage(struct page *page, unsigned int offset,
 		unsigned int len);
 #ifdef CONFIG_MIGRATION
-- 
2.33.0

[PATCH v3 09/25] iomap: Pass the iomap_page into iomap_set_range_uptodate

[Matthew Wilcox (Oracle)]

All but one caller already has the iomap_page, so we can avoid getting
it again.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index de7ce1909527..856ef62b319e 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -134,11 +134,9 @@ iomap_adjust_read_range(struct inode *inode, struct iomap_page *iop,
 	*lenp = plen;
 }
 
-static void
-iomap_iop_set_range_uptodate(struct page *page, unsigned off, unsigned len)
+static void iomap_iop_set_range_uptodate(struct page *page,
+		struct iomap_page *iop, unsigned off, unsigned len)
 {
-	struct folio *folio = page_folio(page);
-	struct iomap_page *iop = to_iomap_page(folio);
 	struct inode *inode = page->mapping->host;
 	unsigned first = off >> inode->i_blkbits;
 	unsigned last = (off + len - 1) >> inode->i_blkbits;
@@ -151,14 +149,14 @@ iomap_iop_set_range_uptodate(struct page *page, unsigned off, unsigned len)
 	spin_unlock_irqrestore(&iop->uptodate_lock, flags);
 }
 
-static void
-iomap_set_range_uptodate(struct page *page, unsigned off, unsigned len)
+static void iomap_set_range_uptodate(struct page *page,
+		struct iomap_page *iop, unsigned off, unsigned len)
 {
 	if (PageError(page))
 		return;
 
-	if (page_has_private(page))
-		iomap_iop_set_range_uptodate(page, off, len);
+	if (iop)
+		iomap_iop_set_range_uptodate(page, iop, off, len);
 	else
 		SetPageUptodate(page);
 }
@@ -174,7 +172,8 @@ iomap_read_page_end_io(struct bio_vec *bvec, int error)
 		ClearPageUptodate(page);
 		SetPageError(page);
 	} else {
-		iomap_set_range_uptodate(page, bvec->bv_offset, bvec->bv_len);
+		iomap_set_range_uptodate(page, iop, bvec->bv_offset,
+						bvec->bv_len);
 	}
 
 	if (!iop || atomic_sub_and_test(bvec->bv_len, &iop->read_bytes_pending))
@@ -213,6 +212,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 		struct page *page)
 {
 	struct folio *folio = page_folio(page);
+	struct iomap_page *iop;
 	const struct iomap *iomap = iomap_iter_srcmap(iter);
 	size_t size = i_size_read(iter->inode) - iomap->offset;
 	size_t poff = offset_in_page(iomap->offset);
@@ -229,13 +229,15 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 	if (WARN_ON_ONCE(size > iomap->length))
 		return -EIO;
 	if (poff > 0)
-		iomap_page_create(iter->inode, folio);
+		iop = iomap_page_create(iter->inode, folio);
+	else
+		iop = to_iomap_page(folio);
 
 	addr = kmap_local_page(page) + poff;
 	memcpy(addr, iomap->inline_data, size);
 	memset(addr + size, 0, PAGE_SIZE - poff - size);
 	kunmap_local(addr);
-	iomap_set_range_uptodate(page, poff, PAGE_SIZE - poff);
+	iomap_set_range_uptodate(page, iop, poff, PAGE_SIZE - poff);
 	return 0;
 }
 
@@ -273,7 +275,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 
 	if (iomap_block_needs_zeroing(iter, pos)) {
 		zero_user(page, poff, plen);
-		iomap_set_range_uptodate(page, poff, plen);
+		iomap_set_range_uptodate(page, iop, poff, plen);
 		goto done;
 	}
 
@@ -589,7 +591,7 @@ static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 			if (status)
 				return status;
 		}
-		iomap_set_range_uptodate(page, poff, plen);
+		iomap_set_range_uptodate(page, iop, poff, plen);
 	} while ((block_start += plen) < block_end);
 
 	return 0;
@@ -661,6 +663,8 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
 		size_t copied, struct page *page)
 {
+	struct folio *folio = page_folio(page);
+	struct iomap_page *iop = to_iomap_page(folio);
 	flush_dcache_page(page);
 
 	/*
@@ -676,7 +680,7 @@ static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
 	 */
 	if (unlikely(copied < len && !PageUptodate(page)))
 		return 0;
-	iomap_set_range_uptodate(page, offset_in_page(pos), len);
+	iomap_set_range_uptodate(page, iop, offset_in_page(pos), len);
 	__set_page_dirty_nobuffers(page);
 	return copied;
 }
-- 
2.33.0

[PATCH v3 10/25] iomap: Convert bio completions to use folios

[Matthew Wilcox (Oracle)]

Use bio_for_each_folio() to iterate over each folio in the bio
instead of iterating over each page.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 50 ++++++++++++++++++------------------------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 856ef62b319e..5730a3317407 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -161,34 +161,29 @@ static void iomap_set_range_uptodate(struct page *page,
 		SetPageUptodate(page);
 }
 
-static void
-iomap_read_page_end_io(struct bio_vec *bvec, int error)
+static void iomap_finish_folio_read(struct folio *folio, size_t offset,
+		size_t len, int error)
 {
-	struct page *page = bvec->bv_page;
-	struct folio *folio = page_folio(page);
 	struct iomap_page *iop = to_iomap_page(folio);
 
 	if (unlikely(error)) {
-		ClearPageUptodate(page);
-		SetPageError(page);
+		folio_clear_uptodate(folio);
+		folio_set_error(folio);
 	} else {
-		iomap_set_range_uptodate(page, iop, bvec->bv_offset,
-						bvec->bv_len);
+		iomap_set_range_uptodate(&folio->page, iop, offset, len);
 	}
 
-	if (!iop || atomic_sub_and_test(bvec->bv_len, &iop->read_bytes_pending))
-		unlock_page(page);
+	if (!iop || atomic_sub_and_test(len, &iop->read_bytes_pending))
+		folio_unlock(folio);
 }
 
-static void
-iomap_read_end_io(struct bio *bio)
+static void iomap_read_end_io(struct bio *bio)
 {
 	int error = blk_status_to_errno(bio->bi_status);
-	struct bio_vec *bvec;
-	struct bvec_iter_all iter_all;
+	struct folio_iter fi;
 
-	bio_for_each_segment_all(bvec, bio, iter_all)
-		iomap_read_page_end_io(bvec, error);
+	bio_for_each_folio_all(fi, bio)
+		iomap_finish_folio_read(fi.folio, fi.offset, fi.length, error);
 	bio_put(bio);
 }
 
@@ -1019,23 +1014,21 @@ vm_fault_t iomap_page_mkwrite(struct vm_fault *vmf, const struct iomap_ops *ops)
 }
 EXPORT_SYMBOL_GPL(iomap_page_mkwrite);
 
-static void
-iomap_finish_page_writeback(struct inode *inode, struct page *page,
-		int error, unsigned int len)
+static void iomap_finish_folio_write(struct inode *inode, struct folio *folio,
+		size_t len, int error)
 {
-	struct folio *folio = page_folio(page);
 	struct iomap_page *iop = to_iomap_page(folio);
 
 	if (error) {
-		SetPageError(page);
+		folio_set_error(folio);
 		mapping_set_error(inode->i_mapping, error);
 	}
 
-	WARN_ON_ONCE(i_blocks_per_page(inode, page) > 1 && !iop);
+	WARN_ON_ONCE(i_blocks_per_folio(inode, folio) > 1 && !iop);
 	WARN_ON_ONCE(iop && atomic_read(&iop->write_bytes_pending) <= 0);
 
 	if (!iop || atomic_sub_and_test(len, &iop->write_bytes_pending))
-		end_page_writeback(page);
+		folio_end_writeback(folio);
 }
 
 /*
@@ -1054,8 +1047,7 @@ iomap_finish_ioend(struct iomap_ioend *ioend, int error)
 	bool quiet = bio_flagged(bio, BIO_QUIET);
 
 	for (bio = &ioend->io_inline_bio; bio; bio = next) {
-		struct bio_vec *bv;
-		struct bvec_iter_all iter_all;
+		struct folio_iter fi;
 
 		/*
 		 * For the last bio, bi_private points to the ioend, so we
@@ -1066,10 +1058,10 @@ iomap_finish_ioend(struct iomap_ioend *ioend, int error)
 		else
 			next = bio->bi_private;
 
-		/* walk each page on bio, ending page IO on them */
-		bio_for_each_segment_all(bv, bio, iter_all)
-			iomap_finish_page_writeback(inode, bv->bv_page, error,
-					bv->bv_len);
+		/* walk all folios in bio, ending page IO on them */
+		bio_for_each_folio_all(fi, bio)
+			iomap_finish_folio_write(inode, fi.folio, fi.length,
+					error);
 		bio_put(bio);
 	}
 	/* The ioend has been freed by bio_put() */
-- 
2.33.0

[PATCH v3 11/25] iomap: Use folio offsets instead of page offsets

[Matthew Wilcox (Oracle)]

Pass a folio around instead of the page, and make sure the offset
is relative to the start of the folio instead of the start of a page.
Also use size_t for offset & length to make it clear that these are byte
counts, and to support >2GB folios in the future.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 78 ++++++++++++++++++++++--------------------
 1 file changed, 40 insertions(+), 38 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 5730a3317407..06ff80c05340 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -75,18 +75,18 @@ static void iomap_page_release(struct folio *folio)
 }
 
 /*
- * Calculate the range inside the page that we actually need to read.
+ * Calculate the range inside the folio that we actually need to read.
  */
-static void
-iomap_adjust_read_range(struct inode *inode, struct iomap_page *iop,
-		loff_t *pos, loff_t length, unsigned *offp, unsigned *lenp)
+static void iomap_adjust_read_range(struct inode *inode, struct folio *folio,
+		loff_t *pos, loff_t length, size_t *offp, size_t *lenp)
 {
+	struct iomap_page *iop = to_iomap_page(folio);
 	loff_t orig_pos = *pos;
 	loff_t isize = i_size_read(inode);
 	unsigned block_bits = inode->i_blkbits;
 	unsigned block_size = (1 << block_bits);
-	unsigned poff = offset_in_page(*pos);
-	unsigned plen = min_t(loff_t, PAGE_SIZE - poff, length);
+	size_t poff = offset_in_folio(folio, *pos);
+	size_t plen = min_t(loff_t, folio_size(folio) - poff, length);
 	unsigned first = poff >> block_bits;
 	unsigned last = (poff + plen - 1) >> block_bits;
 
@@ -124,7 +124,7 @@ iomap_adjust_read_range(struct inode *inode, struct iomap_page *iop,
 	 * page cache for blocks that are entirely outside of i_size.
 	 */
 	if (orig_pos <= isize && orig_pos + length > isize) {
-		unsigned end = offset_in_page(isize - 1) >> block_bits;
+		unsigned end = offset_in_folio(folio, isize - 1) >> block_bits;
 
 		if (first <= end && last > end)
 			plen -= (last - end) * block_size;
@@ -134,31 +134,31 @@ iomap_adjust_read_range(struct inode *inode, struct iomap_page *iop,
 	*lenp = plen;
 }
 
-static void iomap_iop_set_range_uptodate(struct page *page,
-		struct iomap_page *iop, unsigned off, unsigned len)
+static void iomap_iop_set_range_uptodate(struct folio *folio,
+		struct iomap_page *iop, size_t off, size_t len)
 {
-	struct inode *inode = page->mapping->host;
+	struct inode *inode = folio->mapping->host;
 	unsigned first = off >> inode->i_blkbits;
 	unsigned last = (off + len - 1) >> inode->i_blkbits;
 	unsigned long flags;
 
 	spin_lock_irqsave(&iop->uptodate_lock, flags);
 	bitmap_set(iop->uptodate, first, last - first + 1);
-	if (bitmap_full(iop->uptodate, i_blocks_per_page(inode, page)))
-		SetPageUptodate(page);
+	if (bitmap_full(iop->uptodate, i_blocks_per_folio(inode, folio)))
+		folio_mark_uptodate(folio);
 	spin_unlock_irqrestore(&iop->uptodate_lock, flags);
 }
 
-static void iomap_set_range_uptodate(struct page *page,
-		struct iomap_page *iop, unsigned off, unsigned len)
+static void iomap_set_range_uptodate(struct folio *folio,
+		struct iomap_page *iop, size_t off, size_t len)
 {
-	if (PageError(page))
+	if (folio_test_error(folio))
 		return;
 
 	if (iop)
-		iomap_iop_set_range_uptodate(page, iop, off, len);
+		iomap_iop_set_range_uptodate(folio, iop, off, len);
 	else
-		SetPageUptodate(page);
+		folio_mark_uptodate(folio);
 }
 
 static void iomap_finish_folio_read(struct folio *folio, size_t offset,
@@ -170,7 +170,7 @@ static void iomap_finish_folio_read(struct folio *folio, size_t offset,
 		folio_clear_uptodate(folio);
 		folio_set_error(folio);
 	} else {
-		iomap_set_range_uptodate(&folio->page, iop, offset, len);
+		iomap_set_range_uptodate(folio, iop, offset, len);
 	}
 
 	if (!iop || atomic_sub_and_test(len, &iop->read_bytes_pending))
@@ -211,6 +211,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 	const struct iomap *iomap = iomap_iter_srcmap(iter);
 	size_t size = i_size_read(iter->inode) - iomap->offset;
 	size_t poff = offset_in_page(iomap->offset);
+	size_t offset = offset_in_folio(folio, iomap->offset);
 	void *addr;
 
 	if (PageUptodate(page))
@@ -223,7 +224,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 		return -EIO;
 	if (WARN_ON_ONCE(size > iomap->length))
 		return -EIO;
-	if (poff > 0)
+	if (offset > 0)
 		iop = iomap_page_create(iter->inode, folio);
 	else
 		iop = to_iomap_page(folio);
@@ -232,7 +233,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 	memcpy(addr, iomap->inline_data, size);
 	memset(addr + size, 0, PAGE_SIZE - poff - size);
 	kunmap_local(addr);
-	iomap_set_range_uptodate(page, iop, poff, PAGE_SIZE - poff);
+	iomap_set_range_uptodate(folio, iop, offset, PAGE_SIZE - poff);
 	return 0;
 }
 
@@ -256,7 +257,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 	struct folio *folio = page_folio(page);
 	struct iomap_page *iop;
 	loff_t orig_pos = pos;
-	unsigned poff, plen;
+	size_t poff, plen;
 	sector_t sector;
 
 	if (iomap->type == IOMAP_INLINE)
@@ -264,13 +265,13 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 
 	/* zero post-eof blocks as the page may be mapped */
 	iop = iomap_page_create(iter->inode, folio);
-	iomap_adjust_read_range(iter->inode, iop, &pos, length, &poff, &plen);
+	iomap_adjust_read_range(iter->inode, folio, &pos, length, &poff, &plen);
 	if (plen == 0)
 		goto done;
 
 	if (iomap_block_needs_zeroing(iter, pos)) {
-		zero_user(page, poff, plen);
-		iomap_set_range_uptodate(page, iop, poff, plen);
+		folio_zero_range(folio, poff, plen);
+		iomap_set_range_uptodate(folio, iop, poff, plen);
 		goto done;
 	}
 
@@ -281,7 +282,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 	sector = iomap_sector(iomap, pos);
 	if (!ctx->bio ||
 	    bio_end_sector(ctx->bio) != sector ||
-	    bio_add_page(ctx->bio, page, plen, poff) != plen) {
+	    !bio_add_folio(ctx->bio, folio, plen, poff)) {
 		gfp_t gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);
 		gfp_t orig_gfp = gfp;
 		unsigned int nr_vecs = DIV_ROUND_UP(length, PAGE_SIZE);
@@ -305,8 +306,9 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 		ctx->bio->bi_iter.bi_sector = sector;
 		bio_set_dev(ctx->bio, iomap->bdev);
 		ctx->bio->bi_end_io = iomap_read_end_io;
-		__bio_add_page(ctx->bio, page, plen, poff);
+		bio_add_folio(ctx->bio, folio, plen, poff);
 	}
+
 done:
 	/*
 	 * Move the caller beyond our range so that it keeps making progress.
@@ -535,9 +537,8 @@ iomap_write_failed(struct inode *inode, loff_t pos, unsigned len)
 		truncate_pagecache_range(inode, max(pos, i_size), pos + len);
 }
 
-static int
-iomap_read_page_sync(loff_t block_start, struct page *page, unsigned poff,
-		unsigned plen, const struct iomap *iomap)
+static int iomap_read_folio_sync(loff_t block_start, struct folio *folio,
+		size_t poff, size_t plen, const struct iomap *iomap)
 {
 	struct bio_vec bvec;
 	struct bio bio;
@@ -546,7 +547,7 @@ iomap_read_page_sync(loff_t block_start, struct page *page, unsigned poff,
 	bio.bi_opf = REQ_OP_READ;
 	bio.bi_iter.bi_sector = iomap_sector(iomap, block_start);
 	bio_set_dev(&bio, iomap->bdev);
-	__bio_add_page(&bio, page, plen, poff);
+	bio_add_folio(&bio, folio, plen, poff);
 	return submit_bio_wait(&bio);
 }
 
@@ -559,14 +560,15 @@ static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 	loff_t block_size = i_blocksize(iter->inode);
 	loff_t block_start = round_down(pos, block_size);
 	loff_t block_end = round_up(pos + len, block_size);
-	unsigned from = offset_in_page(pos), to = from + len, poff, plen;
+	size_t from = offset_in_folio(folio, pos), to = from + len;
+	size_t poff, plen;
 
-	if (PageUptodate(page))
+	if (folio_test_uptodate(folio))
 		return 0;
-	ClearPageError(page);
+	folio_clear_error(folio);
 
 	do {
-		iomap_adjust_read_range(iter->inode, iop, &block_start,
+		iomap_adjust_read_range(iter->inode, folio, &block_start,
 				block_end - block_start, &poff, &plen);
 		if (plen == 0)
 			break;
@@ -579,14 +581,14 @@ static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 		if (iomap_block_needs_zeroing(iter, block_start)) {
 			if (WARN_ON_ONCE(iter->flags & IOMAP_UNSHARE))
 				return -EIO;
-			zero_user_segments(page, poff, from, to, poff + plen);
+			folio_zero_segments(folio, poff, from, to, poff + plen);
 		} else {
-			int status = iomap_read_page_sync(block_start, page,
+			int status = iomap_read_folio_sync(block_start, folio,
 					poff, plen, srcmap);
 			if (status)
 				return status;
 		}
-		iomap_set_range_uptodate(page, iop, poff, plen);
+		iomap_set_range_uptodate(folio, iop, poff, plen);
 	} while ((block_start += plen) < block_end);
 
 	return 0;
@@ -675,7 +677,7 @@ static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
 	 */
 	if (unlikely(copied < len && !PageUptodate(page)))
 		return 0;
-	iomap_set_range_uptodate(page, iop, offset_in_page(pos), len);
+	iomap_set_range_uptodate(folio, iop, offset_in_folio(folio, pos), len);
 	__set_page_dirty_nobuffers(page);
 	return copied;
 }
-- 
2.33.0

[PATCH v3 12/25] iomap: Convert iomap_read_inline_data to take a folio

[Matthew Wilcox (Oracle)]

We still only support up to a single page of inline data (at least,
per call to iomap_read_inline_data()), but it can now be written into
the middle of a folio in case we decide to allocate a 16KiB page for
a file that's 8.1KiB in size.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 06ff80c05340..2ebea02780b8 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -197,16 +197,15 @@ struct iomap_readpage_ctx {
 /**
  * iomap_read_inline_data - copy inline data into the page cache
  * @iter: iteration structure
- * @page: page to copy to
+ * @folio: folio to copy to
  *
- * Copy the inline data in @iter into @page and zero out the rest of the page.
+ * Copy the inline data in @iter into @folio and zero out the rest of the folio.
  * Only a single IOMAP_INLINE extent is allowed at the end of each file.
  * Returns zero for success to complete the read, or the usual negative errno.
  */
 static int iomap_read_inline_data(const struct iomap_iter *iter,
-		struct page *page)
+		struct folio *folio)
 {
-	struct folio *folio = page_folio(page);
 	struct iomap_page *iop;
 	const struct iomap *iomap = iomap_iter_srcmap(iter);
 	size_t size = i_size_read(iter->inode) - iomap->offset;
@@ -214,7 +213,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 	size_t offset = offset_in_folio(folio, iomap->offset);
 	void *addr;
 
-	if (PageUptodate(page))
+	if (folio_test_uptodate(folio))
 		return 0;
 
 	if (WARN_ON_ONCE(size > PAGE_SIZE - poff))
@@ -229,7 +228,7 @@ static int iomap_read_inline_data(const struct iomap_iter *iter,
 	else
 		iop = to_iomap_page(folio);
 
-	addr = kmap_local_page(page) + poff;
+	addr = kmap_local_folio(folio, offset);
 	memcpy(addr, iomap->inline_data, size);
 	memset(addr + size, 0, PAGE_SIZE - poff - size);
 	kunmap_local(addr);
@@ -261,7 +260,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 	sector_t sector;
 
 	if (iomap->type == IOMAP_INLINE)
-		return iomap_read_inline_data(iter, page);
+		return iomap_read_inline_data(iter, folio);
 
 	/* zero post-eof blocks as the page may be mapped */
 	iop = iomap_page_create(iter->inode, folio);
@@ -597,10 +596,12 @@ static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 static int iomap_write_begin_inline(const struct iomap_iter *iter,
 		struct page *page)
 {
+	struct folio *folio = page_folio(page);
+
 	/* needs more work for the tailpacking case; disable for now */
 	if (WARN_ON_ONCE(iomap_iter_srcmap(iter)->offset != 0))
 		return -EIO;
-	return iomap_read_inline_data(iter, page);
+	return iomap_read_inline_data(iter, folio);
 }
 
 static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
-- 
2.33.0

[PATCH v3 13/25] iomap: Convert readahead and readpage to use a folio

[Matthew Wilcox (Oracle)]

Handle folios of arbitrary size instead of working in PAGE_SIZE units.
readahead_folio() decreases the page refcount for you, so this is not
quite a mechanical change.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 53 +++++++++++++++++++++---------------------
 1 file changed, 26 insertions(+), 27 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 2ebea02780b8..ad89c20cb741 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -188,8 +188,8 @@ static void iomap_read_end_io(struct bio *bio)
 }
 
 struct iomap_readpage_ctx {
-	struct page		*cur_page;
-	bool			cur_page_in_bio;
+	struct folio		*cur_folio;
+	bool			cur_folio_in_bio;
 	struct bio		*bio;
 	struct readahead_control *rac;
 };
@@ -252,8 +252,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 	const struct iomap *iomap = &iter->iomap;
 	loff_t pos = iter->pos + offset;
 	loff_t length = iomap_length(iter) - offset;
-	struct page *page = ctx->cur_page;
-	struct folio *folio = page_folio(page);
+	struct folio *folio = ctx->cur_folio;
 	struct iomap_page *iop;
 	loff_t orig_pos = pos;
 	size_t poff, plen;
@@ -274,7 +273,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 		goto done;
 	}
 
-	ctx->cur_page_in_bio = true;
+	ctx->cur_folio_in_bio = true;
 	if (iop)
 		atomic_add(plen, &iop->read_bytes_pending);
 
@@ -282,7 +281,7 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 	if (!ctx->bio ||
 	    bio_end_sector(ctx->bio) != sector ||
 	    !bio_add_folio(ctx->bio, folio, plen, poff)) {
-		gfp_t gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);
+		gfp_t gfp = mapping_gfp_constraint(folio->mapping, GFP_KERNEL);
 		gfp_t orig_gfp = gfp;
 		unsigned int nr_vecs = DIV_ROUND_UP(length, PAGE_SIZE);
 
@@ -321,30 +320,31 @@ static loff_t iomap_readpage_iter(const struct iomap_iter *iter,
 int
 iomap_readpage(struct page *page, const struct iomap_ops *ops)
 {
+	struct folio *folio = page_folio(page);
 	struct iomap_iter iter = {
-		.inode		= page->mapping->host,
-		.pos		= page_offset(page),
-		.len		= PAGE_SIZE,
+		.inode		= folio->mapping->host,
+		.pos		= folio_pos(folio),
+		.len		= folio_size(folio),
 	};
 	struct iomap_readpage_ctx ctx = {
-		.cur_page	= page,
+		.cur_folio	= folio,
 	};
 	int ret;
 
-	trace_iomap_readpage(page->mapping->host, 1);
+	trace_iomap_readpage(iter.inode, 1);
 
 	while ((ret = iomap_iter(&iter, ops)) > 0)
 		iter.processed = iomap_readpage_iter(&iter, &ctx, 0);
 
 	if (ret < 0)
-		SetPageError(page);
+		folio_set_error(folio);
 
 	if (ctx.bio) {
 		submit_bio(ctx.bio);
-		WARN_ON_ONCE(!ctx.cur_page_in_bio);
+		WARN_ON_ONCE(!ctx.cur_folio_in_bio);
 	} else {
-		WARN_ON_ONCE(ctx.cur_page_in_bio);
-		unlock_page(page);
+		WARN_ON_ONCE(ctx.cur_folio_in_bio);
+		folio_unlock(folio);
 	}
 
 	/*
@@ -363,15 +363,15 @@ static loff_t iomap_readahead_iter(const struct iomap_iter *iter,
 	loff_t done, ret;
 
 	for (done = 0; done < length; done += ret) {
-		if (ctx->cur_page && offset_in_page(iter->pos + done) == 0) {
-			if (!ctx->cur_page_in_bio)
-				unlock_page(ctx->cur_page);
-			put_page(ctx->cur_page);
-			ctx->cur_page = NULL;
+		if (ctx->cur_folio &&
+		    offset_in_folio(ctx->cur_folio, iter->pos + done) == 0) {
+			if (!ctx->cur_folio_in_bio)
+				folio_unlock(ctx->cur_folio);
+			ctx->cur_folio = NULL;
 		}
-		if (!ctx->cur_page) {
-			ctx->cur_page = readahead_page(ctx->rac);
-			ctx->cur_page_in_bio = false;
+		if (!ctx->cur_folio) {
+			ctx->cur_folio = readahead_folio(ctx->rac);
+			ctx->cur_folio_in_bio = false;
 		}
 		ret = iomap_readpage_iter(iter, ctx, done);
 		if (ret <= 0)
@@ -414,10 +414,9 @@ void iomap_readahead(struct readahead_control *rac, const struct iomap_ops *ops)
 
 	if (ctx.bio)
 		submit_bio(ctx.bio);
-	if (ctx.cur_page) {
-		if (!ctx.cur_page_in_bio)
-			unlock_page(ctx.cur_page);
-		put_page(ctx.cur_page);
+	if (ctx.cur_folio) {
+		if (!ctx.cur_folio_in_bio)
+			folio_unlock(ctx.cur_folio);
 	}
 }
 EXPORT_SYMBOL_GPL(iomap_readahead);
-- 
2.33.0

[PATCH v3 14/25] iomap: Convert iomap_page_mkwrite to use a folio

[Matthew Wilcox (Oracle)]

If we write to any page in a folio, we have to mark the entire
folio as dirty, and potentially COW the entire folio, because it'll
all get written back as one unit.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index ad89c20cb741..8d7a67655b60 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -967,10 +967,9 @@ iomap_truncate_page(struct inode *inode, loff_t pos, bool *did_zero,
 }
 EXPORT_SYMBOL_GPL(iomap_truncate_page);
 
-static loff_t iomap_page_mkwrite_iter(struct iomap_iter *iter,
-		struct page *page)
+static loff_t iomap_folio_mkwrite_iter(struct iomap_iter *iter,
+		struct folio *folio)
 {
-	struct folio *folio = page_folio(page);
 	loff_t length = iomap_length(iter);
 	int ret;
 
@@ -979,10 +978,10 @@ static loff_t iomap_page_mkwrite_iter(struct iomap_iter *iter,
 					      &iter->iomap);
 		if (ret)
 			return ret;
-		block_commit_write(page, 0, length);
+		block_commit_write(&folio->page, 0, length);
 	} else {
-		WARN_ON_ONCE(!PageUptodate(page));
-		set_page_dirty(page);
+		WARN_ON_ONCE(!folio_test_uptodate(folio));
+		folio_mark_dirty(folio);
 	}
 
 	return length;
@@ -994,24 +993,24 @@ vm_fault_t iomap_page_mkwrite(struct vm_fault *vmf, const struct iomap_ops *ops)
 		.inode		= file_inode(vmf->vma->vm_file),
 		.flags		= IOMAP_WRITE | IOMAP_FAULT,
 	};
-	struct page *page = vmf->page;
+	struct folio *folio = page_folio(vmf->page);
 	ssize_t ret;
 
-	lock_page(page);
-	ret = page_mkwrite_check_truncate(page, iter.inode);
+	folio_lock(folio);
+	ret = folio_mkwrite_check_truncate(folio, iter.inode);
 	if (ret < 0)
 		goto out_unlock;
-	iter.pos = page_offset(page);
+	iter.pos = folio_pos(folio);
 	iter.len = ret;
 	while ((ret = iomap_iter(&iter, ops)) > 0)
-		iter.processed = iomap_page_mkwrite_iter(&iter, page);
+		iter.processed = iomap_folio_mkwrite_iter(&iter, folio);
 
 	if (ret < 0)
 		goto out_unlock;
-	wait_for_stable_page(page);
+	folio_wait_stable(folio);
 	return VM_FAULT_LOCKED;
 out_unlock:
-	unlock_page(page);
+	folio_unlock(folio);
 	return block_page_mkwrite_return(ret);
 }
 EXPORT_SYMBOL_GPL(iomap_page_mkwrite);
-- 
2.33.0

[PATCH v3 15/25] iomap: Allow iomap_write_begin() to be called with the full length

[Matthew Wilcox (Oracle)]

In the future, we want write_begin to know the entire length of the
write so that it can choose to allocate large folios.  Pass the full
length in from __iomap_zero_iter() and limit it where necessary.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
---
 fs/iomap/buffered-io.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 8d7a67655b60..b1ded5204d1c 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -619,6 +619,9 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 	if (fatal_signal_pending(current))
 		return -EINTR;
 
+	if (!mapping_large_folio_support(iter->inode->i_mapping))
+		len = min_t(size_t, len, PAGE_SIZE - offset_in_page(pos));
+
 	if (page_ops && page_ops->page_prepare) {
 		status = page_ops->page_prepare(iter->inode, pos, len);
 		if (status)
@@ -632,6 +635,8 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 		goto out_no_page;
 	}
 	folio = page_folio(page);
+	if (pos + len > folio_pos(folio) + folio_size(folio))
+		len = folio_pos(folio) + folio_size(folio) - pos;
 
 	if (srcmap->type == IOMAP_INLINE)
 		status = iomap_write_begin_inline(iter, page);
@@ -891,11 +896,13 @@ static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
 	struct page *page;
 	int status;
 	unsigned offset = offset_in_page(pos);
-	unsigned bytes = min_t(u64, PAGE_SIZE - offset, length);
+	unsigned bytes = min_t(u64, UINT_MAX, length);
 
 	status = iomap_write_begin(iter, pos, bytes, &page);
 	if (status)
 		return status;
+	if (bytes > PAGE_SIZE - offset)
+		bytes = PAGE_SIZE - offset;
 
 	zero_user(page, offset, bytes);
 	mark_page_accessed(page);
-- 
2.33.0

Re: [PATCH v3 15/25] iomap: Allow iomap_write_begin() to be called with the full length

[Darrick J. Wong]

On Thu, Dec 16, 2021 at 09:07:05PM +0000, Matthew Wilcox (Oracle) wrote:
> In the future, we want write_begin to know the entire length of the
> write so that it can choose to allocate large folios.  Pass the full
> length in from __iomap_zero_iter() and limit it where necessary.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

Seems reasonable,
Reviewed-by: Darrick J. Wong <djwong@kernel.org>

--D

> ---
>  fs/iomap/buffered-io.c | 9 ++++++++-
>  1 file changed, 8 insertions(+), 1 deletion(-)
> 
> diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
> index 8d7a67655b60..b1ded5204d1c 100644
> --- a/fs/iomap/buffered-io.c
> +++ b/fs/iomap/buffered-io.c
> @@ -619,6 +619,9 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
>  	if (fatal_signal_pending(current))
>  		return -EINTR;
>  
> +	if (!mapping_large_folio_support(iter->inode->i_mapping))
> +		len = min_t(size_t, len, PAGE_SIZE - offset_in_page(pos));
> +
>  	if (page_ops && page_ops->page_prepare) {
>  		status = page_ops->page_prepare(iter->inode, pos, len);
>  		if (status)
> @@ -632,6 +635,8 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
>  		goto out_no_page;
>  	}
>  	folio = page_folio(page);
> +	if (pos + len > folio_pos(folio) + folio_size(folio))
> +		len = folio_pos(folio) + folio_size(folio) - pos;
>  
>  	if (srcmap->type == IOMAP_INLINE)
>  		status = iomap_write_begin_inline(iter, page);
> @@ -891,11 +896,13 @@ static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
>  	struct page *page;
>  	int status;
>  	unsigned offset = offset_in_page(pos);
> -	unsigned bytes = min_t(u64, PAGE_SIZE - offset, length);
> +	unsigned bytes = min_t(u64, UINT_MAX, length);
>  
>  	status = iomap_write_begin(iter, pos, bytes, &page);
>  	if (status)
>  		return status;
> +	if (bytes > PAGE_SIZE - offset)
> +		bytes = PAGE_SIZE - offset;
>  
>  	zero_user(page, offset, bytes);
>  	mark_page_accessed(page);
> -- 
> 2.33.0
> 

[PATCH v3 16/25] iomap: Convert __iomap_zero_iter to use a folio

[Matthew Wilcox (Oracle)]

The zero iterator can work in folio-sized chunks instead of page-sized
chunks.  This will save a lot of page cache lookups if the file is cached
in large folios.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index b1ded5204d1c..47cf558244f4 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -893,19 +893,23 @@ EXPORT_SYMBOL_GPL(iomap_file_unshare);
 
 static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
 {
+	struct folio *folio;
 	struct page *page;
 	int status;
-	unsigned offset = offset_in_page(pos);
+	size_t offset;
 	unsigned bytes = min_t(u64, UINT_MAX, length);
 
 	status = iomap_write_begin(iter, pos, bytes, &page);
 	if (status)
 		return status;
-	if (bytes > PAGE_SIZE - offset)
-		bytes = PAGE_SIZE - offset;
+	folio = page_folio(page);
+
+	offset = offset_in_folio(folio, pos);
+	if (bytes > folio_size(folio) - offset)
+		bytes = folio_size(folio) - offset;
 
-	zero_user(page, offset, bytes);
-	mark_page_accessed(page);
+	folio_zero_range(folio, offset, bytes);
+	folio_mark_accessed(folio);
 
 	return iomap_write_end(iter, pos, bytes, bytes, page);
 }
-- 
2.33.0

iomap-folio & nvdimm merge

[Matthew Wilcox]

On Thu, Dec 16, 2021 at 09:07:06PM +0000, Matthew Wilcox (Oracle) wrote:
> The zero iterator can work in folio-sized chunks instead of page-sized
> chunks.  This will save a lot of page cache lookups if the file is cached
> in large folios.

This patch (and a few others) end up conflicting with what Christoph did
that's now in the nvdimm tree.  In an effort to make the merge cleaner,
I took the next-20211220 tag and did the following:

Revert de291b590286
Apply: https://lore.kernel.org/linux-xfs/20211221044450.517558-1-willy@infradead.org/
(these two things are likely to happen in the nvdimm tree imminently)

I then checked out iomap-folio-5.17e and added this patch:

    iomap: Inline __iomap_zero_iter into its caller

    To make the merge easier, replicate the inlining of __iomap_zero_iter()
    into iomap_zero_iter() that is currently in the nvdimm tree.

    Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index ba80bedd9590..c6b3a148e898 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -895,27 +895,6 @@ iomap_file_unshare(struct inode *inode, loff_t pos, loff_t len,
 }
 EXPORT_SYMBOL_GPL(iomap_file_unshare);
 
-static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
-{
-       struct folio *folio;
-       int status;
-       size_t offset;
-       size_t bytes = min_t(u64, SIZE_MAX, length);
-
-       status = iomap_write_begin(iter, pos, bytes, &folio);
-       if (status)
-               return status;
-
-       offset = offset_in_folio(folio, pos);
-       if (bytes > folio_size(folio) - offset)
-               bytes = folio_size(folio) - offset;
-
-       folio_zero_range(folio, offset, bytes);
-       folio_mark_accessed(folio);
-
-       return iomap_write_end(iter, pos, bytes, bytes, folio);
-}
-
 static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)
 {
        struct iomap *iomap = &iter->iomap;
@@ -929,14 +908,34 @@ static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)
                return length;
 
        do {
-               s64 bytes;
+               struct folio *folio;
+               int status;
+               size_t offset;
+               size_t bytes = min_t(u64, SIZE_MAX, length);
+
+               if (IS_DAX(iter->inode)) {
+                       s64 tmp = dax_iomap_zero(pos, bytes, iomap);
+                       if (tmp < 0)
+                               return tmp;
+                       bytes = tmp;
+                       goto good;
+               }
 
-               if (IS_DAX(iter->inode))
-                       bytes = dax_iomap_zero(pos, length, iomap);
-               else
-                       bytes = __iomap_zero_iter(iter, pos, length);
-               if (bytes < 0)
-                       return bytes;
+               status = iomap_write_begin(iter, pos, bytes, &folio);
+               if (status)
+                       return status;
+
+               offset = offset_in_folio(folio, pos);
+               if (bytes > folio_size(folio) - offset)
+                       bytes = folio_size(folio) - offset;
+
+               folio_zero_range(folio, offset, bytes);
+               folio_mark_accessed(folio);
+
+               bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
+good:
+               if (WARN_ON_ONCE(bytes == 0))
+                       return -EIO;
 
                pos += bytes;
                length -= bytes;



Then I did the merge, and the merge commit looks pretty sensible
afterwards:

    Merge branch 'iomap-folio-5.17f' into fixup

diff --cc fs/iomap/buffered-io.c
index 955f51f94b3f,c6b3a148e898..c938bbad075e
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@@ -888,19 -908,32 +907,23 @@@ static loff_t iomap_zero_iter(struct io
                return length;

        do {
-               unsigned offset = offset_in_page(pos);
-               size_t bytes = min_t(u64, PAGE_SIZE - offset, length);
-               struct page *page;
+               struct folio *folio;
                int status;
+               size_t offset;
+               size_t bytes = min_t(u64, SIZE_MAX, length);

-               status = iomap_write_begin(iter, pos, bytes, &page);
 -              if (IS_DAX(iter->inode)) {
 -                      s64 tmp = dax_iomap_zero(pos, bytes, iomap);
 -                      if (tmp < 0)
 -                              return tmp;
 -                      bytes = tmp;
 -                      goto good;
 -              }
 -
+               status = iomap_write_begin(iter, pos, bytes, &folio);
                if (status)
                        return status;

-               zero_user(page, offset, bytes);
-               mark_page_accessed(page);
+               offset = offset_in_folio(folio, pos);
+               if (bytes > folio_size(folio) - offset)
+                       bytes = folio_size(folio) - offset;
+
+               folio_zero_range(folio, offset, bytes);
+               folio_mark_accessed(folio);

-               bytes = iomap_write_end(iter, pos, bytes, bytes, page);
+               bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
 -good:
                if (WARN_ON_ONCE(bytes == 0))
                        return -EIO;



Shall I push out a version of this patch series which includes the
"iomap: Inline __iomap_zero_iter into its caller" patch I pasted above?

Re: iomap-folio & nvdimm merge

[Darrick J. Wong]

On Tue, Dec 21, 2021 at 05:01:34PM +0000, Matthew Wilcox wrote:
> On Thu, Dec 16, 2021 at 09:07:06PM +0000, Matthew Wilcox (Oracle) wrote:
> > The zero iterator can work in folio-sized chunks instead of page-sized
> > chunks.  This will save a lot of page cache lookups if the file is cached
> > in large folios.
> 
> This patch (and a few others) end up conflicting with what Christoph did
> that's now in the nvdimm tree.  In an effort to make the merge cleaner,
> I took the next-20211220 tag and did the following:
> 
> Revert de291b590286
> Apply: https://lore.kernel.org/linux-xfs/20211221044450.517558-1-willy@infradead.org/
> (these two things are likely to happen in the nvdimm tree imminently)
> 
> I then checked out iomap-folio-5.17e and added this patch:
> 
>     iomap: Inline __iomap_zero_iter into its caller
> 
>     To make the merge easier, replicate the inlining of __iomap_zero_iter()
>     into iomap_zero_iter() that is currently in the nvdimm tree.
> 
>     Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

Looks like a reasonable function promotion to me...
Reviewed-by: Darrick J. Wong <djwong@kernel.org>

> 
> diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
> index ba80bedd9590..c6b3a148e898 100644
> --- a/fs/iomap/buffered-io.c
> +++ b/fs/iomap/buffered-io.c
> @@ -895,27 +895,6 @@ iomap_file_unshare(struct inode *inode, loff_t pos, loff_t len,
>  }
>  EXPORT_SYMBOL_GPL(iomap_file_unshare);
>  
> -static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
> -{
> -       struct folio *folio;
> -       int status;
> -       size_t offset;
> -       size_t bytes = min_t(u64, SIZE_MAX, length);
> -
> -       status = iomap_write_begin(iter, pos, bytes, &folio);
> -       if (status)
> -               return status;
> -
> -       offset = offset_in_folio(folio, pos);
> -       if (bytes > folio_size(folio) - offset)
> -               bytes = folio_size(folio) - offset;
> -
> -       folio_zero_range(folio, offset, bytes);
> -       folio_mark_accessed(folio);
> -
> -       return iomap_write_end(iter, pos, bytes, bytes, folio);
> -}
> -
>  static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)
>  {
>         struct iomap *iomap = &iter->iomap;
> @@ -929,14 +908,34 @@ static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)
>                 return length;
>  
>         do {
> -               s64 bytes;
> +               struct folio *folio;
> +               int status;
> +               size_t offset;
> +               size_t bytes = min_t(u64, SIZE_MAX, length);
> +
> +               if (IS_DAX(iter->inode)) {
> +                       s64 tmp = dax_iomap_zero(pos, bytes, iomap);
> +                       if (tmp < 0)
> +                               return tmp;
> +                       bytes = tmp;
> +                       goto good;
> +               }
>  
> -               if (IS_DAX(iter->inode))
> -                       bytes = dax_iomap_zero(pos, length, iomap);
> -               else
> -                       bytes = __iomap_zero_iter(iter, pos, length);
> -               if (bytes < 0)
> -                       return bytes;
> +               status = iomap_write_begin(iter, pos, bytes, &folio);
> +               if (status)
> +                       return status;
> +
> +               offset = offset_in_folio(folio, pos);
> +               if (bytes > folio_size(folio) - offset)
> +                       bytes = folio_size(folio) - offset;
> +
> +               folio_zero_range(folio, offset, bytes);
> +               folio_mark_accessed(folio);
> +
> +               bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
> +good:
> +               if (WARN_ON_ONCE(bytes == 0))
> +                       return -EIO;
>  
>                 pos += bytes;
>                 length -= bytes;
> 
> 
> 
> Then I did the merge, and the merge commit looks pretty sensible
> afterwards:
> 
>     Merge branch 'iomap-folio-5.17f' into fixup
> 
> diff --cc fs/iomap/buffered-io.c
> index 955f51f94b3f,c6b3a148e898..c938bbad075e
> --- a/fs/iomap/buffered-io.c
> +++ b/fs/iomap/buffered-io.c
> @@@ -888,19 -908,32 +907,23 @@@ static loff_t iomap_zero_iter(struct io
>                 return length;
> 
>         do {
> -               unsigned offset = offset_in_page(pos);
> -               size_t bytes = min_t(u64, PAGE_SIZE - offset, length);
> -               struct page *page;
> +               struct folio *folio;
>                 int status;
> +               size_t offset;
> +               size_t bytes = min_t(u64, SIZE_MAX, length);
> 
> -               status = iomap_write_begin(iter, pos, bytes, &page);
>  -              if (IS_DAX(iter->inode)) {
>  -                      s64 tmp = dax_iomap_zero(pos, bytes, iomap);
>  -                      if (tmp < 0)
>  -                              return tmp;
>  -                      bytes = tmp;
>  -                      goto good;
>  -              }
>  -
> +               status = iomap_write_begin(iter, pos, bytes, &folio);
>                 if (status)
>                         return status;
> 
> -               zero_user(page, offset, bytes);
> -               mark_page_accessed(page);
> +               offset = offset_in_folio(folio, pos);
> +               if (bytes > folio_size(folio) - offset)
> +                       bytes = folio_size(folio) - offset;
> +
> +               folio_zero_range(folio, offset, bytes);
> +               folio_mark_accessed(folio);
> 
> -               bytes = iomap_write_end(iter, pos, bytes, bytes, page);
> +               bytes = iomap_write_end(iter, pos, bytes, bytes, folio);
>  -good:

Assuming I'm reading the metadiff properly, I think this merge
resolution looks correct given what both patchsets are trying to do.

>                 if (WARN_ON_ONCE(bytes == 0))
>                         return -EIO;
> 
> 
> 
> Shall I push out a version of this patch series which includes the
> "iomap: Inline __iomap_zero_iter into its caller" patch I pasted above?

Yes.

I've been distracted for months with first a Huge Customer Escalation
and now a <embargoed>, which means that I've been and continue to be
very distracted.  I /think/ there are no other iomap patches being
proposed for inclusion -- Andreas' patches were applied as fixes during
5.16-rc, Christoph's DAX refactoring is now in the nvdimm tree, and that
leaves Matthew's folios refactoring.

So seeing as (I think?) there are no other iomap patches for 5.17, if
Matthew wants to add his branch to for-next and push directly to Linus
(rather than pushing to me to push the exact same branch to Linus) I
think that would be ... better than letting it block on me.  IIRC I've
RVB'd everything in the folios branch. :(

FWIW I ran the 5.17e branch through my fstests cloud and nothing fell
out, so I think it's in good enough shape to merge to for-next.

--D

Re: iomap-folio & nvdimm merge

[Matthew Wilcox]

On Tue, Dec 21, 2021 at 10:41:15AM -0800, Darrick J. Wong wrote:
> >     iomap: Inline __iomap_zero_iter into its caller
> > 
> >     To make the merge easier, replicate the inlining of __iomap_zero_iter()
> >     into iomap_zero_iter() that is currently in the nvdimm tree.
> > 
> >     Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> 
> Looks like a reasonable function promotion to me...
> Reviewed-by: Darrick J. Wong <djwong@kernel.org>

Thanks, applied that to the commit.

> > Shall I push out a version of this patch series which includes the
> > "iomap: Inline __iomap_zero_iter into its caller" patch I pasted above?
> 
> Yes.
> 
> I've been distracted for months with first a Huge Customer Escalation
> and now a <embargoed>, which means that I've been and continue to be
> very distracted.  I /think/ there are no other iomap patches being
> proposed for inclusion -- Andreas' patches were applied as fixes during
> 5.16-rc, Christoph's DAX refactoring is now in the nvdimm tree, and that
> leaves Matthew's folios refactoring.
> 
> So seeing as (I think?) there are no other iomap patches for 5.17, if
> Matthew wants to add his branch to for-next and push directly to Linus
> (rather than pushing to me to push the exact same branch to Linus) I
> think that would be ... better than letting it block on me.  IIRC I've
> RVB'd everything in the folios branch. :(
> 
> FWIW I ran the 5.17e branch through my fstests cloud and nothing fell
> out, so I think it's in good enough shape to merge to for-next.

Glad to hear it passed that thorough testing.  Stephen, please pick
up a new tree (hopefully just temporarily until Darrick can swim to
the surface):

 git://git.infradead.org/users/willy/linux.git folio-iomap

Hopefully the previous message will give you enough context for
the merge conflict resolution.

Re: iomap-folio & nvdimm merge

[Stephen Rothwell]

[-- Attachment #1: Type: text/plain, Size: 1342 bytes --]

Hi Matthew,

On Tue, 21 Dec 2021 18:53:25 +0000 Matthew Wilcox <willy@infradead.org> wrote:
>
> Glad to hear it passed that thorough testing.  Stephen, please pick
> up a new tree (hopefully just temporarily until Darrick can swim to
> the surface):
> 
>  git://git.infradead.org/users/willy/linux.git folio-iomap
> 
> Hopefully the previous message will give you enough context for
> the merge conflict resolution.

I have added that after the folio tree today.

Thanks for adding your subsystem tree as a participant of linux-next.  As
you may know, this is not a judgement of your code.  The purpose of
linux-next is for integration testing and to lower the impact of
conflicts between subsystems in the next merge window. 

You will need to ensure that the patches/commits in your tree/series have
been:
     * submitted under GPL v2 (or later) and include the Contributor's
        Signed-off-by,
     * posted to the relevant mailing list,
     * reviewed by you (or another maintainer of your subsystem tree),
     * successfully unit tested, and 
     * destined for the current or next Linux merge window.

Basically, this should be just what you would send to Linus (or ask him
to fetch).  It is allowed to be rebased if you deem it necessary.

-- 
Cheers,
Stephen Rothwell 
sfr@canb.auug.org.au

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

[PATCH v3 17/25] iomap: Convert iomap_write_begin() and iomap_write_end() to folios

[Matthew Wilcox (Oracle)]

These functions still only work in PAGE_SIZE chunks, but there are
fewer conversions from tail to head pages as a result of this patch.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 73 ++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 39 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 47cf558244f4..975a4a6aeca0 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -550,9 +550,8 @@ static int iomap_read_folio_sync(loff_t block_start, struct folio *folio,
 }
 
 static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
-		unsigned len, struct page *page)
+		size_t len, struct folio *folio)
 {
-	struct folio *folio = page_folio(page);
 	const struct iomap *srcmap = iomap_iter_srcmap(iter);
 	struct iomap_page *iop = iomap_page_create(iter->inode, folio);
 	loff_t block_size = i_blocksize(iter->inode);
@@ -593,10 +592,8 @@ static int __iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 }
 
 static int iomap_write_begin_inline(const struct iomap_iter *iter,
-		struct page *page)
+		struct folio *folio)
 {
-	struct folio *folio = page_folio(page);
-
 	/* needs more work for the tailpacking case; disable for now */
 	if (WARN_ON_ONCE(iomap_iter_srcmap(iter)->offset != 0))
 		return -EIO;
@@ -604,12 +601,12 @@ static int iomap_write_begin_inline(const struct iomap_iter *iter,
 }
 
 static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
-		unsigned len, struct page **pagep)
+		size_t len, struct folio **foliop)
 {
 	const struct iomap_page_ops *page_ops = iter->iomap.page_ops;
 	const struct iomap *srcmap = iomap_iter_srcmap(iter);
-	struct page *page;
 	struct folio *folio;
+	unsigned fgp = FGP_LOCK | FGP_WRITE | FGP_CREAT | FGP_STABLE | FGP_NOFS;
 	int status = 0;
 
 	BUG_ON(pos + len > iter->iomap.offset + iter->iomap.length);
@@ -620,7 +617,7 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 		return -EINTR;
 
 	if (!mapping_large_folio_support(iter->inode->i_mapping))
-		len = min_t(size_t, len, PAGE_SIZE - offset_in_page(pos));
+		len = min(len, PAGE_SIZE - offset_in_page(pos));
 
 	if (page_ops && page_ops->page_prepare) {
 		status = page_ops->page_prepare(iter->inode, pos, len);
@@ -628,32 +625,31 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 			return status;
 	}
 
-	page = grab_cache_page_write_begin(iter->inode->i_mapping,
-				pos >> PAGE_SHIFT, AOP_FLAG_NOFS);
-	if (!page) {
+	folio = __filemap_get_folio(iter->inode->i_mapping, pos >> PAGE_SHIFT,
+			fgp, mapping_gfp_mask(iter->inode->i_mapping));
+	if (!folio) {
 		status = -ENOMEM;
 		goto out_no_page;
 	}
-	folio = page_folio(page);
 	if (pos + len > folio_pos(folio) + folio_size(folio))
 		len = folio_pos(folio) + folio_size(folio) - pos;
 
 	if (srcmap->type == IOMAP_INLINE)
-		status = iomap_write_begin_inline(iter, page);
+		status = iomap_write_begin_inline(iter, folio);
 	else if (srcmap->flags & IOMAP_F_BUFFER_HEAD)
 		status = __block_write_begin_int(folio, pos, len, NULL, srcmap);
 	else
-		status = __iomap_write_begin(iter, pos, len, page);
+		status = __iomap_write_begin(iter, pos, len, folio);
 
 	if (unlikely(status))
 		goto out_unlock;
 
-	*pagep = page;
+	*foliop = folio;
 	return 0;
 
 out_unlock:
-	unlock_page(page);
-	put_page(page);
+	folio_unlock(folio);
+	folio_put(folio);
 	iomap_write_failed(iter->inode, pos, len);
 
 out_no_page:
@@ -663,11 +659,10 @@ static int iomap_write_begin(const struct iomap_iter *iter, loff_t pos,
 }
 
 static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
-		size_t copied, struct page *page)
+		size_t copied, struct folio *folio)
 {
-	struct folio *folio = page_folio(page);
 	struct iomap_page *iop = to_iomap_page(folio);
-	flush_dcache_page(page);
+	flush_dcache_folio(folio);
 
 	/*
 	 * The blocks that were entirely written will now be uptodate, so we
@@ -680,10 +675,10 @@ static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
 	 * non-uptodate page as a zero-length write, and force the caller to
 	 * redo the whole thing.
 	 */
-	if (unlikely(copied < len && !PageUptodate(page)))
+	if (unlikely(copied < len && !folio_test_uptodate(folio)))
 		return 0;
 	iomap_set_range_uptodate(folio, iop, offset_in_folio(folio, pos), len);
-	__set_page_dirty_nobuffers(page);
+	filemap_dirty_folio(inode->i_mapping, folio);
 	return copied;
 }
 
@@ -707,7 +702,7 @@ static size_t iomap_write_end_inline(const struct iomap_iter *iter,
 
 /* Returns the number of bytes copied.  May be 0.  Cannot be an errno. */
 static size_t iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,
-		size_t copied, struct page *page)
+		size_t copied, struct folio *folio)
 {
 	const struct iomap_page_ops *page_ops = iter->iomap.page_ops;
 	const struct iomap *srcmap = iomap_iter_srcmap(iter);
@@ -715,12 +710,12 @@ static size_t iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,
 	size_t ret;
 
 	if (srcmap->type == IOMAP_INLINE) {
-		ret = iomap_write_end_inline(iter, page, pos, copied);
+		ret = iomap_write_end_inline(iter, &folio->page, pos, copied);
 	} else if (srcmap->flags & IOMAP_F_BUFFER_HEAD) {
 		ret = block_write_end(NULL, iter->inode->i_mapping, pos, len,
-				copied, page, NULL);
+				copied, &folio->page, NULL);
 	} else {
-		ret = __iomap_write_end(iter->inode, pos, len, copied, page);
+		ret = __iomap_write_end(iter->inode, pos, len, copied, folio);
 	}
 
 	/*
@@ -732,13 +727,13 @@ static size_t iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,
 		i_size_write(iter->inode, pos + ret);
 		iter->iomap.flags |= IOMAP_F_SIZE_CHANGED;
 	}
-	unlock_page(page);
+	folio_unlock(folio);
 
 	if (old_size < pos)
 		pagecache_isize_extended(iter->inode, old_size, pos);
 	if (page_ops && page_ops->page_done)
-		page_ops->page_done(iter->inode, pos, ret, page);
-	put_page(page);
+		page_ops->page_done(iter->inode, pos, ret, &folio->page);
+	folio_put(folio);
 
 	if (ret < len)
 		iomap_write_failed(iter->inode, pos, len);
@@ -753,6 +748,7 @@ static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i)
 	long status = 0;
 
 	do {
+		struct folio *folio;
 		struct page *page;
 		unsigned long offset;	/* Offset into pagecache page */
 		unsigned long bytes;	/* Bytes to write to page */
@@ -776,16 +772,17 @@ static loff_t iomap_write_iter(struct iomap_iter *iter, struct iov_iter *i)
 			break;
 		}
 
-		status = iomap_write_begin(iter, pos, bytes, &page);
+		status = iomap_write_begin(iter, pos, bytes, &folio);
 		if (unlikely(status))
 			break;
 
+		page = folio_file_page(folio, pos >> PAGE_SHIFT);
 		if (mapping_writably_mapped(iter->inode->i_mapping))
 			flush_dcache_page(page);
 
 		copied = copy_page_from_iter_atomic(page, offset, bytes, i);
 
-		status = iomap_write_end(iter, pos, bytes, copied, page);
+		status = iomap_write_end(iter, pos, bytes, copied, folio);
 
 		if (unlikely(copied != status))
 			iov_iter_revert(i, copied - status);
@@ -851,13 +848,13 @@ static loff_t iomap_unshare_iter(struct iomap_iter *iter)
 	do {
 		unsigned long offset = offset_in_page(pos);
 		unsigned long bytes = min_t(loff_t, PAGE_SIZE - offset, length);
-		struct page *page;
+		struct folio *folio;
 
-		status = iomap_write_begin(iter, pos, bytes, &page);
+		status = iomap_write_begin(iter, pos, bytes, &folio);
 		if (unlikely(status))
 			return status;
 
-		status = iomap_write_end(iter, pos, bytes, bytes, page);
+		status = iomap_write_end(iter, pos, bytes, bytes, folio);
 		if (WARN_ON_ONCE(status == 0))
 			return -EIO;
 
@@ -894,15 +891,13 @@ EXPORT_SYMBOL_GPL(iomap_file_unshare);
 static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
 {
 	struct folio *folio;
-	struct page *page;
 	int status;
 	size_t offset;
-	unsigned bytes = min_t(u64, UINT_MAX, length);
+	size_t bytes = min_t(u64, SIZE_MAX, length);
 
-	status = iomap_write_begin(iter, pos, bytes, &page);
+	status = iomap_write_begin(iter, pos, bytes, &folio);
 	if (status)
 		return status;
-	folio = page_folio(page);
 
 	offset = offset_in_folio(folio, pos);
 	if (bytes > folio_size(folio) - offset)
@@ -911,7 +906,7 @@ static s64 __iomap_zero_iter(struct iomap_iter *iter, loff_t pos, u64 length)
 	folio_zero_range(folio, offset, bytes);
 	folio_mark_accessed(folio);
 
-	return iomap_write_end(iter, pos, bytes, bytes, page);
+	return iomap_write_end(iter, pos, bytes, bytes, folio);
 }
 
 static loff_t iomap_zero_iter(struct iomap_iter *iter, bool *did_zero)
-- 
2.33.0

[PATCH v3 18/25] iomap: Convert iomap_write_end_inline to take a folio

[Matthew Wilcox (Oracle)]

This conversion is only safe because iomap only supports writes to inline
data which starts at the beginning of the file.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
---
 fs/iomap/buffered-io.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 975a4a6aeca0..b2bf7f337e75 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -683,16 +683,16 @@ static size_t __iomap_write_end(struct inode *inode, loff_t pos, size_t len,
 }
 
 static size_t iomap_write_end_inline(const struct iomap_iter *iter,
-		struct page *page, loff_t pos, size_t copied)
+		struct folio *folio, loff_t pos, size_t copied)
 {
 	const struct iomap *iomap = &iter->iomap;
 	void *addr;
 
-	WARN_ON_ONCE(!PageUptodate(page));
+	WARN_ON_ONCE(!folio_test_uptodate(folio));
 	BUG_ON(!iomap_inline_data_valid(iomap));
 
-	flush_dcache_page(page);
-	addr = kmap_local_page(page) + pos;
+	flush_dcache_folio(folio);
+	addr = kmap_local_folio(folio, pos);
 	memcpy(iomap_inline_data(iomap, pos), addr, copied);
 	kunmap_local(addr);
 
@@ -710,7 +710,7 @@ static size_t iomap_write_end(struct iomap_iter *iter, loff_t pos, size_t len,
 	size_t ret;
 
 	if (srcmap->type == IOMAP_INLINE) {
-		ret = iomap_write_end_inline(iter, &folio->page, pos, copied);
+		ret = iomap_write_end_inline(iter, folio, pos, copied);
 	} else if (srcmap->flags & IOMAP_F_BUFFER_HEAD) {
 		ret = block_write_end(NULL, iter->inode->i_mapping, pos, len,
 				copied, &folio->page, NULL);
-- 
2.33.0

[PATCH v3 19/25] iomap,xfs: Convert ->discard_page to ->discard_folio

[Matthew Wilcox (Oracle)]

XFS has the only implementation of ->discard_page today, so convert it
to use folios in the same patch as converting the API.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c |  4 ++--
 fs/xfs/xfs_aops.c      | 24 ++++++++++++------------
 include/linux/iomap.h  |  2 +-
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index b2bf7f337e75..ceb7fbe4e7c9 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -1360,8 +1360,8 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 		 * won't be affected by I/O completion and we must unlock it
 		 * now.
 		 */
-		if (wpc->ops->discard_page)
-			wpc->ops->discard_page(page, file_offset);
+		if (wpc->ops->discard_folio)
+			wpc->ops->discard_folio(folio, file_offset);
 		if (!count) {
 			ClearPageUptodate(page);
 			unlock_page(page);
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index c8c15c3c3147..4098a9875c5b 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -437,37 +437,37 @@ xfs_prepare_ioend(
  * see a ENOSPC in writeback).
  */
 static void
-xfs_discard_page(
-	struct page		*page,
-	loff_t			fileoff)
+xfs_discard_folio(
+	struct folio		*folio,
+	loff_t			pos)
 {
-	struct inode		*inode = page->mapping->host;
+	struct inode		*inode = folio->mapping->host;
 	struct xfs_inode	*ip = XFS_I(inode);
 	struct xfs_mount	*mp = ip->i_mount;
-	unsigned int		pageoff = offset_in_page(fileoff);
-	xfs_fileoff_t		start_fsb = XFS_B_TO_FSBT(mp, fileoff);
-	xfs_fileoff_t		pageoff_fsb = XFS_B_TO_FSBT(mp, pageoff);
+	size_t			offset = offset_in_folio(folio, pos);
+	xfs_fileoff_t		start_fsb = XFS_B_TO_FSBT(mp, pos);
+	xfs_fileoff_t		pageoff_fsb = XFS_B_TO_FSBT(mp, offset);
 	int			error;
 
 	if (xfs_is_shutdown(mp))
 		goto out_invalidate;
 
 	xfs_alert_ratelimited(mp,
-		"page discard on page "PTR_FMT", inode 0x%llx, offset %llu.",
-			page, ip->i_ino, fileoff);
+		"page discard on page "PTR_FMT", inode 0x%llx, pos %llu.",
+			folio, ip->i_ino, pos);
 
 	error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
-			i_blocks_per_page(inode, page) - pageoff_fsb);
+			i_blocks_per_folio(inode, folio) - pageoff_fsb);
 	if (error && !xfs_is_shutdown(mp))
 		xfs_alert(mp, "page discard unable to remove delalloc mapping.");
 out_invalidate:
-	iomap_invalidatepage(page, pageoff, PAGE_SIZE - pageoff);
+	iomap_invalidate_folio(folio, offset, folio_size(folio) - offset);
 }
 
 static const struct iomap_writeback_ops xfs_writeback_ops = {
 	.map_blocks		= xfs_map_blocks,
 	.prepare_ioend		= xfs_prepare_ioend,
-	.discard_page		= xfs_discard_page,
+	.discard_folio		= xfs_discard_folio,
 };
 
 STATIC int
diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index 29491fb9c5ba..5ef5088dbbd8 100644
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -285,7 +285,7 @@ struct iomap_writeback_ops {
 	 * Optional, allows the file system to discard state on a page where
 	 * we failed to submit any I/O.
 	 */
-	void (*discard_page)(struct page *page, loff_t fileoff);
+	void (*discard_folio)(struct folio *folio, loff_t pos);
 };
 
 struct iomap_writepage_ctx {
-- 
2.33.0

[PATCH v3 20/25] iomap: Simplify iomap_writepage_map()

[Matthew Wilcox (Oracle)]

Rename end_offset to end_pos and file_offset to pos to match the rest
of the file.  Simplify the loop by calculating nblocks up front instead
of each time around the loop.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index ceb7fbe4e7c9..20e7087aa75c 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -1307,37 +1307,36 @@ iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page,
 static int
 iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 		struct writeback_control *wbc, struct inode *inode,
-		struct page *page, u64 end_offset)
+		struct page *page, u64 end_pos)
 {
 	struct folio *folio = page_folio(page);
 	struct iomap_page *iop = iomap_page_create(inode, folio);
 	struct iomap_ioend *ioend, *next;
 	unsigned len = i_blocksize(inode);
-	u64 file_offset; /* file offset of page */
+	unsigned nblocks = i_blocks_per_folio(inode, folio);
+	u64 pos = folio_pos(folio);
 	int error = 0, count = 0, i;
 	LIST_HEAD(submit_list);
 
 	WARN_ON_ONCE(iop && atomic_read(&iop->write_bytes_pending) != 0);
 
 	/*
-	 * Walk through the page to find areas to write back. If we run off the
-	 * end of the current map or find the current map invalid, grab a new
-	 * one.
+	 * Walk through the folio to find areas to write back. If we
+	 * run off the end of the current map or find the current map
+	 * invalid, grab a new one.
 	 */
-	for (i = 0, file_offset = page_offset(page);
-	     i < (PAGE_SIZE >> inode->i_blkbits) && file_offset < end_offset;
-	     i++, file_offset += len) {
+	for (i = 0; i < nblocks && pos < end_pos; i++, pos += len) {
 		if (iop && !test_bit(i, iop->uptodate))
 			continue;
 
-		error = wpc->ops->map_blocks(wpc, inode, file_offset);
+		error = wpc->ops->map_blocks(wpc, inode, pos);
 		if (error)
 			break;
 		if (WARN_ON_ONCE(wpc->iomap.type == IOMAP_INLINE))
 			continue;
 		if (wpc->iomap.type == IOMAP_HOLE)
 			continue;
-		iomap_add_to_ioend(inode, file_offset, page, iop, wpc, wbc,
+		iomap_add_to_ioend(inode, pos, page, iop, wpc, wbc,
 				 &submit_list);
 		count++;
 	}
@@ -1361,7 +1360,7 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 		 * now.
 		 */
 		if (wpc->ops->discard_folio)
-			wpc->ops->discard_folio(folio, file_offset);
+			wpc->ops->discard_folio(folio, pos);
 		if (!count) {
 			ClearPageUptodate(page);
 			unlock_page(page);
-- 
2.33.0

[PATCH v3 21/25] iomap: Simplify iomap_do_writepage()

[Matthew Wilcox (Oracle)]

Rename end_offset to end_pos and offset_into_page to poff to match the
rest of the file.  Simplify the handling of the last page straddling
i_size by doing the EOF check based on the byte granularity i_size
instead of converting to a pgoff prematurely.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 20e7087aa75c..8bfdda8e5f1c 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -1408,9 +1408,7 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 {
 	struct iomap_writepage_ctx *wpc = data;
 	struct inode *inode = page->mapping->host;
-	pgoff_t end_index;
-	u64 end_offset;
-	loff_t offset;
+	u64 end_pos, isize;
 
 	trace_iomap_writepage(inode, page_offset(page), PAGE_SIZE);
 
@@ -1441,11 +1439,9 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 	 * |     desired writeback range    |      see else    |
 	 * ---------------------------------^------------------|
 	 */
-	offset = i_size_read(inode);
-	end_index = offset >> PAGE_SHIFT;
-	if (page->index < end_index)
-		end_offset = (loff_t)(page->index + 1) << PAGE_SHIFT;
-	else {
+	isize = i_size_read(inode);
+	end_pos = page_offset(page) + PAGE_SIZE;
+	if (end_pos > isize) {
 		/*
 		 * Check whether the page to write out is beyond or straddles
 		 * i_size or not.
@@ -1457,7 +1453,8 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		 * |				    |      Straddles     |
 		 * ---------------------------------^-----------|--------|
 		 */
-		unsigned offset_into_page = offset & (PAGE_SIZE - 1);
+		size_t poff = offset_in_page(isize);
+		pgoff_t end_index = isize >> PAGE_SHIFT;
 
 		/*
 		 * Skip the page if it's fully outside i_size, e.g. due to a
@@ -1477,7 +1474,7 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		 * offset is just equal to the EOF.
 		 */
 		if (page->index > end_index ||
-		    (page->index == end_index && offset_into_page == 0))
+		    (page->index == end_index && poff == 0))
 			goto redirty;
 
 		/*
@@ -1488,13 +1485,13 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		 * memory is zeroed when mapped, and writes to that region are
 		 * not written out to the file."
 		 */
-		zero_user_segment(page, offset_into_page, PAGE_SIZE);
+		zero_user_segment(page, poff, PAGE_SIZE);
 
 		/* Adjust the end_offset to the end of file */
-		end_offset = offset;
+		end_pos = isize;
 	}
 
-	return iomap_writepage_map(wpc, wbc, inode, page, end_offset);
+	return iomap_writepage_map(wpc, wbc, inode, page, end_pos);
 
 redirty:
 	redirty_page_for_writepage(wbc, page);
-- 
2.33.0

[PATCH v3 22/25] iomap: Convert iomap_add_to_ioend() to take a folio

[Matthew Wilcox (Oracle)]

We still iterate one block at a time, but now we call compound_head()
less often.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 70 ++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 36 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 8bfdda8e5f1c..a36695db6f9d 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -1263,29 +1263,29 @@ iomap_can_add_to_ioend(struct iomap_writepage_ctx *wpc, loff_t offset,
  * first; otherwise finish off the current ioend and start another.
  */
 static void
-iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page,
+iomap_add_to_ioend(struct inode *inode, loff_t pos, struct folio *folio,
 		struct iomap_page *iop, struct iomap_writepage_ctx *wpc,
 		struct writeback_control *wbc, struct list_head *iolist)
 {
-	sector_t sector = iomap_sector(&wpc->iomap, offset);
+	sector_t sector = iomap_sector(&wpc->iomap, pos);
 	unsigned len = i_blocksize(inode);
-	unsigned poff = offset & (PAGE_SIZE - 1);
+	size_t poff = offset_in_folio(folio, pos);
 
-	if (!wpc->ioend || !iomap_can_add_to_ioend(wpc, offset, sector)) {
+	if (!wpc->ioend || !iomap_can_add_to_ioend(wpc, pos, sector)) {
 		if (wpc->ioend)
 			list_add(&wpc->ioend->io_list, iolist);
-		wpc->ioend = iomap_alloc_ioend(inode, wpc, offset, sector, wbc);
+		wpc->ioend = iomap_alloc_ioend(inode, wpc, pos, sector, wbc);
 	}
 
-	if (bio_add_page(wpc->ioend->io_bio, page, len, poff) != len) {
+	if (!bio_add_folio(wpc->ioend->io_bio, folio, len, poff)) {
 		wpc->ioend->io_bio = iomap_chain_bio(wpc->ioend->io_bio);
-		__bio_add_page(wpc->ioend->io_bio, page, len, poff);
+		bio_add_folio(wpc->ioend->io_bio, folio, len, poff);
 	}
 
 	if (iop)
 		atomic_add(len, &iop->write_bytes_pending);
 	wpc->ioend->io_size += len;
-	wbc_account_cgroup_owner(wbc, page, len);
+	wbc_account_cgroup_owner(wbc, &folio->page, len);
 }
 
 /*
@@ -1307,9 +1307,8 @@ iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page,
 static int
 iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 		struct writeback_control *wbc, struct inode *inode,
-		struct page *page, u64 end_pos)
+		struct folio *folio, u64 end_pos)
 {
-	struct folio *folio = page_folio(page);
 	struct iomap_page *iop = iomap_page_create(inode, folio);
 	struct iomap_ioend *ioend, *next;
 	unsigned len = i_blocksize(inode);
@@ -1336,15 +1335,15 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 			continue;
 		if (wpc->iomap.type == IOMAP_HOLE)
 			continue;
-		iomap_add_to_ioend(inode, pos, page, iop, wpc, wbc,
+		iomap_add_to_ioend(inode, pos, folio, iop, wpc, wbc,
 				 &submit_list);
 		count++;
 	}
 
 	WARN_ON_ONCE(!wpc->ioend && !list_empty(&submit_list));
-	WARN_ON_ONCE(!PageLocked(page));
-	WARN_ON_ONCE(PageWriteback(page));
-	WARN_ON_ONCE(PageDirty(page));
+	WARN_ON_ONCE(!folio_test_locked(folio));
+	WARN_ON_ONCE(folio_test_writeback(folio));
+	WARN_ON_ONCE(folio_test_dirty(folio));
 
 	/*
 	 * We cannot cancel the ioend directly here on error.  We may have
@@ -1362,14 +1361,14 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 		if (wpc->ops->discard_folio)
 			wpc->ops->discard_folio(folio, pos);
 		if (!count) {
-			ClearPageUptodate(page);
-			unlock_page(page);
+			folio_clear_uptodate(folio);
+			folio_unlock(folio);
 			goto done;
 		}
 	}
 
-	set_page_writeback(page);
-	unlock_page(page);
+	folio_start_writeback(folio);
+	folio_unlock(folio);
 
 	/*
 	 * Preserve the original error if there was one; catch
@@ -1390,9 +1389,9 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 	 * with a partial page truncate on a sub-page block sized filesystem.
 	 */
 	if (!count)
-		end_page_writeback(page);
+		folio_end_writeback(folio);
 done:
-	mapping_set_error(page->mapping, error);
+	mapping_set_error(folio->mapping, error);
 	return error;
 }
 
@@ -1406,14 +1405,15 @@ iomap_writepage_map(struct iomap_writepage_ctx *wpc,
 static int
 iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 {
+	struct folio *folio = page_folio(page);
 	struct iomap_writepage_ctx *wpc = data;
-	struct inode *inode = page->mapping->host;
+	struct inode *inode = folio->mapping->host;
 	u64 end_pos, isize;
 
-	trace_iomap_writepage(inode, page_offset(page), PAGE_SIZE);
+	trace_iomap_writepage(inode, folio_pos(folio), folio_size(folio));
 
 	/*
-	 * Refuse to write the page out if we're called from reclaim context.
+	 * Refuse to write the folio out if we're called from reclaim context.
 	 *
 	 * This avoids stack overflows when called from deeply used stacks in
 	 * random callers for direct reclaim or memcg reclaim.  We explicitly
@@ -1427,10 +1427,10 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		goto redirty;
 
 	/*
-	 * Is this page beyond the end of the file?
+	 * Is this folio beyond the end of the file?
 	 *
-	 * The page index is less than the end_index, adjust the end_offset
-	 * to the highest offset that this page should represent.
+	 * The folio index is less than the end_index, adjust the end_pos
+	 * to the highest offset that this folio should represent.
 	 * -----------------------------------------------------
 	 * |			file mapping	       | <EOF> |
 	 * -----------------------------------------------------
@@ -1440,7 +1440,7 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 	 * ---------------------------------^------------------|
 	 */
 	isize = i_size_read(inode);
-	end_pos = page_offset(page) + PAGE_SIZE;
+	end_pos = folio_pos(folio) + folio_size(folio);
 	if (end_pos > isize) {
 		/*
 		 * Check whether the page to write out is beyond or straddles
@@ -1453,7 +1453,7 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		 * |				    |      Straddles     |
 		 * ---------------------------------^-----------|--------|
 		 */
-		size_t poff = offset_in_page(isize);
+		size_t poff = offset_in_folio(folio, isize);
 		pgoff_t end_index = isize >> PAGE_SHIFT;
 
 		/*
@@ -1473,8 +1473,8 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		 * checking if the page is totally beyond i_size or if its
 		 * offset is just equal to the EOF.
 		 */
-		if (page->index > end_index ||
-		    (page->index == end_index && poff == 0))
+		if (folio->index > end_index ||
+		    (folio->index == end_index && poff == 0))
 			goto redirty;
 
 		/*
@@ -1485,17 +1485,15 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
 		 * memory is zeroed when mapped, and writes to that region are
 		 * not written out to the file."
 		 */
-		zero_user_segment(page, poff, PAGE_SIZE);
-
-		/* Adjust the end_offset to the end of file */
+		folio_zero_segment(folio, poff, folio_size(folio));
 		end_pos = isize;
 	}
 
-	return iomap_writepage_map(wpc, wbc, inode, page, end_pos);
+	return iomap_writepage_map(wpc, wbc, inode, folio, end_pos);
 
 redirty:
-	redirty_page_for_writepage(wbc, page);
-	unlock_page(page);
+	folio_redirty_for_writepage(wbc, folio);
+	folio_unlock(folio);
 	return 0;
 }
 
-- 
2.33.0

[PATCH v3 23/25] iomap: Convert iomap_migrate_page() to use folios

[Matthew Wilcox (Oracle)]

The arguments are still pages for now, but we can use folios internally
and cut out a lot of calls to compound_head().

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index a36695db6f9d..b2f6e5991eb0 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -504,19 +504,21 @@ int
 iomap_migrate_page(struct address_space *mapping, struct page *newpage,
 		struct page *page, enum migrate_mode mode)
 {
+	struct folio *folio = page_folio(page);
+	struct folio *newfolio = page_folio(newpage);
 	int ret;
 
-	ret = migrate_page_move_mapping(mapping, newpage, page, 0);
+	ret = folio_migrate_mapping(mapping, newfolio, folio, 0);
 	if (ret != MIGRATEPAGE_SUCCESS)
 		return ret;
 
-	if (page_has_private(page))
-		attach_page_private(newpage, detach_page_private(page));
+	if (folio_test_private(folio))
+		folio_attach_private(newfolio, folio_detach_private(folio));
 
 	if (mode != MIGRATE_SYNC_NO_COPY)
-		migrate_page_copy(newpage, page);
+		folio_migrate_copy(newfolio, folio);
 	else
-		migrate_page_states(newpage, page);
+		folio_migrate_flags(newfolio, folio);
 	return MIGRATEPAGE_SUCCESS;
 }
 EXPORT_SYMBOL_GPL(iomap_migrate_page);
-- 
2.33.0

[PATCH v3 24/25] iomap: Support large folios in invalidatepage

[Matthew Wilcox (Oracle)]

If we're punching a hole in a large folio, we need to remove the
per-folio iomap data as the folio is about to be split and each page will
need its own.  If a dirty folio is only partially-uptodate, the iomap
data contains the information about which blocks cannot be written back,
so assert that a dirty folio is fully uptodate.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/iomap/buffered-io.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index b2f6e5991eb0..36ccb903db92 100644
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -481,13 +481,18 @@ void iomap_invalidate_folio(struct folio *folio, size_t offset, size_t len)
 	trace_iomap_invalidatepage(folio->mapping->host, offset, len);
 
 	/*
-	 * If we're invalidating the entire page, clear the dirty state from it
-	 * and release it to avoid unnecessary buildup of the LRU.
+	 * If we're invalidating the entire folio, clear the dirty state
+	 * from it and release it to avoid unnecessary buildup of the LRU.
 	 */
 	if (offset == 0 && len == folio_size(folio)) {
 		WARN_ON_ONCE(folio_test_writeback(folio));
 		folio_cancel_dirty(folio);
 		iomap_page_release(folio);
+	} else if (folio_test_large(folio)) {
+		/* Must release the iop so the page can be split */
+		WARN_ON_ONCE(!folio_test_uptodate(folio) &&
+			     folio_test_dirty(folio));
+		iomap_page_release(folio);
 	}
 }
 EXPORT_SYMBOL_GPL(iomap_invalidate_folio);
-- 
2.33.0

[PATCH v3 25/25] xfs: Support large folios

[Matthew Wilcox (Oracle)]

Now that iomap has been converted, XFS is large folio safe.
Indicate to the VFS that it can now create large folios for XFS.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
---
 fs/xfs/xfs_icache.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index da4af2142a2b..cdc39f576ca1 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -87,6 +87,7 @@ xfs_inode_alloc(
 	/* VFS doesn't initialise i_mode or i_state! */
 	VFS_I(ip)->i_mode = 0;
 	VFS_I(ip)->i_state = 0;
+	mapping_set_large_folios(VFS_I(ip)->i_mapping);
 
 	XFS_STATS_INC(mp, vn_active);
 	ASSERT(atomic_read(&ip->i_pincount) == 0);
@@ -320,6 +321,7 @@ xfs_reinit_inode(
 	inode->i_rdev = dev;
 	inode->i_uid = uid;
 	inode->i_gid = gid;
+	mapping_set_large_folios(inode->i_mapping);
 	return error;
 }
 
-- 
2.33.0

Re: [PATCH v3 25/25] xfs: Support large folios

[Darrick J. Wong]

On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> Now that iomap has been converted, XFS is large folio safe.
> Indicate to the VFS that it can now create large folios for XFS.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> ---
>  fs/xfs/xfs_icache.c | 2 ++
>  1 file changed, 2 insertions(+)
> 
> diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> index da4af2142a2b..cdc39f576ca1 100644
> --- a/fs/xfs/xfs_icache.c
> +++ b/fs/xfs/xfs_icache.c
> @@ -87,6 +87,7 @@ xfs_inode_alloc(
>  	/* VFS doesn't initialise i_mode or i_state! */
>  	VFS_I(ip)->i_mode = 0;
>  	VFS_I(ip)->i_state = 0;
> +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
>  
>  	XFS_STATS_INC(mp, vn_active);
>  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> @@ -320,6 +321,7 @@ xfs_reinit_inode(
>  	inode->i_rdev = dev;
>  	inode->i_uid = uid;
>  	inode->i_gid = gid;
> +	mapping_set_large_folios(inode->i_mapping);

Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
reports file corruption after 20 minutes of runtime.  The corruption is
surprisingly reproducible (522.out.bad attached below) in that I ran it
three times and always got the same bad offset (0x6e000) and always the
same opcode (6213798(166 mod 256) MAPREAD).

I turned off multipage folios and now 522 has run for over an hour
without problems, so before I go do more debugging, does this ring a
bell to anyone?

--D

QA output created by 522
READ BAD DATA: offset = 0x69e3e, size = 0x1c922, fname = /mnt/junk
OFFSET	GOOD	BAD	RANGE
0x6e000	0x0000	0x9173	0x00000
operation# (mod 256) for the bad data may be 145
0x6e001	0x0000	0x7391	0x00001
operation# (mod 256) for the bad data may be 145
0x6e002	0x0000	0x9195	0x00002
operation# (mod 256) for the bad data may be 145
0x6e003	0x0000	0x9591	0x00003
operation# (mod 256) for the bad data may be 145
0x6e004	0x0000	0x91b5	0x00004
operation# (mod 256) for the bad data may be 145
0x6e005	0x0000	0xb591	0x00005
operation# (mod 256) for the bad data may be 145
0x6e006	0x0000	0x91e2	0x00006
operation# (mod 256) for the bad data may be 145
0x6e007	0x0000	0xe291	0x00007
operation# (mod 256) for the bad data may be 145
0x6e008	0x0000	0x919d	0x00008
operation# (mod 256) for the bad data may be 145
0x6e009	0x0000	0x9d91	0x00009
operation# (mod 256) for the bad data may be 145
0x6e00a	0x0000	0x91e8	0x0000a
operation# (mod 256) for the bad data may be 145
0x6e00b	0x0000	0xe891	0x0000b
operation# (mod 256) for the bad data may be 145
0x6e00c	0x0000	0x91c9	0x0000c
operation# (mod 256) for the bad data may be 145
0x6e00d	0x0000	0xc991	0x0000d
operation# (mod 256) for the bad data may be 145
0x6e00e	0x0000	0x9147	0x0000e
operation# (mod 256) for the bad data may be 145
0x6e00f	0x0000	0x4791	0x0000f
operation# (mod 256) for the bad data may be 145
LOG DUMP (6213798 total operations):
6213799(167 mod 256): DEDUPE 0x6c000 thru 0x6cfff	(0x1000 bytes) to 0x22000 thru 0x22fff
6213800(168 mod 256): DEDUPE 0xc000 thru 0x23fff	(0x18000 bytes) to 0x64000 thru 0x7bfff	******BBBB
6213801(169 mod 256): PUNCH    0x252ee thru 0x29e68	(0x4b7b bytes)
6213802(170 mod 256): SKIPPED (no operation)
6213803(171 mod 256): SKIPPED (no operation)
6213804(172 mod 256): COPY 0x4923e thru 0x4b416	(0x21d9 bytes) to 0x3df88 thru 0x40160
6213805(173 mod 256): ZERO     0x39780 thru 0x3ef09	(0x578a bytes)
6213806(174 mod 256): TRUNCATE DOWN	from 0x80000 to 0x1da92	******WWWW
6213807(175 mod 256): READ     0x51d0 thru 0x11129	(0xbf5a bytes)
6213808(176 mod 256): TRUNCATE UP	from 0x1da92 to 0x4428e
6213809(177 mod 256): COPY 0x3548b thru 0x3ab54	(0x56ca bytes) to 0x7e11f thru 0x837e8
6213810(178 mod 256): MAPWRITE 0x31a45 thru 0x4f750	(0x1dd0c bytes)
6213811(179 mod 256): INSERT 0xb000 thru 0x18fff	(0xe000 bytes)
6213812(180 mod 256): CLONE 0x1e000 thru 0x37fff	(0x1a000 bytes) to 0x3c000 thru 0x55fff
6213813(181 mod 256): SKIPPED (no operation)
6213814(182 mod 256): DEDUPE 0x5000 thru 0xcfff	(0x8000 bytes) to 0x22000 thru 0x29fff
6213815(183 mod 256): CLONE 0x68000 thru 0x6bfff	(0x4000 bytes) to 0x4e000 thru 0x51fff
6213816(184 mod 256): READ     0x88eec thru 0x8a1e5	(0x12fa bytes)
6213817(185 mod 256): WRITE    0x47d4c thru 0x5cee9	(0x1519e bytes)
6213818(186 mod 256): MAPREAD  0x17e42 thru 0x2f728	(0x178e7 bytes)
6213819(187 mod 256): MAPREAD  0x259bd thru 0x3a646	(0x14c8a bytes)
6213820(188 mod 256): WRITE    0x44cfa thru 0x60544	(0x1b84b bytes)
6213821(189 mod 256): COPY 0xb8ff thru 0x13d88	(0x848a bytes) to 0x186a7 thru 0x20b30
6213822(190 mod 256): WRITE    0x92759 thru 0x927bf	(0x67 bytes) HOLE
6213823(191 mod 256): ZERO     0x1c1f3 thru 0x3ac34	(0x1ea42 bytes)
6213824(192 mod 256): CLONE 0x3f000 thru 0x41fff	(0x3000 bytes) to 0x32000 thru 0x34fff
6213825(193 mod 256): READ     0x252a7 thru 0x42df3	(0x1db4d bytes)
6213826(194 mod 256): DEDUPE 0x5b000 thru 0x69fff	(0xf000 bytes) to 0x3b000 thru 0x49fff
6213827(195 mod 256): FALLOC   0x78707 thru 0x8666d	(0xdf66 bytes) INTERIOR
6213828(196 mod 256): PUNCH    0x60b5c thru 0x67934	(0x6dd9 bytes)
6213829(197 mod 256): DEDUPE 0x12000 thru 0x2cfff	(0x1b000 bytes) to 0x35000 thru 0x4ffff
6213830(198 mod 256): PUNCH    0x38f33 thru 0x54ab3	(0x1bb81 bytes)
6213831(199 mod 256): ZERO     0x2f1ab thru 0x3fd66	(0x10bbc bytes)
6213832(200 mod 256): PUNCH    0x1190d thru 0x2a386	(0x18a7a bytes)
6213833(201 mod 256): SKIPPED (no operation)
6213834(202 mod 256): CLONE 0x8b000 thru 0x91fff	(0x7000 bytes) to 0x32000 thru 0x38fff
6213835(203 mod 256): DEDUPE 0x3f000 thru 0x56fff	(0x18000 bytes) to 0x60000 thru 0x77fff	******BBBB
6213836(204 mod 256): FALLOC   0x57523 thru 0x66c22	(0xf6ff bytes) INTERIOR
6213837(205 mod 256): CLONE 0x80000 thru 0x90fff	(0x11000 bytes) to 0x8000 thru 0x18fff
6213838(206 mod 256): SKIPPED (no operation)
6213839(207 mod 256): DEDUPE 0x49000 thru 0x5ffff	(0x17000 bytes) to 0x7a000 thru 0x90fff
6213840(208 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x29911	******WWWW
6213841(209 mod 256): MAPREAD  0x109dd thru 0x2658c	(0x15bb0 bytes)
6213842(210 mod 256): FALLOC   0x8d15d thru 0x927c0	(0x5663 bytes) PAST_EOF
6213843(211 mod 256): WRITE    0x2ccfc thru 0x3aee2	(0xe1e7 bytes) HOLE
6213844(212 mod 256): TRUNCATE UP	from 0x3aee3 to 0x803af	******WWWW
6213845(213 mod 256): ZERO     0x60c8f thru 0x695af	(0x8921 bytes)
6213846(214 mod 256): WRITE    0x2a208 thru 0x408e2	(0x166db bytes)
6213847(215 mod 256): DEDUPE 0xc000 thru 0x18fff	(0xd000 bytes) to 0x71000 thru 0x7dfff
6213848(216 mod 256): READ     0x35e4e thru 0x44903	(0xeab6 bytes)
6213849(217 mod 256): ZERO     0x27e89 thru 0x46612	(0x1e78a bytes)
6213850(218 mod 256): MAPREAD  0x31b18 thru 0x3efef	(0xd4d8 bytes)
6213851(219 mod 256): WRITE    0x33d7d thru 0x341ba	(0x43e bytes)
6213852(220 mod 256): CLONE 0x3000 thru 0xafff	(0x8000 bytes) to 0x44000 thru 0x4bfff
6213853(221 mod 256): PUNCH    0x202bd thru 0x2d706	(0xd44a bytes)
6213854(222 mod 256): MAPREAD  0x6a64f thru 0x6f0c5	(0x4a77 bytes)	***RRRR***
6213855(223 mod 256): WRITE    0x1dc7a thru 0x396a7	(0x1ba2e bytes)
6213856(224 mod 256): READ     0x186d0 thru 0x2c8a6	(0x141d7 bytes)
6213857(225 mod 256): ZERO     0xcc31 thru 0x262f3	(0x196c3 bytes)
6213858(226 mod 256): DEDUPE 0x46000 thru 0x54fff	(0xf000 bytes) to 0x8000 thru 0x16fff
6213859(227 mod 256): COLLAPSE 0x40000 thru 0x44fff	(0x5000 bytes)
6213860(228 mod 256): WRITE    0x13b16 thru 0x1d71f	(0x9c0a bytes)
6213861(229 mod 256): FALLOC   0x3b552 thru 0x52e9a	(0x17948 bytes) INTERIOR
6213862(230 mod 256): ZERO     0x6989b thru 0x83949	(0x1a0af bytes)	******ZZZZ
6213863(231 mod 256): ZERO     0x35134 thru 0x4f1a8	(0x1a075 bytes)
6213864(232 mod 256): SKIPPED (no operation)
6213865(233 mod 256): DEDUPE 0x31000 thru 0x44fff	(0x14000 bytes) to 0x5d000 thru 0x70fff	******BBBB
6213866(234 mod 256): TRUNCATE UP	from 0x8394a to 0x84b17
6213867(235 mod 256): INSERT 0x21000 thru 0x2dfff	(0xd000 bytes)
6213868(236 mod 256): MAPWRITE 0x24d96 thru 0x270e8	(0x2353 bytes)
6213869(237 mod 256): CLONE 0x11000 thru 0x24fff	(0x14000 bytes) to 0x3f000 thru 0x52fff
6213870(238 mod 256): MAPWRITE 0x56aac thru 0x58bc9	(0x211e bytes)
6213871(239 mod 256): WRITE    0x3e722 thru 0x58a53	(0x1a332 bytes)
6213872(240 mod 256): SKIPPED (no operation)
6213873(241 mod 256): PUNCH    0x76908 thru 0x8353a	(0xcc33 bytes)
6213874(242 mod 256): SKIPPED (no operation)
6213875(243 mod 256): COLLAPSE 0x7b000 thru 0x7efff	(0x4000 bytes)
6213876(244 mod 256): MAPREAD  0x2d48a thru 0x341a5	(0x6d1c bytes)
6213877(245 mod 256): COLLAPSE 0x33000 thru 0x39fff	(0x7000 bytes)
6213878(246 mod 256): MAPREAD  0x678a3 thru 0x78845	(0x10fa3 bytes)	***RRRR***
6213879(247 mod 256): FALLOC   0x8283c thru 0x86823	(0x3fe7 bytes) INTERIOR
6213880(248 mod 256): READ     0xf5d9 thru 0xf6ff	(0x127 bytes)
6213881(249 mod 256): MAPREAD  0x14493 thru 0x22ff0	(0xeb5e bytes)
6213882(250 mod 256): ZERO     0x103c7 thru 0x2c783	(0x1c3bd bytes)
6213883(251 mod 256): WRITE    0x844dc thru 0x853dd	(0xf02 bytes)
6213884(252 mod 256): TRUNCATE DOWN	from 0x86b17 to 0x7ac49
6213885(253 mod 256): TRUNCATE DOWN	from 0x7ac49 to 0x5b4fe	******WWWW
6213886(254 mod 256): ZERO     0x8c02c thru 0x927bf	(0x6794 bytes)
6213887(255 mod 256): SKIPPED (no operation)
6213888(  0 mod 256): COPY 0x545b8 thru 0x56e04	(0x284d bytes) to 0x12e01 thru 0x1564d
6213889(  1 mod 256): COPY 0x24c4e thru 0x31081	(0xc434 bytes) to 0xfe1a thru 0x1c24d
6213890(  2 mod 256): MAPREAD  0x550bf thru 0x5ce2e	(0x7d70 bytes)
6213891(  3 mod 256): COLLAPSE 0x1000 thru 0xdfff	(0xd000 bytes)
6213892(  4 mod 256): SKIPPED (no operation)
6213893(  5 mod 256): TRUNCATE DOWN	from 0x857c0 to 0x11286	******WWWW
6213894(  6 mod 256): MAPREAD  0x10b83 thru 0x11285	(0x703 bytes)
6213895(  7 mod 256): PUNCH    0xe3eb thru 0x11285	(0x2e9b bytes)
6213896(  8 mod 256): COPY 0x8fd8 thru 0xe5d1	(0x55fa bytes) to 0x57182 thru 0x5c77b
6213897(  9 mod 256): INSERT 0x2c000 thru 0x39fff	(0xe000 bytes)
6213898( 10 mod 256): READ     0x19e6 thru 0x150fa	(0x13715 bytes)
6213899( 11 mod 256): WRITE    0x4faaa thru 0x679dc	(0x17f33 bytes)
6213900( 12 mod 256): MAPWRITE 0x6f4cf thru 0x7b5d0	(0xc102 bytes)
6213901( 13 mod 256): WRITE    0xdad1 thru 0x10de1	(0x3311 bytes)
6213902( 14 mod 256): TRUNCATE DOWN	from 0x7b5d1 to 0x57b76	******WWWW
6213903( 15 mod 256): MAPWRITE 0x75111 thru 0x91377	(0x1c267 bytes)
6213904( 16 mod 256): MAPREAD  0x4af28 thru 0x4c510	(0x15e9 bytes)
6213905( 17 mod 256): ZERO     0x7e848 thru 0x83ea6	(0x565f bytes)
6213906( 18 mod 256): PUNCH    0xd752 thru 0x22b5d	(0x1540c bytes)
6213907( 19 mod 256): PUNCH    0x3947c thru 0x42596	(0x911b bytes)
6213908( 20 mod 256): MAPWRITE 0x6328 thru 0x79a5	(0x167e bytes)
6213909( 21 mod 256): WRITE    0x1a132 thru 0x21744	(0x7613 bytes)
6213910( 22 mod 256): COPY 0x62278 thru 0x7fdde	(0x1db67 bytes) to 0x3f04 thru 0x21a6a	EEEE******
6213911( 23 mod 256): COLLAPSE 0x2b000 thru 0x40fff	(0x16000 bytes)
6213912( 24 mod 256): MAPREAD  0x47404 thru 0x4d274	(0x5e71 bytes)
6213913( 25 mod 256): MAPWRITE 0x7fc2 thru 0x13c92	(0xbcd1 bytes)
6213914( 26 mod 256): WRITE    0x84a20 thru 0x8546d	(0xa4e bytes) HOLE
6213915( 27 mod 256): READ     0x2550 thru 0x6e06	(0x48b7 bytes)
6213916( 28 mod 256): DEDUPE 0x84000 thru 0x84fff	(0x1000 bytes) to 0x4c000 thru 0x4cfff
6213917( 29 mod 256): SKIPPED (no operation)
6213918( 30 mod 256): MAPWRITE 0x1ef93 thru 0x38a5d	(0x19acb bytes)
6213919( 31 mod 256): COLLAPSE 0x2b000 thru 0x34fff	(0xa000 bytes)
6213920( 32 mod 256): SKIPPED (no operation)
6213921( 33 mod 256): MAPREAD  0xb971 thru 0x132d9	(0x7969 bytes)
6213922( 34 mod 256): ZERO     0x58fa1 thru 0x5a91f	(0x197f bytes)
6213923( 35 mod 256): ZERO     0x60ac1 thru 0x6d945	(0xce85 bytes)
6213924( 36 mod 256): WRITE    0x6a116 thru 0x76d6c	(0xcc57 bytes)	***WWWW
6213925( 37 mod 256): ZERO     0x3bbd1 thru 0x560f7	(0x1a527 bytes)
6213926( 38 mod 256): ZERO     0x6e10c thru 0x80e00	(0x12cf5 bytes)	******ZZZZ
6213927( 39 mod 256): TRUNCATE DOWN	from 0x7b46e to 0x5a01f	******WWWW
6213928( 40 mod 256): WRITE    0x283b8 thru 0x30415	(0x805e bytes)
6213929( 41 mod 256): COPY 0x3e836 thru 0x50db3	(0x1257e bytes) to 0xf506 thru 0x21a83
6213930( 42 mod 256): TRUNCATE DOWN	from 0x5a01f to 0x3ab75
6213931( 43 mod 256): COLLAPSE 0x24000 thru 0x38fff	(0x15000 bytes)
6213932( 44 mod 256): READ     0x40fe thru 0x22f70	(0x1ee73 bytes)
6213933( 45 mod 256): CLONE 0x20000 thru 0x24fff	(0x5000 bytes) to 0x5e000 thru 0x62fff
6213934( 46 mod 256): READ     0x577dd thru 0x5d002	(0x5826 bytes)
6213935( 47 mod 256): MAPREAD  0x1fdc8 thru 0x27262	(0x749b bytes)
6213936( 48 mod 256): COLLAPSE 0x4b000 thru 0x55fff	(0xb000 bytes)
6213937( 49 mod 256): INSERT 0x2c000 thru 0x2dfff	(0x2000 bytes)
6213938( 50 mod 256): FALLOC   0x2f959 thru 0x43992	(0x14039 bytes) INTERIOR
6213939( 51 mod 256): CLONE 0x34000 thru 0x3cfff	(0x9000 bytes) to 0x81000 thru 0x89fff
6213940( 52 mod 256): PUNCH    0x40934 thru 0x438f1	(0x2fbe bytes)
6213941( 53 mod 256): TRUNCATE DOWN	from 0x8a000 to 0x5cc14	******WWWW
6213942( 54 mod 256): MAPWRITE 0x179ae thru 0x2ebbc	(0x1720f bytes)
6213943( 55 mod 256): DEDUPE 0x53000 thru 0x5bfff	(0x9000 bytes) to 0xf000 thru 0x17fff
6213944( 56 mod 256): PUNCH    0xe80 thru 0x12bf9	(0x11d7a bytes)
6213945( 57 mod 256): COPY 0x95fe thru 0x1e12f	(0x14b32 bytes) to 0x20006 thru 0x34b37
6213946( 58 mod 256): CLONE 0x13000 thru 0x1ffff	(0xd000 bytes) to 0x7e000 thru 0x8afff
6213947( 59 mod 256): WRITE    0x8ad4b thru 0x927bf	(0x7a75 bytes) EXTEND
6213948( 60 mod 256): COLLAPSE 0x12000 thru 0x2cfff	(0x1b000 bytes)
6213949( 61 mod 256): PUNCH    0x5d01a thru 0x64183	(0x716a bytes)
6213950( 62 mod 256): WRITE    0xbdaa thru 0x236fb	(0x17952 bytes)
6213951( 63 mod 256): TRUNCATE UP	from 0x777c0 to 0x794ed
6213952( 64 mod 256): ZERO     0x6ef6a thru 0x6f8f5	(0x98c bytes)	******ZZZZ
6213953( 65 mod 256): COLLAPSE 0x5d000 thru 0x75fff	(0x19000 bytes)	******CCCC
6213954( 66 mod 256): PUNCH    0x39237 thru 0x49365	(0x1012f bytes)
6213955( 67 mod 256): DEDUPE 0x2a000 thru 0x2bfff	(0x2000 bytes) to 0xc000 thru 0xdfff
6213956( 68 mod 256): SKIPPED (no operation)
6213957( 69 mod 256): MAPWRITE 0x237ff thru 0x3bb5f	(0x18361 bytes)
6213958( 70 mod 256): COLLAPSE 0x0 thru 0x3fff	(0x4000 bytes)
6213959( 71 mod 256): WRITE    0x32068 thru 0x3d2f7	(0xb290 bytes)
6213960( 72 mod 256): INSERT 0x8000 thru 0xafff	(0x3000 bytes)
6213961( 73 mod 256): COPY 0x1680e thru 0x1e529	(0x7d1c bytes) to 0x546ae thru 0x5c3c9
6213962( 74 mod 256): ZERO     0x7cedb thru 0x84778	(0x789e bytes)
6213963( 75 mod 256): TRUNCATE UP	from 0x5f4ed to 0x71766	******WWWW
6213964( 76 mod 256): WRITE    0x422e8 thru 0x43671	(0x138a bytes)
6213965( 77 mod 256): READ     0x65c43 thru 0x709c1	(0xad7f bytes)	***RRRR***
6213966( 78 mod 256): PUNCH    0x5c712 thru 0x71765	(0x15054 bytes)	******PPPP
6213967( 79 mod 256): ZERO     0x15f27 thru 0x28a18	(0x12af2 bytes)
6213968( 80 mod 256): MAPWRITE 0x60cdc thru 0x71c93	(0x10fb8 bytes)	******WWWW
6213969( 81 mod 256): TRUNCATE UP	from 0x71c94 to 0x82bc8
6213970( 82 mod 256): MAPWRITE 0x3c394 thru 0x44ad9	(0x8746 bytes)
6213971( 83 mod 256): PUNCH    0xc9a3 thru 0x1c5d4	(0xfc32 bytes)
6213972( 84 mod 256): MAPWRITE 0x4ae8f thru 0x4fee1	(0x5053 bytes)
6213973( 85 mod 256): WRITE    0x860ca thru 0x927bf	(0xc6f6 bytes) HOLE
6213974( 86 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1123c	******WWWW
6213975( 87 mod 256): COLLAPSE 0x5000 thru 0xffff	(0xb000 bytes)
6213976( 88 mod 256): MAPREAD  0x4016 thru 0x623b	(0x2226 bytes)
6213977( 89 mod 256): COPY 0x3ac8 thru 0x623b	(0x2774 bytes) to 0x59bb7 thru 0x5c32a
6213978( 90 mod 256): DEDUPE 0x56000 thru 0x5afff	(0x5000 bytes) to 0x39000 thru 0x3dfff
6213979( 91 mod 256): MAPWRITE 0xae88 thru 0x16a7f	(0xbbf8 bytes)
6213980( 92 mod 256): CLONE 0x1c000 thru 0x26fff	(0xb000 bytes) to 0x6d000 thru 0x77fff	******JJJJ
6213981( 93 mod 256): CLONE 0x70000 thru 0x76fff	(0x7000 bytes) to 0x1000 thru 0x7fff
6213982( 94 mod 256): READ     0x4ea60 thru 0x51ea8	(0x3449 bytes)
6213983( 95 mod 256): MAPREAD  0x50167 thru 0x6444e	(0x142e8 bytes)
6213984( 96 mod 256): COPY 0xb3df thru 0x1c353	(0x10f75 bytes) to 0x3c244 thru 0x4d1b8
6213985( 97 mod 256): TRUNCATE DOWN	from 0x78000 to 0x4fb9c	******WWWW
6213986( 98 mod 256): MAPWRITE 0x44d16 thru 0x5856f	(0x1385a bytes)
6213987( 99 mod 256): FALLOC   0x2f070 thru 0x32d73	(0x3d03 bytes) INTERIOR
6213988(100 mod 256): SKIPPED (no operation)
6213989(101 mod 256): ZERO     0x3a0df thru 0x54509	(0x1a42b bytes)
6213990(102 mod 256): INSERT 0x45000 thru 0x59fff	(0x15000 bytes)
6213991(103 mod 256): COPY 0x2da58 thru 0x48fa1	(0x1b54a bytes) to 0xae26 thru 0x2636f
6213992(104 mod 256): INSERT 0xc000 thru 0x17fff	(0xc000 bytes)
6213993(105 mod 256): PUNCH    0x24de4 thru 0x39ba5	(0x14dc2 bytes)
6213994(106 mod 256): WRITE    0x282eb thru 0x30368	(0x807e bytes)
6213995(107 mod 256): READ     0x5b949 thru 0x775b7	(0x1bc6f bytes)	***RRRR***
6213996(108 mod 256): FALLOC   0x3a938 thru 0x56bc2	(0x1c28a bytes) INTERIOR
6213997(109 mod 256): FALLOC   0x6546 thru 0x1ac3c	(0x146f6 bytes) INTERIOR
6213998(110 mod 256): COLLAPSE 0x33000 thru 0x47fff	(0x15000 bytes)
6213999(111 mod 256): MAPREAD  0x46b0d thru 0x5fd89	(0x1927d bytes)
6214000(112 mod 256): SKIPPED (no operation)
6214001(113 mod 256): CLONE 0x44000 thru 0x4afff	(0x7000 bytes) to 0x56000 thru 0x5cfff
6214002(114 mod 256): INSERT 0x59000 thru 0x60fff	(0x8000 bytes)
6214003(115 mod 256): TRUNCATE DOWN	from 0x6c570 to 0x2abe1
6214004(116 mod 256): CLONE 0xc000 thru 0xdfff	(0x2000 bytes) to 0x0 thru 0x1fff
6214005(117 mod 256): TRUNCATE DOWN	from 0x2abe1 to 0x774f
6214006(118 mod 256): PUNCH    0x38b9 thru 0x774e	(0x3e96 bytes)
6214007(119 mod 256): COPY 0x1637 thru 0x774e	(0x6118 bytes) to 0x57576 thru 0x5d68d
6214008(120 mod 256): COLLAPSE 0x5a000 thru 0x5cfff	(0x3000 bytes)
6214009(121 mod 256): DEDUPE 0x2a000 thru 0x2efff	(0x5000 bytes) to 0x3e000 thru 0x42fff
6214010(122 mod 256): WRITE    0x619d1 thru 0x712f1	(0xf921 bytes) HOLE	***WWWW
6214011(123 mod 256): COPY 0x4223e thru 0x45509	(0x32cc bytes) to 0x61d95 thru 0x65060
6214012(124 mod 256): INSERT 0x65000 thru 0x80fff	(0x1c000 bytes)	******IIII
6214013(125 mod 256): MAPWRITE 0x52067 thru 0x68d98	(0x16d32 bytes)
6214014(126 mod 256): ZERO     0x533f thru 0x1b729	(0x163eb bytes)
6214015(127 mod 256): INSERT 0x2f000 thru 0x33fff	(0x5000 bytes)
6214016(128 mod 256): COLLAPSE 0x45000 thru 0x52fff	(0xe000 bytes)
6214017(129 mod 256): READ     0x786d4 thru 0x842f1	(0xbc1e bytes)
6214018(130 mod 256): MAPREAD  0x1ba55 thru 0x2046a	(0x4a16 bytes)
6214019(131 mod 256): MAPWRITE 0x1a71a thru 0x2d41e	(0x12d05 bytes)
6214020(132 mod 256): INSERT 0x46000 thru 0x53fff	(0xe000 bytes)
6214021(133 mod 256): COLLAPSE 0x1000 thru 0x3fff	(0x3000 bytes)
6214022(134 mod 256): SKIPPED (no operation)
6214023(135 mod 256): WRITE    0x85ef1 thru 0x8b26f	(0x537f bytes)
6214024(136 mod 256): WRITE    0x59412 thru 0x595b1	(0x1a0 bytes)
6214025(137 mod 256): INSERT 0x5d000 thru 0x5ffff	(0x3000 bytes)
6214026(138 mod 256): WRITE    0x36000 thru 0x381a8	(0x21a9 bytes)
6214027(139 mod 256): FALLOC   0x8f49 thru 0xf5a9	(0x6660 bytes) INTERIOR
6214028(140 mod 256): MAPWRITE 0x4c86e thru 0x5eee3	(0x12676 bytes)
6214029(141 mod 256): FALLOC   0x32911 thru 0x390fa	(0x67e9 bytes) INTERIOR
6214030(142 mod 256): MAPWRITE 0x216df thru 0x387bc	(0x170de bytes)
6214031(143 mod 256): SKIPPED (no operation)
6214032(144 mod 256): FALLOC   0x72a82 thru 0x7d8c1	(0xae3f bytes) INTERIOR
6214033(145 mod 256): SKIPPED (no operation)
6214034(146 mod 256): ZERO     0x6a7da thru 0x81a1e	(0x17245 bytes)	******ZZZZ
6214035(147 mod 256): MAPWRITE 0x2c763 thru 0x42ea0	(0x1673e bytes)
6214036(148 mod 256): ZERO     0x18433 thru 0x2231f	(0x9eed bytes)
6214037(149 mod 256): MAPWRITE 0x3de53 thru 0x450ce	(0x727c bytes)
6214038(150 mod 256): SKIPPED (no operation)
6214039(151 mod 256): ZERO     0x75c50 thru 0x83451	(0xd802 bytes)
6214040(152 mod 256): DEDUPE 0x16000 thru 0x1ffff	(0xa000 bytes) to 0x28000 thru 0x31fff
6214041(153 mod 256): COLLAPSE 0x5e000 thru 0x7afff	(0x1d000 bytes)	******CCCC
6214042(154 mod 256): FALLOC   0x7af38 thru 0x88ad3	(0xdb9b bytes) EXTENDING
6214043(155 mod 256): COLLAPSE 0x14000 thru 0x21fff	(0xe000 bytes)
6214044(156 mod 256): SKIPPED (no operation)
6214045(157 mod 256): SKIPPED (no operation)
6214046(158 mod 256): COLLAPSE 0x13000 thru 0x13fff	(0x1000 bytes)
6214047(159 mod 256): FALLOC   0x77674 thru 0x7f0e4	(0x7a70 bytes) PAST_EOF
6214048(160 mod 256): MAPWRITE 0x21533 thru 0x2c747	(0xb215 bytes)
6214049(161 mod 256): MAPWRITE 0x64c84 thru 0x82370	(0x1d6ed bytes)	******WWWW
6214050(162 mod 256): MAPREAD  0x888f thru 0xd6b4	(0x4e26 bytes)
6214051(163 mod 256): TRUNCATE DOWN	from 0x82371 to 0x514dd	******WWWW
6214052(164 mod 256): TRUNCATE UP	from 0x514dd to 0x918c9	******WWWW
6214053(165 mod 256): SKIPPED (no operation)
6214054(166 mod 256): PUNCH    0x28a5e thru 0x329d5	(0x9f78 bytes)
6214055(167 mod 256): WRITE    0x1c74b thru 0x318f2	(0x151a8 bytes)
6214056(168 mod 256): WRITE    0x321f6 thru 0x48b6a	(0x16975 bytes)
6214057(169 mod 256): MAPWRITE 0x8e723 thru 0x927bf	(0x409d bytes)
6214058(170 mod 256): CLONE 0x15000 thru 0x2dfff	(0x19000 bytes) to 0x74000 thru 0x8cfff
6214059(171 mod 256): CLONE 0x79000 thru 0x91fff	(0x19000 bytes) to 0x41000 thru 0x59fff
6214060(172 mod 256): MAPWRITE 0x618ed thru 0x7e3c3	(0x1cad7 bytes)	******WWWW
6214061(173 mod 256): COLLAPSE 0x1d000 thru 0x26fff	(0xa000 bytes)
6214062(174 mod 256): MAPREAD  0x73ed8 thru 0x887bf	(0x148e8 bytes)
6214063(175 mod 256): COPY 0x752bb thru 0x887bf	(0x13505 bytes) to 0x56e06 thru 0x6a30a
6214064(176 mod 256): CLONE 0x4e000 thru 0x5efff	(0x11000 bytes) to 0x61000 thru 0x71fff	******JJJJ
6214065(177 mod 256): COLLAPSE 0x7d000 thru 0x7ffff	(0x3000 bytes)
6214066(178 mod 256): CLONE 0x40000 thru 0x41fff	(0x2000 bytes) to 0x44000 thru 0x45fff
6214067(179 mod 256): SKIPPED (no operation)
6214068(180 mod 256): DEDUPE 0x44000 thru 0x5dfff	(0x1a000 bytes) to 0x4000 thru 0x1dfff
6214069(181 mod 256): MAPREAD  0x1288c thru 0x2655e	(0x13cd3 bytes)
6214070(182 mod 256): CLONE 0x18000 thru 0x33fff	(0x1c000 bytes) to 0x48000 thru 0x63fff
6214071(183 mod 256): READ     0x56ebe thru 0x5cd12	(0x5e55 bytes)
6214072(184 mod 256): WRITE    0x37d48 thru 0x4c141	(0x143fa bytes)
6214073(185 mod 256): INSERT 0x85000 thru 0x91fff	(0xd000 bytes)
6214074(186 mod 256): CLONE 0x8f000 thru 0x91fff	(0x3000 bytes) to 0x2000 thru 0x4fff
6214075(187 mod 256): COPY 0x6df99 thru 0x8a7d6	(0x1c83e bytes) to 0x7a67 thru 0x242a4	EEEE******
6214076(188 mod 256): COPY 0x3f003 thru 0x57a9c	(0x18a9a bytes) to 0x2703 thru 0x1b19c
6214077(189 mod 256): WRITE    0x4881a thru 0x647a8	(0x1bf8f bytes)
6214078(190 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x45481	******WWWW
6214079(191 mod 256): CLONE 0x34000 thru 0x35fff	(0x2000 bytes) to 0x2d000 thru 0x2efff
6214080(192 mod 256): COLLAPSE 0xf000 thru 0x12fff	(0x4000 bytes)
6214081(193 mod 256): SKIPPED (no operation)
6214082(194 mod 256): FALLOC   0x76b71 thru 0x8b8fe	(0x14d8d bytes) EXTENDING
6214083(195 mod 256): ZERO     0x777ac thru 0x7ab0c	(0x3361 bytes)
6214084(196 mod 256): MAPREAD  0x606f3 thru 0x7143a	(0x10d48 bytes)	***RRRR***
6214085(197 mod 256): PUNCH    0x45c19 thru 0x51c3b	(0xc023 bytes)
6214086(198 mod 256): CLONE 0xa000 thru 0x15fff	(0xc000 bytes) to 0x69000 thru 0x74fff	******JJJJ
6214087(199 mod 256): COPY 0x5d39d thru 0x6ecf3	(0x11957 bytes) to 0x29acb thru 0x3b421
6214088(200 mod 256): ZERO     0x57a23 thru 0x5cc87	(0x5265 bytes)
6214089(201 mod 256): CLONE 0x40000 thru 0x46fff	(0x7000 bytes) to 0x9000 thru 0xffff
6214090(202 mod 256): READ     0x66b08 thru 0x6b310	(0x4809 bytes)
6214091(203 mod 256): PUNCH    0x7996c thru 0x8b8fd	(0x11f92 bytes)
6214092(204 mod 256): COLLAPSE 0x3a000 thru 0x3afff	(0x1000 bytes)
6214093(205 mod 256): PUNCH    0x1a722 thru 0x33531	(0x18e10 bytes)
6214094(206 mod 256): PUNCH    0x565ce thru 0x6a37d	(0x13db0 bytes)
6214095(207 mod 256): DEDUPE 0x37000 thru 0x48fff	(0x12000 bytes) to 0x9000 thru 0x1afff
6214096(208 mod 256): MAPWRITE 0x7e311 thru 0x863eb	(0x80db bytes)
6214097(209 mod 256): READ     0x571c0 thru 0x67f5e	(0x10d9f bytes)
6214098(210 mod 256): WRITE    0x534e8 thru 0x5552c	(0x2045 bytes)
6214099(211 mod 256): SKIPPED (no operation)
6214100(212 mod 256): DEDUPE 0x13000 thru 0x20fff	(0xe000 bytes) to 0x2a000 thru 0x37fff
6214101(213 mod 256): WRITE    0x379d5 thru 0x48628	(0x10c54 bytes)
6214102(214 mod 256): SKIPPED (no operation)
6214103(215 mod 256): FALLOC   0x25bd thru 0x1f965	(0x1d3a8 bytes) INTERIOR
6214104(216 mod 256): READ     0x66f50 thru 0x68128	(0x11d9 bytes)
6214105(217 mod 256): MAPREAD  0x8977c thru 0x8a8fd	(0x1182 bytes)
6214106(218 mod 256): PUNCH    0x7542a thru 0x808f7	(0xb4ce bytes)
6214107(219 mod 256): COLLAPSE 0x60000 thru 0x73fff	(0x14000 bytes)	******CCCC
6214108(220 mod 256): ZERO     0x796b thru 0x24c8e	(0x1d324 bytes)
6214109(221 mod 256): INSERT 0x67000 thru 0x81fff	(0x1b000 bytes)	******IIII
6214110(222 mod 256): FALLOC   0x764ea thru 0x79495	(0x2fab bytes) INTERIOR
6214111(223 mod 256): DEDUPE 0x2e000 thru 0x40fff	(0x13000 bytes) to 0x6c000 thru 0x7efff	******BBBB
6214112(224 mod 256): COPY 0x1db28 thru 0x2c6eb	(0xebc4 bytes) to 0x49134 thru 0x57cf7
6214113(225 mod 256): ZERO     0x6c6a1 thru 0x71b81	(0x54e1 bytes)	******ZZZZ
6214114(226 mod 256): COPY 0x4b413 thru 0x69b6e	(0x1e75c bytes) to 0x265da thru 0x44d35
6214115(227 mod 256): FALLOC   0x1f799 thru 0x23f32	(0x4799 bytes) INTERIOR
6214116(228 mod 256): MAPWRITE 0x820db thru 0x8c7a3	(0xa6c9 bytes)
6214117(229 mod 256): COLLAPSE 0x35000 thru 0x3afff	(0x6000 bytes)
6214118(230 mod 256): TRUNCATE DOWN	from 0x8b8fe to 0x6ae16	******WWWW
6214119(231 mod 256): COPY 0x4119f thru 0x5101d	(0xfe7f bytes) to 0x575cb thru 0x67449
6214120(232 mod 256): MAPWRITE 0x7ec99 thru 0x8d174	(0xe4dc bytes)
6214121(233 mod 256): READ     0x12d41 thru 0x1a004	(0x72c4 bytes)
6214122(234 mod 256): TRUNCATE DOWN	from 0x8d175 to 0x131aa	******WWWW
6214123(235 mod 256): DEDUPE 0xe000 thru 0x11fff	(0x4000 bytes) to 0x9000 thru 0xcfff
6214124(236 mod 256): ZERO     0x2ca1 thru 0x7918	(0x4c78 bytes)
6214125(237 mod 256): ZERO     0x10753 thru 0x267cd	(0x1607b bytes)
6214126(238 mod 256): INSERT 0x3000 thru 0xffff	(0xd000 bytes)
6214127(239 mod 256): SKIPPED (no operation)
6214128(240 mod 256): PUNCH    0xae6 thru 0x5b25	(0x5040 bytes)
6214129(241 mod 256): SKIPPED (no operation)
6214130(242 mod 256): WRITE    0x4d872 thru 0x5607e	(0x880d bytes) HOLE
6214131(243 mod 256): READ     0x4fea1 thru 0x5607e	(0x61de bytes)
6214132(244 mod 256): WRITE    0x5810c thru 0x60dfa	(0x8cef bytes) HOLE
6214133(245 mod 256): TRUNCATE UP	from 0x60dfb to 0x63ebd
6214134(246 mod 256): DEDUPE 0x53000 thru 0x62fff	(0x10000 bytes) to 0x33000 thru 0x42fff
6214135(247 mod 256): MAPREAD  0x3172 thru 0x36b6	(0x545 bytes)
6214136(248 mod 256): INSERT 0x11000 thru 0x28fff	(0x18000 bytes)
6214137(249 mod 256): INSERT 0x52000 thru 0x5afff	(0x9000 bytes)
6214138(250 mod 256): COLLAPSE 0x7000 thru 0x10fff	(0xa000 bytes)
6214139(251 mod 256): INSERT 0x2e000 thru 0x30fff	(0x3000 bytes)
6214140(252 mod 256): WRITE    0x1aa68 thru 0x29e81	(0xf41a bytes)
6214141(253 mod 256): WRITE    0x3d6e8 thru 0x44b93	(0x74ac bytes)
6214142(254 mod 256): ZERO     0x6a4b9 thru 0x732bc	(0x8e04 bytes)	******ZZZZ
6214143(255 mod 256): PUNCH    0xdf76 thru 0x22a20	(0x14aab bytes)
6214144(  0 mod 256): INSERT 0x65000 thru 0x67fff	(0x3000 bytes)
6214145(  1 mod 256): MAPWRITE 0x8d631 thru 0x922ea	(0x4cba bytes)
6214146(  2 mod 256): CLONE 0x5f000 thru 0x6bfff	(0xd000 bytes) to 0x6c000 thru 0x78fff	******JJJJ
6214147(  3 mod 256): CLONE 0x55000 thru 0x71fff	(0x1d000 bytes) to 0x37000 thru 0x53fff	JJJJ******
6214148(  4 mod 256): PUNCH    0x61e12 thru 0x804e7	(0x1e6d6 bytes)	******PPPP
6214149(  5 mod 256): MAPREAD  0x4f7e6 thru 0x5eb6c	(0xf387 bytes)
6214150(  6 mod 256): MAPWRITE 0x5d3e2 thru 0x6fa3d	(0x1265c bytes)	******WWWW
6214151(  7 mod 256): ZERO     0x30e07 thru 0x37ddd	(0x6fd7 bytes)
6214152(  8 mod 256): SKIPPED (no operation)
6214153(  9 mod 256): ZERO     0x5a1a0 thru 0x66623	(0xc484 bytes)
6214154( 10 mod 256): WRITE    0x1db8b thru 0x2bae4	(0xdf5a bytes)
6214155( 11 mod 256): MAPWRITE 0x335d2 thru 0x34af1	(0x1520 bytes)
6214156( 12 mod 256): MAPWRITE 0x7d4fb thru 0x8000d	(0x2b13 bytes)
6214157( 13 mod 256): SKIPPED (no operation)
6214158( 14 mod 256): MAPREAD  0xcdd1 thru 0x26ad2	(0x19d02 bytes)
6214159( 15 mod 256): FALLOC   0x2520 thru 0xdd2c	(0xb80c bytes) INTERIOR
6214160( 16 mod 256): MAPREAD  0x91af1 thru 0x922ea	(0x7fa bytes)
6214161( 17 mod 256): PUNCH    0x7a318 thru 0x891b5	(0xee9e bytes)
6214162( 18 mod 256): READ     0x4d178 thru 0x52d7f	(0x5c08 bytes)
6214163( 19 mod 256): COPY 0x3730a thru 0x3dcf2	(0x69e9 bytes) to 0x6d409 thru 0x73df1	******EEEE
6214164( 20 mod 256): MAPWRITE 0x2249a thru 0x246e0	(0x2247 bytes)
6214165( 21 mod 256): MAPWRITE 0x4f9af thru 0x5e9a8	(0xeffa bytes)
6214166( 22 mod 256): WRITE    0x5e3ce thru 0x702a0	(0x11ed3 bytes)	***WWWW
6214167( 23 mod 256): CLONE 0x4000 thru 0x10fff	(0xd000 bytes) to 0x28000 thru 0x34fff
6214168( 24 mod 256): ZERO     0x2f64a thru 0x496a0	(0x1a057 bytes)
6214169( 25 mod 256): TRUNCATE DOWN	from 0x922eb to 0x5d920	******WWWW
6214170( 26 mod 256): INSERT 0x33000 thru 0x4efff	(0x1c000 bytes)
6214171( 27 mod 256): MAPREAD  0x72d7b thru 0x7991f	(0x6ba5 bytes)
6214172( 28 mod 256): READ     0x38ccd thru 0x4b0ae	(0x123e2 bytes)
6214173( 29 mod 256): DEDUPE 0x27000 thru 0x42fff	(0x1c000 bytes) to 0x5b000 thru 0x76fff	******BBBB
6214174( 30 mod 256): MAPREAD  0x583bd thru 0x677b1	(0xf3f5 bytes)
6214175( 31 mod 256): TRUNCATE DOWN	from 0x79920 to 0x42b64	******WWWW
6214176( 32 mod 256): INSERT 0x28000 thru 0x40fff	(0x19000 bytes)
6214177( 33 mod 256): COPY 0x21214 thru 0x3206d	(0x10e5a bytes) to 0x80a4c thru 0x918a5
6214178( 34 mod 256): WRITE    0x88cf9 thru 0x927bf	(0x9ac7 bytes) EXTEND
6214179( 35 mod 256): MAPWRITE 0x3c666 thru 0x41cd5	(0x5670 bytes)
6214180( 36 mod 256): WRITE    0x609eb thru 0x73251	(0x12867 bytes)	***WWWW
6214181( 37 mod 256): DEDUPE 0xb000 thru 0x22fff	(0x18000 bytes) to 0x79000 thru 0x90fff
6214182( 38 mod 256): MAPREAD  0x8d21 thru 0x21b45	(0x18e25 bytes)
6214183( 39 mod 256): FALLOC   0x8f861 thru 0x927c0	(0x2f5f bytes) INTERIOR
6214184( 40 mod 256): READ     0x6a7da thru 0x6d9e7	(0x320e bytes)
6214185( 41 mod 256): PUNCH    0x1248a thru 0x3059c	(0x1e113 bytes)
6214186( 42 mod 256): DEDUPE 0xe000 thru 0x20fff	(0x13000 bytes) to 0x70000 thru 0x82fff
6214187( 43 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1beba	******WWWW
6214188( 44 mod 256): WRITE    0x193b5 thru 0x1c04c	(0x2c98 bytes) EXTEND
6214189( 45 mod 256): SKIPPED (no operation)
6214190( 46 mod 256): COPY 0x34d0 thru 0x19e14	(0x16945 bytes) to 0x443dc thru 0x5ad20
6214191( 47 mod 256): READ     0x57920 thru 0x5ad20	(0x3401 bytes)
6214192( 48 mod 256): PUNCH    0x4ef42 thru 0x5ad20	(0xbddf bytes)
6214193( 49 mod 256): PUNCH    0x16cb thru 0xba2a	(0xa360 bytes)
6214194( 50 mod 256): SKIPPED (no operation)
6214195( 51 mod 256): FALLOC   0x82230 thru 0x927c0	(0x10590 bytes) PAST_EOF
6214196( 52 mod 256): FALLOC   0x1c35 thru 0x33fa	(0x17c5 bytes) INTERIOR
6214197( 53 mod 256): COPY 0x511a8 thru 0x551c1	(0x401a bytes) to 0x20841 thru 0x2485a
6214198( 54 mod 256): DEDUPE 0x2e000 thru 0x40fff	(0x13000 bytes) to 0x7000 thru 0x19fff
6214199( 55 mod 256): COLLAPSE 0x41000 thru 0x47fff	(0x7000 bytes)
6214200( 56 mod 256): COPY 0x5091d thru 0x53d20	(0x3404 bytes) to 0x54709 thru 0x57b0c
6214201( 57 mod 256): MAPWRITE 0x567e thru 0x1e803	(0x19186 bytes)
6214202( 58 mod 256): INSERT 0x2c000 thru 0x3cfff	(0x11000 bytes)
6214203( 59 mod 256): CLONE 0x1d000 thru 0x23fff	(0x7000 bytes) to 0x3b000 thru 0x41fff
6214204( 60 mod 256): INSERT 0x3b000 thru 0x4cfff	(0x12000 bytes)
6214205( 61 mod 256): MAPREAD  0x26a1a thru 0x2c289	(0x5870 bytes)
6214206( 62 mod 256): FALLOC   0x8f488 thru 0x927c0	(0x3338 bytes) PAST_EOF
6214207( 63 mod 256): MAPREAD  0x5f77a thru 0x67092	(0x7919 bytes)
6214208( 64 mod 256): PUNCH    0x6617a thru 0x724ce	(0xc355 bytes)	******PPPP
6214209( 65 mod 256): SKIPPED (no operation)
6214210( 66 mod 256): DEDUPE 0x4000 thru 0x19fff	(0x16000 bytes) to 0x4d000 thru 0x62fff
6214211( 67 mod 256): READ     0x2f778 thru 0x48d7c	(0x19605 bytes)
6214212( 68 mod 256): PUNCH    0xbb16 thru 0xd5c5	(0x1ab0 bytes)
6214213( 69 mod 256): MAPREAD  0x55a72 thru 0x568ba	(0xe49 bytes)
6214214( 70 mod 256): DEDUPE 0x75000 thru 0x78fff	(0x4000 bytes) to 0x28000 thru 0x2bfff
6214215( 71 mod 256): CLONE 0x2b000 thru 0x46fff	(0x1c000 bytes) to 0x57000 thru 0x72fff	******JJJJ
6214216( 72 mod 256): READ     0x7047e thru 0x7ab0c	(0xa68f bytes)
6214217( 73 mod 256): READ     0x2a283 thru 0x38688	(0xe406 bytes)
6214218( 74 mod 256): TRUNCATE DOWN	from 0x7ab0d to 0x24dbf	******WWWW
6214219( 75 mod 256): FALLOC   0x25431 thru 0x27908	(0x24d7 bytes) EXTENDING
6214220( 76 mod 256): WRITE    0x4e48 thru 0x57af	(0x968 bytes)
6214221( 77 mod 256): READ     0x2290e thru 0x27907	(0x4ffa bytes)
6214222( 78 mod 256): DEDUPE 0x18000 thru 0x26fff	(0xf000 bytes) to 0x4000 thru 0x12fff
6214223( 79 mod 256): COPY 0x17253 thru 0x27907	(0x106b5 bytes) to 0x5aff5 thru 0x6b6a9
6214224( 80 mod 256): MAPWRITE 0x66d90 thru 0x7065b	(0x98cc bytes)	******WWWW
6214225( 81 mod 256): MAPWRITE 0x273a thru 0x3bb7	(0x147e bytes)
6214226( 82 mod 256): COLLAPSE 0x34000 thru 0x3bfff	(0x8000 bytes)
6214227( 83 mod 256): WRITE    0x24d68 thru 0x258e1	(0xb7a bytes)
6214228( 84 mod 256): CLONE 0x31000 thru 0x44fff	(0x14000 bytes) to 0x5c000 thru 0x6ffff	******JJJJ
6214229( 85 mod 256): COLLAPSE 0x27000 thru 0x29fff	(0x3000 bytes)
6214230( 86 mod 256): READ     0x1a022 thru 0x32267	(0x18246 bytes)
6214231( 87 mod 256): MAPREAD  0x1a4e thru 0xe845	(0xcdf8 bytes)
6214232( 88 mod 256): COPY 0x1ef02 thru 0x3961a	(0x1a719 bytes) to 0x69456 thru 0x83b6e	******EEEE
6214233( 89 mod 256): PUNCH    0x29508 thru 0x2e2ab	(0x4da4 bytes)
6214234( 90 mod 256): WRITE    0x9944 thru 0x1c2cc	(0x12989 bytes)
6214235( 91 mod 256): FALLOC   0x19799 thru 0x361dc	(0x1ca43 bytes) INTERIOR
6214236( 92 mod 256): INSERT 0x41000 thru 0x47fff	(0x7000 bytes)
6214237( 93 mod 256): MAPREAD  0x335ee thru 0x4f80c	(0x1c21f bytes)
6214238( 94 mod 256): MAPWRITE 0x4c78b thru 0x659a3	(0x19219 bytes)
6214239( 95 mod 256): READ     0x66afd thru 0x687be	(0x1cc2 bytes)
6214240( 96 mod 256): COPY 0x478cf thru 0x4a0f0	(0x2822 bytes) to 0x5633e thru 0x58b5f
6214241( 97 mod 256): COPY 0x4232a thru 0x430f9	(0xdd0 bytes) to 0x48603 thru 0x493d2
6214242( 98 mod 256): COPY 0x4876 thru 0x131cd	(0xe958 bytes) to 0x6fc68 thru 0x7e5bf
6214243( 99 mod 256): DEDUPE 0x20000 thru 0x2ffff	(0x10000 bytes) to 0x40000 thru 0x4ffff
6214244(100 mod 256): TRUNCATE DOWN	from 0x8ab6f to 0x1a31c	******WWWW
6214245(101 mod 256): INSERT 0xf000 thru 0x11fff	(0x3000 bytes)
6214246(102 mod 256): ZERO     0x6c78 thru 0x1bf8a	(0x15313 bytes)
6214247(103 mod 256): SKIPPED (no operation)
6214248(104 mod 256): ZERO     0x7e3ae thru 0x927bf	(0x14412 bytes)
6214249(105 mod 256): WRITE    0x260fe thru 0x3d124	(0x17027 bytes)
6214250(106 mod 256): COLLAPSE 0x68000 thru 0x6afff	(0x3000 bytes)
6214251(107 mod 256): ZERO     0x71a16 thru 0x72bca	(0x11b5 bytes)
6214252(108 mod 256): TRUNCATE DOWN	from 0x8f7c0 to 0x84934
6214253(109 mod 256): PUNCH    0x7f6cc thru 0x84933	(0x5268 bytes)
6214254(110 mod 256): COLLAPSE 0x53000 thru 0x55fff	(0x3000 bytes)
6214255(111 mod 256): FALLOC   0x3058a thru 0x33835	(0x32ab bytes) INTERIOR
6214256(112 mod 256): FALLOC   0x1780 thru 0x11382	(0xfc02 bytes) INTERIOR
6214257(113 mod 256): SKIPPED (no operation)
6214258(114 mod 256): DEDUPE 0x7b000 thru 0x80fff	(0x6000 bytes) to 0x5e000 thru 0x63fff
6214259(115 mod 256): WRITE    0x8e263 thru 0x927bf	(0x455d bytes) HOLE
6214260(116 mod 256): MAPWRITE 0x9232b thru 0x927bf	(0x495 bytes)
6214261(117 mod 256): ZERO     0x31c8b thru 0x4c583	(0x1a8f9 bytes)
6214262(118 mod 256): READ     0x21cbc thru 0x23eff	(0x2244 bytes)
6214263(119 mod 256): MAPWRITE 0x757a6 thru 0x80317	(0xab72 bytes)
6214264(120 mod 256): ZERO     0x7818b thru 0x90df8	(0x18c6e bytes)
6214265(121 mod 256): SKIPPED (no operation)
6214266(122 mod 256): MAPWRITE 0x90540 thru 0x927bf	(0x2280 bytes)
6214267(123 mod 256): MAPREAD  0x47af0 thru 0x579f1	(0xff02 bytes)
6214268(124 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x67f37	******WWWW
6214269(125 mod 256): COLLAPSE 0x1b000 thru 0x33fff	(0x19000 bytes)
6214270(126 mod 256): FALLOC   0x7cd6c thru 0x8d471	(0x10705 bytes) EXTENDING
6214271(127 mod 256): DEDUPE 0x9000 thru 0xcfff	(0x4000 bytes) to 0x67000 thru 0x6afff
6214272(128 mod 256): INSERT 0x56000 thru 0x57fff	(0x2000 bytes)
6214273(129 mod 256): SKIPPED (no operation)
6214274(130 mod 256): INSERT 0x7d000 thru 0x7ffff	(0x3000 bytes)
6214275(131 mod 256): MAPREAD  0x1b035 thru 0x2a805	(0xf7d1 bytes)
6214276(132 mod 256): DEDUPE 0x2d000 thru 0x45fff	(0x19000 bytes) to 0x71000 thru 0x89fff
6214277(133 mod 256): FALLOC   0x3756d thru 0x54202	(0x1cc95 bytes) INTERIOR
6214278(134 mod 256): TRUNCATE DOWN	from 0x92471 to 0x74628
6214279(135 mod 256): MAPREAD  0x44214 thru 0x56aec	(0x128d9 bytes)
6214280(136 mod 256): DEDUPE 0x5b000 thru 0x5ffff	(0x5000 bytes) to 0x49000 thru 0x4dfff
6214281(137 mod 256): FALLOC   0x18644 thru 0x25dff	(0xd7bb bytes) INTERIOR
6214282(138 mod 256): COPY 0xa45b thru 0x21578	(0x1711e bytes) to 0x44c73 thru 0x5bd90
6214283(139 mod 256): DEDUPE 0x72000 thru 0x72fff	(0x1000 bytes) to 0x0 thru 0xfff
6214284(140 mod 256): READ     0x67e1e thru 0x74627	(0xc80a bytes)	***RRRR***
6214285(141 mod 256): ZERO     0x2bfee thru 0x32e25	(0x6e38 bytes)
6214286(142 mod 256): PUNCH    0x5b9d0 thru 0x6c2ba	(0x108eb bytes)
6214287(143 mod 256): COLLAPSE 0x47000 thru 0x5efff	(0x18000 bytes)
6214288(144 mod 256): COLLAPSE 0x15000 thru 0x21fff	(0xd000 bytes)
6214289(145 mod 256): WRITE    0x3c2ca thru 0x4dac4	(0x117fb bytes)
6214290(146 mod 256): INSERT 0x33000 thru 0x49fff	(0x17000 bytes)
6214291(147 mod 256): INSERT 0x4f000 thru 0x6bfff	(0x1d000 bytes)
6214292(148 mod 256): COPY 0x56eb7 thru 0x68cf6	(0x11e40 bytes) to 0x3444c thru 0x4628b
6214293(149 mod 256): INSERT 0x2c000 thru 0x30fff	(0x5000 bytes)
6214294(150 mod 256): SKIPPED (no operation)
6214295(151 mod 256): SKIPPED (no operation)
6214296(152 mod 256): TRUNCATE DOWN	from 0x88628 to 0xc441	******WWWW
6214297(153 mod 256): SKIPPED (no operation)
6214298(154 mod 256): COPY 0x2241 thru 0x3fd0	(0x1d90 bytes) to 0x5e6d9 thru 0x60468
6214299(155 mod 256): DEDUPE 0xd000 thru 0x28fff	(0x1c000 bytes) to 0x31000 thru 0x4cfff
6214300(156 mod 256): READ     0x6a0b thru 0x1bf24	(0x1551a bytes)
6214301(157 mod 256): SKIPPED (no operation)
6214302(158 mod 256): MAPWRITE 0x5913d thru 0x685e4	(0xf4a8 bytes)
6214303(159 mod 256): DEDUPE 0x1000 thru 0x7fff	(0x7000 bytes) to 0x33000 thru 0x39fff
6214304(160 mod 256): READ     0xe94f thru 0x10fa3	(0x2655 bytes)
6214305(161 mod 256): READ     0x4d667 thru 0x685e4	(0x1af7e bytes)
6214306(162 mod 256): SKIPPED (no operation)
6214307(163 mod 256): DEDUPE 0x66000 thru 0x67fff	(0x2000 bytes) to 0x62000 thru 0x63fff
6214308(164 mod 256): TRUNCATE UP	from 0x685e5 to 0x90e64	******WWWW
6214309(165 mod 256): WRITE    0x27a67 thru 0x2ece2	(0x727c bytes)
6214310(166 mod 256): READ     0x60425 thru 0x7c3e4	(0x1bfc0 bytes)	***RRRR***
6214311(167 mod 256): ZERO     0x161c4 thru 0x342e0	(0x1e11d bytes)
6214312(168 mod 256): COPY 0x81cd2 thru 0x90e63	(0xf192 bytes) to 0x21c0 thru 0x11351
6214313(169 mod 256): MAPWRITE 0x6e977 thru 0x74075	(0x56ff bytes)	******WWWW
6214314(170 mod 256): TRUNCATE DOWN	from 0x90e64 to 0x225e6	******WWWW
6214315(171 mod 256): READ     0xf751 thru 0x225e5	(0x12e95 bytes)
6214316(172 mod 256): COPY 0xc238 thru 0x225e5	(0x163ae bytes) to 0x4c36d thru 0x6271a
6214317(173 mod 256): READ     0x2ce41 thru 0x2f462	(0x2622 bytes)
6214318(174 mod 256): COPY 0x30221 thru 0x3c7ef	(0xc5cf bytes) to 0x7317a thru 0x7f748
6214319(175 mod 256): SKIPPED (no operation)
6214320(176 mod 256): PUNCH    0xb272 thru 0x15c84	(0xaa13 bytes)
6214321(177 mod 256): SKIPPED (no operation)
6214322(178 mod 256): MAPWRITE 0x10ce5 thru 0x2c017	(0x1b333 bytes)
6214323(179 mod 256): CLONE 0x3e000 thru 0x52fff	(0x15000 bytes) to 0x6e000 thru 0x82fff	******JJJJ
6214324(180 mod 256): WRITE    0x160d3 thru 0x2b78c	(0x156ba bytes)
6214325(181 mod 256): SKIPPED (no operation)
6214326(182 mod 256): ZERO     0x31268 thru 0x4a21a	(0x18fb3 bytes)
6214327(183 mod 256): MAPREAD  0x76686 thru 0x82fff	(0xc97a bytes)
6214328(184 mod 256): SKIPPED (no operation)
6214329(185 mod 256): CLONE 0x70000 thru 0x80fff	(0x11000 bytes) to 0x5e000 thru 0x6efff	******JJJJ
6214330(186 mod 256): WRITE    0x2fc3 thru 0x7dde	(0x4e1c bytes)
6214331(187 mod 256): READ     0x62ee8 thru 0x81ecc	(0x1efe5 bytes)	***RRRR***
6214332(188 mod 256): COLLAPSE 0x45000 thru 0x4afff	(0x6000 bytes)
6214333(189 mod 256): ZERO     0x38b27 thru 0x39187	(0x661 bytes)
6214334(190 mod 256): ZERO     0x63f8c thru 0x775c2	(0x13637 bytes)	******ZZZZ
6214335(191 mod 256): WRITE    0x26551 thru 0x3fdb2	(0x19862 bytes)
6214336(192 mod 256): MAPWRITE 0x838aa thru 0x85574	(0x1ccb bytes)
6214337(193 mod 256): READ     0x80633 thru 0x85574	(0x4f42 bytes)
6214338(194 mod 256): INSERT 0x5f000 thru 0x6bfff	(0xd000 bytes)
6214339(195 mod 256): DEDUPE 0x87000 thru 0x91fff	(0xb000 bytes) to 0x36000 thru 0x40fff
6214340(196 mod 256): WRITE    0x804cc thru 0x881e0	(0x7d15 bytes)
6214341(197 mod 256): COLLAPSE 0xd000 thru 0x1cfff	(0x10000 bytes)
6214342(198 mod 256): TRUNCATE DOWN	from 0x82575 to 0x56979	******WWWW
6214343(199 mod 256): WRITE    0x92466 thru 0x927bf	(0x35a bytes) HOLE	***WWWW
6214344(200 mod 256): ZERO     0x30308 thru 0x33b1a	(0x3813 bytes)
6214345(201 mod 256): CLONE 0x30000 thru 0x4bfff	(0x1c000 bytes) to 0x72000 thru 0x8dfff
6214346(202 mod 256): ZERO     0x2558e thru 0x263f4	(0xe67 bytes)
6214347(203 mod 256): DEDUPE 0x41000 thru 0x5efff	(0x1e000 bytes) to 0x69000 thru 0x86fff	******BBBB
6214348(204 mod 256): ZERO     0x290df thru 0x2fd3e	(0x6c60 bytes)
6214349(205 mod 256): MAPWRITE 0x27d26 thru 0x413cf	(0x196aa bytes)
6214350(206 mod 256): FALLOC   0x4a4e7 thru 0x64502	(0x1a01b bytes) INTERIOR
6214351(207 mod 256): PUNCH    0x72df1 thru 0x74d6e	(0x1f7e bytes)
6214352(208 mod 256): COLLAPSE 0x90000 thru 0x91fff	(0x2000 bytes)
6214353(209 mod 256): ZERO     0x6e93b thru 0x84645	(0x15d0b bytes)	******ZZZZ
6214354(210 mod 256): MAPREAD  0x29701 thru 0x4405a	(0x1a95a bytes)
6214355(211 mod 256): SKIPPED (no operation)
6214356(212 mod 256): ZERO     0x29f81 thru 0x33c06	(0x9c86 bytes)
6214357(213 mod 256): WRITE    0x15ae3 thru 0x2d208	(0x17726 bytes)
6214358(214 mod 256): MAPREAD  0x885d7 thru 0x8c09d	(0x3ac7 bytes)
6214359(215 mod 256): SKIPPED (no operation)
6214360(216 mod 256): SKIPPED (no operation)
6214361(217 mod 256): COPY 0x644a0 thru 0x76b4b	(0x126ac bytes) to 0x27941 thru 0x39fec	EEEE******
6214362(218 mod 256): PUNCH    0x25dd thru 0x1462f	(0x12053 bytes)
6214363(219 mod 256): CLONE 0x2b000 thru 0x31fff	(0x7000 bytes) to 0xb000 thru 0x11fff
6214364(220 mod 256): COPY 0x31b3c thru 0x37495	(0x595a bytes) to 0x4865e thru 0x4dfb7
6214365(221 mod 256): MAPREAD  0xfbf2 thru 0x28397	(0x187a6 bytes)
6214366(222 mod 256): SKIPPED (no operation)
6214367(223 mod 256): DEDUPE 0x65000 thru 0x70fff	(0xc000 bytes) to 0x74000 thru 0x7ffff	BBBB******
6214368(224 mod 256): SKIPPED (no operation)
6214369(225 mod 256): SKIPPED (no operation)
6214370(226 mod 256): COLLAPSE 0x6e000 thru 0x76fff	(0x9000 bytes)	******CCCC
6214371(227 mod 256): MAPWRITE 0x1321a thru 0x1aad7	(0x78be bytes)
6214372(228 mod 256): TRUNCATE DOWN	from 0x877c0 to 0x733d1
6214373(229 mod 256): DEDUPE 0xf000 thru 0x22fff	(0x14000 bytes) to 0x51000 thru 0x64fff
6214374(230 mod 256): WRITE    0x5a987 thru 0x78fec	(0x1e666 bytes) EXTEND	***WWWW
6214375(231 mod 256): SKIPPED (no operation)
6214376(232 mod 256): ZERO     0x86498 thru 0x927bf	(0xc328 bytes)
6214377(233 mod 256): DEDUPE 0x43000 thru 0x5ffff	(0x1d000 bytes) to 0xa000 thru 0x26fff
6214378(234 mod 256): PUNCH    0x41ad4 thru 0x41b15	(0x42 bytes)
6214379(235 mod 256): COLLAPSE 0xc000 thru 0x21fff	(0x16000 bytes)
6214380(236 mod 256): MAPREAD  0x88fe thru 0x1bbfe	(0x13301 bytes)
6214381(237 mod 256): DEDUPE 0x47000 thru 0x49fff	(0x3000 bytes) to 0x20000 thru 0x22fff
6214382(238 mod 256): COPY 0x39c02 thru 0x420b3	(0x84b2 bytes) to 0x54cb3 thru 0x5d164
6214383(239 mod 256): ZERO     0x21072 thru 0x30423	(0xf3b2 bytes)
6214384(240 mod 256): DEDUPE 0x34000 thru 0x4cfff	(0x19000 bytes) to 0x6000 thru 0x1efff
6214385(241 mod 256): DEDUPE 0x13000 thru 0x2bfff	(0x19000 bytes) to 0x39000 thru 0x51fff
6214386(242 mod 256): PUNCH    0x4cdbb thru 0x569f0	(0x9c36 bytes)
6214387(243 mod 256): FALLOC   0x7885d thru 0x91d01	(0x194a4 bytes) EXTENDING
6214388(244 mod 256): DEDUPE 0x61000 thru 0x79fff	(0x19000 bytes) to 0x41000 thru 0x59fff	BBBB******
6214389(245 mod 256): WRITE    0x3913 thru 0x19e6f	(0x1655d bytes)
6214390(246 mod 256): FALLOC   0x87fdc thru 0x8a7e1	(0x2805 bytes) INTERIOR
6214391(247 mod 256): SKIPPED (no operation)
6214392(248 mod 256): CLONE 0x50000 thru 0x57fff	(0x8000 bytes) to 0x5c000 thru 0x63fff
6214393(249 mod 256): CLONE 0x5b000 thru 0x63fff	(0x9000 bytes) to 0x43000 thru 0x4bfff
6214394(250 mod 256): COLLAPSE 0x7b000 thru 0x85fff	(0xb000 bytes)
6214395(251 mod 256): COPY 0x3695a thru 0x4c6ca	(0x15d71 bytes) to 0x13616 thru 0x29386
6214396(252 mod 256): INSERT 0x5b000 thru 0x65fff	(0xb000 bytes)
6214397(253 mod 256): DEDUPE 0x7b000 thru 0x8ffff	(0x15000 bytes) to 0x1a000 thru 0x2efff
6214398(254 mod 256): COPY 0x644ae thru 0x7e983	(0x1a4d6 bytes) to 0x237c2 thru 0x3dc97	EEEE******
6214399(255 mod 256): MAPWRITE 0x4afd4 thru 0x526ac	(0x76d9 bytes)
6214400(  0 mod 256): COLLAPSE 0x51000 thru 0x64fff	(0x14000 bytes)
6214401(  1 mod 256): INSERT 0xa000 thru 0x1cfff	(0x13000 bytes)
6214402(  2 mod 256): FALLOC   0x3cf59 thru 0x55f5f	(0x19006 bytes) INTERIOR
6214403(  3 mod 256): FALLOC   0x2bb5e thru 0x3304b	(0x74ed bytes) INTERIOR
6214404(  4 mod 256): TRUNCATE DOWN	from 0x90d01 to 0x40fca	******WWWW
6214405(  5 mod 256): INSERT 0x3f000 thru 0x4ffff	(0x11000 bytes)
6214406(  6 mod 256): FALLOC   0x45315 thru 0x518c7	(0xc5b2 bytes) INTERIOR
6214407(  7 mod 256): MAPREAD  0x336b0 thru 0x51fc9	(0x1e91a bytes)
6214408(  8 mod 256): COLLAPSE 0x4a000 thru 0x50fff	(0x7000 bytes)
6214409(  9 mod 256): SKIPPED (no operation)
6214410( 10 mod 256): DEDUPE 0x47000 thru 0x49fff	(0x3000 bytes) to 0x43000 thru 0x45fff
6214411( 11 mod 256): INSERT 0x2000 thru 0xbfff	(0xa000 bytes)
6214412( 12 mod 256): MAPWRITE 0x8a2c thru 0x24944	(0x1bf19 bytes)
6214413( 13 mod 256): COPY 0x18e74 thru 0x1a8cb	(0x1a58 bytes) to 0x90a58 thru 0x924af
6214414( 14 mod 256): WRITE    0x82fb5 thru 0x8dfdf	(0xb02b bytes)
6214415( 15 mod 256): PUNCH    0x5ebc3 thru 0x7a4df	(0x1b91d bytes)	******PPPP
6214416( 16 mod 256): DEDUPE 0x7e000 thru 0x8cfff	(0xf000 bytes) to 0x10000 thru 0x1efff
6214417( 17 mod 256): CLONE 0x6e000 thru 0x7cfff	(0xf000 bytes) to 0x50000 thru 0x5efff	JJJJ******
6214418( 18 mod 256): ZERO     0x23448 thru 0x3d778	(0x1a331 bytes)
6214419( 19 mod 256): CLONE 0x6a000 thru 0x6efff	(0x5000 bytes) to 0x1a000 thru 0x1efff	JJJJ******
6214420( 20 mod 256): DEDUPE 0x3000 thru 0xefff	(0xc000 bytes) to 0x2c000 thru 0x37fff
6214421( 21 mod 256): CLONE 0x77000 thru 0x90fff	(0x1a000 bytes) to 0x1b000 thru 0x34fff
6214422( 22 mod 256): ZERO     0x6f50c thru 0x8821d	(0x18d12 bytes)
6214423( 23 mod 256): COLLAPSE 0x3f000 thru 0x52fff	(0x14000 bytes)
6214424( 24 mod 256): TRUNCATE DOWN	from 0x7e4b0 to 0x77fbf
6214425( 25 mod 256): FALLOC   0x18c7f thru 0x3398d	(0x1ad0e bytes) INTERIOR
6214426( 26 mod 256): CLONE 0x31000 thru 0x4cfff	(0x1c000 bytes) to 0x68000 thru 0x83fff	******JJJJ
6214427( 27 mod 256): WRITE    0x44a32 thru 0x4f476	(0xaa45 bytes)
6214428( 28 mod 256): DEDUPE 0x7e000 thru 0x82fff	(0x5000 bytes) to 0x59000 thru 0x5dfff
6214429( 29 mod 256): CLONE 0x18000 thru 0x1cfff	(0x5000 bytes) to 0x2f000 thru 0x33fff
6214430( 30 mod 256): TRUNCATE DOWN	from 0x84000 to 0x677cf	******WWWW
6214431( 31 mod 256): DEDUPE 0x13000 thru 0x16fff	(0x4000 bytes) to 0x20000 thru 0x23fff
6214432( 32 mod 256): FALLOC   0x8839f thru 0x927c0	(0xa421 bytes) EXTENDING
6214433( 33 mod 256): MAPWRITE 0x21ba0 thru 0x397e5	(0x17c46 bytes)
6214434( 34 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x374cb	******WWWW
6214435( 35 mod 256): COPY 0x113f3 thru 0x23d68	(0x12976 bytes) to 0x6b13b thru 0x7dab0	******EEEE
6214436( 36 mod 256): INSERT 0x44000 thru 0x47fff	(0x4000 bytes)
6214437( 37 mod 256): READ     0x3d7fc thru 0x4ff59	(0x1275e bytes)
6214438( 38 mod 256): COPY 0x2c310 thru 0x2e85f	(0x2550 bytes) to 0x72b43 thru 0x75092
6214439( 39 mod 256): SKIPPED (no operation)
6214440( 40 mod 256): MAPREAD  0x49b55 thru 0x5c5b7	(0x12a63 bytes)
6214441( 41 mod 256): MAPREAD  0x5cee0 thru 0x726d6	(0x157f7 bytes)	***RRRR***
6214442( 42 mod 256): READ     0x5ef75 thru 0x73e58	(0x14ee4 bytes)	***RRRR***
6214443( 43 mod 256): PUNCH    0x729d thru 0x1f28e	(0x17ff2 bytes)
6214444( 44 mod 256): TRUNCATE DOWN	from 0x81ab1 to 0xc357	******WWWW
6214445( 45 mod 256): ZERO     0x8c6bc thru 0x8c9f1	(0x336 bytes)
6214446( 46 mod 256): COLLAPSE 0x6000 thru 0x1ffff	(0x1a000 bytes)
6214447( 47 mod 256): WRITE    0x6cb49 thru 0x855c6	(0x18a7e bytes) EXTEND	***WWWW
6214448( 48 mod 256): WRITE    0x2c8e1 thru 0x2df23	(0x1643 bytes)
6214449( 49 mod 256): COLLAPSE 0x7d000 thru 0x83fff	(0x7000 bytes)
6214450( 50 mod 256): TRUNCATE DOWN	from 0x7e5c7 to 0x2ba35	******WWWW
6214451( 51 mod 256): TRUNCATE UP	from 0x2ba35 to 0x3d5bd
6214452( 52 mod 256): MAPWRITE 0x210d0 thru 0x3e6d4	(0x1d605 bytes)
6214453( 53 mod 256): INSERT 0x25000 thru 0x34fff	(0x10000 bytes)
6214454( 54 mod 256): DEDUPE 0x8000 thru 0x1cfff	(0x15000 bytes) to 0x1f000 thru 0x33fff
6214455( 55 mod 256): TRUNCATE UP	from 0x4e6d5 to 0x8e724	******WWWW
6214456( 56 mod 256): READ     0x893a3 thru 0x896ab	(0x309 bytes)
6214457( 57 mod 256): SKIPPED (no operation)
6214458( 58 mod 256): FALLOC   0x1198e thru 0x2d65b	(0x1bccd bytes) INTERIOR
6214459( 59 mod 256): PUNCH    0x3396 thru 0xbd75	(0x89e0 bytes)
6214460( 60 mod 256): COLLAPSE 0x46000 thru 0x53fff	(0xe000 bytes)
6214461( 61 mod 256): ZERO     0x18ca6 thru 0x1a9b1	(0x1d0c bytes)
6214462( 62 mod 256): READ     0x5bb6b thru 0x5f448	(0x38de bytes)
6214463( 63 mod 256): MAPWRITE 0x7cb1c thru 0x7dfef	(0x14d4 bytes)
6214464( 64 mod 256): WRITE    0x58dda thru 0x7742f	(0x1e656 bytes)	***WWWW
6214465( 65 mod 256): ZERO     0x49b53 thru 0x5d920	(0x13dce bytes)
6214466( 66 mod 256): COPY 0xad85 thru 0x10151	(0x53cd bytes) to 0x67b1f thru 0x6ceeb
6214467( 67 mod 256): PUNCH    0x3e728 thru 0x43ada	(0x53b3 bytes)
6214468( 68 mod 256): COLLAPSE 0x40000 thru 0x49fff	(0xa000 bytes)
6214469( 69 mod 256): DEDUPE 0x48000 thru 0x62fff	(0x1b000 bytes) to 0x23000 thru 0x3dfff
6214470( 70 mod 256): READ     0x6ec55 thru 0x76723	(0x7acf bytes)	***RRRR***
6214471( 71 mod 256): MAPREAD  0x25a7a thru 0x2c209	(0x6790 bytes)
6214472( 72 mod 256): PUNCH    0x19c88 thru 0x2459c	(0xa915 bytes)
6214473( 73 mod 256): INSERT 0x26000 thru 0x31fff	(0xc000 bytes)
6214474( 74 mod 256): ZERO     0x35083 thru 0x44d30	(0xfcae bytes)
6214475( 75 mod 256): PUNCH    0x736ee thru 0x7bd8a	(0x869d bytes)
6214476( 76 mod 256): PUNCH    0x359f6 thru 0x3e947	(0x8f52 bytes)
6214477( 77 mod 256): SKIPPED (no operation)
6214478( 78 mod 256): MAPREAD  0x5bad1 thru 0x6220e	(0x673e bytes)
6214479( 79 mod 256): WRITE    0x6f395 thru 0x8a371	(0x1afdd bytes) EXTEND
6214480( 80 mod 256): WRITE    0x795fa thru 0x897ac	(0x101b3 bytes)
6214481( 81 mod 256): WRITE    0x3cb8b thru 0x3f6e8	(0x2b5e bytes)
6214482( 82 mod 256): MAPWRITE 0x842e6 thru 0x927bf	(0xe4da bytes)
6214483( 83 mod 256): FALLOC   0x7ea6c thru 0x927c0	(0x13d54 bytes) INTERIOR
6214484( 84 mod 256): DEDUPE 0x4b000 thru 0x51fff	(0x7000 bytes) to 0x1a000 thru 0x20fff
6214485( 85 mod 256): MAPREAD  0x52763 thru 0x5ae48	(0x86e6 bytes)
6214486( 86 mod 256): ZERO     0x6efd6 thru 0x806f6	(0x11721 bytes)	******ZZZZ
6214487( 87 mod 256): SKIPPED (no operation)
6214488( 88 mod 256): SKIPPED (no operation)
6214489( 89 mod 256): MAPWRITE 0x4162 thru 0x1895f	(0x147fe bytes)
6214490( 90 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1dd0	******WWWW
6214491( 91 mod 256): TRUNCATE UP	from 0x1dd0 to 0x82ed
6214492( 92 mod 256): COPY 0x247 thru 0x82ec	(0x80a6 bytes) to 0x1b5a9 thru 0x2364e
6214493( 93 mod 256): MAPWRITE 0x4c168 thru 0x53e13	(0x7cac bytes)
6214494( 94 mod 256): WRITE    0x788c3 thru 0x7f1d4	(0x6912 bytes) HOLE	***WWWW
6214495( 95 mod 256): SKIPPED (no operation)
6214496( 96 mod 256): CLONE 0x14000 thru 0x17fff	(0x4000 bytes) to 0x59000 thru 0x5cfff
6214497( 97 mod 256): DEDUPE 0x39000 thru 0x51fff	(0x19000 bytes) to 0x11000 thru 0x29fff
6214498( 98 mod 256): PUNCH    0x1fc3e thru 0x35e14	(0x161d7 bytes)
6214499( 99 mod 256): MAPWRITE 0x5b574 thru 0x7099c	(0x15429 bytes)	******WWWW
6214500(100 mod 256): PUNCH    0x31bf5 thru 0x3527f	(0x368b bytes)
6214501(101 mod 256): COLLAPSE 0x1d000 thru 0x2efff	(0x12000 bytes)
6214502(102 mod 256): READ     0x1bf3d thru 0x21b51	(0x5c15 bytes)
6214503(103 mod 256): COPY 0x682dc thru 0x6d1d4	(0x4ef9 bytes) to 0x400fb thru 0x44ff3
6214504(104 mod 256): WRITE    0x660fa thru 0x8086c	(0x1a773 bytes) EXTEND	***WWWW
6214505(105 mod 256): TRUNCATE DOWN	from 0x8086d to 0x32fe8	******WWWW
6214506(106 mod 256): ZERO     0x2c37f thru 0x4a825	(0x1e4a7 bytes)
6214507(107 mod 256): MAPREAD  0x49b4a thru 0x4a825	(0xcdc bytes)
6214508(108 mod 256): READ     0x4194 thru 0x1c164	(0x17fd1 bytes)
6214509(109 mod 256): MAPWRITE 0x12d30 thru 0x293f4	(0x166c5 bytes)
6214510(110 mod 256): DEDUPE 0xc000 thru 0x17fff	(0xc000 bytes) to 0x2a000 thru 0x35fff
6214511(111 mod 256): CLONE 0x38000 thru 0x38fff	(0x1000 bytes) to 0x6b000 thru 0x6bfff
6214512(112 mod 256): CLONE 0x5000 thru 0xafff	(0x6000 bytes) to 0x3f000 thru 0x44fff
6214513(113 mod 256): WRITE    0x7aa38 thru 0x87194	(0xc75d bytes) HOLE	***WWWW
6214514(114 mod 256): MAPREAD  0x5e33f thru 0x63341	(0x5003 bytes)
6214515(115 mod 256): DEDUPE 0x7a000 thru 0x85fff	(0xc000 bytes) to 0x29000 thru 0x34fff
6214516(116 mod 256): MAPWRITE 0x597bf thru 0x5a052	(0x894 bytes)
6214517(117 mod 256): WRITE    0x3d986 thru 0x5a60a	(0x1cc85 bytes)
6214518(118 mod 256): SKIPPED (no operation)
6214519(119 mod 256): WRITE    0x230ec thru 0x335ae	(0x104c3 bytes)
6214520(120 mod 256): SKIPPED (no operation)
6214521(121 mod 256): FALLOC   0x57786 thru 0x765fd	(0x1ee77 bytes) INTERIOR	******FFFF
6214522(122 mod 256): ZERO     0x4dc2e thru 0x629fd	(0x14dd0 bytes)
6214523(123 mod 256): TRUNCATE DOWN	from 0x87195 to 0x50d3f	******WWWW
6214524(124 mod 256): INSERT 0x1f000 thru 0x2bfff	(0xd000 bytes)
6214525(125 mod 256): INSERT 0x11000 thru 0x25fff	(0x15000 bytes)
6214526(126 mod 256): ZERO     0x11fe7 thru 0x261e9	(0x14203 bytes)
6214527(127 mod 256): ZERO     0x7a5ce thru 0x927bf	(0x181f2 bytes)
6214528(128 mod 256): READ     0x83d5d thru 0x88ea9	(0x514d bytes)
6214529(129 mod 256): COPY 0x81e2d thru 0x8cc4c	(0xae20 bytes) to 0x6231c thru 0x6d13b
6214530(130 mod 256): MAPWRITE 0x4a5a6 thru 0x67a7a	(0x1d4d5 bytes)
6214531(131 mod 256): MAPWRITE 0x18c11 thru 0x34f23	(0x1c313 bytes)
6214532(132 mod 256): READ     0x27992 thru 0x46c76	(0x1f2e5 bytes)
6214533(133 mod 256): PUNCH    0x1643f thru 0x319a3	(0x1b565 bytes)
6214534(134 mod 256): MAPWRITE 0x4d89e thru 0x6a2f5	(0x1ca58 bytes)
6214535(135 mod 256): FALLOC   0x365f7 thru 0x4d26f	(0x16c78 bytes) INTERIOR
6214536(136 mod 256): PUNCH    0x91861 thru 0x927bf	(0xf5f bytes)
6214537(137 mod 256): CLONE 0x71000 thru 0x72fff	(0x2000 bytes) to 0x44000 thru 0x45fff
6214538(138 mod 256): DEDUPE 0x14000 thru 0x26fff	(0x13000 bytes) to 0x45000 thru 0x57fff
6214539(139 mod 256): MAPREAD  0x36a28 thru 0x54831	(0x1de0a bytes)
6214540(140 mod 256): DEDUPE 0xe000 thru 0x29fff	(0x1c000 bytes) to 0x4e000 thru 0x69fff
6214541(141 mod 256): READ     0x2fea3 thru 0x37ecf	(0x802d bytes)
6214542(142 mod 256): MAPREAD  0x796cd thru 0x927bf	(0x190f3 bytes)
6214543(143 mod 256): ZERO     0x3c38d thru 0x4a611	(0xe285 bytes)
6214544(144 mod 256): SKIPPED (no operation)
6214545(145 mod 256): DEDUPE 0x0 thru 0x4fff	(0x5000 bytes) to 0x55000 thru 0x59fff
6214546(146 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x90ba6
6214547(147 mod 256): CLONE 0x71000 thru 0x8cfff	(0x1c000 bytes) to 0x40000 thru 0x5bfff
6214548(148 mod 256): ZERO     0x55b10 thru 0x650db	(0xf5cc bytes)
6214549(149 mod 256): INSERT 0x6c000 thru 0x6cfff	(0x1000 bytes)
6214550(150 mod 256): WRITE    0x56466 thru 0x70e5b	(0x1a9f6 bytes)	***WWWW
6214551(151 mod 256): ZERO     0x72137 thru 0x733ad	(0x1277 bytes)
6214552(152 mod 256): FALLOC   0x5fbe8 thru 0x65e3b	(0x6253 bytes) INTERIOR
6214553(153 mod 256): CLONE 0x83000 thru 0x8efff	(0xc000 bytes) to 0x14000 thru 0x1ffff
6214554(154 mod 256): PUNCH    0x1da28 thru 0x24023	(0x65fc bytes)
6214555(155 mod 256): WRITE    0x22eb7 thru 0x3dab2	(0x1abfc bytes)
6214556(156 mod 256): ZERO     0x5c3be thru 0x73e4a	(0x17a8d bytes)	******ZZZZ
6214557(157 mod 256): ZERO     0x7d9f5 thru 0x927bf	(0x14dcb bytes)
6214558(158 mod 256): COPY 0x49df6 thru 0x60fd7	(0x171e2 bytes) to 0x1dd00 thru 0x34ee1
6214559(159 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4d0e8	******WWWW
6214560(160 mod 256): MAPREAD  0x31808 thru 0x4d0e7	(0x1b8e0 bytes)
6214561(161 mod 256): SKIPPED (no operation)
6214562(162 mod 256): WRITE    0x17003 thru 0x18cc4	(0x1cc2 bytes)
6214563(163 mod 256): PUNCH    0x3eaf7 thru 0x3f428	(0x932 bytes)
6214564(164 mod 256): MAPREAD  0x1a9d8 thru 0x25a3c	(0xb065 bytes)
6214565(165 mod 256): READ     0x297ee thru 0x2c929	(0x313c bytes)
6214566(166 mod 256): ZERO     0x7f064 thru 0x872e8	(0x8285 bytes)
6214567(167 mod 256): SKIPPED (no operation)
6214568(168 mod 256): PUNCH    0x228f3 thru 0x25a05	(0x3113 bytes)
6214569(169 mod 256): COPY 0x3bce5 thru 0x3e0c8	(0x23e4 bytes) to 0x1120e thru 0x135f1
6214570(170 mod 256): MAPWRITE 0x4a670 thru 0x52e12	(0x87a3 bytes)
6214571(171 mod 256): INSERT 0x46000 thru 0x46fff	(0x1000 bytes)
6214572(172 mod 256): MAPWRITE 0x1f7bc thru 0x20669	(0xeae bytes)
6214573(173 mod 256): FALLOC   0x3cf13 thru 0x50093	(0x13180 bytes) INTERIOR
6214574(174 mod 256): WRITE    0x80f54 thru 0x8ed92	(0xde3f bytes) HOLE	***WWWW
6214575(175 mod 256): READ     0x31c5 thru 0x1acfe	(0x17b3a bytes)
6214576(176 mod 256): CLONE 0x4f000 thru 0x61fff	(0x13000 bytes) to 0x2a000 thru 0x3cfff
6214577(177 mod 256): TRUNCATE DOWN	from 0x8ed93 to 0x43268	******WWWW
6214578(178 mod 256): READ     0x3660b thru 0x3eb9e	(0x8594 bytes)
6214579(179 mod 256): ZERO     0x3d04a thru 0x42451	(0x5408 bytes)
6214580(180 mod 256): FALLOC   0x84374 thru 0x8aec8	(0x6b54 bytes) PAST_EOF
6214581(181 mod 256): FALLOC   0x74e90 thru 0x927c0	(0x1d930 bytes) PAST_EOF
6214582(182 mod 256): WRITE    0x77170 thru 0x7b37c	(0x420d bytes) HOLE	***WWWW
6214583(183 mod 256): CLONE 0x1a000 thru 0x1afff	(0x1000 bytes) to 0x4d000 thru 0x4dfff
6214584(184 mod 256): READ     0x34066 thru 0x50038	(0x1bfd3 bytes)
6214585(185 mod 256): COPY 0xbbcb thru 0x285a6	(0x1c9dc bytes) to 0x55302 thru 0x71cdd	******EEEE
6214586(186 mod 256): COLLAPSE 0x3e000 thru 0x51fff	(0x14000 bytes)
6214587(187 mod 256): MAPWRITE 0x3f0e4 thru 0x43d14	(0x4c31 bytes)
6214588(188 mod 256): ZERO     0x83cec thru 0x85cf4	(0x2009 bytes)
6214589(189 mod 256): MAPREAD  0x65049 thru 0x6737c	(0x2334 bytes)
6214590(190 mod 256): ZERO     0x54b77 thru 0x57298	(0x2722 bytes)
6214591(191 mod 256): SKIPPED (no operation)
6214592(192 mod 256): MAPREAD  0x27177 thru 0x38c90	(0x11b1a bytes)
6214593(193 mod 256): SKIPPED (no operation)
6214594(194 mod 256): SKIPPED (no operation)
6214595(195 mod 256): DEDUPE 0x4f000 thru 0x59fff	(0xb000 bytes) to 0x19000 thru 0x23fff
6214596(196 mod 256): MAPREAD  0x528d1 thru 0x5abe9	(0x8319 bytes)
6214597(197 mod 256): MAPWRITE 0x650f9 thru 0x70dfd	(0xbd05 bytes)	******WWWW
6214598(198 mod 256): DEDUPE 0x1b000 thru 0x22fff	(0x8000 bytes) to 0x13000 thru 0x1afff
6214599(199 mod 256): FALLOC   0x6e242 thru 0x7cb34	(0xe8f2 bytes) EXTENDING	******FFFF
6214600(200 mod 256): WRITE    0x355e2 thru 0x4ac1c	(0x1563b bytes)
6214601(201 mod 256): DEDUPE 0x51000 thru 0x69fff	(0x19000 bytes) to 0x17000 thru 0x2ffff
6214602(202 mod 256): ZERO     0x3f05d thru 0x430f2	(0x4096 bytes)
6214603(203 mod 256): PUNCH    0x2e25e thru 0x352f3	(0x7096 bytes)
6214604(204 mod 256): SKIPPED (no operation)
6214605(205 mod 256): MAPWRITE 0x7cbda thru 0x8ee86	(0x122ad bytes)
6214606(206 mod 256): INSERT 0x1c000 thru 0x1efff	(0x3000 bytes)
6214607(207 mod 256): COLLAPSE 0x79000 thru 0x8efff	(0x16000 bytes)
6214608(208 mod 256): COLLAPSE 0x3c000 thru 0x59fff	(0x1e000 bytes)
6214609(209 mod 256): WRITE    0x2cb3 thru 0x174d0	(0x1481e bytes)
6214610(210 mod 256): MAPREAD  0x2cafe thru 0x38b44	(0xc047 bytes)
6214611(211 mod 256): COPY 0x4bbea thru 0x4d919	(0x1d30 bytes) to 0xb635 thru 0xd364
6214612(212 mod 256): TRUNCATE UP	from 0x5de87 to 0x8f5d4	******WWWW
6214613(213 mod 256): FALLOC   0xed7e thru 0xf4f2	(0x774 bytes) INTERIOR
6214614(214 mod 256): INSERT 0x1d000 thru 0x1ffff	(0x3000 bytes)
6214615(215 mod 256): COPY 0x663f4 thru 0x850f2	(0x1ecff bytes) to 0xdcd0 thru 0x2c9ce	EEEE******
6214616(216 mod 256): DEDUPE 0x49000 thru 0x5ffff	(0x17000 bytes) to 0xb000 thru 0x21fff
6214617(217 mod 256): SKIPPED (no operation)
6214618(218 mod 256): COLLAPSE 0x1000 thru 0xcfff	(0xc000 bytes)
6214619(219 mod 256): WRITE    0x1c79e thru 0x34578	(0x17ddb bytes)
6214620(220 mod 256): MAPWRITE 0x615b6 thru 0x79427	(0x17e72 bytes)	******WWWW
6214621(221 mod 256): MAPWRITE 0x63337 thru 0x6d767	(0xa431 bytes)
6214622(222 mod 256): ZERO     0xf15a thru 0x125af	(0x3456 bytes)
6214623(223 mod 256): ZERO     0x91a84 thru 0x927bf	(0xd3c bytes)
6214624(224 mod 256): MAPWRITE 0x81420 thru 0x88e9f	(0x7a80 bytes)
6214625(225 mod 256): FALLOC   0x30307 thru 0x49ad2	(0x197cb bytes) INTERIOR
6214626(226 mod 256): CLONE 0x26000 thru 0x2ffff	(0xa000 bytes) to 0x7c000 thru 0x85fff
6214627(227 mod 256): SKIPPED (no operation)
6214628(228 mod 256): MAPREAD  0x70bdd thru 0x7b83b	(0xac5f bytes)
6214629(229 mod 256): COLLAPSE 0x1a000 thru 0x30fff	(0x17000 bytes)
6214630(230 mod 256): PUNCH    0x24f40 thru 0x27f68	(0x3029 bytes)
6214631(231 mod 256): SKIPPED (no operation)
6214632(232 mod 256): MAPREAD  0x16b25 thru 0x31e30	(0x1b30c bytes)
6214633(233 mod 256): SKIPPED (no operation)
6214634(234 mod 256): COPY 0x21044 thru 0x355a5	(0x14562 bytes) to 0x6e3a5 thru 0x82906	******EEEE
6214635(235 mod 256): MAPWRITE 0x396c thru 0x1256a	(0xebff bytes)
6214636(236 mod 256): FALLOC   0x4b416 thru 0x661ad	(0x1ad97 bytes) INTERIOR
6214637(237 mod 256): TRUNCATE UP	from 0x82907 to 0x8c8f8
6214638(238 mod 256): COPY 0x840d0 thru 0x8c8f7	(0x8828 bytes) to 0x6887c thru 0x710a3	******EEEE
6214639(239 mod 256): WRITE    0x7fffb thru 0x927bf	(0x127c5 bytes) EXTEND
6214640(240 mod 256): MAPWRITE 0x4ed55 thru 0x57bc5	(0x8e71 bytes)
6214641(241 mod 256): SKIPPED (no operation)
6214642(242 mod 256): WRITE    0x5f27e thru 0x70fc2	(0x11d45 bytes)	***WWWW
6214643(243 mod 256): SKIPPED (no operation)
6214644(244 mod 256): SKIPPED (no operation)
6214645(245 mod 256): FALLOC   0x1fcd4 thru 0x25c8b	(0x5fb7 bytes) INTERIOR
6214646(246 mod 256): PUNCH    0x6028c thru 0x6883f	(0x85b4 bytes)
6214647(247 mod 256): SKIPPED (no operation)
6214648(248 mod 256): READ     0x7c480 thru 0x927bf	(0x16340 bytes)
6214649(249 mod 256): MAPWRITE 0x7d102 thru 0x927bf	(0x156be bytes)
6214650(250 mod 256): SKIPPED (no operation)
6214651(251 mod 256): COPY 0x56e8f thru 0x6b336	(0x144a8 bytes) to 0x54b1 thru 0x19958
6214652(252 mod 256): COPY 0x43bdc thru 0x586b2	(0x14ad7 bytes) to 0x60110 thru 0x74be6	******EEEE
6214653(253 mod 256): SKIPPED (no operation)
6214654(254 mod 256): FALLOC   0x65ee8 thru 0x6af7d	(0x5095 bytes) INTERIOR
6214655(255 mod 256): ZERO     0x41bd1 thru 0x4a1df	(0x860f bytes)
6214656(  0 mod 256): SKIPPED (no operation)
6214657(  1 mod 256): COLLAPSE 0x81000 thru 0x91fff	(0x11000 bytes)
6214658(  2 mod 256): SKIPPED (no operation)
6214659(  3 mod 256): COLLAPSE 0x2a000 thru 0x3cfff	(0x13000 bytes)
6214660(  4 mod 256): COLLAPSE 0x48000 thru 0x5ffff	(0x18000 bytes)
6214661(  5 mod 256): TRUNCATE DOWN	from 0x567c0 to 0x30e5a
6214662(  6 mod 256): MAPREAD  0x14892 thru 0x29985	(0x150f4 bytes)
6214663(  7 mod 256): SKIPPED (no operation)
6214664(  8 mod 256): CLONE 0x28000 thru 0x2ffff	(0x8000 bytes) to 0x7f000 thru 0x86fff
6214665(  9 mod 256): COPY 0x7a4c1 thru 0x86fff	(0xcb3f bytes) to 0x17605 thru 0x24143
6214666( 10 mod 256): TRUNCATE DOWN	from 0x87000 to 0x779b5
6214667( 11 mod 256): COLLAPSE 0x68000 thru 0x71fff	(0xa000 bytes)	******CCCC
6214668( 12 mod 256): MAPREAD  0x6092d thru 0x6340c	(0x2ae0 bytes)
6214669( 13 mod 256): DEDUPE 0x57000 thru 0x6bfff	(0x15000 bytes) to 0xa000 thru 0x1efff
6214670( 14 mod 256): COLLAPSE 0x4d000 thru 0x60fff	(0x14000 bytes)
6214671( 15 mod 256): CLONE 0x2e000 thru 0x43fff	(0x16000 bytes) to 0x6c000 thru 0x81fff	******JJJJ
6214672( 16 mod 256): READ     0x1c584 thru 0x29362	(0xcddf bytes)
6214673( 17 mod 256): WRITE    0xec83 thru 0x17b86	(0x8f04 bytes)
6214674( 18 mod 256): WRITE    0x77b9c thru 0x7b4e1	(0x3946 bytes)
6214675( 19 mod 256): DEDUPE 0x7e000 thru 0x80fff	(0x3000 bytes) to 0x71000 thru 0x73fff
6214676( 20 mod 256): CLONE 0xf000 thru 0x19fff	(0xb000 bytes) to 0x32000 thru 0x3cfff
6214677( 21 mod 256): TRUNCATE DOWN	from 0x82000 to 0x288bd	******WWWW
6214678( 22 mod 256): READ     0x11886 thru 0x1f38a	(0xdb05 bytes)
6214679( 23 mod 256): WRITE    0x149a2 thru 0x25ae9	(0x11148 bytes)
6214680( 24 mod 256): FALLOC   0x7e493 thru 0x917ee	(0x1335b bytes) PAST_EOF
6214681( 25 mod 256): INSERT 0x5000 thru 0x9fff	(0x5000 bytes)
6214682( 26 mod 256): ZERO     0x4dc64 thru 0x5a4c1	(0xc85e bytes)
6214683( 27 mod 256): TRUNCATE UP	from 0x2d8bd to 0x30890
6214684( 28 mod 256): INSERT 0x16000 thru 0x27fff	(0x12000 bytes)
6214685( 29 mod 256): COPY 0x22c31 thru 0x321a8	(0xf578 bytes) to 0x10219 thru 0x1f790
6214686( 30 mod 256): DEDUPE 0x1d000 thru 0x21fff	(0x5000 bytes) to 0x3000 thru 0x7fff
6214687( 31 mod 256): READ     0x2392 thru 0x1b589	(0x191f8 bytes)
6214688( 32 mod 256): READ     0x2a118 thru 0x2f02a	(0x4f13 bytes)
6214689( 33 mod 256): FALLOC   0xf9b7 thru 0x1709a	(0x76e3 bytes) INTERIOR
6214690( 34 mod 256): READ     0x33071 thru 0x4288f	(0xf81f bytes)
6214691( 35 mod 256): COPY 0x26f91 thru 0x33b3f	(0xcbaf bytes) to 0x960e thru 0x161bc
6214692( 36 mod 256): MAPREAD  0x1478f thru 0x17241	(0x2ab3 bytes)
6214693( 37 mod 256): COLLAPSE 0x31000 thru 0x3afff	(0xa000 bytes)
6214694( 38 mod 256): READ     0x28c41 thru 0x3888f	(0xfc4f bytes)
6214695( 39 mod 256): SKIPPED (no operation)
6214696( 40 mod 256): COLLAPSE 0x2f000 thru 0x30fff	(0x2000 bytes)
6214697( 41 mod 256): INSERT 0x19000 thru 0x2dfff	(0x15000 bytes)
6214698( 42 mod 256): READ     0x20355 thru 0x38105	(0x17db1 bytes)
6214699( 43 mod 256): READ     0xd0ad thru 0x25991	(0x188e5 bytes)
6214700( 44 mod 256): FALLOC   0x34f2a thru 0x37c07	(0x2cdd bytes) INTERIOR
6214701( 45 mod 256): MAPREAD  0x3a583 thru 0x44ec6	(0xa944 bytes)
6214702( 46 mod 256): MAPWRITE 0x2d10d thru 0x394c0	(0xc3b4 bytes)
6214703( 47 mod 256): WRITE    0x322db thru 0x4ddaf	(0x1bad5 bytes) EXTEND
6214704( 48 mod 256): COLLAPSE 0x1a000 thru 0x23fff	(0xa000 bytes)
6214705( 49 mod 256): COPY 0x2c462 thru 0x43daf	(0x1794e bytes) to 0x5759 thru 0x1d0a6
6214706( 50 mod 256): PUNCH    0x43a53 thru 0x43daf	(0x35d bytes)
6214707( 51 mod 256): WRITE    0x122dc thru 0x2466f	(0x12394 bytes)
6214708( 52 mod 256): SKIPPED (no operation)
6214709( 53 mod 256): TRUNCATE DOWN	from 0x43db0 to 0x194dc
6214710( 54 mod 256): CLONE 0xc000 thru 0x17fff	(0xc000 bytes) to 0x27000 thru 0x32fff
6214711( 55 mod 256): MAPREAD  0x30c3e thru 0x32fff	(0x23c2 bytes)
6214712( 56 mod 256): SKIPPED (no operation)
6214713( 57 mod 256): ZERO     0x84e91 thru 0x927bf	(0xd92f bytes)
6214714( 58 mod 256): READ     0x2ff5f thru 0x3e9b1	(0xea53 bytes)
6214715( 59 mod 256): READ     0x7ec9f thru 0x927bf	(0x13b21 bytes)
6214716( 60 mod 256): MAPWRITE 0x71b38 thru 0x85b74	(0x1403d bytes)
6214717( 61 mod 256): ZERO     0x84fa2 thru 0x927bf	(0xd81e bytes)
6214718( 62 mod 256): SKIPPED (no operation)
6214719( 63 mod 256): PUNCH    0x5ee5a thru 0x7b1da	(0x1c381 bytes)	******PPPP
6214720( 64 mod 256): ZERO     0x1eb40 thru 0x32bdf	(0x140a0 bytes)
6214721( 65 mod 256): DEDUPE 0x40000 thru 0x43fff	(0x4000 bytes) to 0x20000 thru 0x23fff
6214722( 66 mod 256): FALLOC   0x4d530 thru 0x6c208	(0x1ecd8 bytes) INTERIOR
6214723( 67 mod 256): SKIPPED (no operation)
6214724( 68 mod 256): COPY 0x55904 thru 0x57a27	(0x2124 bytes) to 0x8c5ca thru 0x8e6ed
6214725( 69 mod 256): FALLOC   0x26a2f thru 0x31030	(0xa601 bytes) INTERIOR
6214726( 70 mod 256): ZERO     0x84711 thru 0x89518	(0x4e08 bytes)
6214727( 71 mod 256): ZERO     0x583ec thru 0x6da2d	(0x15642 bytes)
6214728( 72 mod 256): MAPREAD  0x292fb thru 0x3e357	(0x1505d bytes)
6214729( 73 mod 256): FALLOC   0x68875 thru 0x6a226	(0x19b1 bytes) INTERIOR
6214730( 74 mod 256): SKIPPED (no operation)
6214731( 75 mod 256): SKIPPED (no operation)
6214732( 76 mod 256): FALLOC   0x8a0ac thru 0x927c0	(0x8714 bytes) INTERIOR
6214733( 77 mod 256): READ     0x20dd6 thru 0x3a3e2	(0x1960d bytes)
6214734( 78 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x3bf4	******WWWW
6214735( 79 mod 256): READ     0x1fc1 thru 0x3bf3	(0x1c33 bytes)
6214736( 80 mod 256): PUNCH    0x29fc thru 0x3bf3	(0x11f8 bytes)
6214737( 81 mod 256): INSERT 0x2000 thru 0x1afff	(0x19000 bytes)
6214738( 82 mod 256): TRUNCATE DOWN	from 0x1cbf4 to 0x1827e
6214739( 83 mod 256): WRITE    0x19077 thru 0x353e1	(0x1c36b bytes) HOLE
6214740( 84 mod 256): MAPREAD  0x5d41 thru 0x1e06e	(0x1832e bytes)
6214741( 85 mod 256): INSERT 0x1f000 thru 0x26fff	(0x8000 bytes)
6214742( 86 mod 256): READ     0x3327e thru 0x3d3e1	(0xa164 bytes)
6214743( 87 mod 256): WRITE    0x5226f thru 0x67804	(0x15596 bytes) HOLE
6214744( 88 mod 256): WRITE    0x91c0e thru 0x927bf	(0xbb2 bytes) HOLE	***WWWW
6214745( 89 mod 256): MAPWRITE 0x2fcf4 thru 0x3feda	(0x101e7 bytes)
6214746( 90 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2bb45	******WWWW
6214747( 91 mod 256): READ     0x22238 thru 0x2bb44	(0x990d bytes)
6214748( 92 mod 256): TRUNCATE UP	from 0x2bb45 to 0x3aea4
6214749( 93 mod 256): ZERO     0x3b4d thru 0x190e6	(0x1559a bytes)
6214750( 94 mod 256): INSERT 0x15000 thru 0x1dfff	(0x9000 bytes)
6214751( 95 mod 256): SKIPPED (no operation)
6214752( 96 mod 256): COPY 0x13c1 thru 0xe4fb	(0xd13b bytes) to 0xf09f thru 0x1c1d9
6214753( 97 mod 256): SKIPPED (no operation)
6214754( 98 mod 256): DEDUPE 0x34000 thru 0x42fff	(0xf000 bytes) to 0x15000 thru 0x23fff
6214755( 99 mod 256): TRUNCATE UP	from 0x43ea4 to 0x8b718	******WWWW
6214756(100 mod 256): COPY 0x2b64 thru 0xcf07	(0xa3a4 bytes) to 0x26304 thru 0x306a7
6214757(101 mod 256): ZERO     0x4e346 thru 0x6c115	(0x1ddd0 bytes)
6214758(102 mod 256): WRITE    0x42978 thru 0x4aff6	(0x867f bytes)
6214759(103 mod 256): TRUNCATE DOWN	from 0x8b718 to 0x3f130	******WWWW
6214760(104 mod 256): SKIPPED (no operation)
6214761(105 mod 256): MAPWRITE 0x79e9f thru 0x927bf	(0x18921 bytes)
6214762(106 mod 256): PUNCH    0x91a15 thru 0x927bf	(0xdab bytes)
6214763(107 mod 256): READ     0x91c16 thru 0x927bf	(0xbaa bytes)
6214764(108 mod 256): ZERO     0x678bc thru 0x7ed72	(0x174b7 bytes)	******ZZZZ
6214765(109 mod 256): PUNCH    0x7a4f3 thru 0x7d2a2	(0x2db0 bytes)
6214766(110 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2f99	******WWWW
6214767(111 mod 256): CLONE 0x1000 thru 0x1fff	(0x1000 bytes) to 0x17000 thru 0x17fff
6214768(112 mod 256): PUNCH    0x144c2 thru 0x17fff	(0x3b3e bytes)
6214769(113 mod 256): FALLOC   0x228bc thru 0x3ed37	(0x1c47b bytes) PAST_EOF
6214770(114 mod 256): CLONE 0x14000 thru 0x16fff	(0x3000 bytes) to 0x2b000 thru 0x2dfff
6214771(115 mod 256): INSERT 0x1e000 thru 0x33fff	(0x16000 bytes)
6214772(116 mod 256): TRUNCATE UP	from 0x44000 to 0x6a9b6
6214773(117 mod 256): CLONE 0x20000 thru 0x22fff	(0x3000 bytes) to 0x5e000 thru 0x60fff
6214774(118 mod 256): COLLAPSE 0x30000 thru 0x4afff	(0x1b000 bytes)
6214775(119 mod 256): FALLOC   0x36758 thru 0x4c4cc	(0x15d74 bytes) INTERIOR
6214776(120 mod 256): COLLAPSE 0x47000 thru 0x4dfff	(0x7000 bytes)
6214777(121 mod 256): COPY 0x2b76a thru 0x30006	(0x489d bytes) to 0x3ca86 thru 0x41322
6214778(122 mod 256): ZERO     0x16886 thru 0x2eb4d	(0x182c8 bytes)
6214779(123 mod 256): MAPWRITE 0x46394 thru 0x61b63	(0x1b7d0 bytes)
6214780(124 mod 256): MAPREAD  0x29632 thru 0x3417a	(0xab49 bytes)
6214781(125 mod 256): TRUNCATE UP	from 0x61b64 to 0x78906	******WWWW
6214782(126 mod 256): MAPWRITE 0x311ce thru 0x3f206	(0xe039 bytes)
6214783(127 mod 256): FALLOC   0x437d thru 0x1bd86	(0x17a09 bytes) INTERIOR
6214784(128 mod 256): ZERO     0x7ea81 thru 0x82ee8	(0x4468 bytes)
6214785(129 mod 256): MAPWRITE 0x7e48e thru 0x927bf	(0x14332 bytes)
6214786(130 mod 256): PUNCH    0x69209 thru 0x76519	(0xd311 bytes)	******PPPP
6214787(131 mod 256): MAPWRITE 0x131a thru 0xc912	(0xb5f9 bytes)
6214788(132 mod 256): SKIPPED (no operation)
6214789(133 mod 256): WRITE    0x759cf thru 0x90a88	(0x1b0ba bytes)
6214790(134 mod 256): SKIPPED (no operation)
6214791(135 mod 256): READ     0x2d2cf thru 0x3c4c3	(0xf1f5 bytes)
6214792(136 mod 256): COLLAPSE 0x44000 thru 0x5bfff	(0x18000 bytes)
6214793(137 mod 256): INSERT 0x7a000 thru 0x8dfff	(0x14000 bytes)
6214794(138 mod 256): COPY 0x24e77 thru 0x40adf	(0x1bc69 bytes) to 0x5cf79 thru 0x78be1	******EEEE
6214795(139 mod 256): MAPWRITE 0x2487e thru 0x3ed90	(0x1a513 bytes)
6214796(140 mod 256): WRITE    0x248de thru 0x28125	(0x3848 bytes)
6214797(141 mod 256): COPY 0x63988 thru 0x764cc	(0x12b45 bytes) to 0x2df39 thru 0x40a7d	EEEE******
6214798(142 mod 256): WRITE    0x481bb thru 0x62d6f	(0x1abb5 bytes)
6214799(143 mod 256): READ     0x3eb2f thru 0x4fa23	(0x10ef5 bytes)
6214800(144 mod 256): INSERT 0x2f000 thru 0x30fff	(0x2000 bytes)
6214801(145 mod 256): SKIPPED (no operation)
6214802(146 mod 256): FALLOC   0x1437e thru 0x2b730	(0x173b2 bytes) INTERIOR
6214803(147 mod 256): MAPREAD  0x8842d thru 0x907bf	(0x8393 bytes)
6214804(148 mod 256): SKIPPED (no operation)
6214805(149 mod 256): MAPWRITE 0x18d60 thru 0x30973	(0x17c14 bytes)
6214806(150 mod 256): READ     0x29e6a thru 0x36400	(0xc597 bytes)
6214807(151 mod 256): DEDUPE 0x31000 thru 0x4bfff	(0x1b000 bytes) to 0x53000 thru 0x6dfff
6214808(152 mod 256): TRUNCATE DOWN	from 0x907c0 to 0x85574
6214809(153 mod 256): COPY 0x67644 thru 0x85573	(0x1df30 bytes) to 0x2053d thru 0x3e46c	EEEE******
6214810(154 mod 256): COLLAPSE 0x9000 thru 0x26fff	(0x1e000 bytes)
6214811(155 mod 256): PUNCH    0x1e364 thru 0x1ef38	(0xbd5 bytes)
6214812(156 mod 256): MAPWRITE 0x262d2 thru 0x31ba1	(0xb8d0 bytes)
6214813(157 mod 256): TRUNCATE DOWN	from 0x67574 to 0x55caf
6214814(158 mod 256): COLLAPSE 0x34000 thru 0x4afff	(0x17000 bytes)
6214815(159 mod 256): DEDUPE 0x27000 thru 0x35fff	(0xf000 bytes) to 0x3000 thru 0x11fff
6214816(160 mod 256): READ     0xd8bd thru 0x1a0fb	(0xc83f bytes)
6214817(161 mod 256): SKIPPED (no operation)
6214818(162 mod 256): MAPREAD  0x11a4c thru 0x1add7	(0x938c bytes)
6214819(163 mod 256): COPY 0x22f9a thru 0x33bee	(0x10c55 bytes) to 0x581dc thru 0x68e30
6214820(164 mod 256): FALLOC   0x3d080 thru 0x435db	(0x655b bytes) INTERIOR
6214821(165 mod 256): WRITE    0x8af21 thru 0x8dd8b	(0x2e6b bytes) HOLE	***WWWW
6214822(166 mod 256): TRUNCATE DOWN	from 0x8dd8c to 0x692a6	******WWWW
6214823(167 mod 256): INSERT 0x14000 thru 0x23fff	(0x10000 bytes)
6214824(168 mod 256): CLONE 0x53000 thru 0x64fff	(0x12000 bytes) to 0x66000 thru 0x77fff	******JJJJ
6214825(169 mod 256): WRITE    0x140ea thru 0x1602b	(0x1f42 bytes)
6214826(170 mod 256): TRUNCATE DOWN	from 0x792a6 to 0x252c7	******WWWW
6214827(171 mod 256): FALLOC   0x1cb2d thru 0x1cc56	(0x129 bytes) INTERIOR
6214828(172 mod 256): ZERO     0x543ea thru 0x7119a	(0x1cdb1 bytes)	******ZZZZ
6214829(173 mod 256): FALLOC   0x7db4 thru 0x1a71d	(0x12969 bytes) INTERIOR
6214830(174 mod 256): SKIPPED (no operation)
6214831(175 mod 256): TRUNCATE DOWN	from 0x7119b to 0x5245d	******WWWW
6214832(176 mod 256): DEDUPE 0x17000 thru 0x28fff	(0x12000 bytes) to 0x3a000 thru 0x4bfff
6214833(177 mod 256): INSERT 0x47000 thru 0x5bfff	(0x15000 bytes)
6214834(178 mod 256): ZERO     0x74c1c thru 0x7756f	(0x2954 bytes)
6214835(179 mod 256): MAPWRITE 0x7b94d thru 0x927bf	(0x16e73 bytes)
6214836(180 mod 256): CLONE 0x74000 thru 0x7bfff	(0x8000 bytes) to 0x56000 thru 0x5dfff
6214837(181 mod 256): SKIPPED (no operation)
6214838(182 mod 256): SKIPPED (no operation)
6214839(183 mod 256): PUNCH    0x3bee1 thru 0x59c87	(0x1dda7 bytes)
6214840(184 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4bdf6	******WWWW
6214841(185 mod 256): DEDUPE 0x19000 thru 0x1cfff	(0x4000 bytes) to 0x3000 thru 0x6fff
6214842(186 mod 256): COPY 0xf586 thru 0x21004	(0x11a7f bytes) to 0x24777 thru 0x361f5
6214843(187 mod 256): READ     0x1e12b thru 0x3c55b	(0x1e431 bytes)
6214844(188 mod 256): WRITE    0x86d0f thru 0x927bf	(0xbab1 bytes) HOLE	***WWWW
6214845(189 mod 256): SKIPPED (no operation)
6214846(190 mod 256): FALLOC   0x2c484 thru 0x3c0e4	(0xfc60 bytes) INTERIOR
6214847(191 mod 256): WRITE    0x61f69 thru 0x77dad	(0x15e45 bytes)	***WWWW
6214848(192 mod 256): PUNCH    0x85962 thru 0x927bf	(0xce5e bytes)
6214849(193 mod 256): READ     0x70f48 thru 0x7a0fe	(0x91b7 bytes)
6214850(194 mod 256): MAPWRITE 0x83984 thru 0x83e72	(0x4ef bytes)
6214851(195 mod 256): PUNCH    0x84612 thru 0x927bf	(0xe1ae bytes)
6214852(196 mod 256): ZERO     0x23831 thru 0x389e6	(0x151b6 bytes)
6214853(197 mod 256): DEDUPE 0x6000 thru 0x21fff	(0x1c000 bytes) to 0x2b000 thru 0x46fff
6214854(198 mod 256): MAPWRITE 0x3c821 thru 0x480f4	(0xb8d4 bytes)
6214855(199 mod 256): DEDUPE 0x49000 thru 0x5ffff	(0x17000 bytes) to 0x16000 thru 0x2cfff
6214856(200 mod 256): COPY 0x31ca9 thru 0x4e87f	(0x1cbd7 bytes) to 0x71780 thru 0x8e356
6214857(201 mod 256): MAPWRITE 0x62246 thru 0x73727	(0x114e2 bytes)	******WWWW
6214858(202 mod 256): DEDUPE 0x50000 thru 0x68fff	(0x19000 bytes) to 0x13000 thru 0x2bfff
6214859(203 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x87819
6214860(204 mod 256): READ     0x5eb67 thru 0x66833	(0x7ccd bytes)
6214861(205 mod 256): ZERO     0x2393a thru 0x27efa	(0x45c1 bytes)
6214862(206 mod 256): FALLOC   0x125a9 thru 0x2c011	(0x19a68 bytes) INTERIOR
6214863(207 mod 256): SKIPPED (no operation)
6214864(208 mod 256): PUNCH    0x6d23d thru 0x75fb1	(0x8d75 bytes)	******PPPP
6214865(209 mod 256): COPY 0x50d98 thru 0x60f58	(0x101c1 bytes) to 0x5b1b thru 0x15cdb
6214866(210 mod 256): PUNCH    0x3e8c3 thru 0x43b3b	(0x5279 bytes)
6214867(211 mod 256): ZERO     0x8d400 thru 0x927bf	(0x53c0 bytes)
6214868(212 mod 256): MAPREAD  0x3ebce thru 0x5a65e	(0x1ba91 bytes)
6214869(213 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x62eb0	******WWWW
6214870(214 mod 256): PUNCH    0x53c1f thru 0x62eaf	(0xf291 bytes)
6214871(215 mod 256): CLONE 0x3d000 thru 0x54fff	(0x18000 bytes) to 0x2000 thru 0x19fff
6214872(216 mod 256): DEDUPE 0x5c000 thru 0x61fff	(0x6000 bytes) to 0x4a000 thru 0x4ffff
6214873(217 mod 256): MAPWRITE 0x305e6 thru 0x39abc	(0x94d7 bytes)
6214874(218 mod 256): MAPREAD  0x12783 thru 0x21eea	(0xf768 bytes)
6214875(219 mod 256): MAPWRITE 0x23dde thru 0x27f9e	(0x41c1 bytes)
6214876(220 mod 256): WRITE    0x61075 thru 0x61c7f	(0xc0b bytes)
6214877(221 mod 256): COLLAPSE 0x36000 thru 0x44fff	(0xf000 bytes)
6214878(222 mod 256): TRUNCATE DOWN	from 0x53eb0 to 0x501c
6214879(223 mod 256): MAPREAD  0x1a77 thru 0x29bd	(0xf47 bytes)
6214880(224 mod 256): FALLOC   0x5d61a thru 0x6ff4b	(0x12931 bytes) PAST_EOF	******FFFF
6214881(225 mod 256): READ     0x1726 thru 0x501b	(0x38f6 bytes)
6214882(226 mod 256): SKIPPED (no operation)
6214883(227 mod 256): WRITE    0x4b63 thru 0x18294	(0x13732 bytes) EXTEND
6214884(228 mod 256): PUNCH    0x43f7 thru 0x18294	(0x13e9e bytes)
6214885(229 mod 256): WRITE    0x64c8e thru 0x6f4cd	(0xa840 bytes) HOLE	***WWWW
6214886(230 mod 256): WRITE    0xfb58 thru 0x2c7b2	(0x1cc5b bytes)
6214887(231 mod 256): COLLAPSE 0x40000 thru 0x4cfff	(0xd000 bytes)
6214888(232 mod 256): TRUNCATE DOWN	from 0x624ce to 0x4d345
6214889(233 mod 256): DEDUPE 0x36000 thru 0x3ffff	(0xa000 bytes) to 0x8000 thru 0x11fff
6214890(234 mod 256): INSERT 0x1c000 thru 0x21fff	(0x6000 bytes)
6214891(235 mod 256): COLLAPSE 0x29000 thru 0x35fff	(0xd000 bytes)
6214892(236 mod 256): COPY 0x1324 thru 0x1db0b	(0x1c7e8 bytes) to 0x5fc7c thru 0x7c463	******EEEE
6214893(237 mod 256): SKIPPED (no operation)
6214894(238 mod 256): INSERT 0x4000 thru 0xffff	(0xc000 bytes)
6214895(239 mod 256): COPY 0x4b055 thru 0x58c81	(0xdc2d bytes) to 0x80c00 thru 0x8e82c
6214896(240 mod 256): COPY 0x41460 thru 0x46b01	(0x56a2 bytes) to 0x8273e thru 0x87ddf
6214897(241 mod 256): ZERO     0x4ddf2 thru 0x6b5d8	(0x1d7e7 bytes)
6214898(242 mod 256): READ     0x69f39 thru 0x7a881	(0x10949 bytes)	***RRRR***
6214899(243 mod 256): COPY 0x1c1f4 thru 0x2b805	(0xf612 bytes) to 0x4b017 thru 0x5a628
6214900(244 mod 256): INSERT 0x5f000 thru 0x61fff	(0x3000 bytes)
6214901(245 mod 256): SKIPPED (no operation)
6214902(246 mod 256): SKIPPED (no operation)
6214903(247 mod 256): SKIPPED (no operation)
6214904(248 mod 256): WRITE    0x2a779 thru 0x2b3db	(0xc63 bytes)
6214905(249 mod 256): CLONE 0x7f000 thru 0x89fff	(0xb000 bytes) to 0x10000 thru 0x1afff
6214906(250 mod 256): COLLAPSE 0x69000 thru 0x79fff	(0x11000 bytes)	******CCCC
6214907(251 mod 256): DEDUPE 0x4a000 thru 0x5dfff	(0x14000 bytes) to 0x6c000 thru 0x7ffff	******BBBB
6214908(252 mod 256): SKIPPED (no operation)
6214909(253 mod 256): PUNCH    0x4a1ad thru 0x680c7	(0x1df1b bytes)
6214910(254 mod 256): FALLOC   0x1f5e7 thru 0x27b98	(0x85b1 bytes) INTERIOR
6214911(255 mod 256): FALLOC   0x25a28 thru 0x358a4	(0xfe7c bytes) INTERIOR
6214912(  0 mod 256): COPY 0x3f742 thru 0x437df	(0x409e bytes) to 0x89170 thru 0x8d20d
6214913(  1 mod 256): INSERT 0x3c000 thru 0x40fff	(0x5000 bytes)
6214914(  2 mod 256): MAPREAD  0x6767c thru 0x78921	(0x112a6 bytes)	***RRRR***
6214915(  3 mod 256): SKIPPED (no operation)
6214916(  4 mod 256): DEDUPE 0x5000 thru 0x22fff	(0x1e000 bytes) to 0x4c000 thru 0x69fff
6214917(  5 mod 256): CLONE 0x90000 thru 0x90fff	(0x1000 bytes) to 0x44000 thru 0x44fff
6214918(  6 mod 256): SKIPPED (no operation)
6214919(  7 mod 256): ZERO     0x2c6c5 thru 0x36ee2	(0xa81e bytes)
6214920(  8 mod 256): COPY 0x3b1a0 thru 0x3c5f8	(0x1459 bytes) to 0x9065c thru 0x91ab4
6214921(  9 mod 256): TRUNCATE DOWN	from 0x9220e to 0x3eb43	******WWWW
6214922( 10 mod 256): FALLOC   0x92529 thru 0x927c0	(0x297 bytes) PAST_EOF
6214923( 11 mod 256): READ     0x3f6f thru 0x182c4	(0x14356 bytes)
6214924( 12 mod 256): READ     0xa24b thru 0xb3ea	(0x11a0 bytes)
6214925( 13 mod 256): WRITE    0x7c7dc thru 0x7cab2	(0x2d7 bytes) HOLE	***WWWW
6214926( 14 mod 256): READ     0x61ff1 thru 0x7c332	(0x1a342 bytes)	***RRRR***
6214927( 15 mod 256): MAPREAD  0x6cb31 thru 0x7b0fc	(0xe5cc bytes)	***RRRR***
6214928( 16 mod 256): CLONE 0x5f000 thru 0x6ffff	(0x11000 bytes) to 0x4000 thru 0x14fff	JJJJ******
6214929( 17 mod 256): CLONE 0x40000 thru 0x54fff	(0x15000 bytes) to 0x71000 thru 0x85fff
6214930( 18 mod 256): COPY 0x6032 thru 0x1fc12	(0x19be1 bytes) to 0x3d711 thru 0x572f1
6214931( 19 mod 256): CLONE 0x8000 thru 0xdfff	(0x6000 bytes) to 0x5e000 thru 0x63fff
6214932( 20 mod 256): COPY 0x684a8 thru 0x85f2c	(0x1da85 bytes) to 0x32ba7 thru 0x5062b	EEEE******
6214933( 21 mod 256): READ     0x13176 thru 0x1728f	(0x411a bytes)
6214934( 22 mod 256): PUNCH    0x680b5 thru 0x81fe0	(0x19f2c bytes)	******PPPP
6214935( 23 mod 256): PUNCH    0x4075e thru 0x5be44	(0x1b6e7 bytes)
6214936( 24 mod 256): COLLAPSE 0x2d000 thru 0x2ffff	(0x3000 bytes)
6214937( 25 mod 256): WRITE    0x2acde thru 0x32735	(0x7a58 bytes)
6214938( 26 mod 256): DEDUPE 0x63000 thru 0x74fff	(0x12000 bytes) to 0x24000 thru 0x35fff	BBBB******
6214939( 27 mod 256): SKIPPED (no operation)
6214940( 28 mod 256): INSERT 0xb000 thru 0xdfff	(0x3000 bytes)
6214941( 29 mod 256): READ     0x6ca28 thru 0x74c51	(0x822a bytes)	***RRRR***
6214942( 30 mod 256): FALLOC   0x6986a thru 0x80599	(0x16d2f bytes) INTERIOR	******FFFF
6214943( 31 mod 256): TRUNCATE DOWN	from 0x86000 to 0x56277	******WWWW
6214944( 32 mod 256): DEDUPE 0x6000 thru 0x1afff	(0x15000 bytes) to 0x2d000 thru 0x41fff
6214945( 33 mod 256): COPY 0x3c821 thru 0x3d7b5	(0xf95 bytes) to 0x8cf7a thru 0x8df0e
6214946( 34 mod 256): DEDUPE 0x58000 thru 0x6ffff	(0x18000 bytes) to 0x1b000 thru 0x32fff	BBBB******
6214947( 35 mod 256): CLONE 0x8000 thru 0x25fff	(0x1e000 bytes) to 0x33000 thru 0x50fff
6214948( 36 mod 256): MAPWRITE 0x6491e thru 0x76220	(0x11903 bytes)	******WWWW
6214949( 37 mod 256): DEDUPE 0x60000 thru 0x71fff	(0x12000 bytes) to 0x4e000 thru 0x5ffff	BBBB******
6214950( 38 mod 256): CLONE 0xf000 thru 0x1bfff	(0xd000 bytes) to 0x0 thru 0xcfff
6214951( 39 mod 256): WRITE    0x7b321 thru 0x927bf	(0x1749f bytes) EXTEND
6214952( 40 mod 256): MAPREAD  0x33b8e thru 0x492c0	(0x15733 bytes)
6214953( 41 mod 256): COPY 0x4c508 thru 0x4fd50	(0x3849 bytes) to 0xcf49 thru 0x10791
6214954( 42 mod 256): COLLAPSE 0x17000 thru 0x23fff	(0xd000 bytes)
6214955( 43 mod 256): READ     0x2af0c thru 0x35608	(0xa6fd bytes)
6214956( 44 mod 256): ZERO     0x85cec thru 0x927bf	(0xcad4 bytes)
6214957( 45 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x7794e
6214958( 46 mod 256): DEDUPE 0x12000 thru 0x1cfff	(0xb000 bytes) to 0x5a000 thru 0x64fff
6214959( 47 mod 256): PUNCH    0x21df8 thru 0x2f2ad	(0xd4b6 bytes)
6214960( 48 mod 256): MAPREAD  0xcfb8 thru 0x2a926	(0x1d96f bytes)
6214961( 49 mod 256): MAPREAD  0x7626c thru 0x7794d	(0x16e2 bytes)
6214962( 50 mod 256): WRITE    0x3f710 thru 0x5b515	(0x1be06 bytes)
6214963( 51 mod 256): READ     0x72d93 thru 0x7794d	(0x4bbb bytes)
6214964( 52 mod 256): WRITE    0xd3b8 thru 0x2b47c	(0x1e0c5 bytes)
6214965( 53 mod 256): INSERT 0x1e000 thru 0x33fff	(0x16000 bytes)
6214966( 54 mod 256): WRITE    0xee29 thru 0x10a4d	(0x1c25 bytes)
6214967( 55 mod 256): COPY 0x70ee2 thru 0x8d565	(0x1c684 bytes) to 0x29fe4 thru 0x46667
6214968( 56 mod 256): COPY 0x7ac8 thru 0x10b7b	(0x90b4 bytes) to 0x30fc5 thru 0x3a078
6214969( 57 mod 256): MAPWRITE 0x80901 thru 0x927bf	(0x11ebf bytes)
6214970( 58 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x91cee
6214971( 59 mod 256): SKIPPED (no operation)
6214972( 60 mod 256): FALLOC   0x17911 thru 0x1afa5	(0x3694 bytes) INTERIOR
6214973( 61 mod 256): COPY 0x90994 thru 0x91ced	(0x135a bytes) to 0x6e390 thru 0x6f6e9	******EEEE
6214974( 62 mod 256): COLLAPSE 0x15000 thru 0x31fff	(0x1d000 bytes)
6214975( 63 mod 256): FALLOC   0x1e48e thru 0x22969	(0x44db bytes) INTERIOR
6214976( 64 mod 256): TRUNCATE DOWN	from 0x74cee to 0xcf79	******WWWW
6214977( 65 mod 256): INSERT 0x0 thru 0xdfff	(0xe000 bytes)
6214978( 66 mod 256): TRUNCATE UP	from 0x1af79 to 0x86de7	******WWWW
6214979( 67 mod 256): MAPWRITE 0x68fec thru 0x77350	(0xe365 bytes)	******WWWW
6214980( 68 mod 256): FALLOC   0x78288 thru 0x81c8f	(0x9a07 bytes) INTERIOR
6214981( 69 mod 256): MAPREAD  0x1987d thru 0x1f7ed	(0x5f71 bytes)
6214982( 70 mod 256): CLONE 0x38000 thru 0x49fff	(0x12000 bytes) to 0x5b000 thru 0x6cfff
6214983( 71 mod 256): SKIPPED (no operation)
6214984( 72 mod 256): MAPWRITE 0x3d537 thru 0x4167a	(0x4144 bytes)
6214985( 73 mod 256): ZERO     0x90c21 thru 0x927bf	(0x1b9f bytes)
6214986( 74 mod 256): ZERO     0x38642 thru 0x4a243	(0x11c02 bytes)
6214987( 75 mod 256): PUNCH    0x5f56c thru 0x7ce5e	(0x1d8f3 bytes)	******PPPP
6214988( 76 mod 256): COLLAPSE 0x38000 thru 0x4dfff	(0x16000 bytes)
6214989( 77 mod 256): WRITE    0x28e48 thru 0x32169	(0x9322 bytes)
6214990( 78 mod 256): INSERT 0x4a000 thru 0x4dfff	(0x4000 bytes)
6214991( 79 mod 256): ZERO     0x6757e thru 0x85504	(0x1df87 bytes)	******ZZZZ
6214992( 80 mod 256): COPY 0x60bb8 thru 0x676bd	(0x6b06 bytes) to 0x2adb1 thru 0x318b6
6214993( 81 mod 256): MAPWRITE 0x40ed1 thru 0x57605	(0x16735 bytes)
6214994( 82 mod 256): DEDUPE 0x31000 thru 0x46fff	(0x16000 bytes) to 0x52000 thru 0x67fff
6214995( 83 mod 256): MAPWRITE 0x17a11 thru 0x317be	(0x19dae bytes)
6214996( 84 mod 256): MAPWRITE 0xdb5e thru 0x2abc1	(0x1d064 bytes)
6214997( 85 mod 256): ZERO     0x7ddab thru 0x7f7a1	(0x19f7 bytes)
6214998( 86 mod 256): DEDUPE 0x3e000 thru 0x52fff	(0x15000 bytes) to 0x28000 thru 0x3cfff
6214999( 87 mod 256): COPY 0x39ab3 thru 0x50855	(0x16da3 bytes) to 0x67c1c thru 0x7e9be	******EEEE
6215000( 88 mod 256): ZERO     0x8966f thru 0x927bf	(0x9151 bytes)
6215001( 89 mod 256): DEDUPE 0x13000 thru 0x19fff	(0x7000 bytes) to 0x8b000 thru 0x91fff
6215002( 90 mod 256): SKIPPED (no operation)
6215003( 91 mod 256): SKIPPED (no operation)
6215004( 92 mod 256): PUNCH    0x813f1 thru 0x8541e	(0x402e bytes)
6215005( 93 mod 256): FALLOC   0x57bb3 thru 0x63b81	(0xbfce bytes) INTERIOR
6215006( 94 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x74a1	******WWWW
6215007( 95 mod 256): MAPWRITE 0x18c09 thru 0x32f42	(0x1a33a bytes)
6215008( 96 mod 256): MAPREAD  0x2eac6 thru 0x32f42	(0x447d bytes)
6215009( 97 mod 256): MAPWRITE 0x70243 thru 0x8d180	(0x1cf3e bytes)
6215010( 98 mod 256): FALLOC   0xb1be thru 0x13064	(0x7ea6 bytes) INTERIOR
6215011( 99 mod 256): INSERT 0x34000 thru 0x36fff	(0x3000 bytes)
6215012(100 mod 256): COLLAPSE 0x29000 thru 0x32fff	(0xa000 bytes)
6215013(101 mod 256): TRUNCATE UP	from 0x86181 to 0x8cc09
6215014(102 mod 256): TRUNCATE DOWN	from 0x8cc09 to 0x67d93	******WWWW
6215015(103 mod 256): SKIPPED (no operation)
6215016(104 mod 256): MAPREAD  0x18a3f thru 0x20dff	(0x83c1 bytes)
6215017(105 mod 256): READ     0x47773 thru 0x61b6a	(0x1a3f8 bytes)
6215018(106 mod 256): TRUNCATE UP	from 0x67d93 to 0x87a3a	******WWWW
6215019(107 mod 256): FALLOC   0x38174 thru 0x46fab	(0xee37 bytes) INTERIOR
6215020(108 mod 256): DEDUPE 0x2000 thru 0x18fff	(0x17000 bytes) to 0x69000 thru 0x7ffff	******BBBB
6215021(109 mod 256): PUNCH    0x255c2 thru 0x312e0	(0xbd1f bytes)
6215022(110 mod 256): DEDUPE 0x20000 thru 0x2dfff	(0xe000 bytes) to 0x57000 thru 0x64fff
6215023(111 mod 256): MAPWRITE 0x83ae4 thru 0x92537	(0xea54 bytes)
6215024(112 mod 256): MAPWRITE 0x12a8b thru 0x1fa32	(0xcfa8 bytes)
6215025(113 mod 256): MAPREAD  0x739da thru 0x74182	(0x7a9 bytes)
6215026(114 mod 256): WRITE    0x24b9e thru 0x39016	(0x14479 bytes)
6215027(115 mod 256): DEDUPE 0x42000 thru 0x47fff	(0x6000 bytes) to 0x67000 thru 0x6cfff
6215028(116 mod 256): COLLAPSE 0x83000 thru 0x86fff	(0x4000 bytes)
6215029(117 mod 256): COPY 0x19d1f thru 0x33e14	(0x1a0f6 bytes) to 0x69d1b thru 0x83e10	******EEEE
6215030(118 mod 256): COPY 0x57149 thru 0x6352a	(0xc3e2 bytes) to 0x69057 thru 0x75438	******EEEE
6215031(119 mod 256): FALLOC   0xcc8 thru 0x10990	(0xfcc8 bytes) INTERIOR
6215032(120 mod 256): READ     0x5dd09 thru 0x718ee	(0x13be6 bytes)	***RRRR***
6215033(121 mod 256): MAPWRITE 0x711ad thru 0x88140	(0x16f94 bytes)
6215034(122 mod 256): INSERT 0x5c000 thru 0x5ffff	(0x4000 bytes)
6215035(123 mod 256): CLONE 0x78000 thru 0x86fff	(0xf000 bytes) to 0x33000 thru 0x41fff
6215036(124 mod 256): SKIPPED (no operation)
6215037(125 mod 256): CLONE 0x3000 thru 0x5fff	(0x3000 bytes) to 0x8b000 thru 0x8dfff
6215038(126 mod 256): SKIPPED (no operation)
6215039(127 mod 256): DEDUPE 0x68000 thru 0x74fff	(0xd000 bytes) to 0x30000 thru 0x3cfff	BBBB******
6215040(128 mod 256): CLONE 0x57000 thru 0x71fff	(0x1b000 bytes) to 0x13000 thru 0x2dfff	JJJJ******
6215041(129 mod 256): TRUNCATE DOWN	from 0x92538 to 0x56a4e	******WWWW
6215042(130 mod 256): FALLOC   0x2a000 thru 0x2b095	(0x1095 bytes) INTERIOR
6215043(131 mod 256): MAPWRITE 0x8390d thru 0x8b7b9	(0x7ead bytes)
6215044(132 mod 256): TRUNCATE DOWN	from 0x8b7ba to 0x49d3b	******WWWW
6215045(133 mod 256): FALLOC   0x3f41a thru 0x4817e	(0x8d64 bytes) INTERIOR
6215046(134 mod 256): TRUNCATE DOWN	from 0x49d3b to 0x43956
6215047(135 mod 256): FALLOC   0x4b20a thru 0x4c350	(0x1146 bytes) EXTENDING
6215048(136 mod 256): PUNCH    0x48b9a thru 0x4c34f	(0x37b6 bytes)
6215049(137 mod 256): COPY 0x29756 thru 0x4333e	(0x19be9 bytes) to 0x4f202 thru 0x68dea
6215050(138 mod 256): COLLAPSE 0x2b000 thru 0x44fff	(0x1a000 bytes)
6215051(139 mod 256): READ     0x45796 thru 0x4edea	(0x9655 bytes)
6215052(140 mod 256): INSERT 0x12000 thru 0x2bfff	(0x1a000 bytes)
6215053(141 mod 256): COLLAPSE 0x61000 thru 0x66fff	(0x6000 bytes)
6215054(142 mod 256): MAPWRITE 0x5b518 thru 0x71584	(0x1606d bytes)	******WWWW
6215055(143 mod 256): FALLOC   0x55f3f thru 0x6f154	(0x19215 bytes) INTERIOR	******FFFF
6215056(144 mod 256): PUNCH    0x152ee thru 0x30a33	(0x1b746 bytes)
6215057(145 mod 256): COLLAPSE 0x69000 thru 0x70fff	(0x8000 bytes)	******CCCC
6215058(146 mod 256): WRITE    0x15cc thru 0x4971	(0x33a6 bytes)
6215059(147 mod 256): SKIPPED (no operation)
6215060(148 mod 256): TRUNCATE UP	from 0x69585 to 0x7f303	******WWWW
6215061(149 mod 256): ZERO     0x288ba thru 0x30520	(0x7c67 bytes)
6215062(150 mod 256): READ     0xa03d thru 0x15993	(0xb957 bytes)
6215063(151 mod 256): COPY 0x2906c thru 0x37061	(0xdff6 bytes) to 0x6aeb9 thru 0x78eae	******EEEE
6215064(152 mod 256): COLLAPSE 0x27000 thru 0x2ffff	(0x9000 bytes)
6215065(153 mod 256): SKIPPED (no operation)
6215066(154 mod 256): TRUNCATE UP	from 0x76303 to 0x7d957
6215067(155 mod 256): MAPWRITE 0x4decd thru 0x62c17	(0x14d4b bytes)
6215068(156 mod 256): MAPWRITE 0x82092 thru 0x8a517	(0x8486 bytes)
6215069(157 mod 256): COPY 0x65b80 thru 0x74b67	(0xefe8 bytes) to 0x3644e thru 0x45435	EEEE******
6215070(158 mod 256): FALLOC   0x14ea7 thru 0x2c099	(0x171f2 bytes) INTERIOR
6215071(159 mod 256): INSERT 0x5000 thru 0x7fff	(0x3000 bytes)
6215072(160 mod 256): PUNCH    0x4e7f7 thru 0x5c0a0	(0xd8aa bytes)
6215073(161 mod 256): WRITE    0x2c45a thru 0x49ff2	(0x1db99 bytes)
6215074(162 mod 256): ZERO     0x23a08 thru 0x3bbb5	(0x181ae bytes)
6215075(163 mod 256): COPY 0x78d8c thru 0x84196	(0xb40b bytes) to 0x30ee2 thru 0x3c2ec
6215076(164 mod 256): SKIPPED (no operation)
6215077(165 mod 256): DEDUPE 0x63000 thru 0x68fff	(0x6000 bytes) to 0x7b000 thru 0x80fff
6215078(166 mod 256): CLONE 0x2e000 thru 0x39fff	(0xc000 bytes) to 0x64000 thru 0x6ffff	******JJJJ
6215079(167 mod 256): FALLOC   0x6b2c2 thru 0x7e5a2	(0x132e0 bytes) INTERIOR	******FFFF
6215080(168 mod 256): COLLAPSE 0x8b000 thru 0x8bfff	(0x1000 bytes)
6215081(169 mod 256): COPY 0x23618 thru 0x26987	(0x3370 bytes) to 0x4934f thru 0x4c6be
6215082(170 mod 256): READ     0x48f86 thru 0x5b357	(0x123d2 bytes)
6215083(171 mod 256): FALLOC   0x71e28 thru 0x74ccb	(0x2ea3 bytes) INTERIOR
6215084(172 mod 256): WRITE    0x3043d thru 0x44cf1	(0x148b5 bytes)
6215085(173 mod 256): WRITE    0x6ba0 thru 0x1d4c0	(0x16921 bytes)
6215086(174 mod 256): CLONE 0x16000 thru 0x31fff	(0x1c000 bytes) to 0x3d000 thru 0x58fff
6215087(175 mod 256): COLLAPSE 0x28000 thru 0x35fff	(0xe000 bytes)
6215088(176 mod 256): PUNCH    0x21a2a thru 0x3d206	(0x1b7dd bytes)
6215089(177 mod 256): SKIPPED (no operation)
6215090(178 mod 256): INSERT 0x33000 thru 0x34fff	(0x2000 bytes)
6215091(179 mod 256): COLLAPSE 0x26000 thru 0x3bfff	(0x16000 bytes)
6215092(180 mod 256): TRUNCATE DOWN	from 0x6a518 to 0x347bc
6215093(181 mod 256): MAPREAD  0x12bf6 thru 0x24ad3	(0x11ede bytes)
6215094(182 mod 256): INSERT 0x31000 thru 0x33fff	(0x3000 bytes)
6215095(183 mod 256): COPY 0x26080 thru 0x26711	(0x692 bytes) to 0x57a9f thru 0x58130
6215096(184 mod 256): COLLAPSE 0x1f000 thru 0x1ffff	(0x1000 bytes)
6215097(185 mod 256): INSERT 0x23000 thru 0x3dfff	(0x1b000 bytes)
6215098(186 mod 256): COLLAPSE 0xc000 thru 0x19fff	(0xe000 bytes)
6215099(187 mod 256): CLONE 0x3000 thru 0xdfff	(0xb000 bytes) to 0x85000 thru 0x8ffff
6215100(188 mod 256): COLLAPSE 0x79000 thru 0x82fff	(0xa000 bytes)
6215101(189 mod 256): COPY 0x41295 thru 0x41f58	(0xcc4 bytes) to 0x5f6fa thru 0x603bd
6215102(190 mod 256): SKIPPED (no operation)
6215103(191 mod 256): COPY 0x53b30 thru 0x5ffe9	(0xc4ba bytes) to 0x200c6 thru 0x2c57f
6215104(192 mod 256): WRITE    0x4a56f thru 0x66966	(0x1c3f8 bytes)
6215105(193 mod 256): INSERT 0x44000 thru 0x4ffff	(0xc000 bytes)
6215106(194 mod 256): COLLAPSE 0x3f000 thru 0x57fff	(0x19000 bytes)
6215107(195 mod 256): READ     0x64b33 thru 0x6b416	(0x68e4 bytes)
6215108(196 mod 256): ZERO     0x3f84b thru 0x4574d	(0x5f03 bytes)
6215109(197 mod 256): PUNCH    0x21020 thru 0x24cf0	(0x3cd1 bytes)
6215110(198 mod 256): COPY 0x38914 thru 0x4c059	(0x13746 bytes) to 0x4d51f thru 0x60c64
6215111(199 mod 256): MAPREAD  0x6e2d3 thru 0x718c8	(0x35f6 bytes)	***RRRR***
6215112(200 mod 256): COLLAPSE 0x75000 thru 0x77fff	(0x3000 bytes)
6215113(201 mod 256): WRITE    0x52077 thru 0x6cc48	(0x1abd2 bytes)
6215114(202 mod 256): TRUNCATE DOWN	from 0x76000 to 0x2d4e9	******WWWW
6215115(203 mod 256): ZERO     0x5f40e thru 0x74082	(0x14c75 bytes)	******ZZZZ
6215116(204 mod 256): COPY 0x40239 thru 0x4a9e0	(0xa7a8 bytes) to 0x83027 thru 0x8d7ce
6215117(205 mod 256): MAPWRITE 0x9057 thru 0xfbec	(0x6b96 bytes)
6215118(206 mod 256): MAPWRITE 0x19798 thru 0x36091	(0x1c8fa bytes)
6215119(207 mod 256): PUNCH    0xe858 thru 0x17038	(0x87e1 bytes)
6215120(208 mod 256): INSERT 0x25000 thru 0x28fff	(0x4000 bytes)
6215121(209 mod 256): TRUNCATE DOWN	from 0x917cf to 0x10bf4	******WWWW
6215122(210 mod 256): CLONE 0x6000 thru 0xffff	(0xa000 bytes) to 0x82000 thru 0x8bfff
6215123(211 mod 256): CLONE 0x67000 thru 0x6cfff	(0x6000 bytes) to 0x50000 thru 0x55fff
6215124(212 mod 256): DEDUPE 0xd000 thru 0x23fff	(0x17000 bytes) to 0x4d000 thru 0x63fff
6215125(213 mod 256): MAPREAD  0x43523 thru 0x60345	(0x1ce23 bytes)
6215126(214 mod 256): CLONE 0x37000 thru 0x46fff	(0x10000 bytes) to 0x5d000 thru 0x6cfff
6215127(215 mod 256): DEDUPE 0x56000 thru 0x5bfff	(0x6000 bytes) to 0x66000 thru 0x6bfff
6215128(216 mod 256): TRUNCATE DOWN	from 0x8c000 to 0x310fa	******WWWW
6215129(217 mod 256): COPY 0x1cc27 thru 0x1f5a1	(0x297b bytes) to 0x55dcb thru 0x58745
6215130(218 mod 256): MAPREAD  0x2fb8d thru 0x37db0	(0x8224 bytes)
6215131(219 mod 256): COPY 0x2f4a3 thru 0x428ca	(0x13428 bytes) to 0x55553 thru 0x6897a
6215132(220 mod 256): MAPWRITE 0x13284 thru 0x18df1	(0x5b6e bytes)
6215133(221 mod 256): PUNCH    0x49c6d thru 0x644cb	(0x1a85f bytes)
6215134(222 mod 256): TRUNCATE DOWN	from 0x6897b to 0x48082
6215135(223 mod 256): MAPREAD  0x3814e thru 0x3930a	(0x11bd bytes)
6215136(224 mod 256): MAPREAD  0xe716 thru 0x1bce5	(0xd5d0 bytes)
6215137(225 mod 256): ZERO     0x775ee thru 0x7cf27	(0x593a bytes)
6215138(226 mod 256): TRUNCATE DOWN	from 0x48082 to 0x45e92
6215139(227 mod 256): MAPWRITE 0xe409 thru 0x12562	(0x415a bytes)
6215140(228 mod 256): PUNCH    0xe22c thru 0x2a7be	(0x1c593 bytes)
6215141(229 mod 256): READ     0x3bde3 thru 0x45e91	(0xa0af bytes)
6215142(230 mod 256): TRUNCATE UP	from 0x45e92 to 0x80eb6	******WWWW
6215143(231 mod 256): CLONE 0x44000 thru 0x4bfff	(0x8000 bytes) to 0x19000 thru 0x20fff
6215144(232 mod 256): SKIPPED (no operation)
6215145(233 mod 256): INSERT 0x79000 thru 0x86fff	(0xe000 bytes)
6215146(234 mod 256): WRITE    0x73f35 thru 0x8a11e	(0x161ea bytes)
6215147(235 mod 256): COPY 0x7d531 thru 0x8bcbe	(0xe78e bytes) to 0x55721 thru 0x63eae
6215148(236 mod 256): INSERT 0x59000 thru 0x5bfff	(0x3000 bytes)
6215149(237 mod 256): SKIPPED (no operation)
6215150(238 mod 256): COLLAPSE 0x87000 thru 0x88fff	(0x2000 bytes)
6215151(239 mod 256): TRUNCATE DOWN	from 0x8feb6 to 0x44117	******WWWW
6215152(240 mod 256): MAPWRITE 0x54cb7 thru 0x5deaf	(0x91f9 bytes)
6215153(241 mod 256): PUNCH    0x13230 thru 0x315f0	(0x1e3c1 bytes)
6215154(242 mod 256): TRUNCATE DOWN	from 0x5deb0 to 0x3bc
6215155(243 mod 256): ZERO     0x52920 thru 0x6c055	(0x19736 bytes)
6215156(244 mod 256): WRITE    0x6c3a1 thru 0x7f38d	(0x12fed bytes) HOLE	***WWWW
6215157(245 mod 256): TRUNCATE DOWN	from 0x7f38e to 0x16e50	******WWWW
6215158(246 mod 256): FALLOC   0x333e3 thru 0x4bc01	(0x1881e bytes) PAST_EOF
6215159(247 mod 256): INSERT 0x14000 thru 0x2ffff	(0x1c000 bytes)
6215160(248 mod 256): READ     0x1e094 thru 0x213d2	(0x333f bytes)
6215161(249 mod 256): PUNCH    0x1eceb thru 0x1fcfa	(0x1010 bytes)
6215162(250 mod 256): MAPWRITE 0x90e7c thru 0x9250d	(0x1692 bytes)
6215163(251 mod 256): SKIPPED (no operation)
6215164(252 mod 256): READ     0x7735 thru 0x8150	(0xa1c bytes)
6215165(253 mod 256): SKIPPED (no operation)
6215166(254 mod 256): FALLOC   0x305f7 thru 0x4823b	(0x17c44 bytes) INTERIOR
6215167(255 mod 256): PUNCH    0x22fe5 thru 0x41ea7	(0x1eec3 bytes)
6215168(  0 mod 256): SKIPPED (no operation)
6215169(  1 mod 256): ZERO     0x1f7b thru 0x20c84	(0x1ed0a bytes)
6215170(  2 mod 256): READ     0x68b24 thru 0x7ffba	(0x17497 bytes)	***RRRR***
6215171(  3 mod 256): COLLAPSE 0x5f000 thru 0x6dfff	(0xf000 bytes)
6215172(  4 mod 256): FALLOC   0xe929 thru 0x1129a	(0x2971 bytes) INTERIOR
6215173(  5 mod 256): TRUNCATE DOWN	from 0x8350e to 0x4f820	******WWWW
6215174(  6 mod 256): COPY 0x37277 thru 0x3a8d7	(0x3661 bytes) to 0xaa3a thru 0xe09a
6215175(  7 mod 256): MAPREAD  0x18ffa thru 0x2e65a	(0x15661 bytes)
6215176(  8 mod 256): DEDUPE 0x26000 thru 0x27fff	(0x2000 bytes) to 0x2000 thru 0x3fff
6215177(  9 mod 256): MAPWRITE 0x72a96 thru 0x7f558	(0xcac3 bytes)
6215178( 10 mod 256): PUNCH    0x17cc thru 0x194c6	(0x17cfb bytes)
6215179( 11 mod 256): TRUNCATE DOWN	from 0x7f559 to 0x2d3b9	******WWWW
6215180( 12 mod 256): FALLOC   0x21349 thru 0x256d2	(0x4389 bytes) INTERIOR
6215181( 13 mod 256): SKIPPED (no operation)
6215182( 14 mod 256): TRUNCATE UP	from 0x2d3b9 to 0x4c466
6215183( 15 mod 256): INSERT 0x3e000 thru 0x40fff	(0x3000 bytes)
6215184( 16 mod 256): FALLOC   0x57093 thru 0x67303	(0x10270 bytes) EXTENDING
6215185( 17 mod 256): CLONE 0x39000 thru 0x4afff	(0x12000 bytes) to 0xf000 thru 0x20fff
6215186( 18 mod 256): MAPREAD  0x55595 thru 0x67302	(0x11d6e bytes)
6215187( 19 mod 256): WRITE    0x66eec thru 0x6c86c	(0x5981 bytes) EXTEND
6215188( 20 mod 256): COPY 0x4d301 thru 0x663b2	(0x190b2 bytes) to 0xcf5d thru 0x2600e
6215189( 21 mod 256): COPY 0x1b952 thru 0x284bf	(0xcb6e bytes) to 0x51122 thru 0x5dc8f
6215190( 22 mod 256): DEDUPE 0x1a000 thru 0x1cfff	(0x3000 bytes) to 0x10000 thru 0x12fff
6215191( 23 mod 256): FALLOC   0xf8b3 thru 0x282f0	(0x18a3d bytes) INTERIOR
6215192( 24 mod 256): ZERO     0x10313 thru 0x216f7	(0x113e5 bytes)
6215193( 25 mod 256): DEDUPE 0x4e000 thru 0x4efff	(0x1000 bytes) to 0x25000 thru 0x25fff
6215194( 26 mod 256): MAPREAD  0x24389 thru 0x2c119	(0x7d91 bytes)
6215195( 27 mod 256): CLONE 0x13000 thru 0x26fff	(0x14000 bytes) to 0x27000 thru 0x3afff
6215196( 28 mod 256): FALLOC   0x9047a thru 0x927c0	(0x2346 bytes) EXTENDING
6215197( 29 mod 256): WRITE    0x6d5e3 thru 0x720c7	(0x4ae5 bytes)	***WWWW
6215198( 30 mod 256): MAPWRITE 0x7b760 thru 0x8f31f	(0x13bc0 bytes)
6215199( 31 mod 256): MAPREAD  0x4dc30 thru 0x61bd3	(0x13fa4 bytes)
6215200( 32 mod 256): ZERO     0x11c99 thru 0x14d9b	(0x3103 bytes)
6215201( 33 mod 256): MAPREAD  0x6910f thru 0x7ab16	(0x11a08 bytes)	***RRRR***
6215202( 34 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8eda9
6215203( 35 mod 256): MAPWRITE 0x3ce7f thru 0x449d2	(0x7b54 bytes)
6215204( 36 mod 256): DEDUPE 0x7000 thru 0x12fff	(0xc000 bytes) to 0x3f000 thru 0x4afff
6215205( 37 mod 256): COPY 0x2785d thru 0x44b3e	(0x1d2e2 bytes) to 0x6650f thru 0x837f0	******EEEE
6215206( 38 mod 256): READ     0x1583e thru 0x1d1fa	(0x79bd bytes)
6215207( 39 mod 256): FALLOC   0x626 thru 0x1013b	(0xfb15 bytes) INTERIOR
6215208( 40 mod 256): DEDUPE 0x57000 thru 0x5ffff	(0x9000 bytes) to 0x1c000 thru 0x24fff
6215209( 41 mod 256): FALLOC   0x4b701 thru 0x60c8f	(0x1558e bytes) INTERIOR
6215210( 42 mod 256): WRITE    0x67090 thru 0x7f950	(0x188c1 bytes)	***WWWW
6215211( 43 mod 256): FALLOC   0x7ce41 thru 0x8fd5a	(0x12f19 bytes) PAST_EOF
6215212( 44 mod 256): DEDUPE 0x7000 thru 0xcfff	(0x6000 bytes) to 0x26000 thru 0x2bfff
6215213( 45 mod 256): MAPWRITE 0x33ee2 thru 0x4e8b0	(0x1a9cf bytes)
6215214( 46 mod 256): SKIPPED (no operation)
6215215( 47 mod 256): COLLAPSE 0x69000 thru 0x84fff	(0x1c000 bytes)	******CCCC
6215216( 48 mod 256): COLLAPSE 0x4c000 thru 0x60fff	(0x15000 bytes)
6215217( 49 mod 256): MAPWRITE 0x9110d thru 0x927bf	(0x16b3 bytes)
6215218( 50 mod 256): WRITE    0xc137 thru 0x12c8d	(0x6b57 bytes)
6215219( 51 mod 256): CLONE 0x8f000 thru 0x91fff	(0x3000 bytes) to 0x5d000 thru 0x5ffff
6215220( 52 mod 256): MAPREAD  0x3c5a1 thru 0x44107	(0x7b67 bytes)
6215221( 53 mod 256): SKIPPED (no operation)
6215222( 54 mod 256): COLLAPSE 0x50000 thru 0x5bfff	(0xc000 bytes)
6215223( 55 mod 256): INSERT 0x6d000 thru 0x76fff	(0xa000 bytes)	******IIII
6215224( 56 mod 256): TRUNCATE DOWN	from 0x907c0 to 0x76a5a
6215225( 57 mod 256): ZERO     0x334fc thru 0x3b54f	(0x8054 bytes)
6215226( 58 mod 256): MAPREAD  0x55b74 thru 0x563d7	(0x864 bytes)
6215227( 59 mod 256): DEDUPE 0x69000 thru 0x75fff	(0xd000 bytes) to 0x17000 thru 0x23fff	BBBB******
6215228( 60 mod 256): PUNCH    0x29547 thru 0x3bfb6	(0x12a70 bytes)
6215229( 61 mod 256): SKIPPED (no operation)
6215230( 62 mod 256): READ     0x65143 thru 0x6bea4	(0x6d62 bytes)
6215231( 63 mod 256): INSERT 0x4a000 thru 0x4bfff	(0x2000 bytes)
6215232( 64 mod 256): COLLAPSE 0x60000 thru 0x76fff	(0x17000 bytes)	******CCCC
6215233( 65 mod 256): WRITE    0x15c7 thru 0xef29	(0xd963 bytes)
6215234( 66 mod 256): MAPWRITE 0x85221 thru 0x927bf	(0xd59f bytes)
6215235( 67 mod 256): SKIPPED (no operation)
6215236( 68 mod 256): SKIPPED (no operation)
6215237( 69 mod 256): SKIPPED (no operation)
6215238( 70 mod 256): SKIPPED (no operation)
6215239( 71 mod 256): ZERO     0x49e7d thru 0x5cb9e	(0x12d22 bytes)
6215240( 72 mod 256): SKIPPED (no operation)
6215241( 73 mod 256): ZERO     0x56495 thru 0x5c8f8	(0x6464 bytes)
6215242( 74 mod 256): SKIPPED (no operation)
6215243( 75 mod 256): WRITE    0x8916 thru 0x1d05b	(0x14746 bytes)
6215244( 76 mod 256): SKIPPED (no operation)
6215245( 77 mod 256): PUNCH    0xc691 thru 0x18779	(0xc0e9 bytes)
6215246( 78 mod 256): FALLOC   0x15284 thru 0x3031e	(0x1b09a bytes) INTERIOR
6215247( 79 mod 256): CLONE 0x74000 thru 0x90fff	(0x1d000 bytes) to 0x3a000 thru 0x56fff
6215248( 80 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x87485
6215249( 81 mod 256): COLLAPSE 0x66000 thru 0x74fff	(0xf000 bytes)	******CCCC
6215250( 82 mod 256): SKIPPED (no operation)
6215251( 83 mod 256): FALLOC   0x5f6c3 thru 0x68174	(0x8ab1 bytes) INTERIOR
6215252( 84 mod 256): PUNCH    0x1111b thru 0x13226	(0x210c bytes)
6215253( 85 mod 256): SKIPPED (no operation)
6215254( 86 mod 256): INSERT 0x37000 thru 0x3efff	(0x8000 bytes)
6215255( 87 mod 256): CLONE 0x41000 thru 0x54fff	(0x14000 bytes) to 0x29000 thru 0x3cfff
6215256( 88 mod 256): COPY 0x37df thru 0x118c6	(0xe0e8 bytes) to 0x49cb1 thru 0x57d98
6215257( 89 mod 256): DEDUPE 0x3c000 thru 0x40fff	(0x5000 bytes) to 0x11000 thru 0x15fff
6215258( 90 mod 256): FALLOC   0x44a54 thru 0x4e8b0	(0x9e5c bytes) INTERIOR
6215259( 91 mod 256): CLONE 0x31000 thru 0x42fff	(0x12000 bytes) to 0x68000 thru 0x79fff	******JJJJ
6215260( 92 mod 256): CLONE 0x3a000 thru 0x3afff	(0x1000 bytes) to 0x56000 thru 0x56fff
6215261( 93 mod 256): FALLOC   0xb2ae thru 0x10ea3	(0x5bf5 bytes) INTERIOR
6215262( 94 mod 256): MAPWRITE 0x1447c thru 0x157fa	(0x137f bytes)
6215263( 95 mod 256): READ     0x51eba thru 0x6a18b	(0x182d2 bytes)
6215264( 96 mod 256): TRUNCATE UP	from 0x80485 to 0x8ec18
6215265( 97 mod 256): WRITE    0x1cbc7 thru 0x2801f	(0xb459 bytes)
6215266( 98 mod 256): COPY 0x6b80b thru 0x85074	(0x1986a bytes) to 0x33f85 thru 0x4d7ee	EEEE******
6215267( 99 mod 256): DEDUPE 0xe000 thru 0x1afff	(0xd000 bytes) to 0x76000 thru 0x82fff
6215268(100 mod 256): INSERT 0x2b000 thru 0x2dfff	(0x3000 bytes)
6215269(101 mod 256): WRITE    0x72a72 thru 0x86bf3	(0x14182 bytes)
6215270(102 mod 256): SKIPPED (no operation)
6215271(103 mod 256): ZERO     0x8dd5e thru 0x903f0	(0x2693 bytes)
6215272(104 mod 256): SKIPPED (no operation)
6215273(105 mod 256): SKIPPED (no operation)
6215274(106 mod 256): MAPWRITE 0x21e58 thru 0x34503	(0x126ac bytes)
6215275(107 mod 256): TRUNCATE DOWN	from 0x91c18 to 0x76469
6215276(108 mod 256): SKIPPED (no operation)
6215277(109 mod 256): COLLAPSE 0x4c000 thru 0x56fff	(0xb000 bytes)
6215278(110 mod 256): CLONE 0x3b000 thru 0x47fff	(0xd000 bytes) to 0x4d000 thru 0x59fff
6215279(111 mod 256): FALLOC   0x79139 thru 0x7c838	(0x36ff bytes) PAST_EOF
6215280(112 mod 256): SKIPPED (no operation)
6215281(113 mod 256): WRITE    0x2f39c thru 0x44bec	(0x15851 bytes)
6215282(114 mod 256): TRUNCATE UP	from 0x6b469 to 0x866f6	******WWWW
6215283(115 mod 256): MAPWRITE 0x3198b thru 0x35c6d	(0x42e3 bytes)
6215284(116 mod 256): MAPWRITE 0x5c4be thru 0x6d0b8	(0x10bfb bytes)
6215285(117 mod 256): COLLAPSE 0x2000 thru 0x10fff	(0xf000 bytes)
6215286(118 mod 256): PUNCH    0x62fa6 thru 0x776f5	(0x14750 bytes)	******PPPP
6215287(119 mod 256): CLONE 0x71000 thru 0x71fff	(0x1000 bytes) to 0x20000 thru 0x20fff
6215288(120 mod 256): WRITE    0x2b522 thru 0x34fbb	(0x9a9a bytes)
6215289(121 mod 256): ZERO     0x7060a thru 0x8eb55	(0x1e54c bytes)
6215290(122 mod 256): PUNCH    0x5e8e5 thru 0x70dcb	(0x124e7 bytes)	******PPPP
6215291(123 mod 256): MAPWRITE 0x3d8eb thru 0x55c31	(0x18347 bytes)
6215292(124 mod 256): ZERO     0x43516 thru 0x46f40	(0x3a2b bytes)
6215293(125 mod 256): ZERO     0x7fde7 thru 0x852e8	(0x5502 bytes)
6215294(126 mod 256): PUNCH    0x21d3e thru 0x2a314	(0x85d7 bytes)
6215295(127 mod 256): DEDUPE 0x64000 thru 0x76fff	(0x13000 bytes) to 0x0 thru 0x12fff	BBBB******
6215296(128 mod 256): READ     0x57f4e thru 0x5d7a7	(0x585a bytes)
6215297(129 mod 256): TRUNCATE DOWN	from 0x776f6 to 0x6635d	******WWWW
6215298(130 mod 256): WRITE    0x62650 thru 0x7f07f	(0x1ca30 bytes) EXTEND	***WWWW
6215299(131 mod 256): COLLAPSE 0x13000 thru 0x1ffff	(0xd000 bytes)
6215300(132 mod 256): SKIPPED (no operation)
6215301(133 mod 256): MAPWRITE 0x79023 thru 0x8f4df	(0x164bd bytes)
6215302(134 mod 256): INSERT 0x33000 thru 0x35fff	(0x3000 bytes)
6215303(135 mod 256): SKIPPED (no operation)
6215304(136 mod 256): COLLAPSE 0x28000 thru 0x32fff	(0xb000 bytes)
6215305(137 mod 256): READ     0x3e6a5 thru 0x46576	(0x7ed2 bytes)
6215306(138 mod 256): MAPWRITE 0x37d51 thru 0x3a164	(0x2414 bytes)
6215307(139 mod 256): ZERO     0x150c0 thru 0x22923	(0xd864 bytes)
6215308(140 mod 256): DEDUPE 0x5000 thru 0x14fff	(0x10000 bytes) to 0x33000 thru 0x42fff
6215309(141 mod 256): INSERT 0x84000 thru 0x8efff	(0xb000 bytes)
6215310(142 mod 256): READ     0x4cae0 thru 0x50ecd	(0x43ee bytes)
6215311(143 mod 256): PUNCH    0x278d5 thru 0x2be1f	(0x454b bytes)
6215312(144 mod 256): CLONE 0xf000 thru 0x12fff	(0x4000 bytes) to 0x1d000 thru 0x20fff
6215313(145 mod 256): COLLAPSE 0x17000 thru 0x17fff	(0x1000 bytes)
6215314(146 mod 256): COPY 0x69d36 thru 0x7094d	(0x6c18 bytes) to 0x5f7e thru 0xcb95	EEEE******
6215315(147 mod 256): PUNCH    0x6f474 thru 0x80fc5	(0x11b52 bytes)
6215316(148 mod 256): READ     0x20ebf thru 0x2dcf2	(0xce34 bytes)
6215317(149 mod 256): COLLAPSE 0x75000 thru 0x87fff	(0x13000 bytes)
6215318(150 mod 256): COLLAPSE 0x41000 thru 0x55fff	(0x15000 bytes)
6215319(151 mod 256): DEDUPE 0xb000 thru 0x1ffff	(0x15000 bytes) to 0x49000 thru 0x5dfff
6215320(152 mod 256): SKIPPED (no operation)
6215321(153 mod 256): PUNCH    0x3eba0 thru 0x4d68e	(0xeaef bytes)
6215322(154 mod 256): WRITE    0x82db8 thru 0x927bf	(0xfa08 bytes) HOLE	***WWWW
6215323(155 mod 256): WRITE    0x1dc25 thru 0x29e16	(0xc1f2 bytes)
6215324(156 mod 256): PUNCH    0x3154c thru 0x3cda6	(0xb85b bytes)
6215325(157 mod 256): READ     0x8a025 thru 0x927bf	(0x879b bytes)
6215326(158 mod 256): COLLAPSE 0x19000 thru 0x34fff	(0x1c000 bytes)
6215327(159 mod 256): ZERO     0x3ac5d thru 0x47868	(0xcc0c bytes)
6215328(160 mod 256): COPY 0x58c1 thru 0x17461	(0x11ba1 bytes) to 0x40bf9 thru 0x52799
6215329(161 mod 256): CLONE 0x29000 thru 0x30fff	(0x8000 bytes) to 0x60000 thru 0x67fff
6215330(162 mod 256): TRUNCATE DOWN	from 0x767c0 to 0x5f312	******WWWW
6215331(163 mod 256): FALLOC   0xe97e thru 0x212f7	(0x12979 bytes) INTERIOR
6215332(164 mod 256): READ     0x5e1e4 thru 0x5f311	(0x112e bytes)
6215333(165 mod 256): INSERT 0x4a000 thru 0x60fff	(0x17000 bytes)
6215334(166 mod 256): COPY 0x35536 thru 0x47e9d	(0x12968 bytes) to 0x14bdd thru 0x27544
6215335(167 mod 256): DEDUPE 0x55000 thru 0x55fff	(0x1000 bytes) to 0x13000 thru 0x13fff
6215336(168 mod 256): COLLAPSE 0x50000 thru 0x54fff	(0x5000 bytes)
6215337(169 mod 256): INSERT 0x13000 thru 0x17fff	(0x5000 bytes)
6215338(170 mod 256): PUNCH    0x276e6 thru 0x46913	(0x1f22e bytes)
6215339(171 mod 256): READ     0x55d3b thru 0x5c0a9	(0x636f bytes)
6215340(172 mod 256): MAPWRITE 0x20233 thru 0x2dceb	(0xdab9 bytes)
6215341(173 mod 256): DEDUPE 0x4f000 thru 0x61fff	(0x13000 bytes) to 0x21000 thru 0x33fff
6215342(174 mod 256): PUNCH    0x255af thru 0x32fbc	(0xda0e bytes)
6215343(175 mod 256): DEDUPE 0x26000 thru 0x39fff	(0x14000 bytes) to 0x3e000 thru 0x51fff
6215344(176 mod 256): MAPREAD  0x11310 thru 0x12c92	(0x1983 bytes)
6215345(177 mod 256): READ     0x5c95 thru 0x16b5b	(0x10ec7 bytes)
6215346(178 mod 256): READ     0x74ab8 thru 0x76311	(0x185a bytes)
6215347(179 mod 256): MAPWRITE 0x6c3a thru 0x11cf9	(0xb0c0 bytes)
6215348(180 mod 256): INSERT 0x32000 thru 0x42fff	(0x11000 bytes)
6215349(181 mod 256): ZERO     0x38f4 thru 0x12225	(0xe932 bytes)
6215350(182 mod 256): MAPREAD  0x696ac thru 0x820cd	(0x18a22 bytes)	***RRRR***
6215351(183 mod 256): ZERO     0x21049 thru 0x3780d	(0x167c5 bytes)
6215352(184 mod 256): MAPWRITE 0x25c23 thru 0x261cc	(0x5aa bytes)
6215353(185 mod 256): READ     0x420fd thru 0x4f3fa	(0xd2fe bytes)
6215354(186 mod 256): TRUNCATE DOWN	from 0x87312 to 0x6d07a	******WWWW
6215355(187 mod 256): PUNCH    0x1c781 thru 0x28d92	(0xc612 bytes)
6215356(188 mod 256): TRUNCATE UP	from 0x6d07a to 0x86f94	******WWWW
6215357(189 mod 256): MAPWRITE 0x88211 thru 0x924bc	(0xa2ac bytes)
6215358(190 mod 256): WRITE    0x1e1f6 thru 0x32591	(0x1439c bytes)
6215359(191 mod 256): MAPWRITE 0x58249 thru 0x72bd2	(0x1a98a bytes)	******WWWW
6215360(192 mod 256): ZERO     0x20567 thru 0x3da67	(0x1d501 bytes)
6215361(193 mod 256): READ     0x13182 thru 0x16baa	(0x3a29 bytes)
6215362(194 mod 256): MAPREAD  0x7b11f thru 0x924bc	(0x1739e bytes)
6215363(195 mod 256): DEDUPE 0x1e000 thru 0x34fff	(0x17000 bytes) to 0x4000 thru 0x1afff
6215364(196 mod 256): COPY 0x2b913 thru 0x3b8a5	(0xff93 bytes) to 0x66e04 thru 0x76d96	******EEEE
6215365(197 mod 256): MAPREAD  0x4a901 thru 0x4fb71	(0x5271 bytes)
6215366(198 mod 256): FALLOC   0x359c3 thru 0x4796d	(0x11faa bytes) INTERIOR
6215367(199 mod 256): CLONE 0x85000 thru 0x90fff	(0xc000 bytes) to 0x62000 thru 0x6dfff
6215368(200 mod 256): FALLOC   0x89e87 thru 0x927c0	(0x8939 bytes) EXTENDING
6215369(201 mod 256): DEDUPE 0x79000 thru 0x89fff	(0x11000 bytes) to 0x5b000 thru 0x6bfff
6215370(202 mod 256): DEDUPE 0x62000 thru 0x76fff	(0x15000 bytes) to 0x3a000 thru 0x4efff	BBBB******
6215371(203 mod 256): READ     0x6ebe2 thru 0x76202	(0x7621 bytes)	***RRRR***
6215372(204 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5500a	******WWWW
6215373(205 mod 256): SKIPPED (no operation)
6215374(206 mod 256): MAPWRITE 0x754ed thru 0x8b3e6	(0x15efa bytes)
6215375(207 mod 256): TRUNCATE DOWN	from 0x8b3e7 to 0x3c550	******WWWW
6215376(208 mod 256): COLLAPSE 0x27000 thru 0x39fff	(0x13000 bytes)
6215377(209 mod 256): CLONE 0x1b000 thru 0x27fff	(0xd000 bytes) to 0x3d000 thru 0x49fff
6215378(210 mod 256): CLONE 0x16000 thru 0x26fff	(0x11000 bytes) to 0x4a000 thru 0x5afff
6215379(211 mod 256): PUNCH    0x4af08 thru 0x5afff	(0x100f8 bytes)
6215380(212 mod 256): ZERO     0x5405a thru 0x6ca97	(0x18a3e bytes)
6215381(213 mod 256): WRITE    0x3e635 thru 0x5ca10	(0x1e3dc bytes)
6215382(214 mod 256): FALLOC   0x79939 thru 0x927c0	(0x18e87 bytes) PAST_EOF
6215383(215 mod 256): WRITE    0x3b7b2 thru 0x43020	(0x786f bytes)
6215384(216 mod 256): COPY 0x5920a thru 0x60639	(0x7430 bytes) to 0x3d535 thru 0x44964
6215385(217 mod 256): SKIPPED (no operation)
6215386(218 mod 256): MAPREAD  0x1e5f2 thru 0x20a02	(0x2411 bytes)
6215387(219 mod 256): DEDUPE 0x11000 thru 0x17fff	(0x7000 bytes) to 0x1c000 thru 0x22fff
6215388(220 mod 256): MAPWRITE 0x5f2a1 thru 0x770b2	(0x17e12 bytes)	******WWWW
6215389(221 mod 256): CLONE 0xc000 thru 0x13fff	(0x8000 bytes) to 0x7f000 thru 0x86fff
6215390(222 mod 256): SKIPPED (no operation)
6215391(223 mod 256): READ     0x39ddc thru 0x4181a	(0x7a3f bytes)
6215392(224 mod 256): MAPREAD  0x2f919 thru 0x43e13	(0x144fb bytes)
6215393(225 mod 256): COPY 0x1d5ad thru 0x32a5e	(0x154b2 bytes) to 0x648d0 thru 0x79d81	******EEEE
6215394(226 mod 256): WRITE    0x7001 thru 0x131fa	(0xc1fa bytes)
6215395(227 mod 256): PUNCH    0x69ba2 thru 0x79d61	(0x101c0 bytes)	******PPPP
6215396(228 mod 256): SKIPPED (no operation)
6215397(229 mod 256): MAPWRITE 0x20c44 thru 0x370ab	(0x16468 bytes)
6215398(230 mod 256): READ     0x739e1 thru 0x86fff	(0x1361f bytes)
6215399(231 mod 256): SKIPPED (no operation)
6215400(232 mod 256): ZERO     0x2167d thru 0x3e8a5	(0x1d229 bytes)
6215401(233 mod 256): MAPWRITE 0xdff0 thru 0x1c7d0	(0xe7e1 bytes)
6215402(234 mod 256): MAPWRITE 0x6bf96 thru 0x7d647	(0x116b2 bytes)	******WWWW
6215403(235 mod 256): INSERT 0x6d000 thru 0x77fff	(0xb000 bytes)	******IIII
6215404(236 mod 256): MAPWRITE 0x3fde5 thru 0x41b91	(0x1dad bytes)
6215405(237 mod 256): READ     0x204e9 thru 0x209aa	(0x4c2 bytes)
6215406(238 mod 256): COLLAPSE 0x57000 thru 0x5ffff	(0x9000 bytes)
6215407(239 mod 256): MAPREAD  0x6377d thru 0x713a2	(0xdc26 bytes)	***RRRR***
6215408(240 mod 256): COPY 0x108d4 thru 0x23b92	(0x132bf bytes) to 0x4d16e thru 0x6042c
6215409(241 mod 256): PUNCH    0x4bc5d thru 0x5fc0b	(0x13faf bytes)
6215410(242 mod 256): COPY 0x4652f thru 0x53704	(0xd1d6 bytes) to 0x2be8 thru 0xfdbd
6215411(243 mod 256): INSERT 0x2f000 thru 0x37fff	(0x9000 bytes)
6215412(244 mod 256): ZERO     0x4f099 thru 0x6ca01	(0x1d969 bytes)
6215413(245 mod 256): READ     0x53d44 thru 0x55e6e	(0x212b bytes)
6215414(246 mod 256): DEDUPE 0x80000 thru 0x90fff	(0x11000 bytes) to 0x2000 thru 0x12fff
6215415(247 mod 256): SKIPPED (no operation)
6215416(248 mod 256): TRUNCATE DOWN	from 0x92000 to 0x10230	******WWWW
6215417(249 mod 256): PUNCH    0xeec0 thru 0x1022f	(0x1370 bytes)
6215418(250 mod 256): ZERO     0x438eb thru 0x57424	(0x13b3a bytes)
6215419(251 mod 256): FALLOC   0xd2b6 thru 0x1d4cc	(0x10216 bytes) INTERIOR
6215420(252 mod 256): READ     0x1836a thru 0x2e062	(0x15cf9 bytes)
6215421(253 mod 256): READ     0x28e90 thru 0x2b881	(0x29f2 bytes)
6215422(254 mod 256): PUNCH    0x1a186 thru 0x1f936	(0x57b1 bytes)
6215423(255 mod 256): WRITE    0x89b37 thru 0x927bf	(0x8c89 bytes) HOLE	***WWWW
6215424(  0 mod 256): FALLOC   0x2120b thru 0x389b5	(0x177aa bytes) INTERIOR
6215425(  1 mod 256): PUNCH    0x6c5bd thru 0x77aa5	(0xb4e9 bytes)	******PPPP
6215426(  2 mod 256): MAPWRITE 0x14b90 thru 0x240cc	(0xf53d bytes)
6215427(  3 mod 256): SKIPPED (no operation)
6215428(  4 mod 256): DEDUPE 0x79000 thru 0x8cfff	(0x14000 bytes) to 0x5000 thru 0x18fff
6215429(  5 mod 256): COPY 0x59952 thru 0x756d0	(0x1bd7f bytes) to 0x31e5b thru 0x4dbd9	EEEE******
6215430(  6 mod 256): CLONE 0x78000 thru 0x84fff	(0xd000 bytes) to 0xb000 thru 0x17fff
6215431(  7 mod 256): MAPWRITE 0xbea3 thru 0x24c14	(0x18d72 bytes)
6215432(  8 mod 256): COLLAPSE 0x25000 thru 0x2efff	(0xa000 bytes)
6215433(  9 mod 256): SKIPPED (no operation)
6215434( 10 mod 256): ZERO     0x5894e thru 0x5aea7	(0x255a bytes)
6215435( 11 mod 256): FALLOC   0x4ab01 thru 0x52119	(0x7618 bytes) INTERIOR
6215436( 12 mod 256): WRITE    0x5115d thru 0x5c910	(0xb7b4 bytes)
6215437( 13 mod 256): DEDUPE 0x71000 thru 0x79fff	(0x9000 bytes) to 0x67000 thru 0x6ffff	******BBBB
6215438( 14 mod 256): COPY 0xde59 thru 0x1f4bb	(0x11663 bytes) to 0x48664 thru 0x59cc6
6215439( 15 mod 256): READ     0x14b8b thru 0x1cc0e	(0x8084 bytes)
6215440( 16 mod 256): ZERO     0xf606 thru 0x23b79	(0x14574 bytes)
6215441( 17 mod 256): CLONE 0x3a000 thru 0x48fff	(0xf000 bytes) to 0x27000 thru 0x35fff
6215442( 18 mod 256): MAPWRITE 0x27053 thru 0x36343	(0xf2f1 bytes)
6215443( 19 mod 256): FALLOC   0xd486 thru 0x2a26f	(0x1cde9 bytes) INTERIOR
6215444( 20 mod 256): TRUNCATE DOWN	from 0x887c0 to 0x51a25	******WWWW
6215445( 21 mod 256): COPY 0x38c43 thru 0x51a24	(0x18de2 bytes) to 0x73cf2 thru 0x8cad3
6215446( 22 mod 256): COLLAPSE 0x4b000 thru 0x55fff	(0xb000 bytes)
6215447( 23 mod 256): COPY 0x28da2 thru 0x36573	(0xd7d2 bytes) to 0x1dc2 thru 0xf593
6215448( 24 mod 256): MAPWRITE 0x726b0 thru 0x8ce6d	(0x1a7be bytes)
6215449( 25 mod 256): COPY 0x1615c thru 0x29d6a	(0x13c0f bytes) to 0x627d0 thru 0x763de	******EEEE
6215450( 26 mod 256): READ     0x5c5d0 thru 0x72254	(0x15c85 bytes)	***RRRR***
6215451( 27 mod 256): PUNCH    0x809c4 thru 0x8ce6d	(0xc4aa bytes)
6215452( 28 mod 256): ZERO     0x560e7 thru 0x5ab37	(0x4a51 bytes)
6215453( 29 mod 256): COPY 0x30a1 thru 0x10793	(0xd6f3 bytes) to 0x57370 thru 0x64a62
6215454( 30 mod 256): INSERT 0x7c000 thru 0x80fff	(0x5000 bytes)
6215455( 31 mod 256): ZERO     0x2ca6 thru 0x197a1	(0x16afc bytes)
6215456( 32 mod 256): MAPWRITE 0x547d5 thru 0x6258e	(0xddba bytes)
6215457( 33 mod 256): WRITE    0x1e444 thru 0x2c41c	(0xdfd9 bytes)
6215458( 34 mod 256): CLONE 0x39000 thru 0x49fff	(0x11000 bytes) to 0x6c000 thru 0x7cfff	******JJJJ
6215459( 35 mod 256): COLLAPSE 0x16000 thru 0x2afff	(0x15000 bytes)
6215460( 36 mod 256): TRUNCATE DOWN	from 0x7ce6e to 0x39998	******WWWW
6215461( 37 mod 256): PUNCH    0x9a2b thru 0x17630	(0xdc06 bytes)
6215462( 38 mod 256): TRUNCATE UP	from 0x39998 to 0x6a167
6215463( 39 mod 256): CLONE 0x50000 thru 0x58fff	(0x9000 bytes) to 0x29000 thru 0x31fff
6215464( 40 mod 256): MAPWRITE 0x6a5e8 thru 0x75235	(0xac4e bytes)	******WWWW
6215465( 41 mod 256): SKIPPED (no operation)
6215466( 42 mod 256): DEDUPE 0x1000 thru 0x11fff	(0x11000 bytes) to 0x63000 thru 0x73fff	******BBBB
6215467( 43 mod 256): PUNCH    0x194d thru 0x5a7e	(0x4132 bytes)
6215468( 44 mod 256): CLONE 0x5e000 thru 0x6dfff	(0x10000 bytes) to 0x7b000 thru 0x8afff
6215469( 45 mod 256): PUNCH    0x548f0 thru 0x674f7	(0x12c08 bytes)
6215470( 46 mod 256): DEDUPE 0x80000 thru 0x89fff	(0xa000 bytes) to 0x4000 thru 0xdfff
6215471( 47 mod 256): SKIPPED (no operation)
6215472( 48 mod 256): FALLOC   0x1f28a thru 0x2a5de	(0xb354 bytes) INTERIOR
6215473( 49 mod 256): COLLAPSE 0x15000 thru 0x30fff	(0x1c000 bytes)
6215474( 50 mod 256): MAPWRITE 0x726ea thru 0x80777	(0xe08e bytes)
6215475( 51 mod 256): READ     0xe0fc thru 0x143eb	(0x62f0 bytes)
6215476( 52 mod 256): SKIPPED (no operation)
6215477( 53 mod 256): PUNCH    0x5186d thru 0x5d1a5	(0xb939 bytes)
6215478( 54 mod 256): TRUNCATE DOWN	from 0x80778 to 0x3c914	******WWWW
6215479( 55 mod 256): COLLAPSE 0x2d000 thru 0x3bfff	(0xf000 bytes)
6215480( 56 mod 256): COLLAPSE 0x1a000 thru 0x24fff	(0xb000 bytes)
6215481( 57 mod 256): MAPREAD  0x7431 thru 0x1a893	(0x13463 bytes)
6215482( 58 mod 256): PUNCH    0x1f5bb thru 0x22913	(0x3359 bytes)
6215483( 59 mod 256): CLONE 0x1f000 thru 0x21fff	(0x3000 bytes) to 0x8b000 thru 0x8dfff
6215484( 60 mod 256): PUNCH    0x1cc21 thru 0x1df93	(0x1373 bytes)
6215485( 61 mod 256): MAPWRITE 0x63e65 thru 0x6882e	(0x49ca bytes)
6215486( 62 mod 256): DEDUPE 0x2b000 thru 0x3ffff	(0x15000 bytes) to 0x1000 thru 0x15fff
6215487( 63 mod 256): COLLAPSE 0x1b000 thru 0x29fff	(0xf000 bytes)
6215488( 64 mod 256): MAPWRITE 0xe966 thru 0x249aa	(0x16045 bytes)
6215489( 65 mod 256): READ     0x17963 thru 0x35858	(0x1def6 bytes)
6215490( 66 mod 256): FALLOC   0x6f88e thru 0x857e1	(0x15f53 bytes) EXTENDING
6215491( 67 mod 256): CLONE 0x2e000 thru 0x36fff	(0x9000 bytes) to 0x57000 thru 0x5ffff
6215492( 68 mod 256): WRITE    0x226fa thru 0x3c28a	(0x19b91 bytes)
6215493( 69 mod 256): COPY 0x6fcb2 thru 0x7fa04	(0xfd53 bytes) to 0x357c9 thru 0x4551b
6215494( 70 mod 256): COPY 0x8eb9 thru 0x206fb	(0x17843 bytes) to 0x61a97 thru 0x792d9	******EEEE
6215495( 71 mod 256): TRUNCATE DOWN	from 0x857e1 to 0x1f479	******WWWW
6215496( 72 mod 256): MAPWRITE 0x2f3f2 thru 0x42e92	(0x13aa1 bytes)
6215497( 73 mod 256): COLLAPSE 0x29000 thru 0x3dfff	(0x15000 bytes)
6215498( 74 mod 256): SKIPPED (no operation)
6215499( 75 mod 256): FALLOC   0x56997 thru 0x5ace7	(0x4350 bytes) EXTENDING
6215500( 76 mod 256): COLLAPSE 0x25000 thru 0x2afff	(0x6000 bytes)
6215501( 77 mod 256): COLLAPSE 0x2f000 thru 0x49fff	(0x1b000 bytes)
6215502( 78 mod 256): MAPREAD  0x28736 thru 0x39ce6	(0x115b1 bytes)
6215503( 79 mod 256): READ     0x10268 thru 0x29b5e	(0x198f7 bytes)
6215504( 80 mod 256): FALLOC   0x3b55a thru 0x56778	(0x1b21e bytes) PAST_EOF
6215505( 81 mod 256): INSERT 0x2d000 thru 0x2dfff	(0x1000 bytes)
6215506( 82 mod 256): SKIPPED (no operation)
6215507( 83 mod 256): COLLAPSE 0xa000 thru 0x11fff	(0x8000 bytes)
6215508( 84 mod 256): MAPWRITE 0x87a88 thru 0x927bf	(0xad38 bytes)
6215509( 85 mod 256): COPY 0x7b6b2 thru 0x927bf	(0x1710e bytes) to 0x212df thru 0x383ec
6215510( 86 mod 256): COLLAPSE 0x4d000 thru 0x5ffff	(0x13000 bytes)
6215511( 87 mod 256): MAPWRITE 0x25256 thru 0x413d4	(0x1c17f bytes)
6215512( 88 mod 256): INSERT 0x11000 thru 0x13fff	(0x3000 bytes)
6215513( 89 mod 256): DEDUPE 0x3000 thru 0x1ffff	(0x1d000 bytes) to 0x23000 thru 0x3ffff
6215514( 90 mod 256): READ     0x349a3 thru 0x45e1e	(0x1147c bytes)
6215515( 91 mod 256): ZERO     0x350fd thru 0x3947a	(0x437e bytes)
6215516( 92 mod 256): DEDUPE 0x45000 thru 0x49fff	(0x5000 bytes) to 0x2f000 thru 0x33fff
6215517( 93 mod 256): MAPREAD  0x30bce thru 0x49298	(0x186cb bytes)
6215518( 94 mod 256): COLLAPSE 0x2d000 thru 0x2efff	(0x2000 bytes)
6215519( 95 mod 256): INSERT 0x7e000 thru 0x8ffff	(0x12000 bytes)
6215520( 96 mod 256): SKIPPED (no operation)
6215521( 97 mod 256): SKIPPED (no operation)
6215522( 98 mod 256): MAPREAD  0x16d4d thru 0x32ec0	(0x1c174 bytes)
6215523( 99 mod 256): FALLOC   0x44ab1 thru 0x503ad	(0xb8fc bytes) INTERIOR
6215524(100 mod 256): WRITE    0x7a355 thru 0x927bf	(0x1846b bytes)
6215525(101 mod 256): MAPWRITE 0x6d0e3 thru 0x74810	(0x772e bytes)	******WWWW
6215526(102 mod 256): CLONE 0x5f000 thru 0x63fff	(0x5000 bytes) to 0x81000 thru 0x85fff
6215527(103 mod 256): MAPREAD  0x6d615 thru 0x6df81	(0x96d bytes)
6215528(104 mod 256): CLONE 0x16000 thru 0x20fff	(0xb000 bytes) to 0x7000 thru 0x11fff
6215529(105 mod 256): DEDUPE 0x70000 thru 0x76fff	(0x7000 bytes) to 0x15000 thru 0x1bfff
6215530(106 mod 256): FALLOC   0x7bc6f thru 0x860d6	(0xa467 bytes) INTERIOR
6215531(107 mod 256): READ     0x9155a thru 0x927bf	(0x1266 bytes)
6215532(108 mod 256): SKIPPED (no operation)
6215533(109 mod 256): WRITE    0x18530 thru 0x2f697	(0x17168 bytes)
6215534(110 mod 256): COPY 0x6673b thru 0x7ec05	(0x184cb bytes) to 0x1e2b1 thru 0x3677b	EEEE******
6215535(111 mod 256): COPY 0x74b38 thru 0x7aff0	(0x64b9 bytes) to 0x55066 thru 0x5b51e
6215536(112 mod 256): SKIPPED (no operation)
6215537(113 mod 256): MAPWRITE 0x83b84 thru 0x8ef15	(0xb392 bytes)
6215538(114 mod 256): CLONE 0x18000 thru 0x20fff	(0x9000 bytes) to 0x81000 thru 0x89fff
6215539(115 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x60dff	******WWWW
6215540(116 mod 256): COLLAPSE 0x2000 thru 0xdfff	(0xc000 bytes)
6215541(117 mod 256): MAPWRITE 0x2654e thru 0x27a2a	(0x14dd bytes)
6215542(118 mod 256): CLONE 0x8000 thru 0xefff	(0x7000 bytes) to 0x80000 thru 0x86fff
6215543(119 mod 256): FALLOC   0x3e0e7 thru 0x54e9f	(0x16db8 bytes) INTERIOR
6215544(120 mod 256): PUNCH    0x773b4 thru 0x86fff	(0xfc4c bytes)
6215545(121 mod 256): FALLOC   0x468de thru 0x55a58	(0xf17a bytes) INTERIOR
6215546(122 mod 256): PUNCH    0x1e3fa thru 0x24dac	(0x69b3 bytes)
6215547(123 mod 256): COLLAPSE 0x31000 thru 0x40fff	(0x10000 bytes)
6215548(124 mod 256): PUNCH    0x6f1c9 thru 0x76fff	(0x7e37 bytes)
6215549(125 mod 256): SKIPPED (no operation)
6215550(126 mod 256): PUNCH    0x40b37 thru 0x43d08	(0x31d2 bytes)
6215551(127 mod 256): COLLAPSE 0xe000 thru 0x10fff	(0x3000 bytes)
6215552(128 mod 256): PUNCH    0x174e3 thru 0x33000	(0x1bb1e bytes)
6215553(129 mod 256): MAPWRITE 0x7dbe9 thru 0x9140b	(0x13823 bytes)
6215554(130 mod 256): MAPREAD  0x21cd1 thru 0x40806	(0x1eb36 bytes)
6215555(131 mod 256): PUNCH    0x74212 thru 0x87abd	(0x138ac bytes)
6215556(132 mod 256): TRUNCATE DOWN	from 0x9140c to 0x5fe08	******WWWW
6215557(133 mod 256): DEDUPE 0x2e000 thru 0x39fff	(0xc000 bytes) to 0x48000 thru 0x53fff
6215558(134 mod 256): MAPREAD  0x23a9d thru 0x34a68	(0x10fcc bytes)
6215559(135 mod 256): TRUNCATE DOWN	from 0x5fe08 to 0x5c2b4
6215560(136 mod 256): SKIPPED (no operation)
6215561(137 mod 256): CLONE 0x4000 thru 0x7fff	(0x4000 bytes) to 0x13000 thru 0x16fff
6215562(138 mod 256): WRITE    0x3120 thru 0x16a47	(0x13928 bytes)
6215563(139 mod 256): ZERO     0x3b4a6 thru 0x4115c	(0x5cb7 bytes)
6215564(140 mod 256): MAPREAD  0x1dfe4 thru 0x389b5	(0x1a9d2 bytes)
6215565(141 mod 256): COPY 0x405be thru 0x5ae5f	(0x1a8a2 bytes) to 0xa1fb thru 0x24a9c
6215566(142 mod 256): INSERT 0x34000 thru 0x3cfff	(0x9000 bytes)
6215567(143 mod 256): ZERO     0x828b8 thru 0x8309a	(0x7e3 bytes)
6215568(144 mod 256): TRUNCATE DOWN	from 0x652b4 to 0xe736
6215569(145 mod 256): WRITE    0x5691a thru 0x6a3dd	(0x13ac4 bytes) HOLE
6215570(146 mod 256): CLONE 0x2e000 thru 0x3ffff	(0x12000 bytes) to 0x53000 thru 0x64fff
6215571(147 mod 256): MAPREAD  0x2a81e thru 0x435e9	(0x18dcc bytes)
6215572(148 mod 256): WRITE    0x55380 thru 0x592fb	(0x3f7c bytes)
6215573(149 mod 256): WRITE    0x64cb3 thru 0x70236	(0xb584 bytes) EXTEND	***WWWW
6215574(150 mod 256): COLLAPSE 0xa000 thru 0x25fff	(0x1c000 bytes)
6215575(151 mod 256): PUNCH    0x46231 thru 0x4e02c	(0x7dfc bytes)
6215576(152 mod 256): FALLOC   0x61dd thru 0x13374	(0xd197 bytes) INTERIOR
6215577(153 mod 256): WRITE    0x54aa0 thru 0x5f39b	(0xa8fc bytes) HOLE
6215578(154 mod 256): ZERO     0x277f3 thru 0x352c6	(0xdad4 bytes)
6215579(155 mod 256): INSERT 0xd000 thru 0x11fff	(0x5000 bytes)
6215580(156 mod 256): TRUNCATE DOWN	from 0x6439c to 0x55bfb
6215581(157 mod 256): INSERT 0x43000 thru 0x52fff	(0x10000 bytes)
6215582(158 mod 256): TRUNCATE UP	from 0x65bfb to 0x834ea	******WWWW
6215583(159 mod 256): CLONE 0x51000 thru 0x63fff	(0x13000 bytes) to 0x77000 thru 0x89fff
6215584(160 mod 256): DEDUPE 0x2d000 thru 0x49fff	(0x1d000 bytes) to 0x6d000 thru 0x89fff	******BBBB
6215585(161 mod 256): COPY 0x7261 thru 0x10497	(0x9237 bytes) to 0x24fb3 thru 0x2e1e9
6215586(162 mod 256): ZERO     0x7010 thru 0xf3e6	(0x83d7 bytes)
6215587(163 mod 256): COLLAPSE 0x41000 thru 0x5cfff	(0x1c000 bytes)
6215588(164 mod 256): TRUNCATE DOWN	from 0x6e000 to 0x211be
6215589(165 mod 256): INSERT 0x2000 thru 0x1ffff	(0x1e000 bytes)
6215590(166 mod 256): DEDUPE 0x19000 thru 0x21fff	(0x9000 bytes) to 0x2000 thru 0xafff
6215591(167 mod 256): MAPWRITE 0x6bab7 thru 0x71c9c	(0x61e6 bytes)	******WWWW
6215592(168 mod 256): INSERT 0x31000 thru 0x3efff	(0xe000 bytes)
6215593(169 mod 256): INSERT 0x9000 thru 0x9fff	(0x1000 bytes)
6215594(170 mod 256): MAPWRITE 0xb1e6 thru 0xd776	(0x2591 bytes)
6215595(171 mod 256): CLONE 0x36000 thru 0x38fff	(0x3000 bytes) to 0x52000 thru 0x54fff
6215596(172 mod 256): COLLAPSE 0x26000 thru 0x2cfff	(0x7000 bytes)
6215597(173 mod 256): DEDUPE 0x1d000 thru 0x32fff	(0x16000 bytes) to 0x52000 thru 0x67fff
6215598(174 mod 256): PUNCH    0x573b thru 0xab49	(0x540f bytes)
6215599(175 mod 256): INSERT 0x17000 thru 0x2bfff	(0x15000 bytes)
6215600(176 mod 256): READ     0x740c0 thru 0x837ae	(0xf6ef bytes)
6215601(177 mod 256): SKIPPED (no operation)
6215602(178 mod 256): CLONE 0x4c000 thru 0x61fff	(0x16000 bytes) to 0x9000 thru 0x1efff
6215603(179 mod 256): TRUNCATE DOWN	from 0x8ec9d to 0x17911	******WWWW
6215604(180 mod 256): CLONE 0x3000 thru 0x5fff	(0x3000 bytes) to 0x38000 thru 0x3afff
6215605(181 mod 256): COLLAPSE 0xe000 thru 0x1dfff	(0x10000 bytes)
6215606(182 mod 256): PUNCH    0x2155f thru 0x2afff	(0x9aa1 bytes)
6215607(183 mod 256): CLONE 0x19000 thru 0x24fff	(0xc000 bytes) to 0x39000 thru 0x44fff
6215608(184 mod 256): MAPREAD  0x28cde thru 0x444c7	(0x1b7ea bytes)
6215609(185 mod 256): SKIPPED (no operation)
6215610(186 mod 256): MAPREAD  0x27c21 thru 0x39b3d	(0x11f1d bytes)
6215611(187 mod 256): READ     0x8dee thru 0x12a26	(0x9c39 bytes)
6215612(188 mod 256): COLLAPSE 0x5000 thru 0x8fff	(0x4000 bytes)
6215613(189 mod 256): READ     0xf63a thru 0x18e82	(0x9849 bytes)
6215614(190 mod 256): READ     0x1e293 thru 0x258b3	(0x7621 bytes)
6215615(191 mod 256): MAPWRITE 0x23a24 thru 0x3fe35	(0x1c412 bytes)
6215616(192 mod 256): DEDUPE 0x25000 thru 0x3bfff	(0x17000 bytes) to 0x0 thru 0x16fff
6215617(193 mod 256): MAPREAD  0xa241 thru 0x161f8	(0xbfb8 bytes)
6215618(194 mod 256): MAPREAD  0x17692 thru 0x20a8e	(0x93fd bytes)
6215619(195 mod 256): DEDUPE 0x25000 thru 0x2ffff	(0xb000 bytes) to 0x16000 thru 0x20fff
6215620(196 mod 256): CLONE 0x16000 thru 0x2bfff	(0x16000 bytes) to 0x53000 thru 0x68fff
6215621(197 mod 256): MAPWRITE 0x6cedd thru 0x8a888	(0x1d9ac bytes)	******WWWW
6215622(198 mod 256): TRUNCATE DOWN	from 0x8a889 to 0x2be15	******WWWW
6215623(199 mod 256): PUNCH    0xd0bf thru 0x1f814	(0x12756 bytes)
6215624(200 mod 256): COLLAPSE 0x16000 thru 0x20fff	(0xb000 bytes)
6215625(201 mod 256): TRUNCATE UP	from 0x20e15 to 0x27c6d
6215626(202 mod 256): ZERO     0x281ce thru 0x3af4d	(0x12d80 bytes)
6215627(203 mod 256): FALLOC   0x50187 thru 0x56889	(0x6702 bytes) EXTENDING
6215628(204 mod 256): ZERO     0x5e95a thru 0x684a1	(0x9b48 bytes)
6215629(205 mod 256): READ     0x469a6 thru 0x52cd2	(0xc32d bytes)
6215630(206 mod 256): SKIPPED (no operation)
6215631(207 mod 256): DEDUPE 0x17000 thru 0x1afff	(0x4000 bytes) to 0x42000 thru 0x45fff
6215632(208 mod 256): INSERT 0x2c000 thru 0x32fff	(0x7000 bytes)
6215633(209 mod 256): MAPREAD  0x6e6ea thru 0x6f4a1	(0xdb8 bytes)	***RRRR***
6215634(210 mod 256): CLONE 0x53000 thru 0x58fff	(0x6000 bytes) to 0x2a000 thru 0x2ffff
6215635(211 mod 256): CLONE 0x30000 thru 0x41fff	(0x12000 bytes) to 0x59000 thru 0x6afff
6215636(212 mod 256): DEDUPE 0x6d000 thru 0x6efff	(0x2000 bytes) to 0x48000 thru 0x49fff	BBBB******
6215637(213 mod 256): READ     0x6c711 thru 0x6e2af	(0x1b9f bytes)
6215638(214 mod 256): READ     0x6940e thru 0x6f4a1	(0x6094 bytes)	***RRRR***
6215639(215 mod 256): SKIPPED (no operation)
6215640(216 mod 256): WRITE    0x66f07 thru 0x7f22f	(0x18329 bytes) EXTEND	***WWWW
6215641(217 mod 256): ZERO     0x65ce9 thru 0x7630e	(0x10626 bytes)	******ZZZZ
6215642(218 mod 256): CLONE 0x21000 thru 0x2afff	(0xa000 bytes) to 0x87000 thru 0x90fff
6215643(219 mod 256): MAPREAD  0x23d44 thru 0x3e834	(0x1aaf1 bytes)
6215644(220 mod 256): INSERT 0x4d000 thru 0x4dfff	(0x1000 bytes)
6215645(221 mod 256): FALLOC   0xd94f thru 0x1a773	(0xce24 bytes) INTERIOR
6215646(222 mod 256): WRITE    0x1c570 thru 0x24e35	(0x88c6 bytes)
6215647(223 mod 256): TRUNCATE DOWN	from 0x92000 to 0x736be
6215648(224 mod 256): CLONE 0x62000 thru 0x71fff	(0x10000 bytes) to 0x52000 thru 0x61fff	JJJJ******
6215649(225 mod 256): COLLAPSE 0x51000 thru 0x54fff	(0x4000 bytes)
6215650(226 mod 256): TRUNCATE DOWN	from 0x6f6be to 0x4a692	******WWWW
6215651(227 mod 256): SKIPPED (no operation)
6215652(228 mod 256): ZERO     0xd157 thru 0x202a7	(0x13151 bytes)
6215653(229 mod 256): COPY 0xf8b thru 0x1b146	(0x1a1bc bytes) to 0x6aeae thru 0x85069	******EEEE
6215654(230 mod 256): FALLOC   0xd3b7 thru 0x1d899	(0x104e2 bytes) INTERIOR
6215655(231 mod 256): CLONE 0x80000 thru 0x83fff	(0x4000 bytes) to 0x3a000 thru 0x3dfff
6215656(232 mod 256): WRITE    0xe2a8 thru 0x2039b	(0x120f4 bytes)
6215657(233 mod 256): COPY 0x72075 thru 0x85069	(0x12ff5 bytes) to 0x3d748 thru 0x5073c
6215658(234 mod 256): ZERO     0x28697 thru 0x46702	(0x1e06c bytes)
6215659(235 mod 256): MAPWRITE 0x46482 thru 0x51592	(0xb111 bytes)
6215660(236 mod 256): PUNCH    0x2a16d thru 0x3cb40	(0x129d4 bytes)
6215661(237 mod 256): CLONE 0x62000 thru 0x68fff	(0x7000 bytes) to 0x2a000 thru 0x30fff
6215662(238 mod 256): SKIPPED (no operation)
6215663(239 mod 256): WRITE    0x8f6a0 thru 0x923a6	(0x2d07 bytes) HOLE
6215664(240 mod 256): CLONE 0x86000 thru 0x8afff	(0x5000 bytes) to 0x2a000 thru 0x2efff
6215665(241 mod 256): DEDUPE 0x78000 thru 0x85fff	(0xe000 bytes) to 0x1a000 thru 0x27fff
6215666(242 mod 256): READ     0x8d90c thru 0x923a6	(0x4a9b bytes)
6215667(243 mod 256): SKIPPED (no operation)
6215668(244 mod 256): FALLOC   0x3916e thru 0x4f6f5	(0x16587 bytes) INTERIOR
6215669(245 mod 256): WRITE    0x4ad8f thru 0x51c74	(0x6ee6 bytes)
6215670(246 mod 256): MAPREAD  0x8c56c thru 0x923a6	(0x5e3b bytes)
6215671(247 mod 256): COPY 0x5606d thru 0x71fd1	(0x1bf65 bytes) to 0x74434 thru 0x90398	EEEE******
6215672(248 mod 256): COPY 0x883bc thru 0x8f93b	(0x7580 bytes) to 0x4bf37 thru 0x534b6
6215673(249 mod 256): FALLOC   0x8087b thru 0x8ebbe	(0xe343 bytes) INTERIOR
6215674(250 mod 256): SKIPPED (no operation)
6215675(251 mod 256): MAPREAD  0x4760a thru 0x55a53	(0xe44a bytes)
6215676(252 mod 256): MAPREAD  0x575d5 thru 0x73479	(0x1bea5 bytes)	***RRRR***
6215677(253 mod 256): READ     0x36dba thru 0x3ac15	(0x3e5c bytes)
6215678(254 mod 256): CLONE 0x5c000 thru 0x5cfff	(0x1000 bytes) to 0x11000 thru 0x11fff
6215679(255 mod 256): READ     0x8925f thru 0x923a6	(0x9148 bytes)
6215680(  0 mod 256): COPY 0x115fc thru 0x1fba5	(0xe5aa bytes) to 0x6cef0 thru 0x7b499	******EEEE
6215681(  1 mod 256): SKIPPED (no operation)
6215682(  2 mod 256): COPY 0xe7e6 thru 0x1aedf	(0xc6fa bytes) to 0x32c42 thru 0x3f33b
6215683(  3 mod 256): COLLAPSE 0x23000 thru 0x37fff	(0x15000 bytes)
6215684(  4 mod 256): TRUNCATE DOWN	from 0x7d3a7 to 0x55403	******WWWW
6215685(  5 mod 256): SKIPPED (no operation)
6215686(  6 mod 256): MAPREAD  0x175a7 thru 0x2d91a	(0x16374 bytes)
6215687(  7 mod 256): COPY 0x356f thru 0x1ad24	(0x177b6 bytes) to 0x649a9 thru 0x7c15e	******EEEE
6215688(  8 mod 256): INSERT 0x4d000 thru 0x62fff	(0x16000 bytes)
6215689(  9 mod 256): MAPWRITE 0x8a8de thru 0x927bf	(0x7ee2 bytes)
6215690( 10 mod 256): ZERO     0x3b16e thru 0x3e7e0	(0x3673 bytes)
6215691( 11 mod 256): SKIPPED (no operation)
6215692( 12 mod 256): ZERO     0x68bf4 thru 0x85032	(0x1c43f bytes)	******ZZZZ
6215693( 13 mod 256): WRITE    0x6746e thru 0x80c08	(0x1979b bytes)	***WWWW
6215694( 14 mod 256): MAPREAD  0xf38c thru 0x25c15	(0x1688a bytes)
6215695( 15 mod 256): MAPREAD  0x7427 thru 0x1a91c	(0x134f6 bytes)
6215696( 16 mod 256): WRITE    0x6e553 thru 0x72fdc	(0x4a8a bytes)	***WWWW
6215697( 17 mod 256): WRITE    0x4e7b thru 0x1e1e9	(0x1936f bytes)
6215698( 18 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x7b95a
6215699( 19 mod 256): MAPREAD  0x2ada4 thru 0x457bf	(0x1aa1c bytes)
6215700( 20 mod 256): CLONE 0x15000 thru 0x27fff	(0x13000 bytes) to 0x7f000 thru 0x91fff
6215701( 21 mod 256): PUNCH    0x82d8a thru 0x91fff	(0xf276 bytes)
6215702( 22 mod 256): MAPWRITE 0x90c1a thru 0x927bf	(0x1ba6 bytes)
6215703( 23 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8255d
6215704( 24 mod 256): COLLAPSE 0x18000 thru 0x20fff	(0x9000 bytes)
6215705( 25 mod 256): FALLOC   0x8814d thru 0x927c0	(0xa673 bytes) EXTENDING
6215706( 26 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5f151	******WWWW
6215707( 27 mod 256): FALLOC   0x5f05 thru 0x165a8	(0x106a3 bytes) INTERIOR
6215708( 28 mod 256): INSERT 0x35000 thru 0x4dfff	(0x19000 bytes)
6215709( 29 mod 256): WRITE    0xdd8f thru 0x28e56	(0x1b0c8 bytes)
6215710( 30 mod 256): CLONE 0x9000 thru 0x1afff	(0x12000 bytes) to 0x39000 thru 0x4afff
6215711( 31 mod 256): TRUNCATE UP	from 0x78151 to 0x7d512
6215712( 32 mod 256): COLLAPSE 0x4000 thru 0x1cfff	(0x19000 bytes)
6215713( 33 mod 256): CLONE 0x15000 thru 0x33fff	(0x1f000 bytes) to 0x4d000 thru 0x6bfff
6215714( 34 mod 256): DEDUPE 0x4000 thru 0x10fff	(0xd000 bytes) to 0x14000 thru 0x20fff
6215715( 35 mod 256): COPY 0x5c12a thru 0x6bfff	(0xfed6 bytes) to 0x1975b thru 0x29630
6215716( 36 mod 256): SKIPPED (no operation)
6215717( 37 mod 256): INSERT 0x14000 thru 0x16fff	(0x3000 bytes)
6215718( 38 mod 256): PUNCH    0x612b4 thru 0x6efff	(0xdd4c bytes)	******PPPP
6215719( 39 mod 256): INSERT 0x1d000 thru 0x20fff	(0x4000 bytes)
6215720( 40 mod 256): COPY 0x10c5c thru 0x143e5	(0x378a bytes) to 0x3c11f thru 0x3f8a8
6215721( 41 mod 256): FALLOC   0x5d186 thru 0x78de8	(0x1bc62 bytes) PAST_EOF	******FFFF
6215722( 42 mod 256): CLONE 0x9000 thru 0x22fff	(0x1a000 bytes) to 0x41000 thru 0x5afff
6215723( 43 mod 256): DEDUPE 0xd000 thru 0x18fff	(0xc000 bytes) to 0x24000 thru 0x2ffff
6215724( 44 mod 256): MAPREAD  0x53b98 thru 0x63fc3	(0x1042c bytes)
6215725( 45 mod 256): WRITE    0x3feb8 thru 0x482f9	(0x8442 bytes)
6215726( 46 mod 256): READ     0x1d4c thru 0x1cab6	(0x1ad6b bytes)
6215727( 47 mod 256): FALLOC   0x27ccf thru 0x399d9	(0x11d0a bytes) INTERIOR
6215728( 48 mod 256): READ     0x40afe thru 0x4cd20	(0xc223 bytes)
6215729( 49 mod 256): COPY 0x2948a thru 0x35d77	(0xc8ee bytes) to 0x3d43d thru 0x49d2a
6215730( 50 mod 256): SKIPPED (no operation)
6215731( 51 mod 256): COPY 0x325aa thru 0x3def7	(0xb94e bytes) to 0x13c7e thru 0x1f5cb
6215732( 52 mod 256): INSERT 0x61000 thru 0x62fff	(0x2000 bytes)
6215733( 53 mod 256): WRITE    0x8ccdb thru 0x9015a	(0x3480 bytes) HOLE
6215734( 54 mod 256): PUNCH    0x4f4c8 thru 0x6060b	(0x11144 bytes)
6215735( 55 mod 256): SKIPPED (no operation)
6215736( 56 mod 256): COPY 0x28d54 thru 0x29373	(0x620 bytes) to 0x8ff1d thru 0x9053c
6215737( 57 mod 256): FALLOC   0x2be52 thru 0x39530	(0xd6de bytes) INTERIOR
6215738( 58 mod 256): READ     0x889d thru 0x12234	(0x9998 bytes)
6215739( 59 mod 256): FALLOC   0x1af3d thru 0x3932d	(0x1e3f0 bytes) INTERIOR
6215740( 60 mod 256): DEDUPE 0x52000 thru 0x60fff	(0xf000 bytes) to 0x43000 thru 0x51fff
6215741( 61 mod 256): ZERO     0x1883f thru 0x36504	(0x1dcc6 bytes)
6215742( 62 mod 256): TRUNCATE DOWN	from 0x9053d to 0xecf2	******WWWW
6215743( 63 mod 256): SKIPPED (no operation)
6215744( 64 mod 256): MAPWRITE 0x278be thru 0x392f0	(0x11a33 bytes)
6215745( 65 mod 256): FALLOC   0x3e67a thru 0x41839	(0x31bf bytes) EXTENDING
6215746( 66 mod 256): PUNCH    0x36983 thru 0x41838	(0xaeb6 bytes)
6215747( 67 mod 256): FALLOC   0x34a76 thru 0x3f05b	(0xa5e5 bytes) INTERIOR
6215748( 68 mod 256): PUNCH    0x1ef thru 0x2cbe	(0x2ad0 bytes)
6215749( 69 mod 256): ZERO     0x283ed thru 0x2f9c7	(0x75db bytes)
6215750( 70 mod 256): SKIPPED (no operation)
6215751( 71 mod 256): MAPWRITE 0x47339 thru 0x5df99	(0x16c61 bytes)
6215752( 72 mod 256): COLLAPSE 0x12000 thru 0x19fff	(0x8000 bytes)
6215753( 73 mod 256): SKIPPED (no operation)
6215754( 74 mod 256): SKIPPED (no operation)
6215755( 75 mod 256): READ     0x5e73 thru 0xefde	(0x916c bytes)
6215756( 76 mod 256): PUNCH    0x62c4 thru 0x17a1b	(0x11758 bytes)
6215757( 77 mod 256): WRITE    0x7825e thru 0x832cf	(0xb072 bytes) HOLE	***WWWW
6215758( 78 mod 256): WRITE    0x2da98 thru 0x43ca0	(0x16209 bytes)
6215759( 79 mod 256): WRITE    0x3ebd3 thru 0x57af9	(0x18f27 bytes)
6215760( 80 mod 256): PUNCH    0x807c2 thru 0x832cf	(0x2b0e bytes)
6215761( 81 mod 256): MAPWRITE 0x3cb76 thru 0x4a5fe	(0xda89 bytes)
6215762( 82 mod 256): COLLAPSE 0x18000 thru 0x1afff	(0x3000 bytes)
6215763( 83 mod 256): TRUNCATE DOWN	from 0x802d0 to 0x50fdf	******WWWW
6215764( 84 mod 256): READ     0x4ecd9 thru 0x50fde	(0x2306 bytes)
6215765( 85 mod 256): SKIPPED (no operation)
6215766( 86 mod 256): MAPREAD  0x4cd6 thru 0x1a7c0	(0x15aeb bytes)
6215767( 87 mod 256): PUNCH    0x479f thru 0x117a5	(0xd007 bytes)
6215768( 88 mod 256): SKIPPED (no operation)
6215769( 89 mod 256): COPY 0x20258 thru 0x22475	(0x221e bytes) to 0x16052 thru 0x1826f
6215770( 90 mod 256): READ     0x6066 thru 0x1ba14	(0x159af bytes)
6215771( 91 mod 256): PUNCH    0x394a0 thru 0x3edf1	(0x5952 bytes)
6215772( 92 mod 256): INSERT 0x41000 thru 0x4bfff	(0xb000 bytes)
6215773( 93 mod 256): COPY 0x28f9b thru 0x404af	(0x17515 bytes) to 0x62a42 thru 0x79f56	******EEEE
6215774( 94 mod 256): FALLOC   0x61e0b thru 0x7628f	(0x14484 bytes) INTERIOR	******FFFF
6215775( 95 mod 256): ZERO     0x822d thru 0x1e2d8	(0x160ac bytes)
6215776( 96 mod 256): PUNCH    0x4f736 thru 0x5fc38	(0x10503 bytes)
6215777( 97 mod 256): SKIPPED (no operation)
6215778( 98 mod 256): WRITE    0x315a8 thru 0x4fbbe	(0x1e617 bytes)
6215779( 99 mod 256): FALLOC   0x30759 thru 0x3bd4f	(0xb5f6 bytes) INTERIOR
6215780(100 mod 256): TRUNCATE DOWN	from 0x79f57 to 0x21ee	******WWWW
6215781(101 mod 256): PUNCH    0x12ed thru 0x21ed	(0xf01 bytes)
6215782(102 mod 256): SKIPPED (no operation)
6215783(103 mod 256): ZERO     0x6f07 thru 0xaedd	(0x3fd7 bytes)
6215784(104 mod 256): FALLOC   0x1db61 thru 0x29092	(0xb531 bytes) EXTENDING
6215785(105 mod 256): ZERO     0x43c9c thru 0x5dadb	(0x19e40 bytes)
6215786(106 mod 256): PUNCH    0x5a686 thru 0x5dadb	(0x3456 bytes)
6215787(107 mod 256): INSERT 0x48000 thru 0x4dfff	(0x6000 bytes)
6215788(108 mod 256): SKIPPED (no operation)
6215789(109 mod 256): ZERO     0x907cc thru 0x927bf	(0x1ff4 bytes)
6215790(110 mod 256): COPY 0x484a4 thru 0x51dc4	(0x9921 bytes) to 0x602ad thru 0x69bcd
6215791(111 mod 256): WRITE    0x49d59 thru 0x63e2a	(0x1a0d2 bytes)
6215792(112 mod 256): PUNCH    0x8da9 thru 0xf8f6	(0x6b4e bytes)
6215793(113 mod 256): READ     0x5914f thru 0x69bcd	(0x10a7f bytes)
6215794(114 mod 256): COPY 0x680b1 thru 0x69bcd	(0x1b1d bytes) to 0x47d58 thru 0x49874
6215795(115 mod 256): SKIPPED (no operation)
6215796(116 mod 256): CLONE 0x22000 thru 0x3cfff	(0x1b000 bytes) to 0x68000 thru 0x82fff	******JJJJ
6215797(117 mod 256): MAPREAD  0x160f7 thru 0x3094c	(0x1a856 bytes)
6215798(118 mod 256): TRUNCATE DOWN	from 0x83000 to 0x1ac7d	******WWWW
6215799(119 mod 256): ZERO     0x91d90 thru 0x927bf	(0xa30 bytes)
6215800(120 mod 256): READ     0x7c08b thru 0x927bf	(0x16735 bytes)
6215801(121 mod 256): DEDUPE 0x70000 thru 0x79fff	(0xa000 bytes) to 0x1000 thru 0xafff
6215802(122 mod 256): DEDUPE 0x8000 thru 0x24fff	(0x1d000 bytes) to 0x28000 thru 0x44fff
6215803(123 mod 256): MAPREAD  0x6eae thru 0x9120	(0x2273 bytes)
6215804(124 mod 256): PUNCH    0x40922 thru 0x4953c	(0x8c1b bytes)
6215805(125 mod 256): MAPREAD  0x8504 thru 0x1a499	(0x11f96 bytes)
6215806(126 mod 256): ZERO     0x6adc9 thru 0x799d1	(0xec09 bytes)	******ZZZZ
6215807(127 mod 256): WRITE    0x275d5 thru 0x30976	(0x93a2 bytes)
6215808(128 mod 256): SKIPPED (no operation)
6215809(129 mod 256): CLONE 0x4e000 thru 0x52fff	(0x5000 bytes) to 0x2f000 thru 0x33fff
6215810(130 mod 256): SKIPPED (no operation)
6215811(131 mod 256): PUNCH    0x4d0fb thru 0x5a6c7	(0xd5cd bytes)
6215812(132 mod 256): FALLOC   0x6fa97 thru 0x7b32b	(0xb894 bytes) INTERIOR
6215813(133 mod 256): FALLOC   0x67ac7 thru 0x710e9	(0x9622 bytes) INTERIOR	******FFFF
6215814(134 mod 256): ZERO     0x56f3e thru 0x61f10	(0xafd3 bytes)
6215815(135 mod 256): MAPREAD  0x7fcc2 thru 0x927bf	(0x12afe bytes)
6215816(136 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x12e6f	******WWWW
6215817(137 mod 256): SKIPPED (no operation)
6215818(138 mod 256): WRITE    0x3946f thru 0x4021b	(0x6dad bytes) HOLE
6215819(139 mod 256): ZERO     0x37d65 thru 0x55be4	(0x1de80 bytes)
6215820(140 mod 256): COLLAPSE 0x0 thru 0x4fff	(0x5000 bytes)
6215821(141 mod 256): MAPWRITE 0x19305 thru 0x1df5d	(0x4c59 bytes)
6215822(142 mod 256): ZERO     0x279c5 thru 0x33b55	(0xc191 bytes)
6215823(143 mod 256): TRUNCATE UP	from 0x3b21c to 0x83264	******WWWW
6215824(144 mod 256): READ     0x808d2 thru 0x83263	(0x2992 bytes)
6215825(145 mod 256): SKIPPED (no operation)
6215826(146 mod 256): TRUNCATE DOWN	from 0x83264 to 0x62a1b	******WWWW
6215827(147 mod 256): SKIPPED (no operation)
6215828(148 mod 256): FALLOC   0xc9a3 thru 0x10b97	(0x41f4 bytes) INTERIOR
6215829(149 mod 256): CLONE 0x15000 thru 0x17fff	(0x3000 bytes) to 0x78000 thru 0x7afff
6215830(150 mod 256): MAPWRITE 0x412e8 thru 0x44cab	(0x39c4 bytes)
6215831(151 mod 256): TRUNCATE DOWN	from 0x7b000 to 0x50003	******WWWW
6215832(152 mod 256): COLLAPSE 0xb000 thru 0x10fff	(0x6000 bytes)
6215833(153 mod 256): FALLOC   0x6ba2d thru 0x844fd	(0x18ad0 bytes) EXTENDING	******FFFF
6215834(154 mod 256): COPY 0x173ae thru 0x20d3b	(0x998e bytes) to 0x689d8 thru 0x72365	******EEEE
6215835(155 mod 256): INSERT 0xf000 thru 0x10fff	(0x2000 bytes)
6215836(156 mod 256): READ     0x62cb5 thru 0x77714	(0x14a60 bytes)	***RRRR***
6215837(157 mod 256): TRUNCATE DOWN	from 0x864fd to 0x77c09
6215838(158 mod 256): TRUNCATE DOWN	from 0x77c09 to 0x631eb	******WWWW
6215839(159 mod 256): CLONE 0x2e000 thru 0x4bfff	(0x1e000 bytes) to 0x60000 thru 0x7dfff	******JJJJ
6215840(160 mod 256): WRITE    0x51294 thru 0x5631c	(0x5089 bytes)
6215841(161 mod 256): TRUNCATE DOWN	from 0x7e000 to 0x3050	******WWWW
6215842(162 mod 256): TRUNCATE UP	from 0x3050 to 0x48a2b
6215843(163 mod 256): MAPREAD  0x2ebbf thru 0x34765	(0x5ba7 bytes)
6215844(164 mod 256): INSERT 0xe000 thru 0x24fff	(0x17000 bytes)
6215845(165 mod 256): COPY 0x25312 thru 0x286f7	(0x33e6 bytes) to 0x7e22 thru 0xb207
6215846(166 mod 256): MAPWRITE 0x8af03 thru 0x927bf	(0x78bd bytes)
6215847(167 mod 256): SKIPPED (no operation)
6215848(168 mod 256): PUNCH    0x3b796 thru 0x54c40	(0x194ab bytes)
6215849(169 mod 256): SKIPPED (no operation)
6215850(170 mod 256): SKIPPED (no operation)
6215851(171 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4df29	******WWWW
6215852(172 mod 256): PUNCH    0x198d thru 0xbd7c	(0xa3f0 bytes)
6215853(173 mod 256): PUNCH    0x1c2cb thru 0x24f10	(0x8c46 bytes)
6215854(174 mod 256): SKIPPED (no operation)
6215855(175 mod 256): CLONE 0x38000 thru 0x42fff	(0xb000 bytes) to 0x5f000 thru 0x69fff
6215856(176 mod 256): ZERO     0x10ac6 thru 0x1b7cd	(0xad08 bytes)
6215857(177 mod 256): PUNCH    0x4e316 thru 0x571dc	(0x8ec7 bytes)
6215858(178 mod 256): FALLOC   0x18da5 thru 0x3097e	(0x17bd9 bytes) INTERIOR
6215859(179 mod 256): WRITE    0x81393 thru 0x9166c	(0x102da bytes) HOLE	***WWWW
6215860(180 mod 256): READ     0x5e67b thru 0x79f9d	(0x1b923 bytes)	***RRRR***
6215861(181 mod 256): ZERO     0x1c1ec thru 0x370b9	(0x1aece bytes)
6215862(182 mod 256): COLLAPSE 0x43000 thru 0x57fff	(0x15000 bytes)
6215863(183 mod 256): MAPWRITE 0x2223f thru 0x398dc	(0x1769e bytes)
6215864(184 mod 256): TRUNCATE DOWN	from 0x7c66d to 0xb2a5	******WWWW
6215865(185 mod 256): COPY 0x3a5f thru 0xb2a4	(0x7846 bytes) to 0x4e605 thru 0x55e4a
6215866(186 mod 256): WRITE    0xdb88 thru 0x23980	(0x15df9 bytes)
6215867(187 mod 256): DEDUPE 0x4a000 thru 0x4dfff	(0x4000 bytes) to 0x45000 thru 0x48fff
6215868(188 mod 256): DEDUPE 0x1e000 thru 0x28fff	(0xb000 bytes) to 0xa000 thru 0x14fff
6215869(189 mod 256): COLLAPSE 0x6000 thru 0x1afff	(0x15000 bytes)
6215870(190 mod 256): FALLOC   0xc65f thru 0xf80a	(0x31ab bytes) INTERIOR
6215871(191 mod 256): WRITE    0x8fc5f thru 0x927bf	(0x2b61 bytes) HOLE	***WWWW
6215872(192 mod 256): MAPWRITE 0x1cf41 thru 0x1e71f	(0x17df bytes)
6215873(193 mod 256): SKIPPED (no operation)
6215874(194 mod 256): COPY 0x4b476 thru 0x5d2c2	(0x11e4d bytes) to 0x21da4 thru 0x33bf0
6215875(195 mod 256): COLLAPSE 0x7a000 thru 0x7dfff	(0x4000 bytes)
6215876(196 mod 256): TRUNCATE DOWN	from 0x8e7c0 to 0x848b4
6215877(197 mod 256): TRUNCATE DOWN	from 0x848b4 to 0x6a1dc	******WWWW
6215878(198 mod 256): PUNCH    0x68329 thru 0x6a1db	(0x1eb3 bytes)
6215879(199 mod 256): TRUNCATE DOWN	from 0x6a1dc to 0x218cc
6215880(200 mod 256): COPY 0xdb1e thru 0x218cb	(0x13dae bytes) to 0x574d2 thru 0x6b27f
6215881(201 mod 256): READ     0x4b386 thru 0x4b3c6	(0x41 bytes)
6215882(202 mod 256): COLLAPSE 0x24000 thru 0x3afff	(0x17000 bytes)
6215883(203 mod 256): MAPWRITE 0x7d9b1 thru 0x7ebc7	(0x1217 bytes)
6215884(204 mod 256): DEDUPE 0x28000 thru 0x34fff	(0xd000 bytes) to 0x57000 thru 0x63fff
6215885(205 mod 256): ZERO     0x2ab9f thru 0x3c9ed	(0x11e4f bytes)
6215886(206 mod 256): INSERT 0x27000 thru 0x32fff	(0xc000 bytes)
6215887(207 mod 256): TRUNCATE DOWN	from 0x8abc8 to 0x69ef4	******WWWW
6215888(208 mod 256): MAPWRITE 0x3761d thru 0x53282	(0x1bc66 bytes)
6215889(209 mod 256): WRITE    0x2f94d thru 0x487e4	(0x18e98 bytes)
6215890(210 mod 256): TRUNCATE UP	from 0x69ef4 to 0x71d94	******WWWW
6215891(211 mod 256): TRUNCATE DOWN	from 0x71d94 to 0x71170
6215892(212 mod 256): WRITE    0x612e7 thru 0x77fed	(0x16d07 bytes) EXTEND	***WWWW
6215893(213 mod 256): DEDUPE 0x23000 thru 0x29fff	(0x7000 bytes) to 0x6b000 thru 0x71fff	******BBBB
6215894(214 mod 256): TRUNCATE DOWN	from 0x77fee to 0x1e480	******WWWW
6215895(215 mod 256): COLLAPSE 0x12000 thru 0x1cfff	(0xb000 bytes)
6215896(216 mod 256): INSERT 0xe000 thru 0x29fff	(0x1c000 bytes)
6215897(217 mod 256): WRITE    0x75e7b thru 0x891b7	(0x1333d bytes) HOLE	***WWWW
6215898(218 mod 256): DEDUPE 0x1a000 thru 0x36fff	(0x1d000 bytes) to 0x40000 thru 0x5cfff
6215899(219 mod 256): READ     0x75043 thru 0x891b7	(0x14175 bytes)
6215900(220 mod 256): PUNCH    0x17b89 thru 0x27612	(0xfa8a bytes)
6215901(221 mod 256): INSERT 0x63000 thru 0x6bfff	(0x9000 bytes)
6215902(222 mod 256): TRUNCATE DOWN	from 0x921b8 to 0x35d18	******WWWW
6215903(223 mod 256): FALLOC   0x747ee thru 0x87746	(0x12f58 bytes) EXTENDING
6215904(224 mod 256): WRITE    0x4d9fd thru 0x4e530	(0xb34 bytes)
6215905(225 mod 256): WRITE    0x496f6 thru 0x67511	(0x1de1c bytes)
6215906(226 mod 256): INSERT 0x68000 thru 0x6cfff	(0x5000 bytes)
6215907(227 mod 256): PUNCH    0x34564 thru 0x46f75	(0x12a12 bytes)
6215908(228 mod 256): PUNCH    0x2d48f thru 0x43dae	(0x16920 bytes)
6215909(229 mod 256): PUNCH    0x686ec thru 0x69d31	(0x1646 bytes)
6215910(230 mod 256): PUNCH    0x82f8e thru 0x854d6	(0x2549 bytes)
6215911(231 mod 256): SKIPPED (no operation)
6215912(232 mod 256): FALLOC   0x45f0b thru 0x487b8	(0x28ad bytes) INTERIOR
6215913(233 mod 256): READ     0x524c6 thru 0x655fb	(0x13136 bytes)
6215914(234 mod 256): MAPWRITE 0x2157f thru 0x2919c	(0x7c1e bytes)
6215915(235 mod 256): MAPREAD  0x2d995 thru 0x462bc	(0x18928 bytes)
6215916(236 mod 256): COLLAPSE 0xe000 thru 0x1cfff	(0xf000 bytes)
6215917(237 mod 256): DEDUPE 0x12000 thru 0x1efff	(0xd000 bytes) to 0x38000 thru 0x44fff
6215918(238 mod 256): CLONE 0x56000 thru 0x6efff	(0x19000 bytes) to 0x11000 thru 0x29fff	JJJJ******
6215919(239 mod 256): COPY 0x29914 thru 0x32733	(0x8e20 bytes) to 0xe9a1 thru 0x177c0
6215920(240 mod 256): WRITE    0x5ad60 thru 0x71495	(0x16736 bytes)	***WWWW
6215921(241 mod 256): SKIPPED (no operation)
6215922(242 mod 256): CLONE 0x28000 thru 0x37fff	(0x10000 bytes) to 0x39000 thru 0x48fff
6215923(243 mod 256): READ     0x60e47 thru 0x7af5e	(0x1a118 bytes)	***RRRR***
6215924(244 mod 256): WRITE    0x45303 thru 0x61ee6	(0x1cbe4 bytes)
6215925(245 mod 256): INSERT 0x72000 thru 0x86fff	(0x15000 bytes)
6215926(246 mod 256): SKIPPED (no operation)
6215927(247 mod 256): PUNCH    0x38066 thru 0x56c9f	(0x1ec3a bytes)
6215928(248 mod 256): SKIPPED (no operation)
6215929(249 mod 256): WRITE    0x61cec thru 0x6d7c8	(0xbadd bytes)
6215930(250 mod 256): SKIPPED (no operation)
6215931(251 mod 256): READ     0x4bcd thru 0xe671	(0x9aa5 bytes)
6215932(252 mod 256): MAPWRITE 0x2724b thru 0x27a30	(0x7e6 bytes)
6215933(253 mod 256): WRITE    0x3e49c thru 0x47cd2	(0x9837 bytes)
6215934(254 mod 256): WRITE    0x90c08 thru 0x927bf	(0x1bb8 bytes) EXTEND
6215935(255 mod 256): MAPREAD  0xf93b thru 0x240b1	(0x14777 bytes)
6215936(  0 mod 256): COPY 0x84bba thru 0x927bf	(0xdc06 bytes) to 0x6f96d thru 0x7d572
6215937(  1 mod 256): FALLOC   0x1a665 thru 0x2d2fa	(0x12c95 bytes) INTERIOR
6215938(  2 mod 256): CLONE 0x4e000 thru 0x4ffff	(0x2000 bytes) to 0x61000 thru 0x62fff
6215939(  3 mod 256): SKIPPED (no operation)
6215940(  4 mod 256): SKIPPED (no operation)
6215941(  5 mod 256): SKIPPED (no operation)
6215942(  6 mod 256): ZERO     0x84ae5 thru 0x927bf	(0xdcdb bytes)
6215943(  7 mod 256): PUNCH    0x936d thru 0x24aad	(0x1b741 bytes)
6215944(  8 mod 256): READ     0x7a526 thru 0x89acd	(0xf5a8 bytes)
6215945(  9 mod 256): CLONE 0x2f000 thru 0x34fff	(0x6000 bytes) to 0x78000 thru 0x7dfff
6215946( 10 mod 256): SKIPPED (no operation)
6215947( 11 mod 256): COPY 0x3e405 thru 0x55bdd	(0x177d9 bytes) to 0x55cd7 thru 0x6d4af
6215948( 12 mod 256): ZERO     0x18f4 thru 0x1dee8	(0x1c5f5 bytes)
6215949( 13 mod 256): COPY 0x42f12 thru 0x46b14	(0x3c03 bytes) to 0x3e7c6 thru 0x423c8
6215950( 14 mod 256): PUNCH    0x3a9c8 thru 0x57262	(0x1c89b bytes)
6215951( 15 mod 256): READ     0x12111 thru 0x1e15e	(0xc04e bytes)
6215952( 16 mod 256): SKIPPED (no operation)
6215953( 17 mod 256): DEDUPE 0x2f000 thru 0x37fff	(0x9000 bytes) to 0x73000 thru 0x7bfff
6215954( 18 mod 256): DEDUPE 0x77000 thru 0x88fff	(0x12000 bytes) to 0x35000 thru 0x46fff
6215955( 19 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x6fb3d
6215956( 20 mod 256): TRUNCATE UP	from 0x6fb3d to 0x70193
6215957( 21 mod 256): COPY 0x10b71 thru 0x1e407	(0xd897 bytes) to 0x35ed4 thru 0x4376a
6215958( 22 mod 256): WRITE    0x8ab2 thru 0x16c76	(0xe1c5 bytes)
6215959( 23 mod 256): ZERO     0x8d5ab thru 0x927bf	(0x5215 bytes)
6215960( 24 mod 256): READ     0x55da thru 0x1a5a0	(0x14fc7 bytes)
6215961( 25 mod 256): FALLOC   0x4778b thru 0x63e5b	(0x1c6d0 bytes) INTERIOR
6215962( 26 mod 256): MAPREAD  0x34dbd thru 0x3c8a1	(0x7ae5 bytes)
6215963( 27 mod 256): WRITE    0x326ac thru 0x34d0f	(0x2664 bytes)
6215964( 28 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x39a36	******WWWW
6215965( 29 mod 256): FALLOC   0x8d7b9 thru 0x92110	(0x4957 bytes) EXTENDING
6215966( 30 mod 256): PUNCH    0x10227 thru 0x28c25	(0x189ff bytes)
6215967( 31 mod 256): PUNCH    0x82077 thru 0x9210f	(0x10099 bytes)
6215968( 32 mod 256): READ     0xd918 thru 0x2c047	(0x1e730 bytes)
6215969( 33 mod 256): COPY 0x2e1c1 thru 0x42305	(0x14145 bytes) to 0x6c142 thru 0x80286	******EEEE
6215970( 34 mod 256): MAPREAD  0x84e1f thru 0x9210f	(0xd2f1 bytes)
6215971( 35 mod 256): CLONE 0x89000 thru 0x90fff	(0x8000 bytes) to 0x16000 thru 0x1dfff
6215972( 36 mod 256): CLONE 0x32000 thru 0x32fff	(0x1000 bytes) to 0x9000 thru 0x9fff
6215973( 37 mod 256): COPY 0x8770b thru 0x9210f	(0xaa05 bytes) to 0x7c9f7 thru 0x873fb
6215974( 38 mod 256): COPY 0x67e64 thru 0x79fa3	(0x12140 bytes) to 0x396 thru 0x124d5	EEEE******
6215975( 39 mod 256): MAPREAD  0x3ebe0 thru 0x45a89	(0x6eaa bytes)
6215976( 40 mod 256): TRUNCATE DOWN	from 0x92110 to 0x3c289	******WWWW
6215977( 41 mod 256): SKIPPED (no operation)
6215978( 42 mod 256): ZERO     0x7b91b thru 0x82e06	(0x74ec bytes)
6215979( 43 mod 256): PUNCH    0x717f5 thru 0x82e06	(0x11612 bytes)
6215980( 44 mod 256): CLONE 0x2a000 thru 0x2bfff	(0x2000 bytes) to 0x2000 thru 0x3fff
6215981( 45 mod 256): READ     0x58c0e thru 0x753d6	(0x1c7c9 bytes)	***RRRR***
6215982( 46 mod 256): PUNCH    0x181bf thru 0x2a2f7	(0x12139 bytes)
6215983( 47 mod 256): MAPREAD  0x48e48 thru 0x50f6c	(0x8125 bytes)
6215984( 48 mod 256): MAPREAD  0x280ca thru 0x3a98c	(0x128c3 bytes)
6215985( 49 mod 256): READ     0x57169 thru 0x5c3dc	(0x5274 bytes)
6215986( 50 mod 256): FALLOC   0x18aa0 thru 0x30faf	(0x1850f bytes) INTERIOR
6215987( 51 mod 256): CLONE 0x9000 thru 0xefff	(0x6000 bytes) to 0x35000 thru 0x3afff
6215988( 52 mod 256): READ     0x81729 thru 0x82e06	(0x16de bytes)
6215989( 53 mod 256): COLLAPSE 0x1000 thru 0x2fff	(0x2000 bytes)
6215990( 54 mod 256): DEDUPE 0x74000 thru 0x79fff	(0x6000 bytes) to 0x5b000 thru 0x60fff
6215991( 55 mod 256): WRITE    0x65327 thru 0x67d7c	(0x2a56 bytes)
6215992( 56 mod 256): CLONE 0x64000 thru 0x6ffff	(0xc000 bytes) to 0xc000 thru 0x17fff	JJJJ******
6215993( 57 mod 256): FALLOC   0x5aa3b thru 0x6e961	(0x13f26 bytes) INTERIOR
6215994( 58 mod 256): MAPREAD  0x2b4ba thru 0x464f8	(0x1b03f bytes)
6215995( 59 mod 256): COPY 0x53307 thru 0x6f108	(0x1be02 bytes) to 0x20481 thru 0x3c282	EEEE******
6215996( 60 mod 256): WRITE    0x3b1b2 thru 0x43b43	(0x8992 bytes)
6215997( 61 mod 256): COPY 0x47c6 thru 0x19242	(0x14a7d bytes) to 0x2e856 thru 0x432d2
6215998( 62 mod 256): WRITE    0x132e8 thru 0x23406	(0x1011f bytes)
6215999( 63 mod 256): MAPWRITE 0x17380 thru 0x34fca	(0x1dc4b bytes)
6216000( 64 mod 256): COLLAPSE 0x45000 thru 0x5cfff	(0x18000 bytes)
6216001( 65 mod 256): MAPREAD  0x625ba thru 0x63830	(0x1277 bytes)
6216002( 66 mod 256): SKIPPED (no operation)
6216003( 67 mod 256): SKIPPED (no operation)
6216004( 68 mod 256): DEDUPE 0x56000 thru 0x5bfff	(0x6000 bytes) to 0x4e000 thru 0x53fff
6216005( 69 mod 256): MAPWRITE 0x68a1d thru 0x7c4d2	(0x13ab6 bytes)	******WWWW
6216006( 70 mod 256): READ     0x3bd0 thru 0x1acae	(0x170df bytes)
6216007( 71 mod 256): PUNCH    0x2e71a thru 0x45fce	(0x178b5 bytes)
6216008( 72 mod 256): MAPREAD  0x1461a thru 0x1b073	(0x6a5a bytes)
6216009( 73 mod 256): COPY 0x11c88 thru 0x2bccf	(0x1a048 bytes) to 0x66a39 thru 0x80a80	******EEEE
6216010( 74 mod 256): ZERO     0x4248d thru 0x5e885	(0x1c3f9 bytes)
6216011( 75 mod 256): READ     0x902b thru 0xbe46	(0x2e1c bytes)
6216012( 76 mod 256): WRITE    0xa72 thru 0x1de26	(0x1d3b5 bytes)
6216013( 77 mod 256): MAPWRITE 0x4ac5d thru 0x61ddd	(0x17181 bytes)
6216014( 78 mod 256): ZERO     0x10407 thru 0x104d5	(0xcf bytes)
6216015( 79 mod 256): ZERO     0x4a25e thru 0x62dc0	(0x18b63 bytes)
6216016( 80 mod 256): DEDUPE 0x15000 thru 0x2cfff	(0x18000 bytes) to 0x39000 thru 0x50fff
6216017( 81 mod 256): MAPREAD  0x64d76 thru 0x79202	(0x1448d bytes)	***RRRR***
6216018( 82 mod 256): ZERO     0x1bd71 thru 0x1e244	(0x24d4 bytes)
6216019( 83 mod 256): DEDUPE 0x2f000 thru 0x3dfff	(0xf000 bytes) to 0x45000 thru 0x53fff
6216020( 84 mod 256): COLLAPSE 0x63000 thru 0x69fff	(0x7000 bytes)
6216021( 85 mod 256): COLLAPSE 0x59000 thru 0x72fff	(0x1a000 bytes)	******CCCC
6216022( 86 mod 256): COLLAPSE 0x1c000 thru 0x32fff	(0x17000 bytes)
6216023( 87 mod 256): PUNCH    0xddbd thru 0x29ff1	(0x1c235 bytes)
6216024( 88 mod 256): CLONE 0x4000 thru 0x11fff	(0xe000 bytes) to 0x25000 thru 0x32fff
6216025( 89 mod 256): INSERT 0x46000 thru 0x4dfff	(0x8000 bytes)
6216026( 90 mod 256): SKIPPED (no operation)
6216027( 91 mod 256): INSERT 0xd000 thru 0x25fff	(0x19000 bytes)
6216028( 92 mod 256): PUNCH    0xccc6 thru 0xff0e	(0x3249 bytes)
6216029( 93 mod 256): DEDUPE 0x26000 thru 0x2bfff	(0x6000 bytes) to 0x2d000 thru 0x32fff
6216030( 94 mod 256): MAPREAD  0x23e87 thru 0x363e1	(0x1255b bytes)
6216031( 95 mod 256): READ     0x1c14e thru 0x2eb65	(0x12a18 bytes)
6216032( 96 mod 256): WRITE    0x1e0e7 thru 0x2b4df	(0xd3f9 bytes)
6216033( 97 mod 256): WRITE    0x5fe85 thru 0x76aa7	(0x16c23 bytes) EXTEND	***WWWW
6216034( 98 mod 256): PUNCH    0x19a87 thru 0x2a4cd	(0x10a47 bytes)
6216035( 99 mod 256): DEDUPE 0x22000 thru 0x32fff	(0x11000 bytes) to 0x36000 thru 0x46fff
6216036(100 mod 256): PUNCH    0x1dcfe thru 0x2b95d	(0xdc60 bytes)
6216037(101 mod 256): ZERO     0x6c184 thru 0x79b76	(0xd9f3 bytes)	******ZZZZ
6216038(102 mod 256): TRUNCATE DOWN	from 0x79b77 to 0x923f	******WWWW
6216039(103 mod 256): SKIPPED (no operation)
6216040(104 mod 256): SKIPPED (no operation)
6216041(105 mod 256): MAPWRITE 0x8eb0c thru 0x927bf	(0x3cb4 bytes)
6216042(106 mod 256): MAPREAD  0x45697 thru 0x4f09b	(0x9a05 bytes)
6216043(107 mod 256): WRITE    0x7d4e5 thru 0x927bf	(0x152db bytes)
6216044(108 mod 256): COPY 0x88741 thru 0x927bf	(0xa07f bytes) to 0x5e70f thru 0x6878d
6216045(109 mod 256): READ     0x55b6e thru 0x61b1f	(0xbfb2 bytes)
6216046(110 mod 256): MAPREAD  0xdc1e thru 0x122b6	(0x4699 bytes)
6216047(111 mod 256): READ     0x33b17 thru 0x4787f	(0x13d69 bytes)
6216048(112 mod 256): FALLOC   0x6f2b5 thru 0x6f93e	(0x689 bytes) INTERIOR
6216049(113 mod 256): WRITE    0x826a2 thru 0x88f74	(0x68d3 bytes)
6216050(114 mod 256): DEDUPE 0x76000 thru 0x90fff	(0x1b000 bytes) to 0x41000 thru 0x5bfff
6216051(115 mod 256): SKIPPED (no operation)
6216052(116 mod 256): COLLAPSE 0x6c000 thru 0x84fff	(0x19000 bytes)	******CCCC
6216053(117 mod 256): ZERO     0x259de thru 0x38e52	(0x13475 bytes)
6216054(118 mod 256): ZERO     0x83265 thru 0x927bf	(0xf55b bytes)
6216055(119 mod 256): WRITE    0x8938a thru 0x90c33	(0x78aa bytes) HOLE
6216056(120 mod 256): COLLAPSE 0x12000 thru 0x1afff	(0x9000 bytes)
6216057(121 mod 256): INSERT 0x1c000 thru 0x25fff	(0xa000 bytes)
6216058(122 mod 256): SKIPPED (no operation)
6216059(123 mod 256): MAPWRITE 0x55201 thru 0x6ff50	(0x1ad50 bytes)	******WWWW
6216060(124 mod 256): ZERO     0x23211 thru 0x2428a	(0x107a bytes)
6216061(125 mod 256): PUNCH    0x89058 thru 0x91c33	(0x8bdc bytes)
6216062(126 mod 256): SKIPPED (no operation)
6216063(127 mod 256): DEDUPE 0x84000 thru 0x90fff	(0xd000 bytes) to 0x3000 thru 0xffff
6216064(128 mod 256): ZERO     0x5d889 thru 0x70db3	(0x1352b bytes)	******ZZZZ
6216065(129 mod 256): CLONE 0x66000 thru 0x6ffff	(0xa000 bytes) to 0x73000 thru 0x7cfff	JJJJ******
6216066(130 mod 256): FALLOC   0x41351 thru 0x4c3b6	(0xb065 bytes) INTERIOR
6216067(131 mod 256): MAPREAD  0xfcaf thru 0x2b4dd	(0x1b82f bytes)
6216068(132 mod 256): WRITE    0x4b49d thru 0x6732e	(0x1be92 bytes)
6216069(133 mod 256): READ     0x3bc87 thru 0x520ce	(0x16448 bytes)
6216070(134 mod 256): PUNCH    0x71620 thru 0x90541	(0x1ef22 bytes)
6216071(135 mod 256): SKIPPED (no operation)
6216072(136 mod 256): ZERO     0x840f7 thru 0x927bf	(0xe6c9 bytes)
6216073(137 mod 256): PUNCH    0x33c7b thru 0x3e500	(0xa886 bytes)
6216074(138 mod 256): COLLAPSE 0x25000 thru 0x37fff	(0x13000 bytes)
6216075(139 mod 256): SKIPPED (no operation)
6216076(140 mod 256): TRUNCATE DOWN	from 0x7ec34 to 0x73c06
6216077(141 mod 256): ZERO     0x7347c thru 0x8e664	(0x1b1e9 bytes)
6216078(142 mod 256): ZERO     0x5f386 thru 0x753c3	(0x1603e bytes)	******ZZZZ
6216079(143 mod 256): COLLAPSE 0x1a000 thru 0x20fff	(0x7000 bytes)
6216080(144 mod 256): MAPREAD  0x12bda thru 0x144f8	(0x191f bytes)
6216081(145 mod 256): READ     0x4a5c9 thru 0x68c5c	(0x1e694 bytes)
6216082(146 mod 256): PUNCH    0x5de6e thru 0x63953	(0x5ae6 bytes)
6216083(147 mod 256): MAPREAD  0x6af1e thru 0x6e3c3	(0x34a6 bytes)
6216084(148 mod 256): INSERT 0x15000 thru 0x2dfff	(0x19000 bytes)
6216085(149 mod 256): DEDUPE 0x27000 thru 0x2efff	(0x8000 bytes) to 0x52000 thru 0x59fff
6216086(150 mod 256): SKIPPED (no operation)
6216087(151 mod 256): COPY 0x27530 thru 0x29d30	(0x2801 bytes) to 0x59528 thru 0x5bd28
6216088(152 mod 256): MAPREAD  0x58c3b thru 0x6c145	(0x1350b bytes)
6216089(153 mod 256): WRITE    0x35ab8 thru 0x3fef8	(0xa441 bytes)
6216090(154 mod 256): SKIPPED (no operation)
6216091(155 mod 256): COPY 0x6e9db thru 0x873c3	(0x189e9 bytes) to 0x394d6 thru 0x51ebe	EEEE******
6216092(156 mod 256): WRITE    0x8961b thru 0x927bf	(0x91a5 bytes) HOLE
6216093(157 mod 256): CLONE 0x33000 thru 0x3efff	(0xc000 bytes) to 0x75000 thru 0x80fff
6216094(158 mod 256): FALLOC   0x29a7c thru 0x3c1d3	(0x12757 bytes) INTERIOR
6216095(159 mod 256): SKIPPED (no operation)
6216096(160 mod 256): SKIPPED (no operation)
6216097(161 mod 256): PUNCH    0x427bf thru 0x5e72e	(0x1bf70 bytes)
6216098(162 mod 256): DEDUPE 0x5c000 thru 0x6afff	(0xf000 bytes) to 0x2f000 thru 0x3dfff
6216099(163 mod 256): MAPWRITE 0x65dd8 thru 0x84735	(0x1e95e bytes)	******WWWW
6216100(164 mod 256): MAPREAD  0x9e57 thru 0x19182	(0xf32c bytes)
6216101(165 mod 256): FALLOC   0x36185 thru 0x4653e	(0x103b9 bytes) INTERIOR
6216102(166 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x72f89
6216103(167 mod 256): TRUNCATE DOWN	from 0x72f89 to 0x3ef73	******WWWW
6216104(168 mod 256): ZERO     0x3a1ed thru 0x58197	(0x1dfab bytes)
6216105(169 mod 256): MAPREAD  0x38757 thru 0x3ca44	(0x42ee bytes)
6216106(170 mod 256): READ     0x4f7b thru 0xb4e3	(0x6569 bytes)
6216107(171 mod 256): ZERO     0x53a2a thru 0x6f71f	(0x1bcf6 bytes)	******ZZZZ
6216108(172 mod 256): TRUNCATE DOWN	from 0x6f720 to 0x38a82	******WWWW
6216109(173 mod 256): CLONE 0x23000 thru 0x25fff	(0x3000 bytes) to 0x7f000 thru 0x81fff
6216110(174 mod 256): COLLAPSE 0x2f000 thru 0x3cfff	(0xe000 bytes)
6216111(175 mod 256): ZERO     0x47a3e thru 0x59b35	(0x120f8 bytes)
6216112(176 mod 256): ZERO     0xb165 thru 0x247df	(0x1967b bytes)
6216113(177 mod 256): FALLOC   0x2e81a thru 0x3f977	(0x1115d bytes) INTERIOR
6216114(178 mod 256): MAPREAD  0x1f5b2 thru 0x21296	(0x1ce5 bytes)
6216115(179 mod 256): INSERT 0x6a000 thru 0x84fff	(0x1b000 bytes)	******IIII
6216116(180 mod 256): ZERO     0x6d762 thru 0x713f4	(0x3c93 bytes)	******ZZZZ
6216117(181 mod 256): MAPREAD  0x27673 thru 0x3a6b7	(0x13045 bytes)
6216118(182 mod 256): COPY 0x7a288 thru 0x8a688	(0x10401 bytes) to 0xccef thru 0x1d0ef
6216119(183 mod 256): TRUNCATE DOWN	from 0x8f000 to 0x25e44	******WWWW
6216120(184 mod 256): COLLAPSE 0x8000 thru 0x1efff	(0x17000 bytes)
6216121(185 mod 256): PUNCH    0xda9f thru 0xee43	(0x13a5 bytes)
6216122(186 mod 256): SKIPPED (no operation)
6216123(187 mod 256): TRUNCATE UP	from 0xee44 to 0x8906e	******WWWW
6216124(188 mod 256): ZERO     0x4a4ab thru 0x5eb99	(0x146ef bytes)
6216125(189 mod 256): WRITE    0x336e2 thru 0x3fcec	(0xc60b bytes)
6216126(190 mod 256): TRUNCATE DOWN	from 0x8906e to 0x3d2b5	******WWWW
6216127(191 mod 256): COLLAPSE 0x0 thru 0xfff	(0x1000 bytes)
6216128(192 mod 256): WRITE    0x90a1e thru 0x927bf	(0x1da2 bytes) HOLE	***WWWW
6216129(193 mod 256): WRITE    0x1f2cb thru 0x3443d	(0x15173 bytes)
6216130(194 mod 256): DEDUPE 0x38000 thru 0x4afff	(0x13000 bytes) to 0xe000 thru 0x20fff
6216131(195 mod 256): MAPREAD  0x6c89c thru 0x6e09e	(0x1803 bytes)
6216132(196 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1b3d0	******WWWW
6216133(197 mod 256): WRITE    0x51f09 thru 0x6d115	(0x1b20d bytes) HOLE
6216134(198 mod 256): CLONE 0x6000 thru 0xdfff	(0x8000 bytes) to 0x38000 thru 0x3ffff
6216135(199 mod 256): DEDUPE 0x41000 thru 0x51fff	(0x11000 bytes) to 0x59000 thru 0x69fff
6216136(200 mod 256): ZERO     0x41591 thru 0x535c0	(0x12030 bytes)
6216137(201 mod 256): CLONE 0x20000 thru 0x37fff	(0x18000 bytes) to 0x4e000 thru 0x65fff
6216138(202 mod 256): DEDUPE 0x26000 thru 0x29fff	(0x4000 bytes) to 0xb000 thru 0xefff
6216139(203 mod 256): CLONE 0x2000 thru 0x1afff	(0x19000 bytes) to 0x26000 thru 0x3efff
6216140(204 mod 256): TRUNCATE UP	from 0x6d116 to 0x7ef77	******WWWW
6216141(205 mod 256): PUNCH    0x670bb thru 0x686c1	(0x1607 bytes)
6216142(206 mod 256): SKIPPED (no operation)
6216143(207 mod 256): WRITE    0x1e48 thru 0x131ba	(0x11373 bytes)
6216144(208 mod 256): MAPREAD  0x3a371 thru 0x58a34	(0x1e6c4 bytes)
6216145(209 mod 256): TRUNCATE DOWN	from 0x7ef77 to 0x3d05a	******WWWW
6216146(210 mod 256): SKIPPED (no operation)
6216147(211 mod 256): INSERT 0x15000 thru 0x27fff	(0x13000 bytes)
6216148(212 mod 256): CLONE 0x4e000 thru 0x4efff	(0x1000 bytes) to 0x44000 thru 0x44fff
6216149(213 mod 256): TRUNCATE DOWN	from 0x5005a to 0x4f61b
6216150(214 mod 256): FALLOC   0x19a1e thru 0x1bf80	(0x2562 bytes) INTERIOR
6216151(215 mod 256): WRITE    0x170a9 thru 0x1ac4e	(0x3ba6 bytes)
6216152(216 mod 256): DEDUPE 0x34000 thru 0x3efff	(0xb000 bytes) to 0x1b000 thru 0x25fff
6216153(217 mod 256): READ     0x4096a thru 0x4f61a	(0xecb1 bytes)
6216154(218 mod 256): READ     0x1eb17 thru 0x22e28	(0x4312 bytes)
6216155(219 mod 256): COLLAPSE 0x24000 thru 0x2dfff	(0xa000 bytes)
6216156(220 mod 256): SKIPPED (no operation)
6216157(221 mod 256): PUNCH    0xf890 thru 0x187f9	(0x8f6a bytes)
6216158(222 mod 256): PUNCH    0xf415 thru 0x241e2	(0x14dce bytes)
6216159(223 mod 256): DEDUPE 0x23000 thru 0x2bfff	(0x9000 bytes) to 0x7000 thru 0xffff
6216160(224 mod 256): PUNCH    0x392f4 thru 0x40e68	(0x7b75 bytes)
6216161(225 mod 256): MAPWRITE 0x6f99d thru 0x74461	(0x4ac5 bytes)
6216162(226 mod 256): ZERO     0x7ff80 thru 0x927bf	(0x12840 bytes)
6216163(227 mod 256): TRUNCATE DOWN	from 0x74462 to 0x693ac	******WWWW
6216164(228 mod 256): COLLAPSE 0x31000 thru 0x37fff	(0x7000 bytes)
6216165(229 mod 256): INSERT 0x16000 thru 0x30fff	(0x1b000 bytes)
6216166(230 mod 256): FALLOC   0x3bdfb thru 0x4e67e	(0x12883 bytes) INTERIOR
6216167(231 mod 256): READ     0x5776d thru 0x6410b	(0xc99f bytes)
6216168(232 mod 256): DEDUPE 0x47000 thru 0x64fff	(0x1e000 bytes) to 0x6000 thru 0x23fff
6216169(233 mod 256): SKIPPED (no operation)
6216170(234 mod 256): READ     0x3fb79 thru 0x54a4d	(0x14ed5 bytes)
6216171(235 mod 256): FALLOC   0x656b9 thru 0x769f3	(0x1133a bytes) INTERIOR	******FFFF
6216172(236 mod 256): SKIPPED (no operation)
6216173(237 mod 256): MAPREAD  0x78482 thru 0x7d3ab	(0x4f2a bytes)
6216174(238 mod 256): WRITE    0xdfe6 thru 0x18528	(0xa543 bytes)
6216175(239 mod 256): SKIPPED (no operation)
6216176(240 mod 256): TRUNCATE DOWN	from 0x7d3ac to 0x49162	******WWWW
6216177(241 mod 256): MAPREAD  0x32938 thru 0x3f58c	(0xcc55 bytes)
6216178(242 mod 256): READ     0x2f11e thru 0x39626	(0xa509 bytes)
6216179(243 mod 256): PUNCH    0x220d7 thru 0x2446d	(0x2397 bytes)
6216180(244 mod 256): TRUNCATE UP	from 0x49162 to 0x59d52
6216181(245 mod 256): SKIPPED (no operation)
6216182(246 mod 256): READ     0x3017b thru 0x334bf	(0x3345 bytes)
6216183(247 mod 256): WRITE    0x15adb thru 0x1f4fe	(0x9a24 bytes)
6216184(248 mod 256): SKIPPED (no operation)
6216185(249 mod 256): MAPWRITE 0x22fb7 thru 0x2e993	(0xb9dd bytes)
6216186(250 mod 256): READ     0x27455 thru 0x2828f	(0xe3b bytes)
6216187(251 mod 256): WRITE    0x81450 thru 0x8f19f	(0xdd50 bytes) HOLE	***WWWW
6216188(252 mod 256): TRUNCATE DOWN	from 0x8f1a0 to 0x6ac82	******WWWW
6216189(253 mod 256): MAPWRITE 0x44c9 thru 0xfb9b	(0xb6d3 bytes)
6216190(254 mod 256): READ     0xfdaa thru 0x17734	(0x798b bytes)
6216191(255 mod 256): DEDUPE 0x2a000 thru 0x2afff	(0x1000 bytes) to 0x5000 thru 0x5fff
6216192(  0 mod 256): SKIPPED (no operation)
6216193(  1 mod 256): READ     0x451d2 thru 0x4e4e4	(0x9313 bytes)
6216194(  2 mod 256): COLLAPSE 0x33000 thru 0x4ffff	(0x1d000 bytes)
6216195(  3 mod 256): WRITE    0x15ad7 thru 0x24fb8	(0xf4e2 bytes)
6216196(  4 mod 256): MAPREAD  0x9fce thru 0x22e4c	(0x18e7f bytes)
6216197(  5 mod 256): INSERT 0x3c000 thru 0x43fff	(0x8000 bytes)
6216198(  6 mod 256): ZERO     0x511e5 thru 0x54e59	(0x3c75 bytes)
6216199(  7 mod 256): MAPWRITE 0x18c36 thru 0x247b4	(0xbb7f bytes)
6216200(  8 mod 256): WRITE    0x40330 thru 0x4107f	(0xd50 bytes)
6216201(  9 mod 256): ZERO     0x38220 thru 0x38ba4	(0x985 bytes)
6216202( 10 mod 256): MAPREAD  0x3eb8a thru 0x55c81	(0x170f8 bytes)
6216203( 11 mod 256): READ     0xdaf thru 0x24e2	(0x1734 bytes)
6216204( 12 mod 256): FALLOC   0xe3d9 thru 0x105ca	(0x21f1 bytes) INTERIOR
6216205( 13 mod 256): ZERO     0x718f4 thru 0x76218	(0x4925 bytes)
6216206( 14 mod 256): MAPREAD  0x5c389 thru 0x63a0c	(0x7684 bytes)
6216207( 15 mod 256): PUNCH    0x4b807 thru 0x6669e	(0x1ae98 bytes)
6216208( 16 mod 256): INSERT 0x67000 thru 0x81fff	(0x1b000 bytes)	******IIII
6216209( 17 mod 256): SKIPPED (no operation)
6216210( 18 mod 256): MAPREAD  0x8c3c1 thru 0x91218	(0x4e58 bytes)
6216211( 19 mod 256): SKIPPED (no operation)
6216212( 20 mod 256): CLONE 0x8d000 thru 0x8ffff	(0x3000 bytes) to 0x5000 thru 0x7fff
6216213( 21 mod 256): CLONE 0x1e000 thru 0x31fff	(0x14000 bytes) to 0x5f000 thru 0x72fff	******JJJJ
6216214( 22 mod 256): MAPREAD  0x781e6 thru 0x89241	(0x1105c bytes)
6216215( 23 mod 256): READ     0x242da thru 0x37197	(0x12ebe bytes)
6216216( 24 mod 256): PUNCH    0x7d977 thru 0x7ef32	(0x15bc bytes)
6216217( 25 mod 256): MAPWRITE 0x37c9f thru 0x37d29	(0x8b bytes)
6216218( 26 mod 256): DEDUPE 0x5f000 thru 0x79fff	(0x1b000 bytes) to 0x2e000 thru 0x48fff	BBBB******
6216219( 27 mod 256): CLONE 0x3e000 thru 0x4cfff	(0xf000 bytes) to 0x5a000 thru 0x68fff
6216220( 28 mod 256): COLLAPSE 0x39000 thru 0x3afff	(0x2000 bytes)
6216221( 29 mod 256): WRITE    0x23d01 thru 0x36114	(0x12414 bytes)
6216222( 30 mod 256): DEDUPE 0x2b000 thru 0x44fff	(0x1a000 bytes) to 0x4e000 thru 0x67fff
6216223( 31 mod 256): ZERO     0x29a58 thru 0x33f51	(0xa4fa bytes)
6216224( 32 mod 256): INSERT 0x29000 thru 0x2bfff	(0x3000 bytes)
6216225( 33 mod 256): WRITE    0x2e78e thru 0x35c96	(0x7509 bytes)
6216226( 34 mod 256): MAPWRITE 0x82d53 thru 0x927bf	(0xfa6d bytes)
6216227( 35 mod 256): PUNCH    0xc378 thru 0x1546c	(0x90f5 bytes)
6216228( 36 mod 256): PUNCH    0x353a thru 0x1dc7b	(0x1a742 bytes)
6216229( 37 mod 256): COLLAPSE 0x13000 thru 0x1bfff	(0x9000 bytes)
6216230( 38 mod 256): WRITE    0x7f80b thru 0x927bf	(0x12fb5 bytes) EXTEND
6216231( 39 mod 256): WRITE    0x83320 thru 0x862bc	(0x2f9d bytes)
6216232( 40 mod 256): DEDUPE 0x1e000 thru 0x33fff	(0x16000 bytes) to 0x56000 thru 0x6bfff
6216233( 41 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x24761	******WWWW
6216234( 42 mod 256): FALLOC   0x17a9d thru 0x21fb3	(0xa516 bytes) INTERIOR
6216235( 43 mod 256): SKIPPED (no operation)
6216236( 44 mod 256): WRITE    0x44943 thru 0x530d7	(0xe795 bytes) HOLE
6216237( 45 mod 256): MAPWRITE 0x186d2 thru 0x2373c	(0xb06b bytes)
6216238( 46 mod 256): TRUNCATE UP	from 0x530d8 to 0x5ed78
6216239( 47 mod 256): WRITE    0x8c4b7 thru 0x927bf	(0x6309 bytes) HOLE	***WWWW
6216240( 48 mod 256): DEDUPE 0x5d000 thru 0x69fff	(0xd000 bytes) to 0x21000 thru 0x2dfff
6216241( 49 mod 256): COPY 0x7f2fc thru 0x927bf	(0x134c4 bytes) to 0x6ab39 thru 0x7dffc	******EEEE
6216242( 50 mod 256): SKIPPED (no operation)
6216243( 51 mod 256): ZERO     0x26c5b thru 0x2abe0	(0x3f86 bytes)
6216244( 52 mod 256): READ     0x7cfef thru 0x927bf	(0x157d1 bytes)
6216245( 53 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xde85	******WWWW
6216246( 54 mod 256): SKIPPED (no operation)
6216247( 55 mod 256): FALLOC   0x23e39 thru 0x275ed	(0x37b4 bytes) EXTENDING
6216248( 56 mod 256): TRUNCATE UP	from 0x275ed to 0x2c12e
6216249( 57 mod 256): SKIPPED (no operation)
6216250( 58 mod 256): ZERO     0x2f234 thru 0x3667b	(0x7448 bytes)
6216251( 59 mod 256): ZERO     0x4b6de thru 0x67151	(0x1ba74 bytes)
6216252( 60 mod 256): COLLAPSE 0x15000 thru 0x1bfff	(0x7000 bytes)
6216253( 61 mod 256): CLONE 0x7000 thru 0x23fff	(0x1d000 bytes) to 0x3a000 thru 0x56fff
6216254( 62 mod 256): TRUNCATE DOWN	from 0x57000 to 0x9575
6216255( 63 mod 256): WRITE    0x7d9df thru 0x8e7ed	(0x10e0f bytes) HOLE	***WWWW
6216256( 64 mod 256): INSERT 0x6a000 thru 0x6cfff	(0x3000 bytes)
6216257( 65 mod 256): COPY 0x37022 thru 0x4c1d8	(0x151b7 bytes) to 0x132c4 thru 0x2847a
6216258( 66 mod 256): SKIPPED (no operation)
6216259( 67 mod 256): FALLOC   0x5e1d8 thru 0x75768	(0x17590 bytes) INTERIOR	******FFFF
6216260( 68 mod 256): WRITE    0x2c460 thru 0x41aab	(0x1564c bytes)
6216261( 69 mod 256): WRITE    0x131c2 thru 0x2ef34	(0x1bd73 bytes)
6216262( 70 mod 256): COLLAPSE 0x23000 thru 0x37fff	(0x15000 bytes)
6216263( 71 mod 256): COPY 0x7b272 thru 0x7c7ed	(0x157c bytes) to 0x142d0 thru 0x1584b
6216264( 72 mod 256): MAPWRITE 0x741fc thru 0x88c62	(0x14a67 bytes)
6216265( 73 mod 256): PUNCH    0x6c76c thru 0x8103c	(0x148d1 bytes)	******PPPP
6216266( 74 mod 256): MAPWRITE 0x6173d thru 0x6ec61	(0xd525 bytes)
6216267( 75 mod 256): READ     0x78202 thru 0x88c62	(0x10a61 bytes)
6216268( 76 mod 256): DEDUPE 0x2d000 thru 0x32fff	(0x6000 bytes) to 0x4b000 thru 0x50fff
6216269( 77 mod 256): COLLAPSE 0x11000 thru 0x1afff	(0xa000 bytes)
6216270( 78 mod 256): DEDUPE 0x25000 thru 0x25fff	(0x1000 bytes) to 0x4a000 thru 0x4afff
6216271( 79 mod 256): SKIPPED (no operation)
6216272( 80 mod 256): MAPREAD  0x5289f thru 0x6165a	(0xedbc bytes)
6216273( 81 mod 256): TRUNCATE DOWN	from 0x7ec63 to 0x15677	******WWWW
6216274( 82 mod 256): TRUNCATE UP	from 0x15677 to 0x8aed4	******WWWW
6216275( 83 mod 256): FALLOC   0x22196 thru 0x243d5	(0x223f bytes) INTERIOR
6216276( 84 mod 256): READ     0x1900a thru 0x27ecf	(0xeec6 bytes)
6216277( 85 mod 256): DEDUPE 0x19000 thru 0x1ffff	(0x7000 bytes) to 0x29000 thru 0x2ffff
6216278( 86 mod 256): DEDUPE 0x42000 thru 0x44fff	(0x3000 bytes) to 0x2e000 thru 0x30fff
6216279( 87 mod 256): CLONE 0x4b000 thru 0x4bfff	(0x1000 bytes) to 0x34000 thru 0x34fff
6216280( 88 mod 256): DEDUPE 0x4a000 thru 0x62fff	(0x19000 bytes) to 0x6a000 thru 0x82fff	******BBBB
6216281( 89 mod 256): CLONE 0xd000 thru 0x14fff	(0x8000 bytes) to 0x7a000 thru 0x81fff
6216282( 90 mod 256): SKIPPED (no operation)
6216283( 91 mod 256): SKIPPED (no operation)
6216284( 92 mod 256): INSERT 0x63000 thru 0x69fff	(0x7000 bytes)
6216285( 93 mod 256): READ     0x1ca62 thru 0x2879c	(0xbd3b bytes)
6216286( 94 mod 256): SKIPPED (no operation)
6216287( 95 mod 256): PUNCH    0x444dd thru 0x472f9	(0x2e1d bytes)
6216288( 96 mod 256): COPY 0x4a42e thru 0x4da5a	(0x362d bytes) to 0x2189 thru 0x57b5
6216289( 97 mod 256): FALLOC   0x911bc thru 0x927c0	(0x1604 bytes) PAST_EOF
6216290( 98 mod 256): ZERO     0x3461e thru 0x521da	(0x1dbbd bytes)
6216291( 99 mod 256): MAPREAD  0x887b3 thru 0x91ed3	(0x9721 bytes)
6216292(100 mod 256): MAPREAD  0x4f3a thru 0x105c1	(0xb688 bytes)
6216293(101 mod 256): FALLOC   0x91918 thru 0x927c0	(0xea8 bytes) EXTENDING
6216294(102 mod 256): COLLAPSE 0x65000 thru 0x70fff	(0xc000 bytes)	******CCCC
6216295(103 mod 256): WRITE    0x7bf8d thru 0x927bf	(0x16833 bytes) EXTEND
6216296(104 mod 256): WRITE    0x84268 thru 0x927bf	(0xe558 bytes)
6216297(105 mod 256): READ     0x8a2f6 thru 0x927bf	(0x84ca bytes)
6216298(106 mod 256): SKIPPED (no operation)
6216299(107 mod 256): MAPREAD  0x49189 thru 0x5f476	(0x162ee bytes)
6216300(108 mod 256): DEDUPE 0x42000 thru 0x53fff	(0x12000 bytes) to 0x30000 thru 0x41fff
6216301(109 mod 256): MAPWRITE 0x6ef43 thru 0x7a946	(0xba04 bytes)	******WWWW
6216302(110 mod 256): SKIPPED (no operation)
6216303(111 mod 256): ZERO     0x45c86 thru 0x4d2f9	(0x7674 bytes)
6216304(112 mod 256): PUNCH    0x29246 thru 0x4689e	(0x1d659 bytes)
6216305(113 mod 256): COPY 0x1e198 thru 0x3a67a	(0x1c4e3 bytes) to 0x6c428 thru 0x8890a	******EEEE
6216306(114 mod 256): DEDUPE 0x32000 thru 0x3cfff	(0xb000 bytes) to 0x25000 thru 0x2ffff
6216307(115 mod 256): DEDUPE 0x2e000 thru 0x39fff	(0xc000 bytes) to 0x59000 thru 0x64fff
6216308(116 mod 256): SKIPPED (no operation)
6216309(117 mod 256): MAPWRITE 0x695f4 thru 0x787f3	(0xf200 bytes)	******WWWW
6216310(118 mod 256): SKIPPED (no operation)
6216311(119 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x7ab5	******WWWW
6216312(120 mod 256): MAPWRITE 0x31ad3 thru 0x3ff66	(0xe494 bytes)
6216313(121 mod 256): INSERT 0x2e000 thru 0x4bfff	(0x1e000 bytes)
6216314(122 mod 256): CLONE 0x17000 thru 0x24fff	(0xe000 bytes) to 0x39000 thru 0x46fff
6216315(123 mod 256): FALLOC   0x14eb5 thru 0x25e13	(0x10f5e bytes) INTERIOR
6216316(124 mod 256): MAPWRITE 0x5a09d thru 0x710f4	(0x17058 bytes)	******WWWW
6216317(125 mod 256): MAPWRITE 0x7f460 thru 0x8e65a	(0xf1fb bytes)
6216318(126 mod 256): WRITE    0x2518 thru 0x14e5a	(0x12943 bytes)
6216319(127 mod 256): DEDUPE 0x33000 thru 0x3bfff	(0x9000 bytes) to 0x23000 thru 0x2bfff
6216320(128 mod 256): READ     0x84b13 thru 0x85d77	(0x1265 bytes)
6216321(129 mod 256): SKIPPED (no operation)
6216322(130 mod 256): ZERO     0x4002e thru 0x5e554	(0x1e527 bytes)
6216323(131 mod 256): TRUNCATE DOWN	from 0x8e65b to 0x8cdbf
6216324(132 mod 256): COLLAPSE 0x43000 thru 0x4efff	(0xc000 bytes)
6216325(133 mod 256): FALLOC   0x4088e thru 0x4630e	(0x5a80 bytes) INTERIOR
6216326(134 mod 256): COLLAPSE 0x30000 thru 0x30fff	(0x1000 bytes)
6216327(135 mod 256): SKIPPED (no operation)
6216328(136 mod 256): SKIPPED (no operation)
6216329(137 mod 256): COPY 0x306ba thru 0x35ba2	(0x54e9 bytes) to 0x6ffa7 thru 0x7548f
6216330(138 mod 256): TRUNCATE DOWN	from 0x7fdbf to 0x1bd9c	******WWWW
6216331(139 mod 256): SKIPPED (no operation)
6216332(140 mod 256): COPY 0x18403 thru 0x1bd9b	(0x3999 bytes) to 0x241a5 thru 0x27b3d
6216333(141 mod 256): FALLOC   0x8cc0f thru 0x9186f	(0x4c60 bytes) PAST_EOF
6216334(142 mod 256): COLLAPSE 0x7000 thru 0x1afff	(0x14000 bytes)
6216335(143 mod 256): SKIPPED (no operation)
6216336(144 mod 256): TRUNCATE UP	from 0x13b3e to 0x46b13
6216337(145 mod 256): PUNCH    0x438b6 thru 0x46b12	(0x325d bytes)
6216338(146 mod 256): WRITE    0x3b48d thru 0x3ea00	(0x3574 bytes)
6216339(147 mod 256): ZERO     0x6c9a0 thru 0x87438	(0x1aa99 bytes)	******ZZZZ
6216340(148 mod 256): DEDUPE 0x2000 thru 0x13fff	(0x12000 bytes) to 0x31000 thru 0x42fff
6216341(149 mod 256): CLONE 0x3c000 thru 0x45fff	(0xa000 bytes) to 0x0 thru 0x9fff
6216342(150 mod 256): TRUNCATE DOWN	from 0x46b13 to 0x7f56
6216343(151 mod 256): FALLOC   0x58403 thru 0x74489	(0x1c086 bytes) EXTENDING	******FFFF
6216344(152 mod 256): PUNCH    0x2f50f thru 0x4a3da	(0x1aecc bytes)
6216345(153 mod 256): MAPREAD  0x27611 thru 0x38967	(0x11357 bytes)
6216346(154 mod 256): WRITE    0x384a6 thru 0x3bece	(0x3a29 bytes)
6216347(155 mod 256): INSERT 0xd000 thru 0x1dfff	(0x11000 bytes)
6216348(156 mod 256): READ     0x62daa thru 0x73b3b	(0x10d92 bytes)	***RRRR***
6216349(157 mod 256): PUNCH    0x652f0 thru 0x81cf2	(0x1ca03 bytes)	******PPPP
6216350(158 mod 256): FALLOC   0x14b3e thru 0x29e88	(0x1534a bytes) INTERIOR
6216351(159 mod 256): ZERO     0x524aa thru 0x6a97a	(0x184d1 bytes)
6216352(160 mod 256): TRUNCATE DOWN	from 0x85489 to 0x59751	******WWWW
6216353(161 mod 256): SKIPPED (no operation)
6216354(162 mod 256): INSERT 0x51000 thru 0x69fff	(0x19000 bytes)
6216355(163 mod 256): MAPWRITE 0x8bd24 thru 0x8feeb	(0x41c8 bytes)
6216356(164 mod 256): INSERT 0x89000 thru 0x8afff	(0x2000 bytes)
6216357(165 mod 256): PUNCH    0x4388c thru 0x45845	(0x1fba bytes)
6216358(166 mod 256): COPY 0x7cbcf thru 0x91eeb	(0x1531d bytes) to 0x29a75 thru 0x3ed91
6216359(167 mod 256): TRUNCATE DOWN	from 0x91eec to 0x83bd	******WWWW
6216360(168 mod 256): READ     0x6395 thru 0x83bc	(0x2028 bytes)
6216361(169 mod 256): READ     0x2f21 thru 0x83bc	(0x549c bytes)
6216362(170 mod 256): ZERO     0x87e6f thru 0x8d1da	(0x536c bytes)
6216363(171 mod 256): COLLAPSE 0x3000 thru 0x6fff	(0x4000 bytes)
6216364(172 mod 256): WRITE    0x67d64 thru 0x6ead1	(0x6d6e bytes) HOLE
6216365(173 mod 256): ZERO     0x794a3 thru 0x84a60	(0xb5be bytes)
6216366(174 mod 256): COLLAPSE 0x16000 thru 0x16fff	(0x1000 bytes)
6216367(175 mod 256): PUNCH    0x3e8d3 thru 0x460e1	(0x780f bytes)
6216368(176 mod 256): MAPREAD  0x1f6b7 thru 0x20093	(0x9dd bytes)
6216369(177 mod 256): COPY 0x13962 thru 0x1464c	(0xceb bytes) to 0x6f82d thru 0x70517
6216370(178 mod 256): MAPREAD  0x63716 thru 0x6548d	(0x1d78 bytes)
6216371(179 mod 256): COLLAPSE 0x66000 thru 0x6efff	(0x9000 bytes)	******CCCC
6216372(180 mod 256): FALLOC   0x4b0aa thru 0x63a67	(0x189bd bytes) INTERIOR
6216373(181 mod 256): READ     0x4ddbb thru 0x5afdf	(0xd225 bytes)
6216374(182 mod 256): WRITE    0x47d83 thru 0x55a5b	(0xdcd9 bytes)
6216375(183 mod 256): ZERO     0x8de thru 0x18446	(0x17b69 bytes)
6216376(184 mod 256): DEDUPE 0x48000 thru 0x4dfff	(0x6000 bytes) to 0x5f000 thru 0x64fff
6216377(185 mod 256): ZERO     0x198be thru 0x1b66b	(0x1dae bytes)
6216378(186 mod 256): COPY 0x57e50 thru 0x67517	(0xf6c8 bytes) to 0x25ba7 thru 0x3526e
6216379(187 mod 256): ZERO     0x5f942 thru 0x69f3c	(0xa5fb bytes)
6216380(188 mod 256): INSERT 0x36000 thru 0x49fff	(0x14000 bytes)
6216381(189 mod 256): WRITE    0x8d60 thru 0x14c2f	(0xbed0 bytes)
6216382(190 mod 256): WRITE    0x5bc41 thru 0x7440d	(0x187cd bytes)	***WWWW
6216383(191 mod 256): INSERT 0xa000 thru 0x10fff	(0x7000 bytes)
6216384(192 mod 256): COPY 0x4c115 thru 0x53ffa	(0x7ee6 bytes) to 0x2c01c thru 0x33f01
6216385(193 mod 256): COLLAPSE 0x37000 thru 0x42fff	(0xc000 bytes)
6216386(194 mod 256): FALLOC   0x246b6 thru 0x3a1a9	(0x15af3 bytes) INTERIOR
6216387(195 mod 256): ZERO     0x3ca3 thru 0x14750	(0x10aae bytes)
6216388(196 mod 256): ZERO     0x6c4b2 thru 0x75584	(0x90d3 bytes)	******ZZZZ
6216389(197 mod 256): WRITE    0x437b5 thru 0x6140e	(0x1dc5a bytes)
6216390(198 mod 256): MAPREAD  0x16027 thru 0x33016	(0x1cff0 bytes)
6216391(199 mod 256): TRUNCATE DOWN	from 0x76518 to 0x57017	******WWWW
6216392(200 mod 256): INSERT 0x4e000 thru 0x69fff	(0x1c000 bytes)
6216393(201 mod 256): READ     0x32557 thru 0x33210	(0xcba bytes)
6216394(202 mod 256): MAPREAD  0x67ddd thru 0x69770	(0x1994 bytes)
6216395(203 mod 256): PUNCH    0x53077 thru 0x58250	(0x51da bytes)
6216396(204 mod 256): MAPREAD  0x3a700 thru 0x490fb	(0xe9fc bytes)
6216397(205 mod 256): FALLOC   0x33096 thru 0x34857	(0x17c1 bytes) INTERIOR
6216398(206 mod 256): INSERT 0x2f000 thru 0x4bfff	(0x1d000 bytes)
6216399(207 mod 256): ZERO     0x2df0f thru 0x37ee3	(0x9fd5 bytes)
6216400(208 mod 256): SKIPPED (no operation)
6216401(209 mod 256): FALLOC   0x49195 thru 0x5ba19	(0x12884 bytes) INTERIOR
6216402(210 mod 256): SKIPPED (no operation)
6216403(211 mod 256): READ     0x2eb43 thru 0x3b190	(0xc64e bytes)
6216404(212 mod 256): PUNCH    0x58eb1 thru 0x6d75b	(0x148ab bytes)
6216405(213 mod 256): MAPWRITE 0x888b5 thru 0x927bf	(0x9f0b bytes)
6216406(214 mod 256): PUNCH    0x1c8c0 thru 0x37be4	(0x1b325 bytes)
6216407(215 mod 256): COLLAPSE 0x6d000 thru 0x82fff	(0x16000 bytes)	******CCCC
6216408(216 mod 256): COPY 0x3c272 thru 0x3fa9d	(0x382c bytes) to 0x58a95 thru 0x5c2c0
6216409(217 mod 256): PUNCH    0x2e3e1 thru 0x3b99b	(0xd5bb bytes)
6216410(218 mod 256): PUNCH    0x6735d thru 0x75f2c	(0xebd0 bytes)	******PPPP
6216411(219 mod 256): COLLAPSE 0xb000 thru 0xbfff	(0x1000 bytes)
6216412(220 mod 256): WRITE    0x6d23c thru 0x8875e	(0x1b523 bytes) EXTEND	***WWWW
6216413(221 mod 256): SKIPPED (no operation)
6216414(222 mod 256): COLLAPSE 0x61000 thru 0x65fff	(0x5000 bytes)
6216415(223 mod 256): FALLOC   0x6f0d3 thru 0x71efa	(0x2e27 bytes) INTERIOR
6216416(224 mod 256): INSERT 0x35000 thru 0x3cfff	(0x8000 bytes)
6216417(225 mod 256): COLLAPSE 0x25000 thru 0x31fff	(0xd000 bytes)
6216418(226 mod 256): READ     0x7d450 thru 0x7e75e	(0x130f bytes)
6216419(227 mod 256): SKIPPED (no operation)
6216420(228 mod 256): DEDUPE 0x59000 thru 0x5cfff	(0x4000 bytes) to 0x2e000 thru 0x31fff
6216421(229 mod 256): READ     0x47794 thru 0x57e6e	(0x106db bytes)
6216422(230 mod 256): FALLOC   0x238e0 thru 0x3bb8b	(0x182ab bytes) INTERIOR
6216423(231 mod 256): SKIPPED (no operation)
6216424(232 mod 256): SKIPPED (no operation)
6216425(233 mod 256): COLLAPSE 0x50000 thru 0x59fff	(0xa000 bytes)
6216426(234 mod 256): INSERT 0x35000 thru 0x4ffff	(0x1b000 bytes)
6216427(235 mod 256): MAPWRITE 0x80b17 thru 0x87310	(0x67fa bytes)
6216428(236 mod 256): COLLAPSE 0x5f000 thru 0x7bfff	(0x1d000 bytes)	******CCCC
6216429(237 mod 256): WRITE    0x3990f thru 0x4c774	(0x12e66 bytes)
6216430(238 mod 256): PUNCH    0x432f8 thru 0x43804	(0x50d bytes)
6216431(239 mod 256): WRITE    0x74329 thru 0x74efc	(0xbd4 bytes) HOLE
6216432(240 mod 256): COLLAPSE 0x0 thru 0x3fff	(0x4000 bytes)
6216433(241 mod 256): COPY 0x495fd thru 0x5b267	(0x11c6b bytes) to 0x268fd thru 0x38567
6216434(242 mod 256): READ     0x3019a thru 0x437a0	(0x13607 bytes)
6216435(243 mod 256): MAPREAD  0x19dd4 thru 0x30d30	(0x16f5d bytes)
6216436(244 mod 256): FALLOC   0x32a88 thru 0x4ca6d	(0x19fe5 bytes) INTERIOR
6216437(245 mod 256): COPY 0x14cf thru 0x1dcf7	(0x1c829 bytes) to 0x46ba4 thru 0x633cc
6216438(246 mod 256): COPY 0x65a1c thru 0x70efc	(0xb4e1 bytes) to 0xbc86 thru 0x17166	EEEE******
6216439(247 mod 256): TRUNCATE DOWN	from 0x70efd to 0x3296e	******WWWW
6216440(248 mod 256): SKIPPED (no operation)
6216441(249 mod 256): WRITE    0x3fde1 thru 0x56fee	(0x1720e bytes) HOLE
6216442(250 mod 256): INSERT 0x2a000 thru 0x31fff	(0x8000 bytes)
6216443(251 mod 256): WRITE    0x35d6e thru 0x36b65	(0xdf8 bytes)
6216444(252 mod 256): MAPWRITE 0x8eea8 thru 0x927bf	(0x3918 bytes)
6216445(253 mod 256): DEDUPE 0x6a000 thru 0x75fff	(0xc000 bytes) to 0x5c000 thru 0x67fff	BBBB******
6216446(254 mod 256): WRITE    0x42f00 thru 0x4f6ee	(0xc7ef bytes)
6216447(255 mod 256): DEDUPE 0x46000 thru 0x54fff	(0xf000 bytes) to 0x28000 thru 0x36fff
6216448(  0 mod 256): DEDUPE 0x75000 thru 0x7cfff	(0x8000 bytes) to 0x22000 thru 0x29fff
6216449(  1 mod 256): COPY 0x57c44 thru 0x6a014	(0x123d1 bytes) to 0xb3e5 thru 0x1d7b5
6216450(  2 mod 256): PUNCH    0x125cc thru 0x23a0e	(0x11443 bytes)
6216451(  3 mod 256): PUNCH    0x5ef65 thru 0x7be85	(0x1cf21 bytes)	******PPPP
6216452(  4 mod 256): SKIPPED (no operation)
6216453(  5 mod 256): MAPREAD  0x2e01a thru 0x41659	(0x13640 bytes)
6216454(  6 mod 256): MAPREAD  0x7d279 thru 0x85166	(0x7eee bytes)
6216455(  7 mod 256): SKIPPED (no operation)
6216456(  8 mod 256): FALLOC   0x8e8de thru 0x927c0	(0x3ee2 bytes) INTERIOR
6216457(  9 mod 256): SKIPPED (no operation)
6216458( 10 mod 256): COLLAPSE 0x40000 thru 0x4cfff	(0xd000 bytes)
6216459( 11 mod 256): COPY 0x1bbf7 thru 0x304d5	(0x148df bytes) to 0x1b23 thru 0x16401
6216460( 12 mod 256): SKIPPED (no operation)
6216461( 13 mod 256): COPY 0x79c7e thru 0x857bf	(0xbb42 bytes) to 0x177f0 thru 0x23331
6216462( 14 mod 256): DEDUPE 0x3b000 thru 0x50fff	(0x16000 bytes) to 0x22000 thru 0x37fff
6216463( 15 mod 256): SKIPPED (no operation)
6216464( 16 mod 256): MAPREAD  0x540ff thru 0x5fa59	(0xb95b bytes)
6216465( 17 mod 256): WRITE    0x8744 thru 0x163b3	(0xdc70 bytes)
6216466( 18 mod 256): TRUNCATE DOWN	from 0x857c0 to 0x802d2
6216467( 19 mod 256): SKIPPED (no operation)
6216468( 20 mod 256): FALLOC   0x5340b thru 0x5cb47	(0x973c bytes) INTERIOR
6216469( 21 mod 256): COLLAPSE 0x4000 thru 0x7fff	(0x4000 bytes)
6216470( 22 mod 256): CLONE 0x10000 thru 0x1dfff	(0xe000 bytes) to 0x6e000 thru 0x7bfff	******JJJJ
6216471( 23 mod 256): COPY 0x39a4e thru 0x564be	(0x1ca71 bytes) to 0x6e5f1 thru 0x8b061	******EEEE
6216472( 24 mod 256): DEDUPE 0x88000 thru 0x89fff	(0x2000 bytes) to 0x7a000 thru 0x7bfff
6216473( 25 mod 256): COPY 0x60da4 thru 0x65553	(0x47b0 bytes) to 0x73bc1 thru 0x78370
6216474( 26 mod 256): PUNCH    0x76b78 thru 0x86c46	(0x100cf bytes)
6216475( 27 mod 256): MAPREAD  0x1ad26 thru 0x35619	(0x1a8f4 bytes)
6216476( 28 mod 256): WRITE    0x5f91d thru 0x7ccbe	(0x1d3a2 bytes)	***WWWW
6216477( 29 mod 256): CLONE 0x11000 thru 0x21fff	(0x11000 bytes) to 0x32000 thru 0x42fff
6216478( 30 mod 256): COPY 0x319ca thru 0x426b3	(0x10cea bytes) to 0x19e17 thru 0x2ab00
6216479( 31 mod 256): WRITE    0xc313 thru 0x11759	(0x5447 bytes)
6216480( 32 mod 256): TRUNCATE DOWN	from 0x8b062 to 0x11548	******WWWW
6216481( 33 mod 256): FALLOC   0x651b1 thru 0x7579b	(0x105ea bytes) EXTENDING	******FFFF
6216482( 34 mod 256): READ     0x1f06b thru 0x3da01	(0x1e997 bytes)
6216483( 35 mod 256): PUNCH    0x69011 thru 0x7579a	(0xc78a bytes)	******PPPP
6216484( 36 mod 256): ZERO     0x7816f thru 0x7a463	(0x22f5 bytes)
6216485( 37 mod 256): MAPWRITE 0x71ac thru 0x7560	(0x3b5 bytes)
6216486( 38 mod 256): INSERT 0x4d000 thru 0x4ffff	(0x3000 bytes)
6216487( 39 mod 256): CLONE 0x76000 thru 0x7cfff	(0x7000 bytes) to 0x31000 thru 0x37fff
6216488( 40 mod 256): DEDUPE 0x42000 thru 0x46fff	(0x5000 bytes) to 0x6f000 thru 0x73fff
6216489( 41 mod 256): COLLAPSE 0x67000 thru 0x67fff	(0x1000 bytes)
6216490( 42 mod 256): MAPWRITE 0x335b1 thru 0x4a9d5	(0x17425 bytes)
6216491( 43 mod 256): PUNCH    0x1c9ef thru 0x35024	(0x18636 bytes)
6216492( 44 mod 256): WRITE    0x6ef8 thru 0x2092a	(0x19a33 bytes)
6216493( 45 mod 256): READ     0x1e200 thru 0x23a31	(0x5832 bytes)
6216494( 46 mod 256): ZERO     0x6c12f thru 0x7aff8	(0xeeca bytes)	******ZZZZ
6216495( 47 mod 256): SKIPPED (no operation)
6216496( 48 mod 256): ZERO     0xb16f thru 0x1b56e	(0x10400 bytes)
6216497( 49 mod 256): SKIPPED (no operation)
6216498( 50 mod 256): WRITE    0x8f219 thru 0x927bf	(0x35a7 bytes) HOLE
6216499( 51 mod 256): CLONE 0x3d000 thru 0x44fff	(0x8000 bytes) to 0x55000 thru 0x5cfff
6216500( 52 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x7ae0f
6216501( 53 mod 256): ZERO     0x71464 thru 0x75385	(0x3f22 bytes)
6216502( 54 mod 256): INSERT 0xc000 thru 0x10fff	(0x5000 bytes)
6216503( 55 mod 256): INSERT 0x45000 thru 0x47fff	(0x3000 bytes)
6216504( 56 mod 256): MAPWRITE 0xa46e thru 0xcbba	(0x274d bytes)
6216505( 57 mod 256): MAPWRITE 0x4a13a thru 0x542e1	(0xa1a8 bytes)
6216506( 58 mod 256): TRUNCATE DOWN	from 0x82e0f to 0x41d14	******WWWW
6216507( 59 mod 256): CLONE 0x2000 thru 0xafff	(0x9000 bytes) to 0x40000 thru 0x48fff
6216508( 60 mod 256): MAPWRITE 0x7fc9a thru 0x840ed	(0x4454 bytes)
6216509( 61 mod 256): INSERT 0x6e000 thru 0x74fff	(0x7000 bytes)	******IIII
6216510( 62 mod 256): FALLOC   0x81476 thru 0x87ee0	(0x6a6a bytes) INTERIOR
6216511( 63 mod 256): MAPREAD  0x41c6c thru 0x53247	(0x115dc bytes)
6216512( 64 mod 256): FALLOC   0x66c71 thru 0x75c25	(0xefb4 bytes) INTERIOR	******FFFF
6216513( 65 mod 256): ZERO     0x6b984 thru 0x7cb1f	(0x1119c bytes)	******ZZZZ
6216514( 66 mod 256): FALLOC   0x7200 thru 0x1f5d2	(0x183d2 bytes) INTERIOR
6216515( 67 mod 256): COPY 0x4ea5d thru 0x55bac	(0x7150 bytes) to 0x42292 thru 0x493e1
6216516( 68 mod 256): INSERT 0x7d000 thru 0x83fff	(0x7000 bytes)
6216517( 69 mod 256): SKIPPED (no operation)
6216518( 70 mod 256): FALLOC   0x597d3 thru 0x72217	(0x18a44 bytes) INTERIOR	******FFFF
6216519( 71 mod 256): SKIPPED (no operation)
6216520( 72 mod 256): ZERO     0x242df thru 0x2a7e3	(0x6505 bytes)
6216521( 73 mod 256): SKIPPED (no operation)
6216522( 74 mod 256): CLONE 0x6000 thru 0x20fff	(0x1b000 bytes) to 0x26000 thru 0x40fff
6216523( 75 mod 256): COLLAPSE 0x49000 thru 0x5afff	(0x12000 bytes)
6216524( 76 mod 256): PUNCH    0x100a6 thru 0x110ee	(0x1049 bytes)
6216525( 77 mod 256): COLLAPSE 0x1a000 thru 0x2ffff	(0x16000 bytes)
6216526( 78 mod 256): FALLOC   0x5d878 thru 0x78861	(0x1afe9 bytes) PAST_EOF	******FFFF
6216527( 79 mod 256): TRUNCATE DOWN	from 0x6a0ee to 0x3182a
6216528( 80 mod 256): INSERT 0x27000 thru 0x33fff	(0xd000 bytes)
6216529( 81 mod 256): READ     0x1a8ab thru 0x3500f	(0x1a765 bytes)
6216530( 82 mod 256): FALLOC   0x1ff35 thru 0x39c24	(0x19cef bytes) INTERIOR
6216531( 83 mod 256): WRITE    0x45bf6 thru 0x5327d	(0xd688 bytes) HOLE
6216532( 84 mod 256): FALLOC   0x52bf3 thru 0x5aa39	(0x7e46 bytes) PAST_EOF
6216533( 85 mod 256): TRUNCATE DOWN	from 0x5327e to 0x123dc
6216534( 86 mod 256): SKIPPED (no operation)
6216535( 87 mod 256): READ     0x749b thru 0x7e8e	(0x9f4 bytes)
6216536( 88 mod 256): INSERT 0x11000 thru 0x2efff	(0x1e000 bytes)
6216537( 89 mod 256): PUNCH    0x1e08 thru 0x512b	(0x3324 bytes)
6216538( 90 mod 256): SKIPPED (no operation)
6216539( 91 mod 256): INSERT 0x11000 thru 0x21fff	(0x11000 bytes)
6216540( 92 mod 256): ZERO     0x28d37 thru 0x37994	(0xec5e bytes)
6216541( 93 mod 256): ZERO     0x30fbf thru 0x3d6ee	(0xc730 bytes)
6216542( 94 mod 256): CLONE 0x29000 thru 0x29fff	(0x1000 bytes) to 0x86000 thru 0x86fff
6216543( 95 mod 256): WRITE    0x2e814 thru 0x425ec	(0x13dd9 bytes)
6216544( 96 mod 256): COLLAPSE 0x6f000 thru 0x72fff	(0x4000 bytes)
6216545( 97 mod 256): COPY 0xb6e8 thru 0x20cf3	(0x1560c bytes) to 0x26e15 thru 0x3c420
6216546( 98 mod 256): INSERT 0x3c000 thru 0x49fff	(0xe000 bytes)
6216547( 99 mod 256): FALLOC   0x4acba thru 0x60430	(0x15776 bytes) INTERIOR
6216548(100 mod 256): SKIPPED (no operation)
6216549(101 mod 256): ZERO     0x812d9 thru 0x927bf	(0x114e7 bytes)
6216550(102 mod 256): INSERT 0x45000 thru 0x45fff	(0x1000 bytes)
6216551(103 mod 256): MAPWRITE 0x5ee29 thru 0x6c66e	(0xd846 bytes)
6216552(104 mod 256): PUNCH    0x17663 thru 0x21e39	(0xa7d7 bytes)
6216553(105 mod 256): ZERO     0x4a1bc thru 0x60650	(0x16495 bytes)
6216554(106 mod 256): DEDUPE 0x82000 thru 0x8cfff	(0xb000 bytes) to 0x1a000 thru 0x24fff
6216555(107 mod 256): MAPREAD  0x902b thru 0x1d45a	(0x14430 bytes)
6216556(108 mod 256): MAPREAD  0x52a1c thru 0x5b125	(0x870a bytes)
6216557(109 mod 256): COLLAPSE 0x68000 thru 0x74fff	(0xd000 bytes)	******CCCC
6216558(110 mod 256): TRUNCATE DOWN	from 0x85000 to 0x4a0f6	******WWWW
6216559(111 mod 256): FALLOC   0x2348b thru 0x2527a	(0x1def bytes) INTERIOR
6216560(112 mod 256): PUNCH    0x38017 thru 0x43eb9	(0xbea3 bytes)
6216561(113 mod 256): SKIPPED (no operation)
6216562(114 mod 256): CLONE 0x1d000 thru 0x2ffff	(0x13000 bytes) to 0x66000 thru 0x78fff	******JJJJ
6216563(115 mod 256): PUNCH    0x71d07 thru 0x78fff	(0x72f9 bytes)
6216564(116 mod 256): MAPREAD  0x4f272 thru 0x5d7b1	(0xe540 bytes)
6216565(117 mod 256): SKIPPED (no operation)
6216566(118 mod 256): SKIPPED (no operation)
6216567(119 mod 256): ZERO     0x65ead thru 0x7b803	(0x15957 bytes)	******ZZZZ
6216568(120 mod 256): WRITE    0x1361 thru 0x92d1	(0x7f71 bytes)
6216569(121 mod 256): COLLAPSE 0x2b000 thru 0x44fff	(0x1a000 bytes)
6216570(122 mod 256): TRUNCATE DOWN	from 0x5f000 to 0x5aee1
6216571(123 mod 256): PUNCH    0x3602 thru 0x21913	(0x1e312 bytes)
6216572(124 mod 256): WRITE    0x47045 thru 0x65ea9	(0x1ee65 bytes) EXTEND
6216573(125 mod 256): READ     0x2e5cf thru 0x4cf59	(0x1e98b bytes)
6216574(126 mod 256): DEDUPE 0x54000 thru 0x64fff	(0x11000 bytes) to 0xc000 thru 0x1cfff
6216575(127 mod 256): READ     0x1dfac thru 0x2fdfb	(0x11e50 bytes)
6216576(128 mod 256): COLLAPSE 0x8000 thru 0xdfff	(0x6000 bytes)
6216577(129 mod 256): TRUNCATE DOWN	from 0x5feaa to 0x5ec44
6216578(130 mod 256): WRITE    0x15276 thru 0x3242b	(0x1d1b6 bytes)
6216579(131 mod 256): READ     0x5df45 thru 0x5ec43	(0xcff bytes)
6216580(132 mod 256): ZERO     0x75609 thru 0x811f6	(0xbbee bytes)
6216581(133 mod 256): WRITE    0x290b3 thru 0x31f23	(0x8e71 bytes)
6216582(134 mod 256): INSERT 0x66000 thru 0x72fff	(0xd000 bytes)	******IIII
6216583(135 mod 256): TRUNCATE DOWN	from 0x8e1f7 to 0x5254e	******WWWW
6216584(136 mod 256): ZERO     0x35929 thru 0x3b4a1	(0x5b79 bytes)
6216585(137 mod 256): ZERO     0x64006 thru 0x656e3	(0x16de bytes)
6216586(138 mod 256): WRITE    0x87d6a thru 0x927bf	(0xaa56 bytes) HOLE	***WWWW
6216587(139 mod 256): CLONE 0x3000 thru 0x15fff	(0x13000 bytes) to 0x55000 thru 0x67fff
6216588(140 mod 256): CLONE 0x5b000 thru 0x78fff	(0x1e000 bytes) to 0x27000 thru 0x44fff	JJJJ******
6216589(141 mod 256): FALLOC   0x7b745 thru 0x83d58	(0x8613 bytes) INTERIOR
6216590(142 mod 256): ZERO     0x5d842 thru 0x6a6a8	(0xce67 bytes)
6216591(143 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x50d79	******WWWW
6216592(144 mod 256): COPY 0x229f thru 0x206c5	(0x1e427 bytes) to 0x5a279 thru 0x7869f	******EEEE
6216593(145 mod 256): ZERO     0x1aa89 thru 0x26ceb	(0xc263 bytes)
6216594(146 mod 256): COLLAPSE 0x64000 thru 0x6cfff	(0x9000 bytes)
6216595(147 mod 256): INSERT 0x3e000 thru 0x44fff	(0x7000 bytes)
6216596(148 mod 256): COPY 0x417de thru 0x5c844	(0x1b067 bytes) to 0xf054 thru 0x2a0ba
6216597(149 mod 256): READ     0x55a5b thru 0x62da0	(0xd346 bytes)
6216598(150 mod 256): PUNCH    0x34024 thru 0x4e48e	(0x1a46b bytes)
6216599(151 mod 256): READ     0x2bd3b thru 0x49aa9	(0x1dd6f bytes)
6216600(152 mod 256): DEDUPE 0x51000 thru 0x56fff	(0x6000 bytes) to 0x7000 thru 0xcfff
6216601(153 mod 256): READ     0x750f9 thru 0x7669f	(0x15a7 bytes)
6216602(154 mod 256): TRUNCATE DOWN	from 0x766a0 to 0x72030
6216603(155 mod 256): SKIPPED (no operation)
6216604(156 mod 256): PUNCH    0x5490d thru 0x5cf3b	(0x862f bytes)
6216605(157 mod 256): SKIPPED (no operation)
6216606(158 mod 256): WRITE    0x5c810 thru 0x634d7	(0x6cc8 bytes)
6216607(159 mod 256): SKIPPED (no operation)
6216608(160 mod 256): WRITE    0x3fd70 thru 0x46fbe	(0x724f bytes)
6216609(161 mod 256): MAPREAD  0x6286b thru 0x6bfc2	(0x9758 bytes)
6216610(162 mod 256): CLONE 0x62000 thru 0x70fff	(0xf000 bytes) to 0x47000 thru 0x55fff	JJJJ******
6216611(163 mod 256): COLLAPSE 0x5f000 thru 0x6bfff	(0xd000 bytes)
6216612(164 mod 256): DEDUPE 0x36000 thru 0x46fff	(0x11000 bytes) to 0x4b000 thru 0x5bfff
6216613(165 mod 256): FALLOC   0x3cc43 thru 0x54ecd	(0x1828a bytes) INTERIOR
6216614(166 mod 256): INSERT 0x62000 thru 0x66fff	(0x5000 bytes)
6216615(167 mod 256): READ     0xa343 thru 0x2532e	(0x1afec bytes)
6216616(168 mod 256): CLONE 0x33000 thru 0x4bfff	(0x19000 bytes) to 0x10000 thru 0x28fff
6216617(169 mod 256): SKIPPED (no operation)
6216618(170 mod 256): TRUNCATE DOWN	from 0x6a030 to 0x2df23
6216619(171 mod 256): COLLAPSE 0x25000 thru 0x2cfff	(0x8000 bytes)
6216620(172 mod 256): CLONE 0x3000 thru 0x1efff	(0x1c000 bytes) to 0x4f000 thru 0x6afff
6216621(173 mod 256): READ     0x344f3 thru 0x3b1a5	(0x6cb3 bytes)
6216622(174 mod 256): MAPWRITE 0x1d8a9 thru 0x3bdac	(0x1e504 bytes)
6216623(175 mod 256): INSERT 0x3000 thru 0x12fff	(0x10000 bytes)
6216624(176 mod 256): MAPWRITE 0x517f5 thru 0x5a6a4	(0x8eb0 bytes)
6216625(177 mod 256): ZERO     0x10b1a thru 0x2f0b5	(0x1e59c bytes)
6216626(178 mod 256): ZERO     0x3670b thru 0x4c7c0	(0x160b6 bytes)
6216627(179 mod 256): ZERO     0xe268 thru 0x1da71	(0xf80a bytes)
6216628(180 mod 256): MAPWRITE 0x8b11f thru 0x927bf	(0x76a1 bytes)
6216629(181 mod 256): COLLAPSE 0x2000 thru 0x1afff	(0x19000 bytes)
6216630(182 mod 256): ZERO     0x7faab thru 0x8803d	(0x8593 bytes)
6216631(183 mod 256): COPY 0x645ab thru 0x797bf	(0x15215 bytes) to 0x42804 thru 0x57a18	EEEE******
6216632(184 mod 256): INSERT 0x6b000 thru 0x83fff	(0x19000 bytes)	******IIII
6216633(185 mod 256): DEDUPE 0x8000 thru 0x23fff	(0x1c000 bytes) to 0x33000 thru 0x4efff
6216634(186 mod 256): SKIPPED (no operation)
6216635(187 mod 256): COPY 0x37f67 thru 0x3d36e	(0x5408 bytes) to 0x749f5 thru 0x79dfc
6216636(188 mod 256): SKIPPED (no operation)
6216637(189 mod 256): CLONE 0x2d000 thru 0x48fff	(0x1c000 bytes) to 0x60000 thru 0x7bfff	******JJJJ
6216638(190 mod 256): SKIPPED (no operation)
6216639(191 mod 256): MAPREAD  0x918dc thru 0x927bf	(0xee4 bytes)
6216640(192 mod 256): PUNCH    0x16b2b thru 0x1a031	(0x3507 bytes)
6216641(193 mod 256): SKIPPED (no operation)
6216642(194 mod 256): FALLOC   0x14cc0 thru 0x2f9ab	(0x1aceb bytes) INTERIOR
6216643(195 mod 256): SKIPPED (no operation)
6216644(196 mod 256): MAPREAD  0x349fd thru 0x51a5d	(0x1d061 bytes)
6216645(197 mod 256): COPY 0x31beb thru 0x3d2b2	(0xb6c8 bytes) to 0x4a523 thru 0x55bea
6216646(198 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4697d	******WWWW
6216647(199 mod 256): WRITE    0x48ec2 thru 0x56780	(0xd8bf bytes) HOLE
6216648(200 mod 256): COPY 0x2e0d0 thru 0x4a4fe	(0x1c42f bytes) to 0x50ba8 thru 0x6cfd6
6216649(201 mod 256): READ     0x6170e thru 0x6cfd6	(0xb8c9 bytes)
6216650(202 mod 256): DEDUPE 0x2d000 thru 0x44fff	(0x18000 bytes) to 0x50000 thru 0x67fff
6216651(203 mod 256): DEDUPE 0x1e000 thru 0x2cfff	(0xf000 bytes) to 0x45000 thru 0x53fff
6216652(204 mod 256): COPY 0x37ccc thru 0x4a3a1	(0x126d6 bytes) to 0x74a16 thru 0x870eb
6216653(205 mod 256): SKIPPED (no operation)
6216654(206 mod 256): MAPWRITE 0x24516 thru 0x31f3b	(0xda26 bytes)
6216655(207 mod 256): CLONE 0x54000 thru 0x70fff	(0x1d000 bytes) to 0x16000 thru 0x32fff	JJJJ******
6216656(208 mod 256): WRITE    0x180b9 thru 0x1c7a5	(0x46ed bytes)
6216657(209 mod 256): SKIPPED (no operation)
6216658(210 mod 256): COLLAPSE 0x7c000 thru 0x85fff	(0xa000 bytes)
6216659(211 mod 256): READ     0x1e13f thru 0x2a043	(0xbf05 bytes)
6216660(212 mod 256): DEDUPE 0xa000 thru 0x1dfff	(0x14000 bytes) to 0x20000 thru 0x33fff
6216661(213 mod 256): TRUNCATE DOWN	from 0x7d0ec to 0x52b2b	******WWWW
6216662(214 mod 256): TRUNCATE DOWN	from 0x52b2b to 0x202d
6216663(215 mod 256): ZERO     0x85a7d thru 0x927bf	(0xcd43 bytes)
6216664(216 mod 256): CLONE 0x0 thru 0xfff	(0x1000 bytes) to 0x7e000 thru 0x7efff
6216665(217 mod 256): INSERT 0x79000 thru 0x79fff	(0x1000 bytes)
6216666(218 mod 256): MAPREAD  0x310cc thru 0x3d144	(0xc079 bytes)
6216667(219 mod 256): ZERO     0x15f72 thru 0x190b4	(0x3143 bytes)
6216668(220 mod 256): ZERO     0x864d4 thru 0x892df	(0x2e0c bytes)
6216669(221 mod 256): MAPREAD  0x32a81 thru 0x36ff8	(0x4578 bytes)
6216670(222 mod 256): INSERT 0x2d000 thru 0x36fff	(0xa000 bytes)
6216671(223 mod 256): MAPREAD  0x5ca86 thru 0x618ed	(0x4e68 bytes)
6216672(224 mod 256): FALLOC   0x63e97 thru 0x70e1a	(0xcf83 bytes) INTERIOR	******FFFF
6216673(225 mod 256): FALLOC   0x75862 thru 0x8555b	(0xfcf9 bytes) INTERIOR
6216674(226 mod 256): CLONE 0x27000 thru 0x27fff	(0x1000 bytes) to 0x3e000 thru 0x3efff
6216675(227 mod 256): MAPWRITE 0x1f51f thru 0x30961	(0x11443 bytes)
6216676(228 mod 256): DEDUPE 0x3000 thru 0x5fff	(0x3000 bytes) to 0x35000 thru 0x37fff
6216677(229 mod 256): DEDUPE 0x6000 thru 0x7fff	(0x2000 bytes) to 0x27000 thru 0x28fff
6216678(230 mod 256): ZERO     0x6ddc2 thru 0x84978	(0x16bb7 bytes)	******ZZZZ
6216679(231 mod 256): COLLAPSE 0x6d000 thru 0x71fff	(0x5000 bytes)	******CCCC
6216680(232 mod 256): WRITE    0x25358 thru 0x43683	(0x1e32c bytes)
6216681(233 mod 256): WRITE    0x34488 thru 0x46a04	(0x1257d bytes)
6216682(234 mod 256): MAPREAD  0x512fc thru 0x5b2da	(0x9fdf bytes)
6216683(235 mod 256): FALLOC   0x370d4 thru 0x3f581	(0x84ad bytes) INTERIOR
6216684(236 mod 256): MAPREAD  0x8457 thru 0x1cd39	(0x148e3 bytes)
6216685(237 mod 256): CLONE 0x5c000 thru 0x78fff	(0x1d000 bytes) to 0x2f000 thru 0x4bfff	JJJJ******
6216686(238 mod 256): FALLOC   0x1c7d4 thru 0x3aa2d	(0x1e259 bytes) INTERIOR
6216687(239 mod 256): CLONE 0x22000 thru 0x3afff	(0x19000 bytes) to 0x8000 thru 0x20fff
6216688(240 mod 256): ZERO     0x26de8 thru 0x3be60	(0x15079 bytes)
6216689(241 mod 256): COPY 0x2ccf4 thru 0x4275e	(0x15a6b bytes) to 0x13729 thru 0x29193
6216690(242 mod 256): WRITE    0xdbcf thru 0xea2a	(0xe5c bytes)
6216691(243 mod 256): ZERO     0x74828 thru 0x76fd0	(0x27a9 bytes)
6216692(244 mod 256): COPY 0x1f855 thru 0x24611	(0x4dbd bytes) to 0x741d5 thru 0x78f91
6216693(245 mod 256): PUNCH    0x284a4 thru 0x30c0a	(0x8767 bytes)
6216694(246 mod 256): READ     0xca2e thru 0x13dc3	(0x7396 bytes)
6216695(247 mod 256): MAPREAD  0x557ca thru 0x5b581	(0x5db8 bytes)
6216696(248 mod 256): MAPREAD  0x67ae4 thru 0x817a9	(0x19cc6 bytes)	***RRRR***
6216697(249 mod 256): WRITE    0x2bd44 thru 0x35455	(0x9712 bytes)
6216698(250 mod 256): FALLOC   0x374d2 thru 0x4e7c2	(0x172f0 bytes) INTERIOR
6216699(251 mod 256): PUNCH    0x2c589 thru 0x4061b	(0x14093 bytes)
6216700(252 mod 256): FALLOC   0x91ab8 thru 0x927c0	(0xd08 bytes) EXTENDING
6216701(253 mod 256): PUNCH    0x590fe thru 0x6418f	(0xb092 bytes)
6216702(254 mod 256): SKIPPED (no operation)
6216703(255 mod 256): CLONE 0x32000 thru 0x39fff	(0x8000 bytes) to 0x53000 thru 0x5afff
6216704(  0 mod 256): CLONE 0x5e000 thru 0x6dfff	(0x10000 bytes) to 0x11000 thru 0x20fff
6216705(  1 mod 256): CLONE 0x52000 thru 0x6ffff	(0x1e000 bytes) to 0x3000 thru 0x20fff	JJJJ******
6216706(  2 mod 256): READ     0x5a629 thru 0x60faa	(0x6982 bytes)
6216707(  3 mod 256): ZERO     0x72338 thru 0x8dd2b	(0x1b9f4 bytes)
6216708(  4 mod 256): SKIPPED (no operation)
6216709(  5 mod 256): DEDUPE 0x2c000 thru 0x3efff	(0x13000 bytes) to 0x8000 thru 0x1afff
6216710(  6 mod 256): ZERO     0x24c12 thru 0x3990e	(0x14cfd bytes)
6216711(  7 mod 256): WRITE    0x64075 thru 0x722a8	(0xe234 bytes)	***WWWW
6216712(  8 mod 256): SKIPPED (no operation)
6216713(  9 mod 256): READ     0x45fe7 thru 0x55f05	(0xff1f bytes)
6216714( 10 mod 256): PUNCH    0x64fdf thru 0x7b895	(0x168b7 bytes)	******PPPP
6216715( 11 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2bd43	******WWWW
6216716( 12 mod 256): FALLOC   0x6309a thru 0x7c601	(0x19567 bytes) PAST_EOF	******FFFF
6216717( 13 mod 256): FALLOC   0x5bfa0 thru 0x6d8e0	(0x11940 bytes) PAST_EOF
6216718( 14 mod 256): ZERO     0x3ddf thru 0x52cc	(0x14ee bytes)
6216719( 15 mod 256): COPY 0x29538 thru 0x2bd42	(0x280b bytes) to 0x51217 thru 0x53a21
6216720( 16 mod 256): DEDUPE 0x4f000 thru 0x52fff	(0x4000 bytes) to 0x16000 thru 0x19fff
6216721( 17 mod 256): PUNCH    0x25754 thru 0x3da9f	(0x1834c bytes)
6216722( 18 mod 256): INSERT 0x24000 thru 0x41fff	(0x1e000 bytes)
6216723( 19 mod 256): CLONE 0x3000 thru 0x18fff	(0x16000 bytes) to 0x2d000 thru 0x42fff
6216724( 20 mod 256): PUNCH    0xf1f3 thru 0x290f0	(0x19efe bytes)
6216725( 21 mod 256): TRUNCATE DOWN	from 0x71a22 to 0x64bf4	******WWWW
6216726( 22 mod 256): WRITE    0x171ee thru 0x19c50	(0x2a63 bytes)
6216727( 23 mod 256): ZERO     0x21366 thru 0x2e368	(0xd003 bytes)
6216728( 24 mod 256): INSERT 0x3a000 thru 0x3cfff	(0x3000 bytes)
6216729( 25 mod 256): WRITE    0x1d6c1 thru 0x387cf	(0x1b10f bytes)
6216730( 26 mod 256): MAPREAD  0x325d1 thru 0x32c96	(0x6c6 bytes)
6216731( 27 mod 256): SKIPPED (no operation)
6216732( 28 mod 256): WRITE    0x1a54c thru 0x38efe	(0x1e9b3 bytes)
6216733( 29 mod 256): CLONE 0x12000 thru 0x1cfff	(0xb000 bytes) to 0x5e000 thru 0x68fff
6216734( 30 mod 256): WRITE    0x89a22 thru 0x927bf	(0x8d9e bytes) HOLE	***WWWW
6216735( 31 mod 256): SKIPPED (no operation)
6216736( 32 mod 256): FALLOC   0xa94b thru 0x1dbca	(0x1327f bytes) INTERIOR
6216737( 33 mod 256): COPY 0x85549 thru 0x927bf	(0xd277 bytes) to 0x1615d thru 0x233d3
6216738( 34 mod 256): SKIPPED (no operation)
6216739( 35 mod 256): MAPREAD  0x11ddb thru 0x1c1fd	(0xa423 bytes)
6216740( 36 mod 256): PUNCH    0x2cf8c thru 0x33576	(0x65eb bytes)
6216741( 37 mod 256): WRITE    0x62b53 thru 0x7f116	(0x1c5c4 bytes)	***WWWW
6216742( 38 mod 256): CLONE 0x72000 thru 0x85fff	(0x14000 bytes) to 0x45000 thru 0x58fff
6216743( 39 mod 256): MAPWRITE 0xc508 thru 0x1eebd	(0x129b6 bytes)
6216744( 40 mod 256): MAPREAD  0x6a029 thru 0x83b19	(0x19af1 bytes)	***RRRR***
6216745( 41 mod 256): DEDUPE 0x6e000 thru 0x7cfff	(0xf000 bytes) to 0x10000 thru 0x1efff	BBBB******
6216746( 42 mod 256): CLONE 0x84000 thru 0x88fff	(0x5000 bytes) to 0x67000 thru 0x6bfff
6216747( 43 mod 256): COLLAPSE 0x1b000 thru 0x2dfff	(0x13000 bytes)
6216748( 44 mod 256): FALLOC   0x67856 thru 0x80b8a	(0x19334 bytes) EXTENDING	******FFFF
6216749( 45 mod 256): COLLAPSE 0x21000 thru 0x26fff	(0x6000 bytes)
6216750( 46 mod 256): FALLOC   0x6c037 thru 0x805da	(0x145a3 bytes) PAST_EOF	******FFFF
6216751( 47 mod 256): TRUNCATE DOWN	from 0x7ab8a to 0x5fc6	******WWWW
6216752( 48 mod 256): SKIPPED (no operation)
6216753( 49 mod 256): MAPWRITE 0x1510e thru 0x2181c	(0xc70f bytes)
6216754( 50 mod 256): DEDUPE 0x10000 thru 0x17fff	(0x8000 bytes) to 0x2000 thru 0x9fff
6216755( 51 mod 256): SKIPPED (no operation)
6216756( 52 mod 256): MAPREAD  0xf36e thru 0x2181c	(0x124af bytes)
6216757( 53 mod 256): FALLOC   0x53fe thru 0xe284	(0x8e86 bytes) INTERIOR
6216758( 54 mod 256): INSERT 0x20000 thru 0x2bfff	(0xc000 bytes)
6216759( 55 mod 256): COLLAPSE 0x23000 thru 0x2bfff	(0x9000 bytes)
6216760( 56 mod 256): MAPREAD  0x23bdc thru 0x2481c	(0xc41 bytes)
6216761( 57 mod 256): INSERT 0x2000 thru 0x17fff	(0x16000 bytes)
6216762( 58 mod 256): SKIPPED (no operation)
6216763( 59 mod 256): COPY 0x2348c thru 0x3a81c	(0x17391 bytes) to 0x3be81 thru 0x53211
6216764( 60 mod 256): SKIPPED (no operation)
6216765( 61 mod 256): TRUNCATE UP	from 0x53212 to 0x663cb
6216766( 62 mod 256): READ     0x3de48 thru 0x53cd1	(0x15e8a bytes)
6216767( 63 mod 256): MAPWRITE 0x68c73 thru 0x6c113	(0x34a1 bytes)
6216768( 64 mod 256): CLONE 0xf000 thru 0x19fff	(0xb000 bytes) to 0x50000 thru 0x5afff
6216769( 65 mod 256): MAPREAD  0x4a645 thru 0x5f9fa	(0x153b6 bytes)
6216770( 66 mod 256): MAPWRITE 0x68831 thru 0x72059	(0x9829 bytes)	******WWWW
6216771( 67 mod 256): COPY 0x6b35c thru 0x72059	(0x6cfe bytes) to 0x1b00d thru 0x21d0a	EEEE******
6216772( 68 mod 256): ZERO     0x113a4 thru 0x1f287	(0xdee4 bytes)
6216773( 69 mod 256): PUNCH    0x2e217 thru 0x4d08e	(0x1ee78 bytes)
6216774( 70 mod 256): COPY 0x4024b thru 0x4b36d	(0xb123 bytes) to 0x6b41c thru 0x7653e	******EEEE
6216775( 71 mod 256): SKIPPED (no operation)
6216776( 72 mod 256): INSERT 0x46000 thru 0x57fff	(0x12000 bytes)
6216777( 73 mod 256): PUNCH    0x71c13 thru 0x73be1	(0x1fcf bytes)
6216778( 74 mod 256): WRITE    0x19e78 thru 0x340d3	(0x1a25c bytes)
6216779( 75 mod 256): COPY 0x2d437 thru 0x346f7	(0x72c1 bytes) to 0x1a0db thru 0x2139b
6216780( 76 mod 256): WRITE    0x13991 thru 0x26fcd	(0x1363d bytes)
6216781( 77 mod 256): COPY 0x391b9 thru 0x411cb	(0x8013 bytes) to 0x6e6ca thru 0x766dc	******EEEE
6216782( 78 mod 256): MAPREAD  0x7877e thru 0x7f3f3	(0x6c76 bytes)
6216783( 79 mod 256): COPY 0x87c4f thru 0x8853e	(0x8f0 bytes) to 0x3b147 thru 0x3ba36
6216784( 80 mod 256): FALLOC   0xa263 thru 0xce01	(0x2b9e bytes) INTERIOR
6216785( 81 mod 256): PUNCH    0x3471 thru 0x3e5e	(0x9ee bytes)
6216786( 82 mod 256): FALLOC   0x900e thru 0xc971	(0x3963 bytes) INTERIOR
6216787( 83 mod 256): SKIPPED (no operation)
6216788( 84 mod 256): COPY 0x64c57 thru 0x6a146	(0x54f0 bytes) to 0x1b153 thru 0x20642
6216789( 85 mod 256): WRITE    0x5d7c6 thru 0x62042	(0x487d bytes)
6216790( 86 mod 256): INSERT 0x44000 thru 0x44fff	(0x1000 bytes)
6216791( 87 mod 256): MAPWRITE 0x79c5b thru 0x8aff7	(0x1139d bytes)
6216792( 88 mod 256): TRUNCATE DOWN	from 0x8aff8 to 0x39633	******WWWW
6216793( 89 mod 256): WRITE    0x319f6 thru 0x36e75	(0x5480 bytes)
6216794( 90 mod 256): ZERO     0x2a5ba thru 0x4080a	(0x16251 bytes)
6216795( 91 mod 256): READ     0x43e7 thru 0x185d3	(0x141ed bytes)
6216796( 92 mod 256): INSERT 0xb000 thru 0xbfff	(0x1000 bytes)
6216797( 93 mod 256): SKIPPED (no operation)
6216798( 94 mod 256): COPY 0x4013 thru 0x2131e	(0x1d30c bytes) to 0x49967 thru 0x66c72
6216799( 95 mod 256): PUNCH    0x4e9db thru 0x66c72	(0x18298 bytes)
6216800( 96 mod 256): FALLOC   0x1110a thru 0x26393	(0x15289 bytes) INTERIOR
6216801( 97 mod 256): TRUNCATE DOWN	from 0x66c73 to 0x12644
6216802( 98 mod 256): INSERT 0xa000 thru 0x17fff	(0xe000 bytes)
6216803( 99 mod 256): WRITE    0x6c1cb thru 0x70c6e	(0x4aa4 bytes) HOLE	***WWWW
6216804(100 mod 256): FALLOC   0x19cb9 thru 0x38f2a	(0x1f271 bytes) INTERIOR
6216805(101 mod 256): SKIPPED (no operation)
6216806(102 mod 256): MAPREAD  0x35586 thru 0x4cb13	(0x1758e bytes)
6216807(103 mod 256): MAPREAD  0x3ee56 thru 0x4fff8	(0x111a3 bytes)
6216808(104 mod 256): FALLOC   0x63930 thru 0x6e511	(0xabe1 bytes) INTERIOR
6216809(105 mod 256): INSERT 0x34000 thru 0x50fff	(0x1d000 bytes)
6216810(106 mod 256): INSERT 0x14000 thru 0x17fff	(0x4000 bytes)
6216811(107 mod 256): READ     0x12c7a thru 0x1b40a	(0x8791 bytes)
6216812(108 mod 256): SKIPPED (no operation)
6216813(109 mod 256): ZERO     0x14b5a thru 0x336ef	(0x1eb96 bytes)
6216814(110 mod 256): TRUNCATE DOWN	from 0x91c6f to 0x2b2f1	******WWWW
6216815(111 mod 256): INSERT 0x25000 thru 0x3afff	(0x16000 bytes)
6216816(112 mod 256): ZERO     0x7dbee thru 0x8d424	(0xf837 bytes)
6216817(113 mod 256): ZERO     0x3da5d thru 0x50955	(0x12ef9 bytes)
6216818(114 mod 256): COLLAPSE 0x1b000 thru 0x24fff	(0xa000 bytes)
6216819(115 mod 256): TRUNCATE UP	from 0x372f1 to 0x8959e	******WWWW
6216820(116 mod 256): INSERT 0x39000 thru 0x41fff	(0x9000 bytes)
6216821(117 mod 256): READ     0x18bff thru 0x1fdb1	(0x71b3 bytes)
6216822(118 mod 256): ZERO     0x54303 thru 0x64181	(0xfe7f bytes)
6216823(119 mod 256): TRUNCATE DOWN	from 0x9259e to 0x6b1a4	******WWWW
6216824(120 mod 256): WRITE    0x191ce thru 0x19dd0	(0xc03 bytes)
6216825(121 mod 256): DEDUPE 0x45000 thru 0x62fff	(0x1e000 bytes) to 0x18000 thru 0x35fff
6216826(122 mod 256): TRUNCATE DOWN	from 0x6b1a4 to 0x1f649
6216827(123 mod 256): TRUNCATE UP	from 0x1f649 to 0x2de0c
6216828(124 mod 256): COPY 0xb6a5 thru 0x24b5c	(0x194b8 bytes) to 0x3b73c thru 0x54bf3
6216829(125 mod 256): COLLAPSE 0x3d000 thru 0x46fff	(0xa000 bytes)
6216830(126 mod 256): PUNCH    0x1a007 thru 0x38622	(0x1e61c bytes)
6216831(127 mod 256): CLONE 0x32000 thru 0x49fff	(0x18000 bytes) to 0x0 thru 0x17fff
6216832(128 mod 256): SKIPPED (no operation)
6216833(129 mod 256): FALLOC   0x2181a thru 0x360ca	(0x148b0 bytes) INTERIOR
6216834(130 mod 256): SKIPPED (no operation)
6216835(131 mod 256): INSERT 0x2d000 thru 0x44fff	(0x18000 bytes)
6216836(132 mod 256): MAPREAD  0x3239b thru 0x390ee	(0x6d54 bytes)
6216837(133 mod 256): READ     0xf77e thru 0x13e0d	(0x4690 bytes)
6216838(134 mod 256): ZERO     0x32d1c thru 0x4f5d1	(0x1c8b6 bytes)
6216839(135 mod 256): MAPWRITE 0x46d0b thru 0x4c244	(0x553a bytes)
6216840(136 mod 256): PUNCH    0x43446 thru 0x46a80	(0x363b bytes)
6216841(137 mod 256): WRITE    0x341ac thru 0x45f5e	(0x11db3 bytes)
6216842(138 mod 256): SKIPPED (no operation)
6216843(139 mod 256): READ     0x31a86 thru 0x31ac7	(0x42 bytes)
6216844(140 mod 256): CLONE 0x1c000 thru 0x2ffff	(0x14000 bytes) to 0x5f000 thru 0x72fff	******JJJJ
6216845(141 mod 256): MAPREAD  0x5ae6 thru 0x17088	(0x115a3 bytes)
6216846(142 mod 256): MAPWRITE 0x62aa9 thru 0x6faa9	(0xd001 bytes)	******WWWW
6216847(143 mod 256): INSERT 0x31000 thru 0x38fff	(0x8000 bytes)
6216848(144 mod 256): MAPWRITE 0x7f191 thru 0x8a6cc	(0xb53c bytes)
6216849(145 mod 256): SKIPPED (no operation)
6216850(146 mod 256): TRUNCATE DOWN	from 0x8a6cd to 0xddb5	******WWWW
6216851(147 mod 256): DEDUPE 0xb000 thru 0xbfff	(0x1000 bytes) to 0x8000 thru 0x8fff
6216852(148 mod 256): SKIPPED (no operation)
6216853(149 mod 256): ZERO     0xf5a6 thru 0x2b5c7	(0x1c022 bytes)
6216854(150 mod 256): WRITE    0x16197 thru 0x31d94	(0x1bbfe bytes) EXTEND
6216855(151 mod 256): MAPREAD  0x1e19d thru 0x29f91	(0xbdf5 bytes)
6216856(152 mod 256): PUNCH    0x1a7aa thru 0x2651a	(0xbd71 bytes)
6216857(153 mod 256): READ     0x29c92 thru 0x31d94	(0x8103 bytes)
6216858(154 mod 256): INSERT 0x1a000 thru 0x20fff	(0x7000 bytes)
6216859(155 mod 256): SKIPPED (no operation)
6216860(156 mod 256): PUNCH    0x13311 thru 0x20aca	(0xd7ba bytes)
6216861(157 mod 256): ZERO     0x43224 thru 0x4fa57	(0xc834 bytes)
6216862(158 mod 256): COPY 0x2e6c1 thru 0x32086	(0x39c6 bytes) to 0x5e64c thru 0x62011
6216863(159 mod 256): ZERO     0x2e1a0 thru 0x3e0cd	(0xff2e bytes)
6216864(160 mod 256): ZERO     0x63b36 thru 0x787e1	(0x14cac bytes)	******ZZZZ
6216865(161 mod 256): INSERT 0x21000 thru 0x2cfff	(0xc000 bytes)
6216866(162 mod 256): ZERO     0x40105 thru 0x50e11	(0x10d0d bytes)
6216867(163 mod 256): CLONE 0x2b000 thru 0x30fff	(0x6000 bytes) to 0x4a000 thru 0x4ffff
6216868(164 mod 256): TRUNCATE UP	from 0x6e012 to 0x7ed91	******WWWW
6216869(165 mod 256): PUNCH    0x3500d thru 0x35d39	(0xd2d bytes)
6216870(166 mod 256): WRITE    0x623be thru 0x6e2b9	(0xbefc bytes)
6216871(167 mod 256): READ     0x5ab13 thru 0x687e6	(0xdcd4 bytes)
6216872(168 mod 256): INSERT 0xa000 thru 0x17fff	(0xe000 bytes)
6216873(169 mod 256): SKIPPED (no operation)
6216874(170 mod 256): COPY 0x7189f thru 0x8cd90	(0x1b4f2 bytes) to 0x541be thru 0x6f6af	******EEEE
6216875(171 mod 256): INSERT 0x52000 thru 0x56fff	(0x5000 bytes)
6216876(172 mod 256): COLLAPSE 0x1e000 thru 0x1efff	(0x1000 bytes)
6216877(173 mod 256): DEDUPE 0x74000 thru 0x7bfff	(0x8000 bytes) to 0x53000 thru 0x5afff
6216878(174 mod 256): FALLOC   0x73879 thru 0x81449	(0xdbd0 bytes) INTERIOR
6216879(175 mod 256): SKIPPED (no operation)
6216880(176 mod 256): PUNCH    0x3e2ee thru 0x59834	(0x1b547 bytes)
6216881(177 mod 256): COPY 0x4a899 thru 0x505f6	(0x5d5e bytes) to 0x1d93e thru 0x2369b
6216882(178 mod 256): READ     0x71979 thru 0x73629	(0x1cb1 bytes)
6216883(179 mod 256): ZERO     0x3b6bd thru 0x595ea	(0x1df2e bytes)
6216884(180 mod 256): COLLAPSE 0x8e000 thru 0x8ffff	(0x2000 bytes)
6216885(181 mod 256): TRUNCATE DOWN	from 0x8ed91 to 0x2bfa3	******WWWW
6216886(182 mod 256): CLONE 0x21000 thru 0x29fff	(0x9000 bytes) to 0x3d000 thru 0x45fff
6216887(183 mod 256): WRITE    0x2a742 thru 0x3b014	(0x108d3 bytes)
6216888(184 mod 256): SKIPPED (no operation)
6216889(185 mod 256): COLLAPSE 0x1a000 thru 0x34fff	(0x1b000 bytes)
6216890(186 mod 256): INSERT 0x1e000 thru 0x2ffff	(0x12000 bytes)
6216891(187 mod 256): TRUNCATE UP	from 0x3d000 to 0x58199
6216892(188 mod 256): INSERT 0x18000 thru 0x1cfff	(0x5000 bytes)
6216893(189 mod 256): CLONE 0x3b000 thru 0x45fff	(0xb000 bytes) to 0x17000 thru 0x21fff
6216894(190 mod 256): WRITE    0x2a2f5 thru 0x36dcb	(0xcad7 bytes)
6216895(191 mod 256): COPY 0x275b7 thru 0x3a067	(0x12ab1 bytes) to 0x5bde2 thru 0x6e892
6216896(192 mod 256): INSERT 0x55000 thru 0x55fff	(0x1000 bytes)
6216897(193 mod 256): ZERO     0x1c78f thru 0x3acfc	(0x1e56e bytes)
6216898(194 mod 256): WRITE    0x45cc6 thru 0x60171	(0x1a4ac bytes)
6216899(195 mod 256): TRUNCATE DOWN	from 0x6f893 to 0x63bee	******WWWW
6216900(196 mod 256): READ     0x30bec thru 0x38548	(0x795d bytes)
6216901(197 mod 256): PUNCH    0x9007 thru 0x280c3	(0x1f0bd bytes)
6216902(198 mod 256): INSERT 0x4a000 thru 0x59fff	(0x10000 bytes)
6216903(199 mod 256): READ     0x625ff thru 0x73bed	(0x115ef bytes)	***RRRR***
6216904(200 mod 256): PUNCH    0x6bd24 thru 0x73bed	(0x7eca bytes)	******PPPP
6216905(201 mod 256): CLONE 0x5b000 thru 0x63fff	(0x9000 bytes) to 0x39000 thru 0x41fff
6216906(202 mod 256): PUNCH    0x3a291 thru 0x540fc	(0x19e6c bytes)
6216907(203 mod 256): INSERT 0x1a000 thru 0x33fff	(0x1a000 bytes)
6216908(204 mod 256): MAPWRITE 0x8f707 thru 0x927bf	(0x30b9 bytes)
6216909(205 mod 256): WRITE    0x22bdf thru 0x35ba0	(0x12fc2 bytes)
6216910(206 mod 256): DEDUPE 0x8b000 thru 0x8efff	(0x4000 bytes) to 0x30000 thru 0x33fff
6216911(207 mod 256): PUNCH    0x55325 thru 0x64a62	(0xf73e bytes)
6216912(208 mod 256): MAPWRITE 0x302ea thru 0x402bf	(0xffd6 bytes)
6216913(209 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5cb51	******WWWW
6216914(210 mod 256): SKIPPED (no operation)
6216915(211 mod 256): DEDUPE 0x0 thru 0x18fff	(0x19000 bytes) to 0x2f000 thru 0x47fff
6216916(212 mod 256): COPY 0x36413 thru 0x38f21	(0x2b0f bytes) to 0x4cc98 thru 0x4f7a6
6216917(213 mod 256): COPY 0x4323d thru 0x4558d	(0x2351 bytes) to 0x1a801 thru 0x1cb51
6216918(214 mod 256): READ     0x5cb38 thru 0x5cb50	(0x19 bytes)
6216919(215 mod 256): DEDUPE 0x47000 thru 0x51fff	(0xb000 bytes) to 0x23000 thru 0x2dfff
6216920(216 mod 256): PUNCH    0x3487d thru 0x3f75d	(0xaee1 bytes)
6216921(217 mod 256): SKIPPED (no operation)
6216922(218 mod 256): SKIPPED (no operation)
6216923(219 mod 256): CLONE 0x49000 thru 0x5bfff	(0x13000 bytes) to 0x18000 thru 0x2afff
6216924(220 mod 256): MAPREAD  0x45683 thru 0x4fc6f	(0xa5ed bytes)
6216925(221 mod 256): READ     0x4eb4a thru 0x5cb50	(0xe007 bytes)
6216926(222 mod 256): TRUNCATE DOWN	from 0x5cb51 to 0x23691
6216927(223 mod 256): COLLAPSE 0x20000 thru 0x22fff	(0x3000 bytes)
6216928(224 mod 256): WRITE    0x84329 thru 0x88b48	(0x4820 bytes) HOLE	***WWWW
6216929(225 mod 256): WRITE    0x5a4eb thru 0x6a3c7	(0xfedd bytes)
6216930(226 mod 256): SKIPPED (no operation)
6216931(227 mod 256): PUNCH    0x11c2e thru 0x192ca	(0x769d bytes)
6216932(228 mod 256): PUNCH    0x54dde thru 0x6e653	(0x19876 bytes)
6216933(229 mod 256): WRITE    0x3169c thru 0x4d0d6	(0x1ba3b bytes)
6216934(230 mod 256): READ     0x1478b thru 0x32f7d	(0x1e7f3 bytes)
6216935(231 mod 256): MAPREAD  0x1b216 thru 0x32683	(0x1746e bytes)
6216936(232 mod 256): DEDUPE 0x66000 thru 0x80fff	(0x1b000 bytes) to 0x3000 thru 0x1dfff	BBBB******
6216937(233 mod 256): MAPREAD  0xc0a5 thru 0x1407d	(0x7fd9 bytes)
6216938(234 mod 256): CLONE 0x2b000 thru 0x45fff	(0x1b000 bytes) to 0x6c000 thru 0x86fff	******JJJJ
6216939(235 mod 256): MAPREAD  0x59094 thru 0x65e2d	(0xcd9a bytes)
6216940(236 mod 256): COPY 0xef8d thru 0x2b29f	(0x1c313 bytes) to 0x32658 thru 0x4e96a
6216941(237 mod 256): WRITE    0x12341 thru 0x12bce	(0x88e bytes)
6216942(238 mod 256): SKIPPED (no operation)
6216943(239 mod 256): FALLOC   0x82b30 thru 0x84196	(0x1666 bytes) INTERIOR
6216944(240 mod 256): FALLOC   0x5cf1c thru 0x748e0	(0x179c4 bytes) INTERIOR	******FFFF
6216945(241 mod 256): WRITE    0x11c1b thru 0x1aa77	(0x8e5d bytes)
6216946(242 mod 256): TRUNCATE DOWN	from 0x88b49 to 0x214bd	******WWWW
6216947(243 mod 256): SKIPPED (no operation)
6216948(244 mod 256): COLLAPSE 0x1000 thru 0x13fff	(0x13000 bytes)
6216949(245 mod 256): ZERO     0x66338 thru 0x7eff0	(0x18cb9 bytes)	******ZZZZ
6216950(246 mod 256): MAPWRITE 0x32ec7 thru 0x4d43d	(0x1a577 bytes)
6216951(247 mod 256): READ     0x4af52 thru 0x4d43d	(0x24ec bytes)
6216952(248 mod 256): ZERO     0x22bb7 thru 0x26de3	(0x422d bytes)
6216953(249 mod 256): SKIPPED (no operation)
6216954(250 mod 256): FALLOC   0x71631 thru 0x904e7	(0x1eeb6 bytes) PAST_EOF
6216955(251 mod 256): COPY 0x42aee thru 0x4d43d	(0xa950 bytes) to 0x669a2 thru 0x712f1	******EEEE
6216956(252 mod 256): ZERO     0x8c1a8 thru 0x9252d	(0x6386 bytes)
6216957(253 mod 256): READ     0x6d74b thru 0x6de02	(0x6b8 bytes)
6216958(254 mod 256): TRUNCATE DOWN	from 0x9252e to 0x5fcb9	******WWWW
6216959(255 mod 256): PUNCH    0x18942 thru 0x24640	(0xbcff bytes)
6216960(  0 mod 256): CLONE 0xb000 thru 0xefff	(0x4000 bytes) to 0x62000 thru 0x65fff
6216961(  1 mod 256): DEDUPE 0x15000 thru 0x1cfff	(0x8000 bytes) to 0x34000 thru 0x3bfff
6216962(  2 mod 256): MAPREAD  0x64e33 thru 0x65fff	(0x11cd bytes)
6216963(  3 mod 256): CLONE 0x45000 thru 0x61fff	(0x1d000 bytes) to 0x6f000 thru 0x8bfff
6216964(  4 mod 256): READ     0xf8fc thru 0x2a9f6	(0x1b0fb bytes)
6216965(  5 mod 256): TRUNCATE DOWN	from 0x8c000 to 0x3893a	******WWWW
6216966(  6 mod 256): SKIPPED (no operation)
6216967(  7 mod 256): SKIPPED (no operation)
6216968(  8 mod 256): ZERO     0x7012f thru 0x84a1b	(0x148ed bytes)
6216969(  9 mod 256): SKIPPED (no operation)
6216970( 10 mod 256): ZERO     0x7ecb4 thru 0x927bf	(0x13b0c bytes)
6216971( 11 mod 256): PUNCH    0x11864 thru 0x2ae1a	(0x195b7 bytes)
6216972( 12 mod 256): COPY 0x2f179 thru 0x38939	(0x97c1 bytes) to 0x5b94e thru 0x6510e
6216973( 13 mod 256): SKIPPED (no operation)
6216974( 14 mod 256): MAPWRITE 0x17940 thru 0x21475	(0x9b36 bytes)
6216975( 15 mod 256): READ     0x32012 thru 0x37ff7	(0x5fe6 bytes)
6216976( 16 mod 256): PUNCH    0x39f3e thru 0x44f91	(0xb054 bytes)
6216977( 17 mod 256): CLONE 0x8000 thru 0x1dfff	(0x16000 bytes) to 0x31000 thru 0x46fff
6216978( 18 mod 256): PUNCH    0x5b171 thru 0x5e7a7	(0x3637 bytes)
6216979( 19 mod 256): PUNCH    0x46ae7 thru 0x52a1b	(0xbf35 bytes)
6216980( 20 mod 256): COPY 0xca15 thru 0x129bb	(0x5fa7 bytes) to 0x86e52 thru 0x8cdf8
6216981( 21 mod 256): CLONE 0x28000 thru 0x2ffff	(0x8000 bytes) to 0x68000 thru 0x6ffff	******JJJJ
6216982( 22 mod 256): MAPREAD  0x696e4 thru 0x6a0f3	(0xa10 bytes)
6216983( 23 mod 256): COLLAPSE 0x18000 thru 0x26fff	(0xf000 bytes)
6216984( 24 mod 256): PUNCH    0x5f73e thru 0x756a7	(0x15f6a bytes)	******PPPP
6216985( 25 mod 256): PUNCH    0x1f637 thru 0x3439e	(0x14d68 bytes)
6216986( 26 mod 256): READ     0x719dc thru 0x7ddf8	(0xc41d bytes)
6216987( 27 mod 256): COLLAPSE 0x18000 thru 0x2afff	(0x13000 bytes)
6216988( 28 mod 256): CLONE 0x1c000 thru 0x35fff	(0x1a000 bytes) to 0x3b000 thru 0x54fff
6216989( 29 mod 256): DEDUPE 0x4000 thru 0x5fff	(0x2000 bytes) to 0x4f000 thru 0x50fff
6216990( 30 mod 256): FALLOC   0x48b73 thru 0x50974	(0x7e01 bytes) INTERIOR
6216991( 31 mod 256): MAPWRITE 0x3f77c thru 0x4b730	(0xbfb5 bytes)
6216992( 32 mod 256): PUNCH    0x23503 thru 0x29a7c	(0x657a bytes)
6216993( 33 mod 256): PUNCH    0x47f64 thru 0x51d66	(0x9e03 bytes)
6216994( 34 mod 256): SKIPPED (no operation)
6216995( 35 mod 256): WRITE    0x25197 thru 0x3d252	(0x180bc bytes)
6216996( 36 mod 256): TRUNCATE DOWN	from 0x6adf9 to 0x5bd16
6216997( 37 mod 256): DEDUPE 0x4d000 thru 0x59fff	(0xd000 bytes) to 0x2000 thru 0xefff
6216998( 38 mod 256): INSERT 0x2c000 thru 0x3afff	(0xf000 bytes)
6216999( 39 mod 256): FALLOC   0x81b03 thru 0x9241e	(0x1091b bytes) EXTENDING
6217000( 40 mod 256): MAPREAD  0x56de9 thru 0x70763	(0x1997b bytes)	***RRRR***
6217001( 41 mod 256): TRUNCATE DOWN	from 0x9241e to 0x32960	******WWWW
6217002( 42 mod 256): MAPREAD  0x31dea thru 0x3295f	(0xb76 bytes)
6217003( 43 mod 256): COLLAPSE 0x24000 thru 0x31fff	(0xe000 bytes)
6217004( 44 mod 256): CLONE 0x2000 thru 0x16fff	(0x15000 bytes) to 0x42000 thru 0x56fff
6217005( 45 mod 256): COLLAPSE 0x20000 thru 0x21fff	(0x2000 bytes)
6217006( 46 mod 256): ZERO     0x4508c thru 0x515f9	(0xc56e bytes)
6217007( 47 mod 256): CLONE 0x2b000 thru 0x3bfff	(0x11000 bytes) to 0x47000 thru 0x57fff
6217008( 48 mod 256): SKIPPED (no operation)
6217009( 49 mod 256): DEDUPE 0x3f000 thru 0x43fff	(0x5000 bytes) to 0x45000 thru 0x49fff
6217010( 50 mod 256): PUNCH    0x4c769 thru 0x57fff	(0xb897 bytes)
6217011( 51 mod 256): TRUNCATE UP	from 0x58000 to 0x7e5c0	******WWWW
6217012( 52 mod 256): MAPREAD  0x364c9 thru 0x4a87e	(0x143b6 bytes)
6217013( 53 mod 256): READ     0x56c5f thru 0x67861	(0x10c03 bytes)
6217014( 54 mod 256): MAPWRITE 0x82802 thru 0x927bf	(0xffbe bytes)
6217015( 55 mod 256): READ     0x6ba4e thru 0x78d53	(0xd306 bytes)	***RRRR***
6217016( 56 mod 256): DEDUPE 0x6a000 thru 0x87fff	(0x1e000 bytes) to 0x22000 thru 0x3ffff	BBBB******
6217017( 57 mod 256): SKIPPED (no operation)
6217018( 58 mod 256): CLONE 0x67000 thru 0x7efff	(0x18000 bytes) to 0x45000 thru 0x5cfff	JJJJ******
6217019( 59 mod 256): DEDUPE 0x45000 thru 0x62fff	(0x1e000 bytes) to 0x1b000 thru 0x38fff
6217020( 60 mod 256): FALLOC   0x1ad77 thru 0x36a20	(0x1bca9 bytes) INTERIOR
6217021( 61 mod 256): MAPWRITE 0x482c5 thru 0x56852	(0xe58e bytes)
6217022( 62 mod 256): PUNCH    0xe2a1 thru 0x18917	(0xa677 bytes)
6217023( 63 mod 256): MAPWRITE 0x52a6b thru 0x64fcd	(0x12563 bytes)
6217024( 64 mod 256): MAPWRITE 0x7d95 thru 0x1acf4	(0x12f60 bytes)
6217025( 65 mod 256): SKIPPED (no operation)
6217026( 66 mod 256): SKIPPED (no operation)
6217027( 67 mod 256): MAPREAD  0x1bf7e thru 0x35c6e	(0x19cf1 bytes)
6217028( 68 mod 256): FALLOC   0x61cc1 thru 0x807fd	(0x1eb3c bytes) INTERIOR	******FFFF
6217029( 69 mod 256): SKIPPED (no operation)
6217030( 70 mod 256): SKIPPED (no operation)
6217031( 71 mod 256): SKIPPED (no operation)
6217032( 72 mod 256): DEDUPE 0x28000 thru 0x43fff	(0x1c000 bytes) to 0x1000 thru 0x1cfff
6217033( 73 mod 256): ZERO     0x12ba0 thru 0x19c9b	(0x70fc bytes)
6217034( 74 mod 256): READ     0xdac0 thru 0x1c050	(0xe591 bytes)
6217035( 75 mod 256): DEDUPE 0x85000 thru 0x91fff	(0xd000 bytes) to 0x11000 thru 0x1dfff
6217036( 76 mod 256): SKIPPED (no operation)
6217037( 77 mod 256): MAPWRITE 0x19eeb thru 0x2b004	(0x1111a bytes)
6217038( 78 mod 256): ZERO     0x337d8 thru 0x432ba	(0xfae3 bytes)
6217039( 79 mod 256): MAPREAD  0x1e95f thru 0x259c5	(0x7067 bytes)
6217040( 80 mod 256): CLONE 0x39000 thru 0x50fff	(0x18000 bytes) to 0x71000 thru 0x88fff
6217041( 81 mod 256): FALLOC   0x295fa thru 0x39fd1	(0x109d7 bytes) INTERIOR
6217042( 82 mod 256): MAPWRITE 0x3c436 thru 0x50242	(0x13e0d bytes)
6217043( 83 mod 256): DEDUPE 0x2a000 thru 0x3cfff	(0x13000 bytes) to 0x71000 thru 0x83fff
6217044( 84 mod 256): MAPWRITE 0x3c6a2 thru 0x54f5d	(0x188bc bytes)
6217045( 85 mod 256): READ     0x26180 thru 0x432f8	(0x1d179 bytes)
6217046( 86 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x518bf	******WWWW
6217047( 87 mod 256): FALLOC   0x4a0e3 thru 0x4fd97	(0x5cb4 bytes) INTERIOR
6217048( 88 mod 256): MAPWRITE 0x75b5c thru 0x8abfd	(0x150a2 bytes)
6217049( 89 mod 256): ZERO     0x786b9 thru 0x87ba6	(0xf4ee bytes)
6217050( 90 mod 256): INSERT 0x63000 thru 0x69fff	(0x7000 bytes)
6217051( 91 mod 256): COPY 0x3077e thru 0x4cd7c	(0x1c5ff bytes) to 0x53e70 thru 0x7046e	******EEEE
6217052( 92 mod 256): READ     0x7328c thru 0x8ca83	(0x197f8 bytes)
6217053( 93 mod 256): SKIPPED (no operation)
6217054( 94 mod 256): FALLOC   0x5da3 thru 0x873b	(0x2998 bytes) INTERIOR
6217055( 95 mod 256): READ     0x74988 thru 0x78401	(0x3a7a bytes)
6217056( 96 mod 256): COLLAPSE 0x71000 thru 0x73fff	(0x3000 bytes)
6217057( 97 mod 256): INSERT 0x37000 thru 0x39fff	(0x3000 bytes)
6217058( 98 mod 256): MAPREAD  0x406fb thru 0x4fc3a	(0xf540 bytes)
6217059( 99 mod 256): READ     0x3dfba thru 0x56325	(0x1836c bytes)
6217060(100 mod 256): TRUNCATE DOWN	from 0x91bfe to 0x5742f	******WWWW
6217061(101 mod 256): FALLOC   0x34498 thru 0x354e3	(0x104b bytes) INTERIOR
6217062(102 mod 256): MAPWRITE 0x54693 thru 0x71613	(0x1cf81 bytes)	******WWWW
6217063(103 mod 256): MAPWRITE 0x1042d thru 0x1653b	(0x610f bytes)
6217064(104 mod 256): WRITE    0x801a9 thru 0x913ba	(0x11212 bytes) HOLE
6217065(105 mod 256): COLLAPSE 0x7e000 thru 0x8ffff	(0x12000 bytes)
6217066(106 mod 256): CLONE 0x27000 thru 0x32fff	(0xc000 bytes) to 0x47000 thru 0x52fff
6217067(107 mod 256): DEDUPE 0x22000 thru 0x39fff	(0x18000 bytes) to 0x5b000 thru 0x72fff	******BBBB
6217068(108 mod 256): ZERO     0xdaed thru 0x2b2a7	(0x1d7bb bytes)
6217069(109 mod 256): READ     0x333d8 thru 0x51c7e	(0x1e8a7 bytes)
6217070(110 mod 256): COLLAPSE 0x46000 thru 0x56fff	(0x11000 bytes)
6217071(111 mod 256): WRITE    0x31d17 thru 0x3f484	(0xd76e bytes)
6217072(112 mod 256): SKIPPED (no operation)
6217073(113 mod 256): COPY 0x583c7 thru 0x623a7	(0x9fe1 bytes) to 0x81e24 thru 0x8be04
6217074(114 mod 256): PUNCH    0xd4b4 thru 0x2beb8	(0x1ea05 bytes)
6217075(115 mod 256): CLONE 0x61000 thru 0x67fff	(0x7000 bytes) to 0x2b000 thru 0x31fff
6217076(116 mod 256): MAPWRITE 0x8cd15 thru 0x927bf	(0x5aab bytes)
6217077(117 mod 256): SKIPPED (no operation)
6217078(118 mod 256): MAPWRITE 0x79352 thru 0x8f3bc	(0x1606b bytes)
6217079(119 mod 256): SKIPPED (no operation)
6217080(120 mod 256): COPY 0x90f70 thru 0x927bf	(0x1850 bytes) to 0x85e60 thru 0x876af
6217081(121 mod 256): SKIPPED (no operation)
6217082(122 mod 256): SKIPPED (no operation)
6217083(123 mod 256): CLONE 0x3c000 thru 0x4afff	(0xf000 bytes) to 0x63000 thru 0x71fff	******JJJJ
6217084(124 mod 256): DEDUPE 0x86000 thru 0x91fff	(0xc000 bytes) to 0x12000 thru 0x1dfff
6217085(125 mod 256): FALLOC   0x35ca1 thru 0x54be8	(0x1ef47 bytes) INTERIOR
6217086(126 mod 256): COLLAPSE 0x79000 thru 0x81fff	(0x9000 bytes)
6217087(127 mod 256): MAPREAD  0x600d3 thru 0x61531	(0x145f bytes)
6217088(128 mod 256): PUNCH    0x67702 thru 0x6abf8	(0x34f7 bytes)
6217089(129 mod 256): CLONE 0x26000 thru 0x33fff	(0xe000 bytes) to 0x51000 thru 0x5efff
6217090(130 mod 256): MAPREAD  0x4c9d7 thru 0x53293	(0x68bd bytes)
6217091(131 mod 256): CLONE 0x29000 thru 0x3bfff	(0x13000 bytes) to 0x7c000 thru 0x8efff
6217092(132 mod 256): COLLAPSE 0x6b000 thru 0x6dfff	(0x3000 bytes)
6217093(133 mod 256): COLLAPSE 0x85000 thru 0x89fff	(0x5000 bytes)
6217094(134 mod 256): FALLOC   0x236ae thru 0x2e602	(0xaf54 bytes) INTERIOR
6217095(135 mod 256): MAPREAD  0x187e3 thru 0x1e9db	(0x61f9 bytes)
6217096(136 mod 256): MAPREAD  0x7f431 thru 0x86fff	(0x7bcf bytes)
6217097(137 mod 256): DEDUPE 0x1e000 thru 0x29fff	(0xc000 bytes) to 0x68000 thru 0x73fff	******BBBB
6217098(138 mod 256): MAPREAD  0x62970 thru 0x69d43	(0x73d4 bytes)
6217099(139 mod 256): READ     0x536c6 thru 0x70006	(0x1c941 bytes)	***RRRR***
6217100(140 mod 256): TRUNCATE DOWN	from 0x87000 to 0x5be84	******WWWW
6217101(141 mod 256): SKIPPED (no operation)
6217102(142 mod 256): ZERO     0x2e87b thru 0x346dc	(0x5e62 bytes)
6217103(143 mod 256): FALLOC   0x1d67b thru 0x24eac	(0x7831 bytes) INTERIOR
6217104(144 mod 256): INSERT 0x36000 thru 0x40fff	(0xb000 bytes)
6217105(145 mod 256): PUNCH    0x60005 thru 0x61d8f	(0x1d8b bytes)
6217106(146 mod 256): DEDUPE 0x3d000 thru 0x47fff	(0xb000 bytes) to 0x4f000 thru 0x59fff
6217107(147 mod 256): FALLOC   0x440a thru 0x1405a	(0xfc50 bytes) INTERIOR
6217108(148 mod 256): SKIPPED (no operation)
6217109(149 mod 256): FALLOC   0xe289 thru 0x20228	(0x11f9f bytes) INTERIOR
6217110(150 mod 256): COLLAPSE 0x3c000 thru 0x4ffff	(0x14000 bytes)
6217111(151 mod 256): MAPWRITE 0x8f22b thru 0x927bf	(0x3595 bytes)
6217112(152 mod 256): READ     0x24234 thru 0x40b53	(0x1c920 bytes)
6217113(153 mod 256): PUNCH    0x2360c thru 0x3e4a1	(0x1ae96 bytes)
6217114(154 mod 256): COLLAPSE 0x7c000 thru 0x7ffff	(0x4000 bytes)
6217115(155 mod 256): INSERT 0x80000 thru 0x83fff	(0x4000 bytes)
6217116(156 mod 256): SKIPPED (no operation)
6217117(157 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4807a	******WWWW
6217118(158 mod 256): COLLAPSE 0x2d000 thru 0x43fff	(0x17000 bytes)
6217119(159 mod 256): MAPREAD  0x2fb15 thru 0x31079	(0x1565 bytes)
6217120(160 mod 256): WRITE    0x2c89d thru 0x347ec	(0x7f50 bytes) EXTEND
6217121(161 mod 256): SKIPPED (no operation)
6217122(162 mod 256): INSERT 0x31000 thru 0x46fff	(0x16000 bytes)
6217123(163 mod 256): FALLOC   0x29141 thru 0x4154f	(0x1840e bytes) INTERIOR
6217124(164 mod 256): ZERO     0x8786c thru 0x89e31	(0x25c6 bytes)
6217125(165 mod 256): TRUNCATE DOWN	from 0x4a7ed to 0x32ef6
6217126(166 mod 256): CLONE 0x31000 thru 0x31fff	(0x1000 bytes) to 0x1d000 thru 0x1dfff
6217127(167 mod 256): MAPWRITE 0x91f48 thru 0x927bf	(0x878 bytes)
6217128(168 mod 256): FALLOC   0xbb59 thru 0xe049	(0x24f0 bytes) INTERIOR
6217129(169 mod 256): SKIPPED (no operation)
6217130(170 mod 256): SKIPPED (no operation)
6217131(171 mod 256): DEDUPE 0x89000 thru 0x90fff	(0x8000 bytes) to 0x70000 thru 0x77fff
6217132(172 mod 256): DEDUPE 0x4c000 thru 0x64fff	(0x19000 bytes) to 0x2f000 thru 0x47fff
6217133(173 mod 256): WRITE    0x634c2 thru 0x64b3f	(0x167e bytes)
6217134(174 mod 256): SKIPPED (no operation)
6217135(175 mod 256): PUNCH    0x4e962 thru 0x5c2dd	(0xd97c bytes)
6217136(176 mod 256): FALLOC   0x7e586 thru 0x927c0	(0x1423a bytes) INTERIOR
6217137(177 mod 256): PUNCH    0x84dca thru 0x9077e	(0xb9b5 bytes)
6217138(178 mod 256): DEDUPE 0x66000 thru 0x6efff	(0x9000 bytes) to 0x45000 thru 0x4dfff	BBBB******
6217139(179 mod 256): WRITE    0x81fb6 thru 0x85e45	(0x3e90 bytes)
6217140(180 mod 256): MAPWRITE 0xb785 thru 0x152fe	(0x9b7a bytes)
6217141(181 mod 256): ZERO     0x21958 thru 0x3a78c	(0x18e35 bytes)
6217142(182 mod 256): PUNCH    0x6b5eb thru 0x7b2b2	(0xfcc8 bytes)	******PPPP
6217143(183 mod 256): READ     0x8b401 thru 0x927bf	(0x73bf bytes)
6217144(184 mod 256): CLONE 0x87000 thru 0x90fff	(0xa000 bytes) to 0x28000 thru 0x31fff
6217145(185 mod 256): MAPREAD  0x881a5 thru 0x8efea	(0x6e46 bytes)
6217146(186 mod 256): FALLOC   0x84ee7 thru 0x927c0	(0xd8d9 bytes) INTERIOR
6217147(187 mod 256): SKIPPED (no operation)
6217148(188 mod 256): FALLOC   0x7c3a0 thru 0x8573c	(0x939c bytes) INTERIOR
6217149(189 mod 256): READ     0x25522 thru 0x388a5	(0x13384 bytes)
6217150(190 mod 256): MAPREAD  0x46cea thru 0x5cc5a	(0x15f71 bytes)
6217151(191 mod 256): DEDUPE 0x14000 thru 0x19fff	(0x6000 bytes) to 0x7000 thru 0xcfff
6217152(192 mod 256): ZERO     0x1de48 thru 0x3978b	(0x1b944 bytes)
6217153(193 mod 256): WRITE    0x2aba2 thru 0x322bd	(0x771c bytes)
6217154(194 mod 256): CLONE 0x80000 thru 0x89fff	(0xa000 bytes) to 0xb000 thru 0x14fff
6217155(195 mod 256): WRITE    0x8c118 thru 0x927bf	(0x66a8 bytes)
6217156(196 mod 256): READ     0x18e1d thru 0x2c75a	(0x1393e bytes)
6217157(197 mod 256): DEDUPE 0x7e000 thru 0x84fff	(0x7000 bytes) to 0x3a000 thru 0x40fff
6217158(198 mod 256): MAPREAD  0x75e62 thru 0x7d33a	(0x74d9 bytes)
6217159(199 mod 256): MAPREAD  0x1cbab thru 0x38ff6	(0x1c44c bytes)
6217160(200 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2b685	******WWWW
6217161(201 mod 256): PUNCH    0x17f60 thru 0x1a521	(0x25c2 bytes)
6217162(202 mod 256): TRUNCATE UP	from 0x2b685 to 0x910c7	******WWWW
6217163(203 mod 256): COLLAPSE 0x7d000 thru 0x8cfff	(0x10000 bytes)
6217164(204 mod 256): ZERO     0x4c174 thru 0x576da	(0xb567 bytes)
6217165(205 mod 256): WRITE    0x7712 thru 0xb3e8	(0x3cd7 bytes)
6217166(206 mod 256): INSERT 0x23000 thru 0x33fff	(0x11000 bytes)
6217167(207 mod 256): MAPREAD  0x7824a thru 0x88689	(0x10440 bytes)
6217168(208 mod 256): MAPREAD  0x66c1 thru 0xba06	(0x5346 bytes)
6217169(209 mod 256): WRITE    0x232b4 thru 0x2d0b1	(0x9dfe bytes)
6217170(210 mod 256): COLLAPSE 0x58000 thru 0x5bfff	(0x4000 bytes)
6217171(211 mod 256): COPY 0x7e3c6 thru 0x8e0c6	(0xfd01 bytes) to 0x65ed3 thru 0x75bd3	******EEEE
6217172(212 mod 256): MAPREAD  0x587ba thru 0x5e648	(0x5e8f bytes)
6217173(213 mod 256): MAPREAD  0x2f98d thru 0x30023	(0x697 bytes)
6217174(214 mod 256): MAPWRITE 0x8374e thru 0x889b4	(0x5267 bytes)
6217175(215 mod 256): WRITE    0xe1d9 thru 0x15df4	(0x7c1c bytes)
6217176(216 mod 256): ZERO     0x67bc2 thru 0x68457	(0x896 bytes)
6217177(217 mod 256): COLLAPSE 0x3000 thru 0x4fff	(0x2000 bytes)
6217178(218 mod 256): TRUNCATE DOWN	from 0x8c0c7 to 0x39c88	******WWWW
6217179(219 mod 256): FALLOC   0x7bd8f thru 0x927c0	(0x16a31 bytes) EXTENDING
6217180(220 mod 256): COPY 0x4b52a thru 0x553be	(0x9e95 bytes) to 0x6979a thru 0x7362e	******EEEE
6217181(221 mod 256): MAPREAD  0xc73d thru 0x24d34	(0x185f8 bytes)
6217182(222 mod 256): SKIPPED (no operation)
6217183(223 mod 256): DEDUPE 0x1f000 thru 0x22fff	(0x4000 bytes) to 0x8000 thru 0xbfff
6217184(224 mod 256): ZERO     0x4844d thru 0x606c3	(0x18277 bytes)
6217185(225 mod 256): MAPWRITE 0x45bb8 thru 0x4f3bd	(0x9806 bytes)
6217186(226 mod 256): MAPWRITE 0x37cc0 thru 0x4fd10	(0x18051 bytes)
6217187(227 mod 256): SKIPPED (no operation)
6217188(228 mod 256): SKIPPED (no operation)
6217189(229 mod 256): ZERO     0x9e03 thru 0x17ec8	(0xe0c6 bytes)
6217190(230 mod 256): READ     0x32a05 thru 0x46c88	(0x14284 bytes)
6217191(231 mod 256): MAPREAD  0x43cce thru 0x53cca	(0xfffd bytes)
6217192(232 mod 256): FALLOC   0x2b8c5 thru 0x30044	(0x477f bytes) INTERIOR
6217193(233 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x805a3
6217194(234 mod 256): PUNCH    0x39cb7 thru 0x41b33	(0x7e7d bytes)
6217195(235 mod 256): WRITE    0x13982 thru 0x207eb	(0xce6a bytes)
6217196(236 mod 256): COPY 0x5442 thru 0x6564	(0x1123 bytes) to 0x1a38c thru 0x1b4ae
6217197(237 mod 256): FALLOC   0x34f9 thru 0x1b29a	(0x17da1 bytes) INTERIOR
6217198(238 mod 256): WRITE    0x315f2 thru 0x3f339	(0xdd48 bytes)
6217199(239 mod 256): MAPWRITE 0x67ba9 thru 0x84916	(0x1cd6e bytes)	******WWWW
6217200(240 mod 256): PUNCH    0x61589 thru 0x77e6d	(0x168e5 bytes)	******PPPP
6217201(241 mod 256): FALLOC   0x44d2e thru 0x4f272	(0xa544 bytes) INTERIOR
6217202(242 mod 256): FALLOC   0x318bd thru 0x32f7d	(0x16c0 bytes) INTERIOR
6217203(243 mod 256): COPY 0x89d4 thru 0x279b5	(0x1efe2 bytes) to 0x45a13 thru 0x649f4
6217204(244 mod 256): ZERO     0x32c9c thru 0x4357f	(0x108e4 bytes)
6217205(245 mod 256): ZERO     0x8d896 thru 0x927bf	(0x4f2a bytes)
6217206(246 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x59efd	******WWWW
6217207(247 mod 256): COPY 0x58c10 thru 0x59efc	(0x12ed bytes) to 0x4f8b6 thru 0x50ba2
6217208(248 mod 256): INSERT 0x3f000 thru 0x43fff	(0x5000 bytes)
6217209(249 mod 256): CLONE 0x38000 thru 0x4bfff	(0x14000 bytes) to 0x7d000 thru 0x90fff
6217210(250 mod 256): TRUNCATE DOWN	from 0x91000 to 0x60913	******WWWW
6217211(251 mod 256): COLLAPSE 0x39000 thru 0x56fff	(0x1e000 bytes)
6217212(252 mod 256): ZERO     0x2f7aa thru 0x3b0ea	(0xb941 bytes)
6217213(253 mod 256): FALLOC   0x5cf6d thru 0x60ff2	(0x4085 bytes) EXTENDING
6217214(254 mod 256): COPY 0x60ba3 thru 0x60ff1	(0x44f bytes) to 0x61413 thru 0x61861
6217215(255 mod 256): COLLAPSE 0x2e000 thru 0x3ffff	(0x12000 bytes)
6217216(  0 mod 256): MAPREAD  0x25e1 thru 0x3062	(0xa82 bytes)
6217217(  1 mod 256): FALLOC   0x5a769 thru 0x75511	(0x1ada8 bytes) PAST_EOF	******FFFF
6217218(  2 mod 256): MAPREAD  0x49af9 thru 0x4f861	(0x5d69 bytes)
6217219(  3 mod 256): COLLAPSE 0x2e000 thru 0x37fff	(0xa000 bytes)
6217220(  4 mod 256): COLLAPSE 0x3e000 thru 0x43fff	(0x6000 bytes)
6217221(  5 mod 256): FALLOC   0x1561f thru 0x1f2a9	(0x9c8a bytes) INTERIOR
6217222(  6 mod 256): FALLOC   0x6c241 thru 0x6cbfb	(0x9ba bytes) PAST_EOF
6217223(  7 mod 256): COLLAPSE 0x1e000 thru 0x25fff	(0x8000 bytes)
6217224(  8 mod 256): DEDUPE 0x1c000 thru 0x23fff	(0x8000 bytes) to 0x26000 thru 0x2dfff
6217225(  9 mod 256): ZERO     0x3d59f thru 0x5b7e7	(0x1e249 bytes)
6217226( 10 mod 256): TRUNCATE UP	from 0x37862 to 0x4e4d4
6217227( 11 mod 256): READ     0x185b8 thru 0x2b4d4	(0x12f1d bytes)
6217228( 12 mod 256): MAPREAD  0xc4d7 thru 0x13940	(0x746a bytes)
6217229( 13 mod 256): ZERO     0x5e616 thru 0x79b6e	(0x1b559 bytes)	******ZZZZ
6217230( 14 mod 256): COLLAPSE 0x26000 thru 0x2efff	(0x9000 bytes)
6217231( 15 mod 256): MAPREAD  0x15622 thru 0x165bd	(0xf9c bytes)
6217232( 16 mod 256): INSERT 0x4000 thru 0x1dfff	(0x1a000 bytes)
6217233( 17 mod 256): MAPREAD  0x11af thru 0x1ee74	(0x1dcc6 bytes)
6217234( 18 mod 256): TRUNCATE DOWN	from 0x5f4d4 to 0x23ca7
6217235( 19 mod 256): READ     0x577f thru 0x9304	(0x3b86 bytes)
6217236( 20 mod 256): COLLAPSE 0xd000 thru 0x16fff	(0xa000 bytes)
6217237( 21 mod 256): PUNCH    0xa65e thru 0x19ca6	(0xf649 bytes)
6217238( 22 mod 256): WRITE    0x92244 thru 0x927bf	(0x57c bytes) HOLE	***WWWW
6217239( 23 mod 256): SKIPPED (no operation)
6217240( 24 mod 256): ZERO     0x3abfb thru 0x5596e	(0x1ad74 bytes)
6217241( 25 mod 256): FALLOC   0x91453 thru 0x927c0	(0x136d bytes) INTERIOR
6217242( 26 mod 256): READ     0x6c0cc thru 0x7a125	(0xe05a bytes)	***RRRR***
6217243( 27 mod 256): WRITE    0x2cc4b thru 0x39cb4	(0xd06a bytes)
6217244( 28 mod 256): READ     0x87e1f thru 0x8ee2c	(0x700e bytes)
6217245( 29 mod 256): CLONE 0x22000 thru 0x38fff	(0x17000 bytes) to 0x0 thru 0x16fff
6217246( 30 mod 256): ZERO     0x19d14 thru 0x1b93e	(0x1c2b bytes)
6217247( 31 mod 256): FALLOC   0x13c0f thru 0x267fe	(0x12bef bytes) INTERIOR
6217248( 32 mod 256): COLLAPSE 0x5b000 thru 0x71fff	(0x17000 bytes)	******CCCC
6217249( 33 mod 256): MAPREAD  0x29d41 thru 0x3e6a1	(0x14961 bytes)
6217250( 34 mod 256): WRITE    0x36524 thru 0x52b07	(0x1c5e4 bytes)
6217251( 35 mod 256): WRITE    0xd932 thru 0x2ade7	(0x1d4b6 bytes)
6217252( 36 mod 256): INSERT 0xd000 thru 0x21fff	(0x15000 bytes)
6217253( 37 mod 256): READ     0x2ed89 thru 0x338c6	(0x4b3e bytes)
6217254( 38 mod 256): FALLOC   0x71a4b thru 0x72a80	(0x1035 bytes) INTERIOR
6217255( 39 mod 256): COPY 0x7b08c thru 0x7f565	(0x44da bytes) to 0x6a736 thru 0x6ec0f
6217256( 40 mod 256): TRUNCATE DOWN	from 0x907c0 to 0x89d4	******WWWW
6217257( 41 mod 256): ZERO     0x4be63 thru 0x58bca	(0xcd68 bytes)
6217258( 42 mod 256): CLONE 0x23000 thru 0x25fff	(0x3000 bytes) to 0x82000 thru 0x84fff
6217259( 43 mod 256): PUNCH    0x34f27 thru 0x3f341	(0xa41b bytes)
6217260( 44 mod 256): WRITE    0x4af71 thru 0x53991	(0x8a21 bytes)
6217261( 45 mod 256): READ     0x497fa thru 0x4c8c9	(0x30d0 bytes)
6217262( 46 mod 256): PUNCH    0x2b93c thru 0x2e7aa	(0x2e6f bytes)
6217263( 47 mod 256): ZERO     0x2695e thru 0x437f2	(0x1ce95 bytes)
6217264( 48 mod 256): MAPREAD  0x4cc83 thru 0x64274	(0x175f2 bytes)
6217265( 49 mod 256): WRITE    0x6ff8d thru 0x718c9	(0x193d bytes)
6217266( 50 mod 256): SKIPPED (no operation)
6217267( 51 mod 256): ZERO     0xbdb1 thru 0x20234	(0x14484 bytes)
6217268( 52 mod 256): INSERT 0x43000 thru 0x4ffff	(0xd000 bytes)
6217269( 53 mod 256): PUNCH    0x7f45b thru 0x84c98	(0x583e bytes)
6217270( 54 mod 256): DEDUPE 0x1d000 thru 0x33fff	(0x17000 bytes) to 0x73000 thru 0x89fff
6217271( 55 mod 256): SKIPPED (no operation)
6217272( 56 mod 256): READ     0x29c47 thru 0x2b76a	(0x1b24 bytes)
6217273( 57 mod 256): COPY 0x6a00d thru 0x6d5db	(0x35cf bytes) to 0x55cdb thru 0x592a9
6217274( 58 mod 256): COPY 0x7a76 thru 0x1e603	(0x16b8e bytes) to 0x50df7 thru 0x67984
6217275( 59 mod 256): TRUNCATE DOWN	from 0x92000 to 0x5415d	******WWWW
6217276( 60 mod 256): INSERT 0x4e000 thru 0x67fff	(0x1a000 bytes)
6217277( 61 mod 256): MAPREAD  0x15de9 thru 0x2d9e3	(0x17bfb bytes)
6217278( 62 mod 256): SKIPPED (no operation)
6217279( 63 mod 256): READ     0x6d507 thru 0x6e15c	(0xc56 bytes)
6217280( 64 mod 256): READ     0x70cc thru 0x248fd	(0x1d832 bytes)
6217281( 65 mod 256): READ     0x58f33 thru 0x62bfe	(0x9ccc bytes)
6217282( 66 mod 256): ZERO     0x4a0a8 thru 0x6580b	(0x1b764 bytes)
6217283( 67 mod 256): WRITE    0x2e991 thru 0x33ff4	(0x5664 bytes)
6217284( 68 mod 256): DEDUPE 0x28000 thru 0x2bfff	(0x4000 bytes) to 0x37000 thru 0x3afff
6217285( 69 mod 256): CLONE 0x56000 thru 0x58fff	(0x3000 bytes) to 0x12000 thru 0x14fff
6217286( 70 mod 256): WRITE    0x6fa91 thru 0x77cdf	(0x824f bytes) HOLE	***WWWW
6217287( 71 mod 256): SKIPPED (no operation)
6217288( 72 mod 256): READ     0x24ef5 thru 0x2f255	(0xa361 bytes)
6217289( 73 mod 256): PUNCH    0x4b337 thru 0x4e576	(0x3240 bytes)
6217290( 74 mod 256): TRUNCATE DOWN	from 0x77ce0 to 0x2d856	******WWWW
6217291( 75 mod 256): WRITE    0x8ebae thru 0x927bf	(0x3c12 bytes) HOLE	***WWWW
6217292( 76 mod 256): MAPWRITE 0xb16 thru 0x1f6f3	(0x1ebde bytes)
6217293( 77 mod 256): MAPREAD  0x59f81 thru 0x77c0d	(0x1dc8d bytes)	***RRRR***
6217294( 78 mod 256): ZERO     0x72672 thru 0x7d6b2	(0xb041 bytes)
6217295( 79 mod 256): MAPWRITE 0x2a724 thru 0x39f21	(0xf7fe bytes)
6217296( 80 mod 256): READ     0x3d4a3 thru 0x49e0b	(0xc969 bytes)
6217297( 81 mod 256): ZERO     0x73784 thru 0x74373	(0xbf0 bytes)
6217298( 82 mod 256): SKIPPED (no operation)
6217299( 83 mod 256): FALLOC   0x2fe4a thru 0x35d19	(0x5ecf bytes) INTERIOR
6217300( 84 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1d4af	******WWWW
6217301( 85 mod 256): ZERO     0x6290f thru 0x6f9e2	(0xd0d4 bytes)	******ZZZZ
6217302( 86 mod 256): MAPREAD  0x340a7 thru 0x477f2	(0x1374c bytes)
6217303( 87 mod 256): PUNCH    0x3f094 thru 0x4d9ee	(0xe95b bytes)
6217304( 88 mod 256): ZERO     0x38489 thru 0x50754	(0x182cc bytes)
6217305( 89 mod 256): COPY 0x6e96 thru 0xd8c8	(0x6a33 bytes) to 0x82b72 thru 0x895a4
6217306( 90 mod 256): DEDUPE 0x29000 thru 0x46fff	(0x1e000 bytes) to 0x63000 thru 0x80fff	******BBBB
6217307( 91 mod 256): DEDUPE 0x59000 thru 0x6efff	(0x16000 bytes) to 0x1f000 thru 0x34fff	BBBB******
6217308( 92 mod 256): CLONE 0x33000 thru 0x42fff	(0x10000 bytes) to 0x7000 thru 0x16fff
6217309( 93 mod 256): COPY 0x7fc84 thru 0x840c5	(0x4442 bytes) to 0x5cea6 thru 0x612e7
6217310( 94 mod 256): SKIPPED (no operation)
6217311( 95 mod 256): FALLOC   0x5bc60 thru 0x72be8	(0x16f88 bytes) INTERIOR	******FFFF
6217312( 96 mod 256): CLONE 0x42000 thru 0x50fff	(0xf000 bytes) to 0x56000 thru 0x64fff
6217313( 97 mod 256): INSERT 0x63000 thru 0x6bfff	(0x9000 bytes)
6217314( 98 mod 256): COLLAPSE 0x6d000 thru 0x71fff	(0x5000 bytes)	******CCCC
6217315( 99 mod 256): PUNCH    0x6262d thru 0x77b4d	(0x15521 bytes)	******PPPP
6217316(100 mod 256): MAPWRITE 0x325d3 thru 0x366ba	(0x40e8 bytes)
6217317(101 mod 256): ZERO     0x6afeb thru 0x88037	(0x1d04d bytes)	******ZZZZ
6217318(102 mod 256): TRUNCATE DOWN	from 0x8d5a5 to 0x8528b
6217319(103 mod 256): MAPREAD  0x55329 thru 0x58e8b	(0x3b63 bytes)
6217320(104 mod 256): INSERT 0x45000 thru 0x51fff	(0xd000 bytes)
6217321(105 mod 256): COPY 0x55967 thru 0x6cf55	(0x175ef bytes) to 0x34650 thru 0x4bc3e
6217322(106 mod 256): COLLAPSE 0x16000 thru 0x22fff	(0xd000 bytes)
6217323(107 mod 256): CLONE 0x80000 thru 0x83fff	(0x4000 bytes) to 0x2000 thru 0x5fff
6217324(108 mod 256): MAPREAD  0x2903b thru 0x346c5	(0xb68b bytes)
6217325(109 mod 256): COPY 0x512eb thru 0x5b885	(0xa59b bytes) to 0x7bdbf thru 0x86359
6217326(110 mod 256): SKIPPED (no operation)
6217327(111 mod 256): INSERT 0x48000 thru 0x4dfff	(0x6000 bytes)
6217328(112 mod 256): COLLAPSE 0x54000 thru 0x57fff	(0x4000 bytes)
6217329(113 mod 256): MAPWRITE 0xc776 thru 0x16929	(0xa1b4 bytes)
6217330(114 mod 256): COLLAPSE 0x12000 thru 0x24fff	(0x13000 bytes)
6217331(115 mod 256): INSERT 0xb000 thru 0x15fff	(0xb000 bytes)
6217332(116 mod 256): SKIPPED (no operation)
6217333(117 mod 256): PUNCH    0x6ac9d thru 0x80359	(0x156bd bytes)	******PPPP
6217334(118 mod 256): SKIPPED (no operation)
6217335(119 mod 256): WRITE    0x57515 thru 0x6015c	(0x8c48 bytes)
6217336(120 mod 256): INSERT 0x4d000 thru 0x5afff	(0xe000 bytes)
6217337(121 mod 256): PUNCH    0x6894b thru 0x749ca	(0xc080 bytes)	******PPPP
6217338(122 mod 256): FALLOC   0x5569f thru 0x65964	(0x102c5 bytes) INTERIOR
6217339(123 mod 256): FALLOC   0x8e5fe thru 0x927c0	(0x41c2 bytes) EXTENDING
6217340(124 mod 256): MAPWRITE 0x3337f thru 0x4f792	(0x1c414 bytes)
6217341(125 mod 256): CLONE 0x7d000 thru 0x7efff	(0x2000 bytes) to 0x3f000 thru 0x40fff
6217342(126 mod 256): SKIPPED (no operation)
6217343(127 mod 256): CLONE 0x3e000 thru 0x58fff	(0x1b000 bytes) to 0x64000 thru 0x7efff	******JJJJ
6217344(128 mod 256): COLLAPSE 0x16000 thru 0x2cfff	(0x17000 bytes)
6217345(129 mod 256): TRUNCATE DOWN	from 0x7b7c0 to 0x512c7	******WWWW
6217346(130 mod 256): COPY 0x41747 thru 0x43371	(0x1c2b bytes) to 0x2924f thru 0x2ae79
6217347(131 mod 256): FALLOC   0x29405 thru 0x4053c	(0x17137 bytes) INTERIOR
6217348(132 mod 256): SKIPPED (no operation)
6217349(133 mod 256): TRUNCATE DOWN	from 0x512c7 to 0xdb91
6217350(134 mod 256): TRUNCATE UP	from 0xdb91 to 0x70c26	******WWWW
6217351(135 mod 256): READ     0x6817d thru 0x70c25	(0x8aa9 bytes)	***RRRR***
6217352(136 mod 256): MAPREAD  0x701c1 thru 0x70c25	(0xa65 bytes)
6217353(137 mod 256): ZERO     0x7889e thru 0x7d80b	(0x4f6e bytes)
6217354(138 mod 256): FALLOC   0x8276e thru 0x927c0	(0x10052 bytes) EXTENDING
6217355(139 mod 256): COPY 0x7b6f6 thru 0x8a8a0	(0xf1ab bytes) to 0x18440 thru 0x275ea
6217356(140 mod 256): FALLOC   0x16926 thru 0x2de5f	(0x17539 bytes) INTERIOR
6217357(141 mod 256): READ     0x56d1f thru 0x6a394	(0x13676 bytes)
6217358(142 mod 256): READ     0x2f5cf thru 0x3677a	(0x71ac bytes)
6217359(143 mod 256): MAPREAD  0x526da thru 0x5597c	(0x32a3 bytes)
6217360(144 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2771e	******WWWW
6217361(145 mod 256): CLONE 0x1f000 thru 0x25fff	(0x7000 bytes) to 0x3c000 thru 0x42fff
6217362(146 mod 256): CLONE 0x3f000 thru 0x41fff	(0x3000 bytes) to 0x49000 thru 0x4bfff
6217363(147 mod 256): SKIPPED (no operation)
6217364(148 mod 256): ZERO     0x559fb thru 0x6ee4a	(0x19450 bytes)
6217365(149 mod 256): SKIPPED (no operation)
6217366(150 mod 256): DEDUPE 0x25000 thru 0x28fff	(0x4000 bytes) to 0x1b000 thru 0x1efff
6217367(151 mod 256): COLLAPSE 0x39000 thru 0x3bfff	(0x3000 bytes)
6217368(152 mod 256): SKIPPED (no operation)
6217369(153 mod 256): INSERT 0x8000 thru 0x21fff	(0x1a000 bytes)
6217370(154 mod 256): WRITE    0x19e87 thru 0x25cf4	(0xbe6e bytes)
6217371(155 mod 256): CLONE 0x11000 thru 0x14fff	(0x4000 bytes) to 0x25000 thru 0x28fff
6217372(156 mod 256): READ     0x5e17a thru 0x77806	(0x1968d bytes)	***RRRR***
6217373(157 mod 256): DEDUPE 0x12000 thru 0x15fff	(0x4000 bytes) to 0x53000 thru 0x56fff
6217374(158 mod 256): COLLAPSE 0x50000 thru 0x52fff	(0x3000 bytes)
6217375(159 mod 256): ZERO     0x71b98 thru 0x8bf05	(0x1a36e bytes)
6217376(160 mod 256): COLLAPSE 0x5b000 thru 0x69fff	(0xf000 bytes)
6217377(161 mod 256): TRUNCATE DOWN	from 0x7cf06 to 0x5657	******WWWW
6217378(162 mod 256): MAPWRITE 0x8a80e thru 0x927bf	(0x7fb2 bytes)
6217379(163 mod 256): COPY 0x18a6f thru 0x2acf3	(0x12285 bytes) to 0x52899 thru 0x64b1d
6217380(164 mod 256): CLONE 0x7d000 thru 0x91fff	(0x15000 bytes) to 0x58000 thru 0x6cfff
6217381(165 mod 256): MAPWRITE 0x71e37 thru 0x88084	(0x1624e bytes)
6217382(166 mod 256): FALLOC   0x5f35d thru 0x6ad61	(0xba04 bytes) INTERIOR
6217383(167 mod 256): ZERO     0x4c050 thru 0x5fbec	(0x13b9d bytes)
6217384(168 mod 256): ZERO     0x52231 thru 0x60edc	(0xecac bytes)
6217385(169 mod 256): SKIPPED (no operation)
6217386(170 mod 256): FALLOC   0x1407e thru 0x292b8	(0x1523a bytes) INTERIOR
6217387(171 mod 256): SKIPPED (no operation)
6217388(172 mod 256): CLONE 0x86000 thru 0x90fff	(0xb000 bytes) to 0x48000 thru 0x52fff
6217389(173 mod 256): COPY 0xe914 thru 0x2a727	(0x1be14 bytes) to 0x68d3d thru 0x84b50	******EEEE
6217390(174 mod 256): WRITE    0x6f698 thru 0x85922	(0x1628b bytes)
6217391(175 mod 256): SKIPPED (no operation)
6217392(176 mod 256): MAPWRITE 0x3160f thru 0x4a5a9	(0x18f9b bytes)
6217393(177 mod 256): DEDUPE 0x13000 thru 0x14fff	(0x2000 bytes) to 0x2d000 thru 0x2efff
6217394(178 mod 256): ZERO     0xa72 thru 0x14ef1	(0x14480 bytes)
6217395(179 mod 256): COLLAPSE 0x1c000 thru 0x25fff	(0xa000 bytes)
6217396(180 mod 256): MAPREAD  0x32ffb thru 0x41ec3	(0xeec9 bytes)
6217397(181 mod 256): MAPWRITE 0x72a3d thru 0x74a5a	(0x201e bytes)
6217398(182 mod 256): SKIPPED (no operation)
6217399(183 mod 256): WRITE    0x4d573 thru 0x6abdd	(0x1d66b bytes)
6217400(184 mod 256): FALLOC   0x5d35e thru 0x6202c	(0x4cce bytes) INTERIOR
6217401(185 mod 256): COPY 0x2360e thru 0x26c75	(0x3668 bytes) to 0x64b90 thru 0x681f7
6217402(186 mod 256): WRITE    0x480a6 thru 0x5c586	(0x144e1 bytes)
6217403(187 mod 256): ZERO     0x1a77b thru 0x35fcb	(0x1b851 bytes)
6217404(188 mod 256): DEDUPE 0x21000 thru 0x34fff	(0x14000 bytes) to 0x42000 thru 0x55fff
6217405(189 mod 256): ZERO     0xdc6a thru 0x1c5f0	(0xe987 bytes)
6217406(190 mod 256): FALLOC   0x6a4d6 thru 0x83a72	(0x1959c bytes) INTERIOR	******FFFF
6217407(191 mod 256): MAPREAD  0x463dc thru 0x63102	(0x1cd27 bytes)
6217408(192 mod 256): MAPREAD  0x6dc8c thru 0x871e1	(0x19556 bytes)	***RRRR***
6217409(193 mod 256): FALLOC   0x8474d thru 0x88af3	(0x43a6 bytes) EXTENDING
6217410(194 mod 256): COPY 0x3ccea thru 0x4c811	(0xfb28 bytes) to 0x5059c thru 0x600c3
6217411(195 mod 256): TRUNCATE DOWN	from 0x88af3 to 0x664c4	******WWWW
6217412(196 mod 256): FALLOC   0x3b59a thru 0x3dba1	(0x2607 bytes) INTERIOR
6217413(197 mod 256): MAPWRITE 0x147 thru 0x7f17	(0x7dd1 bytes)
6217414(198 mod 256): CLONE 0x5000 thru 0x14fff	(0x10000 bytes) to 0x57000 thru 0x66fff
6217415(199 mod 256): COLLAPSE 0x1a000 thru 0x30fff	(0x17000 bytes)
6217416(200 mod 256): SKIPPED (no operation)
6217417(201 mod 256): PUNCH    0x3a810 thru 0x4ffff	(0x157f0 bytes)
6217418(202 mod 256): CLONE 0x29000 thru 0x44fff	(0x1c000 bytes) to 0x47000 thru 0x62fff
6217419(203 mod 256): COLLAPSE 0x5a000 thru 0x61fff	(0x8000 bytes)
6217420(204 mod 256): FALLOC   0x60b58 thru 0x6b0f0	(0xa598 bytes) PAST_EOF
6217421(205 mod 256): FALLOC   0x23cdb thru 0x24e24	(0x1149 bytes) INTERIOR
6217422(206 mod 256): COLLAPSE 0x8000 thru 0xafff	(0x3000 bytes)
6217423(207 mod 256): TRUNCATE DOWN	from 0x58000 to 0x4ea3b
6217424(208 mod 256): MAPREAD  0x3fbf9 thru 0x4c70e	(0xcb16 bytes)
6217425(209 mod 256): COPY 0x2baf3 thru 0x3bf6f	(0x1047d bytes) to 0x3e890 thru 0x4ed0c
6217426(210 mod 256): SKIPPED (no operation)
6217427(211 mod 256): DEDUPE 0x33000 thru 0x34fff	(0x2000 bytes) to 0x49000 thru 0x4afff
6217428(212 mod 256): SKIPPED (no operation)
6217429(213 mod 256): MAPREAD  0x13389 thru 0x1ab6d	(0x77e5 bytes)
6217430(214 mod 256): COPY 0x1f801 thru 0x3707d	(0x1787d bytes) to 0x3dfc9 thru 0x55845
6217431(215 mod 256): CLONE 0x54000 thru 0x54fff	(0x1000 bytes) to 0x41000 thru 0x41fff
6217432(216 mod 256): INSERT 0x49000 thru 0x64fff	(0x1c000 bytes)
6217433(217 mod 256): PUNCH    0x575a0 thru 0x61fc7	(0xaa28 bytes)
6217434(218 mod 256): TRUNCATE DOWN	from 0x71846 to 0x47ace	******WWWW
6217435(219 mod 256): WRITE    0x3d3b0 thru 0x48e25	(0xba76 bytes) EXTEND
6217436(220 mod 256): DEDUPE 0x2a000 thru 0x44fff	(0x1b000 bytes) to 0x4000 thru 0x1efff
6217437(221 mod 256): READ     0x25a99 thru 0x275d5	(0x1b3d bytes)
6217438(222 mod 256): COPY 0x10716 thru 0x123ae	(0x1c99 bytes) to 0x44501 thru 0x46199
6217439(223 mod 256): INSERT 0x12000 thru 0x12fff	(0x1000 bytes)
6217440(224 mod 256): WRITE    0x9104a thru 0x927bf	(0x1776 bytes) HOLE	***WWWW
6217441(225 mod 256): MAPREAD  0x81657 thru 0x927bf	(0x11169 bytes)
6217442(226 mod 256): ZERO     0xa60a thru 0x24b15	(0x1a50c bytes)
6217443(227 mod 256): DEDUPE 0x59000 thru 0x70fff	(0x18000 bytes) to 0xe000 thru 0x25fff	BBBB******
6217444(228 mod 256): MAPREAD  0x862c1 thru 0x927bf	(0xc4ff bytes)
6217445(229 mod 256): COPY 0x5cd73 thru 0x790e3	(0x1c371 bytes) to 0x3ac8f thru 0x56fff	EEEE******
6217446(230 mod 256): CLONE 0x90000 thru 0x90fff	(0x1000 bytes) to 0x1000 thru 0x1fff
6217447(231 mod 256): READ     0xad23 thru 0x11364	(0x6642 bytes)
6217448(232 mod 256): READ     0x8924c thru 0x927bf	(0x9574 bytes)
6217449(233 mod 256): CLONE 0x26000 thru 0x38fff	(0x13000 bytes) to 0x5d000 thru 0x6ffff	******JJJJ
6217450(234 mod 256): MAPREAD  0x60b93 thru 0x74416	(0x13884 bytes)	***RRRR***
6217451(235 mod 256): COLLAPSE 0x36000 thru 0x43fff	(0xe000 bytes)
6217452(236 mod 256): TRUNCATE DOWN	from 0x847c0 to 0x50f70	******WWWW
6217453(237 mod 256): TRUNCATE UP	from 0x50f70 to 0x5b674
6217454(238 mod 256): PUNCH    0x618 thru 0x18759	(0x18142 bytes)
6217455(239 mod 256): READ     0x24cdd thru 0x2b83e	(0x6b62 bytes)
6217456(240 mod 256): ZERO     0x34bf9 thru 0x4c75b	(0x17b63 bytes)
6217457(241 mod 256): ZERO     0x6f0f9 thru 0x769e9	(0x78f1 bytes)
6217458(242 mod 256): TRUNCATE UP	from 0x769ea to 0x7dc46
6217459(243 mod 256): ZERO     0x4f8ba thru 0x65792	(0x15ed9 bytes)
6217460(244 mod 256): MAPWRITE 0x58071 thru 0x658b6	(0xd846 bytes)
6217461(245 mod 256): WRITE    0x11b00 thru 0x1a4e7	(0x89e8 bytes)
6217462(246 mod 256): DEDUPE 0x18000 thru 0x1dfff	(0x6000 bytes) to 0x2c000 thru 0x31fff
6217463(247 mod 256): ZERO     0x183a0 thru 0x2fc6b	(0x178cc bytes)
6217464(248 mod 256): TRUNCATE DOWN	from 0x7dc46 to 0x785a2
6217465(249 mod 256): ZERO     0x4e5ba thru 0x5876b	(0xa1b2 bytes)
6217466(250 mod 256): TRUNCATE DOWN	from 0x785a2 to 0x5f539	******WWWW
6217467(251 mod 256): ZERO     0x4db96 thru 0x5f774	(0x11bdf bytes)
6217468(252 mod 256): TRUNCATE UP	from 0x5f775 to 0x65e14
6217469(253 mod 256): FALLOC   0x7acd1 thru 0x7c3cb	(0x16fa bytes) EXTENDING
6217470(254 mod 256): COPY 0x615dd thru 0x7c3ca	(0x1adee bytes) to 0x1bbbd thru 0x369aa	EEEE******
6217471(255 mod 256): READ     0x28551 thru 0x37247	(0xecf7 bytes)
6217472(  0 mod 256): COPY 0x3e15d thru 0x4f917	(0x117bb bytes) to 0x1db74 thru 0x2f32e
6217473(  1 mod 256): READ     0x2f763 thru 0x41195	(0x11a33 bytes)
6217474(  2 mod 256): PUNCH    0x4c341 thru 0x5a11a	(0xddda bytes)
6217475(  3 mod 256): DEDUPE 0x44000 thru 0x49fff	(0x6000 bytes) to 0x12000 thru 0x17fff
6217476(  4 mod 256): CLONE 0x4b000 thru 0x4dfff	(0x3000 bytes) to 0x2c000 thru 0x2efff
6217477(  5 mod 256): TRUNCATE DOWN	from 0x7c3cb to 0x36869	******WWWW
6217478(  6 mod 256): ZERO     0x8d135 thru 0x8ea34	(0x1900 bytes)
6217479(  7 mod 256): SKIPPED (no operation)
6217480(  8 mod 256): READ     0x33804 thru 0x36868	(0x3065 bytes)
6217481(  9 mod 256): READ     0xbfac thru 0x1dced	(0x11d42 bytes)
6217482( 10 mod 256): COLLAPSE 0x9000 thru 0xffff	(0x7000 bytes)
6217483( 11 mod 256): COPY 0x1b6f4 thru 0x25102	(0x9a0f bytes) to 0x8290b thru 0x8c319
6217484( 12 mod 256): TRUNCATE DOWN	from 0x8c31a to 0x6a77e	******WWWW
6217485( 13 mod 256): READ     0x570f1 thru 0x671fa	(0x1010a bytes)
6217486( 14 mod 256): COLLAPSE 0x62000 thru 0x69fff	(0x8000 bytes)
6217487( 15 mod 256): CLONE 0x5f000 thru 0x60fff	(0x2000 bytes) to 0x51000 thru 0x52fff
6217488( 16 mod 256): CLONE 0x1d000 thru 0x20fff	(0x4000 bytes) to 0x4a000 thru 0x4dfff
6217489( 17 mod 256): TRUNCATE DOWN	from 0x6277e to 0x502f8
6217490( 18 mod 256): SKIPPED (no operation)
6217491( 19 mod 256): MAPREAD  0xfb43 thru 0x228fb	(0x12db9 bytes)
6217492( 20 mod 256): READ     0x20e92 thru 0x2c00b	(0xb17a bytes)
6217493( 21 mod 256): PUNCH    0x329f4 thru 0x4091e	(0xdf2b bytes)
6217494( 22 mod 256): READ     0x9d4c thru 0x1efab	(0x15260 bytes)
6217495( 23 mod 256): TRUNCATE UP	from 0x502f8 to 0x74d41	******WWWW
6217496( 24 mod 256): DEDUPE 0x28000 thru 0x3cfff	(0x15000 bytes) to 0x46000 thru 0x5afff
6217497( 25 mod 256): WRITE    0x36882 thru 0x4951c	(0x12c9b bytes)
6217498( 26 mod 256): CLONE 0x51000 thru 0x64fff	(0x14000 bytes) to 0x1c000 thru 0x2ffff
6217499( 27 mod 256): CLONE 0x26000 thru 0x2efff	(0x9000 bytes) to 0x43000 thru 0x4bfff
6217500( 28 mod 256): ZERO     0x3ce2a thru 0x40a51	(0x3c28 bytes)
6217501( 29 mod 256): MAPWRITE 0x87cf2 thru 0x927bf	(0xaace bytes)
6217502( 30 mod 256): ZERO     0xacf0 thru 0x16f67	(0xc278 bytes)
6217503( 31 mod 256): WRITE    0x6322e thru 0x7647b	(0x1324e bytes)	***WWWW
6217504( 32 mod 256): FALLOC   0x3d942 thru 0x3ef48	(0x1606 bytes) INTERIOR
6217505( 33 mod 256): DEDUPE 0x36000 thru 0x4ffff	(0x1a000 bytes) to 0xf000 thru 0x28fff
6217506( 34 mod 256): COLLAPSE 0x77000 thru 0x8dfff	(0x17000 bytes)
6217507( 35 mod 256): INSERT 0x19000 thru 0x2efff	(0x16000 bytes)
6217508( 36 mod 256): MAPREAD  0x22f77 thru 0x31e46	(0xeed0 bytes)
6217509( 37 mod 256): READ     0x870b7 thru 0x917bf	(0xa709 bytes)
6217510( 38 mod 256): FALLOC   0x8f620 thru 0x927c0	(0x31a0 bytes) EXTENDING
6217511( 39 mod 256): MAPWRITE 0x3a0de thru 0x50738	(0x1665b bytes)
6217512( 40 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xfcba	******WWWW
6217513( 41 mod 256): PUNCH    0x89e0 thru 0xfcb9	(0x72da bytes)
6217514( 42 mod 256): FALLOC   0x2d9e4 thru 0x2ed06	(0x1322 bytes) EXTENDING
6217515( 43 mod 256): WRITE    0x106ac thru 0x20376	(0xfccb bytes)
6217516( 44 mod 256): PUNCH    0x19d46 thru 0x1d73f	(0x39fa bytes)
6217517( 45 mod 256): ZERO     0x26055 thru 0x4004a	(0x19ff6 bytes)
6217518( 46 mod 256): DEDUPE 0x25000 thru 0x2dfff	(0x9000 bytes) to 0x30000 thru 0x38fff
6217519( 47 mod 256): WRITE    0x3e6d9 thru 0x56972	(0x1829a bytes) EXTEND
6217520( 48 mod 256): DEDUPE 0x2000 thru 0x19fff	(0x18000 bytes) to 0x22000 thru 0x39fff
6217521( 49 mod 256): FALLOC   0x7faa9 thru 0x927c0	(0x12d17 bytes) EXTENDING
6217522( 50 mod 256): COLLAPSE 0x27000 thru 0x29fff	(0x3000 bytes)
6217523( 51 mod 256): ZERO     0x24595 thru 0x24b2d	(0x599 bytes)
6217524( 52 mod 256): COLLAPSE 0x5f000 thru 0x64fff	(0x6000 bytes)
6217525( 53 mod 256): CLONE 0x17000 thru 0x33fff	(0x1d000 bytes) to 0x61000 thru 0x7dfff	******JJJJ
6217526( 54 mod 256): COPY 0x60060 thru 0x7a2e2	(0x1a283 bytes) to 0xc87e thru 0x26b00	EEEE******
6217527( 55 mod 256): FALLOC   0x8493b thru 0x927c0	(0xde85 bytes) EXTENDING
6217528( 56 mod 256): PUNCH    0x13677 thru 0x2f1e6	(0x1bb70 bytes)
6217529( 57 mod 256): MAPREAD  0x8031 thru 0x23185	(0x1b155 bytes)
6217530( 58 mod 256): ZERO     0x667c6 thru 0x71c50	(0xb48b bytes)	******ZZZZ
6217531( 59 mod 256): ZERO     0x30207 thru 0x42d82	(0x12b7c bytes)
6217532( 60 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x764f9
6217533( 61 mod 256): TRUNCATE UP	from 0x764f9 to 0x82142
6217534( 62 mod 256): WRITE    0x79904 thru 0x85348	(0xba45 bytes) EXTEND
6217535( 63 mod 256): COPY 0x2fd71 thru 0x4b116	(0x1b3a6 bytes) to 0x566ba thru 0x71a5f	******EEEE
6217536( 64 mod 256): MAPREAD  0x153ac thru 0x2cbcd	(0x17822 bytes)
6217537( 65 mod 256): COPY 0x5e4e6 thru 0x66edb	(0x89f6 bytes) to 0x33d42 thru 0x3c737
6217538( 66 mod 256): COLLAPSE 0xc000 thru 0x18fff	(0xd000 bytes)
6217539( 67 mod 256): SKIPPED (no operation)
6217540( 68 mod 256): FALLOC   0x433ea thru 0x48e36	(0x5a4c bytes) INTERIOR
6217541( 69 mod 256): ZERO     0x18fe2 thru 0x19ed0	(0xeef bytes)
6217542( 70 mod 256): FALLOC   0x868e thru 0xed55	(0x66c7 bytes) INTERIOR
6217543( 71 mod 256): PUNCH    0x28f67 thru 0x2da60	(0x4afa bytes)
6217544( 72 mod 256): READ     0x4cc20 thru 0x6279c	(0x15b7d bytes)
6217545( 73 mod 256): MAPWRITE 0x3be44 thru 0x45bcc	(0x9d89 bytes)
6217546( 74 mod 256): MAPREAD  0x1422d thru 0x19802	(0x55d6 bytes)
6217547( 75 mod 256): FALLOC   0x56683 thru 0x6f32a	(0x18ca7 bytes) INTERIOR	******FFFF
6217548( 76 mod 256): COPY 0x4343a thru 0x52f51	(0xfb18 bytes) to 0x77abf thru 0x875d6
6217549( 77 mod 256): COPY 0xdd44 thru 0xfb85	(0x1e42 bytes) to 0x622be thru 0x640ff
6217550( 78 mod 256): CLONE 0x4f000 thru 0x6cfff	(0x1e000 bytes) to 0x9000 thru 0x26fff
6217551( 79 mod 256): READ     0x740b6 thru 0x801bc	(0xc107 bytes)
6217552( 80 mod 256): MAPREAD  0x992a thru 0x113c6	(0x7a9d bytes)
6217553( 81 mod 256): MAPREAD  0x191ec thru 0x32967	(0x1977c bytes)
6217554( 82 mod 256): MAPWRITE 0x10560 thru 0x2cfd1	(0x1ca72 bytes)
6217555( 83 mod 256): READ     0x81b4c thru 0x875d6	(0x5a8b bytes)
6217556( 84 mod 256): TRUNCATE DOWN	from 0x875d7 to 0x3d1d8	******WWWW
6217557( 85 mod 256): READ     0xcbbd thru 0x15516	(0x895a bytes)
6217558( 86 mod 256): ZERO     0x33b63 thru 0x346d2	(0xb70 bytes)
6217559( 87 mod 256): COPY 0x5a0 thru 0x2aed	(0x254e bytes) to 0x7e7a5 thru 0x80cf2
6217560( 88 mod 256): INSERT 0x4c000 thru 0x5cfff	(0x11000 bytes)
6217561( 89 mod 256): ZERO     0x88a79 thru 0x927bf	(0x9d47 bytes)
6217562( 90 mod 256): READ     0x663b1 thru 0x73766	(0xd3b6 bytes)	***RRRR***
6217563( 91 mod 256): MAPWRITE 0x2d746 thru 0x321d3	(0x4a8e bytes)
6217564( 92 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5bd04	******WWWW
6217565( 93 mod 256): TRUNCATE DOWN	from 0x5bd04 to 0x449c0
6217566( 94 mod 256): INSERT 0x23000 thru 0x2bfff	(0x9000 bytes)
6217567( 95 mod 256): CLONE 0x38000 thru 0x41fff	(0xa000 bytes) to 0x11000 thru 0x1afff
6217568( 96 mod 256): PUNCH    0x170bc thru 0x1fc34	(0x8b79 bytes)
6217569( 97 mod 256): PUNCH    0x29c03 thru 0x43b3c	(0x19f3a bytes)
6217570( 98 mod 256): WRITE    0xc242 thru 0x23a4e	(0x1780d bytes)
6217571( 99 mod 256): MAPWRITE 0x75bd7 thru 0x7d0ff	(0x7529 bytes)
6217572(100 mod 256): MAPWRITE 0x4732 thru 0x53e2	(0xcb1 bytes)
6217573(101 mod 256): FALLOC   0x63c23 thru 0x69660	(0x5a3d bytes) INTERIOR
6217574(102 mod 256): FALLOC   0x11873 thru 0x252ad	(0x13a3a bytes) INTERIOR
6217575(103 mod 256): MAPREAD  0x1acd7 thru 0x3069e	(0x159c8 bytes)
6217576(104 mod 256): DEDUPE 0x4b000 thru 0x4dfff	(0x3000 bytes) to 0x36000 thru 0x38fff
6217577(105 mod 256): INSERT 0xb000 thru 0x15fff	(0xb000 bytes)
6217578(106 mod 256): WRITE    0x4538c thru 0x626fb	(0x1d370 bytes)
6217579(107 mod 256): MAPWRITE 0x2a2c3 thru 0x305d8	(0x6316 bytes)
6217580(108 mod 256): COPY 0xd382 thru 0x13863	(0x64e2 bytes) to 0x70d2b thru 0x7720c
6217581(109 mod 256): TRUNCATE DOWN	from 0x88100 to 0x8475c
6217582(110 mod 256): READ     0x6e174 thru 0x788ec	(0xa779 bytes)	***RRRR***
6217583(111 mod 256): COPY 0x5527a thru 0x6a4be	(0x15245 bytes) to 0x55ea thru 0x1a82e
6217584(112 mod 256): SKIPPED (no operation)
6217585(113 mod 256): PUNCH    0x6b11d thru 0x7861a	(0xd4fe bytes)	******PPPP
6217586(114 mod 256): COLLAPSE 0x2c000 thru 0x42fff	(0x17000 bytes)
6217587(115 mod 256): CLONE 0x5b000 thru 0x6bfff	(0x11000 bytes) to 0x6d000 thru 0x7dfff	******JJJJ
6217588(116 mod 256): ZERO     0x5fb99 thru 0x6ad2e	(0xb196 bytes)
6217589(117 mod 256): PUNCH    0x2c18c thru 0x2f46c	(0x32e1 bytes)
6217590(118 mod 256): TRUNCATE UP	from 0x7e000 to 0x80238
6217591(119 mod 256): INSERT 0x3d000 thru 0x4efff	(0x12000 bytes)
6217592(120 mod 256): WRITE    0x7e4c3 thru 0x8911a	(0xac58 bytes)
6217593(121 mod 256): PUNCH    0x1d543 thru 0x30141	(0x12bff bytes)
6217594(122 mod 256): COPY 0x5c255 thru 0x71f4e	(0x15cfa bytes) to 0x12ba7 thru 0x288a0	EEEE******
6217595(123 mod 256): WRITE    0x26296 thru 0x2d55c	(0x72c7 bytes)
6217596(124 mod 256): WRITE    0x484ab thru 0x600fb	(0x17c51 bytes)
6217597(125 mod 256): READ     0x90de8 thru 0x92237	(0x1450 bytes)
6217598(126 mod 256): SKIPPED (no operation)
6217599(127 mod 256): SKIPPED (no operation)
6217600(128 mod 256): PUNCH    0x73c9a thru 0x7ecc0	(0xb027 bytes)
6217601(129 mod 256): DEDUPE 0x5a000 thru 0x69fff	(0x10000 bytes) to 0x40000 thru 0x4ffff
6217602(130 mod 256): TRUNCATE DOWN	from 0x92238 to 0x25185	******WWWW
6217603(131 mod 256): WRITE    0x255c6 thru 0x30846	(0xb281 bytes) HOLE
6217604(132 mod 256): ZERO     0x2a22c thru 0x36cc6	(0xca9b bytes)
6217605(133 mod 256): ZERO     0x8b7fb thru 0x927bf	(0x6fc5 bytes)
6217606(134 mod 256): SKIPPED (no operation)
6217607(135 mod 256): FALLOC   0x49162 thru 0x5486b	(0xb709 bytes) INTERIOR
6217608(136 mod 256): DEDUPE 0x24000 thru 0x3afff	(0x17000 bytes) to 0x59000 thru 0x6ffff	******BBBB
6217609(137 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x14d6f	******WWWW
6217610(138 mod 256): SKIPPED (no operation)
6217611(139 mod 256): COPY 0x825b thru 0x14d6e	(0xcb14 bytes) to 0x2daeb thru 0x3a5fe
6217612(140 mod 256): WRITE    0x1c1d6 thru 0x21ccd	(0x5af8 bytes)
6217613(141 mod 256): INSERT 0x36000 thru 0x44fff	(0xf000 bytes)
6217614(142 mod 256): ZERO     0x3d56 thru 0xac1c	(0x6ec7 bytes)
6217615(143 mod 256): DEDUPE 0xe000 thru 0x22fff	(0x15000 bytes) to 0x24000 thru 0x38fff
6217616(144 mod 256): DEDUPE 0x1000 thru 0x6fff	(0x6000 bytes) to 0x15000 thru 0x1afff
6217617(145 mod 256): WRITE    0x1a626 thru 0x1d083	(0x2a5e bytes)
6217618(146 mod 256): ZERO     0x5f4ce thru 0x69384	(0x9eb7 bytes)
6217619(147 mod 256): READ     0x4a385 thru 0x66766	(0x1c3e2 bytes)
6217620(148 mod 256): PUNCH    0xcc52 thru 0x17e56	(0xb205 bytes)
6217621(149 mod 256): SKIPPED (no operation)
6217622(150 mod 256): FALLOC   0xcb94 thru 0x25c6f	(0x190db bytes) INTERIOR
6217623(151 mod 256): ZERO     0x59910 thru 0x70cc2	(0x173b3 bytes)	******ZZZZ
6217624(152 mod 256): MAPREAD  0x1d9c3 thru 0x25601	(0x7c3f bytes)
6217625(153 mod 256): READ     0xa48c thru 0x1f851	(0x153c6 bytes)
6217626(154 mod 256): DEDUPE 0x2f000 thru 0x2ffff	(0x1000 bytes) to 0x51000 thru 0x51fff
6217627(155 mod 256): MAPWRITE 0x23c7f thru 0x32f57	(0xf2d9 bytes)
6217628(156 mod 256): PUNCH    0x5928b thru 0x69384	(0x100fa bytes)
6217629(157 mod 256): COLLAPSE 0x68000 thru 0x68fff	(0x1000 bytes)
6217630(158 mod 256): MAPREAD  0x5bb15 thru 0x68384	(0xc870 bytes)
6217631(159 mod 256): PUNCH    0x346cb thru 0x40f98	(0xc8ce bytes)
6217632(160 mod 256): MAPWRITE 0x87b6b thru 0x927bf	(0xac55 bytes)
6217633(161 mod 256): DEDUPE 0x1000 thru 0x12fff	(0x12000 bytes) to 0x22000 thru 0x33fff
6217634(162 mod 256): READ     0x5c407 thru 0x79694	(0x1d28e bytes)	***RRRR***
6217635(163 mod 256): COLLAPSE 0x45000 thru 0x49fff	(0x5000 bytes)
6217636(164 mod 256): ZERO     0x13707 thru 0x1af10	(0x780a bytes)
6217637(165 mod 256): TRUNCATE DOWN	from 0x8d7c0 to 0x3c9e6	******WWWW
6217638(166 mod 256): READ     0x39846 thru 0x3c9e5	(0x31a0 bytes)
6217639(167 mod 256): ZERO     0x35dbf thru 0x46464	(0x106a6 bytes)
6217640(168 mod 256): FALLOC   0x253fd thru 0x372c6	(0x11ec9 bytes) INTERIOR
6217641(169 mod 256): ZERO     0x8ee40 thru 0x927bf	(0x3980 bytes)
6217642(170 mod 256): READ     0x67a69 thru 0x8493f	(0x1ced7 bytes)	***RRRR***
6217643(171 mod 256): CLONE 0x56000 thru 0x64fff	(0xf000 bytes) to 0x10000 thru 0x1efff
6217644(172 mod 256): SKIPPED (no operation)
6217645(173 mod 256): COLLAPSE 0x10000 thru 0x2afff	(0x1b000 bytes)
6217646(174 mod 256): SKIPPED (no operation)
6217647(175 mod 256): INSERT 0x27000 thru 0x2dfff	(0x7000 bytes)
6217648(176 mod 256): DEDUPE 0x6c000 thru 0x72fff	(0x7000 bytes) to 0x29000 thru 0x2ffff	BBBB******
6217649(177 mod 256): SKIPPED (no operation)
6217650(178 mod 256): MAPWRITE 0x51222 thru 0x611e6	(0xffc5 bytes)
6217651(179 mod 256): TRUNCATE DOWN	from 0x7e7c0 to 0x6aed3	******WWWW
6217652(180 mod 256): MAPWRITE 0x3e83b thru 0x4c407	(0xdbcd bytes)
6217653(181 mod 256): TRUNCATE DOWN	from 0x6aed3 to 0x55c40
6217654(182 mod 256): COPY 0x2b779 thru 0x37146	(0xb9ce bytes) to 0x58a65 thru 0x64432
6217655(183 mod 256): READ     0x1c669 thru 0x26ece	(0xa866 bytes)
6217656(184 mod 256): ZERO     0x363d5 thru 0x55665	(0x1f291 bytes)
6217657(185 mod 256): TRUNCATE DOWN	from 0x64433 to 0x19a4b
6217658(186 mod 256): MAPREAD  0x12af8 thru 0x1436f	(0x1878 bytes)
6217659(187 mod 256): SKIPPED (no operation)
6217660(188 mod 256): READ     0x9b02 thru 0x1225c	(0x875b bytes)
6217661(189 mod 256): INSERT 0x6000 thru 0x15fff	(0x10000 bytes)
6217662(190 mod 256): FALLOC   0x7aa0d thru 0x7ed86	(0x4379 bytes) EXTENDING
6217663(191 mod 256): ZERO     0x33d04 thru 0x4b475	(0x17772 bytes)
6217664(192 mod 256): MAPREAD  0x465f2 thru 0x5e662	(0x18071 bytes)
6217665(193 mod 256): FALLOC   0x7abc0 thru 0x927c0	(0x17c00 bytes) EXTENDING
6217666(194 mod 256): READ     0x34fb4 thru 0x490d4	(0x14121 bytes)
6217667(195 mod 256): READ     0x49aff thru 0x61496	(0x17998 bytes)
6217668(196 mod 256): SKIPPED (no operation)
6217669(197 mod 256): PUNCH    0x58ec9 thru 0x6d31f	(0x14457 bytes)
6217670(198 mod 256): SKIPPED (no operation)
6217671(199 mod 256): READ     0x1895a thru 0x1b6a1	(0x2d48 bytes)
6217672(200 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xd520	******WWWW
6217673(201 mod 256): FALLOC   0x5fbd thru 0x14657	(0xe69a bytes) EXTENDING
6217674(202 mod 256): SKIPPED (no operation)
6217675(203 mod 256): COLLAPSE 0x13000 thru 0x13fff	(0x1000 bytes)
6217676(204 mod 256): TRUNCATE UP	from 0x13657 to 0x42ce5
6217677(205 mod 256): ZERO     0x83bc8 thru 0x927bf	(0xebf8 bytes)
6217678(206 mod 256): ZERO     0x273e4 thru 0x2acd7	(0x38f4 bytes)
6217679(207 mod 256): PUNCH    0x151cb thru 0x3150e	(0x1c344 bytes)
6217680(208 mod 256): WRITE    0x2cf4f thru 0x38dda	(0xbe8c bytes)
6217681(209 mod 256): CLONE 0x7e000 thru 0x80fff	(0x3000 bytes) to 0x89000 thru 0x8bfff
6217682(210 mod 256): MAPREAD  0xfe58 thru 0x259e3	(0x15b8c bytes)
6217683(211 mod 256): SKIPPED (no operation)
6217684(212 mod 256): SKIPPED (no operation)
6217685(213 mod 256): MAPWRITE 0xb1a8 thru 0x29877	(0x1e6d0 bytes)
6217686(214 mod 256): SKIPPED (no operation)
6217687(215 mod 256): ZERO     0x5a1d9 thru 0x5f114	(0x4f3c bytes)
6217688(216 mod 256): SKIPPED (no operation)
6217689(217 mod 256): COPY 0x6dbf4 thru 0x7f441	(0x1184e bytes) to 0x1e5c5 thru 0x2fe12	EEEE******
6217690(218 mod 256): CLONE 0x8b000 thru 0x90fff	(0x6000 bytes) to 0x7a000 thru 0x7ffff
6217691(219 mod 256): CLONE 0x7a000 thru 0x7bfff	(0x2000 bytes) to 0x5f000 thru 0x60fff
6217692(220 mod 256): WRITE    0x8aea1 thru 0x927bf	(0x791f bytes)
6217693(221 mod 256): MAPREAD  0xb732 thru 0x1a870	(0xf13f bytes)
6217694(222 mod 256): SKIPPED (no operation)
6217695(223 mod 256): SKIPPED (no operation)
6217696(224 mod 256): CLONE 0x62000 thru 0x70fff	(0xf000 bytes) to 0x15000 thru 0x23fff	JJJJ******
6217697(225 mod 256): COLLAPSE 0x3a000 thru 0x57fff	(0x1e000 bytes)
6217698(226 mod 256): DEDUPE 0x5d000 thru 0x5ffff	(0x3000 bytes) to 0x6d000 thru 0x6ffff	******BBBB
6217699(227 mod 256): MAPWRITE 0x7bbdd thru 0x927bf	(0x16be3 bytes)
6217700(228 mod 256): MAPWRITE 0x4a74e thru 0x5d816	(0x130c9 bytes)
6217701(229 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4e9ac	******WWWW
6217702(230 mod 256): READ     0x3980f thru 0x430d1	(0x98c3 bytes)
6217703(231 mod 256): DEDUPE 0x34000 thru 0x39fff	(0x6000 bytes) to 0x14000 thru 0x19fff
6217704(232 mod 256): CLONE 0xf000 thru 0x18fff	(0xa000 bytes) to 0x42000 thru 0x4bfff
6217705(233 mod 256): COLLAPSE 0xa000 thru 0x25fff	(0x1c000 bytes)
6217706(234 mod 256): READ     0x24b14 thru 0x329ab	(0xde98 bytes)
6217707(235 mod 256): ZERO     0xc4f7 thru 0x15dad	(0x98b7 bytes)
6217708(236 mod 256): DEDUPE 0x9000 thru 0x16fff	(0xe000 bytes) to 0x17000 thru 0x24fff
6217709(237 mod 256): PUNCH    0x1203c thru 0x2d4f3	(0x1b4b8 bytes)
6217710(238 mod 256): MAPREAD  0x2b918 thru 0x329ab	(0x7094 bytes)
6217711(239 mod 256): COPY 0x179f5 thru 0x26710	(0xed1c bytes) to 0x3e517 thru 0x4d232
6217712(240 mod 256): INSERT 0x17000 thru 0x33fff	(0x1d000 bytes)
6217713(241 mod 256): COPY 0x32071 thru 0x35197	(0x3127 bytes) to 0x81eeb thru 0x85011
6217714(242 mod 256): INSERT 0x20000 thru 0x2cfff	(0xd000 bytes)
6217715(243 mod 256): WRITE    0x2321e thru 0x3da1d	(0x1a800 bytes)
6217716(244 mod 256): READ     0x28095 thru 0x34a1a	(0xc986 bytes)
6217717(245 mod 256): TRUNCATE DOWN	from 0x92012 to 0x727eb
6217718(246 mod 256): FALLOC   0x5603 thru 0x6791	(0x118e bytes) INTERIOR
6217719(247 mod 256): MAPWRITE 0xc028 thru 0x2117c	(0x15155 bytes)
6217720(248 mod 256): COPY 0x206d7 thru 0x3c175	(0x1ba9f bytes) to 0x3e180 thru 0x59c1e
6217721(249 mod 256): SKIPPED (no operation)
6217722(250 mod 256): SKIPPED (no operation)
6217723(251 mod 256): FALLOC   0x311c2 thru 0x4c8d0	(0x1b70e bytes) INTERIOR
6217724(252 mod 256): FALLOC   0x86f4a thru 0x927c0	(0xb876 bytes) PAST_EOF
6217725(253 mod 256): DEDUPE 0x44000 thru 0x51fff	(0xe000 bytes) to 0x27000 thru 0x34fff
6217726(254 mod 256): DEDUPE 0x4e000 thru 0x5cfff	(0xf000 bytes) to 0x33000 thru 0x41fff
6217727(255 mod 256): COPY 0x69f4c thru 0x727ea	(0x889f bytes) to 0x7a5d7 thru 0x82e75	EEEE******
6217728(  0 mod 256): SKIPPED (no operation)
6217729(  1 mod 256): CLONE 0x47000 thru 0x59fff	(0x13000 bytes) to 0x73000 thru 0x85fff
6217730(  2 mod 256): COPY 0x5e772 thru 0x72904	(0x14193 bytes) to 0x2eba6 thru 0x42d38	EEEE******
6217731(  3 mod 256): MAPWRITE 0x86ddc thru 0x927bf	(0xb9e4 bytes)
6217732(  4 mod 256): CLONE 0x3e000 thru 0x51fff	(0x14000 bytes) to 0x68000 thru 0x7bfff	******JJJJ
6217733(  5 mod 256): FALLOC   0x36b82 thru 0x3d12a	(0x65a8 bytes) INTERIOR
6217734(  6 mod 256): MAPWRITE 0x5eead thru 0x7b771	(0x1c8c5 bytes)	******WWWW
6217735(  7 mod 256): FALLOC   0x35570 thru 0x46eaa	(0x1193a bytes) INTERIOR
6217736(  8 mod 256): CLONE 0x82000 thru 0x90fff	(0xf000 bytes) to 0x5000 thru 0x13fff
6217737(  9 mod 256): PUNCH    0x8be8 thru 0x1d237	(0x14650 bytes)
6217738( 10 mod 256): ZERO     0x234e9 thru 0x24f36	(0x1a4e bytes)
6217739( 11 mod 256): MAPREAD  0x2e631 thru 0x31b7c	(0x354c bytes)
6217740( 12 mod 256): MAPWRITE 0x29aea thru 0x2be31	(0x2348 bytes)
6217741( 13 mod 256): MAPWRITE 0x86cb0 thru 0x927bf	(0xbb10 bytes)
6217742( 14 mod 256): MAPWRITE 0x23b99 thru 0x42167	(0x1e5cf bytes)
6217743( 15 mod 256): ZERO     0x8a209 thru 0x927bf	(0x85b7 bytes)
6217744( 16 mod 256): MAPWRITE 0x5ccff thru 0x6eeb5	(0x121b7 bytes)
6217745( 17 mod 256): PUNCH    0x34519 thru 0x430ca	(0xebb2 bytes)
6217746( 18 mod 256): ZERO     0x58ea8 thru 0x61acd	(0x8c26 bytes)
6217747( 19 mod 256): SKIPPED (no operation)
6217748( 20 mod 256): ZERO     0x11f2d thru 0x204c6	(0xe59a bytes)
6217749( 21 mod 256): FALLOC   0x64655 thru 0x75de3	(0x1178e bytes) INTERIOR	******FFFF
6217750( 22 mod 256): WRITE    0x7901 thru 0x1d9aa	(0x160aa bytes)
6217751( 23 mod 256): ZERO     0x110df thru 0x297b2	(0x186d4 bytes)
6217752( 24 mod 256): CLONE 0xe000 thru 0x14fff	(0x7000 bytes) to 0x5f000 thru 0x65fff
6217753( 25 mod 256): READ     0x54d84 thru 0x6a361	(0x155de bytes)
6217754( 26 mod 256): SKIPPED (no operation)
6217755( 27 mod 256): COLLAPSE 0x3b000 thru 0x48fff	(0xe000 bytes)
6217756( 28 mod 256): READ     0x31bb7 thru 0x45a10	(0x13e5a bytes)
6217757( 29 mod 256): CLONE 0x32000 thru 0x4ffff	(0x1e000 bytes) to 0x5a000 thru 0x77fff	******JJJJ
6217758( 30 mod 256): MAPREAD  0x2a05b thru 0x4578f	(0x1b735 bytes)
6217759( 31 mod 256): DEDUPE 0x1d000 thru 0x2dfff	(0x11000 bytes) to 0x57000 thru 0x67fff
6217760( 32 mod 256): COPY 0xeb89 thru 0x20083	(0x114fb bytes) to 0x4bf9f thru 0x5d499
6217761( 33 mod 256): MAPWRITE 0x731e7 thru 0x87071	(0x13e8b bytes)
6217762( 34 mod 256): MAPWRITE 0x5daa6 thru 0x74bb5	(0x17110 bytes)	******WWWW
6217763( 35 mod 256): WRITE    0x45232 thru 0x60db5	(0x1bb84 bytes)
6217764( 36 mod 256): COLLAPSE 0x21000 thru 0x35fff	(0x15000 bytes)
6217765( 37 mod 256): WRITE    0x6ca9 thru 0x257e3	(0x1eb3b bytes)
6217766( 38 mod 256): COLLAPSE 0x5d000 thru 0x6efff	(0x12000 bytes)	******CCCC
6217767( 39 mod 256): MAPWRITE 0x38e6a thru 0x445df	(0xb776 bytes)
6217768( 40 mod 256): SKIPPED (no operation)
6217769( 41 mod 256): READ     0x155ad thru 0x1fc9a	(0xa6ee bytes)
6217770( 42 mod 256): INSERT 0x4d000 thru 0x4ffff	(0x3000 bytes)
6217771( 43 mod 256): MAPWRITE 0x1fe9b thru 0x2dd03	(0xde69 bytes)
6217772( 44 mod 256): COLLAPSE 0x60000 thru 0x61fff	(0x2000 bytes)
6217773( 45 mod 256): COPY 0x14683 thru 0x31415	(0x1cd93 bytes) to 0x649ab thru 0x8173d	******EEEE
6217774( 46 mod 256): WRITE    0x7219e thru 0x74845	(0x26a8 bytes)
6217775( 47 mod 256): DEDUPE 0x4000 thru 0x21fff	(0x1e000 bytes) to 0x51000 thru 0x6efff	******BBBB
6217776( 48 mod 256): ZERO     0x4a95e thru 0x57a97	(0xd13a bytes)
6217777( 49 mod 256): SKIPPED (no operation)
6217778( 50 mod 256): DEDUPE 0x6e000 thru 0x7ffff	(0x12000 bytes) to 0x10000 thru 0x21fff	BBBB******
6217779( 51 mod 256): FALLOC   0x26da3 thru 0x37196	(0x103f3 bytes) INTERIOR
6217780( 52 mod 256): READ     0x3cd6b thru 0x47a0f	(0xaca5 bytes)
6217781( 53 mod 256): FALLOC   0x64aec thru 0x7c48e	(0x179a2 bytes) INTERIOR	******FFFF
6217782( 54 mod 256): SKIPPED (no operation)
6217783( 55 mod 256): DEDUPE 0x10000 thru 0x18fff	(0x9000 bytes) to 0x29000 thru 0x31fff
6217784( 56 mod 256): MAPREAD  0xab3a thru 0x1a3c5	(0xf88c bytes)
6217785( 57 mod 256): COPY 0x50f1d thru 0x631ad	(0x12291 bytes) to 0x10345 thru 0x225d5
6217786( 58 mod 256): PUNCH    0x2c2 thru 0x50a3	(0x4de2 bytes)
6217787( 59 mod 256): MAPREAD  0x380ee thru 0x4293a	(0xa84d bytes)
6217788( 60 mod 256): MAPWRITE 0x3357c thru 0x4e32d	(0x1adb2 bytes)
6217789( 61 mod 256): PUNCH    0x80f5d thru 0x8173d	(0x7e1 bytes)
6217790( 62 mod 256): WRITE    0x7003b thru 0x87652	(0x17618 bytes) EXTEND
6217791( 63 mod 256): READ     0x2bbd3 thru 0x34bd4	(0x9002 bytes)
6217792( 64 mod 256): ZERO     0x402da thru 0x5e24a	(0x1df71 bytes)
6217793( 65 mod 256): PUNCH    0x1f2b9 thru 0x28115	(0x8e5d bytes)
6217794( 66 mod 256): COPY 0xa043 thru 0x17326	(0xd2e4 bytes) to 0x3ad65 thru 0x48048
6217795( 67 mod 256): READ     0xb752 thru 0x22b7f	(0x1742e bytes)
6217796( 68 mod 256): COLLAPSE 0x4000 thru 0x4fff	(0x1000 bytes)
6217797( 69 mod 256): ZERO     0x5e131 thru 0x60a68	(0x2938 bytes)
6217798( 70 mod 256): MAPWRITE 0x73a4f thru 0x8d910	(0x19ec2 bytes)
6217799( 71 mod 256): READ     0x374c8 thru 0x3add9	(0x3912 bytes)
6217800( 72 mod 256): COPY 0x13f25 thru 0x16263	(0x233f bytes) to 0xb7a thru 0x2eb8
6217801( 73 mod 256): DEDUPE 0x51000 thru 0x5efff	(0xe000 bytes) to 0x2000 thru 0xffff
6217802( 74 mod 256): CLONE 0x6f000 thru 0x7ffff	(0x11000 bytes) to 0x3a000 thru 0x4afff
6217803( 75 mod 256): WRITE    0x3088 thru 0x194a8	(0x16421 bytes)
6217804( 76 mod 256): MAPWRITE 0x48c28 thru 0x6124f	(0x18628 bytes)
6217805( 77 mod 256): MAPREAD  0x6e7ed thru 0x7d8a7	(0xf0bb bytes)	***RRRR***
6217806( 78 mod 256): COLLAPSE 0x82000 thru 0x8cfff	(0xb000 bytes)
6217807( 79 mod 256): COLLAPSE 0x50000 thru 0x68fff	(0x19000 bytes)
6217808( 80 mod 256): DEDUPE 0x34000 thru 0x34fff	(0x1000 bytes) to 0x58000 thru 0x58fff
6217809( 81 mod 256): SKIPPED (no operation)
6217810( 82 mod 256): FALLOC   0x5db5 thru 0x1b954	(0x15b9f bytes) INTERIOR
6217811( 83 mod 256): COLLAPSE 0x2000 thru 0xbfff	(0xa000 bytes)
6217812( 84 mod 256): CLONE 0x35000 thru 0x35fff	(0x1000 bytes) to 0x80000 thru 0x80fff
6217813( 85 mod 256): SKIPPED (no operation)
6217814( 86 mod 256): READ     0x7a7d3 thru 0x80fff	(0x682d bytes)
6217815( 87 mod 256): MAPWRITE 0x1f90e thru 0x2aa7b	(0xb16e bytes)
6217816( 88 mod 256): MAPREAD  0x27be thru 0xe869	(0xc0ac bytes)
6217817( 89 mod 256): CLONE 0x6b000 thru 0x7afff	(0x10000 bytes) to 0x45000 thru 0x54fff	JJJJ******
6217818( 90 mod 256): MAPWRITE 0x6c2f7 thru 0x71684	(0x538e bytes)	******WWWW
6217819( 91 mod 256): MAPREAD  0x6c294 thru 0x763c7	(0xa134 bytes)	***RRRR***
6217820( 92 mod 256): DEDUPE 0x47000 thru 0x64fff	(0x1e000 bytes) to 0xd000 thru 0x2afff
6217821( 93 mod 256): WRITE    0x45edd thru 0x64e34	(0x1ef58 bytes)
6217822( 94 mod 256): TRUNCATE DOWN	from 0x81000 to 0x7f12c
6217823( 95 mod 256): SKIPPED (no operation)
6217824( 96 mod 256): FALLOC   0x543d1 thru 0x6fb2b	(0x1b75a bytes) INTERIOR	******FFFF
6217825( 97 mod 256): ZERO     0x36f66 thru 0x42e63	(0xbefe bytes)
6217826( 98 mod 256): PUNCH    0x7dbd6 thru 0x7f12b	(0x1556 bytes)
6217827( 99 mod 256): CLONE 0x40000 thru 0x55fff	(0x16000 bytes) to 0x2000 thru 0x17fff
6217828(100 mod 256): READ     0x1adf0 thru 0x36acf	(0x1bce0 bytes)
6217829(101 mod 256): SKIPPED (no operation)
6217830(102 mod 256): MAPREAD  0x1dd47 thru 0x3bb74	(0x1de2e bytes)
6217831(103 mod 256): MAPREAD  0x2f9b5 thru 0x3cc59	(0xd2a5 bytes)
6217832(104 mod 256): MAPWRITE 0x20a33 thru 0x3e5c1	(0x1db8f bytes)
6217833(105 mod 256): DEDUPE 0x55000 thru 0x71fff	(0x1d000 bytes) to 0x3000 thru 0x1ffff	BBBB******
6217834(106 mod 256): DEDUPE 0x75000 thru 0x7dfff	(0x9000 bytes) to 0x39000 thru 0x41fff
6217835(107 mod 256): WRITE    0x14ccb thru 0x17259	(0x258f bytes)
6217836(108 mod 256): MAPREAD  0x66ab6 thru 0x72834	(0xbd7f bytes)	***RRRR***
6217837(109 mod 256): COPY 0x222a9 thru 0x3f7ff	(0x1d557 bytes) to 0x43be3 thru 0x61139
6217838(110 mod 256): FALLOC   0x1d200 thru 0x2a3c2	(0xd1c2 bytes) INTERIOR
6217839(111 mod 256): SKIPPED (no operation)
6217840(112 mod 256): TRUNCATE DOWN	from 0x7f12c to 0x39413	******WWWW
6217841(113 mod 256): FALLOC   0x4ccb5 thru 0x63a1a	(0x16d65 bytes) EXTENDING
6217842(114 mod 256): SKIPPED (no operation)
6217843(115 mod 256): SKIPPED (no operation)
6217844(116 mod 256): PUNCH    0x21020 thru 0x27c8c	(0x6c6d bytes)
6217845(117 mod 256): MAPREAD  0x5f522 thru 0x63a19	(0x44f8 bytes)
6217846(118 mod 256): WRITE    0x171a thru 0x39fc	(0x22e3 bytes)
6217847(119 mod 256): WRITE    0x3d45c thru 0x4a3d5	(0xcf7a bytes)
6217848(120 mod 256): COLLAPSE 0x2a000 thru 0x36fff	(0xd000 bytes)
6217849(121 mod 256): SKIPPED (no operation)
6217850(122 mod 256): INSERT 0x2b000 thru 0x40fff	(0x16000 bytes)
6217851(123 mod 256): FALLOC   0x21e9e thru 0x3a7bb	(0x1891d bytes) INTERIOR
6217852(124 mod 256): READ     0x684d0 thru 0x6ca19	(0x454a bytes)
6217853(125 mod 256): MAPREAD  0x1867f thru 0x299f3	(0x11375 bytes)
6217854(126 mod 256): ZERO     0x2c209 thru 0x418b0	(0x156a8 bytes)
6217855(127 mod 256): WRITE    0x3b602 thru 0x3bfb5	(0x9b4 bytes)
6217856(128 mod 256): INSERT 0xe000 thru 0x29fff	(0x1c000 bytes)
6217857(129 mod 256): MAPWRITE 0x80359 thru 0x83ab6	(0x375e bytes)
6217858(130 mod 256): PUNCH    0x2d8d6 thru 0x31120	(0x384b bytes)
6217859(131 mod 256): TRUNCATE DOWN	from 0x88a1a to 0x288d9	******WWWW
6217860(132 mod 256): SKIPPED (no operation)
6217861(133 mod 256): MAPWRITE 0x4c9d4 thru 0x5d5b7	(0x10be4 bytes)
6217862(134 mod 256): SKIPPED (no operation)
6217863(135 mod 256): ZERO     0x334e3 thru 0x35ddf	(0x28fd bytes)
6217864(136 mod 256): READ     0x49740 thru 0x5d5b7	(0x13e78 bytes)
6217865(137 mod 256): TRUNCATE DOWN	from 0x5d5b8 to 0x3e42
6217866(138 mod 256): SKIPPED (no operation)
6217867(139 mod 256): SKIPPED (no operation)
6217868(140 mod 256): FALLOC   0x504bd thru 0x581e1	(0x7d24 bytes) EXTENDING
6217869(141 mod 256): MAPREAD  0x465d1 thru 0x540d6	(0xdb06 bytes)
6217870(142 mod 256): INSERT 0x3d000 thru 0x40fff	(0x4000 bytes)
6217871(143 mod 256): INSERT 0x1b000 thru 0x1efff	(0x4000 bytes)
6217872(144 mod 256): WRITE    0x5b954 thru 0x6adcd	(0xf47a bytes) EXTEND
6217873(145 mod 256): COPY 0x1efa2 thru 0x247e1	(0x5840 bytes) to 0x479d8 thru 0x4d217
6217874(146 mod 256): MAPREAD  0x30836 thru 0x360a5	(0x5870 bytes)
6217875(147 mod 256): PUNCH    0x7ebd thru 0x9b2d	(0x1c71 bytes)
6217876(148 mod 256): READ     0x16afc thru 0x34784	(0x1dc89 bytes)
6217877(149 mod 256): DEDUPE 0x28000 thru 0x3dfff	(0x16000 bytes) to 0x50000 thru 0x65fff
6217878(150 mod 256): MAPREAD  0xb7dc thru 0x206d1	(0x14ef6 bytes)
6217879(151 mod 256): WRITE    0x8ca14 thru 0x8d3b6	(0x9a3 bytes) HOLE	***WWWW
6217880(152 mod 256): TRUNCATE DOWN	from 0x8d3b7 to 0x83557
6217881(153 mod 256): WRITE    0x22653 thru 0x2beca	(0x9878 bytes)
6217882(154 mod 256): MAPWRITE 0x3ca8c thru 0x463b8	(0x992d bytes)
6217883(155 mod 256): MAPWRITE 0x26648 thru 0x41d96	(0x1b74f bytes)
6217884(156 mod 256): DEDUPE 0x53000 thru 0x70fff	(0x1e000 bytes) to 0x2a000 thru 0x47fff	BBBB******
6217885(157 mod 256): PUNCH    0x7b8c6 thru 0x8215e	(0x6899 bytes)
6217886(158 mod 256): FALLOC   0x439c5 thru 0x4c593	(0x8bce bytes) INTERIOR
6217887(159 mod 256): TRUNCATE DOWN	from 0x83557 to 0x40eda	******WWWW
6217888(160 mod 256): SKIPPED (no operation)
6217889(161 mod 256): PUNCH    0x8801 thru 0x182ff	(0xfaff bytes)
6217890(162 mod 256): TRUNCATE UP	from 0x40eda to 0x70bb3	******WWWW
6217891(163 mod 256): READ     0x17e9 thru 0x19996	(0x181ae bytes)
6217892(164 mod 256): FALLOC   0x61740 thru 0x7de50	(0x1c710 bytes) PAST_EOF	******FFFF
6217893(165 mod 256): READ     0x1fce3 thru 0x35247	(0x15565 bytes)
6217894(166 mod 256): COPY 0x26899 thru 0x3cf7c	(0x166e4 bytes) to 0xe90f thru 0x24ff2
6217895(167 mod 256): SKIPPED (no operation)
6217896(168 mod 256): PUNCH    0x3b04 thru 0x11d3d	(0xe23a bytes)
6217897(169 mod 256): ZERO     0x28a46 thru 0x3f861	(0x16e1c bytes)
6217898(170 mod 256): PUNCH    0x2e434 thru 0x3d425	(0xeff2 bytes)
6217899(171 mod 256): MAPREAD  0xc1b5 thru 0x192ec	(0xd138 bytes)
6217900(172 mod 256): SKIPPED (no operation)
6217901(173 mod 256): COLLAPSE 0x1f000 thru 0x2dfff	(0xf000 bytes)
6217902(174 mod 256): WRITE    0x42d4f thru 0x48239	(0x54eb bytes)
6217903(175 mod 256): MAPWRITE 0x6eb6c thru 0x8b788	(0x1cc1d bytes)	******WWWW
6217904(176 mod 256): PUNCH    0x8a6e8 thru 0x8b788	(0x10a1 bytes)
6217905(177 mod 256): SKIPPED (no operation)
6217906(178 mod 256): COLLAPSE 0x42000 thru 0x42fff	(0x1000 bytes)
6217907(179 mod 256): TRUNCATE DOWN	from 0x8a789 to 0x575a	******WWWW
6217908(180 mod 256): MAPWRITE 0x853a5 thru 0x927bf	(0xd41b bytes)
6217909(181 mod 256): COPY 0x71379 thru 0x85506	(0x1418e bytes) to 0xd2b4 thru 0x21441
6217910(182 mod 256): PUNCH    0x48681 thru 0x66982	(0x1e302 bytes)
6217911(183 mod 256): MAPREAD  0x44e18 thru 0x5a9a1	(0x15b8a bytes)
6217912(184 mod 256): MAPWRITE 0x83221 thru 0x8ed11	(0xbaf1 bytes)
6217913(185 mod 256): SKIPPED (no operation)
6217914(186 mod 256): COPY 0x6dc0e thru 0x73f5e	(0x6351 bytes) to 0x5cf13 thru 0x63263	EEEE******
6217915(187 mod 256): READ     0x82052 thru 0x927bf	(0x1076e bytes)
6217916(188 mod 256): SKIPPED (no operation)
6217917(189 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x313e0	******WWWW
6217918(190 mod 256): FALLOC   0x2f316 thru 0x336d3	(0x43bd bytes) PAST_EOF
6217919(191 mod 256): PUNCH    0x22d24 thru 0x25517	(0x27f4 bytes)
6217920(192 mod 256): COLLAPSE 0x11000 thru 0x11fff	(0x1000 bytes)
6217921(193 mod 256): READ     0x26bf1 thru 0x303df	(0x97ef bytes)
6217922(194 mod 256): ZERO     0x80e0a thru 0x927bf	(0x119b6 bytes)
6217923(195 mod 256): TRUNCATE DOWN	from 0x303e0 to 0x2f6fd
6217924(196 mod 256): CLONE 0x18000 thru 0x2efff	(0x17000 bytes) to 0x6d000 thru 0x83fff	******JJJJ
6217925(197 mod 256): SKIPPED (no operation)
6217926(198 mod 256): WRITE    0x12c4b thru 0x2f509	(0x1c8bf bytes)
6217927(199 mod 256): WRITE    0x85f34 thru 0x927bf	(0xc88c bytes) HOLE
6217928(200 mod 256): CLONE 0x3c000 thru 0x42fff	(0x7000 bytes) to 0x16000 thru 0x1cfff
6217929(201 mod 256): MAPREAD  0x8e5bd thru 0x927bf	(0x4203 bytes)
6217930(202 mod 256): PUNCH    0x55699 thru 0x6fd43	(0x1a6ab bytes)	******PPPP
6217931(203 mod 256): SKIPPED (no operation)
6217932(204 mod 256): SKIPPED (no operation)
6217933(205 mod 256): PUNCH    0x1fde8 thru 0x24de3	(0x4ffc bytes)
6217934(206 mod 256): WRITE    0x81c24 thru 0x87bcd	(0x5faa bytes)
6217935(207 mod 256): MAPREAD  0xbd4a thru 0x29468	(0x1d71f bytes)
6217936(208 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x779d9
6217937(209 mod 256): CLONE 0x9000 thru 0x1dfff	(0x15000 bytes) to 0x27000 thru 0x3bfff
6217938(210 mod 256): COLLAPSE 0x40000 thru 0x4bfff	(0xc000 bytes)
6217939(211 mod 256): MAPREAD  0x1624c thru 0x2fa26	(0x197db bytes)
6217940(212 mod 256): INSERT 0x54000 thru 0x6ffff	(0x1c000 bytes)	******IIII
6217941(213 mod 256): FALLOC   0x44fd9 thru 0x58c6a	(0x13c91 bytes) INTERIOR
6217942(214 mod 256): WRITE    0x6f602 thru 0x7439a	(0x4d99 bytes)
6217943(215 mod 256): ZERO     0x3e9d4 thru 0x563c1	(0x179ee bytes)
6217944(216 mod 256): ZERO     0x2c1d4 thru 0x3cf85	(0x10db2 bytes)
6217945(217 mod 256): COLLAPSE 0x30000 thru 0x33fff	(0x4000 bytes)
6217946(218 mod 256): WRITE    0x1a513 thru 0x26995	(0xc483 bytes)
6217947(219 mod 256): READ     0x77327 thru 0x839d8	(0xc6b2 bytes)
6217948(220 mod 256): MAPREAD  0x42bd2 thru 0x5a70c	(0x17b3b bytes)
6217949(221 mod 256): CLONE 0x82000 thru 0x82fff	(0x1000 bytes) to 0x21000 thru 0x21fff
6217950(222 mod 256): SKIPPED (no operation)
6217951(223 mod 256): COLLAPSE 0x4a000 thru 0x59fff	(0x10000 bytes)
6217952(224 mod 256): CLONE 0x10000 thru 0x2bfff	(0x1c000 bytes) to 0x35000 thru 0x50fff
6217953(225 mod 256): INSERT 0x10000 thru 0x1cfff	(0xd000 bytes)
6217954(226 mod 256): INSERT 0xf000 thru 0x1ffff	(0x11000 bytes)
6217955(227 mod 256): CLONE 0x34000 thru 0x4efff	(0x1b000 bytes) to 0x17000 thru 0x31fff
6217956(228 mod 256): ZERO     0x64de5 thru 0x7c59c	(0x177b8 bytes)	******ZZZZ
6217957(229 mod 256): COLLAPSE 0x4a000 thru 0x55fff	(0xc000 bytes)
6217958(230 mod 256): CLONE 0x75000 thru 0x84fff	(0x10000 bytes) to 0x60000 thru 0x6ffff	******JJJJ
6217959(231 mod 256): COPY 0x5d9b3 thru 0x68bcb	(0xb219 bytes) to 0x7c8d3 thru 0x87aeb
6217960(232 mod 256): COLLAPSE 0x42000 thru 0x56fff	(0x15000 bytes)
6217961(233 mod 256): FALLOC   0x1182e thru 0x17466	(0x5c38 bytes) INTERIOR
6217962(234 mod 256): CLONE 0x69000 thru 0x71fff	(0x9000 bytes) to 0x4a000 thru 0x52fff	JJJJ******
6217963(235 mod 256): PUNCH    0x632ad thru 0x72aeb	(0xf83f bytes)	******PPPP
6217964(236 mod 256): INSERT 0x4f000 thru 0x6afff	(0x1c000 bytes)
6217965(237 mod 256): ZERO     0x9042f thru 0x927bf	(0x2391 bytes)
6217966(238 mod 256): MAPREAD  0x80704 thru 0x8b49a	(0xad97 bytes)
6217967(239 mod 256): COLLAPSE 0xd000 thru 0x18fff	(0xc000 bytes)
6217968(240 mod 256): DEDUPE 0x41000 thru 0x55fff	(0x15000 bytes) to 0x68000 thru 0x7cfff	******BBBB
6217969(241 mod 256): DEDUPE 0x71000 thru 0x80fff	(0x10000 bytes) to 0x18000 thru 0x27fff
6217970(242 mod 256): CLONE 0x5000 thru 0x12fff	(0xe000 bytes) to 0x20000 thru 0x2dfff
6217971(243 mod 256): TRUNCATE DOWN	from 0x82aec to 0xe111	******WWWW
6217972(244 mod 256): WRITE    0x3941b thru 0x50570	(0x17156 bytes) HOLE
6217973(245 mod 256): COPY 0x1a5 thru 0x10c3a	(0x10a96 bytes) to 0x210e1 thru 0x31b76
6217974(246 mod 256): SKIPPED (no operation)
6217975(247 mod 256): MAPREAD  0x2600 thru 0x4394	(0x1d95 bytes)
6217976(248 mod 256): MAPREAD  0x3c89 thru 0xafbd	(0x7335 bytes)
6217977(249 mod 256): CLONE 0x3f000 thru 0x4efff	(0x10000 bytes) to 0x1e000 thru 0x2dfff
6217978(250 mod 256): ZERO     0x1e8fa thru 0x2de4a	(0xf551 bytes)
6217979(251 mod 256): CLONE 0x40000 thru 0x41fff	(0x2000 bytes) to 0x4d000 thru 0x4efff
6217980(252 mod 256): WRITE    0x7601f thru 0x7838f	(0x2371 bytes) HOLE	***WWWW
6217981(253 mod 256): WRITE    0x638 thru 0x7aca	(0x7493 bytes)
6217982(254 mod 256): WRITE    0x64973 thru 0x6abf4	(0x6282 bytes)
6217983(255 mod 256): COPY 0x39b4e thru 0x3b470	(0x1923 bytes) to 0x88772 thru 0x8a094
6217984(  0 mod 256): INSERT 0x3f000 thru 0x46fff	(0x8000 bytes)
6217985(  1 mod 256): TRUNCATE DOWN	from 0x92095 to 0x2019b	******WWWW
6217986(  2 mod 256): ZERO     0x6172a thru 0x78bcd	(0x174a4 bytes)	******ZZZZ
6217987(  3 mod 256): CLONE 0xc000 thru 0x1efff	(0x13000 bytes) to 0x21000 thru 0x33fff
6217988(  4 mod 256): COLLAPSE 0x2e000 thru 0x32fff	(0x5000 bytes)
6217989(  5 mod 256): DEDUPE 0xa000 thru 0xafff	(0x1000 bytes) to 0x21000 thru 0x21fff
6217990(  6 mod 256): WRITE    0x8a442 thru 0x927bf	(0x837e bytes) HOLE	***WWWW
6217991(  7 mod 256): MAPREAD  0x5d1b thru 0x92a1	(0x3587 bytes)
6217992(  8 mod 256): SKIPPED (no operation)
6217993(  9 mod 256): COPY 0x49d33 thru 0x5ad8d	(0x1105b bytes) to 0x79798 thru 0x8a7f2
6217994( 10 mod 256): WRITE    0x8eeee thru 0x927bf	(0x38d2 bytes)
6217995( 11 mod 256): PUNCH    0x261e5 thru 0x3eb68	(0x18984 bytes)
6217996( 12 mod 256): SKIPPED (no operation)
6217997( 13 mod 256): MAPWRITE 0x41b19 thru 0x4e9d0	(0xceb8 bytes)
6217998( 14 mod 256): ZERO     0x4991e thru 0x5ba93	(0x12176 bytes)
6217999( 15 mod 256): FALLOC   0x651bf thru 0x69fba	(0x4dfb bytes) INTERIOR
6218000( 16 mod 256): COPY 0x589fe thru 0x5cfa7	(0x45aa bytes) to 0x4371a thru 0x47cc3
6218001( 17 mod 256): ZERO     0x3f91c thru 0x5d291	(0x1d976 bytes)
6218002( 18 mod 256): MAPWRITE 0x898c7 thru 0x927bf	(0x8ef9 bytes)
6218003( 19 mod 256): WRITE    0x20008 thru 0x24afa	(0x4af3 bytes)
6218004( 20 mod 256): SKIPPED (no operation)
6218005( 21 mod 256): READ     0x8cc2e thru 0x927bf	(0x5b92 bytes)
6218006( 22 mod 256): DEDUPE 0x24000 thru 0x34fff	(0x11000 bytes) to 0x7b000 thru 0x8bfff
6218007( 23 mod 256): WRITE    0x3e411 thru 0x411c1	(0x2db1 bytes)
6218008( 24 mod 256): COPY 0x14b65 thru 0x2e429	(0x198c5 bytes) to 0x3633a thru 0x4fbfe
6218009( 25 mod 256): SKIPPED (no operation)
6218010( 26 mod 256): COLLAPSE 0x8a000 thru 0x8afff	(0x1000 bytes)
6218011( 27 mod 256): PUNCH    0x464da thru 0x61ee0	(0x1ba07 bytes)
6218012( 28 mod 256): TRUNCATE DOWN	from 0x917c0 to 0x1e71a	******WWWW
6218013( 29 mod 256): MAPREAD  0x7a56 thru 0x1e579	(0x16b24 bytes)
6218014( 30 mod 256): ZERO     0x14b75 thru 0x2af58	(0x163e4 bytes)
6218015( 31 mod 256): FALLOC   0x5353b thru 0x5caab	(0x9570 bytes) EXTENDING
6218016( 32 mod 256): ZERO     0x42ed7 thru 0x58886	(0x159b0 bytes)
6218017( 33 mod 256): COPY 0x3520d thru 0x50faa	(0x1bd9e bytes) to 0x5ea4b thru 0x7a7e8	******EEEE
6218018( 34 mod 256): FALLOC   0x2065c thru 0x2c387	(0xbd2b bytes) INTERIOR
6218019( 35 mod 256): PUNCH    0x48f90 thru 0x5ef69	(0x15fda bytes)
6218020( 36 mod 256): ZERO     0x4f890 thru 0x53b3a	(0x42ab bytes)
6218021( 37 mod 256): SKIPPED (no operation)
6218022( 38 mod 256): DEDUPE 0x6e000 thru 0x74fff	(0x7000 bytes) to 0x2b000 thru 0x31fff	BBBB******
6218023( 39 mod 256): MAPWRITE 0x375ef thru 0x39623	(0x2035 bytes)
6218024( 40 mod 256): MAPWRITE 0xcfc5 thru 0x10e95	(0x3ed1 bytes)
6218025( 41 mod 256): FALLOC   0x5b76d thru 0x6c1dc	(0x10a6f bytes) INTERIOR
6218026( 42 mod 256): MAPWRITE 0x4561e thru 0x5f203	(0x19be6 bytes)
6218027( 43 mod 256): TRUNCATE DOWN	from 0x7a7e9 to 0x1ee9f	******WWWW
6218028( 44 mod 256): MAPWRITE 0x115b7 thru 0x2bcd7	(0x1a721 bytes)
6218029( 45 mod 256): MAPWRITE 0x531ab thru 0x686da	(0x15530 bytes)
6218030( 46 mod 256): WRITE    0x44cff thru 0x5119c	(0xc49e bytes)
6218031( 47 mod 256): DEDUPE 0x3d000 thru 0x42fff	(0x6000 bytes) to 0x5000 thru 0xafff
6218032( 48 mod 256): MAPWRITE 0x63f3d thru 0x6abf7	(0x6cbb bytes)
6218033( 49 mod 256): FALLOC   0x8e25d thru 0x927c0	(0x4563 bytes) EXTENDING
6218034( 50 mod 256): WRITE    0x7ada6 thru 0x8f766	(0x149c1 bytes)
6218035( 51 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x6c745	******WWWW
6218036( 52 mod 256): WRITE    0x429a7 thru 0x4926f	(0x68c9 bytes)
6218037( 53 mod 256): READ     0x2563 thru 0xbd89	(0x9827 bytes)
6218038( 54 mod 256): MAPWRITE 0x40484 thru 0x5518c	(0x14d09 bytes)
6218039( 55 mod 256): DEDUPE 0x3f000 thru 0x44fff	(0x6000 bytes) to 0x5c000 thru 0x61fff
6218040( 56 mod 256): ZERO     0x27514 thru 0x3cd07	(0x157f4 bytes)
6218041( 57 mod 256): ZERO     0x28caf thru 0x44f3d	(0x1c28f bytes)
6218042( 58 mod 256): READ     0x57be2 thru 0x5faed	(0x7f0c bytes)
6218043( 59 mod 256): COPY 0x7852 thru 0x22751	(0x1af00 bytes) to 0x609fe thru 0x7b8fd	******EEEE
6218044( 60 mod 256): FALLOC   0x5545d thru 0x58760	(0x3303 bytes) INTERIOR
6218045( 61 mod 256): INSERT 0x39000 thru 0x40fff	(0x8000 bytes)
6218046( 62 mod 256): TRUNCATE DOWN	from 0x838fe to 0x10f97	******WWWW
6218047( 63 mod 256): CLONE 0x5000 thru 0xffff	(0xb000 bytes) to 0x45000 thru 0x4ffff
6218048( 64 mod 256): PUNCH    0x25d6e thru 0x40fee	(0x1b281 bytes)
6218049( 65 mod 256): CLONE 0x3f000 thru 0x4efff	(0x10000 bytes) to 0x29000 thru 0x38fff
6218050( 66 mod 256): MAPREAD  0x16c15 thru 0x1a72a	(0x3b16 bytes)
6218051( 67 mod 256): COPY 0x5861 thru 0xada9	(0x5549 bytes) to 0x73a4a thru 0x78f92
6218052( 68 mod 256): DEDUPE 0x14000 thru 0x1bfff	(0x8000 bytes) to 0x48000 thru 0x4ffff
6218053( 69 mod 256): WRITE    0x5278d thru 0x707ee	(0x1e062 bytes)	***WWWW
6218054( 70 mod 256): WRITE    0x1f2df thru 0x3ab15	(0x1b837 bytes)
6218055( 71 mod 256): INSERT 0x1d000 thru 0x23fff	(0x7000 bytes)
6218056( 72 mod 256): COLLAPSE 0x25000 thru 0x38fff	(0x14000 bytes)
6218057( 73 mod 256): SKIPPED (no operation)
6218058( 74 mod 256): MAPREAD  0x41542 thru 0x57815	(0x162d4 bytes)
6218059( 75 mod 256): SKIPPED (no operation)
6218060( 76 mod 256): WRITE    0x8b9e thru 0xc309	(0x376c bytes)
6218061( 77 mod 256): CLONE 0x29000 thru 0x45fff	(0x1d000 bytes) to 0x68000 thru 0x84fff	******JJJJ
6218062( 78 mod 256): MAPREAD  0x7547a thru 0x84fff	(0xfb86 bytes)
6218063( 79 mod 256): MAPWRITE 0x6b903 thru 0x7b01c	(0xf71a bytes)	******WWWW
6218064( 80 mod 256): CLONE 0x1000 thru 0xefff	(0xe000 bytes) to 0x7d000 thru 0x8afff
6218065( 81 mod 256): INSERT 0x5e000 thru 0x64fff	(0x7000 bytes)
6218066( 82 mod 256): SKIPPED (no operation)
6218067( 83 mod 256): DEDUPE 0x2c000 thru 0x2efff	(0x3000 bytes) to 0x6e000 thru 0x70fff	******BBBB
6218068( 84 mod 256): SKIPPED (no operation)
6218069( 85 mod 256): MAPREAD  0x23c41 thru 0x2998b	(0x5d4b bytes)
6218070( 86 mod 256): FALLOC   0x86b27 thru 0x927c0	(0xbc99 bytes) PAST_EOF
6218071( 87 mod 256): MAPREAD  0x5026e thru 0x637e6	(0x13579 bytes)
6218072( 88 mod 256): MAPWRITE 0x7c51a thru 0x88696	(0xc17d bytes)
6218073( 89 mod 256): DEDUPE 0x2000 thru 0x8fff	(0x7000 bytes) to 0x7a000 thru 0x80fff
6218074( 90 mod 256): DEDUPE 0x1000 thru 0x7fff	(0x7000 bytes) to 0x67000 thru 0x6dfff
6218075( 91 mod 256): CLONE 0x84000 thru 0x90fff	(0xd000 bytes) to 0x47000 thru 0x53fff
6218076( 92 mod 256): PUNCH    0x1749d thru 0x200cd	(0x8c31 bytes)
6218077( 93 mod 256): MAPWRITE 0x43323 thru 0x45927	(0x2605 bytes)
6218078( 94 mod 256): PUNCH    0x17c82 thru 0x2ca9f	(0x14e1e bytes)
6218079( 95 mod 256): TRUNCATE DOWN	from 0x92000 to 0x126e1	******WWWW
6218080( 96 mod 256): PUNCH    0xe1b5 thru 0x126e0	(0x452c bytes)
6218081( 97 mod 256): MAPWRITE 0x8fecb thru 0x927bf	(0x28f5 bytes)
6218082( 98 mod 256): FALLOC   0x64068 thru 0x6a55c	(0x64f4 bytes) INTERIOR
6218083( 99 mod 256): ZERO     0x1fe17 thru 0x3510f	(0x152f9 bytes)
6218084(100 mod 256): ZERO     0x5a0a6 thru 0x696cb	(0xf626 bytes)
6218085(101 mod 256): ZERO     0x6bdbb thru 0x776d3	(0xb919 bytes)	******ZZZZ
6218086(102 mod 256): MAPWRITE 0x90b67 thru 0x927bf	(0x1c59 bytes)
6218087(103 mod 256): PUNCH    0x89485 thru 0x927bf	(0x933b bytes)
6218088(104 mod 256): DEDUPE 0x24000 thru 0x3ffff	(0x1c000 bytes) to 0x49000 thru 0x64fff
6218089(105 mod 256): MAPWRITE 0x5c32e thru 0x77eaa	(0x1bb7d bytes)	******WWWW
6218090(106 mod 256): MAPREAD  0x659c0 thru 0x6d9a8	(0x7fe9 bytes)
6218091(107 mod 256): DEDUPE 0x85000 thru 0x90fff	(0xc000 bytes) to 0x58000 thru 0x63fff
6218092(108 mod 256): PUNCH    0x7c74d thru 0x8873e	(0xbff2 bytes)
6218093(109 mod 256): SKIPPED (no operation)
6218094(110 mod 256): WRITE    0x2fc59 thru 0x3f9c7	(0xfd6f bytes)
6218095(111 mod 256): SKIPPED (no operation)
6218096(112 mod 256): DEDUPE 0x69000 thru 0x84fff	(0x1c000 bytes) to 0x33000 thru 0x4efff	BBBB******
6218097(113 mod 256): CLONE 0x5d000 thru 0x70fff	(0x14000 bytes) to 0x5000 thru 0x18fff	JJJJ******
6218098(114 mod 256): SKIPPED (no operation)
6218099(115 mod 256): COPY 0x4f9c9 thru 0x69058	(0x19690 bytes) to 0x139a thru 0x1aa29
6218100(116 mod 256): READ     0x581ae thru 0x6c957	(0x147aa bytes)
6218101(117 mod 256): WRITE    0x866fc thru 0x87967	(0x126c bytes)
6218102(118 mod 256): SKIPPED (no operation)
6218103(119 mod 256): FALLOC   0x1d839 thru 0x3ad5f	(0x1d526 bytes) INTERIOR
6218104(120 mod 256): SKIPPED (no operation)
6218105(121 mod 256): FALLOC   0x8ac29 thru 0x927c0	(0x7b97 bytes) INTERIOR
6218106(122 mod 256): DEDUPE 0x72000 thru 0x89fff	(0x18000 bytes) to 0x1f000 thru 0x36fff
6218107(123 mod 256): SKIPPED (no operation)
6218108(124 mod 256): FALLOC   0x61866 thru 0x79695	(0x17e2f bytes) INTERIOR	******FFFF
6218109(125 mod 256): COPY 0x72d66 thru 0x74ec6	(0x2161 bytes) to 0x17f96 thru 0x1a0f6
6218110(126 mod 256): FALLOC   0x8598 thru 0x1c311	(0x13d79 bytes) INTERIOR
6218111(127 mod 256): COPY 0xd475 thru 0x2b671	(0x1e1fd bytes) to 0x5f0d8 thru 0x7d2d4	******EEEE
6218112(128 mod 256): SKIPPED (no operation)
6218113(129 mod 256): DEDUPE 0x3e000 thru 0x41fff	(0x4000 bytes) to 0x6b000 thru 0x6efff	******BBBB
6218114(130 mod 256): COLLAPSE 0x20000 thru 0x39fff	(0x1a000 bytes)
6218115(131 mod 256): DEDUPE 0x67000 thru 0x77fff	(0x11000 bytes) to 0x38000 thru 0x48fff	BBBB******
6218116(132 mod 256): SKIPPED (no operation)
6218117(133 mod 256): DEDUPE 0x5b000 thru 0x6efff	(0x14000 bytes) to 0x42000 thru 0x55fff	BBBB******
6218118(134 mod 256): WRITE    0x5df69 thru 0x7cbaa	(0x1ec42 bytes) EXTEND	***WWWW
6218119(135 mod 256): READ     0x60484 thru 0x6e4f4	(0xe071 bytes)
6218120(136 mod 256): CLONE 0x1a000 thru 0x36fff	(0x1d000 bytes) to 0x55000 thru 0x71fff	******JJJJ
6218121(137 mod 256): ZERO     0x6bebb thru 0x89634	(0x1d77a bytes)	******ZZZZ
6218122(138 mod 256): PUNCH    0xca02 thru 0x1c579	(0xfb78 bytes)
6218123(139 mod 256): INSERT 0x61000 thru 0x75fff	(0x15000 bytes)	******IIII
6218124(140 mod 256): FALLOC   0x14bca thru 0x32531	(0x1d967 bytes) INTERIOR
6218125(141 mod 256): MAPWRITE 0x86a4 thru 0x1d16b	(0x14ac8 bytes)
6218126(142 mod 256): COLLAPSE 0xf000 thru 0x20fff	(0x12000 bytes)
6218127(143 mod 256): COLLAPSE 0x59000 thru 0x5afff	(0x2000 bytes)
6218128(144 mod 256): INSERT 0x6000 thru 0x11fff	(0xc000 bytes)
6218129(145 mod 256): COPY 0x75f9c thru 0x89baa	(0x13c0f bytes) to 0x3e1f8 thru 0x51e06
6218130(146 mod 256): MAPREAD  0x27fe4 thru 0x2e934	(0x6951 bytes)
6218131(147 mod 256): DEDUPE 0x7000 thru 0xefff	(0x8000 bytes) to 0x52000 thru 0x59fff
6218132(148 mod 256): INSERT 0x85000 thru 0x8cfff	(0x8000 bytes)
6218133(149 mod 256): MAPREAD  0x5e248 thru 0x5f225	(0xfde bytes)
6218134(150 mod 256): COLLAPSE 0x2d000 thru 0x2efff	(0x2000 bytes)
6218135(151 mod 256): PUNCH    0x8041d thru 0x8184a	(0x142e bytes)
6218136(152 mod 256): COPY 0x180c6 thru 0x32887	(0x1a7c2 bytes) to 0x56828 thru 0x70fe9	******EEEE
6218137(153 mod 256): FALLOC   0x452c5 thru 0x52007	(0xcd42 bytes) INTERIOR
6218138(154 mod 256): INSERT 0x31000 thru 0x32fff	(0x2000 bytes)
6218139(155 mod 256): PUNCH    0x993 thru 0x136c8	(0x12d36 bytes)
6218140(156 mod 256): CLONE 0x81000 thru 0x86fff	(0x6000 bytes) to 0x25000 thru 0x2afff
6218141(157 mod 256): COPY 0x286da thru 0x44beb	(0x1c512 bytes) to 0x5b021 thru 0x77532	******EEEE
6218142(158 mod 256): ZERO     0x6bb70 thru 0x7a4f7	(0xe988 bytes)	******ZZZZ
6218143(159 mod 256): COPY 0x33013 thru 0x4df90	(0x1af7e bytes) to 0x6f7c8 thru 0x8a745
6218144(160 mod 256): SKIPPED (no operation)
6218145(161 mod 256): FALLOC   0x6ee4f thru 0x789a4	(0x9b55 bytes) INTERIOR	******FFFF
6218146(162 mod 256): ZERO     0x8a056 thru 0x927bf	(0x876a bytes)
6218147(163 mod 256): ZERO     0x2b6e1 thru 0x36355	(0xac75 bytes)
6218148(164 mod 256): FALLOC   0x52c91 thru 0x70d90	(0x1e0ff bytes) INTERIOR	******FFFF
6218149(165 mod 256): READ     0x8afc3 thru 0x927bf	(0x77fd bytes)
6218150(166 mod 256): MAPWRITE 0x6aef3 thru 0x72eea	(0x7ff8 bytes)	******WWWW
6218151(167 mod 256): SKIPPED (no operation)
6218152(168 mod 256): SKIPPED (no operation)
6218153(169 mod 256): MAPREAD  0x4ca4 thru 0xcae8	(0x7e45 bytes)
6218154(170 mod 256): MAPREAD  0x3549d thru 0x539cc	(0x1e530 bytes)
6218155(171 mod 256): COPY 0x109d5 thru 0x24a90	(0x140bc bytes) to 0x288c3 thru 0x3c97e
6218156(172 mod 256): FALLOC   0x33860 thru 0x48988	(0x15128 bytes) INTERIOR
6218157(173 mod 256): MAPREAD  0x35142 thru 0x4c56d	(0x1742c bytes)
6218158(174 mod 256): FALLOC   0x2dcda thru 0x41a9f	(0x13dc5 bytes) INTERIOR
6218159(175 mod 256): MAPREAD  0x7e0f7 thru 0x91e37	(0x13d41 bytes)
6218160(176 mod 256): SKIPPED (no operation)
6218161(177 mod 256): PUNCH    0x8956e thru 0x927bf	(0x9252 bytes)
6218162(178 mod 256): FALLOC   0x2c9aa thru 0x2da0d	(0x1063 bytes) INTERIOR
6218163(179 mod 256): FALLOC   0x17185 thru 0x2162f	(0xa4aa bytes) INTERIOR
6218164(180 mod 256): ZERO     0x13e71 thru 0x15928	(0x1ab8 bytes)
6218165(181 mod 256): DEDUPE 0x3e000 thru 0x47fff	(0xa000 bytes) to 0x4e000 thru 0x57fff
6218166(182 mod 256): SKIPPED (no operation)
6218167(183 mod 256): ZERO     0x2cc67 thru 0x3042c	(0x37c6 bytes)
6218168(184 mod 256): MAPWRITE 0x213dd thru 0x35812	(0x14436 bytes)
6218169(185 mod 256): DEDUPE 0x1c000 thru 0x1dfff	(0x2000 bytes) to 0x6a000 thru 0x6bfff
6218170(186 mod 256): CLONE 0x42000 thru 0x49fff	(0x8000 bytes) to 0x32000 thru 0x39fff
6218171(187 mod 256): COPY 0x63ba7 thru 0x70a21	(0xce7b bytes) to 0x4d9cd thru 0x5a847	EEEE******
6218172(188 mod 256): FALLOC   0xa755 thru 0x2481c	(0x1a0c7 bytes) INTERIOR
6218173(189 mod 256): SKIPPED (no operation)
6218174(190 mod 256): FALLOC   0x741a1 thru 0x88127	(0x13f86 bytes) INTERIOR
6218175(191 mod 256): COLLAPSE 0x8d000 thru 0x90fff	(0x4000 bytes)
6218176(192 mod 256): MAPWRITE 0x8e455 thru 0x927bf	(0x436b bytes)
6218177(193 mod 256): ZERO     0x68ac2 thru 0x6b791	(0x2cd0 bytes)
6218178(194 mod 256): FALLOC   0x11543 thru 0x2d832	(0x1c2ef bytes) INTERIOR
6218179(195 mod 256): WRITE    0x4bc39 thru 0x50ea4	(0x526c bytes)
6218180(196 mod 256): WRITE    0x3cfae thru 0x43550	(0x65a3 bytes)
6218181(197 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x910c2
6218182(198 mod 256): INSERT 0x49000 thru 0x49fff	(0x1000 bytes)
6218183(199 mod 256): TRUNCATE DOWN	from 0x920c2 to 0x610c2	******WWWW
6218184(200 mod 256): PUNCH    0x18531 thru 0x1c619	(0x40e9 bytes)
6218185(201 mod 256): COLLAPSE 0x5c000 thru 0x5ffff	(0x4000 bytes)
6218186(202 mod 256): COLLAPSE 0x2b000 thru 0x3dfff	(0x13000 bytes)
6218187(203 mod 256): MAPWRITE 0x6f9da thru 0x7830c	(0x8933 bytes)
6218188(204 mod 256): MAPWRITE 0x16946 thru 0x26985	(0x10040 bytes)
6218189(205 mod 256): WRITE    0x557d7 thru 0x6af7f	(0x157a9 bytes)
6218190(206 mod 256): PUNCH    0x3c264 thru 0x45de1	(0x9b7e bytes)
6218191(207 mod 256): DEDUPE 0x45000 thru 0x47fff	(0x3000 bytes) to 0x3c000 thru 0x3efff
6218192(208 mod 256): ZERO     0x193af thru 0x234af	(0xa101 bytes)
6218193(209 mod 256): MAPWRITE 0x1c011 thru 0x20723	(0x4713 bytes)
6218194(210 mod 256): MAPWRITE 0x5a3f0 thru 0x792ab	(0x1eebc bytes)	******WWWW
6218195(211 mod 256): DEDUPE 0x4c000 thru 0x58fff	(0xd000 bytes) to 0x2a000 thru 0x36fff
6218196(212 mod 256): COLLAPSE 0x39000 thru 0x51fff	(0x19000 bytes)
6218197(213 mod 256): PUNCH    0x38e9d thru 0x51496	(0x185fa bytes)
6218198(214 mod 256): COPY 0x5028a thru 0x5c9a2	(0xc719 bytes) to 0xea2c thru 0x1b144
6218199(215 mod 256): SKIPPED (no operation)
6218200(216 mod 256): PUNCH    0x2e7d1 thru 0x477ca	(0x18ffa bytes)
6218201(217 mod 256): INSERT 0x37000 thru 0x46fff	(0x10000 bytes)
6218202(218 mod 256): ZERO     0x1992e thru 0x30682	(0x16d55 bytes)
6218203(219 mod 256): TRUNCATE DOWN	from 0x702ac to 0xc8d2	******WWWW
6218204(220 mod 256): INSERT 0x6000 thru 0x1afff	(0x15000 bytes)
6218205(221 mod 256): CLONE 0xf000 thru 0x1dfff	(0xf000 bytes) to 0x40000 thru 0x4efff
6218206(222 mod 256): MAPREAD  0x46dd thru 0x914a	(0x4a6e bytes)
6218207(223 mod 256): MAPWRITE 0x12c71 thru 0x17397	(0x4727 bytes)
6218208(224 mod 256): SKIPPED (no operation)
6218209(225 mod 256): PUNCH    0x517 thru 0x19af9	(0x195e3 bytes)
6218210(226 mod 256): CLONE 0x47000 thru 0x49fff	(0x3000 bytes) to 0x22000 thru 0x24fff
6218211(227 mod 256): COPY 0x4376 thru 0x212d7	(0x1cf62 bytes) to 0x404ea thru 0x5d44b
6218212(228 mod 256): PUNCH    0x17869 thru 0x24435	(0xcbcd bytes)
6218213(229 mod 256): CLONE 0x5000 thru 0x7fff	(0x3000 bytes) to 0x63000 thru 0x65fff
6218214(230 mod 256): MAPREAD  0x2f0a5 thru 0x4be0b	(0x1cd67 bytes)
6218215(231 mod 256): TRUNCATE DOWN	from 0x66000 to 0x3e589
6218216(232 mod 256): PUNCH    0x1fa75 thru 0x204d4	(0xa60 bytes)
6218217(233 mod 256): COPY 0x13194 thru 0x2d522	(0x1a38f bytes) to 0x4c288 thru 0x66616
6218218(234 mod 256): MAPREAD  0x1112 thru 0x198c9	(0x187b8 bytes)
6218219(235 mod 256): SKIPPED (no operation)
6218220(236 mod 256): WRITE    0x52cf2 thru 0x5d775	(0xaa84 bytes)
6218221(237 mod 256): SKIPPED (no operation)
6218222(238 mod 256): CLONE 0x29000 thru 0x36fff	(0xe000 bytes) to 0x73000 thru 0x80fff
6218223(239 mod 256): COPY 0xee84 thru 0x239ff	(0x14b7c bytes) to 0x438c4 thru 0x5843f
6218224(240 mod 256): FALLOC   0xe283 thru 0x17729	(0x94a6 bytes) INTERIOR
6218225(241 mod 256): INSERT 0xc000 thru 0x1cfff	(0x11000 bytes)
6218226(242 mod 256): ZERO     0x10d3f thru 0x1d067	(0xc329 bytes)
6218227(243 mod 256): MAPREAD  0xfdd8 thru 0x19c2b	(0x9e54 bytes)
6218228(244 mod 256): TRUNCATE DOWN	from 0x92000 to 0x69b2e	******WWWW
6218229(245 mod 256): READ     0x59f6f thru 0x69b2d	(0xfbbf bytes)
6218230(246 mod 256): DEDUPE 0xb000 thru 0x26fff	(0x1c000 bytes) to 0x44000 thru 0x5ffff
6218231(247 mod 256): PUNCH    0x2b98a thru 0x40060	(0x146d7 bytes)
6218232(248 mod 256): PUNCH    0x3a904 thru 0x3aa6f	(0x16c bytes)
6218233(249 mod 256): MAPWRITE 0x5ce6e thru 0x667b7	(0x994a bytes)
6218234(250 mod 256): READ     0x2ffac thru 0x4d0bb	(0x1d110 bytes)
6218235(251 mod 256): PUNCH    0x69dd thru 0x179f2	(0x11016 bytes)
6218236(252 mod 256): DEDUPE 0x58000 thru 0x68fff	(0x11000 bytes) to 0x1d000 thru 0x2dfff
6218237(253 mod 256): FALLOC   0x69f1c thru 0x70df2	(0x6ed6 bytes) EXTENDING	******FFFF
6218238(254 mod 256): ZERO     0x222d0 thru 0x40d18	(0x1ea49 bytes)
6218239(255 mod 256): DEDUPE 0x3f000 thru 0x47fff	(0x9000 bytes) to 0xf000 thru 0x17fff
6218240(  0 mod 256): WRITE    0x92164 thru 0x927bf	(0x65c bytes) HOLE
6218241(  1 mod 256): ZERO     0x36189 thru 0x4b632	(0x154aa bytes)
6218242(  2 mod 256): DEDUPE 0x38000 thru 0x4afff	(0x13000 bytes) to 0xe000 thru 0x20fff
6218243(  3 mod 256): DEDUPE 0x54000 thru 0x5efff	(0xb000 bytes) to 0x78000 thru 0x82fff
6218244(  4 mod 256): DEDUPE 0x4f000 thru 0x5bfff	(0xd000 bytes) to 0x22000 thru 0x2efff
6218245(  5 mod 256): CLONE 0x0 thru 0xafff	(0xb000 bytes) to 0x4a000 thru 0x54fff
6218246(  6 mod 256): FALLOC   0x37df thru 0x1e19a	(0x1a9bb bytes) INTERIOR
6218247(  7 mod 256): COPY 0x39701 thru 0x431f3	(0x9af3 bytes) to 0x40ee thru 0xdbe0
6218248(  8 mod 256): COPY 0x870b4 thru 0x8bebb	(0x4e08 bytes) to 0x5c02b thru 0x60e32
6218249(  9 mod 256): COLLAPSE 0x34000 thru 0x50fff	(0x1d000 bytes)
6218250( 10 mod 256): READ     0x14622 thru 0x2537b	(0x10d5a bytes)
6218251( 11 mod 256): FALLOC   0x871d1 thru 0x927c0	(0xb5ef bytes) EXTENDING
6218252( 12 mod 256): FALLOC   0x7458a thru 0x90a4f	(0x1c4c5 bytes) INTERIOR
6218253( 13 mod 256): PUNCH    0x45ce9 thru 0x536a3	(0xd9bb bytes)
6218254( 14 mod 256): MAPWRITE 0x898cd thru 0x8ecf8	(0x542c bytes)
6218255( 15 mod 256): SKIPPED (no operation)
6218256( 16 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x3c344	******WWWW
6218257( 17 mod 256): CLONE 0x36000 thru 0x3afff	(0x5000 bytes) to 0x54000 thru 0x58fff
6218258( 18 mod 256): DEDUPE 0x37000 thru 0x50fff	(0x1a000 bytes) to 0x8000 thru 0x21fff
6218259( 19 mod 256): PUNCH    0x51753 thru 0x58fff	(0x78ad bytes)
6218260( 20 mod 256): ZERO     0xec26 thru 0x16cae	(0x8089 bytes)
6218261( 21 mod 256): INSERT 0x4f000 thru 0x5dfff	(0xf000 bytes)
6218262( 22 mod 256): PUNCH    0x34e4 thru 0x21f26	(0x1ea43 bytes)
6218263( 23 mod 256): MAPWRITE 0x5d01c thru 0x70f77	(0x13f5c bytes)	******WWWW
6218264( 24 mod 256): COLLAPSE 0x4b000 thru 0x59fff	(0xf000 bytes)
6218265( 25 mod 256): SKIPPED (no operation)
6218266( 26 mod 256): CLONE 0x4c000 thru 0x60fff	(0x15000 bytes) to 0x11000 thru 0x25fff
6218267( 27 mod 256): TRUNCATE DOWN	from 0x61f78 to 0x8cac
6218268( 28 mod 256): SKIPPED (no operation)
6218269( 29 mod 256): COPY 0x5f7d thru 0x8cab	(0x2d2f bytes) to 0x166a1 thru 0x193cf
6218270( 30 mod 256): FALLOC   0x4328a thru 0x47d7b	(0x4af1 bytes) EXTENDING
6218271( 31 mod 256): WRITE    0x3c4bc thru 0x3cf03	(0xa48 bytes)
6218272( 32 mod 256): FALLOC   0x67273 thru 0x7ef66	(0x17cf3 bytes) PAST_EOF	******FFFF
6218273( 33 mod 256): SKIPPED (no operation)
6218274( 34 mod 256): SKIPPED (no operation)
6218275( 35 mod 256): MAPREAD  0x44018 thru 0x47d7a	(0x3d63 bytes)
6218276( 36 mod 256): FALLOC   0x6ecae thru 0x87603	(0x18955 bytes) EXTENDING	******FFFF
6218277( 37 mod 256): PUNCH    0x5d156 thru 0x68612	(0xb4bd bytes)
6218278( 38 mod 256): WRITE    0x5b8fb thru 0x5ef8f	(0x3695 bytes)
6218279( 39 mod 256): ZERO     0x6ce8c thru 0x7a785	(0xd8fa bytes)	******ZZZZ
6218280( 40 mod 256): FALLOC   0x893f5 thru 0x924ec	(0x90f7 bytes) PAST_EOF
6218281( 41 mod 256): COLLAPSE 0x5000 thru 0x20fff	(0x1c000 bytes)
6218282( 42 mod 256): CLONE 0x1a000 thru 0x23fff	(0xa000 bytes) to 0x58000 thru 0x61fff
6218283( 43 mod 256): MAPREAD  0x53a0b thru 0x6b602	(0x17bf8 bytes)
6218284( 44 mod 256): CLONE 0x4000 thru 0x11fff	(0xe000 bytes) to 0x64000 thru 0x71fff	******JJJJ
6218285( 45 mod 256): DEDUPE 0x64000 thru 0x70fff	(0xd000 bytes) to 0x3b000 thru 0x47fff	BBBB******
6218286( 46 mod 256): PUNCH    0x3da0d thru 0x44436	(0x6a2a bytes)
6218287( 47 mod 256): TRUNCATE DOWN	from 0x72000 to 0x53b27	******WWWW
6218288( 48 mod 256): WRITE    0x6743d thru 0x678eb	(0x4af bytes) HOLE
6218289( 49 mod 256): MAPREAD  0x36d21 thru 0x51375	(0x1a655 bytes)
6218290( 50 mod 256): COPY 0x63224 thru 0x678eb	(0x46c8 bytes) to 0x79e3d thru 0x7e504
6218291( 51 mod 256): COPY 0x72da4 thru 0x7e504	(0xb761 bytes) to 0x5627b thru 0x619db
6218292( 52 mod 256): MAPREAD  0x2cc8b thru 0x3d7ce	(0x10b44 bytes)
6218293( 53 mod 256): MAPWRITE 0x3c876 thru 0x51c12	(0x1539d bytes)
6218294( 54 mod 256): ZERO     0x467bb thru 0x5bc74	(0x154ba bytes)
6218295( 55 mod 256): MAPREAD  0x70268 thru 0x72a6e	(0x2807 bytes)
6218296( 56 mod 256): INSERT 0x6b000 thru 0x70fff	(0x6000 bytes)	******IIII
6218297( 57 mod 256): TRUNCATE DOWN	from 0x84505 to 0x507ef	******WWWW
6218298( 58 mod 256): DEDUPE 0xc000 thru 0xffff	(0x4000 bytes) to 0x18000 thru 0x1bfff
6218299( 59 mod 256): WRITE    0x34bfe thru 0x4857c	(0x1397f bytes)
6218300( 60 mod 256): FALLOC   0x7c4fd thru 0x86647	(0xa14a bytes) PAST_EOF
6218301( 61 mod 256): MAPWRITE 0x6511c thru 0x6714b	(0x2030 bytes)
6218302( 62 mod 256): READ     0xb6dc thru 0x12b40	(0x7465 bytes)
6218303( 63 mod 256): COPY 0x2eb76 thru 0x4b9c2	(0x1ce4d bytes) to 0x76f2 thru 0x2453e
6218304( 64 mod 256): MAPREAD  0x271b6 thru 0x432c2	(0x1c10d bytes)
6218305( 65 mod 256): MAPWRITE 0x59c14 thru 0x72886	(0x18c73 bytes)	******WWWW
6218306( 66 mod 256): ZERO     0x6ac54 thru 0x85503	(0x1a8b0 bytes)	******ZZZZ
6218307( 67 mod 256): CLONE 0x69000 thru 0x6afff	(0x2000 bytes) to 0x3e000 thru 0x3ffff
6218308( 68 mod 256): READ     0x5fcca thru 0x617b1	(0x1ae8 bytes)
6218309( 69 mod 256): SKIPPED (no operation)
6218310( 70 mod 256): PUNCH    0x5ca0c thru 0x72886	(0x15e7b bytes)	******PPPP
6218311( 71 mod 256): PUNCH    0x40deb thru 0x53feb	(0x13201 bytes)
6218312( 72 mod 256): PUNCH    0x3c329 thru 0x3cf7d	(0xc55 bytes)
6218313( 73 mod 256): ZERO     0x1b8b3 thru 0x2d001	(0x1174f bytes)
6218314( 74 mod 256): WRITE    0x67e7b thru 0x793c3	(0x11549 bytes) EXTEND	***WWWW
6218315( 75 mod 256): COPY 0x44b2b thru 0x49090	(0x4566 bytes) to 0x51b31 thru 0x56096
6218316( 76 mod 256): PUNCH    0x5fbb2 thru 0x6f274	(0xf6c3 bytes)	******PPPP
6218317( 77 mod 256): SKIPPED (no operation)
6218318( 78 mod 256): COLLAPSE 0x13000 thru 0x2afff	(0x18000 bytes)
6218319( 79 mod 256): MAPWRITE 0x78384 thru 0x927bf	(0x1a43c bytes)
6218320( 80 mod 256): WRITE    0x5a976 thru 0x6b802	(0x10e8d bytes)
6218321( 81 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x86b69
6218322( 82 mod 256): ZERO     0x1bcfe thru 0x2b72e	(0xfa31 bytes)
6218323( 83 mod 256): MAPWRITE 0x3740a thru 0x55f08	(0x1eaff bytes)
6218324( 84 mod 256): SKIPPED (no operation)
6218325( 85 mod 256): ZERO     0x48ec4 thru 0x59bef	(0x10d2c bytes)
6218326( 86 mod 256): ZERO     0x1c30f thru 0x2de1c	(0x11b0e bytes)
6218327( 87 mod 256): COPY 0x352ee thru 0x48401	(0x13114 bytes) to 0x13e2a thru 0x26f3d
6218328( 88 mod 256): MAPWRITE 0x46bb7 thru 0x58c18	(0x12062 bytes)
6218329( 89 mod 256): ZERO     0x6a39a thru 0x80068	(0x15ccf bytes)	******ZZZZ
6218330( 90 mod 256): COPY 0x3e655 thru 0x46f4f	(0x88fb bytes) to 0x71697 thru 0x79f91
6218331( 91 mod 256): FALLOC   0x487f thru 0x16068	(0x117e9 bytes) INTERIOR
6218332( 92 mod 256): MAPREAD  0x23d6e thru 0x35418	(0x116ab bytes)
6218333( 93 mod 256): CLONE 0x5000 thru 0x5fff	(0x1000 bytes) to 0x2b000 thru 0x2bfff
6218334( 94 mod 256): ZERO     0x6914f thru 0x77f63	(0xee15 bytes)	******ZZZZ
6218335( 95 mod 256): INSERT 0x29000 thru 0x33fff	(0xb000 bytes)
6218336( 96 mod 256): MAPREAD  0x32657 thru 0x33906	(0x12b0 bytes)
6218337( 97 mod 256): MAPREAD  0x1dcf3 thru 0x2a460	(0xc76e bytes)
6218338( 98 mod 256): FALLOC   0x44e51 thru 0x4b632	(0x67e1 bytes) INTERIOR
6218339( 99 mod 256): MAPREAD  0x7b063 thru 0x8eece	(0x13e6c bytes)
6218340(100 mod 256): CLONE 0x44000 thru 0x52fff	(0xf000 bytes) to 0x21000 thru 0x2ffff
6218341(101 mod 256): WRITE    0x74e76 thru 0x8f56d	(0x1a6f8 bytes)
6218342(102 mod 256): TRUNCATE DOWN	from 0x91b69 to 0x6829d	******WWWW
6218343(103 mod 256): DEDUPE 0x54000 thru 0x65fff	(0x12000 bytes) to 0x7000 thru 0x18fff
6218344(104 mod 256): SKIPPED (no operation)
6218345(105 mod 256): TRUNCATE DOWN	from 0x6829d to 0x1b9d0
6218346(106 mod 256): TRUNCATE UP	from 0x1b9d0 to 0x688a0
6218347(107 mod 256): MAPREAD  0x538e5 thru 0x5bd15	(0x8431 bytes)
6218348(108 mod 256): MAPWRITE 0x12e7e thru 0x19cab	(0x6e2e bytes)
6218349(109 mod 256): COLLAPSE 0x42000 thru 0x4bfff	(0xa000 bytes)
6218350(110 mod 256): FALLOC   0xa797 thru 0x29b6f	(0x1f3d8 bytes) INTERIOR
6218351(111 mod 256): READ     0x44ec1 thru 0x5c11a	(0x1725a bytes)
6218352(112 mod 256): MAPREAD  0x2273f thru 0x322b4	(0xfb76 bytes)
6218353(113 mod 256): SKIPPED (no operation)
6218354(114 mod 256): CLONE 0x2f000 thru 0x42fff	(0x14000 bytes) to 0x69000 thru 0x7cfff	******JJJJ
6218355(115 mod 256): COLLAPSE 0x47000 thru 0x47fff	(0x1000 bytes)
6218356(116 mod 256): DEDUPE 0x41000 thru 0x5cfff	(0x1c000 bytes) to 0x1e000 thru 0x39fff
6218357(117 mod 256): PUNCH    0x2c80f thru 0x334c9	(0x6cbb bytes)
6218358(118 mod 256): CLONE 0x58000 thru 0x6cfff	(0x15000 bytes) to 0x2e000 thru 0x42fff
6218359(119 mod 256): PUNCH    0x48c90 thru 0x5aca1	(0x12012 bytes)
6218360(120 mod 256): TRUNCATE DOWN	from 0x7c000 to 0x6159b	******WWWW
6218361(121 mod 256): PUNCH    0x56333 thru 0x6159a	(0xb268 bytes)
6218362(122 mod 256): COPY 0x1564e thru 0x245d9	(0xef8c bytes) to 0x61c29 thru 0x70bb4	******EEEE
6218363(123 mod 256): TRUNCATE DOWN	from 0x70bb5 to 0x65dc1	******WWWW
6218364(124 mod 256): INSERT 0x54000 thru 0x55fff	(0x2000 bytes)
6218365(125 mod 256): COLLAPSE 0x48000 thru 0x62fff	(0x1b000 bytes)
6218366(126 mod 256): MAPREAD  0x2a35d thru 0x45de0	(0x1ba84 bytes)
6218367(127 mod 256): MAPREAD  0x36938 thru 0x4b985	(0x1504e bytes)
6218368(128 mod 256): SKIPPED (no operation)
6218369(129 mod 256): SKIPPED (no operation)
6218370(130 mod 256): TRUNCATE DOWN	from 0x4cdc1 to 0x499e2
6218371(131 mod 256): FALLOC   0x80b7a thru 0x842ec	(0x3772 bytes) PAST_EOF
6218372(132 mod 256): CLONE 0x34000 thru 0x35fff	(0x2000 bytes) to 0x32000 thru 0x33fff
6218373(133 mod 256): CLONE 0x1f000 thru 0x24fff	(0x6000 bytes) to 0x58000 thru 0x5dfff
6218374(134 mod 256): DEDUPE 0x54000 thru 0x56fff	(0x3000 bytes) to 0x4c000 thru 0x4efff
6218375(135 mod 256): READ     0x5bfcd thru 0x5dfff	(0x2033 bytes)
6218376(136 mod 256): TRUNCATE DOWN	from 0x5e000 to 0x5cf95
6218377(137 mod 256): WRITE    0x89aed thru 0x927bf	(0x8cd3 bytes) HOLE	***WWWW
6218378(138 mod 256): MAPREAD  0x7bd4d thru 0x841ba	(0x846e bytes)
6218379(139 mod 256): COPY 0x3d4c1 thru 0x44f23	(0x7a63 bytes) to 0x6694f thru 0x6e3b1
6218380(140 mod 256): COLLAPSE 0x56000 thru 0x6ffff	(0x1a000 bytes)	******CCCC
6218381(141 mod 256): SKIPPED (no operation)
6218382(142 mod 256): FALLOC   0x7de38 thru 0x85473	(0x763b bytes) PAST_EOF
6218383(143 mod 256): MAPWRITE 0x72602 thru 0x7a166	(0x7b65 bytes)
6218384(144 mod 256): ZERO     0x3b172 thru 0x510bb	(0x15f4a bytes)
6218385(145 mod 256): ZERO     0x66eb4 thru 0x79726	(0x12873 bytes)	******ZZZZ
6218386(146 mod 256): COLLAPSE 0x20000 thru 0x20fff	(0x1000 bytes)
6218387(147 mod 256): SKIPPED (no operation)
6218388(148 mod 256): DEDUPE 0x4a000 thru 0x5cfff	(0x13000 bytes) to 0x30000 thru 0x42fff
6218389(149 mod 256): TRUNCATE DOWN	from 0x79167 to 0x18d9d	******WWWW
6218390(150 mod 256): TRUNCATE UP	from 0x18d9d to 0x258b4
6218391(151 mod 256): COPY 0xdc49 thru 0x13d49	(0x6101 bytes) to 0x18b60 thru 0x1ec60
6218392(152 mod 256): TRUNCATE DOWN	from 0x258b4 to 0x3ef5
6218393(153 mod 256): SKIPPED (no operation)
6218394(154 mod 256): FALLOC   0x58a7b thru 0x65412	(0xc997 bytes) EXTENDING
6218395(155 mod 256): ZERO     0x53ca thru 0x1873e	(0x13375 bytes)
6218396(156 mod 256): COLLAPSE 0x37000 thru 0x44fff	(0xe000 bytes)
6218397(157 mod 256): PUNCH    0x60ff thru 0x2449e	(0x1e3a0 bytes)
6218398(158 mod 256): MAPREAD  0x57242 thru 0x57411	(0x1d0 bytes)
6218399(159 mod 256): COPY 0x3c4c5 thru 0x57411	(0x1af4d bytes) to 0x15152 thru 0x3009e
6218400(160 mod 256): CLONE 0x3d000 thru 0x40fff	(0x4000 bytes) to 0x2d000 thru 0x30fff
6218401(161 mod 256): INSERT 0x39000 thru 0x52fff	(0x1a000 bytes)
6218402(162 mod 256): PUNCH    0x4ccf5 thru 0x5812a	(0xb436 bytes)
6218403(163 mod 256): SKIPPED (no operation)
6218404(164 mod 256): CLONE 0x64000 thru 0x6dfff	(0xa000 bytes) to 0x72000 thru 0x7bfff
6218405(165 mod 256): INSERT 0x36000 thru 0x4afff	(0x15000 bytes)
6218406(166 mod 256): FALLOC   0x33b42 thru 0x4b8fb	(0x17db9 bytes) INTERIOR
6218407(167 mod 256): FALLOC   0x2bbaa thru 0x4092c	(0x14d82 bytes) INTERIOR
6218408(168 mod 256): INSERT 0x6e000 thru 0x6efff	(0x1000 bytes)	******IIII
6218409(169 mod 256): SKIPPED (no operation)
6218410(170 mod 256): DEDUPE 0x57000 thru 0x68fff	(0x12000 bytes) to 0x6d000 thru 0x7efff	******BBBB
6218411(171 mod 256): TRUNCATE DOWN	from 0x92000 to 0x1dc95	******WWWW
6218412(172 mod 256): MAPREAD  0x189f7 thru 0x1dc94	(0x529e bytes)
6218413(173 mod 256): TRUNCATE UP	from 0x1dc95 to 0x83310	******WWWW
6218414(174 mod 256): ZERO     0x4d9ef thru 0x5037e	(0x2990 bytes)
6218415(175 mod 256): READ     0x3fdb4 thru 0x44764	(0x49b1 bytes)
6218416(176 mod 256): TRUNCATE DOWN	from 0x83310 to 0x39bb4	******WWWW
6218417(177 mod 256): COPY 0xb09d thru 0xde60	(0x2dc4 bytes) to 0x1bd9a thru 0x1eb5d
6218418(178 mod 256): MAPWRITE 0x2afd2 thru 0x2f66c	(0x469b bytes)
6218419(179 mod 256): CLONE 0x2e000 thru 0x38fff	(0xb000 bytes) to 0x18000 thru 0x22fff
6218420(180 mod 256): ZERO     0x4a66 thru 0xd64e	(0x8be9 bytes)
6218421(181 mod 256): INSERT 0x6000 thru 0x14fff	(0xf000 bytes)
6218422(182 mod 256): READ     0x19f7e thru 0x35f92	(0x1c015 bytes)
6218423(183 mod 256): READ     0x44eb1 thru 0x48bb3	(0x3d03 bytes)
6218424(184 mod 256): ZERO     0x44ee7 thru 0x50360	(0xb47a bytes)
6218425(185 mod 256): FALLOC   0x5d770 thru 0x6521b	(0x7aab bytes) EXTENDING
6218426(186 mod 256): COLLAPSE 0x4d000 thru 0x50fff	(0x4000 bytes)
6218427(187 mod 256): DEDUPE 0x29000 thru 0x2afff	(0x2000 bytes) to 0x10000 thru 0x11fff
6218428(188 mod 256): CLONE 0x11000 thru 0x2afff	(0x1a000 bytes) to 0x74000 thru 0x8dfff
6218429(189 mod 256): TRUNCATE DOWN	from 0x8e000 to 0x5fc32	******WWWW
6218430(190 mod 256): MAPREAD  0xd085 thru 0x27f2d	(0x1aea9 bytes)
6218431(191 mod 256): DEDUPE 0x11000 thru 0x2efff	(0x1e000 bytes) to 0x3f000 thru 0x5cfff
6218432(192 mod 256): FALLOC   0x76b6 thru 0x15679	(0xdfc3 bytes) INTERIOR
6218433(193 mod 256): COLLAPSE 0x9000 thru 0x1ffff	(0x17000 bytes)
6218434(194 mod 256): WRITE    0x49dce thru 0x5ce18	(0x1304b bytes) HOLE
6218435(195 mod 256): MAPREAD  0x2c60d thru 0x36b68	(0xa55c bytes)
6218436(196 mod 256): COLLAPSE 0x25000 thru 0x30fff	(0xc000 bytes)
6218437(197 mod 256): INSERT 0x1c000 thru 0x39fff	(0x1e000 bytes)
6218438(198 mod 256): SKIPPED (no operation)
6218439(199 mod 256): COPY 0x4dd70 thru 0x63d6a	(0x15ffb bytes) to 0x22c34 thru 0x38c2e
6218440(200 mod 256): MAPREAD  0x63f93 thru 0x6ee18	(0xae86 bytes)
6218441(201 mod 256): COPY 0x5595a thru 0x65542	(0xfbe9 bytes) to 0x2a4b6 thru 0x3a09e
6218442(202 mod 256): ZERO     0x104d2 thru 0x2e330	(0x1de5f bytes)
6218443(203 mod 256): CLONE 0x2b000 thru 0x44fff	(0x1a000 bytes) to 0x3000 thru 0x1cfff
6218444(204 mod 256): DEDUPE 0x2a000 thru 0x2afff	(0x1000 bytes) to 0x1f000 thru 0x1ffff
6218445(205 mod 256): CLONE 0x32000 thru 0x3afff	(0x9000 bytes) to 0x54000 thru 0x5cfff
6218446(206 mod 256): MAPREAD  0x17ad4 thru 0x2b048	(0x13575 bytes)
6218447(207 mod 256): DEDUPE 0x0 thru 0x1cfff	(0x1d000 bytes) to 0x30000 thru 0x4cfff
6218448(208 mod 256): READ     0xb6b8 thru 0x1e1fa	(0x12b43 bytes)
6218449(209 mod 256): WRITE    0x44674 thru 0x5895a	(0x142e7 bytes)
6218450(210 mod 256): PUNCH    0x6d7c0 thru 0x6ee18	(0x1659 bytes)
6218451(211 mod 256): SKIPPED (no operation)
6218452(212 mod 256): FALLOC   0x28fc7 thru 0x3414c	(0xb185 bytes) INTERIOR
6218453(213 mod 256): COLLAPSE 0x6000 thru 0x11fff	(0xc000 bytes)
6218454(214 mod 256): DEDUPE 0x37000 thru 0x3cfff	(0x6000 bytes) to 0x4f000 thru 0x54fff
6218455(215 mod 256): MAPWRITE 0x91ea7 thru 0x927bf	(0x919 bytes)
6218456(216 mod 256): COPY 0x1279 thru 0x3d4c	(0x2ad4 bytes) to 0x1a7c1 thru 0x1d294
6218457(217 mod 256): WRITE    0x86193 thru 0x927bf	(0xc62d bytes)
6218458(218 mod 256): COLLAPSE 0x80000 thru 0x90fff	(0x11000 bytes)
6218459(219 mod 256): INSERT 0x31000 thru 0x3efff	(0xe000 bytes)
6218460(220 mod 256): READ     0x64688 thru 0x6b04e	(0x69c7 bytes)
6218461(221 mod 256): MAPREAD  0x1c479 thru 0x3adfc	(0x1e984 bytes)
6218462(222 mod 256): FALLOC   0x1720a thru 0x294f4	(0x122ea bytes) INTERIOR
6218463(223 mod 256): COPY 0x86f17 thru 0x8f7bf	(0x88a9 bytes) to 0x260e8 thru 0x2e990
6218464(224 mod 256): COPY 0x57782 thru 0x6581a	(0xe099 bytes) to 0x475a5 thru 0x5563d
6218465(225 mod 256): PUNCH    0x19801 thru 0x29d77	(0x10577 bytes)
6218466(226 mod 256): DEDUPE 0xe000 thru 0x2afff	(0x1d000 bytes) to 0x69000 thru 0x85fff	******BBBB
6218467(227 mod 256): CLONE 0x66000 thru 0x7cfff	(0x17000 bytes) to 0x27000 thru 0x3dfff	JJJJ******
6218468(228 mod 256): TRUNCATE DOWN	from 0x8f7c0 to 0x7012d
6218469(229 mod 256): TRUNCATE DOWN	from 0x7012d to 0x563f2	******WWWW
6218470(230 mod 256): TRUNCATE DOWN	from 0x563f2 to 0x512c9
6218471(231 mod 256): MAPREAD  0x1b41f thru 0x1f189	(0x3d6b bytes)
6218472(232 mod 256): COPY 0x3cc6d thru 0x42f46	(0x62da bytes) to 0x5acd2 thru 0x60fab
6218473(233 mod 256): COLLAPSE 0x23000 thru 0x35fff	(0x13000 bytes)
6218474(234 mod 256): COPY 0x29f57 thru 0x472b3	(0x1d35d bytes) to 0x9687 thru 0x269e3
6218475(235 mod 256): CLONE 0x2c000 thru 0x3cfff	(0x11000 bytes) to 0xa000 thru 0x1afff
6218476(236 mod 256): INSERT 0x3c000 thru 0x43fff	(0x8000 bytes)
6218477(237 mod 256): MAPWRITE 0xafd0 thru 0x1f41e	(0x1444f bytes)
6218478(238 mod 256): SKIPPED (no operation)
6218479(239 mod 256): COLLAPSE 0x8000 thru 0x1bfff	(0x14000 bytes)
6218480(240 mod 256): SKIPPED (no operation)
6218481(241 mod 256): MAPREAD  0x2d89f thru 0x3d268	(0xf9ca bytes)
6218482(242 mod 256): MAPREAD  0x41c29 thru 0x41fab	(0x383 bytes)
6218483(243 mod 256): TRUNCATE DOWN	from 0x41fac to 0x2c82f
6218484(244 mod 256): MAPREAD  0x134ce thru 0x2c82e	(0x19361 bytes)
6218485(245 mod 256): PUNCH    0x17769 thru 0x2c82e	(0x150c6 bytes)
6218486(246 mod 256): INSERT 0x27000 thru 0x3ffff	(0x19000 bytes)
6218487(247 mod 256): INSERT 0x2b000 thru 0x3afff	(0x10000 bytes)
6218488(248 mod 256): WRITE    0x9290 thru 0x15c0a	(0xc97b bytes)
6218489(249 mod 256): COPY 0x22297 thru 0x384ea	(0x16254 bytes) to 0x547a6 thru 0x6a9f9
6218490(250 mod 256): COLLAPSE 0x32000 thru 0x3bfff	(0xa000 bytes)
6218491(251 mod 256): SKIPPED (no operation)
6218492(252 mod 256): PUNCH    0xa66d thru 0xbed0	(0x1864 bytes)
6218493(253 mod 256): DEDUPE 0x5b000 thru 0x5ffff	(0x5000 bytes) to 0x23000 thru 0x27fff
6218494(254 mod 256): MAPREAD  0x39836 thru 0x4f426	(0x15bf1 bytes)
6218495(255 mod 256): WRITE    0x5fe47 thru 0x662f8	(0x64b2 bytes) EXTEND
6218496(  0 mod 256): MAPREAD  0x2a89f thru 0x375d5	(0xcd37 bytes)
6218497(  1 mod 256): CLONE 0xc000 thru 0x17fff	(0xc000 bytes) to 0x35000 thru 0x40fff
6218498(  2 mod 256): SKIPPED (no operation)
6218499(  3 mod 256): COLLAPSE 0xd000 thru 0x14fff	(0x8000 bytes)
6218500(  4 mod 256): FALLOC   0x3d07e thru 0x565e5	(0x19567 bytes) INTERIOR
6218501(  5 mod 256): SKIPPED (no operation)
6218502(  6 mod 256): CLONE 0x21000 thru 0x30fff	(0x10000 bytes) to 0x3e000 thru 0x4dfff
6218503(  7 mod 256): COPY 0x28c39 thru 0x2c053	(0x341b bytes) to 0x389cb thru 0x3bde5
6218504(  8 mod 256): MAPREAD  0x222bf thru 0x3177b	(0xf4bd bytes)
6218505(  9 mod 256): DEDUPE 0x3a000 thru 0x44fff	(0xb000 bytes) to 0xe000 thru 0x18fff
6218506( 10 mod 256): READ     0x174a7 thru 0x215cb	(0xa125 bytes)
6218507( 11 mod 256): READ     0x22a85 thru 0x2c6f0	(0x9c6c bytes)
6218508( 12 mod 256): READ     0x5b2c7 thru 0x5e2f8	(0x3032 bytes)
6218509( 13 mod 256): WRITE    0x51aaa thru 0x64ccb	(0x13222 bytes) EXTEND
6218510( 14 mod 256): INSERT 0x25000 thru 0x3bfff	(0x17000 bytes)
6218511( 15 mod 256): MAPREAD  0xf717 thru 0x2947a	(0x19d64 bytes)
6218512( 16 mod 256): SKIPPED (no operation)
6218513( 17 mod 256): CLONE 0x1e000 thru 0x36fff	(0x19000 bytes) to 0x46000 thru 0x5efff
6218514( 18 mod 256): WRITE    0x30b86 thru 0x45237	(0x146b2 bytes)
6218515( 19 mod 256): TRUNCATE DOWN	from 0x7bccc to 0x66b91	******WWWW
6218516( 20 mod 256): COLLAPSE 0x54000 thru 0x65fff	(0x12000 bytes)
6218517( 21 mod 256): MAPREAD  0x4f684 thru 0x54b90	(0x550d bytes)
6218518( 22 mod 256): MAPREAD  0x19849 thru 0x22942	(0x90fa bytes)
6218519( 23 mod 256): TRUNCATE DOWN	from 0x54b91 to 0x2e96b
6218520( 24 mod 256): CLONE 0x7000 thru 0xbfff	(0x5000 bytes) to 0x11000 thru 0x15fff
6218521( 25 mod 256): WRITE    0x38d94 thru 0x42371	(0x95de bytes) HOLE
6218522( 26 mod 256): READ     0x2b614 thru 0x40f53	(0x15940 bytes)
6218523( 27 mod 256): INSERT 0x21000 thru 0x25fff	(0x5000 bytes)
6218524( 28 mod 256): ZERO     0x152b8 thru 0x32ee8	(0x1dc31 bytes)
6218525( 29 mod 256): INSERT 0x45000 thru 0x45fff	(0x1000 bytes)
6218526( 30 mod 256): MAPREAD  0xc9a thru 0x9d76	(0x90dd bytes)
6218527( 31 mod 256): TRUNCATE UP	from 0x48372 to 0x5b865
6218528( 32 mod 256): CLONE 0x2d000 thru 0x33fff	(0x7000 bytes) to 0x5a000 thru 0x60fff
6218529( 33 mod 256): MAPWRITE 0x8326d thru 0x927bf	(0xf553 bytes)
6218530( 34 mod 256): ZERO     0x2c64 thru 0x1572b	(0x12ac8 bytes)
6218531( 35 mod 256): MAPREAD  0x67e20 thru 0x68bb1	(0xd92 bytes)
6218532( 36 mod 256): SKIPPED (no operation)
6218533( 37 mod 256): SKIPPED (no operation)
6218534( 38 mod 256): PUNCH    0x88b3a thru 0x927bf	(0x9c86 bytes)
6218535( 39 mod 256): COLLAPSE 0x7b000 thru 0x82fff	(0x8000 bytes)
6218536( 40 mod 256): INSERT 0x6c000 thru 0x72fff	(0x7000 bytes)	******IIII
6218537( 41 mod 256): MAPWRITE 0x13b29 thru 0x27939	(0x13e11 bytes)
6218538( 42 mod 256): READ     0x602ea thru 0x6d741	(0xd458 bytes)
6218539( 43 mod 256): PUNCH    0x6b1c9 thru 0x6c350	(0x1188 bytes)
6218540( 44 mod 256): MAPREAD  0x6a3df thru 0x88684	(0x1e2a6 bytes)	***RRRR***
6218541( 45 mod 256): CLONE 0xa000 thru 0xdfff	(0x4000 bytes) to 0x28000 thru 0x2bfff
6218542( 46 mod 256): CLONE 0x8e000 thru 0x8ffff	(0x2000 bytes) to 0x4d000 thru 0x4efff
6218543( 47 mod 256): WRITE    0x6548e thru 0x6ada2	(0x5915 bytes)
6218544( 48 mod 256): COPY 0xe143 thru 0x18c31	(0xaaef bytes) to 0x4029e thru 0x4ad8c
6218545( 49 mod 256): SKIPPED (no operation)
6218546( 50 mod 256): SKIPPED (no operation)
6218547( 51 mod 256): MAPWRITE 0x10425 thru 0x2be5a	(0x1ba36 bytes)
6218548( 52 mod 256): DEDUPE 0x88000 thru 0x90fff	(0x9000 bytes) to 0x13000 thru 0x1bfff
6218549( 53 mod 256): INSERT 0x6b000 thru 0x6bfff	(0x1000 bytes)
6218550( 54 mod 256): FALLOC   0x66e64 thru 0x7fd89	(0x18f25 bytes) INTERIOR	******FFFF
6218551( 55 mod 256): DEDUPE 0x22000 thru 0x26fff	(0x5000 bytes) to 0x53000 thru 0x57fff
6218552( 56 mod 256): MAPREAD  0x76835 thru 0x7ca05	(0x61d1 bytes)
6218553( 57 mod 256): DEDUPE 0x8a000 thru 0x90fff	(0x7000 bytes) to 0x34000 thru 0x3afff
6218554( 58 mod 256): COPY 0x75abb thru 0x7bc30	(0x6176 bytes) to 0xd4ad thru 0x13622
6218555( 59 mod 256): COLLAPSE 0x52000 thru 0x6ffff	(0x1e000 bytes)	******CCCC
6218556( 60 mod 256): FALLOC   0x32ec2 thru 0x4d53f	(0x1a67d bytes) INTERIOR
6218557( 61 mod 256): FALLOC   0x41c59 thru 0x49015	(0x73bc bytes) INTERIOR
6218558( 62 mod 256): READ     0xf3dd thru 0x1768b	(0x82af bytes)
6218559( 63 mod 256): READ     0x58f00 thru 0x747bf	(0x1b8c0 bytes)	***RRRR***
6218560( 64 mod 256): CLONE 0x4a000 thru 0x54fff	(0xb000 bytes) to 0x73000 thru 0x7dfff
6218561( 65 mod 256): READ     0x7c04b thru 0x7dfff	(0x1fb5 bytes)
6218562( 66 mod 256): SKIPPED (no operation)
6218563( 67 mod 256): READ     0x77294 thru 0x78411	(0x117e bytes)
6218564( 68 mod 256): TRUNCATE DOWN	from 0x7e000 to 0x106cc	******WWWW
6218565( 69 mod 256): CLONE 0x1000 thru 0xffff	(0xf000 bytes) to 0x1c000 thru 0x2afff
6218566( 70 mod 256): CLONE 0x14000 thru 0x16fff	(0x3000 bytes) to 0xd000 thru 0xffff
6218567( 71 mod 256): COPY 0x1ec2d thru 0x1eee4	(0x2b8 bytes) to 0x9093e thru 0x90bf5
6218568( 72 mod 256): FALLOC   0x10ce6 thru 0x20d3c	(0x10056 bytes) INTERIOR
6218569( 73 mod 256): WRITE    0x48c34 thru 0x5b32f	(0x126fc bytes)
6218570( 74 mod 256): MAPWRITE 0x518fb thru 0x6b233	(0x19939 bytes)
6218571( 75 mod 256): MAPWRITE 0x7d47b thru 0x8a03d	(0xcbc3 bytes)
6218572( 76 mod 256): COPY 0x6e096 thru 0x86ebe	(0x18e29 bytes) to 0x16a09 thru 0x2f831	EEEE******
6218573( 77 mod 256): CLONE 0x36000 thru 0x37fff	(0x2000 bytes) to 0x4d000 thru 0x4efff
6218574( 78 mod 256): MAPWRITE 0x8bcfc thru 0x927bf	(0x6ac4 bytes)
6218575( 79 mod 256): MAPWRITE 0x8a1b0 thru 0x927bf	(0x8610 bytes)
6218576( 80 mod 256): DEDUPE 0x1e000 thru 0x26fff	(0x9000 bytes) to 0x30000 thru 0x38fff
6218577( 81 mod 256): WRITE    0x14c7 thru 0x191a	(0x454 bytes)
6218578( 82 mod 256): DEDUPE 0x80000 thru 0x86fff	(0x7000 bytes) to 0x34000 thru 0x3afff
6218579( 83 mod 256): MAPREAD  0x5d482 thru 0x76298	(0x18e17 bytes)	***RRRR***
6218580( 84 mod 256): MAPREAD  0x5c358 thru 0x648ee	(0x8597 bytes)
6218581( 85 mod 256): PUNCH    0x52223 thru 0x53fcc	(0x1daa bytes)
6218582( 86 mod 256): DEDUPE 0x7e000 thru 0x90fff	(0x13000 bytes) to 0x45000 thru 0x57fff
6218583( 87 mod 256): ZERO     0x48d2c thru 0x57932	(0xec07 bytes)
6218584( 88 mod 256): SKIPPED (no operation)
6218585( 89 mod 256): COPY 0x4ec04 thru 0x549fd	(0x5dfa bytes) to 0x41112 thru 0x46f0b
6218586( 90 mod 256): MAPREAD  0x50958 thru 0x64da5	(0x1444e bytes)
6218587( 91 mod 256): COPY 0x3f755 thru 0x5080a	(0x110b6 bytes) to 0x66c99 thru 0x77d4e	******EEEE
6218588( 92 mod 256): FALLOC   0x3203e thru 0x4b4dc	(0x1949e bytes) INTERIOR
6218589( 93 mod 256): SKIPPED (no operation)
6218590( 94 mod 256): FALLOC   0x18ff2 thru 0x20536	(0x7544 bytes) INTERIOR
6218591( 95 mod 256): DEDUPE 0x58000 thru 0x75fff	(0x1e000 bytes) to 0x9000 thru 0x26fff	BBBB******
6218592( 96 mod 256): DEDUPE 0x81000 thru 0x89fff	(0x9000 bytes) to 0x4c000 thru 0x54fff
6218593( 97 mod 256): READ     0xe064 thru 0x133af	(0x534c bytes)
6218594( 98 mod 256): SKIPPED (no operation)
6218595( 99 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x83a75
6218596(100 mod 256): CLONE 0x43000 thru 0x55fff	(0x13000 bytes) to 0x2a000 thru 0x3cfff
6218597(101 mod 256): TRUNCATE DOWN	from 0x83a75 to 0x7e10	******WWWW
6218598(102 mod 256): PUNCH    0x6e49 thru 0x7e0f	(0xfc7 bytes)
6218599(103 mod 256): FALLOC   0x7d85a thru 0x927c0	(0x14f66 bytes) EXTENDING
6218600(104 mod 256): WRITE    0x70acf thru 0x8505e	(0x14590 bytes)
6218601(105 mod 256): MAPWRITE 0x516c3 thru 0x5a5ff	(0x8f3d bytes)
6218602(106 mod 256): MAPWRITE 0x3492a thru 0x47544	(0x12c1b bytes)
6218603(107 mod 256): SKIPPED (no operation)
6218604(108 mod 256): ZERO     0x79755 thru 0x8be44	(0x126f0 bytes)
6218605(109 mod 256): PUNCH    0x35315 thru 0x39b38	(0x4824 bytes)
6218606(110 mod 256): COLLAPSE 0x21000 thru 0x3efff	(0x1e000 bytes)
6218607(111 mod 256): COLLAPSE 0x28000 thru 0x39fff	(0x12000 bytes)
6218608(112 mod 256): FALLOC   0x1cc12 thru 0x27f67	(0xb355 bytes) INTERIOR
6218609(113 mod 256): CLONE 0x3c000 thru 0x44fff	(0x9000 bytes) to 0x63000 thru 0x6bfff
6218610(114 mod 256): PUNCH    0x10e71 thru 0x14ea5	(0x4035 bytes)
6218611(115 mod 256): WRITE    0x30303 thru 0x3065b	(0x359 bytes)
6218612(116 mod 256): MAPWRITE 0x3c7d1 thru 0x3f137	(0x2967 bytes)
6218613(117 mod 256): ZERO     0x5ca7f thru 0x64d64	(0x82e6 bytes)
6218614(118 mod 256): PUNCH    0x6a6e5 thru 0x6bfff	(0x191b bytes)
6218615(119 mod 256): INSERT 0x5f000 thru 0x7bfff	(0x1d000 bytes)	******IIII
6218616(120 mod 256): SKIPPED (no operation)
6218617(121 mod 256): TRUNCATE DOWN	from 0x89000 to 0x534aa	******WWWW
6218618(122 mod 256): COPY 0x4781e thru 0x51c0e	(0xa3f1 bytes) to 0x1cdf thru 0xc0cf
6218619(123 mod 256): DEDUPE 0x0 thru 0x1bfff	(0x1c000 bytes) to 0x24000 thru 0x3ffff
6218620(124 mod 256): COPY 0x2531d thru 0x40c0b	(0x1b8ef bytes) to 0x61c thru 0x1bf0a
6218621(125 mod 256): FALLOC   0x8d72 thru 0x1b425	(0x126b3 bytes) INTERIOR
6218622(126 mod 256): CLONE 0x8000 thru 0x8fff	(0x1000 bytes) to 0x7b000 thru 0x7bfff
6218623(127 mod 256): FALLOC   0x3b0b6 thru 0x3dfde	(0x2f28 bytes) INTERIOR
6218624(128 mod 256): MAPREAD  0x1bc4c thru 0x35cbd	(0x1a072 bytes)
6218625(129 mod 256): DEDUPE 0xc000 thru 0x1afff	(0xf000 bytes) to 0x2b000 thru 0x39fff
6218626(130 mod 256): SKIPPED (no operation)
6218627(131 mod 256): COPY 0x2b371 thru 0x45374	(0x1a004 bytes) to 0x5bf11 thru 0x75f14	******EEEE
6218628(132 mod 256): SKIPPED (no operation)
6218629(133 mod 256): COPY 0x3a926 thru 0x3b77a	(0xe55 bytes) to 0x42f0 thru 0x5144
6218630(134 mod 256): SKIPPED (no operation)
6218631(135 mod 256): COPY 0x356c6 thru 0x4cbeb	(0x17526 bytes) to 0x11622 thru 0x28b47
6218632(136 mod 256): SKIPPED (no operation)
6218633(137 mod 256): TRUNCATE DOWN	from 0x7c000 to 0x557df	******WWWW
6218634(138 mod 256): DEDUPE 0x15000 thru 0x1efff	(0xa000 bytes) to 0x6000 thru 0xffff
6218635(139 mod 256): READ     0x3c0be thru 0x43281	(0x71c4 bytes)
6218636(140 mod 256): ZERO     0x20cd4 thru 0x290dd	(0x840a bytes)
6218637(141 mod 256): TRUNCATE UP	from 0x557df to 0x7ff28	******WWWW
6218638(142 mod 256): COLLAPSE 0x52000 thru 0x52fff	(0x1000 bytes)
6218639(143 mod 256): ZERO     0x7ed1d thru 0x918d3	(0x12bb7 bytes)
6218640(144 mod 256): TRUNCATE DOWN	from 0x918d4 to 0x6ce7d	******WWWW
6218641(145 mod 256): DEDUPE 0x3c000 thru 0x4efff	(0x13000 bytes) to 0x51000 thru 0x63fff
6218642(146 mod 256): PUNCH    0x5eee2 thru 0x62f44	(0x4063 bytes)
6218643(147 mod 256): TRUNCATE DOWN	from 0x6ce7d to 0x255c7
6218644(148 mod 256): INSERT 0x13000 thru 0x26fff	(0x14000 bytes)
6218645(149 mod 256): PUNCH    0x12766 thru 0x2143c	(0xecd7 bytes)
6218646(150 mod 256): DEDUPE 0x1000 thru 0x18fff	(0x18000 bytes) to 0x1c000 thru 0x33fff
6218647(151 mod 256): COLLAPSE 0x34000 thru 0x37fff	(0x4000 bytes)
6218648(152 mod 256): TRUNCATE UP	from 0x355c7 to 0x54ef5
6218649(153 mod 256): COPY 0x124e3 thru 0x13f7e	(0x1a9c bytes) to 0x22ac3 thru 0x2455e
6218650(154 mod 256): INSERT 0x26000 thru 0x3efff	(0x19000 bytes)
6218651(155 mod 256): CLONE 0x17000 thru 0x33fff	(0x1d000 bytes) to 0x35000 thru 0x51fff
6218652(156 mod 256): INSERT 0x3a000 thru 0x4afff	(0x11000 bytes)
6218653(157 mod 256): DEDUPE 0xc000 thru 0x21fff	(0x16000 bytes) to 0x2e000 thru 0x43fff
6218654(158 mod 256): TRUNCATE DOWN	from 0x7eef5 to 0x65e46	******WWWW
6218655(159 mod 256): COPY 0x927c thru 0x16b1b	(0xd8a0 bytes) to 0x6bc2f thru 0x794ce	******EEEE
6218656(160 mod 256): CLONE 0x43000 thru 0x5afff	(0x18000 bytes) to 0x68000 thru 0x7ffff	******JJJJ
6218657(161 mod 256): WRITE    0x8eac7 thru 0x927bf	(0x3cf9 bytes) HOLE
6218658(162 mod 256): READ     0x246f1 thru 0x27da5	(0x36b5 bytes)
6218659(163 mod 256): DEDUPE 0x47000 thru 0x48fff	(0x2000 bytes) to 0x44000 thru 0x45fff
6218660(164 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5266f	******WWWW
6218661(165 mod 256): MAPWRITE 0x31810 thru 0x4ab73	(0x19364 bytes)
6218662(166 mod 256): MAPWRITE 0x1419f thru 0x157cf	(0x1631 bytes)
6218663(167 mod 256): WRITE    0x6e995 thru 0x76fb9	(0x8625 bytes) HOLE	***WWWW
6218664(168 mod 256): FALLOC   0x18778 thru 0x35255	(0x1cadd bytes) INTERIOR
6218665(169 mod 256): PUNCH    0x4beb2 thru 0x63861	(0x179b0 bytes)
6218666(170 mod 256): SKIPPED (no operation)
6218667(171 mod 256): MAPWRITE 0x4a8ba thru 0x4b8c0	(0x1007 bytes)
6218668(172 mod 256): READ     0x5ee5c thru 0x6b6bf	(0xc864 bytes)
6218669(173 mod 256): COPY 0xf898 thru 0x2005c	(0x107c5 bytes) to 0x4952c thru 0x59cf0
6218670(174 mod 256): ZERO     0x51b4a thru 0x665e0	(0x14a97 bytes)
6218671(175 mod 256): FALLOC   0x4ddda thru 0x63159	(0x1537f bytes) INTERIOR
6218672(176 mod 256): COLLAPSE 0x61000 thru 0x6dfff	(0xd000 bytes)
6218673(177 mod 256): MAPREAD  0x60c91 thru 0x62381	(0x16f1 bytes)
6218674(178 mod 256): READ     0xba55 thru 0x201e7	(0x14793 bytes)
6218675(179 mod 256): CLONE 0x67000 thru 0x68fff	(0x2000 bytes) to 0x5f000 thru 0x60fff
6218676(180 mod 256): CLONE 0x44000 thru 0x52fff	(0xf000 bytes) to 0x26000 thru 0x34fff
6218677(181 mod 256): MAPWRITE 0x71c5c thru 0x8fb91	(0x1df36 bytes)
6218678(182 mod 256): PUNCH    0x5552f thru 0x6e2f2	(0x18dc4 bytes)
6218679(183 mod 256): MAPREAD  0x8379e thru 0x88aad	(0x5310 bytes)
6218680(184 mod 256): ZERO     0x8b55b thru 0x927bf	(0x7265 bytes)
6218681(185 mod 256): COPY 0x8b7da thru 0x8fb91	(0x43b8 bytes) to 0x177dc thru 0x1bb93
6218682(186 mod 256): INSERT 0x38000 thru 0x39fff	(0x2000 bytes)
6218683(187 mod 256): ZERO     0xe0bf thru 0x1a3d0	(0xc312 bytes)
6218684(188 mod 256): READ     0x5c2a7 thru 0x657da	(0x9534 bytes)
6218685(189 mod 256): TRUNCATE DOWN	from 0x91b92 to 0x4aa2	******WWWW
6218686(190 mod 256): DEDUPE 0x3000 thru 0x3fff	(0x1000 bytes) to 0x0 thru 0xfff
6218687(191 mod 256): COLLAPSE 0x0 thru 0x2fff	(0x3000 bytes)
6218688(192 mod 256): SKIPPED (no operation)
6218689(193 mod 256): MAPREAD  0x73e thru 0x1aa1	(0x1364 bytes)
6218690(194 mod 256): SKIPPED (no operation)
6218691(195 mod 256): PUNCH    0x354 thru 0x1aa1	(0x174e bytes)
6218692(196 mod 256): PUNCH    0x1579 thru 0x1aa1	(0x529 bytes)
6218693(197 mod 256): PUNCH    0x4a8 thru 0x1aa1	(0x15fa bytes)
6218694(198 mod 256): INSERT 0x0 thru 0x15fff	(0x16000 bytes)
6218695(199 mod 256): ZERO     0x56ff0 thru 0x5949d	(0x24ae bytes)
6218696(200 mod 256): FALLOC   0x8db53 thru 0x927c0	(0x4c6d bytes) EXTENDING
6218697(201 mod 256): COLLAPSE 0xa000 thru 0x13fff	(0xa000 bytes)
6218698(202 mod 256): COLLAPSE 0x49000 thru 0x4efff	(0x6000 bytes)
6218699(203 mod 256): TRUNCATE DOWN	from 0x827c0 to 0x6e86f	******WWWW
6218700(204 mod 256): PUNCH    0x15c75 thru 0x174a5	(0x1831 bytes)
6218701(205 mod 256): COPY 0x686cd thru 0x6e86e	(0x61a2 bytes) to 0x2e6e8 thru 0x34889
6218702(206 mod 256): CLONE 0x53000 thru 0x5cfff	(0xa000 bytes) to 0x6e000 thru 0x77fff	******JJJJ
6218703(207 mod 256): TRUNCATE DOWN	from 0x78000 to 0x36c66	******WWWW
6218704(208 mod 256): INSERT 0x29000 thru 0x44fff	(0x1c000 bytes)
6218705(209 mod 256): CLONE 0xf000 thru 0x27fff	(0x19000 bytes) to 0x6b000 thru 0x83fff	******JJJJ
6218706(210 mod 256): DEDUPE 0x64000 thru 0x67fff	(0x4000 bytes) to 0x52000 thru 0x55fff
6218707(211 mod 256): TRUNCATE DOWN	from 0x84000 to 0x34c8a	******WWWW
6218708(212 mod 256): COPY 0x11c25 thru 0x2a0a2	(0x1847e bytes) to 0x2be90 thru 0x4430d
6218709(213 mod 256): INSERT 0x43000 thru 0x48fff	(0x6000 bytes)
6218710(214 mod 256): MAPWRITE 0x7942 thru 0x19aba	(0x12179 bytes)
6218711(215 mod 256): FALLOC   0x48699 thru 0x5db10	(0x15477 bytes) PAST_EOF
6218712(216 mod 256): COPY 0x2a9ed thru 0x389ea	(0xdffe bytes) to 0x18ba4 thru 0x26ba1
6218713(217 mod 256): CLONE 0x15000 thru 0x20fff	(0xc000 bytes) to 0x2a000 thru 0x35fff
6218714(218 mod 256): CLONE 0x15000 thru 0x29fff	(0x15000 bytes) to 0x69000 thru 0x7dfff	******JJJJ
6218715(219 mod 256): COLLAPSE 0x35000 thru 0x3bfff	(0x7000 bytes)
6218716(220 mod 256): ZERO     0x522e2 thru 0x6d2e1	(0x1b000 bytes)
6218717(221 mod 256): DEDUPE 0x2d000 thru 0x49fff	(0x1d000 bytes) to 0x7000 thru 0x23fff
6218718(222 mod 256): TRUNCATE DOWN	from 0x77000 to 0x1cb56	******WWWW
6218719(223 mod 256): TRUNCATE UP	from 0x1cb56 to 0x7243d	******WWWW
6218720(224 mod 256): COLLAPSE 0x38000 thru 0x4cfff	(0x15000 bytes)
6218721(225 mod 256): COPY 0x181b9 thru 0x35dd0	(0x1dc18 bytes) to 0x4981d thru 0x67434
6218722(226 mod 256): TRUNCATE UP	from 0x67435 to 0x91552	******WWWW
6218723(227 mod 256): ZERO     0x43e81 thru 0x55685	(0x11805 bytes)
6218724(228 mod 256): COPY 0x782a4 thru 0x88932	(0x1068f bytes) to 0xb154 thru 0x1b7e2
6218725(229 mod 256): COPY 0x652c3 thru 0x6df26	(0x8c64 bytes) to 0x80098 thru 0x88cfb
6218726(230 mod 256): CLONE 0x5d000 thru 0x6cfff	(0x10000 bytes) to 0x72000 thru 0x81fff
6218727(231 mod 256): WRITE    0x704f9 thru 0x7a3d7	(0x9edf bytes)
6218728(232 mod 256): ZERO     0x3be6b thru 0x48763	(0xc8f9 bytes)
6218729(233 mod 256): ZERO     0x13a8 thru 0x17454	(0x160ad bytes)
6218730(234 mod 256): ZERO     0x55cd2 thru 0x633bc	(0xd6eb bytes)
6218731(235 mod 256): CLONE 0x74000 thru 0x80fff	(0xd000 bytes) to 0x4a000 thru 0x56fff
6218732(236 mod 256): DEDUPE 0x63000 thru 0x7dfff	(0x1b000 bytes) to 0x2b000 thru 0x45fff	BBBB******
6218733(237 mod 256): COPY 0x8d969 thru 0x91551	(0x3be9 bytes) to 0x64b6a thru 0x68752
6218734(238 mod 256): CLONE 0x64000 thru 0x70fff	(0xd000 bytes) to 0x22000 thru 0x2efff	JJJJ******
6218735(239 mod 256): MAPWRITE 0x3e52c thru 0x4e996	(0x1046b bytes)
6218736(240 mod 256): FALLOC   0x13e84 thru 0x25177	(0x112f3 bytes) INTERIOR
6218737(241 mod 256): CLONE 0x8c000 thru 0x8ffff	(0x4000 bytes) to 0x6f000 thru 0x72fff
6218738(242 mod 256): ZERO     0x5df00 thru 0x6416b	(0x626c bytes)
6218739(243 mod 256): MAPREAD  0x13837 thru 0x22e1e	(0xf5e8 bytes)
6218740(244 mod 256): FALLOC   0x8b6ab thru 0x927c0	(0x7115 bytes) EXTENDING
6218741(245 mod 256): COPY 0x616a7 thru 0x7ea61	(0x1d3bb bytes) to 0x2e5a2 thru 0x4b95c	EEEE******
6218742(246 mod 256): READ     0x487b6 thru 0x66a1f	(0x1e26a bytes)
6218743(247 mod 256): ZERO     0x1992f thru 0x1d2bb	(0x398d bytes)
6218744(248 mod 256): SKIPPED (no operation)
6218745(249 mod 256): COLLAPSE 0x45000 thru 0x61fff	(0x1d000 bytes)
6218746(250 mod 256): TRUNCATE UP	from 0x757c0 to 0x8e64b
6218747(251 mod 256): PUNCH    0x7f2b2 thru 0x8e64a	(0xf399 bytes)
6218748(252 mod 256): FALLOC   0x6bd85 thru 0x70abe	(0x4d39 bytes) INTERIOR	******FFFF
6218749(253 mod 256): COPY 0xbd7b thru 0x11ead	(0x6133 bytes) to 0x1ff6a thru 0x2609c
6218750(254 mod 256): ZERO     0x6627c thru 0x6acc7	(0x4a4c bytes)
6218751(255 mod 256): COLLAPSE 0x5f000 thru 0x65fff	(0x7000 bytes)
6218752(  0 mod 256): COLLAPSE 0x1f000 thru 0x31fff	(0x13000 bytes)
6218753(  1 mod 256): INSERT 0x3e000 thru 0x4efff	(0x11000 bytes)
6218754(  2 mod 256): INSERT 0x2f000 thru 0x37fff	(0x9000 bytes)
6218755(  3 mod 256): MAPWRITE 0xe0b7 thru 0x188e8	(0xa832 bytes)
6218756(  4 mod 256): TRUNCATE DOWN	from 0x8e64b to 0x23f43	******WWWW
6218757(  5 mod 256): ZERO     0x4a641 thru 0x655f8	(0x1afb8 bytes)
6218758(  6 mod 256): COPY 0x19aff thru 0x23f42	(0xa444 bytes) to 0x583e0 thru 0x62823
6218759(  7 mod 256): MAPREAD  0x57894 thru 0x61a45	(0xa1b2 bytes)
6218760(  8 mod 256): DEDUPE 0x57000 thru 0x60fff	(0xa000 bytes) to 0x3b000 thru 0x44fff
6218761(  9 mod 256): DEDUPE 0x40000 thru 0x54fff	(0x15000 bytes) to 0x17000 thru 0x2bfff
6218762( 10 mod 256): COLLAPSE 0x2e000 thru 0x2efff	(0x1000 bytes)
6218763( 11 mod 256): CLONE 0x4d000 thru 0x4ffff	(0x3000 bytes) to 0x73000 thru 0x75fff
6218764( 12 mod 256): WRITE    0x45a68 thru 0x5f389	(0x19922 bytes)
6218765( 13 mod 256): COLLAPSE 0x72000 thru 0x74fff	(0x3000 bytes)
6218766( 14 mod 256): COLLAPSE 0x60000 thru 0x71fff	(0x12000 bytes)	******CCCC
6218767( 15 mod 256): TRUNCATE DOWN	from 0x61000 to 0x1709d
6218768( 16 mod 256): WRITE    0x8612d thru 0x927bf	(0xc693 bytes) HOLE	***WWWW
6218769( 17 mod 256): WRITE    0xcbed thru 0x25122	(0x18536 bytes)
6218770( 18 mod 256): CLONE 0x6a000 thru 0x82fff	(0x19000 bytes) to 0x3f000 thru 0x57fff	JJJJ******
6218771( 19 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x399	******WWWW
6218772( 20 mod 256): SKIPPED (no operation)
6218773( 21 mod 256): READ     0xb3 thru 0x398	(0x2e6 bytes)
6218774( 22 mod 256): MAPREAD  0x27a thru 0x398	(0x11f bytes)
6218775( 23 mod 256): COPY 0x376 thru 0x398	(0x23 bytes) to 0x14756 thru 0x14778
6218776( 24 mod 256): INSERT 0x2000 thru 0x5fff	(0x4000 bytes)
6218777( 25 mod 256): COPY 0x1112f thru 0x18778	(0x764a bytes) to 0x1b5b1 thru 0x22bfa
6218778( 26 mod 256): READ     0x111a0 thru 0x22bfa	(0x11a5b bytes)
6218779( 27 mod 256): MAPWRITE 0x3817c thru 0x4573b	(0xd5c0 bytes)
6218780( 28 mod 256): PUNCH    0x28ee8 thru 0x2ceb5	(0x3fce bytes)
6218781( 29 mod 256): CLONE 0x37000 thru 0x43fff	(0xd000 bytes) to 0x4f000 thru 0x5bfff
6218782( 30 mod 256): SKIPPED (no operation)
6218783( 31 mod 256): ZERO     0x33bca thru 0x44341	(0x10778 bytes)
6218784( 32 mod 256): COPY 0x67b1 thru 0x14b27	(0xe377 bytes) to 0x45ddf thru 0x54155
6218785( 33 mod 256): FALLOC   0x465d8 thru 0x54bc7	(0xe5ef bytes) INTERIOR
6218786( 34 mod 256): ZERO     0x700f9 thru 0x7a9f3	(0xa8fb bytes)
6218787( 35 mod 256): SKIPPED (no operation)
6218788( 36 mod 256): PUNCH    0xd09a thru 0x29865	(0x1c7cc bytes)
6218789( 37 mod 256): COPY 0x2f7ae thru 0x4066e	(0x10ec1 bytes) to 0x7d0db thru 0x8df9b
6218790( 38 mod 256): MAPWRITE 0x5e995 thru 0x6153a	(0x2ba6 bytes)
6218791( 39 mod 256): WRITE    0x339a1 thru 0x460e6	(0x12746 bytes)
6218792( 40 mod 256): ZERO     0x2d3dd thru 0x3f054	(0x11c78 bytes)
6218793( 41 mod 256): MAPREAD  0x23db6 thru 0x319a8	(0xdbf3 bytes)
6218794( 42 mod 256): FALLOC   0x56f64 thru 0x67e77	(0x10f13 bytes) INTERIOR
6218795( 43 mod 256): COLLAPSE 0x16000 thru 0x21fff	(0xc000 bytes)
6218796( 44 mod 256): ZERO     0x3126e thru 0x4e5e7	(0x1d37a bytes)
6218797( 45 mod 256): MAPWRITE 0x8fee3 thru 0x927bf	(0x28dd bytes)
6218798( 46 mod 256): COLLAPSE 0x16000 thru 0x1cfff	(0x7000 bytes)
6218799( 47 mod 256): MAPWRITE 0x2d062 thru 0x45dc9	(0x18d68 bytes)
6218800( 48 mod 256): SKIPPED (no operation)
6218801( 49 mod 256): MAPWRITE 0x80e2a thru 0x8fb8d	(0xed64 bytes)
6218802( 50 mod 256): READ     0x777a8 thru 0x8d16a	(0x159c3 bytes)
6218803( 51 mod 256): ZERO     0x5c58 thru 0x9886	(0x3c2f bytes)
6218804( 52 mod 256): PUNCH    0x45048 thru 0x46ba6	(0x1b5f bytes)
6218805( 53 mod 256): PUNCH    0x8b882 thru 0x8fb8d	(0x430c bytes)
6218806( 54 mod 256): WRITE    0x4cf7d thru 0x4dfbf	(0x1043 bytes)
6218807( 55 mod 256): COPY 0x2154d thru 0x3dc25	(0x1c6d9 bytes) to 0x75352 thru 0x91a2a
6218808( 56 mod 256): COPY 0x6cc05 thru 0x7c138	(0xf534 bytes) to 0x4b36d thru 0x5a8a0	EEEE******
6218809( 57 mod 256): READ     0x811e1 thru 0x90210	(0xf030 bytes)
6218810( 58 mod 256): READ     0x692ed thru 0x8135c	(0x18070 bytes)	***RRRR***
6218811( 59 mod 256): SKIPPED (no operation)
6218812( 60 mod 256): PUNCH    0x69891 thru 0x8265e	(0x18dce bytes)	******PPPP
6218813( 61 mod 256): COLLAPSE 0x76000 thru 0x8ffff	(0x1a000 bytes)
6218814( 62 mod 256): SKIPPED (no operation)
6218815( 63 mod 256): CLONE 0x59000 thru 0x65fff	(0xd000 bytes) to 0x1b000 thru 0x27fff
6218816( 64 mod 256): SKIPPED (no operation)
6218817( 65 mod 256): MAPREAD  0x28f78 thru 0x3cf62	(0x13feb bytes)
6218818( 66 mod 256): SKIPPED (no operation)
6218819( 67 mod 256): COLLAPSE 0x56000 thru 0x65fff	(0x10000 bytes)
6218820( 68 mod 256): INSERT 0x2e000 thru 0x43fff	(0x16000 bytes)
6218821( 69 mod 256): COPY 0x3d2b thru 0x1779b	(0x13a71 bytes) to 0x28ff3 thru 0x3ca63
6218822( 70 mod 256): TRUNCATE DOWN	from 0x7da2b to 0x3cb7c	******WWWW
6218823( 71 mod 256): ZERO     0xb9d8 thru 0x2aca7	(0x1f2d0 bytes)
6218824( 72 mod 256): CLONE 0x28000 thru 0x3bfff	(0x14000 bytes) to 0xb000 thru 0x1efff
6218825( 73 mod 256): COLLAPSE 0x30000 thru 0x3bfff	(0xc000 bytes)
6218826( 74 mod 256): WRITE    0x6d428 thru 0x87322	(0x19efb bytes) HOLE	***WWWW
6218827( 75 mod 256): ZERO     0x2f0bc thru 0x3e0fa	(0xf03f bytes)
6218828( 76 mod 256): READ     0x78075 thru 0x87322	(0xf2ae bytes)
6218829( 77 mod 256): MAPWRITE 0x21d67 thru 0x39a02	(0x17c9c bytes)
6218830( 78 mod 256): FALLOC   0x36911 thru 0x486f6	(0x11de5 bytes) INTERIOR
6218831( 79 mod 256): FALLOC   0x9d18 thru 0x2471a	(0x1aa02 bytes) INTERIOR
6218832( 80 mod 256): ZERO     0x59805 thru 0x6a0b8	(0x108b4 bytes)
6218833( 81 mod 256): CLONE 0x29000 thru 0x33fff	(0xb000 bytes) to 0x67000 thru 0x71fff	******JJJJ
6218834( 82 mod 256): COLLAPSE 0x77000 thru 0x78fff	(0x2000 bytes)
6218835( 83 mod 256): WRITE    0x10b67 thru 0x1999f	(0x8e39 bytes)
6218836( 84 mod 256): COLLAPSE 0xd000 thru 0x19fff	(0xd000 bytes)
6218837( 85 mod 256): INSERT 0x34000 thru 0x49fff	(0x16000 bytes)
6218838( 86 mod 256): MAPREAD  0x6dac thru 0x1312e	(0xc383 bytes)
6218839( 87 mod 256): WRITE    0x72e28 thru 0x82d10	(0xfee9 bytes)
6218840( 88 mod 256): COPY 0x76a60 thru 0x7dc60	(0x7201 bytes) to 0x85f26 thru 0x8d126
6218841( 89 mod 256): READ     0x1d261 thru 0x2fd94	(0x12b34 bytes)
6218842( 90 mod 256): CLONE 0x21000 thru 0x25fff	(0x5000 bytes) to 0x64000 thru 0x68fff
6218843( 91 mod 256): CLONE 0xe000 thru 0x1cfff	(0xf000 bytes) to 0x21000 thru 0x2ffff
6218844( 92 mod 256): COLLAPSE 0x5000 thru 0x22fff	(0x1e000 bytes)
6218845( 93 mod 256): SKIPPED (no operation)
6218846( 94 mod 256): TRUNCATE DOWN	from 0x70323 to 0x5f48e	******WWWW
6218847( 95 mod 256): MAPREAD  0x43ad2 thru 0x52c1a	(0xf149 bytes)
6218848( 96 mod 256): DEDUPE 0x3c000 thru 0x4efff	(0x13000 bytes) to 0x19000 thru 0x2bfff
6218849( 97 mod 256): READ     0x29722 thru 0x3f3f8	(0x15cd7 bytes)
6218850( 98 mod 256): INSERT 0x1c000 thru 0x31fff	(0x16000 bytes)
6218851( 99 mod 256): SKIPPED (no operation)
6218852(100 mod 256): INSERT 0x12000 thru 0x2afff	(0x19000 bytes)
6218853(101 mod 256): MAPWRITE 0x814ca thru 0x87932	(0x6469 bytes)
6218854(102 mod 256): ZERO     0x458ea thru 0x5e3f6	(0x18b0d bytes)
6218855(103 mod 256): SKIPPED (no operation)
6218856(104 mod 256): SKIPPED (no operation)
6218857(105 mod 256): CLONE 0x4000 thru 0xffff	(0xc000 bytes) to 0x51000 thru 0x5cfff
6218858(106 mod 256): PUNCH    0x7370a thru 0x74cd6	(0x15cd bytes)
6218859(107 mod 256): COPY 0x3c933 thru 0x53e7c	(0x1754a bytes) to 0x555f2 thru 0x6cb3b
6218860(108 mod 256): COPY 0x580e8 thru 0x659df	(0xd8f8 bytes) to 0x3674d thru 0x44044
6218861(109 mod 256): FALLOC   0x1013 thru 0xeae6	(0xdad3 bytes) INTERIOR
6218862(110 mod 256): SKIPPED (no operation)
6218863(111 mod 256): READ     0x14a8f thru 0x18646	(0x3bb8 bytes)
6218864(112 mod 256): DEDUPE 0x28000 thru 0x3dfff	(0x16000 bytes) to 0x5b000 thru 0x70fff	******BBBB
6218865(113 mod 256): MAPWRITE 0x50298 thru 0x64cb8	(0x14a21 bytes)
6218866(114 mod 256): MAPWRITE 0x6ddf9 thru 0x84995	(0x16b9d bytes)	******WWWW
6218867(115 mod 256): READ     0x55c5 thru 0x13151	(0xdb8d bytes)
6218868(116 mod 256): TRUNCATE UP	from 0x8e48e to 0x91d3c
6218869(117 mod 256): COPY 0x460d3 thru 0x46ec4	(0xdf2 bytes) to 0x1360d thru 0x143fe
6218870(118 mod 256): ZERO     0x85fcb thru 0x927bf	(0xc7f5 bytes)
6218871(119 mod 256): CLONE 0x41000 thru 0x45fff	(0x5000 bytes) to 0x19000 thru 0x1dfff
6218872(120 mod 256): COLLAPSE 0x9000 thru 0x12fff	(0xa000 bytes)
6218873(121 mod 256): COPY 0x3b72 thru 0x1bd15	(0x181a4 bytes) to 0x5cb1e thru 0x74cc1	******EEEE
6218874(122 mod 256): DEDUPE 0x4e000 thru 0x68fff	(0x1b000 bytes) to 0x6b000 thru 0x85fff	******BBBB
6218875(123 mod 256): CLONE 0xe000 thru 0x16fff	(0x9000 bytes) to 0x1000 thru 0x9fff
6218876(124 mod 256): PUNCH    0x7df08 thru 0x7fbe8	(0x1ce1 bytes)
6218877(125 mod 256): INSERT 0x38000 thru 0x3dfff	(0x6000 bytes)
6218878(126 mod 256): MAPWRITE 0x47ac8 thru 0x5e4ea	(0x16a23 bytes)
6218879(127 mod 256): READ     0x7c5df thru 0x8dd3b	(0x1175d bytes)
6218880(128 mod 256): INSERT 0x79000 thru 0x7cfff	(0x4000 bytes)
6218881(129 mod 256): SKIPPED (no operation)
6218882(130 mod 256): PUNCH    0x77802 thru 0x80a38	(0x9237 bytes)
6218883(131 mod 256): READ     0x540ce thru 0x6a63b	(0x1656e bytes)
6218884(132 mod 256): MAPWRITE 0x84a6f thru 0x927bf	(0xdd51 bytes)
6218885(133 mod 256): FALLOC   0x67bf2 thru 0x743c2	(0xc7d0 bytes) INTERIOR	******FFFF
6218886(134 mod 256): ZERO     0x549c6 thru 0x6f1c5	(0x1a800 bytes)	******ZZZZ
6218887(135 mod 256): PUNCH    0x298f thru 0x207e9	(0x1de5b bytes)
6218888(136 mod 256): MAPREAD  0x1d2d0 thru 0x3848f	(0x1b1c0 bytes)
6218889(137 mod 256): ZERO     0x452f8 thru 0x453f8	(0x101 bytes)
6218890(138 mod 256): FALLOC   0x25eb6 thru 0x34d27	(0xee71 bytes) INTERIOR
6218891(139 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x25e2d	******WWWW
6218892(140 mod 256): DEDUPE 0x12000 thru 0x23fff	(0x12000 bytes) to 0x0 thru 0x11fff
6218893(141 mod 256): MAPWRITE 0xe162 thru 0x1471d	(0x65bc bytes)
6218894(142 mod 256): MAPREAD  0x22bfa thru 0x25e2c	(0x3233 bytes)
6218895(143 mod 256): FALLOC   0x704f6 thru 0x88aeb	(0x185f5 bytes) PAST_EOF
6218896(144 mod 256): SKIPPED (no operation)
6218897(145 mod 256): INSERT 0x22000 thru 0x3efff	(0x1d000 bytes)
6218898(146 mod 256): FALLOC   0x3c493 thru 0x459f9	(0x9566 bytes) PAST_EOF
6218899(147 mod 256): FALLOC   0x17da4 thru 0x36d80	(0x1efdc bytes) INTERIOR
6218900(148 mod 256): CLONE 0x3c000 thru 0x3cfff	(0x1000 bytes) to 0x59000 thru 0x59fff
6218901(149 mod 256): COPY 0x22b35 thru 0x2f0e8	(0xc5b4 bytes) to 0x5ce8c thru 0x6943f
6218902(150 mod 256): READ     0x1c8c3 thru 0x3776a	(0x1aea8 bytes)
6218903(151 mod 256): ZERO     0x2ac24 thru 0x43a1a	(0x18df7 bytes)
6218904(152 mod 256): MAPWRITE 0xb148 thru 0xb403	(0x2bc bytes)
6218905(153 mod 256): CLONE 0x3f000 thru 0x54fff	(0x16000 bytes) to 0x7000 thru 0x1cfff
6218906(154 mod 256): WRITE    0x604bc thru 0x7a6bc	(0x1a201 bytes) EXTEND	***WWWW
6218907(155 mod 256): PUNCH    0x53537 thru 0x5f7d2	(0xc29c bytes)
6218908(156 mod 256): READ     0xaa1a thru 0x255a7	(0x1ab8e bytes)
6218909(157 mod 256): TRUNCATE UP	from 0x7a6bd to 0x813d0
6218910(158 mod 256): INSERT 0x7e000 thru 0x7ffff	(0x2000 bytes)
6218911(159 mod 256): SKIPPED (no operation)
6218912(160 mod 256): INSERT 0x4f000 thru 0x5dfff	(0xf000 bytes)
6218913(161 mod 256): FALLOC   0x777dc thru 0x83e37	(0xc65b bytes) INTERIOR
6218914(162 mod 256): TRUNCATE DOWN	from 0x923d0 to 0x50bd3	******WWWW
6218915(163 mod 256): ZERO     0x80ffc thru 0x927bf	(0x117c4 bytes)
6218916(164 mod 256): ZERO     0x7242d thru 0x82581	(0x10155 bytes)
6218917(165 mod 256): READ     0x14568 thru 0x28ba3	(0x1463c bytes)
6218918(166 mod 256): WRITE    0x29b4c thru 0x457ce	(0x1bc83 bytes)
6218919(167 mod 256): SKIPPED (no operation)
6218920(168 mod 256): MAPREAD  0x6adf7 thru 0x7091b	(0x5b25 bytes)	***RRRR***
6218921(169 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x28db1	******WWWW
6218922(170 mod 256): COLLAPSE 0x16000 thru 0x19fff	(0x4000 bytes)
6218923(171 mod 256): FALLOC   0x6a756 thru 0x73b6e	(0x9418 bytes) EXTENDING	******FFFF
6218924(172 mod 256): COPY 0x50918 thru 0x5b3b9	(0xaaa2 bytes) to 0x3d60b thru 0x480ac
6218925(173 mod 256): MAPREAD  0xed95 thru 0x2132c	(0x12598 bytes)
6218926(174 mod 256): FALLOC   0x3fad3 thru 0x437f6	(0x3d23 bytes) INTERIOR
6218927(175 mod 256): ZERO     0x16a2f thru 0x2c2f1	(0x158c3 bytes)
6218928(176 mod 256): ZERO     0x47f8e thru 0x4c157	(0x41ca bytes)
6218929(177 mod 256): READ     0x1ace4 thru 0x35ee6	(0x1b203 bytes)
6218930(178 mod 256): COPY 0x5de48 thru 0x60714	(0x28cd bytes) to 0x1c9f8 thru 0x1f2c4
6218931(179 mod 256): COPY 0x2a60a thru 0x48741	(0x1e138 bytes) to 0x5c03b thru 0x7a172	******EEEE
6218932(180 mod 256): MAPWRITE 0x3e940 thru 0x44561	(0x5c22 bytes)
6218933(181 mod 256): WRITE    0x39e63 thru 0x4053c	(0x66da bytes)
6218934(182 mod 256): WRITE    0x7393e thru 0x73cd4	(0x397 bytes)
6218935(183 mod 256): ZERO     0x3232 thru 0x11528	(0xe2f7 bytes)
6218936(184 mod 256): READ     0x76011 thru 0x76eed	(0xedd bytes)
6218937(185 mod 256): COPY 0x5b68 thru 0x21658	(0x1baf1 bytes) to 0x2850f thru 0x43fff
6218938(186 mod 256): READ     0x2fed3 thru 0x3cdce	(0xcefc bytes)
6218939(187 mod 256): PUNCH    0x6074 thru 0xbce2	(0x5c6f bytes)
6218940(188 mod 256): FALLOC   0x13e6 thru 0x15c1f	(0x14839 bytes) INTERIOR
6218941(189 mod 256): READ     0x1e8b4 thru 0x350ec	(0x16839 bytes)
6218942(190 mod 256): READ     0x3c959 thru 0x46899	(0x9f41 bytes)
6218943(191 mod 256): MAPREAD  0x1ae59 thru 0x39a0a	(0x1ebb2 bytes)
6218944(192 mod 256): INSERT 0x3e000 thru 0x40fff	(0x3000 bytes)
6218945(193 mod 256): MAPWRITE 0x237de thru 0x32b57	(0xf37a bytes)
6218946(194 mod 256): READ     0x4131 thru 0x1d106	(0x18fd6 bytes)
6218947(195 mod 256): TRUNCATE DOWN	from 0x7d173 to 0x61421	******WWWW
6218948(196 mod 256): ZERO     0x2efee thru 0x4305f	(0x14072 bytes)
6218949(197 mod 256): COLLAPSE 0x33000 thru 0x39fff	(0x7000 bytes)
6218950(198 mod 256): TRUNCATE UP	from 0x5a421 to 0x65fbf
6218951(199 mod 256): READ     0x1cc6e thru 0x34dd5	(0x18168 bytes)
6218952(200 mod 256): READ     0x145a5 thru 0x2d4b3	(0x18f0f bytes)
6218953(201 mod 256): MAPREAD  0x2996d thru 0x2a937	(0xfcb bytes)
6218954(202 mod 256): CLONE 0x47000 thru 0x55fff	(0xf000 bytes) to 0x79000 thru 0x87fff
6218955(203 mod 256): SKIPPED (no operation)
6218956(204 mod 256): SKIPPED (no operation)
6218957(205 mod 256): CLONE 0x12000 thru 0x1cfff	(0xb000 bytes) to 0x67000 thru 0x71fff	******JJJJ
6218958(206 mod 256): FALLOC   0xf169 thru 0x2916d	(0x1a004 bytes) INTERIOR
6218959(207 mod 256): TRUNCATE DOWN	from 0x88000 to 0xf7e	******WWWW
6218960(208 mod 256): READ     0xbd4 thru 0xf7d	(0x3aa bytes)
6218961(209 mod 256): ZERO     0x18992 thru 0x32ea5	(0x1a514 bytes)
6218962(210 mod 256): INSERT 0x1b000 thru 0x2cfff	(0x12000 bytes)
6218963(211 mod 256): MAPWRITE 0xeb31 thru 0x293a9	(0x1a879 bytes)
6218964(212 mod 256): FALLOC   0x41fa2 thru 0x60ea0	(0x1eefe bytes) PAST_EOF
6218965(213 mod 256): SKIPPED (no operation)
6218966(214 mod 256): DEDUPE 0x40000 thru 0x43fff	(0x4000 bytes) to 0x25000 thru 0x28fff
6218967(215 mod 256): FALLOC   0x57296 thru 0x633aa	(0xc114 bytes) EXTENDING
6218968(216 mod 256): TRUNCATE DOWN	from 0x633aa to 0x5b8e6
6218969(217 mod 256): MAPREAD  0xb716 thru 0x1330d	(0x7bf8 bytes)
6218970(218 mod 256): COLLAPSE 0x16000 thru 0x2cfff	(0x17000 bytes)
6218971(219 mod 256): MAPREAD  0x101d5 thru 0x195cd	(0x93f9 bytes)
6218972(220 mod 256): ZERO     0x7724b thru 0x786e4	(0x149a bytes)
6218973(221 mod 256): ZERO     0x21b27 thru 0x3526b	(0x13745 bytes)
6218974(222 mod 256): READ     0x3c90 thru 0xe576	(0xa8e7 bytes)
6218975(223 mod 256): INSERT 0x34000 thru 0x4dfff	(0x1a000 bytes)
6218976(224 mod 256): CLONE 0x54000 thru 0x65fff	(0x12000 bytes) to 0xe000 thru 0x1ffff
6218977(225 mod 256): MAPWRITE 0x76fe0 thru 0x7f7c8	(0x87e9 bytes)
6218978(226 mod 256): COLLAPSE 0x50000 thru 0x60fff	(0x11000 bytes)
6218979(227 mod 256): PUNCH    0x1f232 thru 0x354d0	(0x1629f bytes)
6218980(228 mod 256): TRUNCATE DOWN	from 0x816e5 to 0x3414	******WWWW
6218981(229 mod 256): SKIPPED (no operation)
6218982(230 mod 256): INSERT 0x1000 thru 0xafff	(0xa000 bytes)
6218983(231 mod 256): MAPREAD  0xa40 thru 0x3b8b	(0x314c bytes)
6218984(232 mod 256): READ     0x9eba thru 0xd413	(0x355a bytes)
6218985(233 mod 256): WRITE    0x693c2 thru 0x70d07	(0x7946 bytes) HOLE	***WWWW
6218986(234 mod 256): READ     0x70b6a thru 0x70d07	(0x19e bytes)
6218987(235 mod 256): WRITE    0x88ef7 thru 0x927bf	(0x98c9 bytes) HOLE
6218988(236 mod 256): SKIPPED (no operation)
6218989(237 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2caa2	******WWWW
6218990(238 mod 256): COLLAPSE 0x12000 thru 0x28fff	(0x17000 bytes)
6218991(239 mod 256): COLLAPSE 0x6000 thru 0x13fff	(0xe000 bytes)
6218992(240 mod 256): INSERT 0x6000 thru 0x11fff	(0xc000 bytes)
6218993(241 mod 256): WRITE    0x4bd26 thru 0x5201f	(0x62fa bytes) HOLE
6218994(242 mod 256): MAPREAD  0x2cd13 thru 0x3cfd4	(0x102c2 bytes)
6218995(243 mod 256): CLONE 0x2a000 thru 0x42fff	(0x19000 bytes) to 0x6f000 thru 0x87fff
6218996(244 mod 256): WRITE    0x1a4f7 thru 0x3104a	(0x16b54 bytes)
6218997(245 mod 256): MAPREAD  0x4c731 thru 0x662cc	(0x19b9c bytes)
6218998(246 mod 256): READ     0x462fc thru 0x5af6f	(0x14c74 bytes)
6218999(247 mod 256): READ     0x61f6e thru 0x7ae3e	(0x18ed1 bytes)	***RRRR***
6219000(248 mod 256): MAPWRITE 0x6d1b1 thru 0x7dc7f	(0x10acf bytes)	******WWWW
6219001(249 mod 256): INSERT 0x2b000 thru 0x34fff	(0xa000 bytes)
6219002(250 mod 256): READ     0x2d8ee thru 0x31934	(0x4047 bytes)
6219003(251 mod 256): MAPWRITE 0x29edf thru 0x4588e	(0x1b9b0 bytes)
6219004(252 mod 256): COLLAPSE 0x3c000 thru 0x40fff	(0x5000 bytes)
6219005(253 mod 256): ZERO     0x8204 thru 0x137a9	(0xb5a6 bytes)
6219006(254 mod 256): PUNCH    0x55a2b thru 0x59556	(0x3b2c bytes)
6219007(255 mod 256): FALLOC   0x7ddcc thru 0x927c0	(0x149f4 bytes) EXTENDING
6219008(  0 mod 256): SKIPPED (no operation)
6219009(  1 mod 256): COLLAPSE 0x69000 thru 0x78fff	(0x10000 bytes)	******CCCC
6219010(  2 mod 256): PUNCH    0x11ad thru 0x15013	(0x13e67 bytes)
6219011(  3 mod 256): READ     0x24cd5 thru 0x3e84e	(0x19b7a bytes)
6219012(  4 mod 256): WRITE    0x567b6 thru 0x58aff	(0x234a bytes)
6219013(  5 mod 256): WRITE    0x7d397 thru 0x927bf	(0x15429 bytes) EXTEND
6219014(  6 mod 256): COPY 0x534b4 thru 0x6dfb3	(0x1ab00 bytes) to 0x1a5d6 thru 0x350d5
6219015(  7 mod 256): WRITE    0x5c096 thru 0x73f30	(0x17e9b bytes)	***WWWW
6219016(  8 mod 256): MAPWRITE 0x81570 thru 0x82e9c	(0x192d bytes)
6219017(  9 mod 256): COPY 0x2d3c3 thru 0x47df1	(0x1aa2f bytes) to 0x737b2 thru 0x8e1e0
6219018( 10 mod 256): DEDUPE 0x3e000 thru 0x4efff	(0x11000 bytes) to 0x79000 thru 0x89fff
6219019( 11 mod 256): CLONE 0x49000 thru 0x4cfff	(0x4000 bytes) to 0x77000 thru 0x7afff
6219020( 12 mod 256): PUNCH    0x3165f thru 0x42df5	(0x11797 bytes)
6219021( 13 mod 256): CLONE 0x5a000 thru 0x5bfff	(0x2000 bytes) to 0x49000 thru 0x4afff
6219022( 14 mod 256): SKIPPED (no operation)
6219023( 15 mod 256): SKIPPED (no operation)
6219024( 16 mod 256): SKIPPED (no operation)
6219025( 17 mod 256): FALLOC   0x174a3 thru 0x1ebee	(0x774b bytes) INTERIOR
6219026( 18 mod 256): CLONE 0x90000 thru 0x90fff	(0x1000 bytes) to 0x5b000 thru 0x5bfff
6219027( 19 mod 256): WRITE    0x40939 thru 0x5e7fb	(0x1dec3 bytes)
6219028( 20 mod 256): FALLOC   0x6b1a2 thru 0x8593d	(0x1a79b bytes) INTERIOR	******FFFF
6219029( 21 mod 256): COPY 0x29e69 thru 0x42ae2	(0x18c7a bytes) to 0x53947 thru 0x6c5c0
6219030( 22 mod 256): CLONE 0x20000 thru 0x24fff	(0x5000 bytes) to 0x40000 thru 0x44fff
6219031( 23 mod 256): COLLAPSE 0x39000 thru 0x49fff	(0x11000 bytes)
6219032( 24 mod 256): COLLAPSE 0x5a000 thru 0x73fff	(0x1a000 bytes)	******CCCC
6219033( 25 mod 256): FALLOC   0x4f28f thru 0x66a83	(0x177f4 bytes) INTERIOR
6219034( 26 mod 256): COLLAPSE 0x1b000 thru 0x28fff	(0xe000 bytes)
6219035( 27 mod 256): TRUNCATE DOWN	from 0x597c0 to 0x44cc9
6219036( 28 mod 256): MAPWRITE 0xc9eb thru 0x1cb9a	(0x101b0 bytes)
6219037( 29 mod 256): CLONE 0xc000 thru 0x25fff	(0x1a000 bytes) to 0x35000 thru 0x4efff
6219038( 30 mod 256): MAPWRITE 0x74de2 thru 0x83e29	(0xf048 bytes)
6219039( 31 mod 256): ZERO     0x11d06 thru 0x1c970	(0xac6b bytes)
6219040( 32 mod 256): INSERT 0x53000 thru 0x60fff	(0xe000 bytes)
6219041( 33 mod 256): FALLOC   0x4b6c9 thru 0x4ee73	(0x37aa bytes) INTERIOR
6219042( 34 mod 256): FALLOC   0x1da25 thru 0x247bc	(0x6d97 bytes) INTERIOR
6219043( 35 mod 256): COLLAPSE 0x4b000 thru 0x5dfff	(0x13000 bytes)
6219044( 36 mod 256): ZERO     0x2227f thru 0x33f53	(0x11cd5 bytes)
6219045( 37 mod 256): PUNCH    0x5acef thru 0x6a1c3	(0xf4d5 bytes)
6219046( 38 mod 256): FALLOC   0x447b7 thru 0x57bfc	(0x13445 bytes) INTERIOR
6219047( 39 mod 256): DEDUPE 0x6e000 thru 0x76fff	(0x9000 bytes) to 0x1000 thru 0x9fff	BBBB******
6219048( 40 mod 256): MAPWRITE 0x269a9 thru 0x457a1	(0x1edf9 bytes)
6219049( 41 mod 256): MAPREAD  0x76ecc thru 0x7ee29	(0x7f5e bytes)
6219050( 42 mod 256): FALLOC   0x766b3 thru 0x8c262	(0x15baf bytes) PAST_EOF
6219051( 43 mod 256): CLONE 0x2b000 thru 0x2ffff	(0x5000 bytes) to 0x7f000 thru 0x83fff
6219052( 44 mod 256): FALLOC   0x42d6e thru 0x4889f	(0x5b31 bytes) INTERIOR
6219053( 45 mod 256): INSERT 0x1a000 thru 0x27fff	(0xe000 bytes)
6219054( 46 mod 256): MAPREAD  0x285d6 thru 0x3c8d4	(0x142ff bytes)
6219055( 47 mod 256): CLONE 0x33000 thru 0x45fff	(0x13000 bytes) to 0x15000 thru 0x27fff
6219056( 48 mod 256): MAPWRITE 0x8b269 thru 0x927bf	(0x7557 bytes)
6219057( 49 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5c694	******WWWW
6219058( 50 mod 256): WRITE    0x7763 thru 0x15772	(0xe010 bytes)
6219059( 51 mod 256): COLLAPSE 0xb000 thru 0x27fff	(0x1d000 bytes)
6219060( 52 mod 256): FALLOC   0x77024 thru 0x7cbe9	(0x5bc5 bytes) EXTENDING
6219061( 53 mod 256): DEDUPE 0x1000 thru 0x14fff	(0x14000 bytes) to 0x47000 thru 0x5afff
6219062( 54 mod 256): CLONE 0x24000 thru 0x27fff	(0x4000 bytes) to 0x79000 thru 0x7cfff
6219063( 55 mod 256): PUNCH    0x43fa7 thru 0x57c9a	(0x13cf4 bytes)
6219064( 56 mod 256): READ     0x7ce92 thru 0x7cfff	(0x16e bytes)
6219065( 57 mod 256): CLONE 0x3b000 thru 0x3bfff	(0x1000 bytes) to 0x5e000 thru 0x5efff
6219066( 58 mod 256): WRITE    0x43c3e thru 0x4875f	(0x4b22 bytes)
6219067( 59 mod 256): TRUNCATE DOWN	from 0x7d000 to 0x2af47	******WWWW
6219068( 60 mod 256): MAPREAD  0xa083 thru 0x19b2e	(0xfaac bytes)
6219069( 61 mod 256): ZERO     0x44b29 thru 0x625f8	(0x1dad0 bytes)
6219070( 62 mod 256): MAPREAD  0x20f6 thru 0x1f4be	(0x1d3c9 bytes)
6219071( 63 mod 256): COPY 0x10a3e thru 0x28ac2	(0x18085 bytes) to 0x788d1 thru 0x90955
6219072( 64 mod 256): PUNCH    0x621b6 thru 0x6bb9b	(0x99e6 bytes)
6219073( 65 mod 256): SKIPPED (no operation)
6219074( 66 mod 256): CLONE 0x47000 thru 0x61fff	(0x1b000 bytes) to 0x22000 thru 0x3cfff
6219075( 67 mod 256): READ     0x5eb56 thru 0x758e8	(0x16d93 bytes)	***RRRR***
6219076( 68 mod 256): COPY 0x46117 thru 0x55c19	(0xfb03 bytes) to 0x7256a thru 0x8206c
6219077( 69 mod 256): COPY 0x78b83 thru 0x7b1ab	(0x2629 bytes) to 0x53d17 thru 0x5633f
6219078( 70 mod 256): ZERO     0x3c83a thru 0x3e9d8	(0x219f bytes)
6219079( 71 mod 256): ZERO     0x73748 thru 0x852fc	(0x11bb5 bytes)
6219080( 72 mod 256): WRITE    0xe770 thru 0x158c2	(0x7153 bytes)
6219081( 73 mod 256): FALLOC   0x297d1 thru 0x46af4	(0x1d323 bytes) INTERIOR
6219082( 74 mod 256): FALLOC   0x54776 thru 0x5542d	(0xcb7 bytes) INTERIOR
6219083( 75 mod 256): SKIPPED (no operation)
6219084( 76 mod 256): DEDUPE 0x4c000 thru 0x4ffff	(0x4000 bytes) to 0x19000 thru 0x1cfff
6219085( 77 mod 256): CLONE 0x10000 thru 0x1dfff	(0xe000 bytes) to 0x48000 thru 0x55fff
6219086( 78 mod 256): COLLAPSE 0x7a000 thru 0x86fff	(0xd000 bytes)
6219087( 79 mod 256): PUNCH    0x426a5 thru 0x4f3af	(0xcd0b bytes)
6219088( 80 mod 256): MAPWRITE 0x6beee thru 0x70c59	(0x4d6c bytes)	******WWWW
6219089( 81 mod 256): WRITE    0x601b thru 0x24582	(0x1e568 bytes)
6219090( 82 mod 256): COPY 0x69597 thru 0x69650	(0xba bytes) to 0x525c6 thru 0x5267f
6219091( 83 mod 256): INSERT 0x59000 thru 0x66fff	(0xe000 bytes)
6219092( 84 mod 256): TRUNCATE DOWN	from 0x91956 to 0x66861	******WWWW
6219093( 85 mod 256): FALLOC   0x51042 thru 0x676fe	(0x166bc bytes) PAST_EOF
6219094( 86 mod 256): FALLOC   0x7af56 thru 0x7fe61	(0x4f0b bytes) EXTENDING
6219095( 87 mod 256): MAPREAD  0x6682e thru 0x69bf2	(0x33c5 bytes)
6219096( 88 mod 256): COPY 0x7b89 thru 0x1b720	(0x13b98 bytes) to 0x5bf5d thru 0x6faf4	******EEEE
6219097( 89 mod 256): FALLOC   0x3e8 thru 0x1cc11	(0x1c829 bytes) INTERIOR
6219098( 90 mod 256): CLONE 0x79000 thru 0x7efff	(0x6000 bytes) to 0x3d000 thru 0x42fff
6219099( 91 mod 256): SKIPPED (no operation)
6219100( 92 mod 256): ZERO     0x3dd75 thru 0x4cf7b	(0xf207 bytes)
6219101( 93 mod 256): COPY 0x2f49d thru 0x32723	(0x3287 bytes) to 0x50c1a thru 0x53ea0
6219102( 94 mod 256): TRUNCATE DOWN	from 0x7fe61 to 0x23de2	******WWWW
6219103( 95 mod 256): COLLAPSE 0xc000 thru 0x21fff	(0x16000 bytes)
6219104( 96 mod 256): TRUNCATE UP	from 0xdde2 to 0x4c480
6219105( 97 mod 256): DEDUPE 0x5000 thru 0x9fff	(0x5000 bytes) to 0x27000 thru 0x2bfff
6219106( 98 mod 256): SKIPPED (no operation)
6219107( 99 mod 256): COPY 0x3a471 thru 0x4c47f	(0x1200f bytes) to 0x26f58 thru 0x38f66
6219108(100 mod 256): MAPREAD  0x1a69f thru 0x38e08	(0x1e76a bytes)
6219109(101 mod 256): MAPWRITE 0x7b957 thru 0x927bf	(0x16e69 bytes)
6219110(102 mod 256): MAPWRITE 0x1830d thru 0x33d2f	(0x1ba23 bytes)
6219111(103 mod 256): COLLAPSE 0x50000 thru 0x69fff	(0x1a000 bytes)
6219112(104 mod 256): DEDUPE 0x31000 thru 0x46fff	(0x16000 bytes) to 0x52000 thru 0x67fff
6219113(105 mod 256): PUNCH    0x41349 thru 0x5e01e	(0x1ccd6 bytes)
6219114(106 mod 256): DEDUPE 0xc000 thru 0x24fff	(0x19000 bytes) to 0x3c000 thru 0x54fff
6219115(107 mod 256): SKIPPED (no operation)
6219116(108 mod 256): COLLAPSE 0x59000 thru 0x67fff	(0xf000 bytes)
6219117(109 mod 256): MAPREAD  0x36b3e thru 0x3c96b	(0x5e2e bytes)
6219118(110 mod 256): CLONE 0x5c000 thru 0x68fff	(0xd000 bytes) to 0x6f000 thru 0x7bfff
6219119(111 mod 256): SKIPPED (no operation)
6219120(112 mod 256): PUNCH    0x5a1bc thru 0x5d07e	(0x2ec3 bytes)
6219121(113 mod 256): PUNCH    0x350d9 thru 0x387f0	(0x3718 bytes)
6219122(114 mod 256): ZERO     0x4b8e thru 0x16e63	(0x122d6 bytes)
6219123(115 mod 256): COPY 0x6a8a1 thru 0x7bfff	(0x1175f bytes) to 0x40ed8 thru 0x52636	EEEE******
6219124(116 mod 256): COLLAPSE 0x20000 thru 0x22fff	(0x3000 bytes)
6219125(117 mod 256): CLONE 0x1b000 thru 0x2cfff	(0x12000 bytes) to 0x1000 thru 0x12fff
6219126(118 mod 256): WRITE    0x18277 thru 0x3704b	(0x1edd5 bytes)
6219127(119 mod 256): COLLAPSE 0x13000 thru 0x17fff	(0x5000 bytes)
6219128(120 mod 256): MAPREAD  0x5860f thru 0x6edb9	(0x167ab bytes)
6219129(121 mod 256): MAPWRITE 0x5b0b5 thru 0x76e32	(0x1bd7e bytes)	******WWWW
6219130(122 mod 256): DEDUPE 0x25000 thru 0x34fff	(0x10000 bytes) to 0x8000 thru 0x17fff
6219131(123 mod 256): COLLAPSE 0x59000 thru 0x61fff	(0x9000 bytes)
6219132(124 mod 256): MAPWRITE 0x827fe thru 0x927bf	(0xffc2 bytes)
6219133(125 mod 256): DEDUPE 0x10000 thru 0x2afff	(0x1b000 bytes) to 0x34000 thru 0x4efff
6219134(126 mod 256): FALLOC   0x589f8 thru 0x76e8c	(0x1e494 bytes) INTERIOR	******FFFF
6219135(127 mod 256): READ     0x75cf5 thru 0x87a7f	(0x11d8b bytes)
6219136(128 mod 256): MAPWRITE 0x2960b thru 0x3e9a6	(0x1539c bytes)
6219137(129 mod 256): FALLOC   0x72e5a thru 0x898c8	(0x16a6e bytes) INTERIOR
6219138(130 mod 256): DEDUPE 0x2b000 thru 0x3dfff	(0x13000 bytes) to 0x43000 thru 0x55fff
6219139(131 mod 256): SKIPPED (no operation)
6219140(132 mod 256): DEDUPE 0x11000 thru 0x18fff	(0x8000 bytes) to 0x1b000 thru 0x22fff
6219141(133 mod 256): MAPWRITE 0x634de thru 0x6dfac	(0xaacf bytes)
6219142(134 mod 256): FALLOC   0x27f3 thru 0x5013	(0x2820 bytes) INTERIOR
6219143(135 mod 256): COLLAPSE 0x3c000 thru 0x55fff	(0x1a000 bytes)
6219144(136 mod 256): ZERO     0xdf1a thru 0x2c648	(0x1e72f bytes)
6219145(137 mod 256): TRUNCATE UP	from 0x787c0 to 0x86188
6219146(138 mod 256): FALLOC   0x2fab6 thru 0x3103c	(0x1586 bytes) INTERIOR
6219147(139 mod 256): COPY 0x4033 thru 0x21ffc	(0x1dfca bytes) to 0x5e1ae thru 0x7c177	******EEEE
6219148(140 mod 256): WRITE    0x80708 thru 0x927bf	(0x120b8 bytes) EXTEND
6219149(141 mod 256): WRITE    0x77a97 thru 0x8ad5d	(0x132c7 bytes)
6219150(142 mod 256): SKIPPED (no operation)
6219151(143 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x90172
6219152(144 mod 256): MAPWRITE 0x524dd thru 0x6144d	(0xef71 bytes)
6219153(145 mod 256): ZERO     0x3e917 thru 0x41ac9	(0x31b3 bytes)
6219154(146 mod 256): COPY 0x13368 thru 0x1c5c0	(0x9259 bytes) to 0x6fb11 thru 0x78d69
6219155(147 mod 256): TRUNCATE DOWN	from 0x90172 to 0x361e6	******WWWW
6219156(148 mod 256): FALLOC   0x54707 thru 0x6771e	(0x13017 bytes) EXTENDING
6219157(149 mod 256): ZERO     0x51b60 thru 0x6dc2e	(0x1c0cf bytes)
6219158(150 mod 256): READ     0x60419 thru 0x6771d	(0x7305 bytes)
6219159(151 mod 256): COPY 0x432c0 thru 0x4f67f	(0xc3c0 bytes) to 0xe717 thru 0x1aad6
6219160(152 mod 256): READ     0x5f5d7 thru 0x61434	(0x1e5e bytes)
6219161(153 mod 256): READ     0x9bf8 thru 0x23fbe	(0x1a3c7 bytes)
6219162(154 mod 256): PUNCH    0x23229 thru 0x39d22	(0x16afa bytes)
6219163(155 mod 256): MAPWRITE 0x7044 thru 0x1bcb3	(0x14c70 bytes)
6219164(156 mod 256): CLONE 0x3000 thru 0x1efff	(0x1c000 bytes) to 0x39000 thru 0x54fff
6219165(157 mod 256): ZERO     0x904a7 thru 0x927bf	(0x2319 bytes)
6219166(158 mod 256): DEDUPE 0x20000 thru 0x27fff	(0x8000 bytes) to 0xd000 thru 0x14fff
6219167(159 mod 256): CLONE 0x4f000 thru 0x66fff	(0x18000 bytes) to 0x6c000 thru 0x83fff	******JJJJ
6219168(160 mod 256): TRUNCATE DOWN	from 0x84000 to 0xb0d2	******WWWW
6219169(161 mod 256): INSERT 0x0 thru 0xbfff	(0xc000 bytes)
6219170(162 mod 256): COLLAPSE 0xa000 thru 0x15fff	(0xc000 bytes)
6219171(163 mod 256): CLONE 0x5000 thru 0x9fff	(0x5000 bytes) to 0x40000 thru 0x44fff
6219172(164 mod 256): TRUNCATE DOWN	from 0x45000 to 0x9074
6219173(165 mod 256): WRITE    0x50fd thru 0xb6bd	(0x65c1 bytes) EXTEND
6219174(166 mod 256): FALLOC   0x35653 thru 0x541ae	(0x1eb5b bytes) PAST_EOF
6219175(167 mod 256): COPY 0x651 thru 0xb6bd	(0xb06d bytes) to 0x1f70d thru 0x2a779
6219176(168 mod 256): WRITE    0x1d621 thru 0x2fb0e	(0x124ee bytes) EXTEND
6219177(169 mod 256): FALLOC   0x3816e thru 0x55035	(0x1cec7 bytes) PAST_EOF
6219178(170 mod 256): DEDUPE 0xe000 thru 0xefff	(0x1000 bytes) to 0x1f000 thru 0x1ffff
6219179(171 mod 256): ZERO     0x60bd5 thru 0x76958	(0x15d84 bytes)	******ZZZZ
6219180(172 mod 256): PUNCH    0x23736 thru 0x2fb0e	(0xc3d9 bytes)
6219181(173 mod 256): DEDUPE 0x1a000 thru 0x1dfff	(0x4000 bytes) to 0xd000 thru 0x10fff
6219182(174 mod 256): MAPWRITE 0x69c0e thru 0x6bf7c	(0x236f bytes)
6219183(175 mod 256): TRUNCATE DOWN	from 0x6bf7d to 0x23700
6219184(176 mod 256): COLLAPSE 0x3000 thru 0xbfff	(0x9000 bytes)
6219185(177 mod 256): FALLOC   0x3683e thru 0x4cc43	(0x16405 bytes) EXTENDING
6219186(178 mod 256): SKIPPED (no operation)
6219187(179 mod 256): TRUNCATE UP	from 0x4cc43 to 0x827de	******WWWW
6219188(180 mod 256): WRITE    0x2865 thru 0x417d	(0x1919 bytes)
6219189(181 mod 256): TRUNCATE DOWN	from 0x827de to 0x247a6	******WWWW
6219190(182 mod 256): COPY 0x1c370 thru 0x247a5	(0x8436 bytes) to 0x7cced thru 0x85122
6219191(183 mod 256): INSERT 0x41000 thru 0x4cfff	(0xc000 bytes)
6219192(184 mod 256): TRUNCATE DOWN	from 0x91123 to 0x1a0e3	******WWWW
6219193(185 mod 256): READ     0xf15f thru 0x1a0e2	(0xaf84 bytes)
6219194(186 mod 256): MAPWRITE 0x62e9d thru 0x71557	(0xe6bb bytes)	******WWWW
6219195(187 mod 256): COLLAPSE 0x61000 thru 0x6afff	(0xa000 bytes)
6219196(188 mod 256): PUNCH    0x4fa94 thru 0x5d703	(0xdc70 bytes)
6219197(189 mod 256): PUNCH    0x56af9 thru 0x5e7f7	(0x7cff bytes)
6219198(190 mod 256): INSERT 0x1f000 thru 0x3afff	(0x1c000 bytes)
6219199(191 mod 256): PUNCH    0x516ce thru 0x56090	(0x49c3 bytes)
6219200(192 mod 256): MAPWRITE 0x4976e thru 0x5cbd0	(0x13463 bytes)
6219201(193 mod 256): COLLAPSE 0x38000 thru 0x4cfff	(0x15000 bytes)
6219202(194 mod 256): MAPWRITE 0x73fc7 thru 0x7bf63	(0x7f9d bytes)
6219203(195 mod 256): WRITE    0x866e6 thru 0x927bf	(0xc0da bytes) HOLE
6219204(196 mod 256): MAPWRITE 0x32d61 thru 0x43333	(0x105d3 bytes)
6219205(197 mod 256): DEDUPE 0x3b000 thru 0x45fff	(0xb000 bytes) to 0x7a000 thru 0x84fff
6219206(198 mod 256): COLLAPSE 0x77000 thru 0x8ffff	(0x19000 bytes)
6219207(199 mod 256): WRITE    0x8e902 thru 0x927bf	(0x3ebe bytes) HOLE
6219208(200 mod 256): PUNCH    0x69ec1 thru 0x80bf6	(0x16d36 bytes)	******PPPP
6219209(201 mod 256): DEDUPE 0x17000 thru 0x23fff	(0xd000 bytes) to 0x6c000 thru 0x78fff	******BBBB
6219210(202 mod 256): SKIPPED (no operation)
6219211(203 mod 256): FALLOC   0x8a116 thru 0x8e7f2	(0x46dc bytes) INTERIOR
6219212(204 mod 256): COPY 0x4b816 thru 0x613cb	(0x15bb6 bytes) to 0x22e2 thru 0x17e97
6219213(205 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xa14e	******WWWW
6219214(206 mod 256): FALLOC   0x6c722 thru 0x7fe0e	(0x136ec bytes) PAST_EOF	******FFFF
6219215(207 mod 256): PUNCH    0x8d5 thru 0xa14d	(0x9879 bytes)
6219216(208 mod 256): COPY 0x58d thru 0x5324	(0x4d98 bytes) to 0x56845 thru 0x5b5dc
6219217(209 mod 256): SKIPPED (no operation)
6219218(210 mod 256): SKIPPED (no operation)
6219219(211 mod 256): COPY 0x2ce0e thru 0x32751	(0x5944 bytes) to 0x67018 thru 0x6c95b
6219220(212 mod 256): DEDUPE 0x32000 thru 0x4afff	(0x19000 bytes) to 0x4f000 thru 0x67fff
6219221(213 mod 256): DEDUPE 0xd000 thru 0x13fff	(0x7000 bytes) to 0x35000 thru 0x3bfff
6219222(214 mod 256): PUNCH    0x184a5 thru 0x1befd	(0x3a59 bytes)
6219223(215 mod 256): COPY 0x3a476 thru 0x4cacd	(0x12658 bytes) to 0x4ccd6 thru 0x5f32d
6219224(216 mod 256): COPY 0x4fa42 thru 0x6a0e0	(0x1a69f bytes) to 0xa4e1 thru 0x24b7f
6219225(217 mod 256): TRUNCATE DOWN	from 0x6c95c to 0x3c237
6219226(218 mod 256): COPY 0x2e852 thru 0x3a047	(0xb7f6 bytes) to 0xeaca thru 0x1a2bf
6219227(219 mod 256): ZERO     0x6e589 thru 0x8b150	(0x1cbc8 bytes)	******ZZZZ
6219228(220 mod 256): ZERO     0xd8ec thru 0x1e646	(0x10d5b bytes)
6219229(221 mod 256): SKIPPED (no operation)
6219230(222 mod 256): MAPWRITE 0x56dbe thru 0x688e0	(0x11b23 bytes)
6219231(223 mod 256): MAPREAD  0x882c4 thru 0x8b150	(0x2e8d bytes)
6219232(224 mod 256): DEDUPE 0x5d000 thru 0x76fff	(0x1a000 bytes) to 0x16000 thru 0x2ffff	BBBB******
6219233(225 mod 256): FALLOC   0x2ad8b thru 0x40305	(0x1557a bytes) INTERIOR
6219234(226 mod 256): DEDUPE 0x11000 thru 0x26fff	(0x16000 bytes) to 0x52000 thru 0x67fff
6219235(227 mod 256): ZERO     0x2c439 thru 0x2e198	(0x1d60 bytes)
6219236(228 mod 256): COLLAPSE 0x3d000 thru 0x58fff	(0x1c000 bytes)
6219237(229 mod 256): MAPREAD  0x241a5 thru 0x3545c	(0x112b8 bytes)
6219238(230 mod 256): MAPREAD  0x327e thru 0x13710	(0x10493 bytes)
6219239(231 mod 256): WRITE    0x7d711 thru 0x927bf	(0x150af bytes) HOLE
6219240(232 mod 256): DEDUPE 0x8000 thru 0x19fff	(0x12000 bytes) to 0x21000 thru 0x32fff
6219241(233 mod 256): WRITE    0x22285 thru 0x2f868	(0xd5e4 bytes)
6219242(234 mod 256): DEDUPE 0x67000 thru 0x70fff	(0xa000 bytes) to 0x84000 thru 0x8dfff	BBBB******
6219243(235 mod 256): ZERO     0x11346 thru 0x271f8	(0x15eb3 bytes)
6219244(236 mod 256): WRITE    0x3e02e thru 0x55b0b	(0x17ade bytes)
6219245(237 mod 256): MAPREAD  0x19d41 thru 0x2c23d	(0x124fd bytes)
6219246(238 mod 256): SKIPPED (no operation)
6219247(239 mod 256): SKIPPED (no operation)
6219248(240 mod 256): MAPWRITE 0x3a4fa thru 0x5579b	(0x1b2a2 bytes)
6219249(241 mod 256): PUNCH    0xf055 thru 0x1bcea	(0xcc96 bytes)
6219250(242 mod 256): FALLOC   0x32afa thru 0x33286	(0x78c bytes) INTERIOR
6219251(243 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8ca4d
6219252(244 mod 256): COLLAPSE 0x6c000 thru 0x70fff	(0x5000 bytes)	******CCCC
6219253(245 mod 256): COPY 0x25720 thru 0x277b1	(0x2092 bytes) to 0x42298 thru 0x44329
6219254(246 mod 256): CLONE 0x32000 thru 0x33fff	(0x2000 bytes) to 0x41000 thru 0x42fff
6219255(247 mod 256): COLLAPSE 0x7e000 thru 0x86fff	(0x9000 bytes)
6219256(248 mod 256): MAPREAD  0x31b8f thru 0x33b9e	(0x2010 bytes)
6219257(249 mod 256): ZERO     0x143f8 thru 0x1bfee	(0x7bf7 bytes)
6219258(250 mod 256): COPY 0x36c0e thru 0x52b1c	(0x1bf0f bytes) to 0x5d304 thru 0x79212	******EEEE
6219259(251 mod 256): READ     0x17ff9 thru 0x2d84f	(0x15857 bytes)
6219260(252 mod 256): FALLOC   0x77284 thru 0x87126	(0xfea2 bytes) EXTENDING
6219261(253 mod 256): ZERO     0xd812 thru 0x1e289	(0x10a78 bytes)
6219262(254 mod 256): COLLAPSE 0x3c000 thru 0x3efff	(0x3000 bytes)
6219263(255 mod 256): COPY 0x34e88 thru 0x4f940	(0x1aab9 bytes) to 0x3414 thru 0x1decc
6219264(  0 mod 256): ZERO     0x1e0b7 thru 0x250c0	(0x700a bytes)
6219265(  1 mod 256): SKIPPED (no operation)
6219266(  2 mod 256): WRITE    0x4f24d thru 0x6984a	(0x1a5fe bytes)
6219267(  3 mod 256): SKIPPED (no operation)
6219268(  4 mod 256): ZERO     0xebf5 thru 0x25c66	(0x17072 bytes)
6219269(  5 mod 256): COPY 0x5a750 thru 0x5da54	(0x3305 bytes) to 0x68189 thru 0x6b48d
6219270(  6 mod 256): MAPREAD  0x4a209 thru 0x53ce1	(0x9ad9 bytes)
6219271(  7 mod 256): WRITE    0x18b9 thru 0x145d7	(0x12d1f bytes)
6219272(  8 mod 256): MAPWRITE 0x6e2f2 thru 0x6fb51	(0x1860 bytes)	******WWWW
6219273(  9 mod 256): MAPREAD  0x60cb1 thru 0x797fe	(0x18b4e bytes)	***RRRR***
6219274( 10 mod 256): FALLOC   0x84265 thru 0x927c0	(0xe55b bytes) EXTENDING
6219275( 11 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2e9c7	******WWWW
6219276( 12 mod 256): SKIPPED (no operation)
6219277( 13 mod 256): TRUNCATE UP	from 0x2e9c7 to 0x86174	******WWWW
6219278( 14 mod 256): DEDUPE 0x4d000 thru 0x5efff	(0x12000 bytes) to 0x5000 thru 0x16fff
6219279( 15 mod 256): READ     0x23d0d thru 0x2e9de	(0xacd2 bytes)
6219280( 16 mod 256): TRUNCATE DOWN	from 0x86174 to 0x4fa6c	******WWWW
6219281( 17 mod 256): FALLOC   0x10497 thru 0x1ca86	(0xc5ef bytes) INTERIOR
6219282( 18 mod 256): SKIPPED (no operation)
6219283( 19 mod 256): WRITE    0x30ea1 thru 0x3ff9c	(0xf0fc bytes)
6219284( 20 mod 256): WRITE    0x21a92 thru 0x352ee	(0x1385d bytes)
6219285( 21 mod 256): SKIPPED (no operation)
6219286( 22 mod 256): DEDUPE 0x22000 thru 0x2efff	(0xd000 bytes) to 0xe000 thru 0x1afff
6219287( 23 mod 256): SKIPPED (no operation)
6219288( 24 mod 256): ZERO     0x8198d thru 0x927bf	(0x10e33 bytes)
6219289( 25 mod 256): PUNCH    0x4bd52 thru 0x66a42	(0x1acf1 bytes)
6219290( 26 mod 256): SKIPPED (no operation)
6219291( 27 mod 256): CLONE 0x19000 thru 0x34fff	(0x1c000 bytes) to 0x60000 thru 0x7bfff	******JJJJ
6219292( 28 mod 256): SKIPPED (no operation)
6219293( 29 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1747	******WWWW
6219294( 30 mod 256): SKIPPED (no operation)
6219295( 31 mod 256): COPY 0x10a9 thru 0x1746	(0x69e bytes) to 0x3e294 thru 0x3e931
6219296( 32 mod 256): MAPWRITE 0x4b2f thru 0x1c85e	(0x17d30 bytes)
6219297( 33 mod 256): ZERO     0x362f3 thru 0x4b729	(0x15437 bytes)
6219298( 34 mod 256): MAPREAD  0x1617f thru 0x33a1a	(0x1d89c bytes)
6219299( 35 mod 256): MAPREAD  0xe4d9 thru 0x1368c	(0x51b4 bytes)
6219300( 36 mod 256): SKIPPED (no operation)
6219301( 37 mod 256): CLONE 0x49000 thru 0x4afff	(0x2000 bytes) to 0x7000 thru 0x8fff
6219302( 38 mod 256): SKIPPED (no operation)
6219303( 39 mod 256): MAPWRITE 0x16f64 thru 0x17d0a	(0xda7 bytes)
6219304( 40 mod 256): CLONE 0x14000 thru 0x30fff	(0x1d000 bytes) to 0x3f000 thru 0x5bfff
6219305( 41 mod 256): COPY 0x1ada8 thru 0x392a4	(0x1e4fd bytes) to 0x65729 thru 0x83c25	******EEEE
6219306( 42 mod 256): WRITE    0x5aa1a thru 0x75058	(0x1a63f bytes)	***WWWW
6219307( 43 mod 256): PUNCH    0x2b316 thru 0x4073c	(0x15427 bytes)
6219308( 44 mod 256): PUNCH    0x5b5f0 thru 0x72551	(0x16f62 bytes)	******PPPP
6219309( 45 mod 256): CLONE 0x3b000 thru 0x53fff	(0x19000 bytes) to 0x68000 thru 0x80fff	******JJJJ
6219310( 46 mod 256): COPY 0x7063 thru 0x7f4a	(0xee8 bytes) to 0x48242 thru 0x49129
6219311( 47 mod 256): WRITE    0x1e945 thru 0x334d4	(0x14b90 bytes)
6219312( 48 mod 256): ZERO     0x2d182 thru 0x2ea4d	(0x18cc bytes)
6219313( 49 mod 256): MAPREAD  0x5f726 thru 0x7649e	(0x16d79 bytes)	***RRRR***
6219314( 50 mod 256): FALLOC   0x18d7a thru 0x1e97a	(0x5c00 bytes) INTERIOR
6219315( 51 mod 256): PUNCH    0x151ec thru 0x2e76a	(0x1957f bytes)
6219316( 52 mod 256): CLONE 0x4f000 thru 0x62fff	(0x14000 bytes) to 0xd000 thru 0x20fff
6219317( 53 mod 256): ZERO     0xc5a5 thru 0xdaf4	(0x1550 bytes)
6219318( 54 mod 256): MAPWRITE 0x8c329 thru 0x927bf	(0x6497 bytes)
6219319( 55 mod 256): DEDUPE 0x51000 thru 0x58fff	(0x8000 bytes) to 0x5b000 thru 0x62fff
6219320( 56 mod 256): ZERO     0x1def2 thru 0x393bc	(0x1b4cb bytes)
6219321( 57 mod 256): FALLOC   0x6c905 thru 0x7caa7	(0x101a2 bytes) INTERIOR	******FFFF
6219322( 58 mod 256): WRITE    0x880d4 thru 0x8d20b	(0x5138 bytes)
6219323( 59 mod 256): MAPREAD  0x1c120 thru 0x20955	(0x4836 bytes)
6219324( 60 mod 256): PUNCH    0x796f2 thru 0x7ca74	(0x3383 bytes)
6219325( 61 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5bc80	******WWWW
6219326( 62 mod 256): MAPWRITE 0x87de9 thru 0x92285	(0xa49d bytes)
6219327( 63 mod 256): TRUNCATE DOWN	from 0x92286 to 0x3a220	******WWWW
6219328( 64 mod 256): INSERT 0x39000 thru 0x4efff	(0x16000 bytes)
6219329( 65 mod 256): PUNCH    0x2d349 thru 0x4064d	(0x13305 bytes)
6219330( 66 mod 256): MAPREAD  0x2728f thru 0x39205	(0x11f77 bytes)
6219331( 67 mod 256): SKIPPED (no operation)
6219332( 68 mod 256): ZERO     0x2a96d thru 0x3c371	(0x11a05 bytes)
6219333( 69 mod 256): SKIPPED (no operation)
6219334( 70 mod 256): ZERO     0x3ab70 thru 0x49ede	(0xf36f bytes)
6219335( 71 mod 256): DEDUPE 0x3d000 thru 0x4bfff	(0xf000 bytes) to 0xa000 thru 0x18fff
6219336( 72 mod 256): COPY 0x3dfaa thru 0x415cf	(0x3626 bytes) to 0x84ca9 thru 0x882ce
6219337( 73 mod 256): ZERO     0x64b5c thru 0x79346	(0x147eb bytes)	******ZZZZ
6219338( 74 mod 256): INSERT 0x60000 thru 0x69fff	(0xa000 bytes)
6219339( 75 mod 256): WRITE    0x5953c thru 0x66eb3	(0xd978 bytes)
6219340( 76 mod 256): CLONE 0x37000 thru 0x3ffff	(0x9000 bytes) to 0x81000 thru 0x89fff
6219341( 77 mod 256): FALLOC   0x2b46d thru 0x329bf	(0x7552 bytes) INTERIOR
6219342( 78 mod 256): COLLAPSE 0x6e000 thru 0x6efff	(0x1000 bytes)	******CCCC
6219343( 79 mod 256): INSERT 0x11000 thru 0x11fff	(0x1000 bytes)
6219344( 80 mod 256): WRITE    0xa187 thru 0x1cb52	(0x129cc bytes)
6219345( 81 mod 256): SKIPPED (no operation)
6219346( 82 mod 256): PUNCH    0x200f2 thru 0x22abd	(0x29cc bytes)
6219347( 83 mod 256): MAPREAD  0x57487 thru 0x6d708	(0x16282 bytes)
6219348( 84 mod 256): SKIPPED (no operation)
6219349( 85 mod 256): MAPREAD  0x350a7 thru 0x50239	(0x1b193 bytes)
6219350( 86 mod 256): TRUNCATE DOWN	from 0x922cf to 0x73aeb
6219351( 87 mod 256): MAPREAD  0x5c479 thru 0x61864	(0x53ec bytes)
6219352( 88 mod 256): PUNCH    0x72270 thru 0x73aea	(0x187b bytes)
6219353( 89 mod 256): WRITE    0x6efc2 thru 0x7bfa1	(0xcfe0 bytes) EXTEND	***WWWW
6219354( 90 mod 256): INSERT 0x41000 thru 0x54fff	(0x14000 bytes)
6219355( 91 mod 256): MAPREAD  0x45879 thru 0x64adb	(0x1f263 bytes)
6219356( 92 mod 256): READ     0x6d1c thru 0xdd3c	(0x7021 bytes)
6219357( 93 mod 256): READ     0x2a7e1 thru 0x3a818	(0x10038 bytes)
6219358( 94 mod 256): COPY 0x74954 thru 0x8ffa1	(0x1b64e bytes) to 0x3515d thru 0x507aa
6219359( 95 mod 256): FALLOC   0x2b3b7 thru 0x32a76	(0x76bf bytes) INTERIOR
6219360( 96 mod 256): CLONE 0x29000 thru 0x3ffff	(0x17000 bytes) to 0x40000 thru 0x56fff
6219361( 97 mod 256): COPY 0x1bd90 thru 0x29484	(0xd6f5 bytes) to 0x42f75 thru 0x50669
6219362( 98 mod 256): SKIPPED (no operation)
6219363( 99 mod 256): CLONE 0x8000 thru 0x1bfff	(0x14000 bytes) to 0x7c000 thru 0x8ffff
6219364(100 mod 256): TRUNCATE DOWN	from 0x90000 to 0x5abdc	******WWWW
6219365(101 mod 256): READ     0x20846 thru 0x3bfaa	(0x1b765 bytes)
6219366(102 mod 256): COLLAPSE 0x4000 thru 0x16fff	(0x13000 bytes)
6219367(103 mod 256): COLLAPSE 0x5000 thru 0x12fff	(0xe000 bytes)
6219368(104 mod 256): DEDUPE 0x4000 thru 0x11fff	(0xe000 bytes) to 0x29000 thru 0x36fff
6219369(105 mod 256): COPY 0x1412d thru 0x1af22	(0x6df6 bytes) to 0x73125 thru 0x79f1a
6219370(106 mod 256): ZERO     0xb7fa thru 0xfe6d	(0x4674 bytes)
6219371(107 mod 256): SKIPPED (no operation)
6219372(108 mod 256): DEDUPE 0x1b000 thru 0x30fff	(0x16000 bytes) to 0x39000 thru 0x4efff
6219373(109 mod 256): DEDUPE 0x42000 thru 0x4cfff	(0xb000 bytes) to 0x2d000 thru 0x37fff
6219374(110 mod 256): ZERO     0x8312a thru 0x8b62b	(0x8502 bytes)
6219375(111 mod 256): ZERO     0x87887 thru 0x8ddbc	(0x6536 bytes)
6219376(112 mod 256): FALLOC   0x28878 thru 0x35699	(0xce21 bytes) INTERIOR
6219377(113 mod 256): SKIPPED (no operation)
6219378(114 mod 256): COLLAPSE 0x12000 thru 0x21fff	(0x10000 bytes)
6219379(115 mod 256): COLLAPSE 0x3c000 thru 0x54fff	(0x19000 bytes)
6219380(116 mod 256): COLLAPSE 0x4d000 thru 0x4ffff	(0x3000 bytes)
6219381(117 mod 256): COLLAPSE 0x9000 thru 0x25fff	(0x1d000 bytes)
6219382(118 mod 256): TRUNCATE UP	from 0x30f1b to 0x5f813
6219383(119 mod 256): PUNCH    0x574fb thru 0x5da43	(0x6549 bytes)
6219384(120 mod 256): COPY 0x8218 thru 0x1c55e	(0x14347 bytes) to 0x1d4e7 thru 0x3182d
6219385(121 mod 256): DEDUPE 0x3e000 thru 0x59fff	(0x1c000 bytes) to 0x1e000 thru 0x39fff
6219386(122 mod 256): ZERO     0x49c1c thru 0x6748d	(0x1d872 bytes)
6219387(123 mod 256): FALLOC   0x46035 thru 0x5d6ba	(0x17685 bytes) INTERIOR
6219388(124 mod 256): MAPWRITE 0x705fa thru 0x7c5e1	(0xbfe8 bytes)
6219389(125 mod 256): FALLOC   0x424bd thru 0x58f05	(0x16a48 bytes) INTERIOR
6219390(126 mod 256): MAPREAD  0x76a4a thru 0x7c5e1	(0x5b98 bytes)
6219391(127 mod 256): CLONE 0x3c000 thru 0x52fff	(0x17000 bytes) to 0x6b000 thru 0x81fff	******JJJJ
6219392(128 mod 256): WRITE    0x7f3ad thru 0x90a42	(0x11696 bytes) EXTEND
6219393(129 mod 256): ZERO     0x1520e thru 0x2cf45	(0x17d38 bytes)
6219394(130 mod 256): COPY 0x3a498 thru 0x52bdb	(0x18744 bytes) to 0x6d240 thru 0x85983	******EEEE
6219395(131 mod 256): COPY 0xe935 thru 0x11ac9	(0x3195 bytes) to 0x723a6 thru 0x7553a
6219396(132 mod 256): PUNCH    0x8328 thru 0x13b93	(0xb86c bytes)
6219397(133 mod 256): TRUNCATE DOWN	from 0x90a43 to 0xef9a	******WWWW
6219398(134 mod 256): MAPREAD  0x2025 thru 0xef99	(0xcf75 bytes)
6219399(135 mod 256): TRUNCATE UP	from 0xef9a to 0x844c9	******WWWW
6219400(136 mod 256): CLONE 0x9000 thru 0x25fff	(0x1d000 bytes) to 0x35000 thru 0x51fff
6219401(137 mod 256): DEDUPE 0x2c000 thru 0x43fff	(0x18000 bytes) to 0x14000 thru 0x2bfff
6219402(138 mod 256): READ     0x649d0 thru 0x7a4ec	(0x15b1d bytes)	***RRRR***
6219403(139 mod 256): COLLAPSE 0x3a000 thru 0x46fff	(0xd000 bytes)
6219404(140 mod 256): TRUNCATE DOWN	from 0x774c9 to 0x50cc9	******WWWW
6219405(141 mod 256): DEDUPE 0x23000 thru 0x30fff	(0xe000 bytes) to 0x11000 thru 0x1efff
6219406(142 mod 256): TRUNCATE DOWN	from 0x50cc9 to 0x37c68
6219407(143 mod 256): COLLAPSE 0xd000 thru 0x23fff	(0x17000 bytes)
6219408(144 mod 256): MAPWRITE 0x2b35b thru 0x33628	(0x82ce bytes)
6219409(145 mod 256): SKIPPED (no operation)
6219410(146 mod 256): PUNCH    0xdceb thru 0x238cf	(0x15be5 bytes)
6219411(147 mod 256): INSERT 0x11000 thru 0x11fff	(0x1000 bytes)
6219412(148 mod 256): COPY 0x9f35 thru 0x1cbb1	(0x12c7d bytes) to 0x70431 thru 0x830ad
6219413(149 mod 256): FALLOC   0x4353c thru 0x5e71a	(0x1b1de bytes) INTERIOR
6219414(150 mod 256): COPY 0x6d3ae thru 0x74484	(0x70d7 bytes) to 0x34986 thru 0x3ba5c	EEEE******
6219415(151 mod 256): ZERO     0x164a6 thru 0x23050	(0xcbab bytes)
6219416(152 mod 256): TRUNCATE DOWN	from 0x830ae to 0x48c10	******WWWW
6219417(153 mod 256): PUNCH    0x6fb6 thru 0x8e4b	(0x1e96 bytes)
6219418(154 mod 256): TRUNCATE DOWN	from 0x48c10 to 0x2a13f
6219419(155 mod 256): WRITE    0x72e7d thru 0x8e0b2	(0x1b236 bytes) HOLE	***WWWW
6219420(156 mod 256): COLLAPSE 0x23000 thru 0x28fff	(0x6000 bytes)
6219421(157 mod 256): CLONE 0x26000 thru 0x2cfff	(0x7000 bytes) to 0x3a000 thru 0x40fff
6219422(158 mod 256): MAPREAD  0x2ab0a thru 0x3dfbd	(0x134b4 bytes)
6219423(159 mod 256): TRUNCATE DOWN	from 0x880b3 to 0x147fc	******WWWW
6219424(160 mod 256): FALLOC   0x5272e thru 0x57619	(0x4eeb bytes) EXTENDING
6219425(161 mod 256): MAPREAD  0xfdfe thru 0x25b96	(0x15d99 bytes)
6219426(162 mod 256): ZERO     0x585ea thru 0x61028	(0x8a3f bytes)
6219427(163 mod 256): MAPREAD  0x46688 thru 0x57618	(0x10f91 bytes)
6219428(164 mod 256): FALLOC   0x64598 thru 0x834c8	(0x1ef30 bytes) EXTENDING	******FFFF
6219429(165 mod 256): MAPWRITE 0x4016a thru 0x4ecbf	(0xeb56 bytes)
6219430(166 mod 256): CLONE 0x1000 thru 0xcfff	(0xc000 bytes) to 0x21000 thru 0x2cfff
6219431(167 mod 256): COPY 0x4819e thru 0x5bc64	(0x13ac7 bytes) to 0x5e83b thru 0x72301	******EEEE
6219432(168 mod 256): ZERO     0x4de8 thru 0x5deb	(0x1004 bytes)
6219433(169 mod 256): INSERT 0x72000 thru 0x7afff	(0x9000 bytes)
6219434(170 mod 256): TRUNCATE DOWN	from 0x8c4c8 to 0x5b0d9	******WWWW
6219435(171 mod 256): MAPWRITE 0x86696 thru 0x927bf	(0xc12a bytes)
6219436(172 mod 256): PUNCH    0x5737 thru 0x1829c	(0x12b66 bytes)
6219437(173 mod 256): FALLOC   0x46a14 thru 0x504ea	(0x9ad6 bytes) INTERIOR
6219438(174 mod 256): PUNCH    0x2d82e thru 0x44911	(0x170e4 bytes)
6219439(175 mod 256): COPY 0x5c73d thru 0x5e696	(0x1f5a bytes) to 0x258f0 thru 0x27849
6219440(176 mod 256): READ     0x2c767 thru 0x4605c	(0x198f6 bytes)
6219441(177 mod 256): SKIPPED (no operation)
6219442(178 mod 256): WRITE    0x1c5c6 thru 0x209bb	(0x43f6 bytes)
6219443(179 mod 256): WRITE    0x58ef7 thru 0x5f5c4	(0x66ce bytes)
6219444(180 mod 256): DEDUPE 0x7a000 thru 0x90fff	(0x17000 bytes) to 0xc000 thru 0x22fff
6219445(181 mod 256): COLLAPSE 0x75000 thru 0x78fff	(0x4000 bytes)
6219446(182 mod 256): COLLAPSE 0xa000 thru 0x24fff	(0x1b000 bytes)
6219447(183 mod 256): MAPREAD  0x54cc thru 0x10154	(0xac89 bytes)
6219448(184 mod 256): INSERT 0x1a000 thru 0x2dfff	(0x14000 bytes)
6219449(185 mod 256): COPY 0x43303 thru 0x44b1b	(0x1819 bytes) to 0x88e90 thru 0x8a6a8
6219450(186 mod 256): PUNCH    0x65a8f thru 0x7a451	(0x149c3 bytes)	******PPPP
6219451(187 mod 256): WRITE    0x222c thru 0x1c06e	(0x19e43 bytes)
6219452(188 mod 256): COLLAPSE 0x1e000 thru 0x31fff	(0x14000 bytes)
6219453(189 mod 256): MAPWRITE 0x4d89c thru 0x5cb52	(0xf2b7 bytes)
6219454(190 mod 256): INSERT 0x3c000 thru 0x57fff	(0x1c000 bytes)
6219455(191 mod 256): CLONE 0x43000 thru 0x58fff	(0x16000 bytes) to 0x7a000 thru 0x8ffff
6219456(192 mod 256): MAPREAD  0x2b6f0 thru 0x2ef36	(0x3847 bytes)
6219457(193 mod 256): READ     0x3b6af thru 0x4ec36	(0x13588 bytes)
6219458(194 mod 256): SKIPPED (no operation)
6219459(195 mod 256): MAPWRITE 0x6c513 thru 0x7e59e	(0x1208c bytes)	******WWWW
6219460(196 mod 256): CLONE 0x46000 thru 0x52fff	(0xd000 bytes) to 0x5a000 thru 0x66fff
6219461(197 mod 256): CLONE 0x8c000 thru 0x8efff	(0x3000 bytes) to 0x76000 thru 0x78fff
6219462(198 mod 256): COLLAPSE 0x1000 thru 0x14fff	(0x14000 bytes)
6219463(199 mod 256): INSERT 0xf000 thru 0x22fff	(0x14000 bytes)
6219464(200 mod 256): SKIPPED (no operation)
6219465(201 mod 256): READ     0x409aa thru 0x43801	(0x2e58 bytes)
6219466(202 mod 256): DEDUPE 0x3d000 thru 0x58fff	(0x1c000 bytes) to 0x5e000 thru 0x79fff	******BBBB
6219467(203 mod 256): SKIPPED (no operation)
6219468(204 mod 256): MAPWRITE 0x6a5d1 thru 0x7702d	(0xca5d bytes)	******WWWW
6219469(205 mod 256): READ     0x57dcc thru 0x5f838	(0x7a6d bytes)
6219470(206 mod 256): READ     0x67e9e thru 0x6a94c	(0x2aaf bytes)
6219471(207 mod 256): CLONE 0x2d000 thru 0x30fff	(0x4000 bytes) to 0x7000 thru 0xafff
6219472(208 mod 256): CLONE 0x84000 thru 0x90fff	(0xd000 bytes) to 0x4b000 thru 0x57fff
6219473(209 mod 256): SKIPPED (no operation)
6219474(210 mod 256): MAPREAD  0x31984 thru 0x4ef70	(0x1d5ed bytes)
6219475(211 mod 256): DEDUPE 0x1000 thru 0x1afff	(0x1a000 bytes) to 0x37000 thru 0x50fff
6219476(212 mod 256): READ     0x6d943 thru 0x7f682	(0x11d40 bytes)	***RRRR***
6219477(213 mod 256): MAPREAD  0x30e8 thru 0x78d3	(0x47ec bytes)
6219478(214 mod 256): TRUNCATE DOWN	from 0x926a9 to 0x2b1c7	******WWWW
6219479(215 mod 256): INSERT 0x16000 thru 0x1afff	(0x5000 bytes)
6219480(216 mod 256): READ     0x2e2c4 thru 0x301c6	(0x1f03 bytes)
6219481(217 mod 256): TRUNCATE DOWN	from 0x301c7 to 0x49ab
6219482(218 mod 256): PUNCH    0x3169 thru 0x49aa	(0x1842 bytes)
6219483(219 mod 256): WRITE    0x2f679 thru 0x3cebe	(0xd846 bytes) HOLE
6219484(220 mod 256): MAPWRITE 0x8a435 thru 0x8ff6e	(0x5b3a bytes)
6219485(221 mod 256): FALLOC   0x2646c thru 0x26d0d	(0x8a1 bytes) INTERIOR
6219486(222 mod 256): DEDUPE 0x23000 thru 0x33fff	(0x11000 bytes) to 0x4b000 thru 0x5bfff
6219487(223 mod 256): CLONE 0x39000 thru 0x40fff	(0x8000 bytes) to 0x1c000 thru 0x23fff
6219488(224 mod 256): FALLOC   0x7ca0e thru 0x915da	(0x14bcc bytes) EXTENDING
6219489(225 mod 256): MAPWRITE 0x5b9b2 thru 0x6bd3d	(0x1038c bytes)
6219490(226 mod 256): ZERO     0x67199 thru 0x70bdb	(0x9a43 bytes)	******ZZZZ
6219491(227 mod 256): READ     0x4e90b thru 0x5315a	(0x4850 bytes)
6219492(228 mod 256): TRUNCATE DOWN	from 0x915da to 0x75c71
6219493(229 mod 256): MAPREAD  0x67aaf thru 0x75c70	(0xe1c2 bytes)	***RRRR***
6219494(230 mod 256): CLONE 0x2000 thru 0x12fff	(0x11000 bytes) to 0x3a000 thru 0x4afff
6219495(231 mod 256): COLLAPSE 0x49000 thru 0x5bfff	(0x13000 bytes)
6219496(232 mod 256): ZERO     0x8de2f thru 0x927bf	(0x4991 bytes)
6219497(233 mod 256): READ     0x429fc thru 0x5ddc8	(0x1b3cd bytes)
6219498(234 mod 256): PUNCH    0x2e5b4 thru 0x404e6	(0x11f33 bytes)
6219499(235 mod 256): WRITE    0x17ffb thru 0x22a35	(0xaa3b bytes)
6219500(236 mod 256): SKIPPED (no operation)
6219501(237 mod 256): WRITE    0xb280 thru 0x23e75	(0x18bf6 bytes)
6219502(238 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x3f84a	******WWWW
6219503(239 mod 256): SKIPPED (no operation)
6219504(240 mod 256): INSERT 0x25000 thru 0x32fff	(0xe000 bytes)
6219505(241 mod 256): INSERT 0x40000 thru 0x57fff	(0x18000 bytes)
6219506(242 mod 256): DEDUPE 0x13000 thru 0x26fff	(0x14000 bytes) to 0x44000 thru 0x57fff
6219507(243 mod 256): COLLAPSE 0x44000 thru 0x56fff	(0x13000 bytes)
6219508(244 mod 256): TRUNCATE UP	from 0x5284a to 0x79f36	******WWWW
6219509(245 mod 256): COLLAPSE 0x7000 thru 0x25fff	(0x1f000 bytes)
6219510(246 mod 256): PUNCH    0x1a23d thru 0x36b57	(0x1c91b bytes)
6219511(247 mod 256): SKIPPED (no operation)
6219512(248 mod 256): READ     0x483f5 thru 0x4e6ef	(0x62fb bytes)
6219513(249 mod 256): INSERT 0x15000 thru 0x27fff	(0x13000 bytes)
6219514(250 mod 256): WRITE    0x5d325 thru 0x779f5	(0x1a6d1 bytes) EXTEND	***WWWW
6219515(251 mod 256): SKIPPED (no operation)
6219516(252 mod 256): DEDUPE 0x1d000 thru 0x29fff	(0xd000 bytes) to 0x4e000 thru 0x5afff
6219517(253 mod 256): TRUNCATE DOWN	from 0x779f6 to 0x1b849	******WWWW
6219518(254 mod 256): MAPWRITE 0x12b0 thru 0xc366	(0xb0b7 bytes)
6219519(255 mod 256): ZERO     0x28f9d thru 0x454b1	(0x1c515 bytes)
6219520(  0 mod 256): COLLAPSE 0x41000 thru 0x44fff	(0x4000 bytes)
6219521(  1 mod 256): SKIPPED (no operation)
6219522(  2 mod 256): INSERT 0xc000 thru 0xcfff	(0x1000 bytes)
6219523(  3 mod 256): WRITE    0x2854e thru 0x3e8e0	(0x16393 bytes)
6219524(  4 mod 256): PUNCH    0x648f thru 0x1c103	(0x15c75 bytes)
6219525(  5 mod 256): MAPREAD  0x26854 thru 0x424b1	(0x1bc5e bytes)
6219526(  6 mod 256): READ     0x381bb thru 0x424b1	(0xa2f7 bytes)
6219527(  7 mod 256): COPY 0x34ee9 thru 0x424b1	(0xd5c9 bytes) to 0x11e08 thru 0x1f3d0
6219528(  8 mod 256): MAPWRITE 0x2c648 thru 0x3217d	(0x5b36 bytes)
6219529(  9 mod 256): PUNCH    0x1924b thru 0x26fca	(0xdd80 bytes)
6219530( 10 mod 256): FALLOC   0x1d12e thru 0x2a87c	(0xd74e bytes) INTERIOR
6219531( 11 mod 256): READ     0x18694 thru 0x303c0	(0x17d2d bytes)
6219532( 12 mod 256): INSERT 0x1000 thru 0xbfff	(0xb000 bytes)
6219533( 13 mod 256): FALLOC   0x2f59b thru 0x3d817	(0xe27c bytes) INTERIOR
6219534( 14 mod 256): TRUNCATE DOWN	from 0x4d4b2 to 0xd0db
6219535( 15 mod 256): COPY 0x9edc thru 0xd0da	(0x31ff bytes) to 0x843a6 thru 0x875a4
6219536( 16 mod 256): SKIPPED (no operation)
6219537( 17 mod 256): FALLOC   0xbec6 thru 0x10e2d	(0x4f67 bytes) INTERIOR
6219538( 18 mod 256): MAPREAD  0x48c9c thru 0x664aa	(0x1d80f bytes)
6219539( 19 mod 256): TRUNCATE DOWN	from 0x875a5 to 0x70bd4
6219540( 20 mod 256): SKIPPED (no operation)
6219541( 21 mod 256): CLONE 0x5b000 thru 0x66fff	(0xc000 bytes) to 0x1000 thru 0xcfff
6219542( 22 mod 256): CLONE 0x45000 thru 0x51fff	(0xd000 bytes) to 0x5a000 thru 0x66fff
6219543( 23 mod 256): PUNCH    0x2401 thru 0x11d2d	(0xf92d bytes)
6219544( 24 mod 256): SKIPPED (no operation)
6219545( 25 mod 256): READ     0x39584 thru 0x5043e	(0x16ebb bytes)
6219546( 26 mod 256): COLLAPSE 0x6c000 thru 0x6dfff	(0x2000 bytes)
6219547( 27 mod 256): FALLOC   0x29f87 thru 0x42af4	(0x18b6d bytes) INTERIOR
6219548( 28 mod 256): DEDUPE 0x66000 thru 0x6dfff	(0x8000 bytes) to 0x5a000 thru 0x61fff
6219549( 29 mod 256): PUNCH    0x700b thru 0x1f83b	(0x18831 bytes)
6219550( 30 mod 256): COPY 0x35ca1 thru 0x47c72	(0x11fd2 bytes) to 0x727f2 thru 0x847c3
6219551( 31 mod 256): DEDUPE 0x50000 thru 0x58fff	(0x9000 bytes) to 0x71000 thru 0x79fff
6219552( 32 mod 256): COLLAPSE 0x27000 thru 0x3cfff	(0x16000 bytes)
6219553( 33 mod 256): ZERO     0x3f1dc thru 0x5d0ea	(0x1df0f bytes)
6219554( 34 mod 256): MAPWRITE 0x3106e thru 0x48c86	(0x17c19 bytes)
6219555( 35 mod 256): WRITE    0x492d5 thru 0x4c66b	(0x3397 bytes)
6219556( 36 mod 256): PUNCH    0xac4f thru 0x16096	(0xb448 bytes)
6219557( 37 mod 256): MAPWRITE 0x5a4f5 thru 0x785fe	(0x1e10a bytes)	******WWWW
6219558( 38 mod 256): CLONE 0x6c000 thru 0x70fff	(0x5000 bytes) to 0x8c000 thru 0x90fff	JJJJ******
6219559( 39 mod 256): DEDUPE 0x5a000 thru 0x76fff	(0x1d000 bytes) to 0x16000 thru 0x32fff	BBBB******
6219560( 40 mod 256): INSERT 0x4a000 thru 0x4afff	(0x1000 bytes)
6219561( 41 mod 256): MAPREAD  0x82249 thru 0x91fff	(0xfdb7 bytes)
6219562( 42 mod 256): ZERO     0x4d9bd thru 0x546bb	(0x6cff bytes)
6219563( 43 mod 256): SKIPPED (no operation)
6219564( 44 mod 256): TRUNCATE DOWN	from 0x92000 to 0x3acb6	******WWWW
6219565( 45 mod 256): TRUNCATE UP	from 0x3acb6 to 0x744d8	******WWWW
6219566( 46 mod 256): MAPWRITE 0x91153 thru 0x927bf	(0x166d bytes)
6219567( 47 mod 256): ZERO     0x39c49 thru 0x3ff80	(0x6338 bytes)
6219568( 48 mod 256): MAPWRITE 0x5d78a thru 0x70f31	(0x137a8 bytes)	******WWWW
6219569( 49 mod 256): SKIPPED (no operation)
6219570( 50 mod 256): READ     0x2f2d7 thru 0x4d87a	(0x1e5a4 bytes)
6219571( 51 mod 256): MAPREAD  0x5d61b thru 0x6d269	(0xfc4f bytes)
6219572( 52 mod 256): SKIPPED (no operation)
6219573( 53 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x88473
6219574( 54 mod 256): SKIPPED (no operation)
6219575( 55 mod 256): COPY 0x27fdd thru 0x44c7e	(0x1cca2 bytes) to 0x4d25d thru 0x69efe
6219576( 56 mod 256): MAPREAD  0x82ba thru 0x20274	(0x17fbb bytes)
6219577( 57 mod 256): DEDUPE 0x41000 thru 0x49fff	(0x9000 bytes) to 0xe000 thru 0x16fff
6219578( 58 mod 256): FALLOC   0x5432d thru 0x59a54	(0x5727 bytes) INTERIOR
6219579( 59 mod 256): MAPWRITE 0x5f110 thru 0x6b7b6	(0xc6a7 bytes)
6219580( 60 mod 256): TRUNCATE DOWN	from 0x88473 to 0xa0bd	******WWWW
6219581( 61 mod 256): MAPWRITE 0x137f3 thru 0x167f9	(0x3007 bytes)
6219582( 62 mod 256): INSERT 0x14000 thru 0x23fff	(0x10000 bytes)
6219583( 63 mod 256): COLLAPSE 0xd000 thru 0xefff	(0x2000 bytes)
6219584( 64 mod 256): SKIPPED (no operation)
6219585( 65 mod 256): COLLAPSE 0x5000 thru 0x1afff	(0x16000 bytes)
6219586( 66 mod 256): PUNCH    0x2d35 thru 0xe7f9	(0xbac5 bytes)
6219587( 67 mod 256): WRITE    0x432a2 thru 0x52855	(0xf5b4 bytes) HOLE
6219588( 68 mod 256): DEDUPE 0x37000 thru 0x42fff	(0xc000 bytes) to 0x46000 thru 0x51fff
6219589( 69 mod 256): TRUNCATE UP	from 0x52856 to 0x8a446	******WWWW
6219590( 70 mod 256): TRUNCATE DOWN	from 0x8a446 to 0x87790
6219591( 71 mod 256): MAPWRITE 0x18655 thru 0x24e3b	(0xc7e7 bytes)
6219592( 72 mod 256): COPY 0x7d40c thru 0x8778f	(0xa384 bytes) to 0x5f2f8 thru 0x6967b
6219593( 73 mod 256): FALLOC   0x85926 thru 0x8ab4a	(0x5224 bytes) EXTENDING
6219594( 74 mod 256): CLONE 0x51000 thru 0x5dfff	(0xd000 bytes) to 0x68000 thru 0x74fff	******JJJJ
6219595( 75 mod 256): DEDUPE 0x54000 thru 0x6dfff	(0x1a000 bytes) to 0x14000 thru 0x2dfff
6219596( 76 mod 256): PUNCH    0x7ba3d thru 0x8ab49	(0xf10d bytes)
6219597( 77 mod 256): WRITE    0x1f7b1 thru 0x2ec56	(0xf4a6 bytes)
6219598( 78 mod 256): ZERO     0x8f356 thru 0x927bf	(0x346a bytes)
6219599( 79 mod 256): SKIPPED (no operation)
6219600( 80 mod 256): READ     0x2140a thru 0x36e35	(0x15a2c bytes)
6219601( 81 mod 256): SKIPPED (no operation)
6219602( 82 mod 256): MAPWRITE 0x14b7d thru 0x1b152	(0x65d6 bytes)
6219603( 83 mod 256): MAPWRITE 0x4610b thru 0x49afe	(0x39f4 bytes)
6219604( 84 mod 256): SKIPPED (no operation)
6219605( 85 mod 256): MAPREAD  0x17383 thru 0x25127	(0xdda5 bytes)
6219606( 86 mod 256): CLONE 0x41000 thru 0x51fff	(0x11000 bytes) to 0x75000 thru 0x85fff
6219607( 87 mod 256): MAPWRITE 0x34e8e thru 0x498b1	(0x14a24 bytes)
6219608( 88 mod 256): COPY 0x5dfbc thru 0x6b57a	(0xd5bf bytes) to 0x737bd thru 0x80d7b
6219609( 89 mod 256): ZERO     0x8be3e thru 0x927bf	(0x6982 bytes)
6219610( 90 mod 256): ZERO     0x53f9c thru 0x5fc99	(0xbcfe bytes)
6219611( 91 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x15af0	******WWWW
6219612( 92 mod 256): ZERO     0x271e5 thru 0x2e028	(0x6e44 bytes)
6219613( 93 mod 256): PUNCH    0x13c96 thru 0x15aef	(0x1e5a bytes)
6219614( 94 mod 256): PUNCH    0xc0da thru 0x15aef	(0x9a16 bytes)
6219615( 95 mod 256): SKIPPED (no operation)
6219616( 96 mod 256): PUNCH    0x85af thru 0xd104	(0x4b56 bytes)
6219617( 97 mod 256): READ     0x13c97 thru 0x15aef	(0x1e59 bytes)
6219618( 98 mod 256): PUNCH    0x8818 thru 0xa504	(0x1ced bytes)
6219619( 99 mod 256): TRUNCATE UP	from 0x15af0 to 0x1e50e
6219620(100 mod 256): INSERT 0xa000 thru 0xdfff	(0x4000 bytes)
6219621(101 mod 256): INSERT 0x22000 thru 0x31fff	(0x10000 bytes)
6219622(102 mod 256): CLONE 0x27000 thru 0x31fff	(0xb000 bytes) to 0x32000 thru 0x3cfff
6219623(103 mod 256): INSERT 0x19000 thru 0x36fff	(0x1e000 bytes)
6219624(104 mod 256): DEDUPE 0x53000 thru 0x59fff	(0x7000 bytes) to 0x1000 thru 0x7fff
6219625(105 mod 256): ZERO     0x6592e thru 0x68f90	(0x3663 bytes)
6219626(106 mod 256): MAPWRITE 0x6a2ea thru 0x7eab6	(0x147cd bytes)	******WWWW
6219627(107 mod 256): DEDUPE 0x34000 thru 0x38fff	(0x5000 bytes) to 0x2e000 thru 0x32fff
6219628(108 mod 256): WRITE    0x76b43 thru 0x80552	(0x9a10 bytes) EXTEND
6219629(109 mod 256): PUNCH    0x1b9c1 thru 0x397d8	(0x1de18 bytes)
6219630(110 mod 256): READ     0x537c1 thru 0x59fe4	(0x6824 bytes)
6219631(111 mod 256): PUNCH    0x1255c thru 0x30e98	(0x1e93d bytes)
6219632(112 mod 256): ZERO     0x3a821 thru 0x42a38	(0x8218 bytes)
6219633(113 mod 256): PUNCH    0x4cb30 thru 0x4f79b	(0x2c6c bytes)
6219634(114 mod 256): READ     0x72175 thru 0x80552	(0xe3de bytes)
6219635(115 mod 256): PUNCH    0x4960d thru 0x4d009	(0x39fd bytes)
6219636(116 mod 256): CLONE 0x13000 thru 0x14fff	(0x2000 bytes) to 0x7000 thru 0x8fff
6219637(117 mod 256): READ     0x6e280 thru 0x7d241	(0xefc2 bytes)	***RRRR***
6219638(118 mod 256): COPY 0x53437 thru 0x6cc43	(0x1980d bytes) to 0x36da0 thru 0x505ac
6219639(119 mod 256): READ     0x2080c thru 0x310aa	(0x1089f bytes)
6219640(120 mod 256): MAPWRITE 0x6f911 thru 0x80c69	(0x11359 bytes)
6219641(121 mod 256): CLONE 0x40000 thru 0x4ffff	(0x10000 bytes) to 0x74000 thru 0x83fff
6219642(122 mod 256): COPY 0x11366 thru 0x1e178	(0xce13 bytes) to 0x4dea7 thru 0x5acb9
6219643(123 mod 256): PUNCH    0x1b17f thru 0x23327	(0x81a9 bytes)
6219644(124 mod 256): COPY 0x79866 thru 0x7e9d2	(0x516d bytes) to 0x2c481 thru 0x315ed
6219645(125 mod 256): READ     0x15595 thru 0x25074	(0xfae0 bytes)
6219646(126 mod 256): PUNCH    0x71fd1 thru 0x83fff	(0x1202f bytes)
6219647(127 mod 256): MAPREAD  0x56319 thru 0x6d1fc	(0x16ee4 bytes)
6219648(128 mod 256): FALLOC   0x71481 thru 0x7f4da	(0xe059 bytes) INTERIOR
6219649(129 mod 256): SKIPPED (no operation)
6219650(130 mod 256): WRITE    0x11bd5 thru 0x2645f	(0x1488b bytes)
6219651(131 mod 256): DEDUPE 0x3b000 thru 0x4ffff	(0x15000 bytes) to 0xc000 thru 0x20fff
6219652(132 mod 256): WRITE    0x3c242 thru 0x4a5ff	(0xe3be bytes)
6219653(133 mod 256): FALLOC   0x2c259 thru 0x4080b	(0x145b2 bytes) INTERIOR
6219654(134 mod 256): INSERT 0x19000 thru 0x26fff	(0xe000 bytes)
6219655(135 mod 256): MAPWRITE 0x14892 thru 0x2b813	(0x16f82 bytes)
6219656(136 mod 256): ZERO     0x5f535 thru 0x68250	(0x8d1c bytes)
6219657(137 mod 256): ZERO     0x19125 thru 0x2038c	(0x7268 bytes)
6219658(138 mod 256): COPY 0x3d1a7 thru 0x42853	(0x56ad bytes) to 0x20f38 thru 0x265e4
6219659(139 mod 256): COPY 0x4ecb thru 0x593b	(0xa71 bytes) to 0x30ee0 thru 0x31950
6219660(140 mod 256): PUNCH    0xa018 thru 0x2428d	(0x1a276 bytes)
6219661(141 mod 256): MAPREAD  0x90d38 thru 0x91fff	(0x12c8 bytes)
6219662(142 mod 256): READ     0x69b7c thru 0x71353	(0x77d8 bytes)	***RRRR***
6219663(143 mod 256): READ     0x7c4aa thru 0x8a88a	(0xe3e1 bytes)
6219664(144 mod 256): DEDUPE 0x5c000 thru 0x5efff	(0x3000 bytes) to 0x7a000 thru 0x7cfff
6219665(145 mod 256): DEDUPE 0x86000 thru 0x90fff	(0xb000 bytes) to 0x7b000 thru 0x85fff
6219666(146 mod 256): MAPWRITE 0x39d8c thru 0x3e6e9	(0x495e bytes)
6219667(147 mod 256): TRUNCATE DOWN	from 0x92000 to 0x558b3	******WWWW
6219668(148 mod 256): COPY 0x5c7b thru 0x11513	(0xb899 bytes) to 0x31a39 thru 0x3d2d1
6219669(149 mod 256): COLLAPSE 0x47000 thru 0x4bfff	(0x5000 bytes)
6219670(150 mod 256): SKIPPED (no operation)
6219671(151 mod 256): ZERO     0x15502 thru 0x342f5	(0x1edf4 bytes)
6219672(152 mod 256): PUNCH    0x44a91 thru 0x4822a	(0x379a bytes)
6219673(153 mod 256): READ     0x3a0ce thru 0x50883	(0x167b6 bytes)
6219674(154 mod 256): CLONE 0x0 thru 0x1fff	(0x2000 bytes) to 0x4b000 thru 0x4cfff
6219675(155 mod 256): WRITE    0x7a07 thru 0x26de1	(0x1f3db bytes)
6219676(156 mod 256): PUNCH    0x142fe thru 0x2b6cf	(0x173d2 bytes)
6219677(157 mod 256): DEDUPE 0x22000 thru 0x22fff	(0x1000 bytes) to 0x36000 thru 0x36fff
6219678(158 mod 256): SKIPPED (no operation)
6219679(159 mod 256): WRITE    0x76a89 thru 0x91f0c	(0x1b484 bytes) HOLE	***WWWW
6219680(160 mod 256): FALLOC   0x66522 thru 0x7b01c	(0x14afa bytes) INTERIOR	******FFFF
6219681(161 mod 256): TRUNCATE DOWN	from 0x91f0d to 0x3d6f7	******WWWW
6219682(162 mod 256): WRITE    0x5a858 thru 0x5f821	(0x4fca bytes) HOLE
6219683(163 mod 256): READ     0xa38f thru 0x1d329	(0x12f9b bytes)
6219684(164 mod 256): TRUNCATE UP	from 0x5f822 to 0x7ae2e	******WWWW
6219685(165 mod 256): COPY 0x7fb6 thru 0xe485	(0x64d0 bytes) to 0x25963 thru 0x2be32
6219686(166 mod 256): SKIPPED (no operation)
6219687(167 mod 256): MAPWRITE 0x168cb thru 0x27fe0	(0x11716 bytes)
6219688(168 mod 256): TRUNCATE DOWN	from 0x7ae2e to 0xa028	******WWWW
6219689(169 mod 256): TRUNCATE UP	from 0xa028 to 0x78060	******WWWW
6219690(170 mod 256): COPY 0x10f01 thru 0x1c79a	(0xb89a bytes) to 0x3c733 thru 0x47fcc
6219691(171 mod 256): READ     0x6ac79 thru 0x7805f	(0xd3e7 bytes)	***RRRR***
6219692(172 mod 256): CLONE 0x2e000 thru 0x4bfff	(0x1e000 bytes) to 0x10000 thru 0x2dfff
6219693(173 mod 256): DEDUPE 0x16000 thru 0x2afff	(0x15000 bytes) to 0x55000 thru 0x69fff
6219694(174 mod 256): DEDUPE 0x3a000 thru 0x50fff	(0x17000 bytes) to 0x15000 thru 0x2bfff
6219695(175 mod 256): COLLAPSE 0x38000 thru 0x43fff	(0xc000 bytes)
6219696(176 mod 256): ZERO     0x439a2 thru 0x447e1	(0xe40 bytes)
6219697(177 mod 256): TRUNCATE DOWN	from 0x6c060 to 0x566b4
6219698(178 mod 256): TRUNCATE DOWN	from 0x566b4 to 0xc5f6
6219699(179 mod 256): INSERT 0x5000 thru 0x1ffff	(0x1b000 bytes)
6219700(180 mod 256): FALLOC   0xf9d1 thru 0x1b35e	(0xb98d bytes) INTERIOR
6219701(181 mod 256): MAPWRITE 0x1e9ec thru 0x3c9a8	(0x1dfbd bytes)
6219702(182 mod 256): DEDUPE 0x1e000 thru 0x2efff	(0x11000 bytes) to 0x7000 thru 0x17fff
6219703(183 mod 256): DEDUPE 0x2f000 thru 0x3bfff	(0xd000 bytes) to 0x20000 thru 0x2cfff
6219704(184 mod 256): SKIPPED (no operation)
6219705(185 mod 256): MAPWRITE 0x8854e thru 0x927bf	(0xa272 bytes)
6219706(186 mod 256): WRITE    0x647b5 thru 0x72e3e	(0xe68a bytes)	***WWWW
6219707(187 mod 256): COLLAPSE 0x36000 thru 0x37fff	(0x2000 bytes)
6219708(188 mod 256): CLONE 0x37000 thru 0x37fff	(0x1000 bytes) to 0x10000 thru 0x10fff
6219709(189 mod 256): ZERO     0x7620f thru 0x832a0	(0xd092 bytes)
6219710(190 mod 256): PUNCH    0x65be9 thru 0x7570b	(0xfb23 bytes)	******PPPP
6219711(191 mod 256): PUNCH    0x7fbba thru 0x907bf	(0x10c06 bytes)
6219712(192 mod 256): CLONE 0x3b000 thru 0x4dfff	(0x13000 bytes) to 0x69000 thru 0x7bfff	******JJJJ
6219713(193 mod 256): COPY 0x63254 thru 0x68cc2	(0x5a6f bytes) to 0x18ad2 thru 0x1e540
6219714(194 mod 256): FALLOC   0x75ac8 thru 0x7ff64	(0xa49c bytes) INTERIOR
6219715(195 mod 256): SKIPPED (no operation)
6219716(196 mod 256): PUNCH    0x10539 thru 0x15f49	(0x5a11 bytes)
6219717(197 mod 256): SKIPPED (no operation)
6219718(198 mod 256): READ     0x681f6 thru 0x817d1	(0x195dc bytes)	***RRRR***
6219719(199 mod 256): WRITE    0x1524d thru 0x27584	(0x12338 bytes)
6219720(200 mod 256): COPY 0x722a4 thru 0x779ef	(0x574c bytes) to 0x466f3 thru 0x4be3e
6219721(201 mod 256): PUNCH    0x1f76e thru 0x3e5c5	(0x1ee58 bytes)
6219722(202 mod 256): READ     0x2f59f thru 0x434c7	(0x13f29 bytes)
6219723(203 mod 256): COPY 0x3bac6 thru 0x531ee	(0x17729 bytes) to 0x70599 thru 0x87cc1
6219724(204 mod 256): TRUNCATE DOWN	from 0x907c0 to 0x66d70	******WWWW
6219725(205 mod 256): SKIPPED (no operation)
6219726(206 mod 256): ZERO     0x67df3 thru 0x830b4	(0x1b2c2 bytes)	******ZZZZ
6219727(207 mod 256): FALLOC   0x58a2d thru 0x74107	(0x1b6da bytes) INTERIOR	******FFFF
6219728(208 mod 256): COPY 0x3e745 thru 0x4920b	(0xaac7 bytes) to 0x5083b thru 0x5b301
6219729(209 mod 256): COPY 0x1fe51 thru 0x3b105	(0x1b2b5 bytes) to 0x45a71 thru 0x60d25
6219730(210 mod 256): FALLOC   0x5a3d0 thru 0x64bfc	(0xa82c bytes) INTERIOR
6219731(211 mod 256): DEDUPE 0x80000 thru 0x81fff	(0x2000 bytes) to 0x4a000 thru 0x4bfff
6219732(212 mod 256): MAPREAD  0x3b073 thru 0x561f1	(0x1b17f bytes)
6219733(213 mod 256): DEDUPE 0x3c000 thru 0x48fff	(0xd000 bytes) to 0x6000 thru 0x12fff
6219734(214 mod 256): MAPWRITE 0x4d4d0 thru 0x6820d	(0x1ad3e bytes)
6219735(215 mod 256): DEDUPE 0x57000 thru 0x66fff	(0x10000 bytes) to 0x18000 thru 0x27fff
6219736(216 mod 256): DEDUPE 0x38000 thru 0x3cfff	(0x5000 bytes) to 0x6b000 thru 0x6ffff	******BBBB
6219737(217 mod 256): INSERT 0x46000 thru 0x54fff	(0xf000 bytes)
6219738(218 mod 256): SKIPPED (no operation)
6219739(219 mod 256): SKIPPED (no operation)
6219740(220 mod 256): SKIPPED (no operation)
6219741(221 mod 256): TRUNCATE DOWN	from 0x920b5 to 0x215be	******WWWW
6219742(222 mod 256): TRUNCATE UP	from 0x215be to 0x83f9c	******WWWW
6219743(223 mod 256): MAPREAD  0x4bded thru 0x5d6fb	(0x1190f bytes)
6219744(224 mod 256): WRITE    0x204b4 thru 0x26477	(0x5fc4 bytes)
6219745(225 mod 256): MAPWRITE 0x5cc78 thru 0x6028a	(0x3613 bytes)
6219746(226 mod 256): MAPWRITE 0x6626e thru 0x70255	(0x9fe8 bytes)	******WWWW
6219747(227 mod 256): COLLAPSE 0x6a000 thru 0x6bfff	(0x2000 bytes)
6219748(228 mod 256): WRITE    0x66928 thru 0x804b1	(0x19b8a bytes)	***WWWW
6219749(229 mod 256): SKIPPED (no operation)
6219750(230 mod 256): TRUNCATE DOWN	from 0x81f9c to 0x54ca5	******WWWW
6219751(231 mod 256): MAPWRITE 0x33cd7 thru 0x4097c	(0xcca6 bytes)
6219752(232 mod 256): COPY 0x13687 thru 0x1f277	(0xbbf1 bytes) to 0x51498 thru 0x5d088
6219753(233 mod 256): FALLOC   0x11eac thru 0x21c58	(0xfdac bytes) INTERIOR
6219754(234 mod 256): COPY 0x19058 thru 0x1be72	(0x2e1b bytes) to 0x4df55 thru 0x50d6f
6219755(235 mod 256): PUNCH    0xe865 thru 0x241d3	(0x1596f bytes)
6219756(236 mod 256): COPY 0x9e4 thru 0xb4e3	(0xab00 bytes) to 0x6648b thru 0x70f8a	******EEEE
6219757(237 mod 256): PUNCH    0x686c3 thru 0x706db	(0x8019 bytes)	******PPPP
6219758(238 mod 256): COPY 0x1b364 thru 0x21a83	(0x6720 bytes) to 0x5f0c8 thru 0x657e7
6219759(239 mod 256): INSERT 0x50000 thru 0x55fff	(0x6000 bytes)
6219760(240 mod 256): DEDUPE 0x3a000 thru 0x46fff	(0xd000 bytes) to 0x5d000 thru 0x69fff
6219761(241 mod 256): ZERO     0x8619d thru 0x8f066	(0x8eca bytes)
6219762(242 mod 256): CLONE 0x6c000 thru 0x89fff	(0x1e000 bytes) to 0x30000 thru 0x4dfff	JJJJ******
6219763(243 mod 256): MAPREAD  0x6c175 thru 0x7867e	(0xc50a bytes)	***RRRR***
6219764(244 mod 256): READ     0x735ab thru 0x7b8b9	(0x830f bytes)
6219765(245 mod 256): MAPREAD  0x7489a thru 0x8b1ec	(0x16953 bytes)
6219766(246 mod 256): INSERT 0x76000 thru 0x78fff	(0x3000 bytes)
6219767(247 mod 256): ZERO     0x730f5 thru 0x75ac0	(0x29cc bytes)
6219768(248 mod 256): MAPWRITE 0x40b48 thru 0x44b7d	(0x4036 bytes)
6219769(249 mod 256): SKIPPED (no operation)
6219770(250 mod 256): SKIPPED (no operation)
6219771(251 mod 256): DEDUPE 0x80000 thru 0x86fff	(0x7000 bytes) to 0x2f000 thru 0x35fff
6219772(252 mod 256): TRUNCATE DOWN	from 0x92067 to 0x1957	******WWWW
6219773(253 mod 256): SKIPPED (no operation)
6219774(254 mod 256): MAPWRITE 0x3abb5 thru 0x43280	(0x86cc bytes)
6219775(255 mod 256): WRITE    0xc321 thru 0x116ad	(0x538d bytes)
6219776(  0 mod 256): COPY 0x2b865 thru 0x41a62	(0x161fe bytes) to 0x734e7 thru 0x896e4
6219777(  1 mod 256): WRITE    0x3957b thru 0x557a0	(0x1c226 bytes)
6219778(  2 mod 256): DEDUPE 0x3b000 thru 0x40fff	(0x6000 bytes) to 0x33000 thru 0x38fff
6219779(  3 mod 256): SKIPPED (no operation)
6219780(  4 mod 256): WRITE    0x69839 thru 0x77a2d	(0xe1f5 bytes)	***WWWW
6219781(  5 mod 256): WRITE    0x7834f thru 0x887f4	(0x104a6 bytes)
6219782(  6 mod 256): TRUNCATE DOWN	from 0x896e5 to 0x6273f	******WWWW
6219783(  7 mod 256): MAPREAD  0x33582 thru 0x3d538	(0x9fb7 bytes)
6219784(  8 mod 256): SKIPPED (no operation)
6219785(  9 mod 256): PUNCH    0x14ac7 thru 0x294f0	(0x14a2a bytes)
6219786( 10 mod 256): COPY 0x46e85 thru 0x483d1	(0x154d bytes) to 0x3942 thru 0x4e8e
6219787( 11 mod 256): INSERT 0x45000 thru 0x59fff	(0x15000 bytes)
6219788( 12 mod 256): TRUNCATE DOWN	from 0x7773f to 0x6125a	******WWWW
6219789( 13 mod 256): DEDUPE 0x56000 thru 0x5ffff	(0xa000 bytes) to 0x4c000 thru 0x55fff
6219790( 14 mod 256): WRITE    0x6dc55 thru 0x6e7d4	(0xb80 bytes) HOLE
6219791( 15 mod 256): FALLOC   0x362fc thru 0x413fc	(0xb100 bytes) INTERIOR
6219792( 16 mod 256): CLONE 0xe000 thru 0x15fff	(0x8000 bytes) to 0x60000 thru 0x67fff
6219793( 17 mod 256): ZERO     0x49da0 thru 0x4d581	(0x37e2 bytes)
6219794( 18 mod 256): READ     0x38b35 thru 0x4c1a3	(0x1366f bytes)
6219795( 19 mod 256): FALLOC   0x84574 thru 0x91c93	(0xd71f bytes) PAST_EOF
6219796( 20 mod 256): WRITE    0x59b81 thru 0x6c7eb	(0x12c6b bytes)
6219797( 21 mod 256): COPY 0x1a123 thru 0x37070	(0x1cf4e bytes) to 0x4ea04 thru 0x6b951
6219798( 22 mod 256): COLLAPSE 0x41000 thru 0x4dfff	(0xd000 bytes)
6219799( 23 mod 256): TRUNCATE DOWN	from 0x617d5 to 0x4dcf9
6219800( 24 mod 256): INSERT 0x44000 thru 0x59fff	(0x16000 bytes)
6219801( 25 mod 256): SKIPPED (no operation)
6219802( 26 mod 256): INSERT 0xc000 thru 0x24fff	(0x19000 bytes)
6219803( 27 mod 256): CLONE 0x5a000 thru 0x6dfff	(0x14000 bytes) to 0x75000 thru 0x88fff
6219804( 28 mod 256): FALLOC   0x4e68 thru 0xd6b0	(0x8848 bytes) INTERIOR
6219805( 29 mod 256): COPY 0x87ba2 thru 0x88fff	(0x145e bytes) to 0x6c384 thru 0x6d7e1
6219806( 30 mod 256): COPY 0x7100 thru 0x15e41	(0xed42 bytes) to 0x1e1da thru 0x2cf1b
6219807( 31 mod 256): ZERO     0x1df30 thru 0x2e79e	(0x1086f bytes)
6219808( 32 mod 256): READ     0x34674 thru 0x4534b	(0x10cd8 bytes)
6219809( 33 mod 256): WRITE    0x68fdc thru 0x817d4	(0x187f9 bytes)	***WWWW
6219810( 34 mod 256): COPY 0x784a6 thru 0x88fff	(0x10b5a bytes) to 0x3211 thru 0x13d6a
6219811( 35 mod 256): COPY 0x669b thru 0x19b8e	(0x134f4 bytes) to 0x30ede thru 0x443d1
6219812( 36 mod 256): CLONE 0x1e000 thru 0x25fff	(0x8000 bytes) to 0x33000 thru 0x3afff
6219813( 37 mod 256): FALLOC   0x7ecb9 thru 0x8b210	(0xc557 bytes) PAST_EOF
6219814( 38 mod 256): MAPWRITE 0x8de93 thru 0x927bf	(0x492d bytes)
6219815( 39 mod 256): SKIPPED (no operation)
6219816( 40 mod 256): CLONE 0xc000 thru 0x15fff	(0xa000 bytes) to 0x24000 thru 0x2dfff
6219817( 41 mod 256): SKIPPED (no operation)
6219818( 42 mod 256): MAPWRITE 0x65247 thru 0x6e710	(0x94ca bytes)
6219819( 43 mod 256): SKIPPED (no operation)
6219820( 44 mod 256): SKIPPED (no operation)
6219821( 45 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x3f9c2	******WWWW
6219822( 46 mod 256): MAPREAD  0x3934 thru 0x179a0	(0x1406d bytes)
6219823( 47 mod 256): MAPWRITE 0x266ff thru 0x2b9fc	(0x52fe bytes)
6219824( 48 mod 256): MAPREAD  0x10ba6 thru 0x1365d	(0x2ab8 bytes)
6219825( 49 mod 256): WRITE    0x2d5a8 thru 0x3b131	(0xdb8a bytes)
6219826( 50 mod 256): COLLAPSE 0x27000 thru 0x3efff	(0x18000 bytes)
6219827( 51 mod 256): DEDUPE 0x14000 thru 0x25fff	(0x12000 bytes) to 0x2000 thru 0x13fff
6219828( 52 mod 256): ZERO     0x272e7 thru 0x2e772	(0x748c bytes)
6219829( 53 mod 256): SKIPPED (no operation)
6219830( 54 mod 256): SKIPPED (no operation)
6219831( 55 mod 256): WRITE    0x2d544 thru 0x4b285	(0x1dd42 bytes) EXTEND
6219832( 56 mod 256): CLONE 0x23000 thru 0x3ffff	(0x1d000 bytes) to 0x41000 thru 0x5dfff
6219833( 57 mod 256): CLONE 0x5c000 thru 0x5cfff	(0x1000 bytes) to 0xc000 thru 0xcfff
6219834( 58 mod 256): PUNCH    0x7ecd thru 0xe83c	(0x6970 bytes)
6219835( 59 mod 256): COPY 0x15266 thru 0x26429	(0x111c4 bytes) to 0x46e47 thru 0x5800a
6219836( 60 mod 256): MAPREAD  0x49e47 thru 0x5c519	(0x126d3 bytes)
6219837( 61 mod 256): INSERT 0x38000 thru 0x54fff	(0x1d000 bytes)
6219838( 62 mod 256): READ     0x3968f thru 0x49f51	(0x108c3 bytes)
6219839( 63 mod 256): PUNCH    0x39eb0 thru 0x4cc73	(0x12dc4 bytes)
6219840( 64 mod 256): INSERT 0x47000 thru 0x5dfff	(0x17000 bytes)
6219841( 65 mod 256): READ     0x6113f thru 0x6524f	(0x4111 bytes)
6219842( 66 mod 256): COLLAPSE 0x23000 thru 0x35fff	(0x13000 bytes)
6219843( 67 mod 256): COLLAPSE 0x23000 thru 0x27fff	(0x5000 bytes)
6219844( 68 mod 256): COPY 0x5be6a thru 0x76f4e	(0x1b0e5 bytes) to 0x205c3 thru 0x3b6a7	EEEE******
6219845( 69 mod 256): WRITE    0x27792 thru 0x3faea	(0x18359 bytes)
6219846( 70 mod 256): DEDUPE 0x48000 thru 0x48fff	(0x1000 bytes) to 0x4b000 thru 0x4bfff
6219847( 71 mod 256): MAPWRITE 0x5e8c2 thru 0x6a12b	(0xb86a bytes)
6219848( 72 mod 256): COLLAPSE 0x54000 thru 0x55fff	(0x2000 bytes)
6219849( 73 mod 256): TRUNCATE UP	from 0x78000 to 0x7fd33
6219850( 74 mod 256): INSERT 0x7d000 thru 0x88fff	(0xc000 bytes)
6219851( 75 mod 256): COPY 0x16208 thru 0x21c89	(0xba82 bytes) to 0x4372b thru 0x4f1ac
6219852( 76 mod 256): DEDUPE 0x35000 thru 0x37fff	(0x3000 bytes) to 0x43000 thru 0x45fff
6219853( 77 mod 256): MAPREAD  0x5f9dc thru 0x646c2	(0x4ce7 bytes)
6219854( 78 mod 256): CLONE 0x6d000 thru 0x76fff	(0xa000 bytes) to 0x5d000 thru 0x66fff	JJJJ******
6219855( 79 mod 256): MAPREAD  0x4d388 thru 0x6bd63	(0x1e9dc bytes)
6219856( 80 mod 256): DEDUPE 0x64000 thru 0x6afff	(0x7000 bytes) to 0x8000 thru 0xefff
6219857( 81 mod 256): WRITE    0x5b561 thru 0x5bfbf	(0xa5f bytes)
6219858( 82 mod 256): CLONE 0x45000 thru 0x48fff	(0x4000 bytes) to 0x11000 thru 0x14fff
6219859( 83 mod 256): COLLAPSE 0x81000 thru 0x8afff	(0xa000 bytes)
6219860( 84 mod 256): MAPWRITE 0x65e59 thru 0x830b9	(0x1d261 bytes)	******WWWW
6219861( 85 mod 256): MAPWRITE 0x77f62 thru 0x927bf	(0x1a85e bytes)
6219862( 86 mod 256): CLONE 0x17000 thru 0x19fff	(0x3000 bytes) to 0x88000 thru 0x8afff
6219863( 87 mod 256): ZERO     0x634ab thru 0x79f5d	(0x16ab3 bytes)	******ZZZZ
6219864( 88 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x73608
6219865( 89 mod 256): DEDUPE 0x41000 thru 0x41fff	(0x1000 bytes) to 0x3c000 thru 0x3cfff
6219866( 90 mod 256): MAPWRITE 0xdf37 thru 0x1a1a2	(0xc26c bytes)
6219867( 91 mod 256): ZERO     0x4bdc2 thru 0x67419	(0x1b658 bytes)
6219868( 92 mod 256): TRUNCATE UP	from 0x73608 to 0x7d1d3
6219869( 93 mod 256): WRITE    0xc80b thru 0x1567b	(0x8e71 bytes)
6219870( 94 mod 256): READ     0x1081b thru 0x152d6	(0x4abc bytes)
6219871( 95 mod 256): TRUNCATE DOWN	from 0x7d1d3 to 0x17992	******WWWW
6219872( 96 mod 256): ZERO     0x3c11b thru 0x4a591	(0xe477 bytes)
6219873( 97 mod 256): READ     0xf4c0 thru 0x157d4	(0x6315 bytes)
6219874( 98 mod 256): ZERO     0x28e4d thru 0x36c53	(0xde07 bytes)
6219875( 99 mod 256): COLLAPSE 0x3000 thru 0xbfff	(0x9000 bytes)
6219876(100 mod 256): READ     0x3122b thru 0x41591	(0x10367 bytes)
6219877(101 mod 256): SKIPPED (no operation)
6219878(102 mod 256): ZERO     0x6671a thru 0x726ec	(0xbfd3 bytes)	******ZZZZ
6219879(103 mod 256): SKIPPED (no operation)
6219880(104 mod 256): CLONE 0xc000 thru 0x1ffff	(0x14000 bytes) to 0x37000 thru 0x4afff
6219881(105 mod 256): CLONE 0x18000 thru 0x2cfff	(0x15000 bytes) to 0x3a000 thru 0x4efff
6219882(106 mod 256): INSERT 0x42000 thru 0x59fff	(0x18000 bytes)
6219883(107 mod 256): READ     0x7dba4 thru 0x8a6ec	(0xcb49 bytes)
6219884(108 mod 256): READ     0xc794 thru 0x127e0	(0x604d bytes)
6219885(109 mod 256): DEDUPE 0x83000 thru 0x89fff	(0x7000 bytes) to 0x6c000 thru 0x72fff	******BBBB
6219886(110 mod 256): TRUNCATE DOWN	from 0x8a6ed to 0x584bf	******WWWW
6219887(111 mod 256): READ     0xfa56 thru 0x2cffb	(0x1d5a6 bytes)
6219888(112 mod 256): ZERO     0x4aeb4 thru 0x5a5a5	(0xf6f2 bytes)
6219889(113 mod 256): ZERO     0x91644 thru 0x927bf	(0x117c bytes)
6219890(114 mod 256): SKIPPED (no operation)
6219891(115 mod 256): PUNCH    0x1828e thru 0x24c12	(0xc985 bytes)
6219892(116 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x79516
6219893(117 mod 256): MAPWRITE 0x72a2b thru 0x884f6	(0x15acc bytes)
6219894(118 mod 256): TRUNCATE DOWN	from 0x884f7 to 0x63ad	******WWWW
6219895(119 mod 256): ZERO     0x187b2 thru 0x2bc73	(0x134c2 bytes)
6219896(120 mod 256): PUNCH    0x68d thru 0x63ac	(0x5d20 bytes)
6219897(121 mod 256): DEDUPE 0x3000 thru 0x4fff	(0x2000 bytes) to 0x1000 thru 0x2fff
6219898(122 mod 256): TRUNCATE UP	from 0x63ad to 0xc385
6219899(123 mod 256): MAPWRITE 0x1ad42 thru 0x1c886	(0x1b45 bytes)
6219900(124 mod 256): WRITE    0x39c66 thru 0x4d63d	(0x139d8 bytes) HOLE
6219901(125 mod 256): ZERO     0x70987 thru 0x722b0	(0x192a bytes)
6219902(126 mod 256): COPY 0xafbe thru 0x25620	(0x1a663 bytes) to 0x4b423 thru 0x65a85
6219903(127 mod 256): DEDUPE 0x25000 thru 0x3bfff	(0x17000 bytes) to 0x3000 thru 0x19fff
6219904(128 mod 256): PUNCH    0x2bbe1 thru 0x4a3ae	(0x1e7ce bytes)
6219905(129 mod 256): CLONE 0x41000 thru 0x4bfff	(0xb000 bytes) to 0x61000 thru 0x6bfff
6219906(130 mod 256): COLLAPSE 0x67000 thru 0x68fff	(0x2000 bytes)
6219907(131 mod 256): MAPREAD  0x34ae4 thru 0x50d67	(0x1c284 bytes)
6219908(132 mod 256): DEDUPE 0x26000 thru 0x39fff	(0x14000 bytes) to 0xa000 thru 0x1dfff
6219909(133 mod 256): WRITE    0x318f0 thru 0x396b7	(0x7dc8 bytes)
6219910(134 mod 256): FALLOC   0x86ec3 thru 0x927c0	(0xb8fd bytes) EXTENDING
6219911(135 mod 256): WRITE    0x562d9 thru 0x70182	(0x19eaa bytes)	***WWWW
6219912(136 mod 256): SKIPPED (no operation)
6219913(137 mod 256): COLLAPSE 0x71000 thru 0x84fff	(0x14000 bytes)
6219914(138 mod 256): DEDUPE 0x42000 thru 0x45fff	(0x4000 bytes) to 0x77000 thru 0x7afff
6219915(139 mod 256): MAPWRITE 0x3e5d0 thru 0x5682d	(0x1825e bytes)
6219916(140 mod 256): READ     0x53ff6 thru 0x6099d	(0xc9a8 bytes)
6219917(141 mod 256): SKIPPED (no operation)
6219918(142 mod 256): INSERT 0x48000 thru 0x4cfff	(0x5000 bytes)
6219919(143 mod 256): SKIPPED (no operation)
6219920(144 mod 256): MAPREAD  0x2a54b thru 0x354e9	(0xaf9f bytes)
6219921(145 mod 256): FALLOC   0x59500 thru 0x62588	(0x9088 bytes) INTERIOR
6219922(146 mod 256): COPY 0x18430 thru 0x21647	(0x9218 bytes) to 0x4c21c thru 0x55433
6219923(147 mod 256): SKIPPED (no operation)
6219924(148 mod 256): MAPWRITE 0x1a720 thru 0x31585	(0x16e66 bytes)
6219925(149 mod 256): ZERO     0x69a32 thru 0x83c7b	(0x1a24a bytes)	******ZZZZ
6219926(150 mod 256): DEDUPE 0x3c000 thru 0x48fff	(0xd000 bytes) to 0x65000 thru 0x71fff	******BBBB
6219927(151 mod 256): DEDUPE 0xc000 thru 0x23fff	(0x18000 bytes) to 0x27000 thru 0x3efff
6219928(152 mod 256): ZERO     0x55516 thru 0x6055a	(0xb045 bytes)
6219929(153 mod 256): READ     0x23fb3 thru 0x25ee9	(0x1f37 bytes)
6219930(154 mod 256): PUNCH    0x69251 thru 0x6d5b2	(0x4362 bytes)
6219931(155 mod 256): READ     0x2af65 thru 0x419ff	(0x16a9b bytes)
6219932(156 mod 256): SKIPPED (no operation)
6219933(157 mod 256): COPY 0x54eeb thru 0x62584	(0xd69a bytes) to 0x3e2aa thru 0x4b943
6219934(158 mod 256): INSERT 0x42000 thru 0x4bfff	(0xa000 bytes)
6219935(159 mod 256): CLONE 0x5d000 thru 0x73fff	(0x17000 bytes) to 0x33000 thru 0x49fff	JJJJ******
6219936(160 mod 256): ZERO     0x1c617 thru 0x2064f	(0x4039 bytes)
6219937(161 mod 256): DEDUPE 0x82000 thru 0x8bfff	(0xa000 bytes) to 0x6a000 thru 0x73fff	******BBBB
6219938(162 mod 256): READ     0x86ad1 thru 0x8dc7b	(0x71ab bytes)
6219939(163 mod 256): MAPWRITE 0x3efd8 thru 0x41687	(0x26b0 bytes)
6219940(164 mod 256): TRUNCATE DOWN	from 0x8dc7c to 0x33996	******WWWW
6219941(165 mod 256): COPY 0x9eb7 thru 0x1b86f	(0x119b9 bytes) to 0x568a1 thru 0x68259
6219942(166 mod 256): MAPWRITE 0x4cfb0 thru 0x54541	(0x7592 bytes)
6219943(167 mod 256): INSERT 0x17000 thru 0x1dfff	(0x7000 bytes)
6219944(168 mod 256): PUNCH    0x67170 thru 0x6f259	(0x80ea bytes)	******PPPP
6219945(169 mod 256): MAPWRITE 0x6868c thru 0x77899	(0xf20e bytes)	******WWWW
6219946(170 mod 256): FALLOC   0x8bb04 thru 0x8f4d9	(0x39d5 bytes) PAST_EOF
6219947(171 mod 256): INSERT 0x23000 thru 0x29fff	(0x7000 bytes)
6219948(172 mod 256): CLONE 0x74000 thru 0x7dfff	(0xa000 bytes) to 0x86000 thru 0x8ffff
6219949(173 mod 256): MAPREAD  0x4feac thru 0x6bbfe	(0x1bd53 bytes)
6219950(174 mod 256): SKIPPED (no operation)
6219951(175 mod 256): MAPREAD  0x8771b thru 0x8ffff	(0x88e5 bytes)
6219952(176 mod 256): FALLOC   0x73872 thru 0x8297e	(0xf10c bytes) INTERIOR
6219953(177 mod 256): MAPREAD  0x2a3ac thru 0x399e0	(0xf635 bytes)
6219954(178 mod 256): DEDUPE 0xf000 thru 0x1bfff	(0xd000 bytes) to 0x66000 thru 0x72fff	******BBBB
6219955(179 mod 256): PUNCH    0x5e6a8 thru 0x62f1e	(0x4877 bytes)
6219956(180 mod 256): READ     0x7cd92 thru 0x8ffff	(0x1326e bytes)
6219957(181 mod 256): MAPREAD  0x63355 thru 0x69243	(0x5eef bytes)
6219958(182 mod 256): ZERO     0xfa5a thru 0x14d2d	(0x52d4 bytes)
6219959(183 mod 256): WRITE    0x27e8e thru 0x3018a	(0x82fd bytes)
6219960(184 mod 256): INSERT 0x72000 thru 0x73fff	(0x2000 bytes)
6219961(185 mod 256): PUNCH    0x30720 thru 0x4ee45	(0x1e726 bytes)
6219962(186 mod 256): COPY 0x242e3 thru 0x3c163	(0x17e81 bytes) to 0x45edd thru 0x5dd5d
6219963(187 mod 256): READ     0x5e7a4 thru 0x7674b	(0x17fa8 bytes)	***RRRR***
6219964(188 mod 256): TRUNCATE DOWN	from 0x92000 to 0x4d7fd	******WWWW
6219965(189 mod 256): READ     0x1b6c9 thru 0x27948	(0xc280 bytes)
6219966(190 mod 256): SKIPPED (no operation)
6219967(191 mod 256): COPY 0x10f58 thru 0x1c57a	(0xb623 bytes) to 0x54d1e thru 0x60340
6219968(192 mod 256): FALLOC   0x2f88 thru 0x1e556	(0x1b5ce bytes) INTERIOR
6219969(193 mod 256): PUNCH    0x2d1e2 thru 0x351c5	(0x7fe4 bytes)
6219970(194 mod 256): PUNCH    0x308ad thru 0x3d158	(0xc8ac bytes)
6219971(195 mod 256): TRUNCATE DOWN	from 0x60341 to 0x1edab
6219972(196 mod 256): MAPREAD  0x8ffd thru 0x1edaa	(0x15dae bytes)
6219973(197 mod 256): COPY 0x9e3 thru 0x1316c	(0x1278a bytes) to 0x5d818 thru 0x6ffa1	******EEEE
6219974(198 mod 256): FALLOC   0x765cb thru 0x830c9	(0xcafe bytes) PAST_EOF
6219975(199 mod 256): MAPREAD  0x1dc37 thru 0x20869	(0x2c33 bytes)
6219976(200 mod 256): SKIPPED (no operation)
6219977(201 mod 256): MAPREAD  0x468d2 thru 0x512c9	(0xa9f8 bytes)
6219978(202 mod 256): COLLAPSE 0x51000 thru 0x54fff	(0x4000 bytes)
6219979(203 mod 256): SKIPPED (no operation)
6219980(204 mod 256): INSERT 0x28000 thru 0x29fff	(0x2000 bytes)
6219981(205 mod 256): DEDUPE 0x6c000 thru 0x6cfff	(0x1000 bytes) to 0x1a000 thru 0x1afff
6219982(206 mod 256): DEDUPE 0x4b000 thru 0x62fff	(0x18000 bytes) to 0x28000 thru 0x3ffff
6219983(207 mod 256): COPY 0x61c03 thru 0x68197	(0x6595 bytes) to 0x1a25c thru 0x207f0
6219984(208 mod 256): READ     0x665a6 thru 0x6dfa1	(0x79fc bytes)
6219985(209 mod 256): FALLOC   0x2e387 thru 0x422af	(0x13f28 bytes) INTERIOR
6219986(210 mod 256): ZERO     0x21ede thru 0x33086	(0x111a9 bytes)
6219987(211 mod 256): ZERO     0x1b698 thru 0x2377f	(0x80e8 bytes)
6219988(212 mod 256): MAPWRITE 0x64dcc thru 0x783a4	(0x135d9 bytes)	******WWWW
6219989(213 mod 256): ZERO     0x16a55 thru 0x2c5e5	(0x15b91 bytes)
6219990(214 mod 256): MAPREAD  0x19783 thru 0x3485d	(0x1b0db bytes)
6219991(215 mod 256): MAPWRITE 0x74023 thru 0x8276f	(0xe74d bytes)
6219992(216 mod 256): SKIPPED (no operation)
6219993(217 mod 256): INSERT 0x79000 thru 0x88fff	(0x10000 bytes)
6219994(218 mod 256): MAPWRITE 0x7d5f3 thru 0x8bdfc	(0xe80a bytes)
6219995(219 mod 256): ZERO     0xd08a thru 0x29572	(0x1c4e9 bytes)
6219996(220 mod 256): COLLAPSE 0x7000 thru 0x24fff	(0x1e000 bytes)
6219997(221 mod 256): WRITE    0x342d3 thru 0x3b9a6	(0x76d4 bytes)
6219998(222 mod 256): INSERT 0x14000 thru 0x2dfff	(0x1a000 bytes)
6219999(223 mod 256): TRUNCATE DOWN	from 0x8e770 to 0x4e44d	******WWWW
6220000(224 mod 256): ZERO     0x366ed thru 0x551a4	(0x1eab8 bytes)
6210001(209 mod 256): COPY 0x738e thru 0x1142c	(0xa09f bytes) to 0x459c8 thru 0x4fa66
6210002(210 mod 256): READ     0x8bb1 thru 0x16814	(0xdc64 bytes)
6210003(211 mod 256): MAPWRITE 0x45ce5 thru 0x623d0	(0x1c6ec bytes)
6210004(212 mod 256): SKIPPED (no operation)
6210005(213 mod 256): READ     0x53cad thru 0x623d0	(0xe724 bytes)
6210006(214 mod 256): SKIPPED (no operation)
6210007(215 mod 256): MAPREAD  0x3f911 thru 0x533aa	(0x13a9a bytes)
6210008(216 mod 256): MAPWRITE 0x63128 thru 0x7d24e	(0x1a127 bytes)	******WWWW
6210009(217 mod 256): MAPREAD  0x20a4d thru 0x38c40	(0x181f4 bytes)
6210010(218 mod 256): INSERT 0x5b000 thru 0x6bfff	(0x11000 bytes)
6210011(219 mod 256): WRITE    0x2be2a thru 0x47b09	(0x1bce0 bytes)
6210012(220 mod 256): SKIPPED (no operation)
6210013(221 mod 256): COLLAPSE 0x80000 thru 0x89fff	(0xa000 bytes)
6210014(222 mod 256): COLLAPSE 0x6a000 thru 0x7dfff	(0x14000 bytes)	******CCCC
6210015(223 mod 256): SKIPPED (no operation)
6210016(224 mod 256): FALLOC   0x6c97c thru 0x73d60	(0x73e4 bytes) EXTENDING	******FFFF
6210017(225 mod 256): PUNCH    0x370f9 thru 0x51a74	(0x1a97c bytes)
6210018(226 mod 256): READ     0x21db1 thru 0x25ae7	(0x3d37 bytes)
6210019(227 mod 256): DEDUPE 0x28000 thru 0x40fff	(0x19000 bytes) to 0x45000 thru 0x5dfff
6210020(228 mod 256): COLLAPSE 0x1e000 thru 0x23fff	(0x6000 bytes)
6210021(229 mod 256): READ     0x3c1 thru 0x846f	(0x80af bytes)
6210022(230 mod 256): INSERT 0x38000 thru 0x4afff	(0x13000 bytes)
6210023(231 mod 256): INSERT 0x4e000 thru 0x53fff	(0x6000 bytes)
6210024(232 mod 256): PUNCH    0x36343 thru 0x46da4	(0x10a62 bytes)
6210025(233 mod 256): TRUNCATE DOWN	from 0x86d60 to 0x46038	******WWWW
6210026(234 mod 256): MAPREAD  0x18496 thru 0x23949	(0xb4b4 bytes)
6210027(235 mod 256): COLLAPSE 0x31000 thru 0x34fff	(0x4000 bytes)
6210028(236 mod 256): WRITE    0x30d82 thru 0x3ffbf	(0xf23e bytes)
6210029(237 mod 256): COPY 0x40e3 thru 0x792b	(0x3849 bytes) to 0x74ad3 thru 0x7831b
6210030(238 mod 256): PUNCH    0x1a68 thru 0xa392	(0x892b bytes)
6210031(239 mod 256): READ     0x31897 thru 0x4045f	(0xebc9 bytes)
6210032(240 mod 256): MAPWRITE 0x8d02c thru 0x927bf	(0x5794 bytes)
6210033(241 mod 256): WRITE    0x64d44 thru 0x6ceae	(0x816b bytes)
6210034(242 mod 256): WRITE    0x15ae7 thru 0x2bbf5	(0x1610f bytes)
6210035(243 mod 256): READ     0x4536a thru 0x5fdac	(0x1aa43 bytes)
6210036(244 mod 256): MAPREAD  0x4d1b8 thru 0x5a5c9	(0xd412 bytes)
6210037(245 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8c052
6210038(246 mod 256): WRITE    0x29c63 thru 0x3750a	(0xd8a8 bytes)
6210039(247 mod 256): TRUNCATE DOWN	from 0x8c052 to 0x6093d	******WWWW
6210040(248 mod 256): FALLOC   0x78cf2 thru 0x88fc8	(0x102d6 bytes) PAST_EOF
6210041(249 mod 256): MAPWRITE 0x5910b thru 0x623d1	(0x92c7 bytes)
6210042(250 mod 256): TRUNCATE DOWN	from 0x623d2 to 0x2d919
6210043(251 mod 256): SKIPPED (no operation)
6210044(252 mod 256): READ     0x418f thru 0xbe0b	(0x7c7d bytes)
6210045(253 mod 256): COLLAPSE 0x2b000 thru 0x2cfff	(0x2000 bytes)
6210046(254 mod 256): MAPREAD  0xe9f4 thru 0x299cd	(0x1afda bytes)
6210047(255 mod 256): READ     0x1867b thru 0x1f925	(0x72ab bytes)
6210048(  0 mod 256): ZERO     0x37328 thru 0x4f577	(0x18250 bytes)
6210049(  1 mod 256): MAPWRITE 0x882e0 thru 0x927bf	(0xa4e0 bytes)
6210050(  2 mod 256): FALLOC   0x3bf2a thru 0x537ce	(0x178a4 bytes) INTERIOR
6210051(  3 mod 256): CLONE 0x4f000 thru 0x6cfff	(0x1e000 bytes) to 0x72000 thru 0x8ffff
6210052(  4 mod 256): COPY 0x715e4 thru 0x8c377	(0x1ad94 bytes) to 0x2c4fd thru 0x47290
6210053(  5 mod 256): WRITE    0x8884e thru 0x927bf	(0x9f72 bytes)
6210054(  6 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x86799
6210055(  7 mod 256): DEDUPE 0x1000 thru 0x17fff	(0x17000 bytes) to 0x64000 thru 0x7afff	******BBBB
6210056(  8 mod 256): PUNCH    0x39639 thru 0x524f0	(0x18eb8 bytes)
6210057(  9 mod 256): INSERT 0x5a000 thru 0x5afff	(0x1000 bytes)
6210058( 10 mod 256): TRUNCATE UP	from 0x87799 to 0x9028a
6210059( 11 mod 256): CLONE 0x3d000 thru 0x3dfff	(0x1000 bytes) to 0x6e000 thru 0x6efff	******JJJJ
6210060( 12 mod 256): WRITE    0x4e391 thru 0x67c72	(0x198e2 bytes)
6210061( 13 mod 256): MAPREAD  0x7e532 thru 0x90289	(0x11d58 bytes)
6210062( 14 mod 256): FALLOC   0x6cfda thru 0x871de	(0x1a204 bytes) INTERIOR	******FFFF
6210063( 15 mod 256): SKIPPED (no operation)
6210064( 16 mod 256): READ     0x3d960 thru 0x3e3b2	(0xa53 bytes)
6210065( 17 mod 256): MAPWRITE 0x3ed67 thru 0x5b0ed	(0x1c387 bytes)
6210066( 18 mod 256): DEDUPE 0x8b000 thru 0x8efff	(0x4000 bytes) to 0x78000 thru 0x7bfff
6210067( 19 mod 256): ZERO     0x4d965 thru 0x51f93	(0x462f bytes)
6210068( 20 mod 256): READ     0x1f000 thru 0x30980	(0x11981 bytes)
6210069( 21 mod 256): MAPWRITE 0x4c376 thru 0x6ac4f	(0x1e8da bytes)
6210070( 22 mod 256): MAPREAD  0x32821 thru 0x51108	(0x1e8e8 bytes)
6210071( 23 mod 256): DEDUPE 0x59000 thru 0x71fff	(0x19000 bytes) to 0x0 thru 0x18fff	BBBB******
6210072( 24 mod 256): DEDUPE 0x8d000 thru 0x8efff	(0x2000 bytes) to 0x5000 thru 0x6fff
6210073( 25 mod 256): PUNCH    0x68ca1 thru 0x8666c	(0x1d9cc bytes)	******PPPP
6210074( 26 mod 256): CLONE 0x1d000 thru 0x28fff	(0xc000 bytes) to 0x7c000 thru 0x87fff
6210075( 27 mod 256): SKIPPED (no operation)
6210076( 28 mod 256): INSERT 0x2c000 thru 0x2dfff	(0x2000 bytes)
6210077( 29 mod 256): TRUNCATE DOWN	from 0x9228a to 0x535c8	******WWWW
6210078( 30 mod 256): INSERT 0x16000 thru 0x2bfff	(0x16000 bytes)
6210079( 31 mod 256): CLONE 0x64000 thru 0x68fff	(0x5000 bytes) to 0x74000 thru 0x78fff
6210080( 32 mod 256): COLLAPSE 0x58000 thru 0x6bfff	(0x14000 bytes)
6210081( 33 mod 256): COPY 0x1bffe thru 0x32c8b	(0x16c8e bytes) to 0x55ac8 thru 0x6c755
6210082( 34 mod 256): CLONE 0x63000 thru 0x6afff	(0x8000 bytes) to 0x2e000 thru 0x35fff
6210083( 35 mod 256): COPY 0x35c1e thru 0x48a23	(0x12e06 bytes) to 0x7b0e1 thru 0x8dee6
6210084( 36 mod 256): TRUNCATE DOWN	from 0x8dee7 to 0x10882	******WWWW
6210085( 37 mod 256): FALLOC   0xf211 thru 0x272b6	(0x180a5 bytes) PAST_EOF
6210086( 38 mod 256): MAPREAD  0xf9ea thru 0x10881	(0xe98 bytes)
6210087( 39 mod 256): MAPWRITE 0x876d thru 0x1ab09	(0x1239d bytes)
6210088( 40 mod 256): READ     0x13c72 thru 0x1ab09	(0x6e98 bytes)
6210089( 41 mod 256): MAPWRITE 0x6c90f thru 0x74719	(0x7e0b bytes)	******WWWW
6210090( 42 mod 256): DEDUPE 0x2000 thru 0x8fff	(0x7000 bytes) to 0xe000 thru 0x14fff
6210091( 43 mod 256): MAPWRITE 0x4dec0 thru 0x6c42c	(0x1e56d bytes)
6210092( 44 mod 256): MAPREAD  0x17e53 thru 0x23ee6	(0xc094 bytes)
6210093( 45 mod 256): MAPWRITE 0x1e6b thru 0x115bc	(0xf752 bytes)
6210094( 46 mod 256): WRITE    0x2089e thru 0x37191	(0x168f4 bytes)
6210095( 47 mod 256): CLONE 0x2b000 thru 0x2efff	(0x4000 bytes) to 0x84000 thru 0x87fff
6210096( 48 mod 256): FALLOC   0x851e0 thru 0x927c0	(0xd5e0 bytes) EXTENDING
6210097( 49 mod 256): READ     0x87ea9 thru 0x8c5ee	(0x4746 bytes)
6210098( 50 mod 256): WRITE    0x18498 thru 0x300ee	(0x17c57 bytes)
6210099( 51 mod 256): SKIPPED (no operation)
6210100( 52 mod 256): MAPWRITE 0x45374 thru 0x4b72e	(0x63bb bytes)
6210101( 53 mod 256): DEDUPE 0x2e000 thru 0x36fff	(0x9000 bytes) to 0x8000 thru 0x10fff
6210102( 54 mod 256): SKIPPED (no operation)
6210103( 55 mod 256): SKIPPED (no operation)
6210104( 56 mod 256): DEDUPE 0x58000 thru 0x5cfff	(0x5000 bytes) to 0x50000 thru 0x54fff
6210105( 57 mod 256): FALLOC   0x4ebeb thru 0x5e99e	(0xfdb3 bytes) INTERIOR
6210106( 58 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x3497c	******WWWW
6210107( 59 mod 256): MAPREAD  0x31488 thru 0x3497b	(0x34f4 bytes)
6210108( 60 mod 256): SKIPPED (no operation)
6210109( 61 mod 256): SKIPPED (no operation)
6210110( 62 mod 256): READ     0x15ed6 thru 0x2a400	(0x1452b bytes)
6210111( 63 mod 256): MAPREAD  0x2a917 thru 0x3497b	(0xa065 bytes)
6210112( 64 mod 256): MAPREAD  0x1cab6 thru 0x24bf6	(0x8141 bytes)
6210113( 65 mod 256): ZERO     0x336cd thru 0x52209	(0x1eb3d bytes)
6210114( 66 mod 256): INSERT 0x4f000 thru 0x6bfff	(0x1d000 bytes)
6210115( 67 mod 256): FALLOC   0x11d31 thru 0x21f1a	(0x101e9 bytes) INTERIOR
6210116( 68 mod 256): PUNCH    0x26e67 thru 0x3e64d	(0x177e7 bytes)
6210117( 69 mod 256): PUNCH    0x28a19 thru 0x295da	(0xbc2 bytes)
6210118( 70 mod 256): WRITE    0x6dbf4 thru 0x795f8	(0xba05 bytes) EXTEND	***WWWW
6210119( 71 mod 256): FALLOC   0x58997 thru 0x70f36	(0x1859f bytes) INTERIOR	******FFFF
6210120( 72 mod 256): PUNCH    0x5d3bd thru 0x5eadd	(0x1721 bytes)
6210121( 73 mod 256): FALLOC   0x32fef thru 0x35461	(0x2472 bytes) INTERIOR
6210122( 74 mod 256): MAPREAD  0x33532 thru 0x42025	(0xeaf4 bytes)
6210123( 75 mod 256): COPY 0x32146 thru 0x3a936	(0x87f1 bytes) to 0x69282 thru 0x71a72	******EEEE
6210124( 76 mod 256): SKIPPED (no operation)
6210125( 77 mod 256): FALLOC   0x6563e thru 0x7c98a	(0x1734c bytes) EXTENDING	******FFFF
6210126( 78 mod 256): DEDUPE 0x5000 thru 0x6fff	(0x2000 bytes) to 0x4f000 thru 0x50fff
6210127( 79 mod 256): PUNCH    0x705bc thru 0x7b9a7	(0xb3ec bytes)
6210128( 80 mod 256): TRUNCATE DOWN	from 0x7c98a to 0x126c1	******WWWW
6210129( 81 mod 256): MAPWRITE 0x56d48 thru 0x619fe	(0xacb7 bytes)
6210130( 82 mod 256): FALLOC   0x7ab74 thru 0x7f36a	(0x47f6 bytes) PAST_EOF
6210131( 83 mod 256): MAPREAD  0x3b3aa thru 0x4191d	(0x6574 bytes)
6210132( 84 mod 256): SKIPPED (no operation)
6210133( 85 mod 256): ZERO     0x6e6cb thru 0x7fd45	(0x1167b bytes)	******ZZZZ
6210134( 86 mod 256): COPY 0x151ff thru 0x22ace	(0xd8d0 bytes) to 0x3e7b0 thru 0x4c07f
6210135( 87 mod 256): COPY 0x22e9 thru 0x12555	(0x1026d bytes) to 0x2c0ca thru 0x3c336
6210136( 88 mod 256): CLONE 0x45000 thru 0x46fff	(0x2000 bytes) to 0x4e000 thru 0x4ffff
6210137( 89 mod 256): MAPWRITE 0x8d329 thru 0x927bf	(0x5497 bytes)
6210138( 90 mod 256): SKIPPED (no operation)
6210139( 91 mod 256): CLONE 0x1e000 thru 0x31fff	(0x14000 bytes) to 0x5000 thru 0x18fff
6210140( 92 mod 256): SKIPPED (no operation)
6210141( 93 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xa498	******WWWW
6210142( 94 mod 256): CLONE 0x1000 thru 0x8fff	(0x8000 bytes) to 0x84000 thru 0x8bfff
6210143( 95 mod 256): MAPWRITE 0x82d38 thru 0x927bf	(0xfa88 bytes)
6210144( 96 mod 256): CLONE 0x48000 thru 0x55fff	(0xe000 bytes) to 0x78000 thru 0x85fff
6210145( 97 mod 256): COPY 0x486e5 thru 0x4c15e	(0x3a7a bytes) to 0xe4d7 thru 0x11f50
6210146( 98 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x925c8
6210147( 99 mod 256): FALLOC   0x43d8b thru 0x60ed3	(0x1d148 bytes) INTERIOR
6210148(100 mod 256): COPY 0x4a6d5 thru 0x61e47	(0x17773 bytes) to 0x677e thru 0x1def0
6210149(101 mod 256): COLLAPSE 0x7d000 thru 0x8ffff	(0x13000 bytes)
6210150(102 mod 256): COLLAPSE 0x37000 thru 0x4efff	(0x18000 bytes)
6210151(103 mod 256): SKIPPED (no operation)
6210152(104 mod 256): FALLOC   0x69598 thru 0x73c47	(0xa6af bytes) EXTENDING	******FFFF
6210153(105 mod 256): SKIPPED (no operation)
6210154(106 mod 256): INSERT 0x44000 thru 0x4cfff	(0x9000 bytes)
6210155(107 mod 256): READ     0x3b072 thru 0x453c8	(0xa357 bytes)
6210156(108 mod 256): WRITE    0xc6c8 thru 0x1a2fe	(0xdc37 bytes)
6210157(109 mod 256): ZERO     0x8ebe3 thru 0x927bf	(0x3bdd bytes)
6210158(110 mod 256): FALLOC   0x264cc thru 0x39338	(0x12e6c bytes) INTERIOR
6210159(111 mod 256): WRITE    0x11f90 thru 0x1bdc4	(0x9e35 bytes)
6210160(112 mod 256): MAPREAD  0x3b35a thru 0x4693c	(0xb5e3 bytes)
6210161(113 mod 256): CLONE 0x66000 thru 0x7afff	(0x15000 bytes) to 0x20000 thru 0x34fff	JJJJ******
6210162(114 mod 256): CLONE 0x1000 thru 0x18fff	(0x18000 bytes) to 0x41000 thru 0x58fff
6210163(115 mod 256): PUNCH    0x12d67 thru 0x20889	(0xdb23 bytes)
6210164(116 mod 256): COPY 0x6aa2f thru 0x7cc46	(0x12218 bytes) to 0x2da15 thru 0x3fc2c	EEEE******
6210165(117 mod 256): ZERO     0x73ee1 thru 0x8c8a7	(0x189c7 bytes)
6210166(118 mod 256): MAPREAD  0x5fcf0 thru 0x70c73	(0x10f84 bytes)	***RRRR***
6210167(119 mod 256): INSERT 0x71000 thru 0x85fff	(0x15000 bytes)
6210168(120 mod 256): SKIPPED (no operation)
6210169(121 mod 256): SKIPPED (no operation)
6210170(122 mod 256): WRITE    0xe500 thru 0x191b2	(0xacb3 bytes)
6210171(123 mod 256): SKIPPED (no operation)
6210172(124 mod 256): MAPWRITE 0x1d2f4 thru 0x27ad2	(0xa7df bytes)
6210173(125 mod 256): FALLOC   0x318ac thru 0x4013d	(0xe891 bytes) INTERIOR
6210174(126 mod 256): TRUNCATE DOWN	from 0x91c47 to 0x69dc9	******WWWW
6210175(127 mod 256): TRUNCATE DOWN	from 0x69dc9 to 0x4cc5e
6210176(128 mod 256): ZERO     0xcdd3 thru 0x1967a	(0xc8a8 bytes)
6210177(129 mod 256): WRITE    0x5707f thru 0x6c369	(0x152eb bytes) HOLE
6210178(130 mod 256): INSERT 0x41000 thru 0x45fff	(0x5000 bytes)
6210179(131 mod 256): ZERO     0x25a42 thru 0x3b4a9	(0x15a68 bytes)
6210180(132 mod 256): MAPWRITE 0x8101 thru 0x1a2ab	(0x121ab bytes)
6210181(133 mod 256): MAPWRITE 0x3b642 thru 0x50e3f	(0x157fe bytes)
6210182(134 mod 256): TRUNCATE DOWN	from 0x7136a to 0x2210d	******WWWW
6210183(135 mod 256): CLONE 0x12000 thru 0x20fff	(0xf000 bytes) to 0x54000 thru 0x62fff
6210184(136 mod 256): READ     0x47d4e thru 0x54c39	(0xceec bytes)
6210185(137 mod 256): MAPREAD  0xc9dc thru 0x1d931	(0x10f56 bytes)
6210186(138 mod 256): PUNCH    0xa609 thru 0x1f86e	(0x15266 bytes)
6210187(139 mod 256): CLONE 0xd000 thru 0x23fff	(0x17000 bytes) to 0x2d000 thru 0x43fff
6210188(140 mod 256): INSERT 0x3a000 thru 0x41fff	(0x8000 bytes)
6210189(141 mod 256): DEDUPE 0x3a000 thru 0x4bfff	(0x12000 bytes) to 0x16000 thru 0x27fff
6210190(142 mod 256): MAPREAD  0x253e3 thru 0x2dfda	(0x8bf8 bytes)
6210191(143 mod 256): COPY 0xbf42 thru 0xef2b	(0x2fea bytes) to 0x75f06 thru 0x78eef
6210192(144 mod 256): ZERO     0x4d641 thru 0x6c074	(0x1ea34 bytes)
6210193(145 mod 256): MAPWRITE 0x396d0 thru 0x4f0f1	(0x15a22 bytes)
6210194(146 mod 256): MAPREAD  0x3dca7 thru 0x54519	(0x16873 bytes)
6210195(147 mod 256): COPY 0x544 thru 0x1e39e	(0x1de5b bytes) to 0x681cc thru 0x86026	******EEEE
6210196(148 mod 256): READ     0x23f78 thru 0x40156	(0x1c1df bytes)
6210197(149 mod 256): WRITE    0x60efe thru 0x706d7	(0xf7da bytes)	***WWWW
6210198(150 mod 256): FALLOC   0x4bdce thru 0x5d469	(0x1169b bytes) INTERIOR
6210199(151 mod 256): TRUNCATE DOWN	from 0x86027 to 0x45381	******WWWW
6210200(152 mod 256): COPY 0x35423 thru 0x45380	(0xff5e bytes) to 0x4bad1 thru 0x5ba2e
6210201(153 mod 256): COPY 0xd5af thru 0x21d7e	(0x147d0 bytes) to 0x34b7e thru 0x4934d
6210202(154 mod 256): CLONE 0x25000 thru 0x26fff	(0x2000 bytes) to 0x16000 thru 0x17fff
6210203(155 mod 256): MAPWRITE 0x63c13 thru 0x73a85	(0xfe73 bytes)	******WWWW
6210204(156 mod 256): SKIPPED (no operation)
6210205(157 mod 256): MAPREAD  0x47979 thru 0x60f90	(0x19618 bytes)
6210206(158 mod 256): WRITE    0xb437 thru 0x16fda	(0xbba4 bytes)
6210207(159 mod 256): MAPREAD  0x1f1d4 thru 0x2443d	(0x526a bytes)
6210208(160 mod 256): ZERO     0x3bc83 thru 0x46b98	(0xaf16 bytes)
6210209(161 mod 256): ZERO     0x4d578 thru 0x5234c	(0x4dd5 bytes)
6210210(162 mod 256): COPY 0x73049 thru 0x73a85	(0xa3d bytes) to 0xc00d thru 0xca49
6210211(163 mod 256): SKIPPED (no operation)
6210212(164 mod 256): PUNCH    0x24162 thru 0x3f369	(0x1b208 bytes)
6210213(165 mod 256): TRUNCATE UP	from 0x73a86 to 0x75a90
6210214(166 mod 256): FALLOC   0x26e6c thru 0x2e1e2	(0x7376 bytes) INTERIOR
6210215(167 mod 256): CLONE 0x36000 thru 0x37fff	(0x2000 bytes) to 0x5000 thru 0x6fff
6210216(168 mod 256): FALLOC   0x6f942 thru 0x7c995	(0xd053 bytes) PAST_EOF
6210217(169 mod 256): DEDUPE 0x30000 thru 0x48fff	(0x19000 bytes) to 0x4000 thru 0x1cfff
6210218(170 mod 256): ZERO     0x2f0f8 thru 0x3a186	(0xb08f bytes)
6210219(171 mod 256): TRUNCATE DOWN	from 0x75a90 to 0x504f0	******WWWW
6210220(172 mod 256): ZERO     0x51b86 thru 0x55320	(0x379b bytes)
6210221(173 mod 256): TRUNCATE UP	from 0x55321 to 0x554c7
6210222(174 mod 256): INSERT 0x43000 thru 0x43fff	(0x1000 bytes)
6210223(175 mod 256): DEDUPE 0x15000 thru 0x22fff	(0xe000 bytes) to 0x33000 thru 0x40fff
6210224(176 mod 256): PUNCH    0x2b13 thru 0x1a5d7	(0x17ac5 bytes)
6210225(177 mod 256): ZERO     0x82e86 thru 0x927bf	(0xf93a bytes)
6210226(178 mod 256): PUNCH    0x29d0c thru 0x4103a	(0x1732f bytes)
6210227(179 mod 256): DEDUPE 0x10000 thru 0x2bfff	(0x1c000 bytes) to 0x38000 thru 0x53fff
6210228(180 mod 256): MAPREAD  0x746f thru 0x166f7	(0xf289 bytes)
6210229(181 mod 256): COLLAPSE 0x38000 thru 0x48fff	(0x11000 bytes)
6210230(182 mod 256): CLONE 0x1e000 thru 0x2dfff	(0x10000 bytes) to 0x5a000 thru 0x69fff
6210231(183 mod 256): FALLOC   0x879af thru 0x927c0	(0xae11 bytes) EXTENDING
6210232(184 mod 256): MAPREAD  0x86d68 thru 0x927bf	(0xba58 bytes)
6210233(185 mod 256): ZERO     0x3eb14 thru 0x51a85	(0x12f72 bytes)
6210234(186 mod 256): COPY 0x5a714 thru 0x6f871	(0x1515e bytes) to 0x77139 thru 0x8c296	EEEE******
6210235(187 mod 256): COPY 0x25285 thru 0x3a95c	(0x156d8 bytes) to 0x738cb thru 0x88fa2
6210236(188 mod 256): FALLOC   0x22235 thru 0x287b6	(0x6581 bytes) INTERIOR
6210237(189 mod 256): MAPWRITE 0x3642e thru 0x3d2c7	(0x6e9a bytes)
6210238(190 mod 256): READ     0x964a thru 0x22623	(0x18fda bytes)
6210239(191 mod 256): CLONE 0x44000 thru 0x4efff	(0xb000 bytes) to 0x2a000 thru 0x34fff
6210240(192 mod 256): MAPWRITE 0x10d98 thru 0x1838e	(0x75f7 bytes)
6210241(193 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1e4c2	******WWWW
6210242(194 mod 256): TRUNCATE UP	from 0x1e4c2 to 0x65b28
6210243(195 mod 256): SKIPPED (no operation)
6210244(196 mod 256): ZERO     0x3de69 thru 0x5c252	(0x1e3ea bytes)
6210245(197 mod 256): MAPWRITE 0x53872 thru 0x6ef1b	(0x1b6aa bytes)
6210246(198 mod 256): WRITE    0x6c856 thru 0x732aa	(0x6a55 bytes) EXTEND	***WWWW
6210247(199 mod 256): SKIPPED (no operation)
6210248(200 mod 256): READ     0x464bb thru 0x63e9a	(0x1d9e0 bytes)
6210249(201 mod 256): COPY 0x2700f thru 0x42c69	(0x1bc5b bytes) to 0x8ea1 thru 0x24afb
6210250(202 mod 256): READ     0x641ff thru 0x732aa	(0xf0ac bytes)	***RRRR***
6210251(203 mod 256): CLONE 0x2b000 thru 0x39fff	(0xf000 bytes) to 0x53000 thru 0x61fff
6210252(204 mod 256): COPY 0x4bee6 thru 0x6aec7	(0x1efe2 bytes) to 0xb7ea thru 0x2a7cb
6210253(205 mod 256): FALLOC   0x34d5 thru 0xcc2b	(0x9756 bytes) INTERIOR
6210254(206 mod 256): ZERO     0x8b328 thru 0x8de21	(0x2afa bytes)
6210255(207 mod 256): FALLOC   0x777c thru 0x1a29a	(0x12b1e bytes) INTERIOR
6210256(208 mod 256): ZERO     0x69c0a thru 0x84651	(0x1aa48 bytes)	******ZZZZ
6210257(209 mod 256): READ     0x46e57 thru 0x5ff62	(0x1910c bytes)
6210258(210 mod 256): ZERO     0x61a3f thru 0x61dec	(0x3ae bytes)
6210259(211 mod 256): DEDUPE 0x8c000 thru 0x8cfff	(0x1000 bytes) to 0x65000 thru 0x65fff
6210260(212 mod 256): MAPREAD  0x1eea0 thru 0x1f14d	(0x2ae bytes)
6210261(213 mod 256): FALLOC   0x66c7f thru 0x81e76	(0x1b1f7 bytes) INTERIOR	******FFFF
6210262(214 mod 256): READ     0x4938a thru 0x495f8	(0x26f bytes)
6210263(215 mod 256): WRITE    0x88d06 thru 0x927bf	(0x9aba bytes) EXTEND
6210264(216 mod 256): CLONE 0x52000 thru 0x5efff	(0xd000 bytes) to 0xe000 thru 0x1afff
6210265(217 mod 256): MAPREAD  0x79fc7 thru 0x81a27	(0x7a61 bytes)
6210266(218 mod 256): WRITE    0x60c79 thru 0x6af36	(0xa2be bytes)
6210267(219 mod 256): MAPREAD  0x21de3 thru 0x3da2a	(0x1bc48 bytes)
6210268(220 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x43081	******WWWW
6210269(221 mod 256): FALLOC   0x823a8 thru 0x927c0	(0x10418 bytes) EXTENDING
6210270(222 mod 256): ZERO     0x2b41b thru 0x49609	(0x1e1ef bytes)
6210271(223 mod 256): COPY 0x86ad thru 0x1315b	(0xaaaf bytes) to 0x68073 thru 0x72b21	******EEEE
6210272(224 mod 256): READ     0x43c63 thru 0x4b9be	(0x7d5c bytes)
6210273(225 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2b385	******WWWW
6210274(226 mod 256): COLLAPSE 0x29000 thru 0x2afff	(0x2000 bytes)
6210275(227 mod 256): ZERO     0x4f54a thru 0x52cd5	(0x378c bytes)
6210276(228 mod 256): PUNCH    0x14d0a thru 0x29384	(0x1467b bytes)
6210277(229 mod 256): MAPWRITE 0x6e11d thru 0x83e2f	(0x15d13 bytes)	******WWWW
6210278(230 mod 256): COPY 0x2617 thru 0x37a2	(0x118c bytes) to 0x18e68 thru 0x19ff3
6210279(231 mod 256): INSERT 0x19000 thru 0x21fff	(0x9000 bytes)
6210280(232 mod 256): COLLAPSE 0x5b000 thru 0x69fff	(0xf000 bytes)
6210281(233 mod 256): PUNCH    0x27f48 thru 0x3a06e	(0x12127 bytes)
6210282(234 mod 256): SKIPPED (no operation)
6210283(235 mod 256): INSERT 0x44000 thru 0x57fff	(0x14000 bytes)
6210284(236 mod 256): COPY 0x71aa6 thru 0x81f5d	(0x104b8 bytes) to 0x49407 thru 0x598be
6210285(237 mod 256): PUNCH    0x82fe3 thru 0x890db	(0x60f9 bytes)
6210286(238 mod 256): PUNCH    0x5ac5b thru 0x6c6cf	(0x11a75 bytes)
6210287(239 mod 256): ZERO     0x7cbda thru 0x7d282	(0x6a9 bytes)
6210288(240 mod 256): CLONE 0x58000 thru 0x5afff	(0x3000 bytes) to 0x46000 thru 0x48fff
6210289(241 mod 256): COPY 0x20d68 thru 0x327bf	(0x11a58 bytes) to 0x3c848 thru 0x4e29f
6210290(242 mod 256): COPY 0xed21 thru 0x1bbec	(0xcecc bytes) to 0x70e31 thru 0x7dcfc
6210291(243 mod 256): MAPWRITE 0x1090a thru 0x205ac	(0xfca3 bytes)
6210292(244 mod 256): WRITE    0x5ea82 thru 0x7a2a9	(0x1b828 bytes)	***WWWW
6210293(245 mod 256): PUNCH    0x20d9c thru 0x27e6c	(0x70d1 bytes)
6210294(246 mod 256): TRUNCATE DOWN	from 0x91e30 to 0x67bf2	******WWWW
6210295(247 mod 256): WRITE    0x53f7 thru 0x66d0	(0x12da bytes)
6210296(248 mod 256): READ     0x3cd26 thru 0x532e1	(0x165bc bytes)
6210297(249 mod 256): SKIPPED (no operation)
6210298(250 mod 256): MAPREAD  0x1ef thru 0x65b9	(0x63cb bytes)
6210299(251 mod 256): SKIPPED (no operation)
6210300(252 mod 256): COLLAPSE 0x1000 thru 0x16fff	(0x16000 bytes)
6210301(253 mod 256): CLONE 0x1b000 thru 0x1cfff	(0x2000 bytes) to 0xc000 thru 0xdfff
6210302(254 mod 256): FALLOC   0x3efa7 thru 0x49f36	(0xaf8f bytes) INTERIOR
6210303(255 mod 256): COLLAPSE 0x14000 thru 0x28fff	(0x15000 bytes)
6210304(  0 mod 256): MAPWRITE 0x5f530 thru 0x66703	(0x71d4 bytes)
6210305(  1 mod 256): INSERT 0x62000 thru 0x79fff	(0x18000 bytes)	******IIII
6210306(  2 mod 256): WRITE    0x58a11 thru 0x63f50	(0xb540 bytes)
6210307(  3 mod 256): CLONE 0x61000 thru 0x6cfff	(0xc000 bytes) to 0x36000 thru 0x41fff
6210308(  4 mod 256): COLLAPSE 0x6c000 thru 0x7cfff	(0x11000 bytes)	******CCCC
6210309(  5 mod 256): PUNCH    0x45efd thru 0x646ae	(0x1e7b2 bytes)
6210310(  6 mod 256): PUNCH    0x318e1 thru 0x4a94c	(0x1906c bytes)
6210311(  7 mod 256): CLONE 0x1d000 thru 0x2ffff	(0x13000 bytes) to 0x4f000 thru 0x61fff
6210312(  8 mod 256): COLLAPSE 0x2b000 thru 0x38fff	(0xe000 bytes)
6210313(  9 mod 256): FALLOC   0x4b8c1 thru 0x4ba3f	(0x17e bytes) INTERIOR
6210314( 10 mod 256): SKIPPED (no operation)
6210315( 11 mod 256): TRUNCATE DOWN	from 0x5f704 to 0x237bf
6210316( 12 mod 256): ZERO     0x8882f thru 0x88b36	(0x308 bytes)
6210317( 13 mod 256): WRITE    0x3f029 thru 0x403a6	(0x137e bytes) HOLE
6210318( 14 mod 256): PUNCH    0xe21 thru 0xa1f7	(0x93d7 bytes)
6210319( 15 mod 256): COLLAPSE 0x11000 thru 0x23fff	(0x13000 bytes)
6210320( 16 mod 256): DEDUPE 0x1e000 thru 0x2bfff	(0xe000 bytes) to 0x5000 thru 0x12fff
6210321( 17 mod 256): COPY 0xeb70 thru 0x2b819	(0x1ccaa bytes) to 0x594d4 thru 0x7617d	******EEEE
6210322( 18 mod 256): PUNCH    0x2e8ec thru 0x4742f	(0x18b44 bytes)
6210323( 19 mod 256): WRITE    0x2c006 thru 0x401a0	(0x1419b bytes)
6210324( 20 mod 256): COPY 0x3ce87 thru 0x48114	(0xb28e bytes) to 0x17f6a thru 0x231f7
6210325( 21 mod 256): MAPWRITE 0xfc13 thru 0x2a0e5	(0x1a4d3 bytes)
6210326( 22 mod 256): PUNCH    0x57ccd thru 0x61f6e	(0xa2a2 bytes)
6210327( 23 mod 256): WRITE    0x5cf95 thru 0x673ee	(0xa45a bytes)
6210328( 24 mod 256): MAPREAD  0x24dc6 thru 0x34a0f	(0xfc4a bytes)
6210329( 25 mod 256): MAPREAD  0x1b96a thru 0x2e3d5	(0x12a6c bytes)
6210330( 26 mod 256): SKIPPED (no operation)
6210331( 27 mod 256): DEDUPE 0x9000 thru 0x21fff	(0x19000 bytes) to 0x34000 thru 0x4cfff
6210332( 28 mod 256): MAPWRITE 0x64a16 thru 0x7b244	(0x1682f bytes)	******WWWW
6210333( 29 mod 256): SKIPPED (no operation)
6210334( 30 mod 256): FALLOC   0x44c78 thru 0x55ffb	(0x11383 bytes) INTERIOR
6210335( 31 mod 256): COPY 0x5e37c thru 0x7ad5f	(0x1c9e4 bytes) to 0x1b280 thru 0x37c63	EEEE******
6210336( 32 mod 256): READ     0x68391 thru 0x7079a	(0x840a bytes)	***RRRR***
6210337( 33 mod 256): DEDUPE 0x22000 thru 0x2bfff	(0xa000 bytes) to 0x64000 thru 0x6dfff
6210338( 34 mod 256): PUNCH    0x6340f thru 0x6c7f8	(0x93ea bytes)
6210339( 35 mod 256): CLONE 0x1c000 thru 0x2efff	(0x13000 bytes) to 0x46000 thru 0x58fff
6210340( 36 mod 256): MAPREAD  0x18a81 thru 0x1b383	(0x2903 bytes)
6210341( 37 mod 256): CLONE 0x14000 thru 0x23fff	(0x10000 bytes) to 0x78000 thru 0x87fff
6210342( 38 mod 256): WRITE    0x6f089 thru 0x72cda	(0x3c52 bytes)
6210343( 39 mod 256): WRITE    0x90ea3 thru 0x927bf	(0x191d bytes) HOLE
6210344( 40 mod 256): COPY 0x304d2 thru 0x31a68	(0x1597 bytes) to 0x5de39 thru 0x5f3cf
6210345( 41 mod 256): SKIPPED (no operation)
6210346( 42 mod 256): WRITE    0x302b1 thru 0x40e15	(0x10b65 bytes)
6210347( 43 mod 256): DEDUPE 0x24000 thru 0x34fff	(0x11000 bytes) to 0x3c000 thru 0x4cfff
6210348( 44 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x22f3	******WWWW
6210349( 45 mod 256): SKIPPED (no operation)
6210350( 46 mod 256): PUNCH    0x947 thru 0x22f2	(0x19ac bytes)
6210351( 47 mod 256): WRITE    0x8e697 thru 0x927bf	(0x4129 bytes) HOLE	***WWWW
6210352( 48 mod 256): READ     0x2e7de thru 0x2f431	(0xc54 bytes)
6210353( 49 mod 256): MAPWRITE 0x2cba5 thru 0x2d43d	(0x899 bytes)
6210354( 50 mod 256): READ     0x33df8 thru 0x3700d	(0x3216 bytes)
6210355( 51 mod 256): PUNCH    0x2eb58 thru 0x4d1b6	(0x1e65f bytes)
6210356( 52 mod 256): COPY 0x8be95 thru 0x927bf	(0x692b bytes) to 0x37ec1 thru 0x3e7eb
6210357( 53 mod 256): SKIPPED (no operation)
6210358( 54 mod 256): PUNCH    0x61bfe thru 0x74064	(0x12467 bytes)	******PPPP
6210359( 55 mod 256): SKIPPED (no operation)
6210360( 56 mod 256): READ     0x26082 thru 0x3b9b2	(0x15931 bytes)
6210361( 57 mod 256): ZERO     0x8540d thru 0x927bf	(0xd3b3 bytes)
6210362( 58 mod 256): FALLOC   0x8cde thru 0x13106	(0xa428 bytes) INTERIOR
6210363( 59 mod 256): COPY 0x91fa9 thru 0x927bf	(0x817 bytes) to 0x202ef thru 0x20b05
6210364( 60 mod 256): FALLOC   0x2cae2 thru 0x3aba0	(0xe0be bytes) INTERIOR
6210365( 61 mod 256): DEDUPE 0x20000 thru 0x35fff	(0x16000 bytes) to 0x5b000 thru 0x70fff	******BBBB
6210366( 62 mod 256): PUNCH    0x4dd94 thru 0x69d72	(0x1bfdf bytes)
6210367( 63 mod 256): FALLOC   0x13ddb thru 0x1906f	(0x5294 bytes) INTERIOR
6210368( 64 mod 256): CLONE 0x65000 thru 0x72fff	(0xe000 bytes) to 0x19000 thru 0x26fff	JJJJ******
6210369( 65 mod 256): PUNCH    0x8652a thru 0x90dd3	(0xa8aa bytes)
6210370( 66 mod 256): COLLAPSE 0x4d000 thru 0x4dfff	(0x1000 bytes)
6210371( 67 mod 256): DEDUPE 0x2f000 thru 0x33fff	(0x5000 bytes) to 0x77000 thru 0x7bfff
6210372( 68 mod 256): DEDUPE 0x90000 thru 0x90fff	(0x1000 bytes) to 0x27000 thru 0x27fff
6210373( 69 mod 256): DEDUPE 0x37000 thru 0x3afff	(0x4000 bytes) to 0x30000 thru 0x33fff
6210374( 70 mod 256): DEDUPE 0x3000 thru 0xdfff	(0xb000 bytes) to 0x26000 thru 0x30fff
6210375( 71 mod 256): PUNCH    0x51f58 thru 0x579e5	(0x5a8e bytes)
6210376( 72 mod 256): INSERT 0x7a000 thru 0x7afff	(0x1000 bytes)
6210377( 73 mod 256): MAPREAD  0x31cdb thru 0x38cab	(0x6fd1 bytes)
6210378( 74 mod 256): CLONE 0x20000 thru 0x31fff	(0x12000 bytes) to 0x3f000 thru 0x50fff
6210379( 75 mod 256): SKIPPED (no operation)
6210380( 76 mod 256): WRITE    0x6e3d2 thru 0x7b452	(0xd081 bytes)	***WWWW
6210381( 77 mod 256): MAPREAD  0x6de00 thru 0x8798a	(0x19b8b bytes)	***RRRR***
6210382( 78 mod 256): MAPWRITE 0x710cd thru 0x7bc53	(0xab87 bytes)
6210383( 79 mod 256): DEDUPE 0x85000 thru 0x90fff	(0xc000 bytes) to 0x5e000 thru 0x69fff
6210384( 80 mod 256): ZERO     0x7076e thru 0x75cd3	(0x5566 bytes)
6210385( 81 mod 256): PUNCH    0x435de thru 0x59ca1	(0x166c4 bytes)
6210386( 82 mod 256): READ     0x667d2 thru 0x7c2c4	(0x15af3 bytes)	***RRRR***
6210387( 83 mod 256): PUNCH    0x65ab6 thru 0x7c75c	(0x16ca7 bytes)	******PPPP
6210388( 84 mod 256): FALLOC   0x72409 thru 0x8046d	(0xe064 bytes) INTERIOR
6210389( 85 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x369e5	******WWWW
6210390( 86 mod 256): WRITE    0xbb6d thru 0x21aa8	(0x15f3c bytes)
6210391( 87 mod 256): TRUNCATE DOWN	from 0x369e5 to 0x2dd78
6210392( 88 mod 256): PUNCH    0xc607 thru 0x1704f	(0xaa49 bytes)
6210393( 89 mod 256): CLONE 0x1c000 thru 0x2bfff	(0x10000 bytes) to 0x56000 thru 0x65fff
6210394( 90 mod 256): MAPREAD  0x46393 thru 0x5668a	(0x102f8 bytes)
6210395( 91 mod 256): PUNCH    0x3d17d thru 0x45119	(0x7f9d bytes)
6210396( 92 mod 256): ZERO     0xdbc4 thru 0x2c5d1	(0x1ea0e bytes)
6210397( 93 mod 256): INSERT 0x2e000 thru 0x42fff	(0x15000 bytes)
6210398( 94 mod 256): CLONE 0x51000 thru 0x69fff	(0x19000 bytes) to 0x74000 thru 0x8cfff
6210399( 95 mod 256): MAPWRITE 0x8340b thru 0x85b5f	(0x2755 bytes)
6210400( 96 mod 256): COPY 0x2f88a thru 0x40b38	(0x112af bytes) to 0x57d1b thru 0x68fc9
6210401( 97 mod 256): MAPREAD  0x2838b thru 0x28461	(0xd7 bytes)
6210402( 98 mod 256): TRUNCATE DOWN	from 0x8d000 to 0x243ac	******WWWW
6210403( 99 mod 256): MAPWRITE 0x17085 thru 0x31687	(0x1a603 bytes)
6210404(100 mod 256): FALLOC   0x5986b thru 0x60037	(0x67cc bytes) PAST_EOF
6210405(101 mod 256): COPY 0x62a6 thru 0x2082e	(0x1a589 bytes) to 0x53ab5 thru 0x6e03d
6210406(102 mod 256): WRITE    0x64d4a thru 0x80d4d	(0x1c004 bytes) EXTEND	***WWWW
6210407(103 mod 256): COPY 0x7b3db thru 0x80d4d	(0x5973 bytes) to 0x3faa1 thru 0x45413
6210408(104 mod 256): DEDUPE 0x3d000 thru 0x54fff	(0x18000 bytes) to 0x5a000 thru 0x71fff	******BBBB
6210409(105 mod 256): CLONE 0x1b000 thru 0x25fff	(0xb000 bytes) to 0x4f000 thru 0x59fff
6210410(106 mod 256): CLONE 0x74000 thru 0x74fff	(0x1000 bytes) to 0x70000 thru 0x70fff
6210411(107 mod 256): FALLOC   0x28514 thru 0x37fa4	(0xfa90 bytes) INTERIOR
6210412(108 mod 256): SKIPPED (no operation)
6210413(109 mod 256): COLLAPSE 0xb000 thru 0x21fff	(0x17000 bytes)
6210414(110 mod 256): FALLOC   0x5b5d0 thru 0x63363	(0x7d93 bytes) INTERIOR
6210415(111 mod 256): PUNCH    0x40f50 thru 0x54660	(0x13711 bytes)
6210416(112 mod 256): COLLAPSE 0x9000 thru 0x1afff	(0x12000 bytes)
6210417(113 mod 256): ZERO     0x640f5 thru 0x798c8	(0x157d4 bytes)	******ZZZZ
6210418(114 mod 256): COLLAPSE 0x28000 thru 0x2afff	(0x3000 bytes)
6210419(115 mod 256): MAPREAD  0x2f245 thru 0x44a27	(0x157e3 bytes)
6210420(116 mod 256): MAPWRITE 0x61063 thru 0x75df9	(0x14d97 bytes)	******WWWW
6210421(117 mod 256): READ     0x28250 thru 0x417af	(0x19560 bytes)
6210422(118 mod 256): FALLOC   0x80da7 thru 0x8b89e	(0xaaf7 bytes) EXTENDING
6210423(119 mod 256): MAPREAD  0x593fb thru 0x78130	(0x1ed36 bytes)	***RRRR***
6210424(120 mod 256): MAPREAD  0x5a7db thru 0x5c05f	(0x1885 bytes)
6210425(121 mod 256): COLLAPSE 0x59000 thru 0x70fff	(0x18000 bytes)	******CCCC
6210426(122 mod 256): FALLOC   0x36687 thru 0x423fc	(0xbd75 bytes) INTERIOR
6210427(123 mod 256): TRUNCATE DOWN	from 0x7389e to 0x5dd2a	******WWWW
6210428(124 mod 256): SKIPPED (no operation)
6210429(125 mod 256): FALLOC   0x86a4 thru 0x1e670	(0x15fcc bytes) INTERIOR
6210430(126 mod 256): ZERO     0x7da51 thru 0x7dbc9	(0x179 bytes)
6210431(127 mod 256): MAPWRITE 0x9738 thru 0xbd0a	(0x25d3 bytes)
6210432(128 mod 256): FALLOC   0x27f15 thru 0x31a84	(0x9b6f bytes) INTERIOR
6210433(129 mod 256): ZERO     0x49c61 thru 0x61c66	(0x18006 bytes)
6210434(130 mod 256): READ     0x60c63 thru 0x61c66	(0x1004 bytes)
6210435(131 mod 256): TRUNCATE UP	from 0x61c67 to 0x914bc	******WWWW
6210436(132 mod 256): COLLAPSE 0x30000 thru 0x37fff	(0x8000 bytes)
6210437(133 mod 256): INSERT 0x1a000 thru 0x22fff	(0x9000 bytes)
6210438(134 mod 256): COLLAPSE 0x2e000 thru 0x2efff	(0x1000 bytes)
6210439(135 mod 256): READ     0x82b91 thru 0x90caa	(0xe11a bytes)
6210440(136 mod 256): COLLAPSE 0x3d000 thru 0x46fff	(0xa000 bytes)
6210441(137 mod 256): MAPREAD  0x6b262 thru 0x86412	(0x1b1b1 bytes)	***RRRR***
6210442(138 mod 256): COPY 0x546b4 thru 0x60164	(0xbab1 bytes) to 0x81365 thru 0x8ce15
6210443(139 mod 256): MAPREAD  0x1bcfd thru 0x274f8	(0xb7fc bytes)
6210444(140 mod 256): COLLAPSE 0x37000 thru 0x3bfff	(0x5000 bytes)
6210445(141 mod 256): MAPREAD  0x47a8c thru 0x668ce	(0x1ee43 bytes)
6210446(142 mod 256): COLLAPSE 0x5b000 thru 0x68fff	(0xe000 bytes)
6210447(143 mod 256): TRUNCATE DOWN	from 0x79e16 to 0x4384d	******WWWW
6210448(144 mod 256): TRUNCATE DOWN	from 0x4384d to 0x3645e
6210449(145 mod 256): FALLOC   0x8c9d1 thru 0x927c0	(0x5def bytes) EXTENDING
6210450(146 mod 256): WRITE    0x91b47 thru 0x927bf	(0xc79 bytes)
6210451(147 mod 256): FALLOC   0x16b9e thru 0x2bddb	(0x1523d bytes) INTERIOR
6210452(148 mod 256): CLONE 0x8e000 thru 0x90fff	(0x3000 bytes) to 0x80000 thru 0x82fff
6210453(149 mod 256): PUNCH    0x66c4 thru 0x18c9f	(0x125dc bytes)
6210454(150 mod 256): SKIPPED (no operation)
6210455(151 mod 256): FALLOC   0x8f27f thru 0x927c0	(0x3541 bytes) INTERIOR
6210456(152 mod 256): DEDUPE 0x1d000 thru 0x35fff	(0x19000 bytes) to 0x74000 thru 0x8cfff
6210457(153 mod 256): ZERO     0x264a thru 0x1d12a	(0x1aae1 bytes)
6210458(154 mod 256): CLONE 0x36000 thru 0x3ffff	(0xa000 bytes) to 0x7f000 thru 0x88fff
6210459(155 mod 256): ZERO     0x91976 thru 0x927bf	(0xe4a bytes)
6210460(156 mod 256): MAPREAD  0x2b77a thru 0x351c3	(0x9a4a bytes)
6210461(157 mod 256): COLLAPSE 0x8e000 thru 0x91fff	(0x4000 bytes)
6210462(158 mod 256): PUNCH    0x59149 thru 0x5a617	(0x14cf bytes)
6210463(159 mod 256): COPY 0xa0ee thru 0x27707	(0x1d61a bytes) to 0x4bbf3 thru 0x6920c
6210464(160 mod 256): TRUNCATE DOWN	from 0x8e7c0 to 0x188fd	******WWWW
6210465(161 mod 256): INSERT 0x3000 thru 0x1afff	(0x18000 bytes)
6210466(162 mod 256): READ     0x2a208 thru 0x2bacc	(0x18c5 bytes)
6210467(163 mod 256): CLONE 0x1c000 thru 0x2efff	(0x13000 bytes) to 0x62000 thru 0x74fff	******JJJJ
6210468(164 mod 256): COPY 0x4317f thru 0x48583	(0x5405 bytes) to 0x3253c thru 0x37940
6210469(165 mod 256): ZERO     0x23c04 thru 0x42952	(0x1ed4f bytes)
6210470(166 mod 256): SKIPPED (no operation)
6210471(167 mod 256): READ     0x320bb thru 0x4edd9	(0x1cd1f bytes)
6210472(168 mod 256): COPY 0x489d2 thru 0x5def8	(0x15527 bytes) to 0x11e96 thru 0x273bc
6210473(169 mod 256): WRITE    0x8f2cc thru 0x91e10	(0x2b45 bytes) HOLE
6210474(170 mod 256): COPY 0x54844 thru 0x63ea5	(0xf662 bytes) to 0x1d65d thru 0x2ccbe
6210475(171 mod 256): ZERO     0x7ae76 thru 0x927bf	(0x1794a bytes)
6210476(172 mod 256): MAPREAD  0x73bb9 thru 0x8aab1	(0x16ef9 bytes)
6210477(173 mod 256): WRITE    0x64ae thru 0x858a	(0x20dd bytes)
6210478(174 mod 256): CLONE 0x35000 thru 0x3afff	(0x6000 bytes) to 0x82000 thru 0x87fff
6210479(175 mod 256): MAPWRITE 0x452e8 thru 0x4e599	(0x92b2 bytes)
6210480(176 mod 256): MAPREAD  0x3d004 thru 0x3faae	(0x2aab bytes)
6210481(177 mod 256): PUNCH    0x36863 thru 0x52ace	(0x1c26c bytes)
6210482(178 mod 256): FALLOC   0x1c0d thru 0xd816	(0xbc09 bytes) INTERIOR
6210483(179 mod 256): READ     0x6d55d thru 0x71670	(0x4114 bytes)	***RRRR***
6210484(180 mod 256): SKIPPED (no operation)
6210485(181 mod 256): ZERO     0x89a87 thru 0x89f8a	(0x504 bytes)
6210486(182 mod 256): PUNCH    0x4e538 thru 0x5940b	(0xaed4 bytes)
6210487(183 mod 256): COPY 0x35748 thru 0x42207	(0xcac0 bytes) to 0x5fd89 thru 0x6c848
6210488(184 mod 256): SKIPPED (no operation)
6210489(185 mod 256): READ     0x3a208 thru 0x4cc50	(0x12a49 bytes)
6210490(186 mod 256): CLONE 0x1b000 thru 0x23fff	(0x9000 bytes) to 0x45000 thru 0x4dfff
6210491(187 mod 256): MAPWRITE 0x485da thru 0x5c51f	(0x13f46 bytes)
6210492(188 mod 256): ZERO     0x8a418 thru 0x8ae6a	(0xa53 bytes)
6210493(189 mod 256): ZERO     0x73c1d thru 0x8e4c2	(0x1a8a6 bytes)
6210494(190 mod 256): ZERO     0x13f56 thru 0x1bdc0	(0x7e6b bytes)
6210495(191 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2e6a5	******WWWW
6210496(192 mod 256): SKIPPED (no operation)
6210497(193 mod 256): ZERO     0x9dac thru 0x26bd4	(0x1ce29 bytes)
6210498(194 mod 256): SKIPPED (no operation)
6210499(195 mod 256): PUNCH    0x293ef thru 0x2e6a4	(0x52b6 bytes)
6210500(196 mod 256): COLLAPSE 0x1000 thru 0x3fff	(0x3000 bytes)
6210501(197 mod 256): READ     0xce7f thru 0x19b08	(0xcc8a bytes)
6210502(198 mod 256): READ     0x26ccd thru 0x2b6a4	(0x49d8 bytes)
6210503(199 mod 256): COPY 0xec0e thru 0xf648	(0xa3b bytes) to 0x33b8a thru 0x345c4
6210504(200 mod 256): CLONE 0x1c000 thru 0x20fff	(0x5000 bytes) to 0x76000 thru 0x7afff
6210505(201 mod 256): COPY 0x57c8a thru 0x73dd9	(0x1c150 bytes) to 0x4bc9 thru 0x20d18	EEEE******
6210506(202 mod 256): COLLAPSE 0x21000 thru 0x36fff	(0x16000 bytes)
6210507(203 mod 256): COPY 0x2f0ed thru 0x4ab38	(0x1ba4c bytes) to 0x66a83 thru 0x824ce	******EEEE
6210508(204 mod 256): MAPREAD  0x44f86 thru 0x510b3	(0xc12e bytes)
6210509(205 mod 256): SKIPPED (no operation)
6210510(206 mod 256): MAPREAD  0x63b75 thru 0x71389	(0xd815 bytes)	***RRRR***
6210511(207 mod 256): ZERO     0x4c8b5 thru 0x59f23	(0xd66f bytes)
6210512(208 mod 256): SKIPPED (no operation)
6210513(209 mod 256): ZERO     0x854c6 thru 0x87a92	(0x25cd bytes)
6210514(210 mod 256): COLLAPSE 0x3000 thru 0x8fff	(0x6000 bytes)
6210515(211 mod 256): INSERT 0x77000 thru 0x86fff	(0x10000 bytes)
6210516(212 mod 256): WRITE    0x776e8 thru 0x927bf	(0x1b0d8 bytes) EXTEND
6210517(213 mod 256): FALLOC   0x89ceb thru 0x8ad68	(0x107d bytes) INTERIOR
6210518(214 mod 256): COLLAPSE 0x60000 thru 0x68fff	(0x9000 bytes)
6210519(215 mod 256): SKIPPED (no operation)
6210520(216 mod 256): TRUNCATE DOWN	from 0x897c0 to 0x62dd3	******WWWW
6210521(217 mod 256): CLONE 0xa000 thru 0x15fff	(0xc000 bytes) to 0x61000 thru 0x6cfff
6210522(218 mod 256): READ     0x569c0 thru 0x6a5ce	(0x13c0f bytes)
6210523(219 mod 256): COLLAPSE 0x11000 thru 0x2bfff	(0x1b000 bytes)
6210524(220 mod 256): COLLAPSE 0x39000 thru 0x4dfff	(0x15000 bytes)
6210525(221 mod 256): COPY 0x39545 thru 0x3cfff	(0x3abb bytes) to 0x8a27f thru 0x8dd39
6210526(222 mod 256): READ     0x7d29f thru 0x8dd39	(0x10a9b bytes)
6210527(223 mod 256): READ     0x6f950 thru 0x8bf38	(0x1c5e9 bytes)
6210528(224 mod 256): COPY 0x70e1b thru 0x81308	(0x104ee bytes) to 0x41f40 thru 0x5242d
6210529(225 mod 256): MAPREAD  0x6a215 thru 0x7ec01	(0x149ed bytes)	***RRRR***
6210530(226 mod 256): CLONE 0x1d000 thru 0x37fff	(0x1b000 bytes) to 0x5c000 thru 0x76fff	******JJJJ
6210531(227 mod 256): DEDUPE 0xd000 thru 0x2afff	(0x1e000 bytes) to 0x41000 thru 0x5efff
6210532(228 mod 256): MAPREAD  0x87eb7 thru 0x8dd39	(0x5e83 bytes)
6210533(229 mod 256): CLONE 0x69000 thru 0x76fff	(0xe000 bytes) to 0x35000 thru 0x42fff	JJJJ******
6210534(230 mod 256): INSERT 0x6c000 thru 0x6ffff	(0x4000 bytes)	******IIII
6210535(231 mod 256): MAPWRITE 0xa9fa thru 0x21bce	(0x171d5 bytes)
6210536(232 mod 256): COPY 0xaf1c thru 0xff68	(0x504d bytes) to 0x35c6b thru 0x3acb7
6210537(233 mod 256): SKIPPED (no operation)
6210538(234 mod 256): COLLAPSE 0x7000 thru 0x18fff	(0x12000 bytes)
6210539(235 mod 256): READ     0x71eba thru 0x7d4ee	(0xb635 bytes)
6210540(236 mod 256): PUNCH    0x700b1 thru 0x7fd39	(0xfc89 bytes)
6210541(237 mod 256): CLONE 0x7e000 thru 0x7efff	(0x1000 bytes) to 0x36000 thru 0x36fff
6210542(238 mod 256): ZERO     0x20fad thru 0x2da11	(0xca65 bytes)
6210543(239 mod 256): TRUNCATE DOWN	from 0x7fd3a to 0x12538	******WWWW
6210544(240 mod 256): PUNCH    0x36d8 thru 0x12537	(0xee60 bytes)
6210545(241 mod 256): SKIPPED (no operation)
6210546(242 mod 256): MAPWRITE 0x2aca2 thru 0x2db4f	(0x2eae bytes)
6210547(243 mod 256): PUNCH    0xdf55 thru 0x18802	(0xa8ae bytes)
6210548(244 mod 256): TRUNCATE UP	from 0x2db50 to 0x3348d
6210549(245 mod 256): READ     0x32641 thru 0x3348c	(0xe4c bytes)
6210550(246 mod 256): COPY 0x1b5e1 thru 0x2c5c9	(0x10fe9 bytes) to 0x5cea0 thru 0x6de88
6210551(247 mod 256): PUNCH    0x54a54 thru 0x644ea	(0xfa97 bytes)
6210552(248 mod 256): MAPREAD  0x6a623 thru 0x6de88	(0x3866 bytes)
6210553(249 mod 256): SKIPPED (no operation)
6210554(250 mod 256): COPY 0x30cd thru 0x12cb6	(0xfbea bytes) to 0x30c58 thru 0x40841
6210555(251 mod 256): WRITE    0x57090 thru 0x73bea	(0x1cb5b bytes) EXTEND	***WWWW
6210556(252 mod 256): WRITE    0x8d4b6 thru 0x927bf	(0x530a bytes) HOLE
6210557(253 mod 256): DEDUPE 0x76000 thru 0x89fff	(0x14000 bytes) to 0x24000 thru 0x37fff
6210558(254 mod 256): PUNCH    0x71a30 thru 0x86dbe	(0x1538f bytes)
6210559(255 mod 256): FALLOC   0x54641 thru 0x5a6dd	(0x609c bytes) INTERIOR
6210560(  0 mod 256): DEDUPE 0x33000 thru 0x33fff	(0x1000 bytes) to 0x4c000 thru 0x4cfff
6210561(  1 mod 256): READ     0x86f59 thru 0x893d1	(0x2479 bytes)
6210562(  2 mod 256): PUNCH    0x787d1 thru 0x927bf	(0x19fef bytes)
6210563(  3 mod 256): COLLAPSE 0x8000 thru 0x17fff	(0x10000 bytes)
6210564(  4 mod 256): MAPWRITE 0x3e216 thru 0x4a054	(0xbe3f bytes)
6210565(  5 mod 256): PUNCH    0x5f504 thru 0x67a9d	(0x859a bytes)
6210566(  6 mod 256): SKIPPED (no operation)
6210567(  7 mod 256): DEDUPE 0x5c000 thru 0x5ffff	(0x4000 bytes) to 0x42000 thru 0x45fff
6210568(  8 mod 256): ZERO     0x7f4e3 thru 0x927bf	(0x132dd bytes)
6210569(  9 mod 256): ZERO     0x14d3a thru 0x2df91	(0x19258 bytes)
6210570( 10 mod 256): WRITE    0x7559f thru 0x8aafd	(0x1555f bytes)
6210571( 11 mod 256): SKIPPED (no operation)
6210572( 12 mod 256): MAPREAD  0x4c831 thru 0x53ae9	(0x72b9 bytes)
6210573( 13 mod 256): DEDUPE 0x75000 thru 0x90fff	(0x1c000 bytes) to 0x33000 thru 0x4efff
6210574( 14 mod 256): ZERO     0x5b79b thru 0x6ce21	(0x11687 bytes)
6210575( 15 mod 256): PUNCH    0x477a7 thru 0x6475d	(0x1cfb7 bytes)
6210576( 16 mod 256): DEDUPE 0x32000 thru 0x45fff	(0x14000 bytes) to 0x1a000 thru 0x2dfff
6210577( 17 mod 256): ZERO     0x29be8 thru 0x34bed	(0xb006 bytes)
6210578( 18 mod 256): CLONE 0xd000 thru 0x13fff	(0x7000 bytes) to 0x80000 thru 0x86fff
6210579( 19 mod 256): SKIPPED (no operation)
6210580( 20 mod 256): MAPREAD  0x16df7 thru 0x2fc4a	(0x18e54 bytes)
6210581( 21 mod 256): MAPWRITE 0x1dcab thru 0x26825	(0x8b7b bytes)
6210582( 22 mod 256): SKIPPED (no operation)
6210583( 23 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x820ae
6210584( 24 mod 256): TRUNCATE UP	from 0x820ae to 0x8cc91
6210585( 25 mod 256): DEDUPE 0x5f000 thru 0x61fff	(0x3000 bytes) to 0x0 thru 0x2fff
6210586( 26 mod 256): COPY 0x3d83e thru 0x458ff	(0x80c2 bytes) to 0x4e413 thru 0x564d4
6210587( 27 mod 256): COLLAPSE 0x2e000 thru 0x34fff	(0x7000 bytes)
6210588( 28 mod 256): COPY 0x54cc0 thru 0x5d8e9	(0x8c2a bytes) to 0x7d7f1 thru 0x8641a
6210589( 29 mod 256): MAPREAD  0x632d5 thru 0x73b95	(0x108c1 bytes)	***RRRR***
6210590( 30 mod 256): SKIPPED (no operation)
6210591( 31 mod 256): SKIPPED (no operation)
6210592( 32 mod 256): PUNCH    0x3640c thru 0x483b7	(0x11fac bytes)
6210593( 33 mod 256): PUNCH    0x1abd9 thru 0x1cbe9	(0x2011 bytes)
6210594( 34 mod 256): FALLOC   0x76603 thru 0x8655f	(0xff5c bytes) PAST_EOF
6210595( 35 mod 256): SKIPPED (no operation)
6210596( 36 mod 256): ZERO     0x91e45 thru 0x927bf	(0x97b bytes)
6210597( 37 mod 256): READ     0x3ef7 thru 0x137bb	(0xf8c5 bytes)
6210598( 38 mod 256): READ     0x756a2 thru 0x78bc7	(0x3526 bytes)
6210599( 39 mod 256): COLLAPSE 0x3f000 thru 0x5afff	(0x1c000 bytes)
6210600( 40 mod 256): MAPWRITE 0x7c54c thru 0x869cb	(0xa480 bytes)
6210601( 41 mod 256): INSERT 0x1e000 thru 0x28fff	(0xb000 bytes)
6210602( 42 mod 256): FALLOC   0x8da0f thru 0x927c0	(0x4db1 bytes) EXTENDING
6210603( 43 mod 256): SKIPPED (no operation)
6210604( 44 mod 256): PUNCH    0x53cdc thru 0x5fbff	(0xbf24 bytes)
6210605( 45 mod 256): CLONE 0x8b000 thru 0x91fff	(0x7000 bytes) to 0x22000 thru 0x28fff
6210606( 46 mod 256): SKIPPED (no operation)
6210607( 47 mod 256): WRITE    0x4b510 thru 0x5bf46	(0x10a37 bytes)
6210608( 48 mod 256): PUNCH    0x86961 thru 0x86d92	(0x432 bytes)
6210609( 49 mod 256): MAPREAD  0x40813 thru 0x5873a	(0x17f28 bytes)
6210610( 50 mod 256): DEDUPE 0x84000 thru 0x90fff	(0xd000 bytes) to 0x5e000 thru 0x6afff
6210611( 51 mod 256): ZERO     0x72032 thru 0x82ab2	(0x10a81 bytes)
6210612( 52 mod 256): WRITE    0x7cef7 thru 0x7eaba	(0x1bc4 bytes)
6210613( 53 mod 256): MAPREAD  0x61d06 thru 0x80570	(0x1e86b bytes)	***RRRR***
6210614( 54 mod 256): SKIPPED (no operation)
6210615( 55 mod 256): FALLOC   0x3f544 thru 0x4b759	(0xc215 bytes) INTERIOR
6210616( 56 mod 256): SKIPPED (no operation)
6210617( 57 mod 256): DEDUPE 0x50000 thru 0x64fff	(0x15000 bytes) to 0x28000 thru 0x3cfff
6210618( 58 mod 256): MAPREAD  0x30f35 thru 0x3f704	(0xe7d0 bytes)
6210619( 59 mod 256): PUNCH    0x90dc5 thru 0x927bf	(0x19fb bytes)
6210620( 60 mod 256): CLONE 0x51000 thru 0x69fff	(0x19000 bytes) to 0x32000 thru 0x4afff
6210621( 61 mod 256): READ     0x60391 thru 0x6f41a	(0xf08a bytes)	***RRRR***
6210622( 62 mod 256): SKIPPED (no operation)
6210623( 63 mod 256): SKIPPED (no operation)
6210624( 64 mod 256): WRITE    0x5db94 thru 0x68cda	(0xb147 bytes)
6210625( 65 mod 256): PUNCH    0x1c882 thru 0x2d627	(0x10da6 bytes)
6210626( 66 mod 256): COPY 0x47374 thru 0x5868a	(0x11317 bytes) to 0x20a3d thru 0x31d53
6210627( 67 mod 256): COLLAPSE 0x83000 thru 0x8bfff	(0x9000 bytes)
6210628( 68 mod 256): ZERO     0x1422a thru 0x319de	(0x1d7b5 bytes)
6210629( 69 mod 256): TRUNCATE DOWN	from 0x897c0 to 0x763b4
6210630( 70 mod 256): COLLAPSE 0x3d000 thru 0x48fff	(0xc000 bytes)
6210631( 71 mod 256): ZERO     0x47c6 thru 0x1aa77	(0x162b2 bytes)
6210632( 72 mod 256): WRITE    0x3b08 thru 0x6ecc	(0x33c5 bytes)
6210633( 73 mod 256): ZERO     0x6ac85 thru 0x7e328	(0x136a4 bytes)	******ZZZZ
6210634( 74 mod 256): MAPWRITE 0x2602a thru 0x290de	(0x30b5 bytes)
6210635( 75 mod 256): FALLOC   0x6919f thru 0x7e7ad	(0x1560e bytes) PAST_EOF	******FFFF
6210636( 76 mod 256): COLLAPSE 0x2c000 thru 0x49fff	(0x1e000 bytes)
6210637( 77 mod 256): CLONE 0x54000 thru 0x58fff	(0x5000 bytes) to 0x83000 thru 0x87fff
6210638( 78 mod 256): ZERO     0x2a402 thru 0x3e44b	(0x1404a bytes)
6210639( 79 mod 256): INSERT 0x6e000 thru 0x77fff	(0xa000 bytes)	******IIII
6210640( 80 mod 256): CLONE 0x7d000 thru 0x82fff	(0x6000 bytes) to 0x1d000 thru 0x22fff
6210641( 81 mod 256): ZERO     0x190ba thru 0x2a48e	(0x113d5 bytes)
6210642( 82 mod 256): COPY 0xfc08 thru 0x16d61	(0x715a bytes) to 0x286b3 thru 0x2f80c
6210643( 83 mod 256): MAPWRITE 0x4c990 thru 0x5ed91	(0x12402 bytes)
6210644( 84 mod 256): SKIPPED (no operation)
6210645( 85 mod 256): WRITE    0x8dfeb thru 0x927bf	(0x47d5 bytes) EXTEND
6210646( 86 mod 256): MAPWRITE 0x5ce48 thru 0x670dc	(0xa295 bytes)
6210647( 87 mod 256): DEDUPE 0x60000 thru 0x66fff	(0x7000 bytes) to 0x26000 thru 0x2cfff
6210648( 88 mod 256): READ     0x333cf thru 0x3d6ec	(0xa31e bytes)
6210649( 89 mod 256): WRITE    0x4fa8a thru 0x6302b	(0x135a2 bytes)
6210650( 90 mod 256): FALLOC   0x68ec4 thru 0x80551	(0x1768d bytes) INTERIOR	******FFFF
6210651( 91 mod 256): MAPREAD  0x6ecf3 thru 0x8921f	(0x1a52d bytes)	***RRRR***
6210652( 92 mod 256): SKIPPED (no operation)
6210653( 93 mod 256): WRITE    0x6ecea thru 0x89a0e	(0x1ad25 bytes)	***WWWW
6210654( 94 mod 256): FALLOC   0x870d6 thru 0x927c0	(0xb6ea bytes) INTERIOR
6210655( 95 mod 256): ZERO     0x40c73 thru 0x58e2f	(0x181bd bytes)
6210656( 96 mod 256): MAPWRITE 0x11e19 thru 0x2432f	(0x12517 bytes)
6210657( 97 mod 256): SKIPPED (no operation)
6210658( 98 mod 256): WRITE    0x7389a thru 0x8f4da	(0x1bc41 bytes)
6210659( 99 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x24a97	******WWWW
6210660(100 mod 256): MAPWRITE 0x75306 thru 0x8e9b4	(0x196af bytes)
6210661(101 mod 256): PUNCH    0x42665 thru 0x5d892	(0x1b22e bytes)
6210662(102 mod 256): COPY 0x69946 thru 0x6a9c6	(0x1081 bytes) to 0x3b77b thru 0x3c7fb
6210663(103 mod 256): INSERT 0x1a000 thru 0x1cfff	(0x3000 bytes)
6210664(104 mod 256): PUNCH    0x8f193 thru 0x919b4	(0x2822 bytes)
6210665(105 mod 256): PUNCH    0x4395b thru 0x604aa	(0x1cb50 bytes)
6210666(106 mod 256): READ     0x47868 thru 0x5623c	(0xe9d5 bytes)
6210667(107 mod 256): COLLAPSE 0x80000 thru 0x90fff	(0x11000 bytes)
6210668(108 mod 256): PUNCH    0xa5eb thru 0x1e334	(0x13d4a bytes)
6210669(109 mod 256): TRUNCATE DOWN	from 0x809b5 to 0x3f2b4	******WWWW
6210670(110 mod 256): PUNCH    0x2858f thru 0x2d07a	(0x4aec bytes)
6210671(111 mod 256): CLONE 0x1000 thru 0x1dfff	(0x1d000 bytes) to 0x35000 thru 0x51fff
6210672(112 mod 256): PUNCH    0xc9b2 thru 0x1bbbf	(0xf20e bytes)
6210673(113 mod 256): PUNCH    0x4aa11 thru 0x51fff	(0x75ef bytes)
6210674(114 mod 256): COLLAPSE 0xc000 thru 0xefff	(0x3000 bytes)
6210675(115 mod 256): CLONE 0x1b000 thru 0x2cfff	(0x12000 bytes) to 0x59000 thru 0x6afff
6210676(116 mod 256): FALLOC   0x2dba1 thru 0x3c2df	(0xe73e bytes) INTERIOR
6210677(117 mod 256): PUNCH    0x43396 thru 0x59963	(0x165ce bytes)
6210678(118 mod 256): SKIPPED (no operation)
6210679(119 mod 256): PUNCH    0x2d58f thru 0x37c4f	(0xa6c1 bytes)
6210680(120 mod 256): MAPREAD  0x67b87 thru 0x6afff	(0x3479 bytes)
6210681(121 mod 256): TRUNCATE DOWN	from 0x6b000 to 0x1a16b
6210682(122 mod 256): WRITE    0x393eb thru 0x395a1	(0x1b7 bytes) HOLE
6210683(123 mod 256): READ     0x11bb thru 0xec5e	(0xdaa4 bytes)
6210684(124 mod 256): READ     0x2b305 thru 0x395a1	(0xe29d bytes)
6210685(125 mod 256): COPY 0x33f6c thru 0x395a1	(0x5636 bytes) to 0x86205 thru 0x8b83a
6210686(126 mod 256): COPY 0x70acb thru 0x87009	(0x1653f bytes) to 0x4bb85 thru 0x620c3
6210687(127 mod 256): INSERT 0x8a000 thru 0x8ffff	(0x6000 bytes)
6210688(128 mod 256): DEDUPE 0x43000 thru 0x4cfff	(0xa000 bytes) to 0x7e000 thru 0x87fff
6210689(129 mod 256): READ     0x5ac2 thru 0x20d12	(0x1b251 bytes)
6210690(130 mod 256): PUNCH    0x855f8 thru 0x9183a	(0xc243 bytes)
6210691(131 mod 256): PUNCH    0x319f9 thru 0x3224e	(0x856 bytes)
6210692(132 mod 256): MAPREAD  0x4139e thru 0x5f9e2	(0x1e645 bytes)
6210693(133 mod 256): CLONE 0x3f000 thru 0x53fff	(0x15000 bytes) to 0x6b000 thru 0x7ffff	******JJJJ
6210694(134 mod 256): ZERO     0x78b59 thru 0x866f9	(0xdba1 bytes)
6210695(135 mod 256): COPY 0x61094 thru 0x69cc3	(0x8c30 bytes) to 0x35611 thru 0x3e240
6210696(136 mod 256): COLLAPSE 0x83000 thru 0x86fff	(0x4000 bytes)
6210697(137 mod 256): WRITE    0x3b7bb thru 0x3fa9b	(0x42e1 bytes)
6210698(138 mod 256): INSERT 0x57000 thru 0x5afff	(0x4000 bytes)
6210699(139 mod 256): COPY 0x34ff9 thru 0x5271b	(0x1d723 bytes) to 0x56c55 thru 0x74377	******EEEE
6210700(140 mod 256): PUNCH    0x5d8e8 thru 0x6df91	(0x106aa bytes)
6210701(141 mod 256): MAPREAD  0x80687 thru 0x9183a	(0x111b4 bytes)
6210702(142 mod 256): MAPWRITE 0xbe4b thru 0x1c17f	(0x10335 bytes)
6210703(143 mod 256): ZERO     0x6bf35 thru 0x71561	(0x562d bytes)	******ZZZZ
6210704(144 mod 256): DEDUPE 0x18000 thru 0x26fff	(0xf000 bytes) to 0x4d000 thru 0x5bfff
6210705(145 mod 256): ZERO     0x8c2f6 thru 0x927bf	(0x64ca bytes)
6210706(146 mod 256): CLONE 0x78000 thru 0x8ffff	(0x18000 bytes) to 0x48000 thru 0x5ffff
6210707(147 mod 256): MAPWRITE 0x5efaa thru 0x745c0	(0x15617 bytes)	******WWWW
6210708(148 mod 256): TRUNCATE DOWN	from 0x9183b to 0x2b9ba	******WWWW
6210709(149 mod 256): CLONE 0x26000 thru 0x2afff	(0x5000 bytes) to 0xb000 thru 0xffff
6210710(150 mod 256): DEDUPE 0x1000 thru 0x9fff	(0x9000 bytes) to 0x21000 thru 0x29fff
6210711(151 mod 256): MAPWRITE 0x5d7b7 thru 0x67b8a	(0xa3d4 bytes)
6210712(152 mod 256): SKIPPED (no operation)
6210713(153 mod 256): ZERO     0x3f2ec thru 0x4c36b	(0xd080 bytes)
6210714(154 mod 256): CLONE 0x10000 thru 0x25fff	(0x16000 bytes) to 0x63000 thru 0x78fff	******JJJJ
6210715(155 mod 256): FALLOC   0x4469b thru 0x45822	(0x1187 bytes) INTERIOR
6210716(156 mod 256): INSERT 0x5f000 thru 0x74fff	(0x16000 bytes)	******IIII
6210717(157 mod 256): CLONE 0x67000 thru 0x69fff	(0x3000 bytes) to 0x45000 thru 0x47fff
6210718(158 mod 256): TRUNCATE DOWN	from 0x8f000 to 0x781a1
6210719(159 mod 256): READ     0x55d79 thru 0x5ae12	(0x509a bytes)
6210720(160 mod 256): TRUNCATE DOWN	from 0x781a1 to 0x640a3	******WWWW
6210721(161 mod 256): ZERO     0x86453 thru 0x8f564	(0x9112 bytes)
6210722(162 mod 256): DEDUPE 0x89000 thru 0x8dfff	(0x5000 bytes) to 0x41000 thru 0x45fff
6210723(163 mod 256): SKIPPED (no operation)
6210724(164 mod 256): MAPREAD  0x49ece thru 0x5f90e	(0x15a41 bytes)
6210725(165 mod 256): FALLOC   0x83fd9 thru 0x8e23f	(0xa266 bytes) INTERIOR
6210726(166 mod 256): CLONE 0x1a000 thru 0x28fff	(0xf000 bytes) to 0x31000 thru 0x3ffff
6210727(167 mod 256): SKIPPED (no operation)
6210728(168 mod 256): COLLAPSE 0x45000 thru 0x55fff	(0x11000 bytes)
6210729(169 mod 256): COLLAPSE 0x5f000 thru 0x62fff	(0x4000 bytes)
6210730(170 mod 256): TRUNCATE DOWN	from 0x7a565 to 0x18f65	******WWWW
6210731(171 mod 256): WRITE    0xf566 thru 0x1140c	(0x1ea7 bytes)
6210732(172 mod 256): CLONE 0xf000 thru 0x17fff	(0x9000 bytes) to 0x3f000 thru 0x47fff
6210733(173 mod 256): ZERO     0x123 thru 0xc6a8	(0xc586 bytes)
6210734(174 mod 256): ZERO     0x8bd4b thru 0x927bf	(0x6a75 bytes)
6210735(175 mod 256): FALLOC   0x38e96 thru 0x40ebf	(0x8029 bytes) INTERIOR
6210736(176 mod 256): DEDUPE 0x7d000 thru 0x81fff	(0x5000 bytes) to 0x4c000 thru 0x50fff
6210737(177 mod 256): WRITE    0x1c0c5 thru 0x33ba3	(0x17adf bytes)
6210738(178 mod 256): MAPWRITE 0x27abe thru 0x407ca	(0x18d0d bytes)
6210739(179 mod 256): READ     0x3c3b3 thru 0x54794	(0x183e2 bytes)
6210740(180 mod 256): ZERO     0x2d65d thru 0x31960	(0x4304 bytes)
6210741(181 mod 256): WRITE    0x849ea thru 0x87230	(0x2847 bytes)
6210742(182 mod 256): READ     0x555b5 thru 0x6b38c	(0x15dd8 bytes)
6210743(183 mod 256): MAPWRITE 0x31a57 thru 0x35fb9	(0x4563 bytes)
6210744(184 mod 256): MAPWRITE 0x44463 thru 0x46f26	(0x2ac4 bytes)
6210745(185 mod 256): SKIPPED (no operation)
6210746(186 mod 256): CLONE 0x20000 thru 0x32fff	(0x13000 bytes) to 0x52000 thru 0x64fff
6210747(187 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x64e21	******WWWW
6210748(188 mod 256): COPY 0x37986 thru 0x3b523	(0x3b9e bytes) to 0x2aa51 thru 0x2e5ee
6210749(189 mod 256): CLONE 0x22000 thru 0x3afff	(0x19000 bytes) to 0x54000 thru 0x6cfff
6210750(190 mod 256): MAPREAD  0x1c9fa thru 0x25f22	(0x9529 bytes)
6210751(191 mod 256): SKIPPED (no operation)
6210752(192 mod 256): CLONE 0x38000 thru 0x38fff	(0x1000 bytes) to 0x1f000 thru 0x1ffff
6210753(193 mod 256): TRUNCATE DOWN	from 0x6d000 to 0xdf92
6210754(194 mod 256): ZERO     0x43f8c thru 0x5a685	(0x166fa bytes)
6210755(195 mod 256): PUNCH    0x9dbf thru 0x1ac64	(0x10ea6 bytes)
6210756(196 mod 256): COLLAPSE 0x20000 thru 0x3afff	(0x1b000 bytes)
6210757(197 mod 256): DEDUPE 0x24000 thru 0x3bfff	(0x18000 bytes) to 0x5000 thru 0x1cfff
6210758(198 mod 256): PUNCH    0x37686 thru 0x3f685	(0x8000 bytes)
6210759(199 mod 256): WRITE    0x61ffa thru 0x71375	(0xf37c bytes) HOLE	***WWWW
6210760(200 mod 256): INSERT 0x3a000 thru 0x51fff	(0x18000 bytes)
6210761(201 mod 256): ZERO     0x4d3ba thru 0x5f1c4	(0x11e0b bytes)
6210762(202 mod 256): FALLOC   0x55c37 thru 0x725c4	(0x1c98d bytes) INTERIOR	******FFFF
6210763(203 mod 256): MAPWRITE 0x1e47 thru 0x7b2b	(0x5ce5 bytes)
6210764(204 mod 256): ZERO     0x1d5f2 thru 0x23c69	(0x6678 bytes)
6210765(205 mod 256): TRUNCATE UP	from 0x89376 to 0x8a0d5
6210766(206 mod 256): READ     0x75976 thru 0x8a0d4	(0x1475f bytes)
6210767(207 mod 256): PUNCH    0x5b659 thru 0x5cca4	(0x164c bytes)
6210768(208 mod 256): COPY 0x13861 thru 0x1c061	(0x8801 bytes) to 0x3d0e2 thru 0x458e2
6210769(209 mod 256): READ     0x13f44 thru 0x2155e	(0xd61b bytes)
6210770(210 mod 256): READ     0x5b640 thru 0x77828	(0x1c1e9 bytes)	***RRRR***
6210771(211 mod 256): CLONE 0x73000 thru 0x7afff	(0x8000 bytes) to 0x4c000 thru 0x53fff
6210772(212 mod 256): PUNCH    0x73c16 thru 0x784b1	(0x489c bytes)
6210773(213 mod 256): ZERO     0xfe52 thru 0x2051a	(0x106c9 bytes)
6210774(214 mod 256): TRUNCATE DOWN	from 0x8a0d5 to 0x813a5
6210775(215 mod 256): READ     0x78bcb thru 0x813a4	(0x87da bytes)
6210776(216 mod 256): DEDUPE 0x7000 thru 0x8fff	(0x2000 bytes) to 0x70000 thru 0x71fff
6210777(217 mod 256): MAPREAD  0x653d1 thru 0x77e2e	(0x12a5e bytes)	***RRRR***
6210778(218 mod 256): INSERT 0x76000 thru 0x86fff	(0x11000 bytes)
6210779(219 mod 256): DEDUPE 0x2f000 thru 0x44fff	(0x16000 bytes) to 0x0 thru 0x15fff
6210780(220 mod 256): TRUNCATE DOWN	from 0x923a5 to 0x35120	******WWWW
6210781(221 mod 256): READ     0x28894 thru 0x343fe	(0xbb6b bytes)
6210782(222 mod 256): COLLAPSE 0x4000 thru 0xdfff	(0xa000 bytes)
6210783(223 mod 256): FALLOC   0x4bc58 thru 0x5d387	(0x1172f bytes) PAST_EOF
6210784(224 mod 256): TRUNCATE UP	from 0x2b120 to 0x3b2c7
6210785(225 mod 256): DEDUPE 0x0 thru 0x17fff	(0x18000 bytes) to 0x1d000 thru 0x34fff
6210786(226 mod 256): PUNCH    0x321df thru 0x3b2c6	(0x90e8 bytes)
6210787(227 mod 256): FALLOC   0x7784e thru 0x8c2bb	(0x14a6d bytes) EXTENDING
6210788(228 mod 256): WRITE    0x32955 thru 0x39dd2	(0x747e bytes)
6210789(229 mod 256): ZERO     0x14774 thru 0x18849	(0x40d6 bytes)
6210790(230 mod 256): SKIPPED (no operation)
6210791(231 mod 256): WRITE    0x13a37 thru 0x29c85	(0x1624f bytes)
6210792(232 mod 256): MAPREAD  0x6e84f thru 0x71d28	(0x34da bytes)	***RRRR***
6210793(233 mod 256): CLONE 0x20000 thru 0x22fff	(0x3000 bytes) to 0x6d000 thru 0x6ffff	******JJJJ
6210794(234 mod 256): COLLAPSE 0x61000 thru 0x77fff	(0x17000 bytes)	******CCCC
6210795(235 mod 256): FALLOC   0x4a7e2 thru 0x63214	(0x18a32 bytes) INTERIOR
6210796(236 mod 256): WRITE    0x16a34 thru 0x1caf4	(0x60c1 bytes)
6210797(237 mod 256): MAPREAD  0x65846 thru 0x752ba	(0xfa75 bytes)	***RRRR***
6210798(238 mod 256): ZERO     0x1c99e thru 0x3490e	(0x17f71 bytes)
6210799(239 mod 256): FALLOC   0x7e6cb thru 0x927c0	(0x140f5 bytes) PAST_EOF
6210800(240 mod 256): READ     0x68fe0 thru 0x752ba	(0xc2db bytes)	***RRRR***
6210801(241 mod 256): PUNCH    0x68d26 thru 0x752ba	(0xc595 bytes)	******PPPP
6210802(242 mod 256): DEDUPE 0x34000 thru 0x45fff	(0x12000 bytes) to 0x6000 thru 0x17fff
6210803(243 mod 256): FALLOC   0x3c4e3 thru 0x42632	(0x614f bytes) INTERIOR
6210804(244 mod 256): DEDUPE 0x1000 thru 0x6fff	(0x6000 bytes) to 0xb000 thru 0x10fff
6210805(245 mod 256): ZERO     0x4c37a thru 0x57c53	(0xb8da bytes)
6210806(246 mod 256): PUNCH    0x5f7de thru 0x752ba	(0x15add bytes)	******PPPP
6210807(247 mod 256): SKIPPED (no operation)
6210808(248 mod 256): INSERT 0x5000 thru 0x11fff	(0xd000 bytes)
6210809(249 mod 256): PUNCH    0x69ffe thru 0x822ba	(0x182bd bytes)	******PPPP
6210810(250 mod 256): COLLAPSE 0x35000 thru 0x52fff	(0x1e000 bytes)
6210811(251 mod 256): MAPWRITE 0x6fc2b thru 0x88c62	(0x19038 bytes)
6210812(252 mod 256): SKIPPED (no operation)
6210813(253 mod 256): CLONE 0x3a000 thru 0x49fff	(0x10000 bytes) to 0x1f000 thru 0x2efff
6210814(254 mod 256): DEDUPE 0x6b000 thru 0x80fff	(0x16000 bytes) to 0x4e000 thru 0x63fff	BBBB******
6210815(255 mod 256): SKIPPED (no operation)
6210816(  0 mod 256): DEDUPE 0x29000 thru 0x3efff	(0x16000 bytes) to 0x70000 thru 0x85fff
6210817(  1 mod 256): READ     0x7ab7e thru 0x88c62	(0xe0e5 bytes)
6210818(  2 mod 256): SKIPPED (no operation)
6210819(  3 mod 256): MAPWRITE 0x3c1ba thru 0x52275	(0x160bc bytes)
6210820(  4 mod 256): COPY 0x7c946 thru 0x86870	(0x9f2b bytes) to 0x36baf thru 0x40ad9
6210821(  5 mod 256): READ     0x40e23 thru 0x47023	(0x6201 bytes)
6210822(  6 mod 256): COPY 0x65c95 thru 0x691a2	(0x350e bytes) to 0x83afb thru 0x87008
6210823(  7 mod 256): PUNCH    0x67c4b thru 0x7db94	(0x15f4a bytes)	******PPPP
6210824(  8 mod 256): MAPREAD  0x22bf3 thru 0x30cd0	(0xe0de bytes)
6210825(  9 mod 256): ZERO     0x65162 thru 0x69ad4	(0x4973 bytes)
6210826( 10 mod 256): ZERO     0x2a577 thru 0x43e72	(0x198fc bytes)
6210827( 11 mod 256): READ     0x68c9b thru 0x71e52	(0x91b8 bytes)	***RRRR***
6210828( 12 mod 256): CLONE 0x22000 thru 0x22fff	(0x1000 bytes) to 0x39000 thru 0x39fff
6210829( 13 mod 256): MAPWRITE 0x88b8d thru 0x927bf	(0x9c33 bytes)
6210830( 14 mod 256): FALLOC   0xe31a thru 0x250b1	(0x16d97 bytes) INTERIOR
6210831( 15 mod 256): MAPREAD  0x7d29a thru 0x927bf	(0x15526 bytes)
6210832( 16 mod 256): SKIPPED (no operation)
6210833( 17 mod 256): CLONE 0x58000 thru 0x6efff	(0x17000 bytes) to 0x32000 thru 0x48fff	JJJJ******
6210834( 18 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5f83b	******WWWW
6210835( 19 mod 256): DEDUPE 0x56000 thru 0x5dfff	(0x8000 bytes) to 0x10000 thru 0x17fff
6210836( 20 mod 256): MAPREAD  0x56cfb thru 0x5d4b6	(0x67bc bytes)
6210837( 21 mod 256): ZERO     0x91a63 thru 0x927bf	(0xd5d bytes)
6210838( 22 mod 256): MAPREAD  0x2685a thru 0x2d4df	(0x6c86 bytes)
6210839( 23 mod 256): FALLOC   0x17b4f thru 0x2f44a	(0x178fb bytes) INTERIOR
6210840( 24 mod 256): CLONE 0x41000 thru 0x58fff	(0x18000 bytes) to 0x5f000 thru 0x76fff	******JJJJ
6210841( 25 mod 256): INSERT 0x28000 thru 0x42fff	(0x1b000 bytes)
6210842( 26 mod 256): ZERO     0x79ccd thru 0x905c9	(0x168fd bytes)
6210843( 27 mod 256): SKIPPED (no operation)
6210844( 28 mod 256): MAPREAD  0x6ad29 thru 0x8a026	(0x1f2fe bytes)	***RRRR***
6210845( 29 mod 256): WRITE    0x6c36a thru 0x85bdc	(0x19873 bytes)	***WWWW
6210846( 30 mod 256): COPY 0x561f6 thru 0x737e0	(0x1d5eb bytes) to 0x18386 thru 0x35970	EEEE******
6210847( 31 mod 256): SKIPPED (no operation)
6210848( 32 mod 256): READ     0x5304b thru 0x6994d	(0x16903 bytes)
6210849( 33 mod 256): MAPREAD  0x76e thru 0x10525	(0xfdb8 bytes)
6210850( 34 mod 256): WRITE    0x7aab8 thru 0x927bf	(0x17d08 bytes) EXTEND
6210851( 35 mod 256): WRITE    0x7637b thru 0x8db69	(0x177ef bytes)
6210852( 36 mod 256): COPY 0x77cc thru 0x13492	(0xbcc7 bytes) to 0x2c673 thru 0x38339
6210853( 37 mod 256): PUNCH    0x1e1d4 thru 0x2e6b6	(0x104e3 bytes)
6210854( 38 mod 256): COLLAPSE 0x6000 thru 0x1dfff	(0x18000 bytes)
6210855( 39 mod 256): FALLOC   0x4342c thru 0x5ad68	(0x1793c bytes) INTERIOR
6210856( 40 mod 256): CLONE 0x60000 thru 0x62fff	(0x3000 bytes) to 0xc000 thru 0xefff
6210857( 41 mod 256): PUNCH    0xd85d thru 0x1116f	(0x3913 bytes)
6210858( 42 mod 256): TRUNCATE DOWN	from 0x7a7c0 to 0x26fee	******WWWW
6210859( 43 mod 256): READ     0x22209 thru 0x26fed	(0x4de5 bytes)
6210860( 44 mod 256): FALLOC   0x11ab2 thru 0x17a4b	(0x5f99 bytes) INTERIOR
6210861( 45 mod 256): FALLOC   0x817a9 thru 0x927c0	(0x11017 bytes) EXTENDING
6210862( 46 mod 256): FALLOC   0x2dc5f thru 0x42961	(0x14d02 bytes) INTERIOR
6210863( 47 mod 256): SKIPPED (no operation)
6210864( 48 mod 256): WRITE    0x3f4eb thru 0x46b8e	(0x76a4 bytes)
6210865( 49 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x24ed0	******WWWW
6210866( 50 mod 256): FALLOC   0x838a9 thru 0x927c0	(0xef17 bytes) PAST_EOF
6210867( 51 mod 256): COPY 0x21a9c thru 0x24ecf	(0x3434 bytes) to 0x8901d thru 0x8c450
6210868( 52 mod 256): DEDUPE 0xe000 thru 0x15fff	(0x8000 bytes) to 0x1000 thru 0x8fff
6210869( 53 mod 256): WRITE    0x1cd2c thru 0x2a490	(0xd765 bytes)
6210870( 54 mod 256): FALLOC   0x79cff thru 0x7aca3	(0xfa4 bytes) INTERIOR
6210871( 55 mod 256): MAPREAD  0x1ed6c thru 0x3a175	(0x1b40a bytes)
6210872( 56 mod 256): FALLOC   0xed44 thru 0x23bf8	(0x14eb4 bytes) INTERIOR
6210873( 57 mod 256): CLONE 0x55000 thru 0x5bfff	(0x7000 bytes) to 0x3c000 thru 0x42fff
6210874( 58 mod 256): INSERT 0x7f000 thru 0x84fff	(0x6000 bytes)
6210875( 59 mod 256): READ     0xc256 thru 0x1cf34	(0x10cdf bytes)
6210876( 60 mod 256): PUNCH    0x1d756 thru 0x3566c	(0x17f17 bytes)
6210877( 61 mod 256): MAPWRITE 0xd67d thru 0x14b69	(0x74ed bytes)
6210878( 62 mod 256): ZERO     0x2822f thru 0x4520c	(0x1cfde bytes)
6210879( 63 mod 256): COPY 0x348 thru 0x4e7a	(0x4b33 bytes) to 0x39321 thru 0x3de53
6210880( 64 mod 256): DEDUPE 0x41000 thru 0x45fff	(0x5000 bytes) to 0x62000 thru 0x66fff
6210881( 65 mod 256): SKIPPED (no operation)
6210882( 66 mod 256): SKIPPED (no operation)
6210883( 67 mod 256): FALLOC   0x3ee6a thru 0x5a2a3	(0x1b439 bytes) INTERIOR
6210884( 68 mod 256): ZERO     0xa447 thru 0x114d4	(0x708e bytes)
6210885( 69 mod 256): TRUNCATE DOWN	from 0x92451 to 0x5383d	******WWWW
6210886( 70 mod 256): WRITE    0x1ff18 thru 0x32d56	(0x12e3f bytes)
6210887( 71 mod 256): SKIPPED (no operation)
6210888( 72 mod 256): READ     0x12c6 thru 0x1a83e	(0x19579 bytes)
6210889( 73 mod 256): TRUNCATE DOWN	from 0x5383d to 0x1e00f
6210890( 74 mod 256): COLLAPSE 0x2000 thru 0x5fff	(0x4000 bytes)
6210891( 75 mod 256): COLLAPSE 0x13000 thru 0x16fff	(0x4000 bytes)
6210892( 76 mod 256): SKIPPED (no operation)
6210893( 77 mod 256): COPY 0x14c5d thru 0x1600e	(0x13b2 bytes) to 0x569f9 thru 0x57daa
6210894( 78 mod 256): TRUNCATE DOWN	from 0x57dab to 0x6b78
6210895( 79 mod 256): READ     0x1b04 thru 0x6b77	(0x5074 bytes)
6210896( 80 mod 256): CLONE 0x4000 thru 0x5fff	(0x2000 bytes) to 0x6d000 thru 0x6efff	******JJJJ
6210897( 81 mod 256): COPY 0x4b872 thru 0x4d658	(0x1de7 bytes) to 0x584f thru 0x7635
6210898( 82 mod 256): FALLOC   0x63bbc thru 0x65f2a	(0x236e bytes) INTERIOR
6210899( 83 mod 256): FALLOC   0x2c617 thru 0x44dcb	(0x187b4 bytes) INTERIOR
6210900( 84 mod 256): FALLOC   0x43d9e thru 0x4651b	(0x277d bytes) INTERIOR
6210901( 85 mod 256): SKIPPED (no operation)
6210902( 86 mod 256): TRUNCATE DOWN	from 0x6f000 to 0x13ae2	******WWWW
6210903( 87 mod 256): FALLOC   0x7f0c1 thru 0x927c0	(0x136ff bytes) PAST_EOF
6210904( 88 mod 256): PUNCH    0x826e thru 0x13ae1	(0xb874 bytes)
6210905( 89 mod 256): CLONE 0x11000 thru 0x12fff	(0x2000 bytes) to 0x8f000 thru 0x90fff
6210906( 90 mod 256): ZERO     0x442bd thru 0x484d9	(0x421d bytes)
6210907( 91 mod 256): MAPWRITE 0x2917c thru 0x3bc6c	(0x12af1 bytes)
6210908( 92 mod 256): MAPWRITE 0x3ce68 thru 0x4cc21	(0xfdba bytes)
6210909( 93 mod 256): CLONE 0x2d000 thru 0x33fff	(0x7000 bytes) to 0x64000 thru 0x6afff
6210910( 94 mod 256): WRITE    0x4dd65 thru 0x68536	(0x1a7d2 bytes)
6210911( 95 mod 256): SKIPPED (no operation)
6210912( 96 mod 256): FALLOC   0x6f866 thru 0x818dd	(0x12077 bytes) INTERIOR
6210913( 97 mod 256): DEDUPE 0x3b000 thru 0x3cfff	(0x2000 bytes) to 0x45000 thru 0x46fff
6210914( 98 mod 256): CLONE 0x82000 thru 0x8ffff	(0xe000 bytes) to 0x69000 thru 0x76fff	******JJJJ
6210915( 99 mod 256): INSERT 0x87000 thru 0x87fff	(0x1000 bytes)
6210916(100 mod 256): TRUNCATE DOWN	from 0x92000 to 0x602bf	******WWWW
6210917(101 mod 256): CLONE 0x32000 thru 0x3cfff	(0xb000 bytes) to 0x66000 thru 0x70fff	******JJJJ
6210918(102 mod 256): MAPREAD  0x1cd72 thru 0x34ae1	(0x17d70 bytes)
6210919(103 mod 256): CLONE 0x3f000 thru 0x3ffff	(0x1000 bytes) to 0x40000 thru 0x40fff
6210920(104 mod 256): MAPREAD  0x5dcf8 thru 0x6db07	(0xfe10 bytes)
6210921(105 mod 256): COPY 0xe2ef thru 0x29f88	(0x1bc9a bytes) to 0x41e52 thru 0x5daeb
6210922(106 mod 256): COLLAPSE 0x64000 thru 0x6ffff	(0xc000 bytes)	******CCCC
6210923(107 mod 256): WRITE    0x64fcd thru 0x68e3b	(0x3e6f bytes) EXTEND
6210924(108 mod 256): CLONE 0x42000 thru 0x58fff	(0x17000 bytes) to 0x1d000 thru 0x33fff
6210925(109 mod 256): WRITE    0x369ac thru 0x5084e	(0x19ea3 bytes)
6210926(110 mod 256): COLLAPSE 0x5e000 thru 0x67fff	(0xa000 bytes)
6210927(111 mod 256): MAPREAD  0x22f6d thru 0x3d2d3	(0x1a367 bytes)
6210928(112 mod 256): CLONE 0x19000 thru 0x36fff	(0x1e000 bytes) to 0x6c000 thru 0x89fff	******JJJJ
6210929(113 mod 256): WRITE    0x91f67 thru 0x927bf	(0x859 bytes) HOLE
6210930(114 mod 256): SKIPPED (no operation)
6210931(115 mod 256): SKIPPED (no operation)
6210932(116 mod 256): MAPWRITE 0x22196 thru 0x36064	(0x13ecf bytes)
6210933(117 mod 256): SKIPPED (no operation)
6210934(118 mod 256): READ     0x91d44 thru 0x927bf	(0xa7c bytes)
6210935(119 mod 256): FALLOC   0x4edf3 thru 0x5cc54	(0xde61 bytes) INTERIOR
6210936(120 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x63d5b	******WWWW
6210937(121 mod 256): MAPREAD  0x109fe thru 0x1deaf	(0xd4b2 bytes)
6210938(122 mod 256): MAPWRITE 0x335a1 thru 0x3fb98	(0xc5f8 bytes)
6210939(123 mod 256): COPY 0x5b084 thru 0x63d5a	(0x8cd7 bytes) to 0x30f1d thru 0x39bf3
6210940(124 mod 256): READ     0x612f8 thru 0x63d5a	(0x2a63 bytes)
6210941(125 mod 256): INSERT 0x56000 thru 0x6afff	(0x15000 bytes)
6210942(126 mod 256): PUNCH    0x54efa thru 0x5ea6f	(0x9b76 bytes)
6210943(127 mod 256): TRUNCATE DOWN	from 0x78d5b to 0x26069	******WWWW
6210944(128 mod 256): DEDUPE 0x1b000 thru 0x20fff	(0x6000 bytes) to 0x11000 thru 0x16fff
6210945(129 mod 256): COPY 0xaa99 thru 0x13d53	(0x92bb bytes) to 0x26c1a thru 0x2fed4
6210946(130 mod 256): INSERT 0x26000 thru 0x39fff	(0x14000 bytes)
6210947(131 mod 256): READ     0xaabc thru 0x1c74e	(0x11c93 bytes)
6210948(132 mod 256): INSERT 0x1d000 thru 0x25fff	(0x9000 bytes)
6210949(133 mod 256): INSERT 0x26000 thru 0x29fff	(0x4000 bytes)
6210950(134 mod 256): INSERT 0x32000 thru 0x49fff	(0x18000 bytes)
6210951(135 mod 256): FALLOC   0x1636e thru 0x29c32	(0x138c4 bytes) INTERIOR
6210952(136 mod 256): COPY 0x612d0 thru 0x68ed4	(0x7c05 bytes) to 0x88dec thru 0x909f0
6210953(137 mod 256): DEDUPE 0x33000 thru 0x4afff	(0x18000 bytes) to 0x4d000 thru 0x64fff
6210954(138 mod 256): WRITE    0x47fc6 thru 0x61518	(0x19553 bytes)
6210955(139 mod 256): MAPWRITE 0x44c7e thru 0x61252	(0x1c5d5 bytes)
6210956(140 mod 256): COPY 0x6d6e3 thru 0x86e79	(0x19797 bytes) to 0x30784 thru 0x49f1a	EEEE******
6210957(141 mod 256): WRITE    0x112fa thru 0x28026	(0x16d2d bytes)
6210958(142 mod 256): WRITE    0x9191d thru 0x91f3a	(0x61e bytes) HOLE
6210959(143 mod 256): WRITE    0x3a390 thru 0x475e3	(0xd254 bytes)
6210960(144 mod 256): READ     0x42831 thru 0x5cd4b	(0x1a51b bytes)
6210961(145 mod 256): WRITE    0x85eac thru 0x904f2	(0xa647 bytes)
6210962(146 mod 256): MAPWRITE 0x6da5c thru 0x77784	(0x9d29 bytes)	******WWWW
6210963(147 mod 256): SKIPPED (no operation)
6210964(148 mod 256): WRITE    0x88953 thru 0x927bf	(0x9e6d bytes) EXTEND
6210965(149 mod 256): DEDUPE 0x27000 thru 0x3afff	(0x14000 bytes) to 0x6f000 thru 0x82fff
6210966(150 mod 256): SKIPPED (no operation)
6210967(151 mod 256): SKIPPED (no operation)
6210968(152 mod 256): MAPREAD  0x34b19 thru 0x34c48	(0x130 bytes)
6210969(153 mod 256): DEDUPE 0x46000 thru 0x5cfff	(0x17000 bytes) to 0x6f000 thru 0x85fff
6210970(154 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x82f46
6210971(155 mod 256): COPY 0x20a75 thru 0x24478	(0x3a04 bytes) to 0x612fd thru 0x64d00
6210972(156 mod 256): READ     0x733d9 thru 0x82f45	(0xfb6d bytes)
6210973(157 mod 256): MAPREAD  0x50a75 thru 0x56327	(0x58b3 bytes)
6210974(158 mod 256): TRUNCATE DOWN	from 0x82f46 to 0x3de11	******WWWW
6210975(159 mod 256): SKIPPED (no operation)
6210976(160 mod 256): MAPWRITE 0x3e344 thru 0x56227	(0x17ee4 bytes)
6210977(161 mod 256): ZERO     0x4efb9 thru 0x67673	(0x186bb bytes)
6210978(162 mod 256): READ     0x2729 thru 0x1bb20	(0x193f8 bytes)
6210979(163 mod 256): ZERO     0x7fb56 thru 0x800d6	(0x581 bytes)
6210980(164 mod 256): INSERT 0x73000 thru 0x78fff	(0x6000 bytes)
6210981(165 mod 256): COLLAPSE 0x74000 thru 0x7afff	(0x7000 bytes)
6210982(166 mod 256): READ     0x6b725 thru 0x7afb1	(0xf88d bytes)	***RRRR***
6210983(167 mod 256): COPY 0xb96d thru 0x16ae0	(0xb174 bytes) to 0x2d710 thru 0x38883
6210984(168 mod 256): MAPREAD  0xd923 thru 0x27a36	(0x1a114 bytes)
6210985(169 mod 256): COPY 0x35d38 thru 0x3c930	(0x6bf9 bytes) to 0x6ec04 thru 0x757fc	******EEEE
6210986(170 mod 256): COLLAPSE 0x75000 thru 0x7dfff	(0x9000 bytes)
6210987(171 mod 256): DEDUPE 0x2c000 thru 0x49fff	(0x1e000 bytes) to 0x7000 thru 0x24fff
6210988(172 mod 256): COLLAPSE 0x2a000 thru 0x47fff	(0x1e000 bytes)
6210989(173 mod 256): MAPWRITE 0x65519 thru 0x82453	(0x1cf3b bytes)	******WWWW
6210990(174 mod 256): WRITE    0x17403 thru 0x29519	(0x12117 bytes)
6210991(175 mod 256): READ     0x63aa6 thru 0x64691	(0xbec bytes)
6210992(176 mod 256): PUNCH    0x19a8a thru 0x1e55a	(0x4ad1 bytes)
6210993(177 mod 256): PUNCH    0x2cda1 thru 0x38bdd	(0xbe3d bytes)
6210994(178 mod 256): FALLOC   0x18b7c thru 0x28cb0	(0x10134 bytes) INTERIOR
6210995(179 mod 256): MAPWRITE 0x28fd0 thru 0x301ce	(0x71ff bytes)
6210996(180 mod 256): MAPWRITE 0x8f63c thru 0x927bf	(0x3184 bytes)
6210997(181 mod 256): SKIPPED (no operation)
6210998(182 mod 256): COLLAPSE 0x36000 thru 0x37fff	(0x2000 bytes)
6210999(183 mod 256): SKIPPED (no operation)
6211000(184 mod 256): COPY 0x29a54 thru 0x3922f	(0xf7dc bytes) to 0x3999 thru 0x13174
6211001(185 mod 256): MAPWRITE 0x516e5 thru 0x51dce	(0x6ea bytes)
6211002(186 mod 256): WRITE    0x3e9bb thru 0x4bf5f	(0xd5a5 bytes)
6211003(187 mod 256): MAPREAD  0x32adf thru 0x4f282	(0x1c7a4 bytes)
6211004(188 mod 256): READ     0x6e4af thru 0x8356e	(0x150c0 bytes)	***RRRR***
6211005(189 mod 256): FALLOC   0x2a075 thru 0x34861	(0xa7ec bytes) INTERIOR
6211006(190 mod 256): READ     0x161aa thru 0x1a627	(0x447e bytes)
6211007(191 mod 256): MAPREAD  0xda1 thru 0x13974	(0x12bd4 bytes)
6211008(192 mod 256): READ     0x6bef4 thru 0x86493	(0x1a5a0 bytes)	***RRRR***
6211009(193 mod 256): ZERO     0x1ec46 thru 0x345f1	(0x159ac bytes)
6211010(194 mod 256): COPY 0x34fd0 thru 0x43e4e	(0xee7f bytes) to 0x6ab7b thru 0x799f9	******EEEE
6211011(195 mod 256): INSERT 0x21000 thru 0x22fff	(0x2000 bytes)
6211012(196 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x6e648	******WWWW
6211013(197 mod 256): INSERT 0x42000 thru 0x50fff	(0xf000 bytes)
6211014(198 mod 256): MAPWRITE 0x28156 thru 0x3b610	(0x134bb bytes)
6211015(199 mod 256): CLONE 0x3e000 thru 0x53fff	(0x16000 bytes) to 0x79000 thru 0x8efff
6211016(200 mod 256): MAPWRITE 0x1111b thru 0x21e82	(0x10d68 bytes)
6211017(201 mod 256): COPY 0x8d360 thru 0x8efff	(0x1ca0 bytes) to 0x8523e thru 0x86edd
6211018(202 mod 256): MAPREAD  0x804c thru 0x167b0	(0xe765 bytes)
6211019(203 mod 256): MAPREAD  0xaf25 thru 0x28142	(0x1d21e bytes)
6211020(204 mod 256): READ     0x78125 thru 0x7cee5	(0x4dc1 bytes)
6211021(205 mod 256): CLONE 0x83000 thru 0x8dfff	(0xb000 bytes) to 0x2f000 thru 0x39fff
6211022(206 mod 256): COPY 0x7b506 thru 0x8d5a6	(0x120a1 bytes) to 0x1114d thru 0x231ed
6211023(207 mod 256): TRUNCATE DOWN	from 0x8f000 to 0x6f00e
6211024(208 mod 256): READ     0x3fd49 thru 0x46a06	(0x6cbe bytes)
6211025(209 mod 256): CLONE 0x6c000 thru 0x6dfff	(0x2000 bytes) to 0x1d000 thru 0x1efff
6211026(210 mod 256): COPY 0x50cce thru 0x57f27	(0x725a bytes) to 0x23dbf thru 0x2b018
6211027(211 mod 256): READ     0xabc0 thru 0xb53a	(0x97b bytes)
6211028(212 mod 256): ZERO     0x4517f thru 0x4817b	(0x2ffd bytes)
6211029(213 mod 256): CLONE 0x1d000 thru 0x26fff	(0xa000 bytes) to 0x73000 thru 0x7cfff
6211030(214 mod 256): FALLOC   0x5a150 thru 0x721cb	(0x1807b bytes) INTERIOR	******FFFF
6211031(215 mod 256): READ     0x54116 thru 0x62c71	(0xeb5c bytes)
6211032(216 mod 256): TRUNCATE DOWN	from 0x7d000 to 0x3abd7	******WWWW
6211033(217 mod 256): COLLAPSE 0x28000 thru 0x31fff	(0xa000 bytes)
6211034(218 mod 256): ZERO     0x8bf32 thru 0x927bf	(0x688e bytes)
6211035(219 mod 256): DEDUPE 0x15000 thru 0x29fff	(0x15000 bytes) to 0x74000 thru 0x88fff
6211036(220 mod 256): PUNCH    0x245e5 thru 0x43944	(0x1f360 bytes)
6211037(221 mod 256): CLONE 0x67000 thru 0x7bfff	(0x15000 bytes) to 0x4f000 thru 0x63fff	JJJJ******
6211038(222 mod 256): PUNCH    0x9425 thru 0xb644	(0x2220 bytes)
6211039(223 mod 256): FALLOC   0x1297a thru 0x13a1a	(0x10a0 bytes) INTERIOR
6211040(224 mod 256): CLONE 0x9000 thru 0xefff	(0x6000 bytes) to 0x78000 thru 0x7dfff
6211041(225 mod 256): SKIPPED (no operation)
6211042(226 mod 256): MAPWRITE 0x28c25 thru 0x3054e	(0x792a bytes)
6211043(227 mod 256): ZERO     0x881cd thru 0x927bf	(0xa5f3 bytes)
6211044(228 mod 256): READ     0x2d619 thru 0x3f728	(0x12110 bytes)
6211045(229 mod 256): SKIPPED (no operation)
6211046(230 mod 256): SKIPPED (no operation)
6211047(231 mod 256): CLONE 0x5f000 thru 0x76fff	(0x18000 bytes) to 0x1a000 thru 0x31fff	JJJJ******
6211048(232 mod 256): COLLAPSE 0x7f000 thru 0x84fff	(0x6000 bytes)
6211049(233 mod 256): WRITE    0xa0fa thru 0x2420b	(0x1a112 bytes)
6211050(234 mod 256): COPY 0x19c0e thru 0x323a7	(0x1879a bytes) to 0x6cdaa thru 0x85543	******EEEE
6211051(235 mod 256): READ     0x5fefb thru 0x69a58	(0x9b5e bytes)
6211052(236 mod 256): PUNCH    0x33749 thru 0x442ee	(0x10ba6 bytes)
6211053(237 mod 256): WRITE    0x4910e thru 0x65cf4	(0x1cbe7 bytes)
6211054(238 mod 256): TRUNCATE DOWN	from 0x8c7c0 to 0x4c316	******WWWW
6211055(239 mod 256): MAPREAD  0x5f16 thru 0x22cf4	(0x1cddf bytes)
6211056(240 mod 256): COPY 0x2b910 thru 0x4227e	(0x1696f bytes) to 0x12835 thru 0x291a3
6211057(241 mod 256): INSERT 0x1d000 thru 0x30fff	(0x14000 bytes)
6211058(242 mod 256): SKIPPED (no operation)
6211059(243 mod 256): COLLAPSE 0x2d000 thru 0x3dfff	(0x11000 bytes)
6211060(244 mod 256): INSERT 0x4a000 thru 0x5afff	(0x11000 bytes)
6211061(245 mod 256): SKIPPED (no operation)
6211062(246 mod 256): COLLAPSE 0x3c000 thru 0x4ffff	(0x14000 bytes)
6211063(247 mod 256): WRITE    0x8896f thru 0x927bf	(0x9e51 bytes) HOLE	***WWWW
6211064(248 mod 256): ZERO     0x1ac37 thru 0x283ce	(0xd798 bytes)
6211065(249 mod 256): SKIPPED (no operation)
6211066(250 mod 256): MAPREAD  0x294e0 thru 0x448bb	(0x1b3dc bytes)
6211067(251 mod 256): ZERO     0x84cf9 thru 0x927bf	(0xdac7 bytes)
6211068(252 mod 256): MAPWRITE 0x55fee thru 0x625ae	(0xc5c1 bytes)
6211069(253 mod 256): COLLAPSE 0x3f000 thru 0x40fff	(0x2000 bytes)
6211070(254 mod 256): ZERO     0xba04 thru 0x1661b	(0xac18 bytes)
6211071(255 mod 256): WRITE    0x3b52f thru 0x4a4b5	(0xef87 bytes)
6211072(  0 mod 256): WRITE    0x44074 thru 0x52734	(0xe6c1 bytes)
6211073(  1 mod 256): CLONE 0x2000 thru 0x1afff	(0x19000 bytes) to 0x5e000 thru 0x76fff	******JJJJ
6211074(  2 mod 256): ZERO     0x2c589 thru 0x4605c	(0x19ad4 bytes)
6211075(  3 mod 256): CLONE 0x7f000 thru 0x86fff	(0x8000 bytes) to 0x37000 thru 0x3efff
6211076(  4 mod 256): WRITE    0x5c881 thru 0x764e0	(0x19c60 bytes)	***WWWW
6211077(  5 mod 256): COPY 0x77e77 thru 0x8daf2	(0x15c7c bytes) to 0x1c2c9 thru 0x31f44
6211078(  6 mod 256): TRUNCATE DOWN	from 0x907c0 to 0x2cad7	******WWWW
6211079(  7 mod 256): READ     0x1e0f7 thru 0x2b2e6	(0xd1f0 bytes)
6211080(  8 mod 256): ZERO     0x594a4 thru 0x71e9d	(0x189fa bytes)	******ZZZZ
6211081(  9 mod 256): WRITE    0x5e38 thru 0x1b6ff	(0x158c8 bytes)
6211082( 10 mod 256): MAPREAD  0x18d59 thru 0x209e8	(0x7c90 bytes)
6211083( 11 mod 256): COPY 0xc7b6 thru 0x291d4	(0x1ca1f bytes) to 0x4f46f thru 0x6be8d
6211084( 12 mod 256): MAPREAD  0x1e540 thru 0x33af5	(0x155b6 bytes)
6211085( 13 mod 256): CLONE 0x67000 thru 0x6afff	(0x4000 bytes) to 0xd000 thru 0x10fff
6211086( 14 mod 256): TRUNCATE DOWN	from 0x6be8e to 0x4d061
6211087( 15 mod 256): CLONE 0x1d000 thru 0x25fff	(0x9000 bytes) to 0x26000 thru 0x2efff
6211088( 16 mod 256): COLLAPSE 0xc000 thru 0x15fff	(0xa000 bytes)
6211089( 17 mod 256): SKIPPED (no operation)
6211090( 18 mod 256): MAPWRITE 0x35055 thru 0x381c3	(0x316f bytes)
6211091( 19 mod 256): WRITE    0x67203 thru 0x84bc9	(0x1d9c7 bytes) HOLE	***WWWW
6211092( 20 mod 256): DEDUPE 0x1b000 thru 0x2afff	(0x10000 bytes) to 0x5b000 thru 0x6afff
6211093( 21 mod 256): SKIPPED (no operation)
6211094( 22 mod 256): ZERO     0x72697 thru 0x8f22c	(0x1cb96 bytes)
6211095( 23 mod 256): PUNCH    0x2f018 thru 0x329a3	(0x398c bytes)
6211096( 24 mod 256): ZERO     0x44381 thru 0x56e9e	(0x12b1e bytes)
6211097( 25 mod 256): ZERO     0x83210 thru 0x927bf	(0xf5b0 bytes)
6211098( 26 mod 256): READ     0x2d000 thru 0x441b2	(0x171b3 bytes)
6211099( 27 mod 256): READ     0x3118d thru 0x43c3a	(0x12aae bytes)
6211100( 28 mod 256): SKIPPED (no operation)
6211101( 29 mod 256): SKIPPED (no operation)
6211102( 30 mod 256): COPY 0x7043 thru 0x1c191	(0x1514f bytes) to 0x47520 thru 0x5c66e
6211103( 31 mod 256): SKIPPED (no operation)
6211104( 32 mod 256): READ     0x25208 thru 0x2d40f	(0x8208 bytes)
6211105( 33 mod 256): ZERO     0x142ed thru 0x2f0fa	(0x1ae0e bytes)
6211106( 34 mod 256): CLONE 0x5f000 thru 0x78fff	(0x1a000 bytes) to 0x38000 thru 0x51fff	JJJJ******
6211107( 35 mod 256): CLONE 0x8a000 thru 0x90fff	(0x7000 bytes) to 0x4e000 thru 0x54fff
6211108( 36 mod 256): CLONE 0x42000 thru 0x4efff	(0xd000 bytes) to 0x29000 thru 0x35fff
6211109( 37 mod 256): ZERO     0x86dd9 thru 0x927bf	(0xb9e7 bytes)
6211110( 38 mod 256): MAPWRITE 0x6b4f5 thru 0x7fa1f	(0x1452b bytes)	******WWWW
6211111( 39 mod 256): SKIPPED (no operation)
6211112( 40 mod 256): MAPREAD  0x133f0 thru 0x2505b	(0x11c6c bytes)
6211113( 41 mod 256): SKIPPED (no operation)
6211114( 42 mod 256): COLLAPSE 0x30000 thru 0x49fff	(0x1a000 bytes)
6211115( 43 mod 256): COPY 0x23e75 thru 0x27de6	(0x3f72 bytes) to 0x33cec thru 0x37c5d
6211116( 44 mod 256): DEDUPE 0x69000 thru 0x76fff	(0xe000 bytes) to 0x34000 thru 0x41fff	BBBB******
6211117( 45 mod 256): FALLOC   0x314d1 thru 0x342ae	(0x2ddd bytes) INTERIOR
6211118( 46 mod 256): MAPREAD  0x39c13 thru 0x50e7d	(0x1726b bytes)
6211119( 47 mod 256): CLONE 0x2a000 thru 0x44fff	(0x1b000 bytes) to 0x68000 thru 0x82fff	******JJJJ
6211120( 48 mod 256): READ     0x7d1e4 thru 0x7d294	(0xb1 bytes)
6211121( 49 mod 256): FALLOC   0x76f1 thru 0x22cf7	(0x1b606 bytes) INTERIOR
6211122( 50 mod 256): PUNCH    0x48af8 thru 0x53cfe	(0xb207 bytes)
6211123( 51 mod 256): TRUNCATE DOWN	from 0x83000 to 0x4d0e2	******WWWW
6211124( 52 mod 256): PUNCH    0x2a5e1 thru 0x446a4	(0x1a0c4 bytes)
6211125( 53 mod 256): DEDUPE 0x38000 thru 0x4bfff	(0x14000 bytes) to 0x18000 thru 0x2bfff
6211126( 54 mod 256): PUNCH    0x18b52 thru 0x32d70	(0x1a21f bytes)
6211127( 55 mod 256): FALLOC   0x3a89d thru 0x58965	(0x1e0c8 bytes) EXTENDING
6211128( 56 mod 256): DEDUPE 0x26000 thru 0x3bfff	(0x16000 bytes) to 0x9000 thru 0x1efff
6211129( 57 mod 256): READ     0x157ae thru 0x17b4d	(0x23a0 bytes)
6211130( 58 mod 256): INSERT 0x12000 thru 0x15fff	(0x4000 bytes)
6211131( 59 mod 256): FALLOC   0x1935f thru 0x2cc8b	(0x1392c bytes) INTERIOR
6211132( 60 mod 256): TRUNCATE DOWN	from 0x5c965 to 0x53b05
6211133( 61 mod 256): INSERT 0x1000 thru 0x13fff	(0x13000 bytes)
6211134( 62 mod 256): TRUNCATE UP	from 0x66b05 to 0x6d3b7
6211135( 63 mod 256): TRUNCATE DOWN	from 0x6d3b7 to 0x2e459
6211136( 64 mod 256): CLONE 0x27000 thru 0x2cfff	(0x6000 bytes) to 0x6000 thru 0xbfff
6211137( 65 mod 256): PUNCH    0x2b3c3 thru 0x2e458	(0x3096 bytes)
6211138( 66 mod 256): WRITE    0x45644 thru 0x5981c	(0x141d9 bytes) HOLE
6211139( 67 mod 256): CLONE 0x16000 thru 0x1bfff	(0x6000 bytes) to 0x56000 thru 0x5bfff
6211140( 68 mod 256): WRITE    0x33a72 thru 0x3b177	(0x7706 bytes)
6211141( 69 mod 256): PUNCH    0x23fa8 thru 0x2c822	(0x887b bytes)
6211142( 70 mod 256): READ     0x3823f thru 0x47296	(0xf058 bytes)
6211143( 71 mod 256): WRITE    0x5e65e thru 0x791a3	(0x1ab46 bytes) HOLE	***WWWW
6211144( 72 mod 256): PUNCH    0x2f45 thru 0x15515	(0x125d1 bytes)
6211145( 73 mod 256): ZERO     0x8bfb5 thru 0x927bf	(0x680b bytes)
6211146( 74 mod 256): READ     0x44c27 thru 0x542c3	(0xf69d bytes)
6211147( 75 mod 256): FALLOC   0x6ee3f thru 0x83dc4	(0x14f85 bytes) INTERIOR	******FFFF
6211148( 76 mod 256): COPY 0x41cd3 thru 0x48517	(0x6845 bytes) to 0x1961d thru 0x1fe61
6211149( 77 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x25158	******WWWW
6211150( 78 mod 256): FALLOC   0x7202f thru 0x823e5	(0x103b6 bytes) EXTENDING
6211151( 79 mod 256): PUNCH    0x368dc thru 0x37da7	(0x14cc bytes)
6211152( 80 mod 256): COLLAPSE 0x73000 thru 0x80fff	(0xe000 bytes)
6211153( 81 mod 256): COLLAPSE 0x4e000 thru 0x55fff	(0x8000 bytes)
6211154( 82 mod 256): COPY 0x60542 thru 0x6c3e4	(0xbea3 bytes) to 0x6ed51 thru 0x7abf3	******EEEE
6211155( 83 mod 256): TRUNCATE DOWN	from 0x7abf4 to 0x7aa76
6211156( 84 mod 256): DEDUPE 0x65000 thru 0x6cfff	(0x8000 bytes) to 0x72000 thru 0x79fff
6211157( 85 mod 256): MAPWRITE 0x555dd thru 0x6f1c9	(0x19bed bytes)	******WWWW
6211158( 86 mod 256): INSERT 0x6b000 thru 0x7bfff	(0x11000 bytes)	******IIII
6211159( 87 mod 256): MAPWRITE 0x851b1 thru 0x87ae4	(0x2934 bytes)
6211160( 88 mod 256): TRUNCATE DOWN	from 0x8ba76 to 0xeb04	******WWWW
6211161( 89 mod 256): FALLOC   0x4a71a thru 0x530d1	(0x89b7 bytes) PAST_EOF
6211162( 90 mod 256): SKIPPED (no operation)
6211163( 91 mod 256): COLLAPSE 0x9000 thru 0xdfff	(0x5000 bytes)
6211164( 92 mod 256): SKIPPED (no operation)
6211165( 93 mod 256): MAPWRITE 0x302aa thru 0x47d67	(0x17abe bytes)
6211166( 94 mod 256): MAPWRITE 0x169be thru 0x21549	(0xab8c bytes)
6211167( 95 mod 256): MAPREAD  0x3a211 thru 0x47d67	(0xdb57 bytes)
6211168( 96 mod 256): INSERT 0x3a000 thru 0x43fff	(0xa000 bytes)
6211169( 97 mod 256): ZERO     0x39ed2 thru 0x4f287	(0x153b6 bytes)
6211170( 98 mod 256): TRUNCATE DOWN	from 0x51d68 to 0x30a97
6211171( 99 mod 256): WRITE    0x6013d thru 0x70ab4	(0x10978 bytes) HOLE	***WWWW
6211172(100 mod 256): SKIPPED (no operation)
6211173(101 mod 256): COPY 0x221a2 thru 0x2b1b8	(0x9017 bytes) to 0x4efc5 thru 0x57fdb
6211174(102 mod 256): WRITE    0x8f151 thru 0x927bf	(0x366f bytes) HOLE
6211175(103 mod 256): COPY 0x4a089 thru 0x4d658	(0x35d0 bytes) to 0x290a6 thru 0x2c675
6211176(104 mod 256): COLLAPSE 0x83000 thru 0x90fff	(0xe000 bytes)
6211177(105 mod 256): COLLAPSE 0x7e000 thru 0x83fff	(0x6000 bytes)
6211178(106 mod 256): DEDUPE 0x39000 thru 0x3afff	(0x2000 bytes) to 0x3f000 thru 0x40fff
6211179(107 mod 256): COPY 0x6aceb thru 0x7e7bf	(0x13ad5 bytes) to 0x2789b thru 0x3b36f	EEEE******
6211180(108 mod 256): COLLAPSE 0x1f000 thru 0x25fff	(0x7000 bytes)
6211181(109 mod 256): FALLOC   0x496af thru 0x4d56e	(0x3ebf bytes) INTERIOR
6211182(110 mod 256): COLLAPSE 0xa000 thru 0x20fff	(0x17000 bytes)
6211183(111 mod 256): DEDUPE 0x53000 thru 0x59fff	(0x7000 bytes) to 0x33000 thru 0x39fff
6211184(112 mod 256): INSERT 0x5a000 thru 0x76fff	(0x1d000 bytes)	******IIII
6211185(113 mod 256): READ     0x9b7 thru 0x15881	(0x14ecb bytes)
6211186(114 mod 256): DEDUPE 0x2f000 thru 0x3efff	(0x10000 bytes) to 0x1000 thru 0x10fff
6211187(115 mod 256): SKIPPED (no operation)
6211188(116 mod 256): SKIPPED (no operation)
6211189(117 mod 256): COPY 0x3ea15 thru 0x4271e	(0x3d0a bytes) to 0x1931b thru 0x1d024
6211190(118 mod 256): WRITE    0x4dfda thru 0x5694d	(0x8974 bytes)
6211191(119 mod 256): SKIPPED (no operation)
6211192(120 mod 256): ZERO     0x10796 thru 0x14548	(0x3db3 bytes)
6211193(121 mod 256): TRUNCATE DOWN	from 0x7d7c0 to 0x4dbae	******WWWW
6211194(122 mod 256): ZERO     0x4101f thru 0x4e54b	(0xd52d bytes)
6211195(123 mod 256): CLONE 0x31000 thru 0x42fff	(0x12000 bytes) to 0x6f000 thru 0x80fff
6211196(124 mod 256): SKIPPED (no operation)
6211197(125 mod 256): READ     0x580c1 thru 0x65f2b	(0xde6b bytes)
6211198(126 mod 256): COPY 0x764c2 thru 0x7dff8	(0x7b37 bytes) to 0x57171 thru 0x5eca7
6211199(127 mod 256): MAPWRITE 0x336b0 thru 0x4b968	(0x182b9 bytes)
6211200(128 mod 256): DEDUPE 0x73000 thru 0x7ffff	(0xd000 bytes) to 0x34000 thru 0x40fff
6211201(129 mod 256): TRUNCATE DOWN	from 0x81000 to 0x3ad4b	******WWWW
6211202(130 mod 256): MAPREAD  0x101ed thru 0x25f9c	(0x15db0 bytes)
6211203(131 mod 256): SKIPPED (no operation)
6211204(132 mod 256): CLONE 0x35000 thru 0x39fff	(0x5000 bytes) to 0x60000 thru 0x64fff
6211205(133 mod 256): MAPWRITE 0x2f098 thru 0x32893	(0x37fc bytes)
6211206(134 mod 256): CLONE 0x5a000 thru 0x63fff	(0xa000 bytes) to 0x66000 thru 0x6ffff	******JJJJ
6211207(135 mod 256): CLONE 0x2a000 thru 0x42fff	(0x19000 bytes) to 0x5f000 thru 0x77fff	******JJJJ
6211208(136 mod 256): CLONE 0x29000 thru 0x3efff	(0x16000 bytes) to 0x4a000 thru 0x5ffff
6211209(137 mod 256): DEDUPE 0x2d000 thru 0x35fff	(0x9000 bytes) to 0x55000 thru 0x5dfff
6211210(138 mod 256): ZERO     0x42806 thru 0x46c21	(0x441c bytes)
6211211(139 mod 256): ZERO     0x6d0d thru 0x2504b	(0x1e33f bytes)
6211212(140 mod 256): COPY 0x1fb8b thru 0x3dc6a	(0x1e0e0 bytes) to 0x4fa9e thru 0x6db7d
6211213(141 mod 256): SKIPPED (no operation)
6211214(142 mod 256): ZERO     0xb8bf thru 0x1fe5e	(0x145a0 bytes)
6211215(143 mod 256): MAPWRITE 0x6173b thru 0x724c1	(0x10d87 bytes)	******WWWW
6211216(144 mod 256): COLLAPSE 0x74000 thru 0x76fff	(0x3000 bytes)
6211217(145 mod 256): CLONE 0x55000 thru 0x5bfff	(0x7000 bytes) to 0x18000 thru 0x1efff
6211218(146 mod 256): CLONE 0x2c000 thru 0x2dfff	(0x2000 bytes) to 0x28000 thru 0x29fff
6211219(147 mod 256): ZERO     0x76fe9 thru 0x90988	(0x199a0 bytes)
6211220(148 mod 256): TRUNCATE DOWN	from 0x75000 to 0x2d3dc	******WWWW
6211221(149 mod 256): READ     0xc416 thru 0x19075	(0xcc60 bytes)
6211222(150 mod 256): SKIPPED (no operation)
6211223(151 mod 256): INSERT 0x3000 thru 0x16fff	(0x14000 bytes)
6211224(152 mod 256): MAPREAD  0x1c211 thru 0x2e696	(0x12486 bytes)
6211225(153 mod 256): SKIPPED (no operation)
6211226(154 mod 256): SKIPPED (no operation)
6211227(155 mod 256): CLONE 0x4000 thru 0x11fff	(0xe000 bytes) to 0x60000 thru 0x6dfff
6211228(156 mod 256): READ     0x40d07 thru 0x5c57d	(0x1b877 bytes)
6211229(157 mod 256): WRITE    0x1465c thru 0x2a278	(0x15c1d bytes)
6211230(158 mod 256): COLLAPSE 0x2d000 thru 0x44fff	(0x18000 bytes)
6211231(159 mod 256): FALLOC   0xc1f7 thru 0x1c609	(0x10412 bytes) INTERIOR
6211232(160 mod 256): CLONE 0x11000 thru 0x26fff	(0x16000 bytes) to 0x4c000 thru 0x61fff
6211233(161 mod 256): READ     0x2c14d thru 0x3f2db	(0x1318f bytes)
6211234(162 mod 256): ZERO     0x65287 thru 0x7c6c7	(0x17441 bytes)	******ZZZZ
6211235(163 mod 256): DEDUPE 0x6a000 thru 0x6efff	(0x5000 bytes) to 0x47000 thru 0x4bfff	BBBB******
6211236(164 mod 256): READ     0x3c8b5 thru 0x5740d	(0x1ab59 bytes)
6211237(165 mod 256): PUNCH    0x68b9d thru 0x7a4a1	(0x11905 bytes)	******PPPP
6211238(166 mod 256): ZERO     0x1b110 thru 0x2237a	(0x726b bytes)
6211239(167 mod 256): PUNCH    0x5769 thru 0xcf7a	(0x7812 bytes)
6211240(168 mod 256): MAPREAD  0x15763 thru 0x2a2fa	(0x14b98 bytes)
6211241(169 mod 256): READ     0xd453 thru 0x2b74b	(0x1e2f9 bytes)
6211242(170 mod 256): COPY 0x492d6 thru 0x67162	(0x1de8d bytes) to 0x67e0 thru 0x2466c
6211243(171 mod 256): MAPREAD  0x14943 thru 0x2efaa	(0x1a668 bytes)
6211244(172 mod 256): READ     0x21f91 thru 0x2c729	(0xa799 bytes)
6211245(173 mod 256): COLLAPSE 0x12000 thru 0x1cfff	(0xb000 bytes)
6211246(174 mod 256): MAPWRITE 0x5dcd5 thru 0x6ea02	(0x10d2e bytes)
6211247(175 mod 256): ZERO     0x8e690 thru 0x927bf	(0x4130 bytes)
6211248(176 mod 256): CLONE 0x2b000 thru 0x37fff	(0xd000 bytes) to 0x19000 thru 0x25fff
6211249(177 mod 256): PUNCH    0x2efb3 thru 0x4c524	(0x1d572 bytes)
6211250(178 mod 256): WRITE    0x2e55b thru 0x34ecb	(0x6971 bytes)
6211251(179 mod 256): SKIPPED (no operation)
6211252(180 mod 256): FALLOC   0x85449 thru 0x90e1b	(0xb9d2 bytes) INTERIOR
6211253(181 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x642ab	******WWWW
6211254(182 mod 256): COPY 0x2f054 thru 0x47058	(0x18005 bytes) to 0x724f5 thru 0x8a4f9
6211255(183 mod 256): WRITE    0xb6f4 thru 0x192d2	(0xdbdf bytes)
6211256(184 mod 256): COLLAPSE 0x27000 thru 0x40fff	(0x1a000 bytes)
6211257(185 mod 256): SKIPPED (no operation)
6211258(186 mod 256): FALLOC   0x8bec4 thru 0x927c0	(0x68fc bytes) EXTENDING
6211259(187 mod 256): PUNCH    0x2473a thru 0x409d1	(0x1c298 bytes)
6211260(188 mod 256): ZERO     0x8ad39 thru 0x927bf	(0x7a87 bytes)
6211261(189 mod 256): PUNCH    0x761dc thru 0x7fe56	(0x9c7b bytes)
6211262(190 mod 256): ZERO     0x3ed22 thru 0x5ce8c	(0x1e16b bytes)
6211263(191 mod 256): MAPWRITE 0x757cf thru 0x927bf	(0x1cff1 bytes)
6211264(192 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8a10f
6211265(193 mod 256): CLONE 0x0 thru 0xfff	(0x1000 bytes) to 0xe000 thru 0xefff
6211266(194 mod 256): PUNCH    0x70dd2 thru 0x7d96f	(0xcb9e bytes)
6211267(195 mod 256): INSERT 0x1f000 thru 0x1ffff	(0x1000 bytes)
6211268(196 mod 256): CLONE 0x49000 thru 0x65fff	(0x1d000 bytes) to 0x70000 thru 0x8cfff
6211269(197 mod 256): FALLOC   0x1f256 thru 0x2569e	(0x6448 bytes) INTERIOR
6211270(198 mod 256): MAPREAD  0x1b16f thru 0x3899c	(0x1d82e bytes)
6211271(199 mod 256): TRUNCATE DOWN	from 0x8d000 to 0x42fa4	******WWWW
6211272(200 mod 256): FALLOC   0x29700 thru 0x38493	(0xed93 bytes) INTERIOR
6211273(201 mod 256): MAPWRITE 0x6de6d thru 0x7f766	(0x118fa bytes)	******WWWW
6211274(202 mod 256): PUNCH    0x53481 thru 0x61775	(0xe2f5 bytes)
6211275(203 mod 256): COPY 0x2c128 thru 0x4586d	(0x19746 bytes) to 0x6332e thru 0x7ca73	******EEEE
6211276(204 mod 256): INSERT 0x29000 thru 0x3bfff	(0x13000 bytes)
6211277(205 mod 256): SKIPPED (no operation)
6211278(206 mod 256): FALLOC   0x7b8ab thru 0x87e78	(0xc5cd bytes) INTERIOR
6211279(207 mod 256): TRUNCATE DOWN	from 0x92767 to 0x895e5
6211280(208 mod 256): INSERT 0x1a000 thru 0x22fff	(0x9000 bytes)
6211281(209 mod 256): PUNCH    0xa7f0 thru 0x2326b	(0x18a7c bytes)
6211282(210 mod 256): CLONE 0x41000 thru 0x5afff	(0x1a000 bytes) to 0x15000 thru 0x2efff
6211283(211 mod 256): WRITE    0x62cd8 thru 0x79ccb	(0x16ff4 bytes)	***WWWW
6211284(212 mod 256): COLLAPSE 0x68000 thru 0x79fff	(0x12000 bytes)	******CCCC
6211285(213 mod 256): SKIPPED (no operation)
6211286(214 mod 256): WRITE    0x8a72e thru 0x8cf16	(0x27e9 bytes) HOLE
6211287(215 mod 256): INSERT 0x5000 thru 0x9fff	(0x5000 bytes)
6211288(216 mod 256): DEDUPE 0x80000 thru 0x90fff	(0x11000 bytes) to 0xc000 thru 0x1cfff
6211289(217 mod 256): FALLOC   0x7a957 thru 0x88fc7	(0xe670 bytes) INTERIOR
6211290(218 mod 256): TRUNCATE DOWN	from 0x91f17 to 0x7ac6b
6211291(219 mod 256): SKIPPED (no operation)
6211292(220 mod 256): PUNCH    0xf782 thru 0x18fda	(0x9859 bytes)
6211293(221 mod 256): DEDUPE 0x2d000 thru 0x4bfff	(0x1f000 bytes) to 0x0 thru 0x1efff
6211294(222 mod 256): COPY 0x74b1d thru 0x7ac6a	(0x614e bytes) to 0x373f2 thru 0x3d53f
6211295(223 mod 256): INSERT 0x32000 thru 0x39fff	(0x8000 bytes)
6211296(224 mod 256): DEDUPE 0x37000 thru 0x39fff	(0x3000 bytes) to 0x55000 thru 0x57fff
6211297(225 mod 256): CLONE 0x5f000 thru 0x6cfff	(0xe000 bytes) to 0x50000 thru 0x5dfff
6211298(226 mod 256): INSERT 0x74000 thru 0x82fff	(0xf000 bytes)
6211299(227 mod 256): TRUNCATE DOWN	from 0x91c6b to 0x7c13c
6211300(228 mod 256): FALLOC   0x2896d thru 0x4284c	(0x19edf bytes) INTERIOR
6211301(229 mod 256): CLONE 0x46000 thru 0x48fff	(0x3000 bytes) to 0x7a000 thru 0x7cfff
6211302(230 mod 256): READ     0x136cd thru 0x13d7d	(0x6b1 bytes)
6211303(231 mod 256): FALLOC   0x5f167 thru 0x676d8	(0x8571 bytes) INTERIOR
6211304(232 mod 256): MAPREAD  0x7cdbe thru 0x7cfff	(0x242 bytes)
6211305(233 mod 256): SKIPPED (no operation)
6211306(234 mod 256): COLLAPSE 0x3000 thru 0x13fff	(0x11000 bytes)
6211307(235 mod 256): COPY 0x5f099 thru 0x6bfff	(0xcf67 bytes) to 0x3eaac thru 0x4ba12
6211308(236 mod 256): WRITE    0x3abbd thru 0x3f16f	(0x45b3 bytes)
6211309(237 mod 256): READ     0x51973 thru 0x66eff	(0x1558d bytes)
6211310(238 mod 256): PUNCH    0x574a3 thru 0x63013	(0xbb71 bytes)
6211311(239 mod 256): FALLOC   0x3cb41 thru 0x3e587	(0x1a46 bytes) INTERIOR
6211312(240 mod 256): SKIPPED (no operation)
6211313(241 mod 256): MAPREAD  0x1f5f2 thru 0x3431b	(0x14d2a bytes)
6211314(242 mod 256): READ     0x37815 thru 0x451ac	(0xd998 bytes)
6211315(243 mod 256): SKIPPED (no operation)
6211316(244 mod 256): SKIPPED (no operation)
6211317(245 mod 256): COPY 0x31501 thru 0x4131e	(0xfe1e bytes) to 0x585a thru 0x15677
6211318(246 mod 256): INSERT 0x36000 thru 0x51fff	(0x1c000 bytes)
6211319(247 mod 256): CLONE 0x84000 thru 0x86fff	(0x3000 bytes) to 0x1000 thru 0x3fff
6211320(248 mod 256): COPY 0x124f4 thru 0x2a8e8	(0x183f5 bytes) to 0x4475a thru 0x5cb4e
6211321(249 mod 256): COLLAPSE 0x11000 thru 0x1bfff	(0xb000 bytes)
6211322(250 mod 256): SKIPPED (no operation)
6211323(251 mod 256): COLLAPSE 0x72000 thru 0x7bfff	(0xa000 bytes)
6211324(252 mod 256): WRITE    0x2f6ba thru 0x46f54	(0x1789b bytes)
6211325(253 mod 256): ZERO     0x52534 thru 0x6aa6c	(0x18539 bytes)
6211326(254 mod 256): MAPWRITE 0x1430e thru 0x1ec12	(0xa905 bytes)
6211327(255 mod 256): MAPREAD  0x52829 thru 0x5773c	(0x4f14 bytes)
6211328(  0 mod 256): DEDUPE 0xa000 thru 0x1cfff	(0x13000 bytes) to 0x5d000 thru 0x6ffff	******BBBB
6211329(  1 mod 256): DEDUPE 0x14000 thru 0x14fff	(0x1000 bytes) to 0x54000 thru 0x54fff
6211330(  2 mod 256): TRUNCATE DOWN	from 0x73000 to 0x3c59	******WWWW
6211331(  3 mod 256): READ     0x3330 thru 0x3c58	(0x929 bytes)
6211332(  4 mod 256): CLONE 0x2000 thru 0x2fff	(0x1000 bytes) to 0x68000 thru 0x68fff
6211333(  5 mod 256): COLLAPSE 0x32000 thru 0x4ffff	(0x1e000 bytes)
6211334(  6 mod 256): PUNCH    0x3c5b9 thru 0x4871a	(0xc162 bytes)
6211335(  7 mod 256): INSERT 0x33000 thru 0x41fff	(0xf000 bytes)
6211336(  8 mod 256): ZERO     0x3d07a thru 0x5b9e2	(0x1e969 bytes)
6211337(  9 mod 256): PUNCH    0x19ca8 thru 0x2cc13	(0x12f6c bytes)
6211338( 10 mod 256): COPY 0x41149 thru 0x59fff	(0x18eb7 bytes) to 0x5afe5 thru 0x73e9b	******EEEE
6211339( 11 mod 256): CLONE 0x31000 thru 0x42fff	(0x12000 bytes) to 0x4e000 thru 0x5ffff
6211340( 12 mod 256): WRITE    0x26b99 thru 0x44fcb	(0x1e433 bytes)
6211341( 13 mod 256): ZERO     0x591e6 thru 0x71a68	(0x18883 bytes)	******ZZZZ
6211342( 14 mod 256): MAPREAD  0x223d9 thru 0x32ba0	(0x107c8 bytes)
6211343( 15 mod 256): MAPWRITE 0x2df4f thru 0x3a3f1	(0xc4a3 bytes)
6211344( 16 mod 256): DEDUPE 0xd000 thru 0x27fff	(0x1b000 bytes) to 0x36000 thru 0x50fff
6211345( 17 mod 256): FALLOC   0x8be4f thru 0x927c0	(0x6971 bytes) EXTENDING
6211346( 18 mod 256): MAPREAD  0x392f8 thru 0x542b6	(0x1afbf bytes)
6211347( 19 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x90810
6211348( 20 mod 256): FALLOC   0x1c402 thru 0x34084	(0x17c82 bytes) INTERIOR
6211349( 21 mod 256): READ     0x55481 thru 0x6af1d	(0x15a9d bytes)
6211350( 22 mod 256): WRITE    0x1f350 thru 0x26e08	(0x7ab9 bytes)
6211351( 23 mod 256): SKIPPED (no operation)
6211352( 24 mod 256): DEDUPE 0x4a000 thru 0x67fff	(0x1e000 bytes) to 0x2c000 thru 0x49fff
6211353( 25 mod 256): READ     0x19619 thru 0x356ab	(0x1c093 bytes)
6211354( 26 mod 256): TRUNCATE DOWN	from 0x90810 to 0x51b4c	******WWWW
6211355( 27 mod 256): TRUNCATE DOWN	from 0x51b4c to 0x27866
6211356( 28 mod 256): MAPWRITE 0x3bf46 thru 0x4aabf	(0xeb7a bytes)
6211357( 29 mod 256): CLONE 0x36000 thru 0x42fff	(0xd000 bytes) to 0x73000 thru 0x7ffff
6211358( 30 mod 256): COPY 0x288ff thru 0x39a17	(0x11119 bytes) to 0x78c65 thru 0x89d7d
6211359( 31 mod 256): PUNCH    0x73cb6 thru 0x7ce4e	(0x9199 bytes)
6211360( 32 mod 256): PUNCH    0x33c92 thru 0x3e03a	(0xa3a9 bytes)
6211361( 33 mod 256): WRITE    0x72f65 thru 0x7e218	(0xb2b4 bytes)
6211362( 34 mod 256): COPY 0x37584 thru 0x495ff	(0x1207c bytes) to 0x12914 thru 0x2498f
6211363( 35 mod 256): SKIPPED (no operation)
6211364( 36 mod 256): FALLOC   0x6538 thru 0x20665	(0x1a12d bytes) INTERIOR
6211365( 37 mod 256): MAPREAD  0x885bc thru 0x89d7d	(0x17c2 bytes)
6211366( 38 mod 256): COPY 0x347d8 thru 0x4904b	(0x14874 bytes) to 0x6a215 thru 0x7ea88	******EEEE
6211367( 39 mod 256): TRUNCATE DOWN	from 0x89d7e to 0x12ee	******WWWW
6211368( 40 mod 256): SKIPPED (no operation)
6211369( 41 mod 256): INSERT 0x0 thru 0x11fff	(0x12000 bytes)
6211370( 42 mod 256): READ     0xd421 thru 0x132ed	(0x5ecd bytes)
6211371( 43 mod 256): PUNCH    0xad51 thru 0xf461	(0x4711 bytes)
6211372( 44 mod 256): ZERO     0x68820 thru 0x85303	(0x1cae4 bytes)	******ZZZZ
6211373( 45 mod 256): PUNCH    0x505eb thru 0x6a9b7	(0x1a3cd bytes)
6211374( 46 mod 256): COPY 0x4142 thru 0x57f7	(0x16b6 bytes) to 0x7d869 thru 0x7ef1e
6211375( 47 mod 256): FALLOC   0x39dd1 thru 0x52000	(0x1822f bytes) INTERIOR
6211376( 48 mod 256): DEDUPE 0x75000 thru 0x79fff	(0x5000 bytes) to 0x10000 thru 0x14fff
6211377( 49 mod 256): FALLOC   0xc6aa thru 0x21c55	(0x155ab bytes) INTERIOR
6211378( 50 mod 256): COLLAPSE 0x52000 thru 0x5afff	(0x9000 bytes)
6211379( 51 mod 256): PUNCH    0x4318c thru 0x52423	(0xf298 bytes)
6211380( 52 mod 256): ZERO     0x1f2c9 thru 0x3a491	(0x1b1c9 bytes)
6211381( 53 mod 256): TRUNCATE DOWN	from 0x7c304 to 0x2c8ce	******WWWW
6211382( 54 mod 256): TRUNCATE UP	from 0x2c8ce to 0x64076
6211383( 55 mod 256): SKIPPED (no operation)
6211384( 56 mod 256): WRITE    0x65e76 thru 0x6bc74	(0x5dff bytes) HOLE
6211385( 57 mod 256): PUNCH    0x639a thru 0x16505	(0x1016c bytes)
6211386( 58 mod 256): SKIPPED (no operation)
6211387( 59 mod 256): COLLAPSE 0xf000 thru 0x19fff	(0xb000 bytes)
6211388( 60 mod 256): TRUNCATE UP	from 0x60c75 to 0x6a4e8
6211389( 61 mod 256): SKIPPED (no operation)
6211390( 62 mod 256): TRUNCATE DOWN	from 0x6a4e8 to 0x679ff
6211391( 63 mod 256): ZERO     0x6df9e thru 0x71748	(0x37ab bytes)	******ZZZZ
6211392( 64 mod 256): DEDUPE 0x12000 thru 0x19fff	(0x8000 bytes) to 0x39000 thru 0x40fff
6211393( 65 mod 256): COPY 0x475b9 thru 0x522d4	(0xad1c bytes) to 0x81818 thru 0x8c533
6211394( 66 mod 256): SKIPPED (no operation)
6211395( 67 mod 256): SKIPPED (no operation)
6211396( 68 mod 256): SKIPPED (no operation)
6211397( 69 mod 256): COLLAPSE 0x7d000 thru 0x8afff	(0xe000 bytes)
6211398( 70 mod 256): CLONE 0x11000 thru 0x2efff	(0x1e000 bytes) to 0x4a000 thru 0x67fff
6211399( 71 mod 256): CLONE 0x4f000 thru 0x60fff	(0x12000 bytes) to 0x8000 thru 0x19fff
6211400( 72 mod 256): PUNCH    0x7cc49 thru 0x7e533	(0x18eb bytes)
6211401( 73 mod 256): SKIPPED (no operation)
6211402( 74 mod 256): CLONE 0x58000 thru 0x59fff	(0x2000 bytes) to 0x5e000 thru 0x5ffff
6211403( 75 mod 256): TRUNCATE DOWN	from 0x7e534 to 0x3e5b9	******WWWW
6211404( 76 mod 256): PUNCH    0x2808e thru 0x2ccec	(0x4c5f bytes)
6211405( 77 mod 256): MAPWRITE 0x57dc9 thru 0x5fe36	(0x806e bytes)
6211406( 78 mod 256): FALLOC   0x699cc thru 0x7ee0d	(0x15441 bytes) PAST_EOF	******FFFF
6211407( 79 mod 256): SKIPPED (no operation)
6211408( 80 mod 256): TRUNCATE DOWN	from 0x5fe37 to 0x5168b
6211409( 81 mod 256): SKIPPED (no operation)
6211410( 82 mod 256): PUNCH    0x137f1 thru 0x16d3b	(0x354b bytes)
6211411( 83 mod 256): WRITE    0xd472 thru 0x20175	(0x12d04 bytes)
6211412( 84 mod 256): FALLOC   0x437d1 thru 0x5d765	(0x19f94 bytes) EXTENDING
6211413( 85 mod 256): READ     0x39cfa thru 0x4ec61	(0x14f68 bytes)
6211414( 86 mod 256): ZERO     0x4055a thru 0x4f7a8	(0xf24f bytes)
6211415( 87 mod 256): WRITE    0x4e63e thru 0x51441	(0x2e04 bytes)
6211416( 88 mod 256): READ     0x4efe9 thru 0x54bed	(0x5c05 bytes)
6211417( 89 mod 256): SKIPPED (no operation)
6211418( 90 mod 256): MAPWRITE 0x19165 thru 0x2f2bc	(0x16158 bytes)
6211419( 91 mod 256): READ     0x3682 thru 0x1b57b	(0x17efa bytes)
6211420( 92 mod 256): SKIPPED (no operation)
6211421( 93 mod 256): COPY 0x1cb7d thru 0x277aa	(0xac2e bytes) to 0x40ecf thru 0x4bafc
6211422( 94 mod 256): INSERT 0x41000 thru 0x53fff	(0x13000 bytes)
6211423( 95 mod 256): INSERT 0x23000 thru 0x39fff	(0x17000 bytes)
6211424( 96 mod 256): INSERT 0x18000 thru 0x22fff	(0xb000 bytes)
6211425( 97 mod 256): SKIPPED (no operation)
6211426( 98 mod 256): COLLAPSE 0x75000 thru 0x8cfff	(0x18000 bytes)
6211427( 99 mod 256): CLONE 0x4c000 thru 0x60fff	(0x15000 bytes) to 0x72000 thru 0x86fff
6211428(100 mod 256): COLLAPSE 0x62000 thru 0x64fff	(0x3000 bytes)
6211429(101 mod 256): ZERO     0x5a8d0 thru 0x73cb3	(0x193e4 bytes)	******ZZZZ
6211430(102 mod 256): DEDUPE 0x54000 thru 0x6ffff	(0x1c000 bytes) to 0x33000 thru 0x4efff	BBBB******
6211431(103 mod 256): CLONE 0x5a000 thru 0x67fff	(0xe000 bytes) to 0x6b000 thru 0x78fff	******JJJJ
6211432(104 mod 256): FALLOC   0xecc thru 0x1aa3f	(0x19b73 bytes) INTERIOR
6211433(105 mod 256): WRITE    0x32dc1 thru 0x43398	(0x105d8 bytes)
6211434(106 mod 256): WRITE    0x601d4 thru 0x74172	(0x13f9f bytes)	***WWWW
6211435(107 mod 256): PUNCH    0x28e21 thru 0x3487b	(0xba5b bytes)
6211436(108 mod 256): READ     0x7b548 thru 0x83fff	(0x8ab8 bytes)
6211437(109 mod 256): COLLAPSE 0x5f000 thru 0x7afff	(0x1c000 bytes)	******CCCC
6211438(110 mod 256): READ     0x159d9 thru 0x2adaa	(0x153d2 bytes)
6211439(111 mod 256): INSERT 0x5e000 thru 0x6dfff	(0x10000 bytes)
6211440(112 mod 256): PUNCH    0x44464 thru 0x519c6	(0xd563 bytes)
6211441(113 mod 256): PUNCH    0x1480f thru 0x1bfb6	(0x77a8 bytes)
6211442(114 mod 256): ZERO     0x43a64 thru 0x49932	(0x5ecf bytes)
6211443(115 mod 256): CLONE 0x5000 thru 0x13fff	(0xf000 bytes) to 0x79000 thru 0x87fff
6211444(116 mod 256): FALLOC   0x28a9c thru 0x325e3	(0x9b47 bytes) INTERIOR
6211445(117 mod 256): SKIPPED (no operation)
6211446(118 mod 256): DEDUPE 0x5c000 thru 0x77fff	(0x1c000 bytes) to 0x4000 thru 0x1ffff	BBBB******
6211447(119 mod 256): INSERT 0x32000 thru 0x3bfff	(0xa000 bytes)
6211448(120 mod 256): MAPWRITE 0x2f7ae thru 0x3254a	(0x2d9d bytes)
6211449(121 mod 256): CLONE 0x34000 thru 0x34fff	(0x1000 bytes) to 0x53000 thru 0x53fff
6211450(122 mod 256): MAPREAD  0x2cb72 thru 0x476f6	(0x1ab85 bytes)
6211451(123 mod 256): MAPWRITE 0x1f167 thru 0x31b0c	(0x129a6 bytes)
6211452(124 mod 256): WRITE    0x908ab thru 0x927bf	(0x1f15 bytes) EXTEND
6211453(125 mod 256): DEDUPE 0x31000 thru 0x31fff	(0x1000 bytes) to 0x42000 thru 0x42fff
6211454(126 mod 256): COPY 0x3f054 thru 0x56312	(0x172bf bytes) to 0x1ad2c thru 0x31fea
6211455(127 mod 256): SKIPPED (no operation)
6211456(128 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x40801	******WWWW
6211457(129 mod 256): PUNCH    0x35029 thru 0x40800	(0xb7d8 bytes)
6211458(130 mod 256): COPY 0x2fe16 thru 0x3ade7	(0xafd2 bytes) to 0x5db83 thru 0x68b54
6211459(131 mod 256): COLLAPSE 0x2a000 thru 0x2efff	(0x5000 bytes)
6211460(132 mod 256): TRUNCATE DOWN	from 0x63b55 to 0x452a9
6211461(133 mod 256): COPY 0x1283a thru 0x2782a	(0x14ff1 bytes) to 0x6e209 thru 0x831f9	******EEEE
6211462(134 mod 256): DEDUPE 0x39000 thru 0x51fff	(0x19000 bytes) to 0x5a000 thru 0x72fff	******BBBB
6211463(135 mod 256): MAPWRITE 0x250ee thru 0x322cc	(0xd1df bytes)
6211464(136 mod 256): SKIPPED (no operation)
6211465(137 mod 256): COPY 0x36381 thru 0x3be5f	(0x5adf bytes) to 0x17544 thru 0x1d022
6211466(138 mod 256): INSERT 0x28000 thru 0x31fff	(0xa000 bytes)
6211467(139 mod 256): COPY 0x43bd0 thru 0x50c8c	(0xd0bd bytes) to 0x83bab thru 0x90c67
6211468(140 mod 256): ZERO     0x32f7a thru 0x4d7a3	(0x1a82a bytes)
6211469(141 mod 256): MAPREAD  0x30f65 thru 0x33cfa	(0x2d96 bytes)
6211470(142 mod 256): SKIPPED (no operation)
6211471(143 mod 256): SKIPPED (no operation)
6211472(144 mod 256): READ     0x41187 thru 0x4300d	(0x1e87 bytes)
6211473(145 mod 256): SKIPPED (no operation)
6211474(146 mod 256): CLONE 0x53000 thru 0x59fff	(0x7000 bytes) to 0x21000 thru 0x27fff
6211475(147 mod 256): CLONE 0x65000 thru 0x82fff	(0x1e000 bytes) to 0x2f000 thru 0x4cfff	JJJJ******
6211476(148 mod 256): FALLOC   0x56494 thru 0x65146	(0xecb2 bytes) INTERIOR
6211477(149 mod 256): COLLAPSE 0x1a000 thru 0x27fff	(0xe000 bytes)
6211478(150 mod 256): ZERO     0x6903b thru 0x7e07e	(0x15044 bytes)	******ZZZZ
6211479(151 mod 256): MAPWRITE 0x36c2c thru 0x3c0bb	(0x5490 bytes)
6211480(152 mod 256): ZERO     0x4e9c4 thru 0x521d0	(0x380d bytes)
6211481(153 mod 256): WRITE    0x334c0 thru 0x4e6d1	(0x1b212 bytes)
6211482(154 mod 256): CLONE 0x5000 thru 0x17fff	(0x13000 bytes) to 0x75000 thru 0x87fff
6211483(155 mod 256): COPY 0x646e0 thru 0x79af7	(0x15418 bytes) to 0x41b5d thru 0x56f74	EEEE******
6211484(156 mod 256): MAPWRITE 0x89dcc thru 0x8a286	(0x4bb bytes)
6211485(157 mod 256): WRITE    0x3487a thru 0x4c68b	(0x17e12 bytes)
6211486(158 mod 256): READ     0xdd52 thru 0xe8ce	(0xb7d bytes)
6211487(159 mod 256): COLLAPSE 0x55000 thru 0x6bfff	(0x17000 bytes)
6211488(160 mod 256): ZERO     0x71c3b thru 0x758a9	(0x3c6f bytes)
6211489(161 mod 256): MAPWRITE 0x61730 thru 0x7c5ae	(0x1ae7f bytes)	******WWWW
6211490(162 mod 256): DEDUPE 0x3c000 thru 0x52fff	(0x17000 bytes) to 0x56000 thru 0x6cfff
6211491(163 mod 256): DEDUPE 0x9000 thru 0xffff	(0x7000 bytes) to 0x3a000 thru 0x40fff
6211492(164 mod 256): MAPWRITE 0x253fd thru 0x27826	(0x242a bytes)
6211493(165 mod 256): ZERO     0x8add7 thru 0x912bd	(0x64e7 bytes)
6211494(166 mod 256): INSERT 0x3f000 thru 0x3ffff	(0x1000 bytes)
6211495(167 mod 256): CLONE 0x23000 thru 0x2cfff	(0xa000 bytes) to 0x2d000 thru 0x36fff
6211496(168 mod 256): DEDUPE 0x0 thru 0x2fff	(0x3000 bytes) to 0x7a000 thru 0x7cfff
6211497(169 mod 256): SKIPPED (no operation)
6211498(170 mod 256): SKIPPED (no operation)
6211499(171 mod 256): READ     0x87510 thru 0x922bd	(0xadae bytes)
6211500(172 mod 256): COLLAPSE 0x62000 thru 0x6afff	(0x9000 bytes)
6211501(173 mod 256): TRUNCATE DOWN	from 0x892be to 0x50485	******WWWW
6211502(174 mod 256): COPY 0x3bab1 thru 0x45416	(0x9966 bytes) to 0x713ee thru 0x7ad53
6211503(175 mod 256): FALLOC   0x20946 thru 0x32677	(0x11d31 bytes) INTERIOR
6211504(176 mod 256): SKIPPED (no operation)
6211505(177 mod 256): PUNCH    0x48eca thru 0x4f247	(0x637e bytes)
6211506(178 mod 256): MAPWRITE 0x8dc9f thru 0x927bf	(0x4b21 bytes)
6211507(179 mod 256): FALLOC   0x2e2e9 thru 0x3f1bf	(0x10ed6 bytes) INTERIOR
6211508(180 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x23203	******WWWW
6211509(181 mod 256): TRUNCATE UP	from 0x23203 to 0x4c120
6211510(182 mod 256): READ     0x27a36 thru 0x3bf9e	(0x14569 bytes)
6211511(183 mod 256): READ     0x132aa thru 0x28eef	(0x15c46 bytes)
6211512(184 mod 256): COPY 0x172f5 thru 0x1ed2a	(0x7a36 bytes) to 0x80aa thru 0xfadf
6211513(185 mod 256): INSERT 0x33000 thru 0x3bfff	(0x9000 bytes)
6211514(186 mod 256): MAPWRITE 0x4e764 thru 0x523ae	(0x3c4b bytes)
6211515(187 mod 256): ZERO     0x6d0ba thru 0x85756	(0x1869d bytes)	******ZZZZ
6211516(188 mod 256): TRUNCATE DOWN	from 0x55120 to 0x20e0
6211517(189 mod 256): FALLOC   0x2c202 thru 0x2f8b0	(0x36ae bytes) EXTENDING
6211518(190 mod 256): CLONE 0x1000 thru 0x9fff	(0x9000 bytes) to 0x73000 thru 0x7bfff
6211519(191 mod 256): INSERT 0x1000 thru 0x16fff	(0x16000 bytes)
6211520(192 mod 256): DEDUPE 0x16000 thru 0x2ffff	(0x1a000 bytes) to 0x47000 thru 0x60fff
6211521(193 mod 256): COLLAPSE 0x4b000 thru 0x58fff	(0xe000 bytes)
6211522(194 mod 256): INSERT 0x2000 thru 0xffff	(0xe000 bytes)
6211523(195 mod 256): DEDUPE 0x84000 thru 0x90fff	(0xd000 bytes) to 0x6b000 thru 0x77fff	******BBBB
6211524(196 mod 256): TRUNCATE DOWN	from 0x92000 to 0xc25d	******WWWW
6211525(197 mod 256): ZERO     0x1b412 thru 0x1b4a2	(0x91 bytes)
6211526(198 mod 256): INSERT 0x0 thru 0x4fff	(0x5000 bytes)
6211527(199 mod 256): READ     0x178fc thru 0x18353	(0xa58 bytes)
6211528(200 mod 256): READ     0xadf thru 0xad41	(0xa263 bytes)
6211529(201 mod 256): ZERO     0x15645 thru 0x24444	(0xee00 bytes)
6211530(202 mod 256): PUNCH    0x17a9a thru 0x184a7	(0xa0e bytes)
6211531(203 mod 256): DEDUPE 0x13000 thru 0x22fff	(0x10000 bytes) to 0x0 thru 0xffff
6211532(204 mod 256): TRUNCATE UP	from 0x24445 to 0x5d340
6211533(205 mod 256): SKIPPED (no operation)
6211534(206 mod 256): CLONE 0x31000 thru 0x3cfff	(0xc000 bytes) to 0x6e000 thru 0x79fff	******JJJJ
6211535(207 mod 256): SKIPPED (no operation)
6211536(208 mod 256): INSERT 0x1c000 thru 0x33fff	(0x18000 bytes)
6211537(209 mod 256): SKIPPED (no operation)
6211538(210 mod 256): WRITE    0x12cb thru 0x752d	(0x6263 bytes)
6211539(211 mod 256): READ     0x7c005 thru 0x8b53e	(0xf53a bytes)
6211540(212 mod 256): SKIPPED (no operation)
6211541(213 mod 256): ZERO     0x44f27 thru 0x5fa67	(0x1ab41 bytes)
6211542(214 mod 256): PUNCH    0x67022 thru 0x7ce12	(0x15df1 bytes)	******PPPP
6211543(215 mod 256): SKIPPED (no operation)
6211544(216 mod 256): MAPWRITE 0x36310 thru 0x3d2f6	(0x6fe7 bytes)
6211545(217 mod 256): FALLOC   0x2e2fd thru 0x33237	(0x4f3a bytes) INTERIOR
6211546(218 mod 256): WRITE    0xe522 thru 0x15c0f	(0x76ee bytes)
6211547(219 mod 256): COPY 0x2d94f thru 0x48ef1	(0x1b5a3 bytes) to 0x5f52b thru 0x7aacd	******EEEE
6211548(220 mod 256): COLLAPSE 0x23000 thru 0x34fff	(0x12000 bytes)
6211549(221 mod 256): COPY 0x6645c thru 0x7dc58	(0x177fd bytes) to 0x4b2e6 thru 0x62ae2	EEEE******
6211550(222 mod 256): ZERO     0x7da23 thru 0x8f463	(0x11a41 bytes)
6211551(223 mod 256): COLLAPSE 0x6d000 thru 0x7efff	(0x12000 bytes)	******CCCC
6211552(224 mod 256): COPY 0x22a7f thru 0x40ec6	(0x1e448 bytes) to 0x4a0e1 thru 0x68528
6211553(225 mod 256): CLONE 0xa000 thru 0x16fff	(0xd000 bytes) to 0x2c000 thru 0x38fff
6211554(226 mod 256): READ     0x29e83 thru 0x32e4f	(0x8fcd bytes)
6211555(227 mod 256): DEDUPE 0x40000 thru 0x5dfff	(0x1e000 bytes) to 0x5e000 thru 0x7bfff	******BBBB
6211556(228 mod 256): CLONE 0x38000 thru 0x44fff	(0xd000 bytes) to 0xa000 thru 0x16fff
6211557(229 mod 256): TRUNCATE DOWN	from 0x7d464 to 0x1838a	******WWWW
6211558(230 mod 256): COLLAPSE 0xa000 thru 0x11fff	(0x8000 bytes)
6211559(231 mod 256): SKIPPED (no operation)
6211560(232 mod 256): FALLOC   0x726b9 thru 0x79e13	(0x775a bytes) EXTENDING
6211561(233 mod 256): CLONE 0x4f000 thru 0x69fff	(0x1b000 bytes) to 0x6f000 thru 0x89fff
6211562(234 mod 256): READ     0x86eae thru 0x89fff	(0x3152 bytes)
6211563(235 mod 256): PUNCH    0x11054 thru 0x26b9c	(0x15b49 bytes)
6211564(236 mod 256): READ     0x70cb2 thru 0x89fff	(0x1934e bytes)
6211565(237 mod 256): MAPREAD  0x45114 thru 0x470bc	(0x1fa9 bytes)
6211566(238 mod 256): COLLAPSE 0x1e000 thru 0x28fff	(0xb000 bytes)
6211567(239 mod 256): MAPREAD  0x5f397 thru 0x758ba	(0x16524 bytes)	***RRRR***
6211568(240 mod 256): COLLAPSE 0x74000 thru 0x78fff	(0x5000 bytes)
6211569(241 mod 256): WRITE    0x83609 thru 0x89590	(0x5f88 bytes) HOLE
6211570(242 mod 256): WRITE    0x5e265 thru 0x7b17e	(0x1cf1a bytes)	***WWWW
6211571(243 mod 256): COPY 0x6a244 thru 0x7ab47	(0x10904 bytes) to 0xc9e4 thru 0x1d2e7	EEEE******
6211572(244 mod 256): ZERO     0x75428 thru 0x7909b	(0x3c74 bytes)
6211573(245 mod 256): TRUNCATE DOWN	from 0x89591 to 0x49187	******WWWW
6211574(246 mod 256): CLONE 0x5000 thru 0x1ffff	(0x1b000 bytes) to 0x4f000 thru 0x69fff
6211575(247 mod 256): PUNCH    0x62117 thru 0x69fff	(0x7ee9 bytes)
6211576(248 mod 256): WRITE    0x4c304 thru 0x4c366	(0x63 bytes)
6211577(249 mod 256): ZERO     0x358f1 thru 0x3fc08	(0xa318 bytes)
6211578(250 mod 256): MAPREAD  0x6032b thru 0x69fff	(0x9cd5 bytes)
6211579(251 mod 256): CLONE 0x59000 thru 0x68fff	(0x10000 bytes) to 0x6c000 thru 0x7bfff	******JJJJ
6211580(252 mod 256): SKIPPED (no operation)
6211581(253 mod 256): WRITE    0x8c4c8 thru 0x927bf	(0x62f8 bytes) HOLE
6211582(254 mod 256): DEDUPE 0x3e000 thru 0x53fff	(0x16000 bytes) to 0x19000 thru 0x2efff
6211583(255 mod 256): WRITE    0x47325 thru 0x49237	(0x1f13 bytes)
6211584(  0 mod 256): MAPWRITE 0x21eb6 thru 0x3da83	(0x1bbce bytes)
6211585(  1 mod 256): MAPWRITE 0x38e3c thru 0x439ec	(0xabb1 bytes)
6211586(  2 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x25265	******WWWW
6211587(  3 mod 256): FALLOC   0x12233 thru 0x2ec0f	(0x1c9dc bytes) EXTENDING
6211588(  4 mod 256): MAPREAD  0x2d99 thru 0x1c1c6	(0x1942e bytes)
6211589(  5 mod 256): READ     0x289f4 thru 0x2a845	(0x1e52 bytes)
6211590(  6 mod 256): MAPWRITE 0x1b332 thru 0x2f20a	(0x13ed9 bytes)
6211591(  7 mod 256): SKIPPED (no operation)
6211592(  8 mod 256): DEDUPE 0x23000 thru 0x2bfff	(0x9000 bytes) to 0x10000 thru 0x18fff
6211593(  9 mod 256): READ     0x1d4e4 thru 0x2144b	(0x3f68 bytes)
6211594( 10 mod 256): INSERT 0x0 thru 0x1afff	(0x1b000 bytes)
6211595( 11 mod 256): SKIPPED (no operation)
6211596( 12 mod 256): FALLOC   0x196e7 thru 0x1bdb0	(0x26c9 bytes) INTERIOR
6211597( 13 mod 256): MAPREAD  0x1bd6 thru 0x1398b	(0x11db6 bytes)
6211598( 14 mod 256): COPY 0x28301 thru 0x395cb	(0x112cb bytes) to 0x16fae thru 0x28278
6211599( 15 mod 256): MAPREAD  0x3e5f2 thru 0x4a20a	(0xbc19 bytes)
6211600( 16 mod 256): MAPREAD  0x3bf3 thru 0x1e5aa	(0x1a9b8 bytes)
6211601( 17 mod 256): CLONE 0x36000 thru 0x48fff	(0x13000 bytes) to 0x7f000 thru 0x91fff
6211602( 18 mod 256): MAPWRITE 0x20bce thru 0x2a35e	(0x9791 bytes)
6211603( 19 mod 256): ZERO     0x35d33 thru 0x36b8d	(0xe5b bytes)
6211604( 20 mod 256): ZERO     0x8122b thru 0x913a9	(0x1017f bytes)
6211605( 21 mod 256): SKIPPED (no operation)
6211606( 22 mod 256): COPY 0x6d8f8 thru 0x72df0	(0x54f9 bytes) to 0x2a9cd thru 0x2fec5	EEEE******
6211607( 23 mod 256): SKIPPED (no operation)
6211608( 24 mod 256): READ     0x4ab89 thru 0x653ac	(0x1a824 bytes)
6211609( 25 mod 256): SKIPPED (no operation)
6211610( 26 mod 256): MAPWRITE 0x8d5e1 thru 0x927bf	(0x51df bytes)
6211611( 27 mod 256): SKIPPED (no operation)
6211612( 28 mod 256): READ     0x77155 thru 0x894a0	(0x1234c bytes)
6211613( 29 mod 256): SKIPPED (no operation)
6211614( 30 mod 256): FALLOC   0x3807e thru 0x56188	(0x1e10a bytes) INTERIOR
6211615( 31 mod 256): COPY 0x8cfa7 thru 0x927bf	(0x5819 bytes) to 0x477e1 thru 0x4cff9
6211616( 32 mod 256): READ     0xd3d8 thru 0xd720	(0x349 bytes)
6211617( 33 mod 256): SKIPPED (no operation)
6211618( 34 mod 256): FALLOC   0x6f2fe thru 0x8c6b7	(0x1d3b9 bytes) INTERIOR
6211619( 35 mod 256): COPY 0x3c450 thru 0x58180	(0x1bd31 bytes) to 0xaad9 thru 0x26809
6211620( 36 mod 256): SKIPPED (no operation)
6211621( 37 mod 256): SKIPPED (no operation)
6211622( 38 mod 256): DEDUPE 0x8f000 thru 0x91fff	(0x3000 bytes) to 0x23000 thru 0x25fff
6211623( 39 mod 256): SKIPPED (no operation)
6211624( 40 mod 256): MAPREAD  0x467ef thru 0x62017	(0x1b829 bytes)
6211625( 41 mod 256): WRITE    0x71cbd thru 0x75f21	(0x4265 bytes)
6211626( 42 mod 256): ZERO     0x54e4c thru 0x6d106	(0x182bb bytes)
6211627( 43 mod 256): PUNCH    0x5fa67 thru 0x6f805	(0xfd9f bytes)	******PPPP
6211628( 44 mod 256): COPY 0x5f4fc thru 0x7706f	(0x17b74 bytes) to 0x224ca thru 0x3a03d	EEEE******
6211629( 45 mod 256): COLLAPSE 0x64000 thru 0x66fff	(0x3000 bytes)
6211630( 46 mod 256): MAPREAD  0x2ad02 thru 0x34270	(0x956f bytes)
6211631( 47 mod 256): READ     0xb3e1 thru 0x24855	(0x19475 bytes)
6211632( 48 mod 256): ZERO     0x2993c thru 0x2c893	(0x2f58 bytes)
6211633( 49 mod 256): MAPWRITE 0xd040 thru 0x1b850	(0xe811 bytes)
6211634( 50 mod 256): ZERO     0x49cb6 thru 0x5f451	(0x1579c bytes)
6211635( 51 mod 256): MAPWRITE 0x678e9 thru 0x6e1f7	(0x690f bytes)
6211636( 52 mod 256): COPY 0x7c350 thru 0x8f7bf	(0x13470 bytes) to 0x15eca thru 0x29339
6211637( 53 mod 256): SKIPPED (no operation)
6211638( 54 mod 256): INSERT 0x5a000 thru 0x5cfff	(0x3000 bytes)
6211639( 55 mod 256): SKIPPED (no operation)
6211640( 56 mod 256): FALLOC   0x33307 thru 0x41cce	(0xe9c7 bytes) INTERIOR
6211641( 57 mod 256): MAPREAD  0x86d85 thru 0x927bf	(0xba3b bytes)
6211642( 58 mod 256): DEDUPE 0x16000 thru 0x21fff	(0xc000 bytes) to 0x2a000 thru 0x35fff
6211643( 59 mod 256): COPY 0x28a5c thru 0x30163	(0x7708 bytes) to 0x79ffe thru 0x81705
6211644( 60 mod 256): ZERO     0x6cab2 thru 0x83eb7	(0x17406 bytes)	******ZZZZ
6211645( 61 mod 256): MAPREAD  0x492df thru 0x5493f	(0xb661 bytes)
6211646( 62 mod 256): MAPWRITE 0x73762 thru 0x897e3	(0x16082 bytes)
6211647( 63 mod 256): DEDUPE 0x5d000 thru 0x66fff	(0xa000 bytes) to 0xa000 thru 0x13fff
6211648( 64 mod 256): SKIPPED (no operation)
6211649( 65 mod 256): PUNCH    0x68fa8 thru 0x728d3	(0x992c bytes)	******PPPP
6211650( 66 mod 256): SKIPPED (no operation)
6211651( 67 mod 256): MAPREAD  0x20be4 thru 0x36409	(0x15826 bytes)
6211652( 68 mod 256): COPY 0x85e11 thru 0x8e752	(0x8942 bytes) to 0x45ced thru 0x4e62e
6211653( 69 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8a9c1
6211654( 70 mod 256): COPY 0x31064 thru 0x4db70	(0x1cb0d bytes) to 0x4a01 thru 0x2150d
6211655( 71 mod 256): COPY 0x8480b thru 0x89a3b	(0x5231 bytes) to 0x1a2d0 thru 0x1f500
6211656( 72 mod 256): CLONE 0x38000 thru 0x40fff	(0x9000 bytes) to 0x4e000 thru 0x56fff
6211657( 73 mod 256): MAPREAD  0x82ee8 thru 0x8a9c0	(0x7ad9 bytes)
6211658( 74 mod 256): COPY 0x2fcac thru 0x4ba4a	(0x1bd9f bytes) to 0xb9e7 thru 0x27785
6211659( 75 mod 256): DEDUPE 0x51000 thru 0x6afff	(0x1a000 bytes) to 0x25000 thru 0x3efff
6211660( 76 mod 256): SKIPPED (no operation)
6211661( 77 mod 256): COPY 0x7a317 thru 0x8a9c0	(0x106aa bytes) to 0xd25b thru 0x1d904
6211662( 78 mod 256): WRITE    0x8c7be thru 0x927bf	(0x6002 bytes) HOLE
6211663( 79 mod 256): FALLOC   0x1d9f3 thru 0x26f11	(0x951e bytes) INTERIOR
6211664( 80 mod 256): SKIPPED (no operation)
6211665( 81 mod 256): SKIPPED (no operation)
6211666( 82 mod 256): COPY 0x3cdf5 thru 0x4bf6a	(0xf176 bytes) to 0x9969 thru 0x18ade
6211667( 83 mod 256): SKIPPED (no operation)
6211668( 84 mod 256): FALLOC   0x7bc80 thru 0x86b84	(0xaf04 bytes) INTERIOR
6211669( 85 mod 256): WRITE    0x23290 thru 0x2c636	(0x93a7 bytes)
6211670( 86 mod 256): COLLAPSE 0x89000 thru 0x90fff	(0x8000 bytes)
6211671( 87 mod 256): MAPWRITE 0x8f09f thru 0x927bf	(0x3721 bytes)
6211672( 88 mod 256): READ     0x123aa thru 0x21541	(0xf198 bytes)
6211673( 89 mod 256): COPY 0xcfca thru 0x2697c	(0x199b3 bytes) to 0x3651f thru 0x4fed1
6211674( 90 mod 256): FALLOC   0xb9b8 thru 0x18f8d	(0xd5d5 bytes) INTERIOR
6211675( 91 mod 256): READ     0x7aaa8 thru 0x927bf	(0x17d18 bytes)
6211676( 92 mod 256): DEDUPE 0x15000 thru 0x26fff	(0x12000 bytes) to 0x59000 thru 0x6afff
6211677( 93 mod 256): FALLOC   0x1d7cb thru 0x29f27	(0xc75c bytes) INTERIOR
6211678( 94 mod 256): READ     0x6da0e thru 0x8112c	(0x1371f bytes)	***RRRR***
6211679( 95 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x286f2	******WWWW
6211680( 96 mod 256): DEDUPE 0x14000 thru 0x26fff	(0x13000 bytes) to 0x0 thru 0x12fff
6211681( 97 mod 256): WRITE    0x106fa thru 0x1f003	(0xe90a bytes)
6211682( 98 mod 256): ZERO     0x3d1ed thru 0x4abbd	(0xd9d1 bytes)
6211683( 99 mod 256): COPY 0xfb0a thru 0x1c2c8	(0xc7bf bytes) to 0x43cee thru 0x504ac
6211684(100 mod 256): MAPWRITE 0x48933 thru 0x4f390	(0x6a5e bytes)
6211685(101 mod 256): ZERO     0x5b6e8 thru 0x5c457	(0xd70 bytes)
6211686(102 mod 256): FALLOC   0x486e8 thru 0x67164	(0x1ea7c bytes) EXTENDING
6211687(103 mod 256): SKIPPED (no operation)
6211688(104 mod 256): FALLOC   0x65730 thru 0x7d8fb	(0x181cb bytes) EXTENDING	******FFFF
6211689(105 mod 256): DEDUPE 0x8000 thru 0xcfff	(0x5000 bytes) to 0x1d000 thru 0x21fff
6211690(106 mod 256): TRUNCATE DOWN	from 0x7d8fb to 0x34a51	******WWWW
6211691(107 mod 256): COPY 0x1a16d thru 0x1ff8c	(0x5e20 bytes) to 0x40235 thru 0x46054
6211692(108 mod 256): ZERO     0x41be7 thru 0x60fb0	(0x1f3ca bytes)
6211693(109 mod 256): ZERO     0x33ad5 thru 0x46f9d	(0x134c9 bytes)
6211694(110 mod 256): INSERT 0x36000 thru 0x47fff	(0x12000 bytes)
6211695(111 mod 256): MAPWRITE 0x4594c thru 0x480c5	(0x277a bytes)
6211696(112 mod 256): DEDUPE 0x4000 thru 0x18fff	(0x15000 bytes) to 0x37000 thru 0x4bfff
6211697(113 mod 256): COPY 0x39bcb thru 0x3e8e9	(0x4d1f bytes) to 0x1c7f5 thru 0x21513
6211698(114 mod 256): COLLAPSE 0x70000 thru 0x71fff	(0x2000 bytes)
6211699(115 mod 256): COPY 0x3d6d0 thru 0x43ee7	(0x6818 bytes) to 0x2adc4 thru 0x315db
6211700(116 mod 256): WRITE    0x2476c thru 0x2eacb	(0xa360 bytes)
6211701(117 mod 256): WRITE    0x40618 thru 0x4e7e7	(0xe1d0 bytes)
6211702(118 mod 256): DEDUPE 0x1a000 thru 0x1dfff	(0x4000 bytes) to 0x37000 thru 0x3afff
6211703(119 mod 256): SKIPPED (no operation)
6211704(120 mod 256): TRUNCATE DOWN	from 0x70fb1 to 0x623be	******WWWW
6211705(121 mod 256): COPY 0x2b990 thru 0x3e73d	(0x12dae bytes) to 0x7e3b3 thru 0x91160
6211706(122 mod 256): MAPWRITE 0x8ca12 thru 0x927bf	(0x5dae bytes)
6211707(123 mod 256): CLONE 0x81000 thru 0x8cfff	(0xc000 bytes) to 0x39000 thru 0x44fff
6211708(124 mod 256): ZERO     0x5d0af thru 0x6fecf	(0x12e21 bytes)	******ZZZZ
6211709(125 mod 256): READ     0x1669 thru 0x70f9	(0x5a91 bytes)
6211710(126 mod 256): PUNCH    0x50e82 thru 0x5242b	(0x15aa bytes)
6211711(127 mod 256): DEDUPE 0x5e000 thru 0x63fff	(0x6000 bytes) to 0x37000 thru 0x3cfff
6211712(128 mod 256): CLONE 0x46000 thru 0x62fff	(0x1d000 bytes) to 0x19000 thru 0x35fff
6211713(129 mod 256): SKIPPED (no operation)
6211714(130 mod 256): COLLAPSE 0x40000 thru 0x42fff	(0x3000 bytes)
6211715(131 mod 256): MAPREAD  0x7e549 thru 0x8f7bf	(0x11277 bytes)
6211716(132 mod 256): INSERT 0x20000 thru 0x22fff	(0x3000 bytes)
6211717(133 mod 256): COLLAPSE 0x3e000 thru 0x54fff	(0x17000 bytes)
6211718(134 mod 256): CLONE 0x28000 thru 0x40fff	(0x19000 bytes) to 0x65000 thru 0x7dfff	******JJJJ
6211719(135 mod 256): PUNCH    0x7219a thru 0x7dfff	(0xbe66 bytes)
6211720(136 mod 256): WRITE    0x51e76 thru 0x68271	(0x163fc bytes)
6211721(137 mod 256): ZERO     0x4d42d thru 0x68c99	(0x1b86d bytes)
6211722(138 mod 256): WRITE    0x5d786 thru 0x7aa64	(0x1d2df bytes)	***WWWW
6211723(139 mod 256): TRUNCATE DOWN	from 0x7e000 to 0x36c41	******WWWW
6211724(140 mod 256): FALLOC   0x1ff09 thru 0x2e1c2	(0xe2b9 bytes) INTERIOR
6211725(141 mod 256): COLLAPSE 0x1e000 thru 0x2dfff	(0x10000 bytes)
6211726(142 mod 256): WRITE    0x73bde thru 0x84a5e	(0x10e81 bytes) HOLE	***WWWW
6211727(143 mod 256): MAPWRITE 0x32d2c thru 0x3e204	(0xb4d9 bytes)
6211728(144 mod 256): SKIPPED (no operation)
6211729(145 mod 256): COLLAPSE 0x7d000 thru 0x83fff	(0x7000 bytes)
6211730(146 mod 256): MAPWRITE 0x3e2b9 thru 0x4854a	(0xa292 bytes)
6211731(147 mod 256): DEDUPE 0x30000 thru 0x47fff	(0x18000 bytes) to 0xb000 thru 0x22fff
6211732(148 mod 256): FALLOC   0x6cc22 thru 0x75f7a	(0x9358 bytes) INTERIOR	******FFFF
6211733(149 mod 256): FALLOC   0x79d70 thru 0x91c7d	(0x17f0d bytes) PAST_EOF
6211734(150 mod 256): TRUNCATE DOWN	from 0x7da5f to 0x5ae17	******WWWW
6211735(151 mod 256): DEDUPE 0x28000 thru 0x29fff	(0x2000 bytes) to 0x3f000 thru 0x40fff
6211736(152 mod 256): COLLAPSE 0x3e000 thru 0x40fff	(0x3000 bytes)
6211737(153 mod 256): COLLAPSE 0x5000 thru 0xcfff	(0x8000 bytes)
6211738(154 mod 256): INSERT 0x24000 thru 0x29fff	(0x6000 bytes)
6211739(155 mod 256): INSERT 0x18000 thru 0x19fff	(0x2000 bytes)
6211740(156 mod 256): TRUNCATE DOWN	from 0x57e17 to 0x4ba86
6211741(157 mod 256): READ     0x18be6 thru 0x2c784	(0x13b9f bytes)
6211742(158 mod 256): SKIPPED (no operation)
6211743(159 mod 256): SKIPPED (no operation)
6211744(160 mod 256): WRITE    0x826c1 thru 0x927bf	(0x100ff bytes) HOLE	***WWWW
6211745(161 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x3cb19	******WWWW
6211746(162 mod 256): READ     0x11d0a thru 0x12b3f	(0xe36 bytes)
6211747(163 mod 256): READ     0x2dfe1 thru 0x3cb18	(0xeb38 bytes)
6211748(164 mod 256): CLONE 0x2000 thru 0x1dfff	(0x1c000 bytes) to 0x5a000 thru 0x75fff	******JJJJ
6211749(165 mod 256): CLONE 0x2b000 thru 0x2efff	(0x4000 bytes) to 0x8b000 thru 0x8efff
6211750(166 mod 256): COLLAPSE 0x36000 thru 0x48fff	(0x13000 bytes)
6211751(167 mod 256): WRITE    0x45a3 thru 0x1624c	(0x11caa bytes)
6211752(168 mod 256): TRUNCATE DOWN	from 0x7c000 to 0x69c5d	******WWWW
6211753(169 mod 256): CLONE 0xa000 thru 0x12fff	(0x9000 bytes) to 0x63000 thru 0x6bfff
6211754(170 mod 256): TRUNCATE UP	from 0x6c000 to 0x78480	******WWWW
6211755(171 mod 256): MAPWRITE 0x50355 thru 0x5aa61	(0xa70d bytes)
6211756(172 mod 256): SKIPPED (no operation)
6211757(173 mod 256): COLLAPSE 0x18000 thru 0x2ffff	(0x18000 bytes)
6211758(174 mod 256): FALLOC   0x252fa thru 0x31631	(0xc337 bytes) INTERIOR
6211759(175 mod 256): FALLOC   0x128c8 thru 0x2aa61	(0x18199 bytes) INTERIOR
6211760(176 mod 256): MAPWRITE 0x2aafc thru 0x31ee6	(0x73eb bytes)
6211761(177 mod 256): INSERT 0x5f000 thru 0x74fff	(0x16000 bytes)	******IIII
6211762(178 mod 256): CLONE 0x37000 thru 0x43fff	(0xd000 bytes) to 0xd000 thru 0x19fff
6211763(179 mod 256): MAPWRITE 0x71ad7 thru 0x8e700	(0x1cc2a bytes)
6211764(180 mod 256): READ     0x4272e thru 0x5bbd0	(0x194a3 bytes)
6211765(181 mod 256): DEDUPE 0x53000 thru 0x5ffff	(0xd000 bytes) to 0x7f000 thru 0x8bfff
6211766(182 mod 256): TRUNCATE DOWN	from 0x8e701 to 0x5a077	******WWWW
6211767(183 mod 256): COPY 0x3e51 thru 0x4ac5	(0xc75 bytes) to 0x76831 thru 0x774a5
6211768(184 mod 256): CLONE 0x3e000 thru 0x51fff	(0x14000 bytes) to 0x71000 thru 0x84fff
6211769(185 mod 256): PUNCH    0x620d4 thru 0x7f93b	(0x1d868 bytes)	******PPPP
6211770(186 mod 256): INSERT 0x62000 thru 0x6efff	(0xd000 bytes)	******IIII
6211771(187 mod 256): TRUNCATE DOWN	from 0x92000 to 0x91910
6211772(188 mod 256): COLLAPSE 0x66000 thru 0x6ffff	(0xa000 bytes)	******CCCC
6211773(189 mod 256): MAPREAD  0x3fcb9 thru 0x4b3f9	(0xb741 bytes)
6211774(190 mod 256): TRUNCATE DOWN	from 0x87910 to 0x875d4
6211775(191 mod 256): MAPWRITE 0x3c7e5 thru 0x4df48	(0x11764 bytes)
6211776(192 mod 256): SKIPPED (no operation)
6211777(193 mod 256): COPY 0x11465 thru 0x2cabc	(0x1b658 bytes) to 0x33604 thru 0x4ec5b
6211778(194 mod 256): DEDUPE 0x9000 thru 0x10fff	(0x8000 bytes) to 0x1b000 thru 0x22fff
6211779(195 mod 256): PUNCH    0x2e40 thru 0x21377	(0x1e538 bytes)
6211780(196 mod 256): SKIPPED (no operation)
6211781(197 mod 256): INSERT 0xf000 thru 0x19fff	(0xb000 bytes)
6211782(198 mod 256): MAPWRITE 0x21d5e thru 0x358df	(0x13b82 bytes)
6211783(199 mod 256): SKIPPED (no operation)
6211784(200 mod 256): WRITE    0x62acd thru 0x62b61	(0x95 bytes)
6211785(201 mod 256): ZERO     0x6e2f thru 0x174f2	(0x106c4 bytes)
6211786(202 mod 256): WRITE    0x67788 thru 0x796f7	(0x11f70 bytes)	***WWWW
6211787(203 mod 256): MAPREAD  0x8912c thru 0x925d3	(0x94a8 bytes)
6211788(204 mod 256): FALLOC   0x8b1a0 thru 0x927c0	(0x7620 bytes) PAST_EOF
6211789(205 mod 256): WRITE    0x4701 thru 0x12c7a	(0xe57a bytes)
6211790(206 mod 256): MAPREAD  0x88b95 thru 0x925d3	(0x9a3f bytes)
6211791(207 mod 256): DEDUPE 0x3e000 thru 0x57fff	(0x1a000 bytes) to 0x74000 thru 0x8dfff
6211792(208 mod 256): COPY 0x5f1fd thru 0x7a977	(0x1b77b bytes) to 0x10cae thru 0x2c428	EEEE******
6211793(209 mod 256): MAPWRITE 0x4d871 thru 0x549dd	(0x716d bytes)
6211794(210 mod 256): READ     0x869e2 thru 0x925d3	(0xbbf2 bytes)
6211795(211 mod 256): READ     0x32612 thru 0x40d57	(0xe746 bytes)
6211796(212 mod 256): PUNCH    0x3d64e thru 0x4014d	(0x2b00 bytes)
6211797(213 mod 256): TRUNCATE DOWN	from 0x925d4 to 0xefc5	******WWWW
6211798(214 mod 256): TRUNCATE UP	from 0xefc5 to 0x2bbdd
6211799(215 mod 256): TRUNCATE UP	from 0x2bbdd to 0x340fb
6211800(216 mod 256): COPY 0x25414 thru 0x29eb0	(0x4a9d bytes) to 0x2ac76 thru 0x2f712
6211801(217 mod 256): TRUNCATE UP	from 0x340fb to 0x6be83
6211802(218 mod 256): FALLOC   0x53af thru 0x101e8	(0xae39 bytes) INTERIOR
6211803(219 mod 256): WRITE    0x44f9d thru 0x45326	(0x38a bytes)
6211804(220 mod 256): MAPWRITE 0x8aea0 thru 0x927bf	(0x7920 bytes)
6211805(221 mod 256): MAPREAD  0x26fd thru 0x3bce	(0x14d2 bytes)
6211806(222 mod 256): DEDUPE 0x38000 thru 0x41fff	(0xa000 bytes) to 0x13000 thru 0x1cfff
6211807(223 mod 256): SKIPPED (no operation)
6211808(224 mod 256): SKIPPED (no operation)
6211809(225 mod 256): ZERO     0x36f94 thru 0x37fe1	(0x104e bytes)
6211810(226 mod 256): SKIPPED (no operation)
6211811(227 mod 256): ZERO     0x87b0 thru 0x15862	(0xd0b3 bytes)
6211812(228 mod 256): SKIPPED (no operation)
6211813(229 mod 256): FALLOC   0x6ec31 thru 0x81c99	(0x13068 bytes) INTERIOR	******FFFF
6211814(230 mod 256): DEDUPE 0x24000 thru 0x3efff	(0x1b000 bytes) to 0x3000 thru 0x1dfff
6211815(231 mod 256): PUNCH    0x30f6a thru 0x467f9	(0x15890 bytes)
6211816(232 mod 256): ZERO     0x744dc thru 0x81c38	(0xd75d bytes)
6211817(233 mod 256): CLONE 0x43000 thru 0x4dfff	(0xb000 bytes) to 0x53000 thru 0x5dfff
6211818(234 mod 256): READ     0x1923b thru 0x27749	(0xe50f bytes)
6211819(235 mod 256): FALLOC   0x50f38 thru 0x613b3	(0x1047b bytes) INTERIOR
6211820(236 mod 256): COPY 0x2cea4 thru 0x47cb4	(0x1ae11 bytes) to 0x6a557 thru 0x85367	******EEEE
6211821(237 mod 256): SKIPPED (no operation)
6211822(238 mod 256): WRITE    0x32ae9 thru 0x3fac9	(0xcfe1 bytes)
6211823(239 mod 256): PUNCH    0x12dac thru 0x18dce	(0x6023 bytes)
6211824(240 mod 256): WRITE    0x54f1f thru 0x6f577	(0x1a659 bytes)	***WWWW
6211825(241 mod 256): MAPWRITE 0x35216 thru 0x38750	(0x353b bytes)
6211826(242 mod 256): MAPWRITE 0x6d57c thru 0x6e9d8	(0x145d bytes)
6211827(243 mod 256): CLONE 0xa000 thru 0x1efff	(0x15000 bytes) to 0x22000 thru 0x36fff
6211828(244 mod 256): PUNCH    0x37f65 thru 0x47e27	(0xfec3 bytes)
6211829(245 mod 256): ZERO     0x7889a thru 0x927bf	(0x19f26 bytes)
6211830(246 mod 256): DEDUPE 0xe000 thru 0x21fff	(0x14000 bytes) to 0x62000 thru 0x75fff	******BBBB
6211831(247 mod 256): PUNCH    0xb234 thru 0x1f2c2	(0x1408f bytes)
6211832(248 mod 256): MAPREAD  0x315f1 thru 0x48a90	(0x174a0 bytes)
6211833(249 mod 256): ZERO     0xab72 thru 0x11c7e	(0x710d bytes)
6211834(250 mod 256): FALLOC   0x4fba7 thru 0x6eefc	(0x1f355 bytes) INTERIOR
6211835(251 mod 256): FALLOC   0x334aa thru 0x348ea	(0x1440 bytes) INTERIOR
6211836(252 mod 256): WRITE    0x3f609 thru 0x54571	(0x14f69 bytes)
6211837(253 mod 256): MAPWRITE 0x5e92a thru 0x77a70	(0x19147 bytes)	******WWWW
6211838(254 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x25576	******WWWW
6211839(255 mod 256): MAPREAD  0x1b77 thru 0x11e39	(0x102c3 bytes)
6211840(  0 mod 256): READ     0x7ffc thru 0x16ee1	(0xeee6 bytes)
6211841(  1 mod 256): MAPWRITE 0x8d50f thru 0x927bf	(0x52b1 bytes)
6211842(  2 mod 256): FALLOC   0x88361 thru 0x927c0	(0xa45f bytes) INTERIOR
6211843(  3 mod 256): MAPWRITE 0x44ccc thru 0x48432	(0x3767 bytes)
6211844(  4 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x7ad2	******WWWW
6211845(  5 mod 256): MAPREAD  0x261b thru 0x7ad1	(0x54b7 bytes)
6211846(  6 mod 256): ZERO     0x2621d thru 0x372d6	(0x110ba bytes)
6211847(  7 mod 256): CLONE 0x1000 thru 0x6fff	(0x6000 bytes) to 0x6d000 thru 0x72fff	******JJJJ
6211848(  8 mod 256): FALLOC   0x5d015 thru 0x76c06	(0x19bf1 bytes) PAST_EOF	******FFFF
6211849(  9 mod 256): MAPWRITE 0x7fc89 thru 0x81aa8	(0x1e20 bytes)
6211850( 10 mod 256): FALLOC   0x8ecee thru 0x927c0	(0x3ad2 bytes) PAST_EOF
6211851( 11 mod 256): DEDUPE 0x79000 thru 0x80fff	(0x8000 bytes) to 0x6000 thru 0xdfff
6211852( 12 mod 256): FALLOC   0x67899 thru 0x85bd7	(0x1e33e bytes) PAST_EOF	******FFFF
6211853( 13 mod 256): COLLAPSE 0x5c000 thru 0x74fff	(0x19000 bytes)	******CCCC
6211854( 14 mod 256): READ     0xc577 thru 0x11598	(0x5022 bytes)
6211855( 15 mod 256): MAPREAD  0x174de thru 0x2829c	(0x10dbf bytes)
6211856( 16 mod 256): COLLAPSE 0x16000 thru 0x29fff	(0x14000 bytes)
6211857( 17 mod 256): PUNCH    0x3f320 thru 0x54aa8	(0x15789 bytes)
6211858( 18 mod 256): COPY 0x46a3c thru 0x48c21	(0x21e6 bytes) to 0x76391 thru 0x78576
6211859( 19 mod 256): ZERO     0x8df40 thru 0x927bf	(0x4880 bytes)
6211860( 20 mod 256): ZERO     0x39e3e thru 0x59203	(0x1f3c6 bytes)
6211861( 21 mod 256): SKIPPED (no operation)
6211862( 22 mod 256): CLONE 0x59000 thru 0x6ffff	(0x17000 bytes) to 0x0 thru 0x16fff	JJJJ******
6211863( 23 mod 256): DEDUPE 0x6b000 thru 0x76fff	(0xc000 bytes) to 0x8000 thru 0x13fff	BBBB******
6211864( 24 mod 256): WRITE    0x80624 thru 0x8c045	(0xba22 bytes)
6211865( 25 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x31d37	******WWWW
6211866( 26 mod 256): MAPREAD  0x5a0c thru 0x9c4d	(0x4242 bytes)
6211867( 27 mod 256): COPY 0xf272 thru 0x17f4b	(0x8cda bytes) to 0x6816a thru 0x70e43	******EEEE
6211868( 28 mod 256): FALLOC   0x89c5c thru 0x927c0	(0x8b64 bytes) EXTENDING
6211869( 29 mod 256): SKIPPED (no operation)
6211870( 30 mod 256): SKIPPED (no operation)
6211871( 31 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xbc52	******WWWW
6211872( 32 mod 256): MAPWRITE 0x17edb thru 0x2bc68	(0x13d8e bytes)
6211873( 33 mod 256): INSERT 0xb000 thru 0xefff	(0x4000 bytes)
6211874( 34 mod 256): FALLOC   0x14193 thru 0x2f1ca	(0x1b037 bytes) INTERIOR
6211875( 35 mod 256): CLONE 0x25000 thru 0x2efff	(0xa000 bytes) to 0x7000 thru 0x10fff
6211876( 36 mod 256): CLONE 0x14000 thru 0x1bfff	(0x8000 bytes) to 0x25000 thru 0x2cfff
6211877( 37 mod 256): COPY 0x2a32f thru 0x2fc68	(0x593a bytes) to 0x39521 thru 0x3ee5a
6211878( 38 mod 256): TRUNCATE UP	from 0x3ee5b to 0x42c61
6211879( 39 mod 256): TRUNCATE UP	from 0x42c61 to 0x7ab68	******WWWW
6211880( 40 mod 256): SKIPPED (no operation)
6211881( 41 mod 256): MAPREAD  0x10ad9 thru 0x23fbb	(0x134e3 bytes)
6211882( 42 mod 256): FALLOC   0x29499 thru 0x3568e	(0xc1f5 bytes) INTERIOR
6211883( 43 mod 256): DEDUPE 0x46000 thru 0x4ffff	(0xa000 bytes) to 0x53000 thru 0x5cfff
6211884( 44 mod 256): FALLOC   0x267c1 thru 0x2b336	(0x4b75 bytes) INTERIOR
6211885( 45 mod 256): COPY 0x4d2b7 thru 0x6a804	(0x1d54e bytes) to 0x6ef52 thru 0x8c49f	******EEEE
6211886( 46 mod 256): ZERO     0x33cbe thru 0x37864	(0x3ba7 bytes)
6211887( 47 mod 256): COLLAPSE 0x50000 thru 0x5ffff	(0x10000 bytes)
6211888( 48 mod 256): WRITE    0x6c92b thru 0x7909c	(0xc772 bytes)	***WWWW
6211889( 49 mod 256): ZERO     0x744d6 thru 0x74b0c	(0x637 bytes)
6211890( 50 mod 256): MAPREAD  0x29d8e thru 0x47dd0	(0x1e043 bytes)
6211891( 51 mod 256): PUNCH    0x6ac29 thru 0x7c49f	(0x11877 bytes)	******PPPP
6211892( 52 mod 256): DEDUPE 0x31000 thru 0x4afff	(0x1a000 bytes) to 0x7000 thru 0x20fff
6211893( 53 mod 256): DEDUPE 0x61000 thru 0x65fff	(0x5000 bytes) to 0x72000 thru 0x76fff
6211894( 54 mod 256): INSERT 0x6000 thru 0x1bfff	(0x16000 bytes)
6211895( 55 mod 256): TRUNCATE DOWN	from 0x924a0 to 0x23f78	******WWWW
6211896( 56 mod 256): COLLAPSE 0x1000 thru 0x9fff	(0x9000 bytes)
6211897( 57 mod 256): ZERO     0x3d83a thru 0x3e1a7	(0x96e bytes)
6211898( 58 mod 256): MAPWRITE 0x1915c thru 0x2fc1a	(0x16abf bytes)
6211899( 59 mod 256): MAPWRITE 0x27a0f thru 0x4303b	(0x1b62d bytes)
6211900( 60 mod 256): CLONE 0x23000 thru 0x25fff	(0x3000 bytes) to 0x48000 thru 0x4afff
6211901( 61 mod 256): MAPWRITE 0x913b0 thru 0x927bf	(0x1410 bytes)
6211902( 62 mod 256): READ     0x765ee thru 0x89766	(0x13179 bytes)
6211903( 63 mod 256): READ     0x768be thru 0x77ec1	(0x1604 bytes)
6211904( 64 mod 256): COPY 0x2fd3c thru 0x4ccb9	(0x1cf7e bytes) to 0x5f691 thru 0x7c60e	******EEEE
6211905( 65 mod 256): WRITE    0x77a0e thru 0x81553	(0x9b46 bytes)
6211906( 66 mod 256): MAPWRITE 0xde2 thru 0x93c1	(0x85e0 bytes)
6211907( 67 mod 256): FALLOC   0x6f6e0 thru 0x88bba	(0x194da bytes) INTERIOR
6211908( 68 mod 256): PUNCH    0x3b794 thru 0x47429	(0xbc96 bytes)
6211909( 69 mod 256): DEDUPE 0x70000 thru 0x82fff	(0x13000 bytes) to 0x9000 thru 0x1bfff
6211910( 70 mod 256): DEDUPE 0x47000 thru 0x4bfff	(0x5000 bytes) to 0x40000 thru 0x44fff
6211911( 71 mod 256): CLONE 0x2a000 thru 0x34fff	(0xb000 bytes) to 0x68000 thru 0x72fff	******JJJJ
6211912( 72 mod 256): SKIPPED (no operation)
6211913( 73 mod 256): FALLOC   0x6ab48 thru 0x82c72	(0x1812a bytes) INTERIOR	******FFFF
6211914( 74 mod 256): SKIPPED (no operation)
6211915( 75 mod 256): FALLOC   0x508f1 thru 0x676c2	(0x16dd1 bytes) INTERIOR
6211916( 76 mod 256): WRITE    0x13c9d thru 0x1fb16	(0xbe7a bytes)
6211917( 77 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1f637	******WWWW
6211918( 78 mod 256): SKIPPED (no operation)
6211919( 79 mod 256): MAPREAD  0x28ff thru 0x1b9fe	(0x19100 bytes)
6211920( 80 mod 256): CLONE 0x4000 thru 0xffff	(0xc000 bytes) to 0x78000 thru 0x83fff
6211921( 81 mod 256): INSERT 0x54000 thru 0x61fff	(0xe000 bytes)
6211922( 82 mod 256): WRITE    0x7505f thru 0x91fba	(0x1cf5c bytes)
6211923( 83 mod 256): ZERO     0x220c0 thru 0x2c49b	(0xa3dc bytes)
6211924( 84 mod 256): WRITE    0x2f299 thru 0x40707	(0x1146f bytes)
6211925( 85 mod 256): SKIPPED (no operation)
6211926( 86 mod 256): COLLAPSE 0x34000 thru 0x39fff	(0x6000 bytes)
6211927( 87 mod 256): COLLAPSE 0x9000 thru 0x19fff	(0x11000 bytes)
6211928( 88 mod 256): COLLAPSE 0x35000 thru 0x4cfff	(0x18000 bytes)
6211929( 89 mod 256): MAPREAD  0x5ba0c thru 0x62fff	(0x75f4 bytes)
6211930( 90 mod 256): MAPREAD  0x12ce9 thru 0x228c2	(0xfbda bytes)
6211931( 91 mod 256): COLLAPSE 0x48000 thru 0x61fff	(0x1a000 bytes)
6211932( 92 mod 256): TRUNCATE DOWN	from 0x49000 to 0x23694
6211933( 93 mod 256): COLLAPSE 0x5000 thru 0xdfff	(0x9000 bytes)
6211934( 94 mod 256): MAPWRITE 0x7eb6 thru 0x13531	(0xb67c bytes)
6211935( 95 mod 256): COPY 0x1d5d thru 0x4952	(0x2bf6 bytes) to 0x1e698 thru 0x2128d
6211936( 96 mod 256): FALLOC   0x2a1e8 thru 0x2e8a0	(0x46b8 bytes) PAST_EOF
6211937( 97 mod 256): DEDUPE 0x17000 thru 0x1ffff	(0x9000 bytes) to 0xe000 thru 0x16fff
6211938( 98 mod 256): COLLAPSE 0x1e000 thru 0x1ffff	(0x2000 bytes)
6211939( 99 mod 256): SKIPPED (no operation)
6211940(100 mod 256): FALLOC   0x2b06 thru 0x9ed0	(0x73ca bytes) INTERIOR
6211941(101 mod 256): TRUNCATE UP	from 0x1f28e to 0x32ffe
6211942(102 mod 256): MAPWRITE 0x4e60 thru 0x5d67	(0xf08 bytes)
6211943(103 mod 256): COPY 0x1f199 thru 0x2a08b	(0xaef3 bytes) to 0x5defd thru 0x68def
6211944(104 mod 256): PUNCH    0x2199c thru 0x3a337	(0x1899c bytes)
6211945(105 mod 256): COPY 0x36a5e thru 0x37629	(0xbcc bytes) to 0x27c76 thru 0x28841
6211946(106 mod 256): MAPREAD  0x64913 thru 0x68def	(0x44dd bytes)
6211947(107 mod 256): SKIPPED (no operation)
6211948(108 mod 256): FALLOC   0x84dda thru 0x927c0	(0xd9e6 bytes) PAST_EOF
6211949(109 mod 256): COLLAPSE 0x8000 thru 0x14fff	(0xd000 bytes)
6211950(110 mod 256): COPY 0x937e thru 0x1d161	(0x13de4 bytes) to 0x2c054 thru 0x3fe37
6211951(111 mod 256): DEDUPE 0x35000 thru 0x37fff	(0x3000 bytes) to 0x3a000 thru 0x3cfff
6211952(112 mod 256): MAPREAD  0x39bf6 thru 0x3d39b	(0x37a6 bytes)
6211953(113 mod 256): SKIPPED (no operation)
6211954(114 mod 256): DEDUPE 0x15000 thru 0x2ffff	(0x1b000 bytes) to 0x30000 thru 0x4afff
6211955(115 mod 256): FALLOC   0x5dc6 thru 0x1974c	(0x13986 bytes) INTERIOR
6211956(116 mod 256): READ     0xdedc thru 0xfae1	(0x1c06 bytes)
6211957(117 mod 256): TRUNCATE UP	from 0x5bdf0 to 0x6fed9	******WWWW
6211958(118 mod 256): ZERO     0xb4cb thru 0x27502	(0x1c038 bytes)
6211959(119 mod 256): CLONE 0xd000 thru 0x23fff	(0x17000 bytes) to 0x57000 thru 0x6dfff
6211960(120 mod 256): MAPREAD  0x1b266 thru 0x203b1	(0x514c bytes)
6211961(121 mod 256): MAPWRITE 0x35529 thru 0x4a8d1	(0x153a9 bytes)
6211962(122 mod 256): READ     0x39d09 thru 0x45cea	(0xbfe2 bytes)
6211963(123 mod 256): INSERT 0x54000 thru 0x69fff	(0x16000 bytes)
6211964(124 mod 256): SKIPPED (no operation)
6211965(125 mod 256): DEDUPE 0x66000 thru 0x66fff	(0x1000 bytes) to 0x61000 thru 0x61fff
6211966(126 mod 256): FALLOC   0x69051 thru 0x73c73	(0xac22 bytes) INTERIOR	******FFFF
6211967(127 mod 256): INSERT 0x12000 thru 0x13fff	(0x2000 bytes)
6211968(128 mod 256): PUNCH    0x7925a thru 0x87ed8	(0xec7f bytes)
6211969(129 mod 256): READ     0x65ca1 thru 0x7f767	(0x19ac7 bytes)	***RRRR***
6211970(130 mod 256): MAPWRITE 0x10d92 thru 0x142a4	(0x3513 bytes)
6211971(131 mod 256): FALLOC   0x35456 thru 0x48a4a	(0x135f4 bytes) INTERIOR
6211972(132 mod 256): WRITE    0x4bdd2 thru 0x5c546	(0x10775 bytes)
6211973(133 mod 256): READ     0x7c89d thru 0x8118c	(0x48f0 bytes)
6211974(134 mod 256): PUNCH    0x868e2 thru 0x87ed8	(0x15f7 bytes)
6211975(135 mod 256): FALLOC   0x140ca thru 0x333f1	(0x1f327 bytes) INTERIOR
6211976(136 mod 256): MAPWRITE 0xcc0e thru 0x19651	(0xca44 bytes)
6211977(137 mod 256): CLONE 0x26000 thru 0x2cfff	(0x7000 bytes) to 0xe000 thru 0x14fff
6211978(138 mod 256): SKIPPED (no operation)
6211979(139 mod 256): DEDUPE 0x7b000 thru 0x85fff	(0xb000 bytes) to 0x50000 thru 0x5afff
6211980(140 mod 256): CLONE 0x6f000 thru 0x7ffff	(0x11000 bytes) to 0x35000 thru 0x45fff
6211981(141 mod 256): COPY 0x45fa9 thru 0x47a35	(0x1a8d bytes) to 0x84ad0 thru 0x8655c
6211982(142 mod 256): COPY 0x6a043 thru 0x874e4	(0x1d4a2 bytes) to 0x1dded thru 0x3b28e	EEEE******
6211983(143 mod 256): DEDUPE 0x24000 thru 0x39fff	(0x16000 bytes) to 0x58000 thru 0x6dfff
6211984(144 mod 256): READ     0x4ff7 thru 0x7075	(0x207f bytes)
6211985(145 mod 256): MAPREAD  0xaf02 thru 0x16695	(0xb794 bytes)
6211986(146 mod 256): FALLOC   0x55ef6 thru 0x72c35	(0x1cd3f bytes) INTERIOR	******FFFF
6211987(147 mod 256): CLONE 0x5c000 thru 0x60fff	(0x5000 bytes) to 0x82000 thru 0x86fff
6211988(148 mod 256): INSERT 0x74000 thru 0x76fff	(0x3000 bytes)
6211989(149 mod 256): READ     0x41289 thru 0x45ec8	(0x4c40 bytes)
6211990(150 mod 256): TRUNCATE UP	from 0x8aed9 to 0x90527
6211991(151 mod 256): READ     0x31c99 thru 0x4cc32	(0x1af9a bytes)
6211992(152 mod 256): SKIPPED (no operation)
6211993(153 mod 256): COPY 0x2d4f6 thru 0x4288c	(0x15397 bytes) to 0x6b56c thru 0x80902	******EEEE
6211994(154 mod 256): DEDUPE 0x5f000 thru 0x73fff	(0x15000 bytes) to 0x76000 thru 0x8afff	BBBB******
6211995(155 mod 256): INSERT 0x66000 thru 0x67fff	(0x2000 bytes)
6211996(156 mod 256): DEDUPE 0x71000 thru 0x89fff	(0x19000 bytes) to 0x1b000 thru 0x33fff
6211997(157 mod 256): FALLOC   0x7e36a thru 0x927c0	(0x14456 bytes) PAST_EOF
6211998(158 mod 256): COPY 0x48c28 thru 0x5ed55	(0x1612e bytes) to 0x629f6 thru 0x78b23	******EEEE
6211999(159 mod 256): DEDUPE 0x74000 thru 0x7bfff	(0x8000 bytes) to 0x27000 thru 0x2efff
6212000(160 mod 256): SKIPPED (no operation)
6212001(161 mod 256): MAPWRITE 0x47e5e thru 0x52c30	(0xadd3 bytes)
6212002(162 mod 256): READ     0x2c032 thru 0x382c7	(0xc296 bytes)
6212003(163 mod 256): FALLOC   0x8e012 thru 0x927c0	(0x47ae bytes) PAST_EOF
6212004(164 mod 256): MAPWRITE 0x6e41b thru 0x76c82	(0x8868 bytes)	******WWWW
6212005(165 mod 256): COPY 0x432d9 thru 0x50c05	(0xd92d bytes) to 0x6897a thru 0x762a6	******EEEE
6212006(166 mod 256): WRITE    0x3b081 thru 0x3bf59	(0xed9 bytes)
6212007(167 mod 256): ZERO     0x75e60 thru 0x8c502	(0x166a3 bytes)
6212008(168 mod 256): PUNCH    0x7d79b thru 0x92526	(0x14d8c bytes)
6212009(169 mod 256): CLONE 0x8b000 thru 0x8efff	(0x4000 bytes) to 0x85000 thru 0x88fff
6212010(170 mod 256): CLONE 0x5d000 thru 0x74fff	(0x18000 bytes) to 0x13000 thru 0x2afff	JJJJ******
6212011(171 mod 256): FALLOC   0x39d22 thru 0x506a9	(0x16987 bytes) INTERIOR
6212012(172 mod 256): COLLAPSE 0x50000 thru 0x64fff	(0x15000 bytes)
6212013(173 mod 256): COLLAPSE 0x26000 thru 0x42fff	(0x1d000 bytes)
6212014(174 mod 256): READ     0x17d81 thru 0x27783	(0xfa03 bytes)
6212015(175 mod 256): MAPREAD  0x1dbdf thru 0x2747a	(0x989c bytes)
6212016(176 mod 256): COPY 0x22aa5 thru 0x3bbfb	(0x19157 bytes) to 0xabc thru 0x19c12
6212017(177 mod 256): CLONE 0x4a000 thru 0x5efff	(0x15000 bytes) to 0x1b000 thru 0x2ffff
6212018(178 mod 256): WRITE    0x8dc19 thru 0x927bf	(0x4ba7 bytes) HOLE	***WWWW
6212019(179 mod 256): MAPWRITE 0x8d8d9 thru 0x927bf	(0x4ee7 bytes)
6212020(180 mod 256): MAPREAD  0x539a4 thru 0x64035	(0x10692 bytes)
6212021(181 mod 256): MAPREAD  0x8e42e thru 0x927bf	(0x4392 bytes)
6212022(182 mod 256): FALLOC   0x88bbc thru 0x927c0	(0x9c04 bytes) INTERIOR
6212023(183 mod 256): SKIPPED (no operation)
6212024(184 mod 256): DEDUPE 0x7c000 thru 0x84fff	(0x9000 bytes) to 0x38000 thru 0x40fff
6212025(185 mod 256): ZERO     0x6ab62 thru 0x8142a	(0x168c9 bytes)	******ZZZZ
6212026(186 mod 256): MAPWRITE 0x214e thru 0x97c1	(0x7674 bytes)
6212027(187 mod 256): DEDUPE 0x63000 thru 0x65fff	(0x3000 bytes) to 0x69000 thru 0x6bfff
6212028(188 mod 256): SKIPPED (no operation)
6212029(189 mod 256): PUNCH    0x6b36a thru 0x79439	(0xe0d0 bytes)	******PPPP
6212030(190 mod 256): FALLOC   0x85773 thru 0x86ea1	(0x172e bytes) INTERIOR
6212031(191 mod 256): MAPWRITE 0x7527a thru 0x78094	(0x2e1b bytes)
6212032(192 mod 256): WRITE    0x13313 thru 0x2a3d0	(0x170be bytes)
6212033(193 mod 256): MAPREAD  0x760b5 thru 0x8b7e5	(0x15731 bytes)
6212034(194 mod 256): SKIPPED (no operation)
6212035(195 mod 256): COPY 0x27988 thru 0x41211	(0x1988a bytes) to 0x5bff3 thru 0x7587c	******EEEE
6212036(196 mod 256): COLLAPSE 0x30000 thru 0x39fff	(0xa000 bytes)
6212037(197 mod 256): ZERO     0xc873 thru 0x15b83	(0x9311 bytes)
6212038(198 mod 256): INSERT 0x1000 thru 0x4fff	(0x4000 bytes)
6212039(199 mod 256): COPY 0xe547 thru 0x2c749	(0x1e203 bytes) to 0x69ccc thru 0x87ece	******EEEE
6212040(200 mod 256): PUNCH    0x18ee thru 0x20325	(0x1ea38 bytes)
6212041(201 mod 256): WRITE    0x2a6d7 thru 0x3b909	(0x11233 bytes)
6212042(202 mod 256): COPY 0x4b496 thru 0x4fd01	(0x486c bytes) to 0x81509 thru 0x85d74
6212043(203 mod 256): COPY 0x10821 thru 0x10ee9	(0x6c9 bytes) to 0xef0 thru 0x15b8
6212044(204 mod 256): MAPWRITE 0x6804f thru 0x6efc1	(0x6f73 bytes)
6212045(205 mod 256): COPY 0x562e7 thru 0x6a979	(0x14693 bytes) to 0x29ba6 thru 0x3e238
6212046(206 mod 256): PUNCH    0x5fd1f thru 0x6b877	(0xbb59 bytes)
6212047(207 mod 256): INSERT 0x3b000 thru 0x40fff	(0x6000 bytes)
6212048(208 mod 256): MAPREAD  0x783d8 thru 0x927bf	(0x1a3e8 bytes)
6212049(209 mod 256): ZERO     0x69fbb thru 0x6bd72	(0x1db8 bytes)
6212050(210 mod 256): SKIPPED (no operation)
6212051(211 mod 256): ZERO     0x15c1 thru 0x1af4d	(0x1998d bytes)
6212052(212 mod 256): SKIPPED (no operation)
6212053(213 mod 256): SKIPPED (no operation)
6212054(214 mod 256): COLLAPSE 0x1f000 thru 0x2dfff	(0xf000 bytes)
6212055(215 mod 256): MAPWRITE 0xde15 thru 0x1b5e7	(0xd7d3 bytes)
6212056(216 mod 256): READ     0x690ac thru 0x77093	(0xdfe8 bytes)	***RRRR***
6212057(217 mod 256): ZERO     0x7b62a thru 0x90e98	(0x1586f bytes)
6212058(218 mod 256): FALLOC   0x2d647 thru 0x4b56e	(0x1df27 bytes) INTERIOR
6212059(219 mod 256): TRUNCATE DOWN	from 0x837c0 to 0x58c78	******WWWW
6212060(220 mod 256): MAPWRITE 0x6efc3 thru 0x73a03	(0x4a41 bytes)	******WWWW
6212061(221 mod 256): MAPREAD  0x1e3ae thru 0x3c364	(0x1dfb7 bytes)
6212062(222 mod 256): COLLAPSE 0x65000 thru 0x72fff	(0xe000 bytes)	******CCCC
6212063(223 mod 256): INSERT 0x45000 thru 0x5bfff	(0x17000 bytes)
6212064(224 mod 256): SKIPPED (no operation)
6212065(225 mod 256): DEDUPE 0x5d000 thru 0x70fff	(0x14000 bytes) to 0x11000 thru 0x24fff	BBBB******
6212066(226 mod 256): FALLOC   0x57b72 thru 0x626ad	(0xab3b bytes) INTERIOR
6212067(227 mod 256): COLLAPSE 0x10000 thru 0x19fff	(0xa000 bytes)
6212068(228 mod 256): MAPWRITE 0x84f4e thru 0x927bf	(0xd872 bytes)
6212069(229 mod 256): PUNCH    0x91870 thru 0x927bf	(0xf50 bytes)
6212070(230 mod 256): READ     0x68cc3 thru 0x8310f	(0x1a44d bytes)	***RRRR***
6212071(231 mod 256): CLONE 0x61000 thru 0x7afff	(0x1a000 bytes) to 0x37000 thru 0x50fff	JJJJ******
6212072(232 mod 256): READ     0x8a99a thru 0x8d57e	(0x2be5 bytes)
6212073(233 mod 256): SKIPPED (no operation)
6212074(234 mod 256): SKIPPED (no operation)
6212075(235 mod 256): READ     0x7eab1 thru 0x8bbe3	(0xd133 bytes)
6212076(236 mod 256): ZERO     0x261 thru 0x14578	(0x14318 bytes)
6212077(237 mod 256): CLONE 0x2a000 thru 0x3cfff	(0x13000 bytes) to 0x62000 thru 0x74fff	******JJJJ
6212078(238 mod 256): COPY 0x2810a thru 0x3edda	(0x16cd1 bytes) to 0x5bb3b thru 0x7280b	******EEEE
6212079(239 mod 256): COLLAPSE 0x54000 thru 0x6cfff	(0x19000 bytes)
6212080(240 mod 256): MAPREAD  0x1b0e thru 0xc49e	(0xa991 bytes)
6212081(241 mod 256): DEDUPE 0x17000 thru 0x1efff	(0x8000 bytes) to 0x57000 thru 0x5efff
6212082(242 mod 256): TRUNCATE UP	from 0x797c0 to 0x82d53
6212083(243 mod 256): COLLAPSE 0x42000 thru 0x4ffff	(0xe000 bytes)
6212084(244 mod 256): WRITE    0x77079 thru 0x84055	(0xcfdd bytes) HOLE
6212085(245 mod 256): WRITE    0x1fadc thru 0x23031	(0x3556 bytes)
6212086(246 mod 256): MAPREAD  0x5a432 thru 0x6d77e	(0x1334d bytes)
6212087(247 mod 256): TRUNCATE DOWN	from 0x84056 to 0x90	******WWWW
6212088(248 mod 256): ZERO     0x41de0 thru 0x57adf	(0x15d00 bytes)
6212089(249 mod 256): SKIPPED (no operation)
6212090(250 mod 256): COPY 0x1d thru 0x8f	(0x73 bytes) to 0x25706 thru 0x25778
6212091(251 mod 256): PUNCH    0x19962 thru 0x25778	(0xbe17 bytes)
6212092(252 mod 256): MAPWRITE 0x1e5d7 thru 0x29a4e	(0xb478 bytes)
6212093(253 mod 256): CLONE 0x1f000 thru 0x28fff	(0xa000 bytes) to 0x41000 thru 0x4afff
6212094(254 mod 256): INSERT 0x2a000 thru 0x3cfff	(0x13000 bytes)
6212095(255 mod 256): COPY 0x3bf72 thru 0x58933	(0x1c9c2 bytes) to 0x611ef thru 0x7dbb0	******EEEE
6212096(  0 mod 256): COPY 0x4803e thru 0x4af5a	(0x2f1d bytes) to 0x2b25c thru 0x2e178
6212097(  1 mod 256): MAPWRITE 0x8627e thru 0x927bf	(0xc542 bytes)
6212098(  2 mod 256): CLONE 0x12000 thru 0x29fff	(0x18000 bytes) to 0x49000 thru 0x60fff
6212099(  3 mod 256): SKIPPED (no operation)
6212100(  4 mod 256): SKIPPED (no operation)
6212101(  5 mod 256): READ     0x3b2a2 thru 0x3d2da	(0x2039 bytes)
6212102(  6 mod 256): FALLOC   0xeb68 thru 0x1042a	(0x18c2 bytes) INTERIOR
6212103(  7 mod 256): WRITE    0x67368 thru 0x76ad6	(0xf76f bytes)	***WWWW
6212104(  8 mod 256): CLONE 0x2b000 thru 0x43fff	(0x19000 bytes) to 0x4e000 thru 0x66fff
6212105(  9 mod 256): ZERO     0x4c12 thru 0x18602	(0x139f1 bytes)
6212106( 10 mod 256): WRITE    0x70b8e thru 0x8e663	(0x1dad6 bytes)
6212107( 11 mod 256): READ     0x7e52c thru 0x927bf	(0x14294 bytes)
6212108( 12 mod 256): SKIPPED (no operation)
6212109( 13 mod 256): MAPWRITE 0x71a15 thru 0x81eff	(0x104eb bytes)
6212110( 14 mod 256): CLONE 0x1f000 thru 0x1ffff	(0x1000 bytes) to 0x42000 thru 0x42fff
6212111( 15 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x6559d	******WWWW
6212112( 16 mod 256): FALLOC   0x8c71e thru 0x927c0	(0x60a2 bytes) EXTENDING
6212113( 17 mod 256): READ     0x3e0f4 thru 0x46f73	(0x8e80 bytes)
6212114( 18 mod 256): COPY 0x57505 thru 0x587bb	(0x12b7 bytes) to 0xc7a thru 0x1f30
6212115( 19 mod 256): CLONE 0x78000 thru 0x85fff	(0xe000 bytes) to 0x10000 thru 0x1dfff
6212116( 20 mod 256): COPY 0x2746a thru 0x2e3a1	(0x6f38 bytes) to 0xf660 thru 0x16597
6212117( 21 mod 256): CLONE 0x63000 thru 0x81fff	(0x1f000 bytes) to 0x20000 thru 0x3efff	JJJJ******
6212118( 22 mod 256): CLONE 0x49000 thru 0x5dfff	(0x15000 bytes) to 0x2b000 thru 0x3ffff
6212119( 23 mod 256): PUNCH    0x28161 thru 0x3274a	(0xa5ea bytes)
6212120( 24 mod 256): SKIPPED (no operation)
6212121( 25 mod 256): ZERO     0x7e115 thru 0x8aae6	(0xc9d2 bytes)
6212122( 26 mod 256): SKIPPED (no operation)
6212123( 27 mod 256): COLLAPSE 0x37000 thru 0x49fff	(0x13000 bytes)
6212124( 28 mod 256): PUNCH    0x233a6 thru 0x37291	(0x13eec bytes)
6212125( 29 mod 256): CLONE 0x27000 thru 0x38fff	(0x12000 bytes) to 0x69000 thru 0x7afff	******JJJJ
6212126( 30 mod 256): WRITE    0x54c99 thru 0x55c19	(0xf81 bytes)
6212127( 31 mod 256): INSERT 0xd000 thru 0x17fff	(0xb000 bytes)
6212128( 32 mod 256): FALLOC   0x8224f thru 0x91853	(0xf604 bytes) PAST_EOF
6212129( 33 mod 256): TRUNCATE DOWN	from 0x8a7c0 to 0x7b183
6212130( 34 mod 256): INSERT 0x4c000 thru 0x55fff	(0xa000 bytes)
6212131( 35 mod 256): MAPREAD  0x4b938 thru 0x5109e	(0x5767 bytes)
6212132( 36 mod 256): WRITE    0xa07b thru 0x14371	(0xa2f7 bytes)
6212133( 37 mod 256): FALLOC   0x4a90f thru 0x68e37	(0x1e528 bytes) INTERIOR
6212134( 38 mod 256): COPY 0x4a66f thru 0x4d462	(0x2df4 bytes) to 0x42ef2 thru 0x45ce5
6212135( 39 mod 256): READ     0x71d7b thru 0x7f778	(0xd9fe bytes)
6212136( 40 mod 256): CLONE 0x14000 thru 0x1afff	(0x7000 bytes) to 0x7a000 thru 0x80fff
6212137( 41 mod 256): MAPREAD  0xab7c thru 0x10ee4	(0x6369 bytes)
6212138( 42 mod 256): DEDUPE 0x7b000 thru 0x83fff	(0x9000 bytes) to 0xe000 thru 0x16fff
6212139( 43 mod 256): COLLAPSE 0x5000 thru 0x1bfff	(0x17000 bytes)
6212140( 44 mod 256): COLLAPSE 0xf000 thru 0x28fff	(0x1a000 bytes)
6212141( 45 mod 256): COLLAPSE 0xe000 thru 0x29fff	(0x1c000 bytes)
6212142( 46 mod 256): PUNCH    0x2f7a2 thru 0x38182	(0x89e1 bytes)
6212143( 47 mod 256): COLLAPSE 0x28000 thru 0x29fff	(0x2000 bytes)
6212144( 48 mod 256): TRUNCATE UP	from 0x36183 to 0x6dd35
6212145( 49 mod 256): PUNCH    0x30695 thru 0x40607	(0xff73 bytes)
6212146( 50 mod 256): FALLOC   0x6e353 thru 0x7a3ba	(0xc067 bytes) EXTENDING	******FFFF
6212147( 51 mod 256): MAPREAD  0x12d7a thru 0x2401b	(0x112a2 bytes)
6212148( 52 mod 256): COLLAPSE 0x20000 thru 0x20fff	(0x1000 bytes)
6212149( 53 mod 256): CLONE 0xc000 thru 0x2afff	(0x1f000 bytes) to 0x52000 thru 0x70fff	******JJJJ
6212150( 54 mod 256): WRITE    0x5e7df thru 0x7d577	(0x1ed99 bytes) EXTEND	***WWWW
6212151( 55 mod 256): INSERT 0x1a000 thru 0x22fff	(0x9000 bytes)
6212152( 56 mod 256): PUNCH    0x1e6de thru 0x2d098	(0xe9bb bytes)
6212153( 57 mod 256): INSERT 0x85000 thru 0x90fff	(0xc000 bytes)
6212154( 58 mod 256): ZERO     0x857dd thru 0x8787c	(0x20a0 bytes)
6212155( 59 mod 256): TRUNCATE DOWN	from 0x92578 to 0x29983	******WWWW
6212156( 60 mod 256): ZERO     0x8eeab thru 0x927bf	(0x3915 bytes)
6212157( 61 mod 256): CLONE 0x1f000 thru 0x34fff	(0x16000 bytes) to 0x2000 thru 0x17fff
6212158( 62 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x15f6a	******WWWW
6212159( 63 mod 256): MAPREAD  0x71ff thru 0x105de	(0x93e0 bytes)
6212160( 64 mod 256): MAPWRITE 0x17c6c thru 0x19364	(0x16f9 bytes)
6212161( 65 mod 256): COLLAPSE 0xb000 thru 0x17fff	(0xd000 bytes)
6212162( 66 mod 256): PUNCH    0x89d9 thru 0xc364	(0x398c bytes)
6212163( 67 mod 256): INSERT 0x7000 thru 0x23fff	(0x1d000 bytes)
6212164( 68 mod 256): INSERT 0x24000 thru 0x40fff	(0x1d000 bytes)
6212165( 69 mod 256): ZERO     0x926f5 thru 0x927bf	(0xcb bytes)
6212166( 70 mod 256): READ     0x1b536 thru 0x35cd4	(0x1a79f bytes)
6212167( 71 mod 256): COLLAPSE 0x6d000 thru 0x6efff	(0x2000 bytes)	******CCCC
6212168( 72 mod 256): CLONE 0x87000 thru 0x8cfff	(0x6000 bytes) to 0x6d000 thru 0x72fff	******JJJJ
6212169( 73 mod 256): COLLAPSE 0x3d000 thru 0x59fff	(0x1d000 bytes)
6212170( 74 mod 256): TRUNCATE UP	from 0x737c0 to 0x8aad9
6212171( 75 mod 256): PUNCH    0x934f thru 0x1f84c	(0x164fe bytes)
6212172( 76 mod 256): MAPREAD  0x7a653 thru 0x8aad8	(0x10486 bytes)
6212173( 77 mod 256): ZERO     0x85f3 thru 0xfa2a	(0x7438 bytes)
6212174( 78 mod 256): SKIPPED (no operation)
6212175( 79 mod 256): SKIPPED (no operation)
6212176( 80 mod 256): COLLAPSE 0x5d000 thru 0x78fff	(0x1c000 bytes)	******CCCC
6212177( 81 mod 256): WRITE    0x6d61b thru 0x86289	(0x18c6f bytes) EXTEND	***WWWW
6212178( 82 mod 256): WRITE    0x5a1f7 thru 0x76900	(0x1c70a bytes)	***WWWW
6212179( 83 mod 256): MAPREAD  0x190bd thru 0x36f80	(0x1dec4 bytes)
6212180( 84 mod 256): COPY 0xde9a thru 0x24e08	(0x16f6f bytes) to 0x76ac6 thru 0x8da34
6212181( 85 mod 256): SKIPPED (no operation)
6212182( 86 mod 256): MAPWRITE 0x31880 thru 0x4c022	(0x1a7a3 bytes)
6212183( 87 mod 256): INSERT 0x2c000 thru 0x2ffff	(0x4000 bytes)
6212184( 88 mod 256): DEDUPE 0x2a000 thru 0x42fff	(0x19000 bytes) to 0x44000 thru 0x5cfff
6212185( 89 mod 256): READ     0x7b675 thru 0x91a34	(0x163c0 bytes)
6212186( 90 mod 256): ZERO     0x260d6 thru 0x3d9e2	(0x1790d bytes)
6212187( 91 mod 256): READ     0x88aa thru 0x9d92	(0x14e9 bytes)
6212188( 92 mod 256): MAPREAD  0x21d58 thru 0x3bd5c	(0x1a005 bytes)
6212189( 93 mod 256): TRUNCATE DOWN	from 0x91a35 to 0x82c95
6212190( 94 mod 256): PUNCH    0x175b5 thru 0x2e1d0	(0x16c1c bytes)
6212191( 95 mod 256): TRUNCATE DOWN	from 0x82c95 to 0x47da2	******WWWW
6212192( 96 mod 256): CLONE 0x46000 thru 0x46fff	(0x1000 bytes) to 0x88000 thru 0x88fff
6212193( 97 mod 256): WRITE    0x2e26d thru 0x40c81	(0x12a15 bytes)
6212194( 98 mod 256): COPY 0xd26d thru 0x18591	(0xb325 bytes) to 0x2cadb thru 0x37dff
6212195( 99 mod 256): CLONE 0x6e000 thru 0x87fff	(0x1a000 bytes) to 0x25000 thru 0x3efff	JJJJ******
6212196(100 mod 256): READ     0x86cbb thru 0x88fff	(0x2345 bytes)
6212197(101 mod 256): READ     0xdf93 thru 0x2ba5e	(0x1dacc bytes)
6212198(102 mod 256): SKIPPED (no operation)
6212199(103 mod 256): FALLOC   0x8cc34 thru 0x927c0	(0x5b8c bytes) EXTENDING
6212200(104 mod 256): ZERO     0x6b44f thru 0x7975b	(0xe30d bytes)	******ZZZZ
6212201(105 mod 256): SKIPPED (no operation)
6212202(106 mod 256): ZERO     0x7bb2f thru 0x850c7	(0x9599 bytes)
6212203(107 mod 256): DEDUPE 0x86000 thru 0x91fff	(0xc000 bytes) to 0x3c000 thru 0x47fff
6212204(108 mod 256): READ     0x2df37 thru 0x43a8d	(0x15b57 bytes)
6212205(109 mod 256): PUNCH    0xb55c thru 0x14bfc	(0x96a1 bytes)
6212206(110 mod 256): PUNCH    0x25b49 thru 0x4418f	(0x1e647 bytes)
6212207(111 mod 256): READ     0x2d202 thru 0x33c64	(0x6a63 bytes)
6212208(112 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xef6	******WWWW
6212209(113 mod 256): COPY 0x5b5 thru 0xef5	(0x941 bytes) to 0x5fd90 thru 0x606d0
6212210(114 mod 256): COPY 0x4a30e thru 0x4b6ce	(0x13c1 bytes) to 0x1567f thru 0x16a3f
6212211(115 mod 256): DEDUPE 0x1e000 thru 0x32fff	(0x15000 bytes) to 0x40000 thru 0x54fff
6212212(116 mod 256): WRITE    0x10df7 thru 0x26cc0	(0x15eca bytes)
6212213(117 mod 256): MAPWRITE 0x1e065 thru 0x323d3	(0x1436f bytes)
6212214(118 mod 256): DEDUPE 0x53000 thru 0x5efff	(0xc000 bytes) to 0x19000 thru 0x24fff
6212215(119 mod 256): MAPREAD  0x2201a thru 0x37ec0	(0x15ea7 bytes)
6212216(120 mod 256): MAPWRITE 0x56a40 thru 0x72f06	(0x1c4c7 bytes)	******WWWW
6212217(121 mod 256): SKIPPED (no operation)
6212218(122 mod 256): COPY 0x6518d thru 0x72f06	(0xdd7a bytes) to 0x342de thru 0x42057	EEEE******
6212219(123 mod 256): READ     0x26031 thru 0x439ec	(0x1d9bc bytes)
6212220(124 mod 256): ZERO     0x50b82 thru 0x581ca	(0x7649 bytes)
6212221(125 mod 256): COPY 0x4c97b thru 0x5000d	(0x3693 bytes) to 0x8694e thru 0x89fe0
6212222(126 mod 256): COLLAPSE 0x46000 thru 0x59fff	(0x14000 bytes)
6212223(127 mod 256): SKIPPED (no operation)
6212224(128 mod 256): MAPREAD  0x26a83 thru 0x35361	(0xe8df bytes)
6212225(129 mod 256): COPY 0x5adde thru 0x676fb	(0xc91e bytes) to 0x3d21a thru 0x49b37
6212226(130 mod 256): INSERT 0x3b000 thru 0x50fff	(0x16000 bytes)
6212227(131 mod 256): READ     0x17d59 thru 0x2aa25	(0x12ccd bytes)
6212228(132 mod 256): INSERT 0x6c000 thru 0x6cfff	(0x1000 bytes)
6212229(133 mod 256): INSERT 0x55000 thru 0x59fff	(0x5000 bytes)
6212230(134 mod 256): COPY 0x40f68 thru 0x42caf	(0x1d48 bytes) to 0x8dad5 thru 0x8f81c
6212231(135 mod 256): CLONE 0x59000 thru 0x6cfff	(0x14000 bytes) to 0x1d000 thru 0x30fff
6212232(136 mod 256): ZERO     0x5af67 thru 0x79611	(0x1e6ab bytes)	******ZZZZ
6212233(137 mod 256): MAPWRITE 0x62185 thru 0x6a73e	(0x85ba bytes)
6212234(138 mod 256): MAPREAD  0x8f5b8 thru 0x91fe0	(0x2a29 bytes)
6212235(139 mod 256): ZERO     0x7c10f thru 0x868e5	(0xa7d7 bytes)
6212236(140 mod 256): ZERO     0x19501 thru 0x29ee3	(0x109e3 bytes)
6212237(141 mod 256): ZERO     0x6097c thru 0x698d1	(0x8f56 bytes)
6212238(142 mod 256): ZERO     0x66828 thru 0x6a55d	(0x3d36 bytes)
6212239(143 mod 256): PUNCH    0x6697e thru 0x70c03	(0xa286 bytes)	******PPPP
6212240(144 mod 256): DEDUPE 0x68000 thru 0x73fff	(0xc000 bytes) to 0x74000 thru 0x7ffff	BBBB******
6212241(145 mod 256): DEDUPE 0x59000 thru 0x72fff	(0x1a000 bytes) to 0x2e000 thru 0x47fff	BBBB******
6212242(146 mod 256): MAPREAD  0x5f497 thru 0x7ce66	(0x1d9d0 bytes)	***RRRR***
6212243(147 mod 256): SKIPPED (no operation)
6212244(148 mod 256): COPY 0x42fde thru 0x53c6d	(0x10c90 bytes) to 0x70ecb thru 0x81b5a
6212245(149 mod 256): COPY 0x5eb49 thru 0x76329	(0x177e1 bytes) to 0x37599 thru 0x4ed79	EEEE******
6212246(150 mod 256): DEDUPE 0x10000 thru 0x1bfff	(0xc000 bytes) to 0x71000 thru 0x7cfff
6212247(151 mod 256): WRITE    0x3d8de thru 0x51a82	(0x141a5 bytes)
6212248(152 mod 256): COPY 0x5c486 thru 0x77788	(0x1b303 bytes) to 0x9c4a thru 0x24f4c	EEEE******
6212249(153 mod 256): DEDUPE 0x30000 thru 0x41fff	(0x12000 bytes) to 0x17000 thru 0x28fff
6212250(154 mod 256): SKIPPED (no operation)
6212251(155 mod 256): WRITE    0x629c6 thru 0x6c437	(0x9a72 bytes)
6212252(156 mod 256): ZERO     0x3efa0 thru 0x41ee7	(0x2f48 bytes)
6212253(157 mod 256): FALLOC   0x27371 thru 0x436a1	(0x1c330 bytes) INTERIOR
6212254(158 mod 256): MAPREAD  0x8203 thru 0x26978	(0x1e776 bytes)
6212255(159 mod 256): MAPREAD  0x7e652 thru 0x80131	(0x1ae0 bytes)
6212256(160 mod 256): FALLOC   0x51575 thru 0x516e5	(0x170 bytes) INTERIOR
6212257(161 mod 256): COLLAPSE 0x6a000 thru 0x87fff	(0x1e000 bytes)	******CCCC
6212258(162 mod 256): DEDUPE 0x8000 thru 0x16fff	(0xf000 bytes) to 0x3e000 thru 0x4cfff
6212259(163 mod 256): SKIPPED (no operation)
6212260(164 mod 256): ZERO     0x3ebcc thru 0x4ef26	(0x1035b bytes)
6212261(165 mod 256): ZERO     0x4a53e thru 0x4cfdc	(0x2a9f bytes)
6212262(166 mod 256): INSERT 0x44000 thru 0x49fff	(0x6000 bytes)
6212263(167 mod 256): DEDUPE 0x0 thru 0xfff	(0x1000 bytes) to 0x55000 thru 0x55fff
6212264(168 mod 256): TRUNCATE DOWN	from 0x79fe1 to 0x129a3	******WWWW
6212265(169 mod 256): FALLOC   0x8337 thru 0x20661	(0x1832a bytes) EXTENDING
6212266(170 mod 256): PUNCH    0xcca3 thru 0x20660	(0x139be bytes)
6212267(171 mod 256): FALLOC   0x8ca89 thru 0x927c0	(0x5d37 bytes) EXTENDING
6212268(172 mod 256): FALLOC   0x173a8 thru 0x1c65e	(0x52b6 bytes) INTERIOR
6212269(173 mod 256): DEDUPE 0x41000 thru 0x47fff	(0x7000 bytes) to 0xf000 thru 0x15fff
6212270(174 mod 256): DEDUPE 0x39000 thru 0x56fff	(0x1e000 bytes) to 0x3000 thru 0x20fff
6212271(175 mod 256): ZERO     0xe33c thru 0x19ea7	(0xbb6c bytes)
6212272(176 mod 256): MAPWRITE 0xdd4 thru 0x15532	(0x1475f bytes)
6212273(177 mod 256): FALLOC   0x5a988 thru 0x695b2	(0xec2a bytes) INTERIOR
6212274(178 mod 256): READ     0x7a48e thru 0x88396	(0xdf09 bytes)
6212275(179 mod 256): ZERO     0x3da29 thru 0x3ea88	(0x1060 bytes)
6212276(180 mod 256): MAPWRITE 0x86be thru 0x1634f	(0xdc92 bytes)
6212277(181 mod 256): FALLOC   0x2b765 thru 0x48861	(0x1d0fc bytes) INTERIOR
6212278(182 mod 256): MAPWRITE 0x40101 thru 0x5ec46	(0x1eb46 bytes)
6212279(183 mod 256): FALLOC   0x2bad5 thru 0x2e393	(0x28be bytes) INTERIOR
6212280(184 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x6074d	******WWWW
6212281(185 mod 256): PUNCH    0x35121 thru 0x48fef	(0x13ecf bytes)
6212282(186 mod 256): PUNCH    0x14c4a thru 0x2ef42	(0x1a2f9 bytes)
6212283(187 mod 256): COPY 0x52406 thru 0x6074c	(0xe347 bytes) to 0x65f2 thru 0x14938
6212284(188 mod 256): DEDUPE 0x36000 thru 0x4cfff	(0x17000 bytes) to 0x18000 thru 0x2efff
6212285(189 mod 256): READ     0x34ec0 thru 0x47ebb	(0x12ffc bytes)
6212286(190 mod 256): SKIPPED (no operation)
6212287(191 mod 256): MAPREAD  0x3a86b thru 0x5462d	(0x19dc3 bytes)
6212288(192 mod 256): DEDUPE 0x3d000 thru 0x59fff	(0x1d000 bytes) to 0x1c000 thru 0x38fff
6212289(193 mod 256): CLONE 0x38000 thru 0x38fff	(0x1000 bytes) to 0x20000 thru 0x20fff
6212290(194 mod 256): SKIPPED (no operation)
6212291(195 mod 256): FALLOC   0x7df0d thru 0x85f5b	(0x804e bytes) EXTENDING
6212292(196 mod 256): MAPREAD  0x21c thru 0x1adb4	(0x1ab99 bytes)
6212293(197 mod 256): MAPREAD  0x64f27 thru 0x7ac9a	(0x15d74 bytes)	***RRRR***
6212294(198 mod 256): MAPWRITE 0x1c936 thru 0x24164	(0x782f bytes)
6212295(199 mod 256): INSERT 0x32000 thru 0x3dfff	(0xc000 bytes)
6212296(200 mod 256): READ     0x2ce9b thru 0x37db7	(0xaf1d bytes)
6212297(201 mod 256): ZERO     0x214ea thru 0x233f3	(0x1f0a bytes)
6212298(202 mod 256): TRUNCATE DOWN	from 0x91f5b to 0x5519c	******WWWW
6212299(203 mod 256): ZERO     0x4db7e thru 0x5710d	(0x9590 bytes)
6212300(204 mod 256): READ     0x43ce7 thru 0x51965	(0xdc7f bytes)
6212301(205 mod 256): DEDUPE 0x2e000 thru 0x2ffff	(0x2000 bytes) to 0x8000 thru 0x9fff
6212302(206 mod 256): COLLAPSE 0xd000 thru 0x1afff	(0xe000 bytes)
6212303(207 mod 256): PUNCH    0x1d2e6 thru 0x1e9e5	(0x1700 bytes)
6212304(208 mod 256): PUNCH    0x21aa2 thru 0x2579e	(0x3cfd bytes)
6212305(209 mod 256): CLONE 0x1000 thru 0x5fff	(0x5000 bytes) to 0x3d000 thru 0x41fff
6212306(210 mod 256): WRITE    0x2d06b thru 0x2df71	(0xf07 bytes)
6212307(211 mod 256): FALLOC   0x91a0 thru 0x13e38	(0xac98 bytes) INTERIOR
6212308(212 mod 256): WRITE    0x3ef1b thru 0x47292	(0x8378 bytes) EXTEND
6212309(213 mod 256): DEDUPE 0xa000 thru 0x1cfff	(0x13000 bytes) to 0x33000 thru 0x45fff
6212310(214 mod 256): SKIPPED (no operation)
6212311(215 mod 256): READ     0x80ba thru 0x15ecc	(0xde13 bytes)
6212312(216 mod 256): SKIPPED (no operation)
6212313(217 mod 256): ZERO     0x34106 thru 0x4cbe8	(0x18ae3 bytes)
6212314(218 mod 256): CLONE 0x23000 thru 0x30fff	(0xe000 bytes) to 0x3000 thru 0x10fff
6212315(219 mod 256): TRUNCATE UP	from 0x47293 to 0x7fbb1	******WWWW
6212316(220 mod 256): MAPREAD  0x2091c thru 0x3a02a	(0x1970f bytes)
6212317(221 mod 256): CLONE 0xa000 thru 0x1bfff	(0x12000 bytes) to 0x57000 thru 0x68fff
6212318(222 mod 256): INSERT 0x39000 thru 0x4afff	(0x12000 bytes)
6212319(223 mod 256): CLONE 0x74000 thru 0x7bfff	(0x8000 bytes) to 0x47000 thru 0x4efff
6212320(224 mod 256): READ     0x69091 thru 0x7b06a	(0x11fda bytes)	***RRRR***
6212321(225 mod 256): SKIPPED (no operation)
6212322(226 mod 256): DEDUPE 0x6f000 thru 0x76fff	(0x8000 bytes) to 0x55000 thru 0x5cfff
6212323(227 mod 256): DEDUPE 0x13000 thru 0x13fff	(0x1000 bytes) to 0x3f000 thru 0x3ffff
6212324(228 mod 256): MAPREAD  0x4826e thru 0x60a82	(0x18815 bytes)
6212325(229 mod 256): SKIPPED (no operation)
6212326(230 mod 256): COPY 0x902c6 thru 0x91bb0	(0x18eb bytes) to 0x7be92 thru 0x7d77c
6212327(231 mod 256): SKIPPED (no operation)
6212328(232 mod 256): ZERO     0x207be thru 0x33a4f	(0x13292 bytes)
6212329(233 mod 256): MAPREAD  0x209a thru 0x6ac4	(0x4a2b bytes)
6212330(234 mod 256): TRUNCATE DOWN	from 0x91bb1 to 0x29534	******WWWW
6212331(235 mod 256): TRUNCATE UP	from 0x29534 to 0x3e907
6212332(236 mod 256): FALLOC   0x8bf81 thru 0x927c0	(0x683f bytes) PAST_EOF
6212333(237 mod 256): TRUNCATE UP	from 0x3e907 to 0x4397b
6212334(238 mod 256): SKIPPED (no operation)
6212335(239 mod 256): INSERT 0x7000 thru 0x21fff	(0x1b000 bytes)
6212336(240 mod 256): ZERO     0x27ebc thru 0x29934	(0x1a79 bytes)
6212337(241 mod 256): FALLOC   0x71d2d thru 0x7696b	(0x4c3e bytes) PAST_EOF
6212338(242 mod 256): TRUNCATE DOWN	from 0x5e97b to 0x148b3
6212339(243 mod 256): WRITE    0x97da thru 0x21a3e	(0x18265 bytes) EXTEND
6212340(244 mod 256): FALLOC   0x6eaae thru 0x6ff14	(0x1466 bytes) PAST_EOF	******FFFF
6212341(245 mod 256): INSERT 0x0 thru 0x8fff	(0x9000 bytes)
6212342(246 mod 256): ZERO     0x85669 thru 0x927bf	(0xd157 bytes)
6212343(247 mod 256): COLLAPSE 0x16000 thru 0x1afff	(0x5000 bytes)
6212344(248 mod 256): ZERO     0x2c677 thru 0x320d9	(0x5a63 bytes)
6212345(249 mod 256): TRUNCATE UP	from 0x25a3f to 0x86659	******WWWW
6212346(250 mod 256): COLLAPSE 0x2000 thru 0x1bfff	(0x1a000 bytes)
6212347(251 mod 256): TRUNCATE DOWN	from 0x6c659 to 0x676b4
6212348(252 mod 256): COPY 0x3afde thru 0x446a9	(0x96cc bytes) to 0x61110 thru 0x6a7db
6212349(253 mod 256): TRUNCATE DOWN	from 0x6a7dc to 0x64d66
6212350(254 mod 256): DEDUPE 0xf000 thru 0x21fff	(0x13000 bytes) to 0x2e000 thru 0x40fff
6212351(255 mod 256): DEDUPE 0x1000 thru 0x17fff	(0x17000 bytes) to 0x34000 thru 0x4afff
6212352(  0 mod 256): COLLAPSE 0xf000 thru 0x19fff	(0xb000 bytes)
6212353(  1 mod 256): MAPREAD  0x5618f thru 0x59d65	(0x3bd7 bytes)
6212354(  2 mod 256): DEDUPE 0x13000 thru 0x28fff	(0x16000 bytes) to 0x3f000 thru 0x54fff
6212355(  3 mod 256): TRUNCATE DOWN	from 0x59d66 to 0x27641
6212356(  4 mod 256): SKIPPED (no operation)
6212357(  5 mod 256): COLLAPSE 0xe000 thru 0x1afff	(0xd000 bytes)
6212358(  6 mod 256): PUNCH    0x16dd5 thru 0x1a640	(0x386c bytes)
6212359(  7 mod 256): INSERT 0x15000 thru 0x1efff	(0xa000 bytes)
6212360(  8 mod 256): ZERO     0x2f294 thru 0x3e17e	(0xeeeb bytes)
6212361(  9 mod 256): COPY 0x39490 thru 0x3e17e	(0x4cef bytes) to 0x64617 thru 0x69305
6212362( 10 mod 256): TRUNCATE DOWN	from 0x69306 to 0x2c458
6212363( 11 mod 256): TRUNCATE UP	from 0x2c458 to 0x842dc	******WWWW
6212364( 12 mod 256): COLLAPSE 0x1b000 thru 0x27fff	(0xd000 bytes)
6212365( 13 mod 256): ZERO     0x8bb38 thru 0x927bf	(0x6c88 bytes)
6212366( 14 mod 256): INSERT 0x3c000 thru 0x50fff	(0x15000 bytes)
6212367( 15 mod 256): SKIPPED (no operation)
6212368( 16 mod 256): ZERO     0x10f6 thru 0x41d8	(0x30e3 bytes)
6212369( 17 mod 256): FALLOC   0x19af1 thru 0x2cda5	(0x132b4 bytes) INTERIOR
6212370( 18 mod 256): ZERO     0x1235a thru 0x28d4c	(0x169f3 bytes)
6212371( 19 mod 256): FALLOC   0x4b31d thru 0x626de	(0x173c1 bytes) INTERIOR
6212372( 20 mod 256): COLLAPSE 0x7e000 thru 0x8afff	(0xd000 bytes)
6212373( 21 mod 256): CLONE 0x2b000 thru 0x38fff	(0xe000 bytes) to 0x77000 thru 0x84fff
6212374( 22 mod 256): COLLAPSE 0x7b000 thru 0x83fff	(0x9000 bytes)
6212375( 23 mod 256): READ     0x6133a thru 0x729df	(0x116a6 bytes)	***RRRR***
6212376( 24 mod 256): PUNCH    0x67027 thru 0x7bfff	(0x14fd9 bytes)	******PPPP
6212377( 25 mod 256): DEDUPE 0x4e000 thru 0x68fff	(0x1b000 bytes) to 0x17000 thru 0x31fff
6212378( 26 mod 256): INSERT 0x3a000 thru 0x4ffff	(0x16000 bytes)
6212379( 27 mod 256): MAPWRITE 0x523ad thru 0x5f7d2	(0xd426 bytes)
6212380( 28 mod 256): MAPREAD  0x83533 thru 0x8741a	(0x3ee8 bytes)
6212381( 29 mod 256): CLONE 0x28000 thru 0x36fff	(0xf000 bytes) to 0xf000 thru 0x1dfff
6212382( 30 mod 256): PUNCH    0x3e8e2 thru 0x3fa58	(0x1177 bytes)
6212383( 31 mod 256): ZERO     0x1d480 thru 0x32ab0	(0x15631 bytes)
6212384( 32 mod 256): SKIPPED (no operation)
6212385( 33 mod 256): FALLOC   0xf6de thru 0x2e6f0	(0x1f012 bytes) INTERIOR
6212386( 34 mod 256): COLLAPSE 0x39000 thru 0x54fff	(0x1c000 bytes)
6212387( 35 mod 256): ZERO     0xa634 thru 0x15a93	(0xb460 bytes)
6212388( 36 mod 256): MAPREAD  0x4cb04 thru 0x67021	(0x1a51e bytes)
6212389( 37 mod 256): WRITE    0x53a3f thru 0x59514	(0x5ad6 bytes)
6212390( 38 mod 256): MAPWRITE 0x2ce7f thru 0x36015	(0x9197 bytes)
6212391( 39 mod 256): WRITE    0x402eb thru 0x54877	(0x1458d bytes)
6212392( 40 mod 256): FALLOC   0x2b4d0 thru 0x41a99	(0x165c9 bytes) INTERIOR
6212393( 41 mod 256): WRITE    0x22a4d thru 0x25212	(0x27c6 bytes)
6212394( 42 mod 256): INSERT 0x68000 thru 0x74fff	(0xd000 bytes)	******IIII
6212395( 43 mod 256): READ     0x349eb thru 0x3ec29	(0xa23f bytes)
6212396( 44 mod 256): MAPREAD  0x649f3 thru 0x6f295	(0xa8a3 bytes)	***RRRR***
6212397( 45 mod 256): FALLOC   0xb981 thru 0x1c41c	(0x10a9b bytes) INTERIOR
6212398( 46 mod 256): COLLAPSE 0x1f000 thru 0x26fff	(0x8000 bytes)
6212399( 47 mod 256): PUNCH    0x3a86d thru 0x56432	(0x1bbc6 bytes)
6212400( 48 mod 256): ZERO     0x18afe thru 0x30783	(0x17c86 bytes)
6212401( 49 mod 256): INSERT 0x5e000 thru 0x70fff	(0x13000 bytes)	******IIII
6212402( 50 mod 256): SKIPPED (no operation)
6212403( 51 mod 256): SKIPPED (no operation)
6212404( 52 mod 256): DEDUPE 0x3b000 thru 0x3ffff	(0x5000 bytes) to 0x71000 thru 0x75fff
6212405( 53 mod 256): COPY 0x2d893 thru 0x3b74c	(0xdeba bytes) to 0x78a16 thru 0x868cf
6212406( 54 mod 256): ZERO     0x3123f thru 0x4d240	(0x1c002 bytes)
6212407( 55 mod 256): TRUNCATE DOWN	from 0x8e000 to 0x4d811	******WWWW
6212408( 56 mod 256): COLLAPSE 0x19000 thru 0x2efff	(0x16000 bytes)
6212409( 57 mod 256): INSERT 0x26000 thru 0x30fff	(0xb000 bytes)
6212410( 58 mod 256): SKIPPED (no operation)
6212411( 59 mod 256): COLLAPSE 0x3a000 thru 0x41fff	(0x8000 bytes)
6212412( 60 mod 256): COPY 0xf157 thru 0x25813	(0x166bd bytes) to 0x3de6a thru 0x54526
6212413( 61 mod 256): CLONE 0x9000 thru 0xafff	(0x2000 bytes) to 0x53000 thru 0x54fff
6212414( 62 mod 256): ZERO     0x69487 thru 0x7441f	(0xaf99 bytes)	******ZZZZ
6212415( 63 mod 256): MAPREAD  0x61cc thru 0x1c3ef	(0x16224 bytes)
6212416( 64 mod 256): COPY 0x11035 thru 0x1789e	(0x686a bytes) to 0x83368 thru 0x89bd1
6212417( 65 mod 256): PUNCH    0x11cb0 thru 0x205bf	(0xe910 bytes)
6212418( 66 mod 256): COLLAPSE 0x6d000 thru 0x86fff	(0x1a000 bytes)	******CCCC
6212419( 67 mod 256): FALLOC   0x2b5a3 thru 0x47b6c	(0x1c5c9 bytes) INTERIOR
6212420( 68 mod 256): FALLOC   0x90519 thru 0x927c0	(0x22a7 bytes) PAST_EOF
6212421( 69 mod 256): MAPREAD  0x3865e thru 0x555d4	(0x1cf77 bytes)
6212422( 70 mod 256): SKIPPED (no operation)
6212423( 71 mod 256): WRITE    0x2ad8b thru 0x2be87	(0x10fd bytes)
6212424( 72 mod 256): PUNCH    0x3a3c thru 0xb7b5	(0x7d7a bytes)
6212425( 73 mod 256): WRITE    0x3fb22 thru 0x411cc	(0x16ab bytes)
6212426( 74 mod 256): COPY 0x1cede thru 0x38cd3	(0x1bdf6 bytes) to 0x3f805 thru 0x5b5fa
6212427( 75 mod 256): WRITE    0x80213 thru 0x89a23	(0x9811 bytes) HOLE
6212428( 76 mod 256): MAPREAD  0x72fb4 thru 0x85593	(0x125e0 bytes)
6212429( 77 mod 256): COPY 0x69d16 thru 0x8261c	(0x18907 bytes) to 0x4ed0a thru 0x67610	EEEE******
6212430( 78 mod 256): SKIPPED (no operation)
6212431( 79 mod 256): PUNCH    0x77e02 thru 0x844fc	(0xc6fb bytes)
6212432( 80 mod 256): MAPWRITE 0x4bfd2 thru 0x63e64	(0x17e93 bytes)
6212433( 81 mod 256): DEDUPE 0x7d000 thru 0x82fff	(0x6000 bytes) to 0x36000 thru 0x3bfff
6212434( 82 mod 256): ZERO     0x8c9d8 thru 0x927bf	(0x5de8 bytes)
6212435( 83 mod 256): SKIPPED (no operation)
6212436( 84 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1c147	******WWWW
6212437( 85 mod 256): SKIPPED (no operation)
6212438( 86 mod 256): MAPWRITE 0x76449 thru 0x8b64f	(0x15207 bytes)
6212439( 87 mod 256): READ     0x72782 thru 0x8416c	(0x119eb bytes)
6212440( 88 mod 256): COLLAPSE 0x21000 thru 0x21fff	(0x1000 bytes)
6212441( 89 mod 256): TRUNCATE DOWN	from 0x8a650 to 0x13147	******WWWW
6212442( 90 mod 256): SKIPPED (no operation)
6212443( 91 mod 256): FALLOC   0x5055a thru 0x61066	(0x10b0c bytes) EXTENDING
6212444( 92 mod 256): COPY 0x262a0 thru 0x35b11	(0xf872 bytes) to 0x36072 thru 0x458e3
6212445( 93 mod 256): DEDUPE 0xa000 thru 0x13fff	(0xa000 bytes) to 0x16000 thru 0x1ffff
6212446( 94 mod 256): WRITE    0x685a1 thru 0x72c39	(0xa699 bytes) HOLE	***WWWW
6212447( 95 mod 256): MAPWRITE 0x48763 thru 0x4fbab	(0x7449 bytes)
6212448( 96 mod 256): PUNCH    0x2ac76 thru 0x36999	(0xbd24 bytes)
6212449( 97 mod 256): PUNCH    0x5432b thru 0x57556	(0x322c bytes)
6212450( 98 mod 256): FALLOC   0x2b49b thru 0x3d878	(0x123dd bytes) INTERIOR
6212451( 99 mod 256): ZERO     0x5c4b0 thru 0x72e9d	(0x169ee bytes)	******ZZZZ
6212452(100 mod 256): COPY 0x5f15d thru 0x72c39	(0x13add bytes) to 0x34ef thru 0x16fcb	EEEE******
6212453(101 mod 256): SKIPPED (no operation)
6212454(102 mod 256): CLONE 0x1b000 thru 0x23fff	(0x9000 bytes) to 0x48000 thru 0x50fff
6212455(103 mod 256): WRITE    0x465b3 thru 0x4bc6b	(0x56b9 bytes)
6212456(104 mod 256): READ     0x65c8a thru 0x72c39	(0xcfb0 bytes)	***RRRR***
6212457(105 mod 256): SKIPPED (no operation)
6212458(106 mod 256): FALLOC   0x61fdc thru 0x64a22	(0x2a46 bytes) INTERIOR
6212459(107 mod 256): DEDUPE 0x5f000 thru 0x65fff	(0x7000 bytes) to 0x8000 thru 0xefff
6212460(108 mod 256): PUNCH    0x14983 thru 0x1cb89	(0x8207 bytes)
6212461(109 mod 256): DEDUPE 0x54000 thru 0x6afff	(0x17000 bytes) to 0x19000 thru 0x2ffff
6212462(110 mod 256): COLLAPSE 0x6c000 thru 0x70fff	(0x5000 bytes)	******CCCC
6212463(111 mod 256): DEDUPE 0x63000 thru 0x6bfff	(0x9000 bytes) to 0x7000 thru 0xffff
6212464(112 mod 256): READ     0x1e495 thru 0x27349	(0x8eb5 bytes)
6212465(113 mod 256): MAPWRITE 0x45146 thru 0x5c48c	(0x17347 bytes)
6212466(114 mod 256): MAPREAD  0x2a195 thru 0x31c39	(0x7aa5 bytes)
6212467(115 mod 256): CLONE 0x27000 thru 0x3bfff	(0x15000 bytes) to 0x74000 thru 0x88fff
6212468(116 mod 256): MAPWRITE 0x52fef thru 0x67358	(0x1436a bytes)
6212469(117 mod 256): MAPWRITE 0x482c9 thru 0x674c3	(0x1f1fb bytes)
6212470(118 mod 256): PUNCH    0x35280 thru 0x4f011	(0x19d92 bytes)
6212471(119 mod 256): TRUNCATE DOWN	from 0x89000 to 0x53194	******WWWW
6212472(120 mod 256): INSERT 0x18000 thru 0x19fff	(0x2000 bytes)
6212473(121 mod 256): DEDUPE 0x10000 thru 0x20fff	(0x11000 bytes) to 0x27000 thru 0x37fff
6212474(122 mod 256): INSERT 0x1a000 thru 0x29fff	(0x10000 bytes)
6212475(123 mod 256): TRUNCATE DOWN	from 0x65194 to 0x146fb
6212476(124 mod 256): TRUNCATE UP	from 0x146fb to 0x47299
6212477(125 mod 256): READ     0x15833 thru 0x25270	(0xfa3e bytes)
6212478(126 mod 256): DEDUPE 0x13000 thru 0x18fff	(0x6000 bytes) to 0x1e000 thru 0x23fff
6212479(127 mod 256): COPY 0x7943 thru 0x1f1f9	(0x178b7 bytes) to 0x4f801 thru 0x670b7
6212480(128 mod 256): MAPREAD  0x12fac thru 0x24efa	(0x11f4f bytes)
6212481(129 mod 256): TRUNCATE UP	from 0x670b8 to 0x9032d	******WWWW
6212482(130 mod 256): TRUNCATE DOWN	from 0x9032d to 0x323bc	******WWWW
6212483(131 mod 256): DEDUPE 0x2e000 thru 0x30fff	(0x3000 bytes) to 0x1000 thru 0x3fff
6212484(132 mod 256): READ     0x23823 thru 0x323bb	(0xeb99 bytes)
6212485(133 mod 256): COPY 0x2afa thru 0xae91	(0x8398 bytes) to 0x25498 thru 0x2d82f
6212486(134 mod 256): TRUNCATE DOWN	from 0x323bc to 0x27f84
6212487(135 mod 256): ZERO     0x5582a thru 0x6e49d	(0x18c74 bytes)
6212488(136 mod 256): SKIPPED (no operation)
6212489(137 mod 256): PUNCH    0x436ba thru 0x57cea	(0x14631 bytes)
6212490(138 mod 256): CLONE 0x68000 thru 0x6cfff	(0x5000 bytes) to 0xe000 thru 0x12fff
6212491(139 mod 256): COPY 0x1f1b0 thru 0x320ee	(0x12f3f bytes) to 0x47fe9 thru 0x5af27
6212492(140 mod 256): DEDUPE 0xf000 thru 0x25fff	(0x17000 bytes) to 0x42000 thru 0x58fff
6212493(141 mod 256): COPY 0x27fbc thru 0x29273	(0x12b8 bytes) to 0x7af9f thru 0x7c256
6212494(142 mod 256): WRITE    0xd9bc thru 0x14c91	(0x72d6 bytes)
6212495(143 mod 256): SKIPPED (no operation)
6212496(144 mod 256): SKIPPED (no operation)
6212497(145 mod 256): CLONE 0x4f000 thru 0x6bfff	(0x1d000 bytes) to 0x12000 thru 0x2efff
6212498(146 mod 256): COPY 0x27151 thru 0x31881	(0xa731 bytes) to 0x5d7c6 thru 0x67ef6
6212499(147 mod 256): PUNCH    0x29e7f thru 0x37b23	(0xdca5 bytes)
6212500(148 mod 256): DEDUPE 0x5e000 thru 0x74fff	(0x17000 bytes) to 0x3d000 thru 0x53fff	BBBB******
6212501(149 mod 256): CLONE 0x12000 thru 0x1dfff	(0xc000 bytes) to 0x3c000 thru 0x47fff
6212502(150 mod 256): COPY 0x244ad thru 0x32ba5	(0xe6f9 bytes) to 0x5b0ef thru 0x697e7
6212503(151 mod 256): SKIPPED (no operation)
6212504(152 mod 256): SKIPPED (no operation)
6212505(153 mod 256): FALLOC   0x84c71 thru 0x927c0	(0xdb4f bytes) EXTENDING
6212506(154 mod 256): MAPWRITE 0x7b3a thru 0x9bb7	(0x207e bytes)
6212507(155 mod 256): WRITE    0x4932d thru 0x544df	(0xb1b3 bytes)
6212508(156 mod 256): ZERO     0x3fe81 thru 0x509f0	(0x10b70 bytes)
6212509(157 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xd9c8	******WWWW
6212510(158 mod 256): PUNCH    0x5990 thru 0xd9c7	(0x8038 bytes)
6212511(159 mod 256): MAPWRITE 0x16f14 thru 0x2ebe4	(0x17cd1 bytes)
6212512(160 mod 256): COLLAPSE 0x1d000 thru 0x26fff	(0xa000 bytes)
6212513(161 mod 256): DEDUPE 0x13000 thru 0x20fff	(0xe000 bytes) to 0x3000 thru 0x10fff
6212514(162 mod 256): SKIPPED (no operation)
6212515(163 mod 256): FALLOC   0x22abf thru 0x30f0e	(0xe44f bytes) PAST_EOF
6212516(164 mod 256): INSERT 0x22000 thru 0x31fff	(0x10000 bytes)
6212517(165 mod 256): COLLAPSE 0x0 thru 0xffff	(0x10000 bytes)
6212518(166 mod 256): PUNCH    0x1df5c thru 0x24be4	(0x6c89 bytes)
6212519(167 mod 256): PUNCH    0xbf49 thru 0xfa72	(0x3b2a bytes)
6212520(168 mod 256): WRITE    0x14335 thru 0x1da7b	(0x9747 bytes)
6212521(169 mod 256): SKIPPED (no operation)
6212522(170 mod 256): MAPWRITE 0x61bec thru 0x69db7	(0x81cc bytes)
6212523(171 mod 256): SKIPPED (no operation)
6212524(172 mod 256): WRITE    0x81764 thru 0x927bf	(0x1105c bytes) HOLE	***WWWW
6212525(173 mod 256): PUNCH    0x36357 thru 0x48e42	(0x12aec bytes)
6212526(174 mod 256): SKIPPED (no operation)
6212527(175 mod 256): ZERO     0x64c13 thru 0x6509e	(0x48c bytes)
6212528(176 mod 256): ZERO     0x1749a thru 0x27649	(0x101b0 bytes)
6212529(177 mod 256): CLONE 0x2a000 thru 0x36fff	(0xd000 bytes) to 0xe000 thru 0x1afff
6212530(178 mod 256): MAPREAD  0x37da1 thru 0x4d129	(0x15389 bytes)
6212531(179 mod 256): MAPREAD  0xcf84 thru 0x1c8c2	(0xf93f bytes)
6212532(180 mod 256): SKIPPED (no operation)
6212533(181 mod 256): SKIPPED (no operation)
6212534(182 mod 256): MAPREAD  0x75a52 thru 0x866e9	(0x10c98 bytes)
6212535(183 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x5a889	******WWWW
6212536(184 mod 256): DEDUPE 0x57000 thru 0x58fff	(0x2000 bytes) to 0x3a000 thru 0x3bfff
6212537(185 mod 256): COLLAPSE 0x41000 thru 0x59fff	(0x19000 bytes)
6212538(186 mod 256): MAPWRITE 0x5724c thru 0x736c4	(0x1c479 bytes)	******WWWW
6212539(187 mod 256): COLLAPSE 0x2c000 thru 0x35fff	(0xa000 bytes)
6212540(188 mod 256): COLLAPSE 0x23000 thru 0x3cfff	(0x1a000 bytes)
6212541(189 mod 256): ZERO     0x6ad65 thru 0x7f839	(0x14ad5 bytes)	******ZZZZ
6212542(190 mod 256): MAPWRITE 0x4fb51 thru 0x659cc	(0x15e7c bytes)
6212543(191 mod 256): ZERO     0x33668 thru 0x4193e	(0xe2d7 bytes)
6212544(192 mod 256): ZERO     0x22e81 thru 0x390fc	(0x1627c bytes)
6212545(193 mod 256): FALLOC   0x66a0 thru 0x1e3c9	(0x17d29 bytes) INTERIOR
6212546(194 mod 256): WRITE    0x20fe thru 0x11205	(0xf108 bytes)
6212547(195 mod 256): CLONE 0x1b000 thru 0x2cfff	(0x12000 bytes) to 0x41000 thru 0x52fff
6212548(196 mod 256): PUNCH    0x59733 thru 0x6198f	(0x825d bytes)
6212549(197 mod 256): FALLOC   0x655a6 thru 0x7933b	(0x13d95 bytes) PAST_EOF	******FFFF
6212550(198 mod 256): ZERO     0x7ee04 thru 0x9220c	(0x13409 bytes)
6212551(199 mod 256): CLONE 0x8b000 thru 0x90fff	(0x6000 bytes) to 0x51000 thru 0x56fff
6212552(200 mod 256): SKIPPED (no operation)
6212553(201 mod 256): CLONE 0x1f000 thru 0x3afff	(0x1c000 bytes) to 0x41000 thru 0x5cfff
6212554(202 mod 256): COPY 0x7bd22 thru 0x8a079	(0xe358 bytes) to 0x50bee thru 0x5ef45
6212555(203 mod 256): TRUNCATE DOWN	from 0x9220d to 0x88f5f
6212556(204 mod 256): MAPREAD  0x653b6 thru 0x680b5	(0x2d00 bytes)
6212557(205 mod 256): WRITE    0x4c78e thru 0x6ad1a	(0x1e58d bytes)
6212558(206 mod 256): SKIPPED (no operation)
6212559(207 mod 256): CLONE 0x7b000 thru 0x7bfff	(0x1000 bytes) to 0x64000 thru 0x64fff
6212560(208 mod 256): READ     0x39de5 thru 0x54122	(0x1a33e bytes)
6212561(209 mod 256): READ     0x11041 thru 0x16432	(0x53f2 bytes)
6212562(210 mod 256): READ     0x58607 thru 0x58c06	(0x600 bytes)
6212563(211 mod 256): READ     0xdbf2 thru 0x1d2d7	(0xf6e6 bytes)
6212564(212 mod 256): PUNCH    0x40fe8 thru 0x5f924	(0x1e93d bytes)
6212565(213 mod 256): COPY 0x38d3a thru 0x3ed6f	(0x6036 bytes) to 0x71d82 thru 0x77db7
6212566(214 mod 256): COPY 0x714e2 thru 0x735d7	(0x20f6 bytes) to 0x5d45f thru 0x5f554
6212567(215 mod 256): COPY 0x61619 thru 0x68ab9	(0x74a1 bytes) to 0x2338 thru 0x97d8
6212568(216 mod 256): READ     0x9da3 thru 0x14dc2	(0xb020 bytes)
6212569(217 mod 256): COPY 0x2bdba thru 0x2d89d	(0x1ae4 bytes) to 0x7ebe8 thru 0x806cb
6212570(218 mod 256): MAPWRITE 0x78230 thru 0x8771b	(0xf4ec bytes)
6212571(219 mod 256): FALLOC   0x313c0 thru 0x32970	(0x15b0 bytes) INTERIOR
6212572(220 mod 256): MAPREAD  0x83a4d thru 0x85d47	(0x22fb bytes)
6212573(221 mod 256): MAPWRITE 0x71881 thru 0x8f09e	(0x1d81e bytes)
6212574(222 mod 256): MAPWRITE 0x7398d thru 0x927bf	(0x1ee33 bytes)
6212575(223 mod 256): READ     0x78e59 thru 0x7def9	(0x50a1 bytes)
6212576(224 mod 256): SKIPPED (no operation)
6212577(225 mod 256): COPY 0x5c9d5 thru 0x6b137	(0xe763 bytes) to 0x30a64 thru 0x3f1c6
6212578(226 mod 256): COPY 0x80ee5 thru 0x8a0c7	(0x91e3 bytes) to 0x621e8 thru 0x6b3ca
6212579(227 mod 256): COLLAPSE 0x76000 thru 0x87fff	(0x12000 bytes)
6212580(228 mod 256): MAPREAD  0x4ae79 thru 0x525d7	(0x775f bytes)
6212581(229 mod 256): SKIPPED (no operation)
6212582(230 mod 256): TRUNCATE UP	from 0x807c0 to 0x849ab
6212583(231 mod 256): ZERO     0x2386f thru 0x30640	(0xcdd2 bytes)
6212584(232 mod 256): WRITE    0x54910 thru 0x626ea	(0xdddb bytes)
6212585(233 mod 256): DEDUPE 0x22000 thru 0x32fff	(0x11000 bytes) to 0x36000 thru 0x46fff
6212586(234 mod 256): TRUNCATE DOWN	from 0x849ab to 0x65e8d	******WWWW
6212587(235 mod 256): ZERO     0x83629 thru 0x927bf	(0xf197 bytes)
6212588(236 mod 256): WRITE    0x92460 thru 0x927bf	(0x360 bytes) HOLE	***WWWW
6212589(237 mod 256): READ     0x13e7c thru 0x2a6de	(0x16863 bytes)
6212590(238 mod 256): MAPREAD  0x4890f thru 0x6709b	(0x1e78d bytes)
6212591(239 mod 256): FALLOC   0x70b5e thru 0x7a331	(0x97d3 bytes) INTERIOR
6212592(240 mod 256): CLONE 0x8c000 thru 0x90fff	(0x5000 bytes) to 0x66000 thru 0x6afff
6212593(241 mod 256): COPY 0x1f9fe thru 0x38749	(0x18d4c bytes) to 0x678b6 thru 0x80601	******EEEE
6212594(242 mod 256): MAPWRITE 0x221fe thru 0x2a94b	(0x874e bytes)
6212595(243 mod 256): COPY 0x440d1 thru 0x50a3c	(0xc96c bytes) to 0x32bd5 thru 0x3f540
6212596(244 mod 256): ZERO     0x6b81a thru 0x6cdcb	(0x15b2 bytes)
6212597(245 mod 256): READ     0x63484 thru 0x78788	(0x15305 bytes)	***RRRR***
6212598(246 mod 256): COPY 0x8cca4 thru 0x927bf	(0x5b1c bytes) to 0x7a1fd thru 0x7fd18
6212599(247 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x76b76
6212600(248 mod 256): MAPREAD  0x34b7d thru 0x4874c	(0x13bd0 bytes)
6212601(249 mod 256): MAPREAD  0x541e2 thru 0x617c1	(0xd5e0 bytes)
6212602(250 mod 256): INSERT 0x3f000 thru 0x45fff	(0x7000 bytes)
6212603(251 mod 256): MAPWRITE 0x8dbfb thru 0x927bf	(0x4bc5 bytes)
6212604(252 mod 256): READ     0x198d1 thru 0x1ccf1	(0x3421 bytes)
6212605(253 mod 256): WRITE    0x7852e thru 0x794e2	(0xfb5 bytes)
6212606(254 mod 256): PUNCH    0x471e1 thru 0x4dc36	(0x6a56 bytes)
6212607(255 mod 256): FALLOC   0x7c107 thru 0x900ff	(0x13ff8 bytes) INTERIOR
6212608(  0 mod 256): WRITE    0x59790 thru 0x68ef1	(0xf762 bytes)
6212609(  1 mod 256): READ     0x509b3 thru 0x6a9d9	(0x1a027 bytes)
6212610(  2 mod 256): SKIPPED (no operation)
6212611(  3 mod 256): WRITE    0x73c5e thru 0x83273	(0xf616 bytes)
6212612(  4 mod 256): SKIPPED (no operation)
6212613(  5 mod 256): ZERO     0x91846 thru 0x927bf	(0xf7a bytes)
6212614(  6 mod 256): PUNCH    0x3006e thru 0x4ed11	(0x1eca4 bytes)
6212615(  7 mod 256): WRITE    0x57702 thru 0x5aeff	(0x37fe bytes)
6212616(  8 mod 256): COPY 0x5cd7a thru 0x6f156	(0x123dd bytes) to 0x3f5d8 thru 0x519b4	EEEE******
6212617(  9 mod 256): DEDUPE 0x54000 thru 0x5cfff	(0x9000 bytes) to 0x6e000 thru 0x76fff	******BBBB
6212618( 10 mod 256): MAPWRITE 0x2e746 thru 0x38944	(0xa1ff bytes)
6212619( 11 mod 256): READ     0x3e0b1 thru 0x54ce8	(0x16c38 bytes)
6212620( 12 mod 256): COLLAPSE 0x82000 thru 0x83fff	(0x2000 bytes)
6212621( 13 mod 256): ZERO     0x6aa4c thru 0x8963f	(0x1ebf4 bytes)	******ZZZZ
6212622( 14 mod 256): ZERO     0xc89b thru 0x2b455	(0x1ebbb bytes)
6212623( 15 mod 256): INSERT 0x1a000 thru 0x1bfff	(0x2000 bytes)
6212624( 16 mod 256): PUNCH    0x687ba thru 0x7aece	(0x12715 bytes)	******PPPP
6212625( 17 mod 256): COLLAPSE 0x22000 thru 0x2cfff	(0xb000 bytes)
6212626( 18 mod 256): SKIPPED (no operation)
6212627( 19 mod 256): WRITE    0x4ae1d thru 0x5844a	(0xd62e bytes)
6212628( 20 mod 256): DEDUPE 0x70000 thru 0x83fff	(0x14000 bytes) to 0x0 thru 0x13fff
6212629( 21 mod 256): DEDUPE 0x13000 thru 0x1efff	(0xc000 bytes) to 0x59000 thru 0x64fff
6212630( 22 mod 256): MAPWRITE 0x56bd9 thru 0x57e3f	(0x1267 bytes)
6212631( 23 mod 256): DEDUPE 0x21000 thru 0x2cfff	(0xc000 bytes) to 0x50000 thru 0x5bfff
6212632( 24 mod 256): ZERO     0x636af thru 0x729ad	(0xf2ff bytes)	******ZZZZ
6212633( 25 mod 256): TRUNCATE DOWN	from 0x877c0 to 0x12045	******WWWW
6212634( 26 mod 256): ZERO     0x59b07 thru 0x5a1fd	(0x6f7 bytes)
6212635( 27 mod 256): CLONE 0x8000 thru 0x10fff	(0x9000 bytes) to 0x50000 thru 0x58fff
6212636( 28 mod 256): PUNCH    0x22919 thru 0x2cce7	(0xa3cf bytes)
6212637( 29 mod 256): WRITE    0x3fde6 thru 0x40883	(0xa9e bytes)
6212638( 30 mod 256): READ     0x49f65 thru 0x4f551	(0x55ed bytes)
6212639( 31 mod 256): READ     0x2eb5a thru 0x3cfca	(0xe471 bytes)
6212640( 32 mod 256): TRUNCATE DOWN	from 0x59000 to 0x34b42
6212641( 33 mod 256): COPY 0x1c064 thru 0x34b41	(0x18ade bytes) to 0x38f1b thru 0x519f8
6212642( 34 mod 256): READ     0x34b8e thru 0x4e9d4	(0x19e47 bytes)
6212643( 35 mod 256): READ     0x2b11 thru 0xeefc	(0xc3ec bytes)
6212644( 36 mod 256): FALLOC   0x49650 thru 0x5b650	(0x12000 bytes) EXTENDING
6212645( 37 mod 256): INSERT 0x48000 thru 0x56fff	(0xf000 bytes)
6212646( 38 mod 256): CLONE 0x37000 thru 0x52fff	(0x1c000 bytes) to 0x17000 thru 0x32fff
6212647( 39 mod 256): WRITE    0x651ee thru 0x6cf1b	(0x7d2e bytes) EXTEND
6212648( 40 mod 256): MAPREAD  0x50555 thru 0x64785	(0x14231 bytes)
6212649( 41 mod 256): MAPWRITE 0x522bf thru 0x64ae7	(0x12829 bytes)
6212650( 42 mod 256): FALLOC   0x35a6f thru 0x4f4ca	(0x19a5b bytes) INTERIOR
6212651( 43 mod 256): MAPWRITE 0x257aa thru 0x29111	(0x3968 bytes)
6212652( 44 mod 256): PUNCH    0x538f9 thru 0x6cf1b	(0x19623 bytes)
6212653( 45 mod 256): ZERO     0x30f0d thru 0x4742d	(0x16521 bytes)
6212654( 46 mod 256): INSERT 0x3e000 thru 0x49fff	(0xc000 bytes)
6212655( 47 mod 256): ZERO     0x34560 thru 0x35119	(0xbba bytes)
6212656( 48 mod 256): CLONE 0x38000 thru 0x55fff	(0x1e000 bytes) to 0x5b000 thru 0x78fff	******JJJJ
6212657( 49 mod 256): COLLAPSE 0x52000 thru 0x63fff	(0x12000 bytes)
6212658( 50 mod 256): TRUNCATE DOWN	from 0x67000 to 0x4d3ef
6212659( 51 mod 256): TRUNCATE DOWN	from 0x4d3ef to 0x1360a
6212660( 52 mod 256): MAPREAD  0xeaa9 thru 0x13609	(0x4b61 bytes)
6212661( 53 mod 256): MAPREAD  0x4ac8 thru 0x58d2	(0xe0b bytes)
6212662( 54 mod 256): READ     0x7b6a thru 0x13609	(0xbaa0 bytes)
6212663( 55 mod 256): CLONE 0x10000 thru 0x12fff	(0x3000 bytes) to 0x62000 thru 0x64fff
6212664( 56 mod 256): DEDUPE 0x13000 thru 0x13fff	(0x1000 bytes) to 0x5e000 thru 0x5efff
6212665( 57 mod 256): COLLAPSE 0x9000 thru 0x13fff	(0xb000 bytes)
6212666( 58 mod 256): CLONE 0xb000 thru 0x1afff	(0x10000 bytes) to 0x74000 thru 0x83fff
6212667( 59 mod 256): MAPWRITE 0x309e0 thru 0x3baf1	(0xb112 bytes)
6212668( 60 mod 256): WRITE    0x16809 thru 0x21c65	(0xb45d bytes)
6212669( 61 mod 256): TRUNCATE DOWN	from 0x84000 to 0x1feeb	******WWWW
6212670( 62 mod 256): COLLAPSE 0x6000 thru 0x16fff	(0x11000 bytes)
6212671( 63 mod 256): ZERO     0x65d8f thru 0x7c6f3	(0x16965 bytes)	******ZZZZ
6212672( 64 mod 256): CLONE 0x5000 thru 0xdfff	(0x9000 bytes) to 0x7a000 thru 0x82fff
6212673( 65 mod 256): FALLOC   0x1ff04 thru 0x386d8	(0x187d4 bytes) INTERIOR
6212674( 66 mod 256): CLONE 0x4b000 thru 0x64fff	(0x1a000 bytes) to 0x2d000 thru 0x46fff
6212675( 67 mod 256): MAPREAD  0x39e27 thru 0x440da	(0xa2b4 bytes)
6212676( 68 mod 256): MAPWRITE 0x8c94a thru 0x9190c	(0x4fc3 bytes)
6212677( 69 mod 256): MAPREAD  0x7451f thru 0x7eec7	(0xa9a9 bytes)
6212678( 70 mod 256): PUNCH    0x118d4 thru 0x1be95	(0xa5c2 bytes)
6212679( 71 mod 256): MAPREAD  0x231b1 thru 0x26561	(0x33b1 bytes)
6212680( 72 mod 256): COPY 0x5f75b thru 0x6b844	(0xc0ea bytes) to 0x39305 thru 0x453ee
6212681( 73 mod 256): FALLOC   0x77272 thru 0x83125	(0xbeb3 bytes) INTERIOR
6212682( 74 mod 256): READ     0xd88f thru 0x1dc6f	(0x103e1 bytes)
6212683( 75 mod 256): TRUNCATE DOWN	from 0x9190d to 0x81686
6212684( 76 mod 256): MAPWRITE 0x1cd1d thru 0x1f523	(0x2807 bytes)
6212685( 77 mod 256): MAPWRITE 0x13944 thru 0x1f3e4	(0xbaa1 bytes)
6212686( 78 mod 256): SKIPPED (no operation)
6212687( 79 mod 256): MAPWRITE 0x5f1b0 thru 0x6952a	(0xa37b bytes)
6212688( 80 mod 256): CLONE 0x62000 thru 0x67fff	(0x6000 bytes) to 0x79000 thru 0x7efff
6212689( 81 mod 256): DEDUPE 0x38000 thru 0x49fff	(0x12000 bytes) to 0x13000 thru 0x24fff
6212690( 82 mod 256): CLONE 0x2e000 thru 0x45fff	(0x18000 bytes) to 0x77000 thru 0x8efff
6212691( 83 mod 256): FALLOC   0x23c5 thru 0x199fa	(0x17635 bytes) INTERIOR
6212692( 84 mod 256): READ     0x67a48 thru 0x853e3	(0x1d99c bytes)	***RRRR***
6212693( 85 mod 256): TRUNCATE DOWN	from 0x8f000 to 0x779f8
6212694( 86 mod 256): MAPREAD  0xba8a thru 0x18617	(0xcb8e bytes)
6212695( 87 mod 256): COLLAPSE 0x27000 thru 0x2bfff	(0x5000 bytes)
6212696( 88 mod 256): INSERT 0x19000 thru 0x1ffff	(0x7000 bytes)
6212697( 89 mod 256): READ     0x3fc99 thru 0x5a985	(0x1aced bytes)
6212698( 90 mod 256): TRUNCATE DOWN	from 0x799f8 to 0x97c6	******WWWW
6212699( 91 mod 256): WRITE    0x8a04a thru 0x927bf	(0x8776 bytes) HOLE	***WWWW
6212700( 92 mod 256): SKIPPED (no operation)
6212701( 93 mod 256): SKIPPED (no operation)
6212702( 94 mod 256): ZERO     0x7468f thru 0x7e50b	(0x9e7d bytes)
6212703( 95 mod 256): MAPREAD  0x6251b thru 0x659bc	(0x34a2 bytes)
6212704( 96 mod 256): DEDUPE 0x17000 thru 0x2bfff	(0x15000 bytes) to 0x6d000 thru 0x81fff	******BBBB
6212705( 97 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8501	******WWWW
6212706( 98 mod 256): TRUNCATE UP	from 0x8501 to 0x6d5a5
6212707( 99 mod 256): WRITE    0x678dd thru 0x7a510	(0x12c34 bytes) EXTEND	***WWWW
6212708(100 mod 256): MAPREAD  0x35fd8 thru 0x3dca6	(0x7ccf bytes)
6212709(101 mod 256): COPY 0x51064 thru 0x624d1	(0x1146e bytes) to 0x87b6 thru 0x19c23
6212710(102 mod 256): COPY 0x4d3e6 thru 0x68606	(0x1b221 bytes) to 0x1715e thru 0x3237e
6212711(103 mod 256): COPY 0x5652d thru 0x58408	(0x1edc bytes) to 0xa5f8 thru 0xc4d3
6212712(104 mod 256): MAPWRITE 0x82edc thru 0x927bf	(0xf8e4 bytes)
6212713(105 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8078	******WWWW
6212714(106 mod 256): MAPREAD  0x22b8 thru 0x8077	(0x5dc0 bytes)
6212715(107 mod 256): READ     0x56a1 thru 0x8077	(0x29d7 bytes)
6212716(108 mod 256): SKIPPED (no operation)
6212717(109 mod 256): READ     0x1d3f thru 0x8077	(0x6339 bytes)
6212718(110 mod 256): PUNCH    0xdf8 thru 0x8077	(0x7280 bytes)
6212719(111 mod 256): COLLAPSE 0x3000 thru 0x6fff	(0x4000 bytes)
6212720(112 mod 256): READ     0xec6 thru 0x4077	(0x31b2 bytes)
6212721(113 mod 256): MAPREAD  0x11f7 thru 0x4077	(0x2e81 bytes)
6212722(114 mod 256): TRUNCATE UP	from 0x4078 to 0x6a183
6212723(115 mod 256): MAPREAD  0x2848c thru 0x2ae4d	(0x29c2 bytes)
6212724(116 mod 256): ZERO     0x5cea0 thru 0x7b514	(0x1e675 bytes)	******ZZZZ
6212725(117 mod 256): SKIPPED (no operation)
6212726(118 mod 256): SKIPPED (no operation)
6212727(119 mod 256): COLLAPSE 0x41000 thru 0x51fff	(0x11000 bytes)
6212728(120 mod 256): SKIPPED (no operation)
6212729(121 mod 256): ZERO     0x83aca thru 0x927bf	(0xecf6 bytes)
6212730(122 mod 256): PUNCH    0x381a thru 0x1800f	(0x147f6 bytes)
6212731(123 mod 256): MAPWRITE 0xfe9c thru 0x20c92	(0x10df7 bytes)
6212732(124 mod 256): MAPREAD  0x54b2 thru 0xd284	(0x7dd3 bytes)
6212733(125 mod 256): COPY 0x1005f thru 0x2208a	(0x1202c bytes) to 0x6a660 thru 0x7c68b	******EEEE
6212734(126 mod 256): READ     0x28e6 thru 0x99f8	(0x7113 bytes)
6212735(127 mod 256): READ     0x4f589 thru 0x6ce8d	(0x1d905 bytes)
6212736(128 mod 256): FALLOC   0x72174 thru 0x907a7	(0x1e633 bytes) PAST_EOF
6212737(129 mod 256): SKIPPED (no operation)
6212738(130 mod 256): WRITE    0x68e94 thru 0x6dda9	(0x4f16 bytes)
6212739(131 mod 256): INSERT 0x58000 thru 0x60fff	(0x9000 bytes)
6212740(132 mod 256): ZERO     0x4a9b7 thru 0x65529	(0x1ab73 bytes)
6212741(133 mod 256): MAPWRITE 0x6213c thru 0x67c6f	(0x5b34 bytes)
6212742(134 mod 256): COLLAPSE 0x51000 thru 0x6dfff	(0x1d000 bytes)
6212743(135 mod 256): PUNCH    0x5c225 thru 0x5d5b0	(0x138c bytes)
6212744(136 mod 256): SKIPPED (no operation)
6212745(137 mod 256): TRUNCATE UP	from 0x6868c to 0x6988e
6212746(138 mod 256): ZERO     0x6a23f thru 0x8272d	(0x184ef bytes)	******ZZZZ
6212747(139 mod 256): CLONE 0x15000 thru 0x28fff	(0x14000 bytes) to 0x40000 thru 0x53fff
6212748(140 mod 256): CLONE 0x2c000 thru 0x31fff	(0x6000 bytes) to 0x12000 thru 0x17fff
6212749(141 mod 256): WRITE    0x74ac7 thru 0x7c925	(0x7e5f bytes) HOLE	***WWWW
6212750(142 mod 256): FALLOC   0x69cbb thru 0x763c0	(0xc705 bytes) INTERIOR	******FFFF
6212751(143 mod 256): DEDUPE 0x1f000 thru 0x2afff	(0xc000 bytes) to 0x45000 thru 0x50fff
6212752(144 mod 256): CLONE 0x66000 thru 0x6ffff	(0xa000 bytes) to 0x71000 thru 0x7afff	JJJJ******
6212753(145 mod 256): TRUNCATE DOWN	from 0x7c926 to 0x380d1	******WWWW
6212754(146 mod 256): INSERT 0x23000 thru 0x24fff	(0x2000 bytes)
6212755(147 mod 256): INSERT 0x16000 thru 0x33fff	(0x1e000 bytes)
6212756(148 mod 256): ZERO     0x595a4 thru 0x6d72a	(0x14187 bytes)
6212757(149 mod 256): MAPREAD  0x375f7 thru 0x431fc	(0xbc06 bytes)
6212758(150 mod 256): INSERT 0x1c000 thru 0x39fff	(0x1e000 bytes)
6212759(151 mod 256): MAPWRITE 0x4afff thru 0x4c9e1	(0x19e3 bytes)
6212760(152 mod 256): ZERO     0x39bde thru 0x3a5c4	(0x9e7 bytes)
6212761(153 mod 256): DEDUPE 0x28000 thru 0x36fff	(0xf000 bytes) to 0x3d000 thru 0x4bfff
6212762(154 mod 256): MAPWRITE 0x29b1d thru 0x32909	(0x8ded bytes)
6212763(155 mod 256): WRITE    0xd4ef thru 0xf4b9	(0x1fcb bytes)
6212764(156 mod 256): CLONE 0x24000 thru 0x39fff	(0x16000 bytes) to 0x4000 thru 0x19fff
6212765(157 mod 256): DEDUPE 0x29000 thru 0x37fff	(0xf000 bytes) to 0xc000 thru 0x1afff
6212766(158 mod 256): WRITE    0x3623c thru 0x4f496	(0x1925b bytes)
6212767(159 mod 256): FALLOC   0x8539f thru 0x927c0	(0xd421 bytes) EXTENDING
6212768(160 mod 256): ZERO     0x2ae61 thru 0x3787c	(0xca1c bytes)
6212769(161 mod 256): ZERO     0x38ec2 thru 0x4d4e5	(0x14624 bytes)
6212770(162 mod 256): SKIPPED (no operation)
6212771(163 mod 256): MAPWRITE 0x74be0 thru 0x775ac	(0x29cd bytes)
6212772(164 mod 256): COPY 0x8ea91 thru 0x927bf	(0x3d2f bytes) to 0x74412 thru 0x78140
6212773(165 mod 256): MAPWRITE 0x80ee3 thru 0x927bf	(0x118dd bytes)
6212774(166 mod 256): READ     0x538d9 thru 0x5b293	(0x79bb bytes)
6212775(167 mod 256): WRITE    0x4ef21 thru 0x5c867	(0xd947 bytes)
6212776(168 mod 256): CLONE 0x13000 thru 0x2efff	(0x1c000 bytes) to 0x42000 thru 0x5dfff
6212777(169 mod 256): SKIPPED (no operation)
6212778(170 mod 256): TRUNCATE DOWN	from 0x927c0 to 0xa0b2	******WWWW
6212779(171 mod 256): READ     0x371f thru 0xa0b1	(0x6993 bytes)
6212780(172 mod 256): READ     0x37f3 thru 0xa0b1	(0x68bf bytes)
6212781(173 mod 256): MAPWRITE 0x6a660 thru 0x866b3	(0x1c054 bytes)	******WWWW
6212782(174 mod 256): COPY 0x66764 thru 0x815c8	(0x1ae65 bytes) to 0x16813 thru 0x31677	EEEE******
6212783(175 mod 256): DEDUPE 0x7000 thru 0x1afff	(0x14000 bytes) to 0x31000 thru 0x44fff
6212784(176 mod 256): MAPWRITE 0x89218 thru 0x8a5f7	(0x13e0 bytes)
6212785(177 mod 256): INSERT 0x21000 thru 0x28fff	(0x8000 bytes)
6212786(178 mod 256): SKIPPED (no operation)
6212787(179 mod 256): MAPREAD  0x62893 thru 0x6eb78	(0xc2e6 bytes)
6212788(180 mod 256): SKIPPED (no operation)
6212789(181 mod 256): PUNCH    0x74955 thru 0x85590	(0x10c3c bytes)
6212790(182 mod 256): PUNCH    0x1da8f thru 0x2a40e	(0xc980 bytes)
6212791(183 mod 256): PUNCH    0x6cff5 thru 0x86a56	(0x19a62 bytes)	******PPPP
6212792(184 mod 256): COPY 0x669f6 thru 0x75761	(0xed6c bytes) to 0x53a8d thru 0x627f8	EEEE******
6212793(185 mod 256): COLLAPSE 0x7f000 thru 0x90fff	(0x12000 bytes)
6212794(186 mod 256): FALLOC   0x49c6e thru 0x680b9	(0x1e44b bytes) INTERIOR
6212795(187 mod 256): DEDUPE 0x6000 thru 0x1ffff	(0x1a000 bytes) to 0x20000 thru 0x39fff
6212796(188 mod 256): COPY 0x5b9b thru 0x23f2a	(0x1e390 bytes) to 0x4b525 thru 0x698b4
6212797(189 mod 256): ZERO     0x2867d thru 0x3ee99	(0x1681d bytes)
6212798(190 mod 256): INSERT 0x5e000 thru 0x6ffff	(0x12000 bytes)	******IIII
6212799(191 mod 256): COPY 0x61778 thru 0x77295	(0x15b1e bytes) to 0x1e587 thru 0x340a4	EEEE******
6212800(192 mod 256): ZERO     0x87e3f thru 0x927bf	(0xa981 bytes)
6212801(193 mod 256): PUNCH    0x4897d thru 0x57ea8	(0xf52c bytes)
6212802(194 mod 256): COLLAPSE 0x4c000 thru 0x5efff	(0x13000 bytes)
6212803(195 mod 256): CLONE 0x72000 thru 0x79fff	(0x8000 bytes) to 0x67000 thru 0x6efff	******JJJJ
6212804(196 mod 256): PUNCH    0x2321d thru 0x3d144	(0x19f28 bytes)
6212805(197 mod 256): COLLAPSE 0x4d000 thru 0x63fff	(0x17000 bytes)
6212806(198 mod 256): ZERO     0x6f4d thru 0xcb97	(0x5c4b bytes)
6212807(199 mod 256): TRUNCATE UP	from 0x687c0 to 0x8d4ca	******WWWW
6212808(200 mod 256): READ     0x420db thru 0x4dde0	(0xbd06 bytes)
6212809(201 mod 256): ZERO     0x2ca2c thru 0x44e29	(0x183fe bytes)
6212810(202 mod 256): TRUNCATE DOWN	from 0x8d4ca to 0x82384
6212811(203 mod 256): ZERO     0x59f7c thru 0x5c8a6	(0x292b bytes)
6212812(204 mod 256): FALLOC   0x8f2b8 thru 0x927c0	(0x3508 bytes) EXTENDING
6212813(205 mod 256): SKIPPED (no operation)
6212814(206 mod 256): READ     0x54ad8 thru 0x6b7d6	(0x16cff bytes)
6212815(207 mod 256): COPY 0x54b59 thru 0x6e94e	(0x19df6 bytes) to 0x1b146 thru 0x34f3b
6212816(208 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x14231	******WWWW
6212817(209 mod 256): CLONE 0xc000 thru 0x12fff	(0x7000 bytes) to 0x43000 thru 0x49fff
6212818(210 mod 256): READ     0x15c18 thru 0x2da86	(0x17e6f bytes)
6212819(211 mod 256): SKIPPED (no operation)
6212820(212 mod 256): MAPREAD  0x2bdf2 thru 0x2eea9	(0x30b8 bytes)
6212821(213 mod 256): FALLOC   0x2f586 thru 0x31d07	(0x2781 bytes) INTERIOR
6212822(214 mod 256): COLLAPSE 0x25000 thru 0x25fff	(0x1000 bytes)
6212823(215 mod 256): FALLOC   0x8bd18 thru 0x927c0	(0x6aa8 bytes) EXTENDING
6212824(216 mod 256): MAPREAD  0x60166 thru 0x62bc8	(0x2a63 bytes)
6212825(217 mod 256): PUNCH    0x1f537 thru 0x3ae70	(0x1b93a bytes)
6212826(218 mod 256): SKIPPED (no operation)
6212827(219 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x6866f	******WWWW
6212828(220 mod 256): SKIPPED (no operation)
6212829(221 mod 256): DEDUPE 0x24000 thru 0x3bfff	(0x18000 bytes) to 0x4e000 thru 0x65fff
6212830(222 mod 256): SKIPPED (no operation)
6212831(223 mod 256): INSERT 0x35000 thru 0x4ffff	(0x1b000 bytes)
6212832(224 mod 256): SKIPPED (no operation)
6212833(225 mod 256): MAPREAD  0xb653 thru 0x27301	(0x1bcaf bytes)
6212834(226 mod 256): READ     0x34eb2 thru 0x3dfe8	(0x9137 bytes)
6212835(227 mod 256): MAPREAD  0xa51e thru 0x24c38	(0x1a71b bytes)
6212836(228 mod 256): DEDUPE 0x7a000 thru 0x81fff	(0x8000 bytes) to 0x3f000 thru 0x46fff
6212837(229 mod 256): FALLOC   0x854dd thru 0x927c0	(0xd2e3 bytes) PAST_EOF
6212838(230 mod 256): READ     0x16687 thru 0x344bb	(0x1de35 bytes)
6212839(231 mod 256): SKIPPED (no operation)
6212840(232 mod 256): COLLAPSE 0x27000 thru 0x30fff	(0xa000 bytes)
6212841(233 mod 256): COPY 0xf2d thru 0x18d2f	(0x17e03 bytes) to 0x646af thru 0x7c4b1	******EEEE
6212842(234 mod 256): PUNCH    0x5f200 thru 0x6e02d	(0xee2e bytes)
6212843(235 mod 256): TRUNCATE DOWN	from 0x7c4b2 to 0x631cd	******WWWW
6212844(236 mod 256): INSERT 0x1c000 thru 0x25fff	(0xa000 bytes)
6212845(237 mod 256): MAPREAD  0x4a39c thru 0x5c9f3	(0x12658 bytes)
6212846(238 mod 256): PUNCH    0x61447 thru 0x6d1cc	(0xbd86 bytes)
6212847(239 mod 256): FALLOC   0x5c5b2 thru 0x66ebc	(0xa90a bytes) INTERIOR
6212848(240 mod 256): CLONE 0x63000 thru 0x6bfff	(0x9000 bytes) to 0x8000 thru 0x10fff
6212849(241 mod 256): TRUNCATE DOWN	from 0x6d1cd to 0xaac
6212850(242 mod 256): INSERT 0x0 thru 0xafff	(0xb000 bytes)
6212851(243 mod 256): COLLAPSE 0x1000 thru 0x9fff	(0x9000 bytes)
6212852(244 mod 256): COLLAPSE 0x1000 thru 0x1fff	(0x1000 bytes)
6212853(245 mod 256): COPY 0x16db thru 0x1aab	(0x3d1 bytes) to 0x2b89f thru 0x2bc6f
6212854(246 mod 256): CLONE 0x21000 thru 0x28fff	(0x8000 bytes) to 0x73000 thru 0x7afff
6212855(247 mod 256): SKIPPED (no operation)
6212856(248 mod 256): MAPWRITE 0x5de2 thru 0x7217	(0x1436 bytes)
6212857(249 mod 256): PUNCH    0x1888f thru 0x31a93	(0x19205 bytes)
6212858(250 mod 256): FALLOC   0x561e2 thru 0x73fc3	(0x1dde1 bytes) INTERIOR	******FFFF
6212859(251 mod 256): MAPWRITE 0x813f0 thru 0x927bf	(0x113d0 bytes)
6212860(252 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4609d	******WWWW
6212861(253 mod 256): FALLOC   0x20788 thru 0x350d2	(0x1494a bytes) INTERIOR
6212862(254 mod 256): MAPREAD  0x75a4 thru 0xb2b6	(0x3d13 bytes)
6212863(255 mod 256): MAPREAD  0x3c560 thru 0x4609c	(0x9b3d bytes)
6212864(  0 mod 256): MAPREAD  0x546b thru 0x1d78b	(0x18321 bytes)
6212865(  1 mod 256): DEDUPE 0x2c000 thru 0x31fff	(0x6000 bytes) to 0x3a000 thru 0x3ffff
6212866(  2 mod 256): SKIPPED (no operation)
6212867(  3 mod 256): INSERT 0x15000 thru 0x18fff	(0x4000 bytes)
6212868(  4 mod 256): WRITE    0x437a7 thru 0x4d6f7	(0x9f51 bytes) EXTEND
6212869(  5 mod 256): READ     0x3b9fc thru 0x3cc9f	(0x12a4 bytes)
6212870(  6 mod 256): TRUNCATE UP	from 0x4d6f8 to 0x6b687
6212871(  7 mod 256): FALLOC   0x59395 thru 0x764e8	(0x1d153 bytes) EXTENDING	******FFFF
6212872(  8 mod 256): READ     0x2fe54 thru 0x45423	(0x155d0 bytes)
6212873(  9 mod 256): READ     0x16e8e thru 0x300dc	(0x1924f bytes)
6212874( 10 mod 256): COLLAPSE 0x5c000 thru 0x6cfff	(0x11000 bytes)
6212875( 11 mod 256): CLONE 0x2000 thru 0x1bfff	(0x1a000 bytes) to 0x5e000 thru 0x77fff	******JJJJ
6212876( 12 mod 256): CLONE 0x3000 thru 0xcfff	(0xa000 bytes) to 0x6c000 thru 0x75fff	******JJJJ
6212877( 13 mod 256): WRITE    0x7d957 thru 0x7e078	(0x722 bytes) HOLE
6212878( 14 mod 256): TRUNCATE DOWN	from 0x7e079 to 0x2e334	******WWWW
6212879( 15 mod 256): ZERO     0x38b32 thru 0x54cdd	(0x1c1ac bytes)
6212880( 16 mod 256): SKIPPED (no operation)
6212881( 17 mod 256): WRITE    0x17117 thru 0x181b9	(0x10a3 bytes)
6212882( 18 mod 256): READ     0x44cda thru 0x539e3	(0xed0a bytes)
6212883( 19 mod 256): COLLAPSE 0x22000 thru 0x3ffff	(0x1e000 bytes)
6212884( 20 mod 256): CLONE 0x17000 thru 0x2afff	(0x14000 bytes) to 0x76000 thru 0x89fff
6212885( 21 mod 256): MAPREAD  0x8503b thru 0x89fff	(0x4fc5 bytes)
6212886( 22 mod 256): PUNCH    0x6fbf0 thru 0x7faaa	(0xfebb bytes)
6212887( 23 mod 256): COPY 0x893a4 thru 0x89fff	(0xc5c bytes) to 0x58a33 thru 0x5968e
6212888( 24 mod 256): MAPWRITE 0x47671 thru 0x510b1	(0x9a41 bytes)
6212889( 25 mod 256): CLONE 0x61000 thru 0x6bfff	(0xb000 bytes) to 0xb000 thru 0x15fff
6212890( 26 mod 256): SKIPPED (no operation)
6212891( 27 mod 256): READ     0x6858d thru 0x71be0	(0x9654 bytes)	***RRRR***
6212892( 28 mod 256): SKIPPED (no operation)
6212893( 29 mod 256): MAPREAD  0x56bd8 thru 0x60737	(0x9b60 bytes)
6212894( 30 mod 256): PUNCH    0x14876 thru 0x31a0f	(0x1d19a bytes)
6212895( 31 mod 256): WRITE    0x47f34 thru 0x5422f	(0xc2fc bytes)
6212896( 32 mod 256): FALLOC   0x8d5ed thru 0x927c0	(0x51d3 bytes) EXTENDING
6212897( 33 mod 256): DEDUPE 0x3c000 thru 0x3dfff	(0x2000 bytes) to 0x38000 thru 0x39fff
6212898( 34 mod 256): ZERO     0x747d3 thru 0x8a5c9	(0x15df7 bytes)
6212899( 35 mod 256): DEDUPE 0x80000 thru 0x8cfff	(0xd000 bytes) to 0x15000 thru 0x21fff
6212900( 36 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x4df5d	******WWWW
6212901( 37 mod 256): MAPWRITE 0x2292d thru 0x3b9b2	(0x19086 bytes)
6212902( 38 mod 256): TRUNCATE UP	from 0x4df5d to 0x72355	******WWWW
6212903( 39 mod 256): CLONE 0x64000 thru 0x71fff	(0xe000 bytes) to 0x15000 thru 0x22fff	JJJJ******
6212904( 40 mod 256): COPY 0x32f79 thru 0x39c6b	(0x6cf3 bytes) to 0x4ec5d thru 0x5594f
6212905( 41 mod 256): TRUNCATE DOWN	from 0x72355 to 0x3df77	******WWWW
6212906( 42 mod 256): CLONE 0x8000 thru 0x25fff	(0x1e000 bytes) to 0x36000 thru 0x53fff
6212907( 43 mod 256): INSERT 0xb000 thru 0x26fff	(0x1c000 bytes)
6212908( 44 mod 256): TRUNCATE UP	from 0x70000 to 0x86903
6212909( 45 mod 256): MAPWRITE 0x4f99e thru 0x6dabe	(0x1e121 bytes)
6212910( 46 mod 256): PUNCH    0x31d77 thru 0x4b104	(0x1938e bytes)
6212911( 47 mod 256): DEDUPE 0xb000 thru 0x19fff	(0xf000 bytes) to 0x29000 thru 0x37fff
6212912( 48 mod 256): TRUNCATE DOWN	from 0x86903 to 0x2f586	******WWWW
6212913( 49 mod 256): INSERT 0x22000 thru 0x3bfff	(0x1a000 bytes)
6212914( 50 mod 256): PUNCH    0x52cb thru 0x20b78	(0x1b8ae bytes)
6212915( 51 mod 256): INSERT 0x9000 thru 0x1dfff	(0x15000 bytes)
6212916( 52 mod 256): COLLAPSE 0x8000 thru 0x9fff	(0x2000 bytes)
6212917( 53 mod 256): SKIPPED (no operation)
6212918( 54 mod 256): TRUNCATE UP	from 0x5c586 to 0x73aac	******WWWW
6212919( 55 mod 256): MAPREAD  0x187b6 thru 0x2912f	(0x1097a bytes)
6212920( 56 mod 256): DEDUPE 0x50000 thru 0x66fff	(0x17000 bytes) to 0xe000 thru 0x24fff
6212921( 57 mod 256): MAPWRITE 0x8d025 thru 0x927bf	(0x579b bytes)
6212922( 58 mod 256): PUNCH    0x73273 thru 0x8aef5	(0x17c83 bytes)
6212923( 59 mod 256): SKIPPED (no operation)
6212924( 60 mod 256): SKIPPED (no operation)
6212925( 61 mod 256): CLONE 0x82000 thru 0x90fff	(0xf000 bytes) to 0x5b000 thru 0x69fff
6212926( 62 mod 256): DEDUPE 0x5d000 thru 0x66fff	(0xa000 bytes) to 0x19000 thru 0x22fff
6212927( 63 mod 256): PUNCH    0x8983a thru 0x927bf	(0x8f86 bytes)
6212928( 64 mod 256): CLONE 0xe000 thru 0x25fff	(0x18000 bytes) to 0x2d000 thru 0x44fff
6212929( 65 mod 256): MAPWRITE 0x468fa thru 0x4c184	(0x588b bytes)
6212930( 66 mod 256): READ     0x4e49f thru 0x5538d	(0x6eef bytes)
6212931( 67 mod 256): COLLAPSE 0x2f000 thru 0x4dfff	(0x1f000 bytes)
6212932( 68 mod 256): INSERT 0x70000 thru 0x84fff	(0x15000 bytes)
6212933( 69 mod 256): SKIPPED (no operation)
6212934( 70 mod 256): DEDUPE 0x76000 thru 0x86fff	(0x11000 bytes) to 0x5a000 thru 0x6afff
6212935( 71 mod 256): DEDUPE 0x6c000 thru 0x7dfff	(0x12000 bytes) to 0x48000 thru 0x59fff	BBBB******
6212936( 72 mod 256): PUNCH    0x763c1 thru 0x887bf	(0x123ff bytes)
6212937( 73 mod 256): TRUNCATE UP	from 0x887c0 to 0x9158e
6212938( 74 mod 256): MAPWRITE 0x11da9 thru 0x2151a	(0xf772 bytes)
6212939( 75 mod 256): WRITE    0x1a49 thru 0x1ff84	(0x1e53c bytes)
6212940( 76 mod 256): COLLAPSE 0x42000 thru 0x5cfff	(0x1b000 bytes)
6212941( 77 mod 256): ZERO     0x2ad02 thru 0x3c846	(0x11b45 bytes)
6212942( 78 mod 256): MAPREAD  0x965d thru 0x13ded	(0xa791 bytes)
6212943( 79 mod 256): COPY 0x3cc6a thru 0x5bd40	(0x1f0d7 bytes) to 0x573b thru 0x24811
6212944( 80 mod 256): INSERT 0x26000 thru 0x3ffff	(0x1a000 bytes)
6212945( 81 mod 256): MAPREAD  0x6a1a2 thru 0x6de90	(0x3cef bytes)
6212946( 82 mod 256): SKIPPED (no operation)
6212947( 83 mod 256): ZERO     0x4111a thru 0x4379b	(0x2682 bytes)
6212948( 84 mod 256): DEDUPE 0x32000 thru 0x47fff	(0x16000 bytes) to 0x56000 thru 0x6bfff
6212949( 85 mod 256): ZERO     0x195d6 thru 0x23e1e	(0xa849 bytes)
6212950( 86 mod 256): PUNCH    0x4c0d1 thru 0x4d53e	(0x146e bytes)
6212951( 87 mod 256): MAPWRITE 0x991f thru 0xcc03	(0x32e5 bytes)
6212952( 88 mod 256): MAPWRITE 0x57ef2 thru 0x5ee3c	(0x6f4b bytes)
6212953( 89 mod 256): COPY 0x343d thru 0x5586	(0x214a bytes) to 0x4cbc3 thru 0x4ed0c
6212954( 90 mod 256): WRITE    0x5947e thru 0x72334	(0x18eb7 bytes)	***WWWW
6212955( 91 mod 256): DEDUPE 0x29000 thru 0x2dfff	(0x5000 bytes) to 0x12000 thru 0x16fff
6212956( 92 mod 256): COLLAPSE 0x7000 thru 0x17fff	(0x11000 bytes)
6212957( 93 mod 256): SKIPPED (no operation)
6212958( 94 mod 256): INSERT 0xa000 thru 0x12fff	(0x9000 bytes)
6212959( 95 mod 256): MAPWRITE 0x8802f thru 0x927bf	(0xa791 bytes)
6212960( 96 mod 256): COLLAPSE 0x42000 thru 0x48fff	(0x7000 bytes)
6212961( 97 mod 256): SKIPPED (no operation)
6212962( 98 mod 256): MAPWRITE 0x64e89 thru 0x6ae3a	(0x5fb2 bytes)
6212963( 99 mod 256): ZERO     0x631fe thru 0x694ec	(0x62ef bytes)
6212964(100 mod 256): COPY 0x6a019 thru 0x76c6d	(0xcc55 bytes) to 0x27079 thru 0x33ccd	EEEE******
6212965(101 mod 256): FALLOC   0x82c43 thru 0x87fe0	(0x539d bytes) INTERIOR
6212966(102 mod 256): MAPREAD  0x591c0 thru 0x672ac	(0xe0ed bytes)
6212967(103 mod 256): COPY 0x61dfa thru 0x743aa	(0x125b1 bytes) to 0x28b48 thru 0x3b0f8	EEEE******
6212968(104 mod 256): WRITE    0x4cb61 thru 0x4e237	(0x16d7 bytes)
6212969(105 mod 256): SKIPPED (no operation)
6212970(106 mod 256): FALLOC   0x3f558 thru 0x584a6	(0x18f4e bytes) INTERIOR
6212971(107 mod 256): PUNCH    0x30f56 thru 0x384fa	(0x75a5 bytes)
6212972(108 mod 256): SKIPPED (no operation)
6212973(109 mod 256): TRUNCATE UP	from 0x8b7c0 to 0x90d04
6212974(110 mod 256): COLLAPSE 0x3f000 thru 0x4efff	(0x10000 bytes)
6212975(111 mod 256): READ     0x774e1 thru 0x80d03	(0x9823 bytes)
6212976(112 mod 256): COPY 0x6309b thru 0x6b385	(0x82eb bytes) to 0x4059f thru 0x48889
6212977(113 mod 256): PUNCH    0x4a33f thru 0x4abdc	(0x89e bytes)
6212978(114 mod 256): MAPREAD  0x69043 thru 0x80d03	(0x17cc1 bytes)	***RRRR***
6212979(115 mod 256): MAPWRITE 0x1fb6a thru 0x349e3	(0x14e7a bytes)
6212980(116 mod 256): CLONE 0x64000 thru 0x6cfff	(0x9000 bytes) to 0x4f000 thru 0x57fff
6212981(117 mod 256): FALLOC   0x1f042 thru 0x23f39	(0x4ef7 bytes) INTERIOR
6212982(118 mod 256): COPY 0x3288f thru 0x3ca9b	(0xa20d bytes) to 0x4d7c3 thru 0x579cf
6212983(119 mod 256): MAPWRITE 0x65aa4 thru 0x7ad04	(0x15261 bytes)	******WWWW
6212984(120 mod 256): MAPWRITE 0x3319 thru 0x1179d	(0xe485 bytes)
6212985(121 mod 256): INSERT 0xf000 thru 0x1cfff	(0xe000 bytes)
6212986(122 mod 256): READ     0x277dc thru 0x37f37	(0x1075c bytes)
6212987(123 mod 256): PUNCH    0x4a87f thru 0x4c02d	(0x17af bytes)
6212988(124 mod 256): FALLOC   0x77aca thru 0x8617b	(0xe6b1 bytes) INTERIOR
6212989(125 mod 256): ZERO     0x447a0 thru 0x578b6	(0x13117 bytes)
6212990(126 mod 256): MAPREAD  0x55ca1 thru 0x5686b	(0xbcb bytes)
6212991(127 mod 256): MAPREAD  0x48dbf thru 0x56a74	(0xdcb6 bytes)
6212992(128 mod 256): PUNCH    0xf1f6 thru 0x2a32d	(0x1b138 bytes)
6212993(129 mod 256): MAPWRITE 0x2122d thru 0x27c54	(0x6a28 bytes)
6212994(130 mod 256): ZERO     0x59573 thru 0x5cac3	(0x3551 bytes)
6212995(131 mod 256): DEDUPE 0x78000 thru 0x8cfff	(0x15000 bytes) to 0x35000 thru 0x49fff
6212996(132 mod 256): TRUNCATE DOWN	from 0x8ed04 to 0x10557	******WWWW
6212997(133 mod 256): COLLAPSE 0xe000 thru 0xefff	(0x1000 bytes)
6212998(134 mod 256): DEDUPE 0x9000 thru 0xefff	(0x6000 bytes) to 0x1000 thru 0x6fff
6212999(135 mod 256): FALLOC   0x640a0 thru 0x72328	(0xe288 bytes) PAST_EOF	******FFFF
6213000(136 mod 256): COLLAPSE 0x0 thru 0xdfff	(0xe000 bytes)
6213001(137 mod 256): FALLOC   0x677c4 thru 0x7fc25	(0x18461 bytes) PAST_EOF	******FFFF
6213002(138 mod 256): MAPWRITE 0x49baf thru 0x60800	(0x16c52 bytes)
6213003(139 mod 256): MAPREAD  0x14595 thru 0x2b86f	(0x172db bytes)
6213004(140 mod 256): MAPWRITE 0x5a1ff thru 0x729df	(0x187e1 bytes)	******WWWW
6213005(141 mod 256): DEDUPE 0x3c000 thru 0x43fff	(0x8000 bytes) to 0x53000 thru 0x5afff
6213006(142 mod 256): WRITE    0x4d42c thru 0x5f6de	(0x122b3 bytes)
6213007(143 mod 256): SKIPPED (no operation)
6213008(144 mod 256): TRUNCATE DOWN	from 0x729e0 to 0x37742	******WWWW
6213009(145 mod 256): MAPREAD  0x34ff1 thru 0x37741	(0x2751 bytes)
6213010(146 mod 256): COPY 0x868f thru 0xd814	(0x5186 bytes) to 0x17baa thru 0x1cd2f
6213011(147 mod 256): COPY 0x1af79 thru 0x1d879	(0x2901 bytes) to 0x6ec1d thru 0x7151d	******EEEE
6213012(148 mod 256): TRUNCATE UP	from 0x7151e to 0x89f73
6213013(149 mod 256): ZERO     0x87aec thru 0x927bf	(0xacd4 bytes)
6213014(150 mod 256): COPY 0x3b3f6 thru 0x5913e	(0x1dd49 bytes) to 0x61cbd thru 0x7fa05	******EEEE
6213015(151 mod 256): ZERO     0x161d0 thru 0x2d2ea	(0x1711b bytes)
6213016(152 mod 256): PUNCH    0x1000d thru 0x1c0cb	(0xc0bf bytes)
6213017(153 mod 256): FALLOC   0x100a2 thru 0x2a99e	(0x1a8fc bytes) INTERIOR
6213018(154 mod 256): DEDUPE 0x4b000 thru 0x62fff	(0x18000 bytes) to 0x64000 thru 0x7bfff	******BBBB
6213019(155 mod 256): SKIPPED (no operation)
6213020(156 mod 256): MAPREAD  0x8d111 thru 0x927bf	(0x56af bytes)
6213021(157 mod 256): COPY 0x34c8 thru 0x5ec4	(0x29fd bytes) to 0x8af04 thru 0x8d900
6213022(158 mod 256): MAPWRITE 0x601c1 thru 0x75806	(0x15646 bytes)	******WWWW
6213023(159 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x86159
6213024(160 mod 256): MAPWRITE 0x2ca30 thru 0x4b604	(0x1ebd5 bytes)
6213025(161 mod 256): WRITE    0x8ebd7 thru 0x927bf	(0x3be9 bytes) HOLE
6213026(162 mod 256): MAPWRITE 0x48c5a thru 0x533f9	(0xa7a0 bytes)
6213027(163 mod 256): READ     0x7e717 thru 0x927bf	(0x140a9 bytes)
6213028(164 mod 256): SKIPPED (no operation)
6213029(165 mod 256): WRITE    0x914dc thru 0x927bf	(0x12e4 bytes)
6213030(166 mod 256): ZERO     0x35732 thru 0x52387	(0x1cc56 bytes)
6213031(167 mod 256): MAPWRITE 0x27d3f thru 0x45733	(0x1d9f5 bytes)
6213032(168 mod 256): MAPREAD  0x53942 thru 0x71105	(0x1d7c4 bytes)	***RRRR***
6213033(169 mod 256): PUNCH    0x7c06a thru 0x8b187	(0xf11e bytes)
6213034(170 mod 256): SKIPPED (no operation)
6213035(171 mod 256): ZERO     0x5d2ce thru 0x739b8	(0x166eb bytes)	******ZZZZ
6213036(172 mod 256): CLONE 0x0 thru 0x13fff	(0x14000 bytes) to 0x21000 thru 0x34fff
6213037(173 mod 256): READ     0x141c7 thru 0x2a675	(0x164af bytes)
6213038(174 mod 256): MAPWRITE 0x4458a thru 0x59d92	(0x15809 bytes)
6213039(175 mod 256): SKIPPED (no operation)
6213040(176 mod 256): DEDUPE 0x35000 thru 0x45fff	(0x11000 bytes) to 0x1d000 thru 0x2dfff
6213041(177 mod 256): WRITE    0x58616 thru 0x6ab14	(0x124ff bytes)
6213042(178 mod 256): MAPREAD  0x4f6b8 thru 0x5be20	(0xc769 bytes)
6213043(179 mod 256): FALLOC   0xe080 thru 0x1298c	(0x490c bytes) INTERIOR
6213044(180 mod 256): DEDUPE 0x77000 thru 0x7afff	(0x4000 bytes) to 0x3e000 thru 0x41fff
6213045(181 mod 256): SKIPPED (no operation)
6213046(182 mod 256): DEDUPE 0x47000 thru 0x50fff	(0xa000 bytes) to 0x14000 thru 0x1dfff
6213047(183 mod 256): SKIPPED (no operation)
6213048(184 mod 256): COPY 0x8ab9d thru 0x91adb	(0x6f3f bytes) to 0x25171 thru 0x2c0af
6213049(185 mod 256): SKIPPED (no operation)
6213050(186 mod 256): CLONE 0x3000 thru 0x10fff	(0xe000 bytes) to 0x2e000 thru 0x3bfff
6213051(187 mod 256): SKIPPED (no operation)
6213052(188 mod 256): PUNCH    0x74fdd thru 0x8dbcc	(0x18bf0 bytes)
6213053(189 mod 256): DEDUPE 0x1d000 thru 0x23fff	(0x7000 bytes) to 0x26000 thru 0x2cfff
6213054(190 mod 256): COPY 0x17f72 thru 0x26aae	(0xeb3d bytes) to 0x2b5b8 thru 0x3a0f4
6213055(191 mod 256): MAPWRITE 0x32476 thru 0x38cc8	(0x6853 bytes)
6213056(192 mod 256): MAPWRITE 0x769b5 thru 0x7a3ad	(0x39f9 bytes)
6213057(193 mod 256): COLLAPSE 0x19000 thru 0x2cfff	(0x14000 bytes)
6213058(194 mod 256): READ     0x36e2e thru 0x3b74b	(0x491e bytes)
6213059(195 mod 256): INSERT 0x5f000 thru 0x72fff	(0x14000 bytes)	******IIII
6213060(196 mod 256): MAPREAD  0x8b974 thru 0x927bf	(0x6e4c bytes)
6213061(197 mod 256): MAPREAD  0x72140 thru 0x785ec	(0x64ad bytes)
6213062(198 mod 256): SKIPPED (no operation)
6213063(199 mod 256): SKIPPED (no operation)
6213064(200 mod 256): DEDUPE 0x45000 thru 0x54fff	(0x10000 bytes) to 0x6f000 thru 0x7efff
6213065(201 mod 256): FALLOC   0x294e7 thru 0x43e8d	(0x1a9a6 bytes) INTERIOR
6213066(202 mod 256): WRITE    0x2730d thru 0x3cd7d	(0x15a71 bytes)
6213067(203 mod 256): SKIPPED (no operation)
6213068(204 mod 256): ZERO     0x7d0e thru 0x15961	(0xdc54 bytes)
6213069(205 mod 256): DEDUPE 0x69000 thru 0x77fff	(0xf000 bytes) to 0xc000 thru 0x1afff	BBBB******
6213070(206 mod 256): PUNCH    0x61f82 thru 0x7ae02	(0x18e81 bytes)	******PPPP
6213071(207 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8b847
6213072(208 mod 256): PUNCH    0x4175 thru 0xc6e6	(0x8572 bytes)
6213073(209 mod 256): FALLOC   0x3b38e thru 0x3be28	(0xa9a bytes) INTERIOR
6213074(210 mod 256): PUNCH    0x1e668 thru 0x2ec09	(0x105a2 bytes)
6213075(211 mod 256): INSERT 0x3d000 thru 0x42fff	(0x6000 bytes)
6213076(212 mod 256): MAPWRITE 0x35bcb thru 0x37ada	(0x1f10 bytes)
6213077(213 mod 256): COPY 0x23356 thru 0x2f4fa	(0xc1a5 bytes) to 0x4b888 thru 0x57a2c
6213078(214 mod 256): TRUNCATE DOWN	from 0x91847 to 0x77163
6213079(215 mod 256): COLLAPSE 0xb000 thru 0xffff	(0x5000 bytes)
6213080(216 mod 256): INSERT 0xa000 thru 0x25fff	(0x1c000 bytes)
6213081(217 mod 256): MAPWRITE 0x11d3c thru 0x23a19	(0x11cde bytes)
6213082(218 mod 256): TRUNCATE DOWN	from 0x8e163 to 0x267fd	******WWWW
6213083(219 mod 256): TRUNCATE DOWN	from 0x267fd to 0x2510d
6213084(220 mod 256): COLLAPSE 0x23000 thru 0x23fff	(0x1000 bytes)
6213085(221 mod 256): PUNCH    0xe075 thru 0x2410c	(0x16098 bytes)
6213086(222 mod 256): MAPREAD  0x1757f thru 0x2410c	(0xcb8e bytes)
6213087(223 mod 256): MAPWRITE 0x638fc thru 0x6dcc4	(0xa3c9 bytes)
6213088(224 mod 256): COLLAPSE 0x34000 thru 0x4efff	(0x1b000 bytes)
6213089(225 mod 256): SKIPPED (no operation)
6213090(226 mod 256): SKIPPED (no operation)
6213091(227 mod 256): SKIPPED (no operation)
6213092(228 mod 256): COPY 0x19e70 thru 0x2b1d7	(0x11368 bytes) to 0x5f7f8 thru 0x70b5f	******EEEE
6213093(229 mod 256): INSERT 0x11000 thru 0x14fff	(0x4000 bytes)
6213094(230 mod 256): MAPWRITE 0x25c11 thru 0x29ed0	(0x42c0 bytes)
6213095(231 mod 256): DEDUPE 0x4f000 thru 0x63fff	(0x15000 bytes) to 0x20000 thru 0x34fff
6213096(232 mod 256): FALLOC   0x1c4b6 thru 0x338d2	(0x1741c bytes) INTERIOR
6213097(233 mod 256): DEDUPE 0x26000 thru 0x3bfff	(0x16000 bytes) to 0xc000 thru 0x21fff
6213098(234 mod 256): PUNCH    0x5115 thru 0x1fa27	(0x1a913 bytes)
6213099(235 mod 256): DEDUPE 0xc000 thru 0x1dfff	(0x12000 bytes) to 0x59000 thru 0x6afff
6213100(236 mod 256): CLONE 0x16000 thru 0x19fff	(0x4000 bytes) to 0x20000 thru 0x23fff
6213101(237 mod 256): PUNCH    0x32b94 thru 0x4a0cc	(0x17539 bytes)
6213102(238 mod 256): CLONE 0x3000 thru 0x1dfff	(0x1b000 bytes) to 0x48000 thru 0x62fff
6213103(239 mod 256): MAPWRITE 0x6c95f thru 0x74369	(0x7a0b bytes)	******WWWW
6213104(240 mod 256): SKIPPED (no operation)
6213105(241 mod 256): DEDUPE 0x45000 thru 0x57fff	(0x13000 bytes) to 0xf000 thru 0x21fff
6213106(242 mod 256): COPY 0xfd43 thru 0x2167c	(0x1193a bytes) to 0x39103 thru 0x4aa3c
6213107(243 mod 256): READ     0x34821 thru 0x3c936	(0x8116 bytes)
6213108(244 mod 256): INSERT 0x3000 thru 0xdfff	(0xb000 bytes)
6213109(245 mod 256): MAPREAD  0x4580e thru 0x4838b	(0x2b7e bytes)
6213110(246 mod 256): CLONE 0x4d000 thru 0x4dfff	(0x1000 bytes) to 0x20000 thru 0x20fff
6213111(247 mod 256): MAPREAD  0x285a9 thru 0x2a328	(0x1d80 bytes)
6213112(248 mod 256): PUNCH    0x45a11 thru 0x4ce35	(0x7425 bytes)
6213113(249 mod 256): DEDUPE 0x8000 thru 0x1ffff	(0x18000 bytes) to 0x29000 thru 0x40fff
6213114(250 mod 256): TRUNCATE DOWN	from 0x7fb60 to 0x591ee	******WWWW
6213115(251 mod 256): CLONE 0x44000 thru 0x57fff	(0x14000 bytes) to 0x11000 thru 0x24fff
6213116(252 mod 256): COLLAPSE 0x4000 thru 0x9fff	(0x6000 bytes)
6213117(253 mod 256): MAPREAD  0x41601 thru 0x4ad0b	(0x970b bytes)
6213118(254 mod 256): SKIPPED (no operation)
6213119(255 mod 256): INSERT 0x33000 thru 0x48fff	(0x16000 bytes)
6213120(  0 mod 256): PUNCH    0x4c512 thru 0x5bc5f	(0xf74e bytes)
6213121(  1 mod 256): MAPWRITE 0x62422 thru 0x6406f	(0x1c4e bytes)
6213122(  2 mod 256): INSERT 0x52000 thru 0x5efff	(0xd000 bytes)
6213123(  3 mod 256): WRITE    0x2ea0d thru 0x48e81	(0x1a475 bytes)
6213124(  4 mod 256): ZERO     0x2aa98 thru 0x48aec	(0x1e055 bytes)
6213125(  5 mod 256): COPY 0x4885f thru 0x63cf9	(0x1b49b bytes) to 0x6c19a thru 0x87634	******EEEE
6213126(  6 mod 256): PUNCH    0x1050 thru 0x1de88	(0x1ce39 bytes)
6213127(  7 mod 256): MAPREAD  0x54c2e thru 0x6ae67	(0x1623a bytes)
6213128(  8 mod 256): INSERT 0x73000 thru 0x7dfff	(0xb000 bytes)
6213129(  9 mod 256): PUNCH    0x433cd thru 0x5d9df	(0x1a613 bytes)
6213130( 10 mod 256): PUNCH    0x51836 thru 0x5889a	(0x7065 bytes)
6213131( 11 mod 256): FALLOC   0x36660 thru 0x50303	(0x19ca3 bytes) INTERIOR
6213132( 12 mod 256): DEDUPE 0x8d000 thru 0x8efff	(0x2000 bytes) to 0x8b000 thru 0x8cfff
6213133( 13 mod 256): PUNCH    0x48b36 thru 0x64adb	(0x1bfa6 bytes)
6213134( 14 mod 256): TRUNCATE DOWN	from 0x92635 to 0x1415a	******WWWW
6213135( 15 mod 256): ZERO     0x6c34c thru 0x6ca3d	(0x6f2 bytes)
6213136( 16 mod 256): MAPWRITE 0x2e1bf thru 0x34c4d	(0x6a8f bytes)
6213137( 17 mod 256): PUNCH    0x1f386 thru 0x34c4d	(0x158c8 bytes)
6213138( 18 mod 256): INSERT 0x2000 thru 0x11fff	(0x10000 bytes)
6213139( 19 mod 256): COPY 0x37046 thru 0x44c4d	(0xdc08 bytes) to 0x46138 thru 0x53d3f
6213140( 20 mod 256): PUNCH    0x102a9 thru 0x29d12	(0x19a6a bytes)
6213141( 21 mod 256): DEDUPE 0x3e000 thru 0x52fff	(0x15000 bytes) to 0xe000 thru 0x22fff
6213142( 22 mod 256): COLLAPSE 0x4c000 thru 0x4efff	(0x3000 bytes)
6213143( 23 mod 256): WRITE    0x6c682 thru 0x84648	(0x17fc7 bytes) HOLE	***WWWW
6213144( 24 mod 256): TRUNCATE DOWN	from 0x84649 to 0x46f80	******WWWW
6213145( 25 mod 256): FALLOC   0x3bdb3 thru 0x4d3c9	(0x11616 bytes) PAST_EOF
6213146( 26 mod 256): READ     0x3dbe3 thru 0x46f7f	(0x939d bytes)
6213147( 27 mod 256): MAPREAD  0x27825 thru 0x42930	(0x1b10c bytes)
6213148( 28 mod 256): COLLAPSE 0x7000 thru 0x18fff	(0x12000 bytes)
6213149( 29 mod 256): TRUNCATE UP	from 0x34f80 to 0x54e0a
6213150( 30 mod 256): WRITE    0x17954 thru 0x1dfa9	(0x6656 bytes)
6213151( 31 mod 256): ZERO     0x6323c thru 0x7ea31	(0x1b7f6 bytes)	******ZZZZ
6213152( 32 mod 256): FALLOC   0x86657 thru 0x86a72	(0x41b bytes) EXTENDING
6213153( 33 mod 256): INSERT 0xe000 thru 0x18fff	(0xb000 bytes)
6213154( 34 mod 256): COLLAPSE 0x85000 thru 0x88fff	(0x4000 bytes)
6213155( 35 mod 256): CLONE 0x45000 thru 0x62fff	(0x1e000 bytes) to 0x4000 thru 0x21fff
6213156( 36 mod 256): MAPREAD  0x6f342 thru 0x84d0b	(0x159ca bytes)
6213157( 37 mod 256): COPY 0x173ae thru 0x30798	(0x193eb bytes) to 0x73d97 thru 0x8d181
6213158( 38 mod 256): COLLAPSE 0x23000 thru 0x28fff	(0x6000 bytes)
6213159( 39 mod 256): MAPREAD  0x82ed1 thru 0x87a71	(0x4ba1 bytes)
6213160( 40 mod 256): FALLOC   0x6d997 thru 0x727c3	(0x4e2c bytes) INTERIOR	******FFFF
6213161( 41 mod 256): MAPREAD  0x34160 thru 0x36ae5	(0x2986 bytes)
6213162( 42 mod 256): ZERO     0x50ac4 thru 0x5ad06	(0xa243 bytes)
6213163( 43 mod 256): SKIPPED (no operation)
6213164( 44 mod 256): PUNCH    0x3c881 thru 0x4610b	(0x988b bytes)
6213165( 45 mod 256): TRUNCATE DOWN	from 0x87a72 to 0x7318d
6213166( 46 mod 256): FALLOC   0x43817 thru 0x4da8b	(0xa274 bytes) INTERIOR
6213167( 47 mod 256): MAPREAD  0x60650 thru 0x6260b	(0x1fbc bytes)
6213168( 48 mod 256): PUNCH    0x2e312 thru 0x3bdd2	(0xdac1 bytes)
6213169( 49 mod 256): PUNCH    0x31c9f thru 0x40bcb	(0xef2d bytes)
6213170( 50 mod 256): COLLAPSE 0x2b000 thru 0x2ffff	(0x5000 bytes)
6213171( 51 mod 256): PUNCH    0x57465 thru 0x6d7b1	(0x1634d bytes)
6213172( 52 mod 256): MAPWRITE 0x3293a thru 0x420d2	(0xf799 bytes)
6213173( 53 mod 256): CLONE 0x62000 thru 0x6cfff	(0xb000 bytes) to 0x12000 thru 0x1cfff
6213174( 54 mod 256): CLONE 0xc000 thru 0x24fff	(0x19000 bytes) to 0x61000 thru 0x79fff	******JJJJ
6213175( 55 mod 256): ZERO     0x2b1d6 thru 0x3df7f	(0x12daa bytes)
6213176( 56 mod 256): WRITE    0x63557 thru 0x7a704	(0x171ae bytes) EXTEND	***WWWW
6213177( 57 mod 256): DEDUPE 0x15000 thru 0x2bfff	(0x17000 bytes) to 0x39000 thru 0x4ffff
6213178( 58 mod 256): WRITE    0x36223 thru 0x482d2	(0x120b0 bytes)
6213179( 59 mod 256): DEDUPE 0x3e000 thru 0x4bfff	(0xe000 bytes) to 0xa000 thru 0x17fff
6213180( 60 mod 256): TRUNCATE DOWN	from 0x7a705 to 0x23fd1	******WWWW
6213181( 61 mod 256): MAPWRITE 0x35039 thru 0x3f832	(0xa7fa bytes)
6213182( 62 mod 256): COPY 0x2cac0 thru 0x3f832	(0x12d73 bytes) to 0x51f1a thru 0x64c8c
6213183( 63 mod 256): ZERO     0x32e06 thru 0x338fb	(0xaf6 bytes)
6213184( 64 mod 256): CLONE 0x4e000 thru 0x62fff	(0x15000 bytes) to 0x75000 thru 0x89fff
6213185( 65 mod 256): DEDUPE 0x5a000 thru 0x60fff	(0x7000 bytes) to 0x72000 thru 0x78fff
6213186( 66 mod 256): SKIPPED (no operation)
6213187( 67 mod 256): TRUNCATE DOWN	from 0x8a000 to 0x1ca1a	******WWWW
6213188( 68 mod 256): SKIPPED (no operation)
6213189( 69 mod 256): DEDUPE 0x10000 thru 0x1bfff	(0xc000 bytes) to 0x0 thru 0xbfff
6213190( 70 mod 256): READ     0xb780 thru 0x1ca19	(0x1129a bytes)
6213191( 71 mod 256): DEDUPE 0x15000 thru 0x1bfff	(0x7000 bytes) to 0x8000 thru 0xefff
6213192( 72 mod 256): COPY 0xcdbd thru 0x1936a	(0xc5ae bytes) to 0x7a856 thru 0x86e03
6213193( 73 mod 256): PUNCH    0x54d1b thru 0x6ace1	(0x15fc7 bytes)
6213194( 74 mod 256): MAPREAD  0x32c5a thru 0x4dee9	(0x1b290 bytes)
6213195( 75 mod 256): WRITE    0x59720 thru 0x73948	(0x1a229 bytes)	***WWWW
6213196( 76 mod 256): WRITE    0x6321c thru 0x7dabc	(0x1a8a1 bytes)	***WWWW
6213197( 77 mod 256): INSERT 0x9000 thru 0x13fff	(0xb000 bytes)
6213198( 78 mod 256): WRITE    0x27f06 thru 0x2d767	(0x5862 bytes)
6213199( 79 mod 256): WRITE    0x82193 thru 0x91005	(0xee73 bytes)
6213200( 80 mod 256): FALLOC   0x534fc thru 0x6654d	(0x13051 bytes) INTERIOR
6213201( 81 mod 256): FALLOC   0x5bbc0 thru 0x755c0	(0x19a00 bytes) INTERIOR	******FFFF
6213202( 82 mod 256): FALLOC   0x18f61 thru 0x1a221	(0x12c0 bytes) INTERIOR
6213203( 83 mod 256): DEDUPE 0x1b000 thru 0x1ffff	(0x5000 bytes) to 0x34000 thru 0x38fff
6213204( 84 mod 256): MAPREAD  0x62fce thru 0x80533	(0x1d566 bytes)	***RRRR***
6213205( 85 mod 256): MAPWRITE 0x7d3d7 thru 0x875e4	(0xa20e bytes)
6213206( 86 mod 256): SKIPPED (no operation)
6213207( 87 mod 256): PUNCH    0x9bf thru 0x4c4e	(0x4290 bytes)
6213208( 88 mod 256): ZERO     0x3e23a thru 0x53d8b	(0x15b52 bytes)
6213209( 89 mod 256): PUNCH    0x465dc thru 0x51325	(0xad4a bytes)
6213210( 90 mod 256): COLLAPSE 0x7b000 thru 0x8ffff	(0x15000 bytes)
6213211( 91 mod 256): MAPWRITE 0x10a16 thru 0x1cf2c	(0xc517 bytes)
6213212( 92 mod 256): MAPREAD  0x100b thru 0x3d6a	(0x2d60 bytes)
6213213( 93 mod 256): FALLOC   0x67817 thru 0x7c70d	(0x14ef6 bytes) INTERIOR	******FFFF
6213214( 94 mod 256): TRUNCATE DOWN	from 0x7ce04 to 0x5dbf9	******WWWW
6213215( 95 mod 256): FALLOC   0xd61a thru 0xdd2c	(0x712 bytes) INTERIOR
6213216( 96 mod 256): MAPREAD  0x35dec thru 0x484fb	(0x12710 bytes)
6213217( 97 mod 256): WRITE    0x44533 thru 0x51b16	(0xd5e4 bytes)
6213218( 98 mod 256): MAPREAD  0x35aff thru 0x3843f	(0x2941 bytes)
6213219( 99 mod 256): WRITE    0x8d324 thru 0x927bf	(0x549c bytes) HOLE	***WWWW
6213220(100 mod 256): DEDUPE 0x7e000 thru 0x8dfff	(0x10000 bytes) to 0x43000 thru 0x52fff
6213221(101 mod 256): COPY 0x8b59a thru 0x927bf	(0x7226 bytes) to 0x2a1f thru 0x9c44
6213222(102 mod 256): SKIPPED (no operation)
6213223(103 mod 256): MAPWRITE 0x78828 thru 0x88b9d	(0x10376 bytes)
6213224(104 mod 256): COPY 0x3752d thru 0x3fd32	(0x8806 bytes) to 0x43404 thru 0x4bc09
6213225(105 mod 256): CLONE 0x6d000 thru 0x6ffff	(0x3000 bytes) to 0x5a000 thru 0x5cfff	JJJJ******
6213226(106 mod 256): ZERO     0x2c9e0 thru 0x3dba5	(0x111c6 bytes)
6213227(107 mod 256): WRITE    0x5c182 thru 0x732f1	(0x17170 bytes)	***WWWW
6213228(108 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x574e0	******WWWW
6213229(109 mod 256): SKIPPED (no operation)
6213230(110 mod 256): INSERT 0x0 thru 0x13fff	(0x14000 bytes)
6213231(111 mod 256): COPY 0x42f36 thru 0x4ecdc	(0xbda7 bytes) to 0x74b35 thru 0x808db
6213232(112 mod 256): COPY 0x1c176 thru 0x291d1	(0xd05c bytes) to 0x563e3 thru 0x6343e
6213233(113 mod 256): INSERT 0x4e000 thru 0x5efff	(0x11000 bytes)
6213234(114 mod 256): COLLAPSE 0x7d000 thru 0x8ffff	(0x13000 bytes)
6213235(115 mod 256): SKIPPED (no operation)
6213236(116 mod 256): MAPWRITE 0x684a8 thru 0x7efa0	(0x16af9 bytes)	******WWWW
6213237(117 mod 256): READ     0x68379 thru 0x695ac	(0x1234 bytes)
6213238(118 mod 256): SKIPPED (no operation)
6213239(119 mod 256): COPY 0x4e332 thru 0x5e87c	(0x1054b bytes) to 0x3a8b7 thru 0x4ae01
6213240(120 mod 256): INSERT 0x50000 thru 0x5cfff	(0xd000 bytes)
6213241(121 mod 256): SKIPPED (no operation)
6213242(122 mod 256): MAPWRITE 0x74bb7 thru 0x84050	(0xf49a bytes)
6213243(123 mod 256): PUNCH    0x882a7 thru 0x8bfa0	(0x3cfa bytes)
6213244(124 mod 256): MAPWRITE 0x3479d thru 0x3c10e	(0x7972 bytes)
6213245(125 mod 256): SKIPPED (no operation)
6213246(126 mod 256): INSERT 0x85000 thru 0x8afff	(0x6000 bytes)
6213247(127 mod 256): MAPWRITE 0x54f0f thru 0x5f5a0	(0xa692 bytes)
6213248(128 mod 256): SKIPPED (no operation)
6213249(129 mod 256): WRITE    0x52337 thru 0x65a83	(0x1374d bytes)
6213250(130 mod 256): COPY 0x1eccf thru 0x299c8	(0xacfa bytes) to 0x6ca22 thru 0x7771b	******EEEE
6213251(131 mod 256): MAPREAD  0x70963 thru 0x820c1	(0x1175f bytes)
6213252(132 mod 256): FALLOC   0x606ae thru 0x6c63a	(0xbf8c bytes) INTERIOR
6213253(133 mod 256): SKIPPED (no operation)
6213254(134 mod 256): CLONE 0xc000 thru 0x14fff	(0x9000 bytes) to 0x25000 thru 0x2dfff
6213255(135 mod 256): READ     0x4b7b2 thru 0x66897	(0x1b0e6 bytes)
6213256(136 mod 256): SKIPPED (no operation)
6213257(137 mod 256): SKIPPED (no operation)
6213258(138 mod 256): CLONE 0x9000 thru 0x19fff	(0x11000 bytes) to 0x46000 thru 0x56fff
6213259(139 mod 256): COLLAPSE 0xd000 thru 0x22fff	(0x16000 bytes)
6213260(140 mod 256): CLONE 0x18000 thru 0x31fff	(0x1a000 bytes) to 0x69000 thru 0x82fff	******JJJJ
6213261(141 mod 256): PUNCH    0x5ac61 thru 0x7103a	(0x163da bytes)	******PPPP
6213262(142 mod 256): COLLAPSE 0xd000 thru 0x20fff	(0x14000 bytes)
6213263(143 mod 256): MAPREAD  0x759d thru 0x1b988	(0x143ec bytes)
6213264(144 mod 256): COPY 0xf0ea thru 0x21014	(0x11f2b bytes) to 0x72783 thru 0x846ad
6213265(145 mod 256): INSERT 0x71000 thru 0x7efff	(0xe000 bytes)
6213266(146 mod 256): READ     0x2c17b thru 0x43932	(0x177b8 bytes)
6213267(147 mod 256): DEDUPE 0x1c000 thru 0x2ffff	(0x14000 bytes) to 0x6000 thru 0x19fff
6213268(148 mod 256): SKIPPED (no operation)
6213269(149 mod 256): DEDUPE 0x48000 thru 0x4efff	(0x7000 bytes) to 0xe000 thru 0x14fff
6213270(150 mod 256): FALLOC   0x2e910 thru 0x43fec	(0x156dc bytes) INTERIOR
6213271(151 mod 256): WRITE    0x568ff thru 0x5a8d7	(0x3fd9 bytes)
6213272(152 mod 256): WRITE    0x48ca6 thru 0x5a130	(0x1148b bytes)
6213273(153 mod 256): DEDUPE 0x7d000 thru 0x85fff	(0x9000 bytes) to 0x23000 thru 0x2bfff
6213274(154 mod 256): DEDUPE 0x38000 thru 0x4ffff	(0x18000 bytes) to 0x72000 thru 0x89fff
6213275(155 mod 256): MAPWRITE 0x19eb5 thru 0x1d26e	(0x33ba bytes)
6213276(156 mod 256): MAPREAD  0x87cb8 thru 0x926ad	(0xa9f6 bytes)
6213277(157 mod 256): ZERO     0x67d89 thru 0x72274	(0xa4ec bytes)	******ZZZZ
6213278(158 mod 256): TRUNCATE DOWN	from 0x926ae to 0x45dab	******WWWW
6213279(159 mod 256): DEDUPE 0x16000 thru 0x17fff	(0x2000 bytes) to 0x3b000 thru 0x3cfff
6213280(160 mod 256): INSERT 0x2a000 thru 0x2dfff	(0x4000 bytes)
6213281(161 mod 256): READ     0x2b532 thru 0x3b086	(0xfb55 bytes)
6213282(162 mod 256): CLONE 0x7000 thru 0x1cfff	(0x16000 bytes) to 0x22000 thru 0x37fff
6213283(163 mod 256): READ     0xaf2 thru 0xd497	(0xc9a6 bytes)
6213284(164 mod 256): READ     0x14a98 thru 0x2d311	(0x1887a bytes)
6213285(165 mod 256): TRUNCATE UP	from 0x49dab to 0x8bec1	******WWWW
6213286(166 mod 256): FALLOC   0x66433 thru 0x702d9	(0x9ea6 bytes) INTERIOR	******FFFF
6213287(167 mod 256): SKIPPED (no operation)
6213288(168 mod 256): INSERT 0x55000 thru 0x5afff	(0x6000 bytes)
6213289(169 mod 256): WRITE    0x1011f thru 0x1434a	(0x422c bytes)
6213290(170 mod 256): COPY 0x3f3f0 thru 0x570ea	(0x17cfb bytes) to 0x1ca10 thru 0x3470a
6213291(171 mod 256): FALLOC   0x105c2 thru 0x1faf0	(0xf52e bytes) INTERIOR
6213292(172 mod 256): TRUNCATE DOWN	from 0x91ec1 to 0x9076e
6213293(173 mod 256): DEDUPE 0x82000 thru 0x8efff	(0xd000 bytes) to 0x37000 thru 0x43fff
6213294(174 mod 256): COLLAPSE 0x2c000 thru 0x2efff	(0x3000 bytes)
6213295(175 mod 256): MAPREAD  0x79e6f thru 0x8d76d	(0x138ff bytes)
6213296(176 mod 256): PUNCH    0x5fde6 thru 0x7112b	(0x11346 bytes)	******PPPP
6213297(177 mod 256): PUNCH    0x3f30 thru 0xefc2	(0xb093 bytes)
6213298(178 mod 256): COLLAPSE 0x2000 thru 0x7fff	(0x6000 bytes)
6213299(179 mod 256): DEDUPE 0x3c000 thru 0x3cfff	(0x1000 bytes) to 0x45000 thru 0x45fff
6213300(180 mod 256): COLLAPSE 0x52000 thru 0x55fff	(0x4000 bytes)
6213301(181 mod 256): MAPREAD  0x5953d thru 0x65bde	(0xc6a2 bytes)
6213302(182 mod 256): COPY 0x7141b thru 0x7a6fb	(0x92e1 bytes) to 0x2be59 thru 0x35139
6213303(183 mod 256): CLONE 0x7e000 thru 0x82fff	(0x5000 bytes) to 0x58000 thru 0x5cfff
6213304(184 mod 256): CLONE 0x71000 thru 0x82fff	(0x12000 bytes) to 0x24000 thru 0x35fff
6213305(185 mod 256): MAPREAD  0x49948 thru 0x5f692	(0x15d4b bytes)
6213306(186 mod 256): TRUNCATE DOWN	from 0x8376e to 0x1cb2	******WWWW
6213307(187 mod 256): WRITE    0x1785d thru 0x23c7a	(0xc41e bytes) HOLE
6213308(188 mod 256): INSERT 0x8000 thru 0x21fff	(0x1a000 bytes)
6213309(189 mod 256): MAPREAD  0x1566f thru 0x24d0b	(0xf69d bytes)
6213310(190 mod 256): INSERT 0x25000 thru 0x28fff	(0x4000 bytes)
6213311(191 mod 256): SKIPPED (no operation)
6213312(192 mod 256): PUNCH    0xd737 thru 0x1feeb	(0x127b5 bytes)
6213313(193 mod 256): FALLOC   0x50a79 thru 0x6a722	(0x19ca9 bytes) EXTENDING
6213314(194 mod 256): FALLOC   0x544b4 thru 0x6464a	(0x10196 bytes) INTERIOR
6213315(195 mod 256): PUNCH    0x4d04f thru 0x6570f	(0x186c1 bytes)
6213316(196 mod 256): INSERT 0x17000 thru 0x18fff	(0x2000 bytes)
6213317(197 mod 256): FALLOC   0x69dc8 thru 0x87e16	(0x1e04e bytes) EXTENDING	******FFFF
6213318(198 mod 256): MAPREAD  0x39f27 thru 0x41f34	(0x800e bytes)
6213319(199 mod 256): PUNCH    0x37dd4 thru 0x522e7	(0x1a514 bytes)
6213320(200 mod 256): FALLOC   0x58980 thru 0x6a421	(0x11aa1 bytes) INTERIOR
6213321(201 mod 256): COLLAPSE 0x69000 thru 0x72fff	(0xa000 bytes)	******CCCC
6213322(202 mod 256): FALLOC   0x4f59a thru 0x6216e	(0x12bd4 bytes) INTERIOR
6213323(203 mod 256): MAPREAD  0x63bdb thru 0x653ab	(0x17d1 bytes)
6213324(204 mod 256): CLONE 0x4a000 thru 0x67fff	(0x1e000 bytes) to 0x6d000 thru 0x8afff	******JJJJ
6213325(205 mod 256): CLONE 0x20000 thru 0x2ffff	(0x10000 bytes) to 0x7c000 thru 0x8bfff
6213326(206 mod 256): COPY 0x55700 thru 0x620ed	(0xc9ee bytes) to 0x77e50 thru 0x8483d
6213327(207 mod 256): INSERT 0x44000 thru 0x49fff	(0x6000 bytes)
6213328(208 mod 256): SKIPPED (no operation)
6213329(209 mod 256): FALLOC   0x5dc5f thru 0x688b5	(0xac56 bytes) INTERIOR
6213330(210 mod 256): CLONE 0x33000 thru 0x36fff	(0x4000 bytes) to 0x39000 thru 0x3cfff
6213331(211 mod 256): READ     0x4c68 thru 0x17a29	(0x12dc2 bytes)
6213332(212 mod 256): MAPREAD  0x8bac6 thru 0x91fff	(0x653a bytes)
6213333(213 mod 256): COPY 0x1f973 thru 0x27764	(0x7df2 bytes) to 0x16881 thru 0x1e672
6213334(214 mod 256): COPY 0x85132 thru 0x91fff	(0xcece bytes) to 0x1f803 thru 0x2c6d0
6213335(215 mod 256): PUNCH    0x2c788 thru 0x43709	(0x16f82 bytes)
6213336(216 mod 256): DEDUPE 0x4000 thru 0x6fff	(0x3000 bytes) to 0x8a000 thru 0x8cfff
6213337(217 mod 256): ZERO     0x837f6 thru 0x927bf	(0xefca bytes)
6213338(218 mod 256): COLLAPSE 0x7d000 thru 0x85fff	(0x9000 bytes)
6213339(219 mod 256): DEDUPE 0x47000 thru 0x5ffff	(0x19000 bytes) to 0x18000 thru 0x30fff
6213340(220 mod 256): DEDUPE 0x7e000 thru 0x7efff	(0x1000 bytes) to 0x2f000 thru 0x2ffff
6213341(221 mod 256): INSERT 0x5000 thru 0x6fff	(0x2000 bytes)
6213342(222 mod 256): SKIPPED (no operation)
6213343(223 mod 256): READ     0x657b6 thru 0x7ebac	(0x193f7 bytes)	***RRRR***
6213344(224 mod 256): FALLOC   0x47331 thru 0x5f55b	(0x1822a bytes) INTERIOR
6213345(225 mod 256): WRITE    0x5653 thru 0x2306a	(0x1da18 bytes)
6213346(226 mod 256): MAPWRITE 0x6fcbe thru 0x75079	(0x53bc bytes)
6213347(227 mod 256): TRUNCATE DOWN	from 0x8b7c0 to 0x6e3bb	******WWWW
6213348(228 mod 256): WRITE    0x52f99 thru 0x6051e	(0xd586 bytes)
6213349(229 mod 256): READ     0x6484b thru 0x6e3ba	(0x9b70 bytes)
6213350(230 mod 256): WRITE    0x2b658 thru 0x3dfbf	(0x12968 bytes)
6213351(231 mod 256): DEDUPE 0x31000 thru 0x3efff	(0xe000 bytes) to 0x9000 thru 0x16fff
6213352(232 mod 256): PUNCH    0x103cd thru 0x12403	(0x2037 bytes)
6213353(233 mod 256): SKIPPED (no operation)
6213354(234 mod 256): MAPREAD  0x24871 thru 0x34362	(0xfaf2 bytes)
6213355(235 mod 256): CLONE 0x13000 thru 0x1cfff	(0xa000 bytes) to 0x23000 thru 0x2cfff
6213356(236 mod 256): CLONE 0x37000 thru 0x3efff	(0x8000 bytes) to 0x62000 thru 0x69fff
6213357(237 mod 256): READ     0x3ff46 thru 0x47fd2	(0x808d bytes)
6213358(238 mod 256): INSERT 0x64000 thru 0x78fff	(0x15000 bytes)	******IIII
6213359(239 mod 256): DEDUPE 0x1d000 thru 0x30fff	(0x14000 bytes) to 0x59000 thru 0x6cfff
6213360(240 mod 256): WRITE    0x1b2c5 thru 0x1baab	(0x7e7 bytes)
6213361(241 mod 256): COLLAPSE 0x2c000 thru 0x46fff	(0x1b000 bytes)
6213362(242 mod 256): TRUNCATE DOWN	from 0x683bb to 0x44be5
6213363(243 mod 256): DEDUPE 0x42000 thru 0x43fff	(0x2000 bytes) to 0x2d000 thru 0x2efff
6213364(244 mod 256): DEDUPE 0x19000 thru 0x27fff	(0xf000 bytes) to 0x29000 thru 0x37fff
6213365(245 mod 256): INSERT 0x19000 thru 0x1efff	(0x6000 bytes)
6213366(246 mod 256): FALLOC   0x815cc thru 0x908d3	(0xf307 bytes) EXTENDING
6213367(247 mod 256): MAPWRITE 0x76ca6 thru 0x87865	(0x10bc0 bytes)
6213368(248 mod 256): COPY 0x3ec65 thru 0x46da7	(0x8143 bytes) to 0xa9c4 thru 0x12b06
6213369(249 mod 256): SKIPPED (no operation)
6213370(250 mod 256): DEDUPE 0x40000 thru 0x57fff	(0x18000 bytes) to 0x10000 thru 0x27fff
6213371(251 mod 256): MAPWRITE 0x4dd42 thru 0x63e87	(0x16146 bytes)
6213372(252 mod 256): READ     0x288c3 thru 0x366c3	(0xde01 bytes)
6213373(253 mod 256): WRITE    0x347e8 thru 0x44f99	(0x107b2 bytes)
6213374(254 mod 256): ZERO     0x7741b thru 0x7cc67	(0x584d bytes)
6213375(255 mod 256): COPY 0x23ae9 thru 0x3f6e0	(0x1bbf8 bytes) to 0x426db thru 0x5e2d2
6213376(  0 mod 256): MAPREAD  0x27956 thru 0x451a3	(0x1d84e bytes)
6213377(  1 mod 256): SKIPPED (no operation)
6213378(  2 mod 256): MAPWRITE 0x919f thru 0x1b690	(0x124f2 bytes)
6213379(  3 mod 256): DEDUPE 0x0 thru 0xbfff	(0xc000 bytes) to 0x72000 thru 0x7dfff
6213380(  4 mod 256): INSERT 0x8f000 thru 0x8ffff	(0x1000 bytes)
6213381(  5 mod 256): DEDUPE 0x36000 thru 0x51fff	(0x1c000 bytes) to 0x72000 thru 0x8dfff
6213382(  6 mod 256): SKIPPED (no operation)
6213383(  7 mod 256): MAPWRITE 0x12d4a thru 0x27568	(0x1481f bytes)
6213384(  8 mod 256): READ     0x1807c thru 0x32178	(0x1a0fd bytes)
6213385(  9 mod 256): DEDUPE 0x7a000 thru 0x8efff	(0x15000 bytes) to 0x33000 thru 0x47fff
6213386( 10 mod 256): FALLOC   0x3f720 thru 0x50c85	(0x11565 bytes) INTERIOR
6213387( 11 mod 256): WRITE    0x70dd thru 0xa253	(0x3177 bytes)
6213388( 12 mod 256): READ     0x1eaa9 thru 0x29916	(0xae6e bytes)
6213389( 13 mod 256): DEDUPE 0x4a000 thru 0x64fff	(0x1b000 bytes) to 0x25000 thru 0x3ffff
6213390( 14 mod 256): SKIPPED (no operation)
6213391( 15 mod 256): MAPWRITE 0x2af4e thru 0x40b92	(0x15c45 bytes)
6213392( 16 mod 256): COLLAPSE 0x6a000 thru 0x82fff	(0x19000 bytes)	******CCCC
6213393( 17 mod 256): CLONE 0x5a000 thru 0x63fff	(0xa000 bytes) to 0x4b000 thru 0x54fff
6213394( 18 mod 256): CLONE 0x44000 thru 0x5dfff	(0x1a000 bytes) to 0x1d000 thru 0x36fff
6213395( 19 mod 256): ZERO     0x1b071 thru 0x39aef	(0x1ea7f bytes)
6213396( 20 mod 256): WRITE    0xbbd9 thru 0x1f030	(0x13458 bytes)
6213397( 21 mod 256): FALLOC   0x4f88 thru 0xcefa	(0x7f72 bytes) INTERIOR
6213398( 22 mod 256): ZERO     0x7ab0a thru 0x927bf	(0x17cb6 bytes)
6213399( 23 mod 256): READ     0x2c046 thru 0x359ce	(0x9989 bytes)
6213400( 24 mod 256): READ     0x76c62 thru 0x8398d	(0xcd2c bytes)
6213401( 25 mod 256): SKIPPED (no operation)
6213402( 26 mod 256): MAPREAD  0x3e70f thru 0x4db3e	(0xf430 bytes)
6213403( 27 mod 256): FALLOC   0x23ddf thru 0x29a2f	(0x5c50 bytes) INTERIOR
6213404( 28 mod 256): COPY 0x45b23 thru 0x583b3	(0x12891 bytes) to 0x775dc thru 0x89e6c
6213405( 29 mod 256): CLONE 0x17000 thru 0x30fff	(0x1a000 bytes) to 0x4e000 thru 0x67fff
6213406( 30 mod 256): SKIPPED (no operation)
6213407( 31 mod 256): PUNCH    0xbacb thru 0x1355a	(0x7a90 bytes)
6213408( 32 mod 256): COPY 0x802ad thru 0x86114	(0x5e68 bytes) to 0x6cfc2 thru 0x72e29	******EEEE
6213409( 33 mod 256): MAPREAD  0x82bfa thru 0x927bf	(0xfbc6 bytes)
6213410( 34 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x773ac
6213411( 35 mod 256): READ     0x32f5a thru 0x3bbf4	(0x8c9b bytes)
6213412( 36 mod 256): TRUNCATE DOWN	from 0x773ac to 0x2f192	******WWWW
6213413( 37 mod 256): PUNCH    0x28b72 thru 0x2f191	(0x6620 bytes)
6213414( 38 mod 256): DEDUPE 0x3000 thru 0x9fff	(0x7000 bytes) to 0x13000 thru 0x19fff
6213415( 39 mod 256): FALLOC   0x8f18c thru 0x927c0	(0x3634 bytes) EXTENDING
6213416( 40 mod 256): SKIPPED (no operation)
6213417( 41 mod 256): FALLOC   0x50ea3 thru 0x6ba83	(0x1abe0 bytes) INTERIOR
6213418( 42 mod 256): CLONE 0x5a000 thru 0x68fff	(0xf000 bytes) to 0x31000 thru 0x3ffff
6213419( 43 mod 256): READ     0xf8b2 thru 0x21e70	(0x125bf bytes)
6213420( 44 mod 256): MAPWRITE 0x916ee thru 0x927bf	(0x10d2 bytes)
6213421( 45 mod 256): DEDUPE 0x48000 thru 0x4efff	(0x7000 bytes) to 0x57000 thru 0x5dfff
6213422( 46 mod 256): ZERO     0x4ba25 thru 0x60f86	(0x15562 bytes)
6213423( 47 mod 256): WRITE    0x1b306 thru 0x31f2d	(0x16c28 bytes)
6213424( 48 mod 256): READ     0x1e345 thru 0x3501a	(0x16cd6 bytes)
6213425( 49 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x8441d
6213426( 50 mod 256): MAPREAD  0x12007 thru 0x22751	(0x1074b bytes)
6213427( 51 mod 256): CLONE 0x17000 thru 0x30fff	(0x1a000 bytes) to 0x69000 thru 0x82fff	******JJJJ
6213428( 52 mod 256): WRITE    0x80d6a thru 0x848c3	(0x3b5a bytes) EXTEND
6213429( 53 mod 256): WRITE    0x9a50 thru 0x12fbb	(0x956c bytes)
6213430( 54 mod 256): SKIPPED (no operation)
6213431( 55 mod 256): INSERT 0x51000 thru 0x5dfff	(0xd000 bytes)
6213432( 56 mod 256): CLONE 0x63000 thru 0x6efff	(0xc000 bytes) to 0x30000 thru 0x3bfff	JJJJ******
6213433( 57 mod 256): MAPWRITE 0x82f7f thru 0x88071	(0x50f3 bytes)
6213434( 58 mod 256): PUNCH    0x52b72 thru 0x5c1e1	(0x9670 bytes)
6213435( 59 mod 256): READ     0x8f4ab thru 0x918c3	(0x2419 bytes)
6213436( 60 mod 256): WRITE    0x83530 thru 0x91c17	(0xe6e8 bytes) EXTEND
6213437( 61 mod 256): ZERO     0x83f1e thru 0x87b43	(0x3c26 bytes)
6213438( 62 mod 256): TRUNCATE DOWN	from 0x91c18 to 0x86c3c
6213439( 63 mod 256): INSERT 0x80000 thru 0x8afff	(0xb000 bytes)
6213440( 64 mod 256): MAPREAD  0x23b83 thru 0x3029d	(0xc71b bytes)
6213441( 65 mod 256): MAPWRITE 0x7a6c thru 0xac56	(0x31eb bytes)
6213442( 66 mod 256): ZERO     0x82dc4 thru 0x927bf	(0xf9fc bytes)
6213443( 67 mod 256): WRITE    0xae26 thru 0xc0e6	(0x12c1 bytes)
6213444( 68 mod 256): COPY 0x65906 thru 0x7502d	(0xf728 bytes) to 0x75b00 thru 0x85227	EEEE******
6213445( 69 mod 256): COPY 0x588e9 thru 0x6985b	(0x10f73 bytes) to 0x27735 thru 0x386a7
6213446( 70 mod 256): MAPWRITE 0x80beb thru 0x8cd08	(0xc11e bytes)
6213447( 71 mod 256): CLONE 0x7d000 thru 0x7dfff	(0x1000 bytes) to 0x84000 thru 0x84fff
6213448( 72 mod 256): READ     0x9076f thru 0x927bf	(0x2051 bytes)
6213449( 73 mod 256): CLONE 0x4d000 thru 0x58fff	(0xc000 bytes) to 0x7c000 thru 0x87fff
6213450( 74 mod 256): PUNCH    0x5f7df thru 0x6a838	(0xb05a bytes)
6213451( 75 mod 256): MAPREAD  0x1d802 thru 0x28b07	(0xb306 bytes)
6213452( 76 mod 256): DEDUPE 0x3d000 thru 0x4efff	(0x12000 bytes) to 0xf000 thru 0x20fff
6213453( 77 mod 256): CLONE 0x80000 thru 0x91fff	(0x12000 bytes) to 0x69000 thru 0x7afff	******JJJJ
6213454( 78 mod 256): MAPREAD  0x8cf5c thru 0x8fa0c	(0x2ab1 bytes)
6213455( 79 mod 256): MAPREAD  0x207bb thru 0x39d5d	(0x195a3 bytes)
6213456( 80 mod 256): CLONE 0x39000 thru 0x4bfff	(0x13000 bytes) to 0x22000 thru 0x34fff
6213457( 81 mod 256): MAPWRITE 0x5ce96 thru 0x657eb	(0x8956 bytes)
6213458( 82 mod 256): ZERO     0x52f48 thru 0x6a95f	(0x17a18 bytes)
6213459( 83 mod 256): MAPWRITE 0x741c4 thru 0x7f6ab	(0xb4e8 bytes)
6213460( 84 mod 256): MAPWRITE 0x2b86f thru 0x31046	(0x57d8 bytes)
6213461( 85 mod 256): WRITE    0x4c5a3 thru 0x68832	(0x1c290 bytes)
6213462( 86 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x1ff4a	******WWWW
6213463( 87 mod 256): COPY 0x19dce thru 0x1ff49	(0x617c bytes) to 0x64d92 thru 0x6af0d
6213464( 88 mod 256): SKIPPED (no operation)
6213465( 89 mod 256): PUNCH    0x1b49d thru 0x33bbc	(0x18720 bytes)
6213466( 90 mod 256): DEDUPE 0x1d000 thru 0x2efff	(0x12000 bytes) to 0x36000 thru 0x47fff
6213467( 91 mod 256): FALLOC   0x30230 thru 0x33946	(0x3716 bytes) INTERIOR
6213468( 92 mod 256): FALLOC   0x70ad5 thru 0x816e4	(0x10c0f bytes) EXTENDING
6213469( 93 mod 256): FALLOC   0x29011 thru 0x39aa3	(0x10a92 bytes) INTERIOR
6213470( 94 mod 256): WRITE    0x5b6d5 thru 0x76c18	(0x1b544 bytes)	***WWWW
6213471( 95 mod 256): SKIPPED (no operation)
6213472( 96 mod 256): INSERT 0x18000 thru 0x26fff	(0xf000 bytes)
6213473( 97 mod 256): READ     0x1999c thru 0x3780b	(0x1de70 bytes)
6213474( 98 mod 256): DEDUPE 0x4d000 thru 0x64fff	(0x18000 bytes) to 0x24000 thru 0x3bfff
6213475( 99 mod 256): FALLOC   0x711b4 thru 0x82047	(0x10e93 bytes) INTERIOR
6213476(100 mod 256): FALLOC   0x194c7 thru 0x33949	(0x1a482 bytes) INTERIOR
6213477(101 mod 256): DEDUPE 0x5d000 thru 0x67fff	(0xb000 bytes) to 0x6a000 thru 0x74fff	******BBBB
6213478(102 mod 256): MAPREAD  0x14ecf thru 0x15780	(0x8b2 bytes)
6213479(103 mod 256): TRUNCATE DOWN	from 0x906e4 to 0x5dba5	******WWWW
6213480(104 mod 256): TRUNCATE DOWN	from 0x5dba5 to 0x33ac9
6213481(105 mod 256): WRITE    0x7125f thru 0x88cd6	(0x17a78 bytes) HOLE	***WWWW
6213482(106 mod 256): DEDUPE 0x65000 thru 0x80fff	(0x1c000 bytes) to 0x40000 thru 0x5bfff	BBBB******
6213483(107 mod 256): TRUNCATE DOWN	from 0x88cd7 to 0x3b04f	******WWWW
6213484(108 mod 256): WRITE    0x6866e thru 0x69b4c	(0x14df bytes) HOLE
6213485(109 mod 256): SKIPPED (no operation)
6213486(110 mod 256): INSERT 0x1d000 thru 0x32fff	(0x16000 bytes)
6213487(111 mod 256): READ     0x69017 thru 0x6b2ec	(0x22d6 bytes)
6213488(112 mod 256): COPY 0x6b636 thru 0x7fb4c	(0x14517 bytes) to 0xd8a8 thru 0x21dbe	EEEE******
6213489(113 mod 256): INSERT 0x3f000 thru 0x40fff	(0x2000 bytes)
6213490(114 mod 256): FALLOC   0x311b thru 0x18494	(0x15379 bytes) INTERIOR
6213491(115 mod 256): COPY 0x455e7 thru 0x4eefa	(0x9914 bytes) to 0x25d6c thru 0x2f67f
6213492(116 mod 256): ZERO     0x80b2b thru 0x81f1a	(0x13f0 bytes)
6213493(117 mod 256): COPY 0x58f23 thru 0x61ca9	(0x8d87 bytes) to 0xf933 thru 0x186b9
6213494(118 mod 256): MAPREAD  0x24696 thru 0x2ebdd	(0xa548 bytes)
6213495(119 mod 256): READ     0x2f723 thru 0x30d12	(0x15f0 bytes)
6213496(120 mod 256): SKIPPED (no operation)
6213497(121 mod 256): READ     0x3ee3 thru 0x186c6	(0x147e4 bytes)
6213498(122 mod 256): MAPREAD  0x41e55 thru 0x49b56	(0x7d02 bytes)
6213499(123 mod 256): COLLAPSE 0x67000 thru 0x7afff	(0x14000 bytes)	******CCCC
6213500(124 mod 256): MAPREAD  0x57ed5 thru 0x6be2f	(0x13f5b bytes)
6213501(125 mod 256): MAPREAD  0x44322 thru 0x4543a	(0x1119 bytes)
6213502(126 mod 256): MAPWRITE 0x22bf2 thru 0x33ad2	(0x10ee1 bytes)
6213503(127 mod 256): FALLOC   0x296d2 thru 0x37777	(0xe0a5 bytes) INTERIOR
6213504(128 mod 256): INSERT 0x11000 thru 0x16fff	(0x6000 bytes)
6213505(129 mod 256): INSERT 0x7000 thru 0x23fff	(0x1d000 bytes)
6213506(130 mod 256): WRITE    0x627a thru 0xfe4f	(0x9bd6 bytes)
6213507(131 mod 256): TRUNCATE DOWN	from 0x90b4d to 0x1c1c	******WWWW
6213508(132 mod 256): MAPWRITE 0x3a0b6 thru 0x4405f	(0x9faa bytes)
6213509(133 mod 256): CLONE 0x3b000 thru 0x42fff	(0x8000 bytes) to 0x50000 thru 0x57fff
6213510(134 mod 256): SKIPPED (no operation)
6213511(135 mod 256): DEDUPE 0x8000 thru 0xdfff	(0x6000 bytes) to 0x3c000 thru 0x41fff
6213512(136 mod 256): ZERO     0x5e339 thru 0x72ce1	(0x149a9 bytes)	******ZZZZ
6213513(137 mod 256): ZERO     0x2dc26 thru 0x353cb	(0x77a6 bytes)
6213514(138 mod 256): COLLAPSE 0x37000 thru 0x3dfff	(0x7000 bytes)
6213515(139 mod 256): READ     0x4853e thru 0x50fff	(0x8ac2 bytes)
6213516(140 mod 256): ZERO     0x30556 thru 0x4e520	(0x1dfcb bytes)
6213517(141 mod 256): CLONE 0x31000 thru 0x4afff	(0x1a000 bytes) to 0x0 thru 0x19fff
6213518(142 mod 256): WRITE    0x8d832 thru 0x927bf	(0x4f8e bytes) HOLE	***WWWW
6213519(143 mod 256): MAPWRITE 0x74ca1 thru 0x8ecc8	(0x1a028 bytes)
6213520(144 mod 256): PUNCH    0x56d8d thru 0x5f91d	(0x8b91 bytes)
6213521(145 mod 256): FALLOC   0x244fd thru 0x283ca	(0x3ecd bytes) INTERIOR
6213522(146 mod 256): WRITE    0x22575 thru 0x2b2af	(0x8d3b bytes)
6213523(147 mod 256): SKIPPED (no operation)
6213524(148 mod 256): FALLOC   0x45eaf thru 0x4b711	(0x5862 bytes) INTERIOR
6213525(149 mod 256): READ     0x612e5 thru 0x6e58c	(0xd2a8 bytes)
6213526(150 mod 256): PUNCH    0x834bb thru 0x90641	(0xd187 bytes)
6213527(151 mod 256): WRITE    0x2f811 thru 0x348bf	(0x50af bytes)
6213528(152 mod 256): MAPREAD  0x2d0c3 thru 0x4668a	(0x195c8 bytes)
6213529(153 mod 256): DEDUPE 0x7f000 thru 0x8afff	(0xc000 bytes) to 0x5c000 thru 0x67fff
6213530(154 mod 256): CLONE 0x2b000 thru 0x35fff	(0xb000 bytes) to 0x85000 thru 0x8ffff
6213531(155 mod 256): COPY 0x3a41 thru 0x1e804	(0x1adc4 bytes) to 0x634b4 thru 0x7e277	******EEEE
6213532(156 mod 256): ZERO     0x67d65 thru 0x753b7	(0xd653 bytes)	******ZZZZ
6213533(157 mod 256): SKIPPED (no operation)
6213534(158 mod 256): SKIPPED (no operation)
6213535(159 mod 256): FALLOC   0x79595 thru 0x8d2d5	(0x13d40 bytes) INTERIOR
6213536(160 mod 256): ZERO     0x2b398 thru 0x44887	(0x194f0 bytes)
6213537(161 mod 256): MAPWRITE 0x46f15 thru 0x4d6cd	(0x67b9 bytes)
6213538(162 mod 256): SKIPPED (no operation)
6213539(163 mod 256): READ     0x8144c thru 0x92189	(0x10d3e bytes)
6213540(164 mod 256): COLLAPSE 0x5f000 thru 0x6cfff	(0xe000 bytes)
6213541(165 mod 256): INSERT 0x71000 thru 0x7efff	(0xe000 bytes)
6213542(166 mod 256): SKIPPED (no operation)
6213543(167 mod 256): ZERO     0x2e358 thru 0x4ad6c	(0x1ca15 bytes)
6213544(168 mod 256): SKIPPED (no operation)
6213545(169 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x2cec0	******WWWW
6213546(170 mod 256): COLLAPSE 0x1000 thru 0x12fff	(0x12000 bytes)
6213547(171 mod 256): MAPWRITE 0x5a6a5 thru 0x71b45	(0x174a1 bytes)	******WWWW
6213548(172 mod 256): SKIPPED (no operation)
6213549(173 mod 256): SKIPPED (no operation)
6213550(174 mod 256): COLLAPSE 0xf000 thru 0xffff	(0x1000 bytes)
6213551(175 mod 256): CLONE 0x3d000 thru 0x5afff	(0x1e000 bytes) to 0x19000 thru 0x36fff
6213552(176 mod 256): INSERT 0x56000 thru 0x66fff	(0x11000 bytes)
6213553(177 mod 256): TRUNCATE UP	from 0x81b46 to 0x9005b
6213554(178 mod 256): SKIPPED (no operation)
6213555(179 mod 256): CLONE 0x24000 thru 0x29fff	(0x6000 bytes) to 0x89000 thru 0x8efff
6213556(180 mod 256): PUNCH    0x3ba66 thru 0x42570	(0x6b0b bytes)
6213557(181 mod 256): READ     0x55aad thru 0x6d053	(0x175a7 bytes)
6213558(182 mod 256): ZERO     0x5c513 thru 0x79ddd	(0x1d8cb bytes)	******ZZZZ
6213559(183 mod 256): MAPREAD  0x41e06 thru 0x609c0	(0x1ebbb bytes)
6213560(184 mod 256): MAPWRITE 0x1c664 thru 0x2aca4	(0xe641 bytes)
6213561(185 mod 256): CLONE 0x54000 thru 0x6dfff	(0x1a000 bytes) to 0xd000 thru 0x26fff
6213562(186 mod 256): COLLAPSE 0x20000 thru 0x2cfff	(0xd000 bytes)
6213563(187 mod 256): FALLOC   0x41466 thru 0x537d8	(0x12372 bytes) INTERIOR
6213564(188 mod 256): INSERT 0x39000 thru 0x45fff	(0xd000 bytes)
6213565(189 mod 256): SKIPPED (no operation)
6213566(190 mod 256): READ     0x5e7bd thru 0x73fb5	(0x157f9 bytes)	***RRRR***
6213567(191 mod 256): SKIPPED (no operation)
6213568(192 mod 256): MAPWRITE 0x79dd9 thru 0x8aed4	(0x110fc bytes)
6213569(193 mod 256): MAPWRITE 0x5207a thru 0x54004	(0x1f8b bytes)
6213570(194 mod 256): PUNCH    0x4928b thru 0x545f9	(0xb36f bytes)
6213571(195 mod 256): FALLOC   0x6bf6a thru 0x80278	(0x1430e bytes) INTERIOR	******FFFF
6213572(196 mod 256): COLLAPSE 0x2d000 thru 0x30fff	(0x4000 bytes)
6213573(197 mod 256): COPY 0x19745 thru 0x24544	(0xae00 bytes) to 0xbbda thru 0x169d9
6213574(198 mod 256): PUNCH    0xbf18 thru 0x27388	(0x1b471 bytes)
6213575(199 mod 256): COLLAPSE 0x89000 thru 0x8afff	(0x2000 bytes)
6213576(200 mod 256): MAPREAD  0x32f58 thru 0x3d822	(0xa8cb bytes)
6213577(201 mod 256): FALLOC   0x1d373 thru 0x20373	(0x3000 bytes) INTERIOR
6213578(202 mod 256): MAPWRITE 0x2e22a thru 0x3f530	(0x11307 bytes)
6213579(203 mod 256): COPY 0x695ec thru 0x6df4a	(0x495f bytes) to 0x1558a thru 0x19ee8
6213580(204 mod 256): FALLOC   0x556c0 thru 0x6fe4b	(0x1a78b bytes) INTERIOR	******FFFF
6213581(205 mod 256): PUNCH    0x60377 thru 0x7a7fb	(0x1a485 bytes)	******PPPP
6213582(206 mod 256): READ     0x3f998 thru 0x5137d	(0x119e6 bytes)
6213583(207 mod 256): DEDUPE 0x30000 thru 0x4cfff	(0x1d000 bytes) to 0xf000 thru 0x2bfff
6213584(208 mod 256): MAPWRITE 0x27169 thru 0x33c4e	(0xcae6 bytes)
6213585(209 mod 256): FALLOC   0x22083 thru 0x2e614	(0xc591 bytes) INTERIOR
6213586(210 mod 256): TRUNCATE DOWN	from 0x8a05b to 0x886d4
6213587(211 mod 256): FALLOC   0x228e6 thru 0x3d5c4	(0x1acde bytes) INTERIOR
6213588(212 mod 256): MAPWRITE 0x18c9c thru 0x22117	(0x947c bytes)
6213589(213 mod 256): MAPWRITE 0x5048c thru 0x67c9e	(0x17813 bytes)
6213590(214 mod 256): COPY 0x6697b thru 0x75b7c	(0xf202 bytes) to 0x3b0e6 thru 0x4a2e7	EEEE******
6213591(215 mod 256): SKIPPED (no operation)
6213592(216 mod 256): ZERO     0x706dc thru 0x71785	(0x10aa bytes)
6213593(217 mod 256): COLLAPSE 0x44000 thru 0x5efff	(0x1b000 bytes)
6213594(218 mod 256): DEDUPE 0x54000 thru 0x69fff	(0x16000 bytes) to 0xd000 thru 0x22fff
6213595(219 mod 256): CLONE 0x9000 thru 0x12fff	(0xa000 bytes) to 0x7a000 thru 0x83fff
6213596(220 mod 256): COPY 0x3bdba thru 0x3cd27	(0xf6e bytes) to 0x72d75 thru 0x73ce2
6213597(221 mod 256): DEDUPE 0x72000 thru 0x7dfff	(0xc000 bytes) to 0x1c000 thru 0x27fff
6213598(222 mod 256): COLLAPSE 0x31000 thru 0x3efff	(0xe000 bytes)
6213599(223 mod 256): WRITE    0xfa15 thru 0x1ac82	(0xb26e bytes)
6213600(224 mod 256): ZERO     0x15f68 thru 0x32c3d	(0x1ccd6 bytes)
6213601(225 mod 256): INSERT 0x6000 thru 0xbfff	(0x6000 bytes)
6213602(226 mod 256): FALLOC   0x88489 thru 0x8e268	(0x5ddf bytes) EXTENDING
6213603(227 mod 256): ZERO     0x7a581 thru 0x8ba78	(0x114f8 bytes)
6213604(228 mod 256): COLLAPSE 0x7a000 thru 0x85fff	(0xc000 bytes)
6213605(229 mod 256): COPY 0x1fbe7 thru 0x2cfe2	(0xd3fc bytes) to 0x4e11c thru 0x5b517
6213606(230 mod 256): INSERT 0x1e000 thru 0x28fff	(0xb000 bytes)
6213607(231 mod 256): PUNCH    0x85469 thru 0x8d267	(0x7dff bytes)
6213608(232 mod 256): WRITE    0x6916e thru 0x6a885	(0x1718 bytes)
6213609(233 mod 256): DEDUPE 0x62000 thru 0x7dfff	(0x1c000 bytes) to 0x1e000 thru 0x39fff	BBBB******
6213610(234 mod 256): WRITE    0x518e4 thru 0x62ec6	(0x115e3 bytes)
6213611(235 mod 256): READ     0x21056 thru 0x2f866	(0xe811 bytes)
6213612(236 mod 256): DEDUPE 0x2000 thru 0x15fff	(0x14000 bytes) to 0x1d000 thru 0x30fff
6213613(237 mod 256): FALLOC   0xebf4 thru 0x29663	(0x1aa6f bytes) INTERIOR
6213614(238 mod 256): PUNCH    0x94ae thru 0x10550	(0x70a3 bytes)
6213615(239 mod 256): SKIPPED (no operation)
6213616(240 mod 256): MAPREAD  0x3e131 thru 0x3f44b	(0x131b bytes)
6213617(241 mod 256): SKIPPED (no operation)
6213618(242 mod 256): SKIPPED (no operation)
6213619(243 mod 256): MAPREAD  0x12534 thru 0x1f9ca	(0xd497 bytes)
6213620(244 mod 256): PUNCH    0x7e0f6 thru 0x83054	(0x4f5f bytes)
6213621(245 mod 256): DEDUPE 0x6e000 thru 0x84fff	(0x17000 bytes) to 0x3000 thru 0x19fff	BBBB******
6213622(246 mod 256): FALLOC   0x226a6 thru 0x23adb	(0x1435 bytes) INTERIOR
6213623(247 mod 256): DEDUPE 0x2d000 thru 0x3ffff	(0x13000 bytes) to 0x4f000 thru 0x61fff
6213624(248 mod 256): READ     0x79303 thru 0x8b072	(0x11d70 bytes)
6213625(249 mod 256): MAPREAD  0x8340e thru 0x8d267	(0x9e5a bytes)
6213626(250 mod 256): PUNCH    0x5d1bf thru 0x79d3c	(0x1cb7e bytes)	******PPPP
6213627(251 mod 256): MAPREAD  0x601c4 thru 0x65a03	(0x5840 bytes)
6213628(252 mod 256): ZERO     0x3aa80 thru 0x53a5a	(0x18fdb bytes)
6213629(253 mod 256): DEDUPE 0x5d000 thru 0x73fff	(0x17000 bytes) to 0x3b000 thru 0x51fff	BBBB******
6213630(254 mod 256): COLLAPSE 0x72000 thru 0x8bfff	(0x1a000 bytes)
6213631(255 mod 256): COPY 0xbed7 thru 0x1e15c	(0x12286 bytes) to 0x63c04 thru 0x75e89	******EEEE
6213632(  0 mod 256): PUNCH    0x6b942 thru 0x75e89	(0xa548 bytes)	******PPPP
6213633(  1 mod 256): WRITE    0x7bcba thru 0x927bf	(0x16b06 bytes) HOLE
6213634(  2 mod 256): TRUNCATE DOWN	from 0x927c0 to 0x7780d
6213635(  3 mod 256): TRUNCATE DOWN	from 0x7780d to 0x536e2	******WWWW
6213636(  4 mod 256): READ     0x353f0 thru 0x4fc56	(0x1a867 bytes)
6213637(  5 mod 256): ZERO     0x2d0d5 thru 0x49489	(0x1c3b5 bytes)
6213638(  6 mod 256): CLONE 0x47000 thru 0x51fff	(0xb000 bytes) to 0x21000 thru 0x2bfff
6213639(  7 mod 256): TRUNCATE DOWN	from 0x536e2 to 0x15f8a
6213640(  8 mod 256): COLLAPSE 0x6000 thru 0xdfff	(0x8000 bytes)
6213641(  9 mod 256): FALLOC   0x62da2 thru 0x65888	(0x2ae6 bytes) EXTENDING
6213642( 10 mod 256): READ     0x3bc10 thru 0x56cb6	(0x1b0a7 bytes)
6213643( 11 mod 256): DEDUPE 0x5f000 thru 0x63fff	(0x5000 bytes) to 0x3d000 thru 0x41fff
6213644( 12 mod 256): MAPREAD  0x2470b thru 0x3483a	(0x10130 bytes)
6213645( 13 mod 256): SKIPPED (no operation)
6213646( 14 mod 256): INSERT 0x17000 thru 0x29fff	(0x13000 bytes)
6213647( 15 mod 256): DEDUPE 0x27000 thru 0x33fff	(0xd000 bytes) to 0x3000 thru 0xffff
6213648( 16 mod 256): ZERO     0x191e0 thru 0x1eab9	(0x58da bytes)
6213649( 17 mod 256): INSERT 0x44000 thru 0x5afff	(0x17000 bytes)
6213650( 18 mod 256): COLLAPSE 0x3c000 thru 0x52fff	(0x17000 bytes)
6213651( 19 mod 256): COPY 0x750c thru 0x12a8e	(0xb583 bytes) to 0x4753b thru 0x52abd
6213652( 20 mod 256): PUNCH    0x71571 thru 0x78887	(0x7317 bytes)
6213653( 21 mod 256): ZERO     0x882a thru 0x23bc1	(0x1b398 bytes)
6213654( 22 mod 256): INSERT 0x53000 thru 0x60fff	(0xe000 bytes)
6213655( 23 mod 256): DEDUPE 0x53000 thru 0x5bfff	(0x9000 bytes) to 0x75000 thru 0x7dfff
6213656( 24 mod 256): READ     0x6787b thru 0x79505	(0x11c8b bytes)	***RRRR***
6213657( 25 mod 256): TRUNCATE DOWN	from 0x86888 to 0x233a6	******WWWW
6213658( 26 mod 256): DEDUPE 0x11000 thru 0x13fff	(0x3000 bytes) to 0x1a000 thru 0x1cfff
6213659( 27 mod 256): WRITE    0xf890 thru 0x1314d	(0x38be bytes)
6213660( 28 mod 256): DEDUPE 0x18000 thru 0x21fff	(0xa000 bytes) to 0xd000 thru 0x16fff
6213661( 29 mod 256): MAPREAD  0x103ca thru 0x233a5	(0x12fdc bytes)
6213662( 30 mod 256): MAPREAD  0xab1d thru 0x1908e	(0xe572 bytes)
6213663( 31 mod 256): ZERO     0x86ec thru 0x1c7bd	(0x140d2 bytes)
6213664( 32 mod 256): MAPWRITE 0x705c9 thru 0x8d59e	(0x1cfd6 bytes)
6213665( 33 mod 256): SKIPPED (no operation)
6213666( 34 mod 256): WRITE    0x5a37 thru 0xf676	(0x9c40 bytes)
6213667( 35 mod 256): CLONE 0x6f000 thru 0x8bfff	(0x1d000 bytes) to 0x1f000 thru 0x3bfff
6213668( 36 mod 256): COPY 0x4b133 thru 0x64b17	(0x199e5 bytes) to 0x20fa4 thru 0x3a988
6213669( 37 mod 256): COPY 0x22404 thru 0x247b1	(0x23ae bytes) to 0x4209b thru 0x44448
6213670( 38 mod 256): CLONE 0x6000 thru 0xdfff	(0x8000 bytes) to 0x2b000 thru 0x32fff
6213671( 39 mod 256): SKIPPED (no operation)
6213672( 40 mod 256): WRITE    0x337e1 thru 0x4ac77	(0x17497 bytes)
6213673( 41 mod 256): PUNCH    0x790ba thru 0x7aa7f	(0x19c6 bytes)
6213674( 42 mod 256): PUNCH    0x444fd thru 0x4a610	(0x6114 bytes)
6213675( 43 mod 256): CLONE 0x3000 thru 0x19fff	(0x17000 bytes) to 0x7a000 thru 0x90fff
6213676( 44 mod 256): MAPREAD  0x810a1 thru 0x8d2a1	(0xc201 bytes)
6213677( 45 mod 256): WRITE    0x53c07 thru 0x6df01	(0x1a2fb bytes)
6213678( 46 mod 256): WRITE    0x87d6e thru 0x927bf	(0xaa52 bytes) EXTEND
6213679( 47 mod 256): ZERO     0x2ea63 thru 0x3fd75	(0x11313 bytes)
6213680( 48 mod 256): READ     0x610f6 thru 0x65f93	(0x4e9e bytes)
6213681( 49 mod 256): WRITE    0x1d89f thru 0x315d3	(0x13d35 bytes)
6213682( 50 mod 256): PUNCH    0x820f0 thru 0x90f91	(0xeea2 bytes)
6213683( 51 mod 256): READ     0x71de3 thru 0x81044	(0xf262 bytes)
6213684( 52 mod 256): COLLAPSE 0x0 thru 0x16fff	(0x17000 bytes)
6213685( 53 mod 256): CLONE 0x4a000 thru 0x64fff	(0x1b000 bytes) to 0x23000 thru 0x3dfff
6213686( 54 mod 256): MAPWRITE 0x5495a thru 0x64d62	(0x10409 bytes)
6213687( 55 mod 256): COPY 0x23777 thru 0x3a55e	(0x16de8 bytes) to 0x411a2 thru 0x57f89
6213688( 56 mod 256): FALLOC   0xa3b7 thru 0xe890	(0x44d9 bytes) INTERIOR
6213689( 57 mod 256): TRUNCATE DOWN	from 0x7b7c0 to 0x3c10d	******WWWW
6213690( 58 mod 256): SKIPPED (no operation)
6213691( 59 mod 256): MAPREAD  0x132a2 thru 0x1fda6	(0xcb05 bytes)
6213692( 60 mod 256): ZERO     0x3aaf5 thru 0x3bfad	(0x14b9 bytes)
6213693( 61 mod 256): COPY 0x25012 thru 0x2e79e	(0x978d bytes) to 0x40c02 thru 0x4a38e
6213694( 62 mod 256): SKIPPED (no operation)
6213695( 63 mod 256): TRUNCATE DOWN	from 0x4a38f to 0x4659d
6213696( 64 mod 256): ZERO     0x8f285 thru 0x90c5a	(0x19d6 bytes)
6213697( 65 mod 256): PUNCH    0x7fda thru 0xb997	(0x39be bytes)
6213698( 66 mod 256): READ     0x1fe6a thru 0x2ab87	(0xad1e bytes)
6213699( 67 mod 256): COLLAPSE 0x2000 thru 0x5fff	(0x4000 bytes)
6213700( 68 mod 256): WRITE    0x8780e thru 0x927bf	(0xafb2 bytes) HOLE	***WWWW
6213701( 69 mod 256): SKIPPED (no operation)
6213702( 70 mod 256): SKIPPED (no operation)
6213703( 71 mod 256): MAPWRITE 0x26738 thru 0x2e656	(0x7f1f bytes)
6213704( 72 mod 256): SKIPPED (no operation)
6213705( 73 mod 256): DEDUPE 0xe000 thru 0x18fff	(0xb000 bytes) to 0x1c000 thru 0x26fff
6213706( 74 mod 256): MAPWRITE 0x89058 thru 0x927bf	(0x9768 bytes)
6213707( 75 mod 256): CLONE 0x32000 thru 0x4dfff	(0x1c000 bytes) to 0x55000 thru 0x70fff	******JJJJ
6213708( 76 mod 256): SKIPPED (no operation)
6213709( 77 mod 256): WRITE    0x3a75e thru 0x51b6e	(0x17411 bytes)
6213710( 78 mod 256): PUNCH    0x1ee77 thru 0x22f7b	(0x4105 bytes)
6213711( 79 mod 256): MAPREAD  0x61c30 thru 0x7eaf8	(0x1cec9 bytes)	***RRRR***
6213712( 80 mod 256): MAPWRITE 0x166af thru 0x350d3	(0x1ea25 bytes)
6213713( 81 mod 256): PUNCH    0x57986 thru 0x5fc99	(0x8314 bytes)
6213714( 82 mod 256): COLLAPSE 0x18000 thru 0x2afff	(0x13000 bytes)
6213715( 83 mod 256): PUNCH    0x3022d thru 0x360fc	(0x5ed0 bytes)
6213716( 84 mod 256): READ     0x3e030 thru 0x412f6	(0x32c7 bytes)
6213717( 85 mod 256): PUNCH    0x6e968 thru 0x7aa64	(0xc0fd bytes)	******PPPP
6213718( 86 mod 256): READ     0x65294 thru 0x7f7bf	(0x1a52c bytes)	***RRRR***
6213719( 87 mod 256): INSERT 0x2000 thru 0x14fff	(0x13000 bytes)
6213720( 88 mod 256): PUNCH    0x3350e thru 0x3f120	(0xbc13 bytes)
6213721( 89 mod 256): READ     0x60541 thru 0x7ed3c	(0x1e7fc bytes)	***RRRR***
6213722( 90 mod 256): MAPREAD  0x5cd83 thru 0x63f76	(0x71f4 bytes)
6213723( 91 mod 256): PUNCH    0x108e9 thru 0x28bde	(0x182f6 bytes)
6213724( 92 mod 256): COLLAPSE 0x64000 thru 0x76fff	(0x13000 bytes)	******CCCC
6213725( 93 mod 256): TRUNCATE DOWN	from 0x7f7c0 to 0x74c33
6213726( 94 mod 256): CLONE 0x4a000 thru 0x51fff	(0x8000 bytes) to 0x2d000 thru 0x34fff
6213727( 95 mod 256): ZERO     0x401e4 thru 0x4f925	(0xf742 bytes)
6213728( 96 mod 256): PUNCH    0x128bd thru 0x23868	(0x10fac bytes)
6213729( 97 mod 256): FALLOC   0x20281 thru 0x32217	(0x11f96 bytes) INTERIOR
6213730( 98 mod 256): TRUNCATE DOWN	from 0x74c33 to 0x55540	******WWWW
6213731( 99 mod 256): SKIPPED (no operation)
6213732(100 mod 256): COLLAPSE 0x3b000 thru 0x4efff	(0x14000 bytes)
6213733(101 mod 256): READ     0x1953d thru 0x29311	(0xfdd5 bytes)
6213734(102 mod 256): INSERT 0x14000 thru 0x2ffff	(0x1c000 bytes)
6213735(103 mod 256): COPY 0x1d381 thru 0x36d38	(0x199b8 bytes) to 0x64491 thru 0x7de48	******EEEE
6213736(104 mod 256): ZERO     0x74247 thru 0x927bf	(0x1e579 bytes)
6213737(105 mod 256): INSERT 0x8000 thru 0x16fff	(0xf000 bytes)
6213738(106 mod 256): READ     0x87aba thru 0x8ce48	(0x538f bytes)
6213739(107 mod 256): TRUNCATE DOWN	from 0x8ce49 to 0x46571	******WWWW
6213740(108 mod 256): SKIPPED (no operation)
6213741(109 mod 256): ZERO     0x55674 thru 0x70d41	(0x1b6ce bytes)	******ZZZZ
6213742(110 mod 256): PUNCH    0xc8b5 thru 0xe80d	(0x1f59 bytes)
6213743(111 mod 256): TRUNCATE DOWN	from 0x70d42 to 0x11ade	******WWWW
6213744(112 mod 256): COLLAPSE 0x6000 thru 0xffff	(0xa000 bytes)
6213745(113 mod 256): SKIPPED (no operation)
6213746(114 mod 256): MAPREAD  0x2625 thru 0x7add	(0x54b9 bytes)
6213747(115 mod 256): CLONE 0x2000 thru 0x6fff	(0x5000 bytes) to 0x10000 thru 0x14fff
6213748(116 mod 256): SKIPPED (no operation)
6213749(117 mod 256): TRUNCATE UP	from 0x15000 to 0x8d131	******WWWW
6213750(118 mod 256): WRITE    0x82547 thru 0x88334	(0x5dee bytes)
6213751(119 mod 256): DEDUPE 0x7d000 thru 0x83fff	(0x7000 bytes) to 0x22000 thru 0x28fff
6213752(120 mod 256): READ     0x11e69 thru 0x2864c	(0x167e4 bytes)
6213753(121 mod 256): INSERT 0x41000 thru 0x45fff	(0x5000 bytes)
6213754(122 mod 256): COPY 0x2ca4c thru 0x2ed9f	(0x2354 bytes) to 0x2fef1 thru 0x32244
6213755(123 mod 256): MAPWRITE 0x70677 thru 0x8b993	(0x1b31d bytes)
6213756(124 mod 256): FALLOC   0x7229f thru 0x91158	(0x1eeb9 bytes) INTERIOR
6213757(125 mod 256): COLLAPSE 0x13000 thru 0x2bfff	(0x19000 bytes)
6213758(126 mod 256): COPY 0x9271 thru 0xba34	(0x27c4 bytes) to 0x3227c thru 0x34a3f
6213759(127 mod 256): CLONE 0x23000 thru 0x2cfff	(0xa000 bytes) to 0x6c000 thru 0x75fff	******JJJJ
6213760(128 mod 256): READ     0x44cff thru 0x4c4a1	(0x77a3 bytes)
6213761(129 mod 256): DEDUPE 0x60000 thru 0x73fff	(0x14000 bytes) to 0x39000 thru 0x4cfff	BBBB******
6213762(130 mod 256): COLLAPSE 0x39000 thru 0x3ffff	(0x7000 bytes)
6213763(131 mod 256): WRITE    0x57565 thru 0x5e710	(0x71ac bytes)
6213764(132 mod 256): MAPREAD  0x39c49 thru 0x4accd	(0x11085 bytes)
6213765(133 mod 256): ZERO     0x4faf5 thru 0x6a5cc	(0x1aad8 bytes)
6213766(134 mod 256): MAPREAD  0x57f8 thru 0x8c98	(0x34a1 bytes)
6213767(135 mod 256): MAPREAD  0x5cbd8 thru 0x72130	(0x15559 bytes)	***RRRR***
6213768(136 mod 256): SKIPPED (no operation)
6213769(137 mod 256): INSERT 0x24000 thru 0x32fff	(0xf000 bytes)
6213770(138 mod 256): COPY 0x32b0c thru 0x4d035	(0x1a52a bytes) to 0x4f97f thru 0x69ea8
6213771(139 mod 256): DEDUPE 0x3f000 thru 0x52fff	(0x14000 bytes) to 0x23000 thru 0x36fff
6213772(140 mod 256): READ     0x6d9bf thru 0x81130	(0x13772 bytes)	***RRRR***
6213773(141 mod 256): TRUNCATE DOWN	from 0x81131 to 0x569c0	******WWWW
6213774(142 mod 256): MAPREAD  0x354d5 thru 0x44e7b	(0xf9a7 bytes)
6213775(143 mod 256): MAPWRITE 0x547c4 thru 0x60a8e	(0xc2cb bytes)
6213776(144 mod 256): SKIPPED (no operation)
6213777(145 mod 256): WRITE    0x28ada thru 0x4356c	(0x1aa93 bytes)
6213778(146 mod 256): ZERO     0x74c28 thru 0x91fec	(0x1d3c5 bytes)
6213779(147 mod 256): INSERT 0x12000 thru 0x1cfff	(0xb000 bytes)
6213780(148 mod 256): ZERO     0x30834 thru 0x330f7	(0x28c4 bytes)
6213781(149 mod 256): PUNCH    0x36080 thru 0x42edc	(0xce5d bytes)
6213782(150 mod 256): DEDUPE 0x14000 thru 0x19fff	(0x6000 bytes) to 0x49000 thru 0x4efff
6213783(151 mod 256): DEDUPE 0x51000 thru 0x5efff	(0xe000 bytes) to 0x2a000 thru 0x37fff
6213784(152 mod 256): WRITE    0x2448e thru 0x400f5	(0x1bc68 bytes)
6213785(153 mod 256): ZERO     0x87615 thru 0x927bf	(0xb1ab bytes)
6213786(154 mod 256): READ     0x5afc thru 0xa32c	(0x4831 bytes)
6213787(155 mod 256): SKIPPED (no operation)
6213788(156 mod 256): ZERO     0x7aab0 thru 0x7e2b3	(0x3804 bytes)
6213789(157 mod 256): INSERT 0x45000 thru 0x58fff	(0x14000 bytes)
6213790(158 mod 256): FALLOC   0x1a80e thru 0x289a3	(0xe195 bytes) INTERIOR
6213791(159 mod 256): SKIPPED (no operation)
6213792(160 mod 256): SKIPPED (no operation)
6213793(161 mod 256): FALLOC   0x2aca thru 0x20562	(0x1da98 bytes) INTERIOR
6213794(162 mod 256): ZERO     0x72fb9 thru 0x75887	(0x28cf bytes)
6213795(163 mod 256): COPY 0xa62e thru 0x218d0	(0x172a3 bytes) to 0x28ab1 thru 0x3fd53
6213796(164 mod 256): SKIPPED (no operation)
6213797(165 mod 256): COPY 0xa666 thru 0xf6a1	(0x503c bytes) to 0x353f0 thru 0x3a42b
6213798(166 mod 256): MAPREAD  0x69e3e thru 0x8675f	(0x1c922 bytes)	***RRRR***
Log of operations saved to "/mnt/junk.fsxops"; replay with --replay-ops
Correct content saved for comparison
(maybe hexdump "/mnt/junk" vs "/mnt/junk.fsxgood")
Silence is golden

Re: [PATCH v3 25/25] xfs: Support large folios

[Darrick J. Wong]

[resend with shorter 522.out file to keep us under the 300k maximum]

On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> Now that iomap has been converted, XFS is large folio safe.
> Indicate to the VFS that it can now create large folios for XFS.
> 
> Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> Reviewed-by: Christoph Hellwig <hch@lst.de>
> Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> ---
>  fs/xfs/xfs_icache.c | 2 ++
>  1 file changed, 2 insertions(+)
> 
> diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> index da4af2142a2b..cdc39f576ca1 100644
> --- a/fs/xfs/xfs_icache.c
> +++ b/fs/xfs/xfs_icache.c
> @@ -87,6 +87,7 @@ xfs_inode_alloc(
>  	/* VFS doesn't initialise i_mode or i_state! */
>  	VFS_I(ip)->i_mode = 0;
>  	VFS_I(ip)->i_state = 0;
> +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
>  
>  	XFS_STATS_INC(mp, vn_active);
>  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> @@ -320,6 +321,7 @@ xfs_reinit_inode(
>  	inode->i_rdev = dev;
>  	inode->i_uid = uid;
>  	inode->i_gid = gid;
> +	mapping_set_large_folios(inode->i_mapping);

Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
reports file corruption after 20 minutes of runtime.  The corruption is
surprisingly reproducible (522.out.bad attached below) in that I ran it
three times and always got the same bad offset (0x6e000) and always the
same opcode (6213798(166 mod 256) MAPREAD).

I turned off multipage folios and now 522 has run for over an hour
without problems, so before I go do more debugging, does this ring a
bell to anyone?

[addendum: Apparently vger now has a 300K message size limit; if you
want the full output, see https://djwong.org/docs/522.out.txt ]

--D

QA output created by 522
READ BAD DATA: offset = 0x69e3e, size = 0x1c922, fname = /mnt/junk
OFFSET	GOOD	BAD	RANGE
0x6e000	0x0000	0x9173	0x00000
operation# (mod 256) for the bad data may be 145
0x6e001	0x0000	0x7391	0x00001
operation# (mod 256) for the bad data may be 145
0x6e002	0x0000	0x9195	0x00002
operation# (mod 256) for the bad data may be 145
0x6e003	0x0000	0x9591	0x00003
operation# (mod 256) for the bad data may be 145
0x6e004	0x0000	0x91b5	0x00004
operation# (mod 256) for the bad data may be 145
0x6e005	0x0000	0xb591	0x00005
operation# (mod 256) for the bad data may be 145
0x6e006	0x0000	0x91e2	0x00006
operation# (mod 256) for the bad data may be 145
0x6e007	0x0000	0xe291	0x00007
operation# (mod 256) for the bad data may be 145
0x6e008	0x0000	0x919d	0x00008
operation# (mod 256) for the bad data may be 145
0x6e009	0x0000	0x9d91	0x00009
operation# (mod 256) for the bad data may be 145
0x6e00a	0x0000	0x91e8	0x0000a
operation# (mod 256) for the bad data may be 145
0x6e00b	0x0000	0xe891	0x0000b
operation# (mod 256) for the bad data may be 145
0x6e00c	0x0000	0x91c9	0x0000c
operation# (mod 256) for the bad data may be 145
0x6e00d	0x0000	0xc991	0x0000d
operation# (mod 256) for the bad data may be 145
0x6e00e	0x0000	0x9147	0x0000e
operation# (mod 256) for the bad data may be 145
0x6e00f	0x0000	0x4791	0x0000f
operation# (mod 256) for the bad data may be 145
LOG DUMP (6213798 total operations):

<snip>

6213732(100 mod 256): COLLAPSE 0x3b000 thru 0x4efff	(0x14000 bytes)
6213733(101 mod 256): READ     0x1953d thru 0x29311	(0xfdd5 bytes)
6213734(102 mod 256): INSERT 0x14000 thru 0x2ffff	(0x1c000 bytes)
6213735(103 mod 256): COPY 0x1d381 thru 0x36d38	(0x199b8 bytes) to 0x64491 thru 0x7de48	******EEEE
6213736(104 mod 256): ZERO     0x74247 thru 0x927bf	(0x1e579 bytes)
6213737(105 mod 256): INSERT 0x8000 thru 0x16fff	(0xf000 bytes)
6213738(106 mod 256): READ     0x87aba thru 0x8ce48	(0x538f bytes)
6213739(107 mod 256): TRUNCATE DOWN	from 0x8ce49 to 0x46571	******WWWW
6213740(108 mod 256): SKIPPED (no operation)
6213741(109 mod 256): ZERO     0x55674 thru 0x70d41	(0x1b6ce bytes)	******ZZZZ
6213742(110 mod 256): PUNCH    0xc8b5 thru 0xe80d	(0x1f59 bytes)
6213743(111 mod 256): TRUNCATE DOWN	from 0x70d42 to 0x11ade	******WWWW
6213744(112 mod 256): COLLAPSE 0x6000 thru 0xffff	(0xa000 bytes)
6213745(113 mod 256): SKIPPED (no operation)
6213746(114 mod 256): MAPREAD  0x2625 thru 0x7add	(0x54b9 bytes)
6213747(115 mod 256): CLONE 0x2000 thru 0x6fff	(0x5000 bytes) to 0x10000 thru 0x14fff
6213748(116 mod 256): SKIPPED (no operation)
6213749(117 mod 256): TRUNCATE UP	from 0x15000 to 0x8d131	******WWWW
6213750(118 mod 256): WRITE    0x82547 thru 0x88334	(0x5dee bytes)
6213751(119 mod 256): DEDUPE 0x7d000 thru 0x83fff	(0x7000 bytes) to 0x22000 thru 0x28fff
6213752(120 mod 256): READ     0x11e69 thru 0x2864c	(0x167e4 bytes)
6213753(121 mod 256): INSERT 0x41000 thru 0x45fff	(0x5000 bytes)
6213754(122 mod 256): COPY 0x2ca4c thru 0x2ed9f	(0x2354 bytes) to 0x2fef1 thru 0x32244
6213755(123 mod 256): MAPWRITE 0x70677 thru 0x8b993	(0x1b31d bytes)
6213756(124 mod 256): FALLOC   0x7229f thru 0x91158	(0x1eeb9 bytes) INTERIOR
6213757(125 mod 256): COLLAPSE 0x13000 thru 0x2bfff	(0x19000 bytes)
6213758(126 mod 256): COPY 0x9271 thru 0xba34	(0x27c4 bytes) to 0x3227c thru 0x34a3f
6213759(127 mod 256): CLONE 0x23000 thru 0x2cfff	(0xa000 bytes) to 0x6c000 thru 0x75fff	******JJJJ
6213760(128 mod 256): READ     0x44cff thru 0x4c4a1	(0x77a3 bytes)
6213761(129 mod 256): DEDUPE 0x60000 thru 0x73fff	(0x14000 bytes) to 0x39000 thru 0x4cfff	BBBB******
6213762(130 mod 256): COLLAPSE 0x39000 thru 0x3ffff	(0x7000 bytes)
6213763(131 mod 256): WRITE    0x57565 thru 0x5e710	(0x71ac bytes)
6213764(132 mod 256): MAPREAD  0x39c49 thru 0x4accd	(0x11085 bytes)
6213765(133 mod 256): ZERO     0x4faf5 thru 0x6a5cc	(0x1aad8 bytes)
6213766(134 mod 256): MAPREAD  0x57f8 thru 0x8c98	(0x34a1 bytes)
6213767(135 mod 256): MAPREAD  0x5cbd8 thru 0x72130	(0x15559 bytes)	***RRRR***
6213768(136 mod 256): SKIPPED (no operation)
6213769(137 mod 256): INSERT 0x24000 thru 0x32fff	(0xf000 bytes)
6213770(138 mod 256): COPY 0x32b0c thru 0x4d035	(0x1a52a bytes) to 0x4f97f thru 0x69ea8
6213771(139 mod 256): DEDUPE 0x3f000 thru 0x52fff	(0x14000 bytes) to 0x23000 thru 0x36fff
6213772(140 mod 256): READ     0x6d9bf thru 0x81130	(0x13772 bytes)	***RRRR***
6213773(141 mod 256): TRUNCATE DOWN	from 0x81131 to 0x569c0	******WWWW
6213774(142 mod 256): MAPREAD  0x354d5 thru 0x44e7b	(0xf9a7 bytes)
6213775(143 mod 256): MAPWRITE 0x547c4 thru 0x60a8e	(0xc2cb bytes)
6213776(144 mod 256): SKIPPED (no operation)
6213777(145 mod 256): WRITE    0x28ada thru 0x4356c	(0x1aa93 bytes)
6213778(146 mod 256): ZERO     0x74c28 thru 0x91fec	(0x1d3c5 bytes)
6213779(147 mod 256): INSERT 0x12000 thru 0x1cfff	(0xb000 bytes)
6213780(148 mod 256): ZERO     0x30834 thru 0x330f7	(0x28c4 bytes)
6213781(149 mod 256): PUNCH    0x36080 thru 0x42edc	(0xce5d bytes)
6213782(150 mod 256): DEDUPE 0x14000 thru 0x19fff	(0x6000 bytes) to 0x49000 thru 0x4efff
6213783(151 mod 256): DEDUPE 0x51000 thru 0x5efff	(0xe000 bytes) to 0x2a000 thru 0x37fff
6213784(152 mod 256): WRITE    0x2448e thru 0x400f5	(0x1bc68 bytes)
6213785(153 mod 256): ZERO     0x87615 thru 0x927bf	(0xb1ab bytes)
6213786(154 mod 256): READ     0x5afc thru 0xa32c	(0x4831 bytes)
6213787(155 mod 256): SKIPPED (no operation)
6213788(156 mod 256): ZERO     0x7aab0 thru 0x7e2b3	(0x3804 bytes)
6213789(157 mod 256): INSERT 0x45000 thru 0x58fff	(0x14000 bytes)
6213790(158 mod 256): FALLOC   0x1a80e thru 0x289a3	(0xe195 bytes) INTERIOR
6213791(159 mod 256): SKIPPED (no operation)
6213792(160 mod 256): SKIPPED (no operation)
6213793(161 mod 256): FALLOC   0x2aca thru 0x20562	(0x1da98 bytes) INTERIOR
6213794(162 mod 256): ZERO     0x72fb9 thru 0x75887	(0x28cf bytes)
6213795(163 mod 256): COPY 0xa62e thru 0x218d0	(0x172a3 bytes) to 0x28ab1 thru 0x3fd53
6213796(164 mod 256): SKIPPED (no operation)
6213797(165 mod 256): COPY 0xa666 thru 0xf6a1	(0x503c bytes) to 0x353f0 thru 0x3a42b
6213798(166 mod 256): MAPREAD  0x69e3e thru 0x8675f	(0x1c922 bytes)	***RRRR***
Log of operations saved to "/mnt/junk.fsxops"; replay with --replay-ops
Correct content saved for comparison
(maybe hexdump "/mnt/junk" vs "/mnt/junk.fsxgood")
Silence is golden

Re: [PATCH v3 25/25] xfs: Support large folios

[Darrick J. Wong]

On Wed, Jun 22, 2022 at 05:42:11PM -0700, Darrick J. Wong wrote:
> [resend with shorter 522.out file to keep us under the 300k maximum]
> 
> On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> > Now that iomap has been converted, XFS is large folio safe.
> > Indicate to the VFS that it can now create large folios for XFS.
> > 
> > Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> > Reviewed-by: Christoph Hellwig <hch@lst.de>
> > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> > ---
> >  fs/xfs/xfs_icache.c | 2 ++
> >  1 file changed, 2 insertions(+)
> > 
> > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > index da4af2142a2b..cdc39f576ca1 100644
> > --- a/fs/xfs/xfs_icache.c
> > +++ b/fs/xfs/xfs_icache.c
> > @@ -87,6 +87,7 @@ xfs_inode_alloc(
> >  	/* VFS doesn't initialise i_mode or i_state! */
> >  	VFS_I(ip)->i_mode = 0;
> >  	VFS_I(ip)->i_state = 0;
> > +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
> >  
> >  	XFS_STATS_INC(mp, vn_active);
> >  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> > @@ -320,6 +321,7 @@ xfs_reinit_inode(
> >  	inode->i_rdev = dev;
> >  	inode->i_uid = uid;
> >  	inode->i_gid = gid;
> > +	mapping_set_large_folios(inode->i_mapping);
> 
> Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
> reports file corruption after 20 minutes of runtime.  The corruption is
> surprisingly reproducible (522.out.bad attached below) in that I ran it
> three times and always got the same bad offset (0x6e000) and always the
> same opcode (6213798(166 mod 256) MAPREAD).
> 
> I turned off multipage folios and now 522 has run for over an hour
> without problems, so before I go do more debugging, does this ring a
> bell to anyone?

I tried bisecting, but that didn't yield anything productive and
5.19-rc4 still fails after 25 minutes; however, it seems that g/522 will
run without problems for at least 3-4 days after reverting this patch
from -rc3.

So I guess I have a blunt force fix if we can't figure this one out
before 5.19 final, but I'd really rather not.  Will keep trying this
week.

--D

> [addendum: Apparently vger now has a 300K message size limit; if you
> want the full output, see https://djwong.org/docs/522.out.txt ]
> 
> --D
> 
> QA output created by 522
> READ BAD DATA: offset = 0x69e3e, size = 0x1c922, fname = /mnt/junk
> OFFSET	GOOD	BAD	RANGE
> 0x6e000	0x0000	0x9173	0x00000
> operation# (mod 256) for the bad data may be 145
> 0x6e001	0x0000	0x7391	0x00001
> operation# (mod 256) for the bad data may be 145
> 0x6e002	0x0000	0x9195	0x00002
> operation# (mod 256) for the bad data may be 145
> 0x6e003	0x0000	0x9591	0x00003
> operation# (mod 256) for the bad data may be 145
> 0x6e004	0x0000	0x91b5	0x00004
> operation# (mod 256) for the bad data may be 145
> 0x6e005	0x0000	0xb591	0x00005
> operation# (mod 256) for the bad data may be 145
> 0x6e006	0x0000	0x91e2	0x00006
> operation# (mod 256) for the bad data may be 145
> 0x6e007	0x0000	0xe291	0x00007
> operation# (mod 256) for the bad data may be 145
> 0x6e008	0x0000	0x919d	0x00008
> operation# (mod 256) for the bad data may be 145
> 0x6e009	0x0000	0x9d91	0x00009
> operation# (mod 256) for the bad data may be 145
> 0x6e00a	0x0000	0x91e8	0x0000a
> operation# (mod 256) for the bad data may be 145
> 0x6e00b	0x0000	0xe891	0x0000b
> operation# (mod 256) for the bad data may be 145
> 0x6e00c	0x0000	0x91c9	0x0000c
> operation# (mod 256) for the bad data may be 145
> 0x6e00d	0x0000	0xc991	0x0000d
> operation# (mod 256) for the bad data may be 145
> 0x6e00e	0x0000	0x9147	0x0000e
> operation# (mod 256) for the bad data may be 145
> 0x6e00f	0x0000	0x4791	0x0000f
> operation# (mod 256) for the bad data may be 145
> LOG DUMP (6213798 total operations):
> 
> <snip>
> 
> 6213732(100 mod 256): COLLAPSE 0x3b000 thru 0x4efff	(0x14000 bytes)
> 6213733(101 mod 256): READ     0x1953d thru 0x29311	(0xfdd5 bytes)
> 6213734(102 mod 256): INSERT 0x14000 thru 0x2ffff	(0x1c000 bytes)
> 6213735(103 mod 256): COPY 0x1d381 thru 0x36d38	(0x199b8 bytes) to 0x64491 thru 0x7de48	******EEEE
> 6213736(104 mod 256): ZERO     0x74247 thru 0x927bf	(0x1e579 bytes)
> 6213737(105 mod 256): INSERT 0x8000 thru 0x16fff	(0xf000 bytes)
> 6213738(106 mod 256): READ     0x87aba thru 0x8ce48	(0x538f bytes)
> 6213739(107 mod 256): TRUNCATE DOWN	from 0x8ce49 to 0x46571	******WWWW
> 6213740(108 mod 256): SKIPPED (no operation)
> 6213741(109 mod 256): ZERO     0x55674 thru 0x70d41	(0x1b6ce bytes)	******ZZZZ
> 6213742(110 mod 256): PUNCH    0xc8b5 thru 0xe80d	(0x1f59 bytes)
> 6213743(111 mod 256): TRUNCATE DOWN	from 0x70d42 to 0x11ade	******WWWW
> 6213744(112 mod 256): COLLAPSE 0x6000 thru 0xffff	(0xa000 bytes)
> 6213745(113 mod 256): SKIPPED (no operation)
> 6213746(114 mod 256): MAPREAD  0x2625 thru 0x7add	(0x54b9 bytes)
> 6213747(115 mod 256): CLONE 0x2000 thru 0x6fff	(0x5000 bytes) to 0x10000 thru 0x14fff
> 6213748(116 mod 256): SKIPPED (no operation)
> 6213749(117 mod 256): TRUNCATE UP	from 0x15000 to 0x8d131	******WWWW
> 6213750(118 mod 256): WRITE    0x82547 thru 0x88334	(0x5dee bytes)
> 6213751(119 mod 256): DEDUPE 0x7d000 thru 0x83fff	(0x7000 bytes) to 0x22000 thru 0x28fff
> 6213752(120 mod 256): READ     0x11e69 thru 0x2864c	(0x167e4 bytes)
> 6213753(121 mod 256): INSERT 0x41000 thru 0x45fff	(0x5000 bytes)
> 6213754(122 mod 256): COPY 0x2ca4c thru 0x2ed9f	(0x2354 bytes) to 0x2fef1 thru 0x32244
> 6213755(123 mod 256): MAPWRITE 0x70677 thru 0x8b993	(0x1b31d bytes)
> 6213756(124 mod 256): FALLOC   0x7229f thru 0x91158	(0x1eeb9 bytes) INTERIOR
> 6213757(125 mod 256): COLLAPSE 0x13000 thru 0x2bfff	(0x19000 bytes)
> 6213758(126 mod 256): COPY 0x9271 thru 0xba34	(0x27c4 bytes) to 0x3227c thru 0x34a3f
> 6213759(127 mod 256): CLONE 0x23000 thru 0x2cfff	(0xa000 bytes) to 0x6c000 thru 0x75fff	******JJJJ
> 6213760(128 mod 256): READ     0x44cff thru 0x4c4a1	(0x77a3 bytes)
> 6213761(129 mod 256): DEDUPE 0x60000 thru 0x73fff	(0x14000 bytes) to 0x39000 thru 0x4cfff	BBBB******
> 6213762(130 mod 256): COLLAPSE 0x39000 thru 0x3ffff	(0x7000 bytes)
> 6213763(131 mod 256): WRITE    0x57565 thru 0x5e710	(0x71ac bytes)
> 6213764(132 mod 256): MAPREAD  0x39c49 thru 0x4accd	(0x11085 bytes)
> 6213765(133 mod 256): ZERO     0x4faf5 thru 0x6a5cc	(0x1aad8 bytes)
> 6213766(134 mod 256): MAPREAD  0x57f8 thru 0x8c98	(0x34a1 bytes)
> 6213767(135 mod 256): MAPREAD  0x5cbd8 thru 0x72130	(0x15559 bytes)	***RRRR***
> 6213768(136 mod 256): SKIPPED (no operation)
> 6213769(137 mod 256): INSERT 0x24000 thru 0x32fff	(0xf000 bytes)
> 6213770(138 mod 256): COPY 0x32b0c thru 0x4d035	(0x1a52a bytes) to 0x4f97f thru 0x69ea8
> 6213771(139 mod 256): DEDUPE 0x3f000 thru 0x52fff	(0x14000 bytes) to 0x23000 thru 0x36fff
> 6213772(140 mod 256): READ     0x6d9bf thru 0x81130	(0x13772 bytes)	***RRRR***
> 6213773(141 mod 256): TRUNCATE DOWN	from 0x81131 to 0x569c0	******WWWW
> 6213774(142 mod 256): MAPREAD  0x354d5 thru 0x44e7b	(0xf9a7 bytes)
> 6213775(143 mod 256): MAPWRITE 0x547c4 thru 0x60a8e	(0xc2cb bytes)
> 6213776(144 mod 256): SKIPPED (no operation)
> 6213777(145 mod 256): WRITE    0x28ada thru 0x4356c	(0x1aa93 bytes)
> 6213778(146 mod 256): ZERO     0x74c28 thru 0x91fec	(0x1d3c5 bytes)
> 6213779(147 mod 256): INSERT 0x12000 thru 0x1cfff	(0xb000 bytes)
> 6213780(148 mod 256): ZERO     0x30834 thru 0x330f7	(0x28c4 bytes)
> 6213781(149 mod 256): PUNCH    0x36080 thru 0x42edc	(0xce5d bytes)
> 6213782(150 mod 256): DEDUPE 0x14000 thru 0x19fff	(0x6000 bytes) to 0x49000 thru 0x4efff
> 6213783(151 mod 256): DEDUPE 0x51000 thru 0x5efff	(0xe000 bytes) to 0x2a000 thru 0x37fff
> 6213784(152 mod 256): WRITE    0x2448e thru 0x400f5	(0x1bc68 bytes)
> 6213785(153 mod 256): ZERO     0x87615 thru 0x927bf	(0xb1ab bytes)
> 6213786(154 mod 256): READ     0x5afc thru 0xa32c	(0x4831 bytes)
> 6213787(155 mod 256): SKIPPED (no operation)
> 6213788(156 mod 256): ZERO     0x7aab0 thru 0x7e2b3	(0x3804 bytes)
> 6213789(157 mod 256): INSERT 0x45000 thru 0x58fff	(0x14000 bytes)
> 6213790(158 mod 256): FALLOC   0x1a80e thru 0x289a3	(0xe195 bytes) INTERIOR
> 6213791(159 mod 256): SKIPPED (no operation)
> 6213792(160 mod 256): SKIPPED (no operation)
> 6213793(161 mod 256): FALLOC   0x2aca thru 0x20562	(0x1da98 bytes) INTERIOR
> 6213794(162 mod 256): ZERO     0x72fb9 thru 0x75887	(0x28cf bytes)
> 6213795(163 mod 256): COPY 0xa62e thru 0x218d0	(0x172a3 bytes) to 0x28ab1 thru 0x3fd53
> 6213796(164 mod 256): SKIPPED (no operation)
> 6213797(165 mod 256): COPY 0xa666 thru 0xf6a1	(0x503c bytes) to 0x353f0 thru 0x3a42b
> 6213798(166 mod 256): MAPREAD  0x69e3e thru 0x8675f	(0x1c922 bytes)	***RRRR***
> Log of operations saved to "/mnt/junk.fsxops"; replay with --replay-ops
> Correct content saved for comparison
> (maybe hexdump "/mnt/junk" vs "/mnt/junk.fsxgood")
> Silence is golden

Re: [PATCH v3 25/25] xfs: Support large folios

[Matthew Wilcox]

On Sun, Jun 26, 2022 at 09:15:27PM -0700, Darrick J. Wong wrote:
> On Wed, Jun 22, 2022 at 05:42:11PM -0700, Darrick J. Wong wrote:
> > [resend with shorter 522.out file to keep us under the 300k maximum]
> > 
> > On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> > > Now that iomap has been converted, XFS is large folio safe.
> > > Indicate to the VFS that it can now create large folios for XFS.
> > > 
> > > Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> > > Reviewed-by: Christoph Hellwig <hch@lst.de>
> > > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> > > ---
> > >  fs/xfs/xfs_icache.c | 2 ++
> > >  1 file changed, 2 insertions(+)
> > > 
> > > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > > index da4af2142a2b..cdc39f576ca1 100644
> > > --- a/fs/xfs/xfs_icache.c
> > > +++ b/fs/xfs/xfs_icache.c
> > > @@ -87,6 +87,7 @@ xfs_inode_alloc(
> > >  	/* VFS doesn't initialise i_mode or i_state! */
> > >  	VFS_I(ip)->i_mode = 0;
> > >  	VFS_I(ip)->i_state = 0;
> > > +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
> > >  
> > >  	XFS_STATS_INC(mp, vn_active);
> > >  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> > > @@ -320,6 +321,7 @@ xfs_reinit_inode(
> > >  	inode->i_rdev = dev;
> > >  	inode->i_uid = uid;
> > >  	inode->i_gid = gid;
> > > +	mapping_set_large_folios(inode->i_mapping);
> > 
> > Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
> > reports file corruption after 20 minutes of runtime.  The corruption is
> > surprisingly reproducible (522.out.bad attached below) in that I ran it
> > three times and always got the same bad offset (0x6e000) and always the
> > same opcode (6213798(166 mod 256) MAPREAD).
> > 
> > I turned off multipage folios and now 522 has run for over an hour
> > without problems, so before I go do more debugging, does this ring a
> > bell to anyone?
> 
> I tried bisecting, but that didn't yield anything productive and
> 5.19-rc4 still fails after 25 minutes; however, it seems that g/522 will
> run without problems for at least 3-4 days after reverting this patch
> from -rc3.
> 
> So I guess I have a blunt force fix if we can't figure this one out
> before 5.19 final, but I'd really rather not.  Will keep trying this
> week.

I'm on holiday for the next week, so I'm not going to be able to spend
any time on this until then.  I have a suspicion that this may be the
same bug Zorro is seeing here:

https://lore.kernel.org/linux-mm/20220613010850.6kmpenitmuct2osb@zlang-mailbox/

At least I hope it is, and finding a folio that has been freed would
explain (apparent) file corruption.

Re: [PATCH v3 25/25] xfs: Support large folios

[Darrick J. Wong]

On Mon, Jun 27, 2022 at 03:10:40PM +0100, Matthew Wilcox wrote:
> On Sun, Jun 26, 2022 at 09:15:27PM -0700, Darrick J. Wong wrote:
> > On Wed, Jun 22, 2022 at 05:42:11PM -0700, Darrick J. Wong wrote:
> > > [resend with shorter 522.out file to keep us under the 300k maximum]
> > > 
> > > On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> > > > Now that iomap has been converted, XFS is large folio safe.
> > > > Indicate to the VFS that it can now create large folios for XFS.
> > > > 
> > > > Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> > > > Reviewed-by: Christoph Hellwig <hch@lst.de>
> > > > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> > > > ---
> > > >  fs/xfs/xfs_icache.c | 2 ++
> > > >  1 file changed, 2 insertions(+)
> > > > 
> > > > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > > > index da4af2142a2b..cdc39f576ca1 100644
> > > > --- a/fs/xfs/xfs_icache.c
> > > > +++ b/fs/xfs/xfs_icache.c
> > > > @@ -87,6 +87,7 @@ xfs_inode_alloc(
> > > >  	/* VFS doesn't initialise i_mode or i_state! */
> > > >  	VFS_I(ip)->i_mode = 0;
> > > >  	VFS_I(ip)->i_state = 0;
> > > > +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
> > > >  
> > > >  	XFS_STATS_INC(mp, vn_active);
> > > >  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> > > > @@ -320,6 +321,7 @@ xfs_reinit_inode(
> > > >  	inode->i_rdev = dev;
> > > >  	inode->i_uid = uid;
> > > >  	inode->i_gid = gid;
> > > > +	mapping_set_large_folios(inode->i_mapping);
> > > 
> > > Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
> > > reports file corruption after 20 minutes of runtime.  The corruption is
> > > surprisingly reproducible (522.out.bad attached below) in that I ran it
> > > three times and always got the same bad offset (0x6e000) and always the
> > > same opcode (6213798(166 mod 256) MAPREAD).
> > > 
> > > I turned off multipage folios and now 522 has run for over an hour
> > > without problems, so before I go do more debugging, does this ring a
> > > bell to anyone?
> > 
> > I tried bisecting, but that didn't yield anything productive and
> > 5.19-rc4 still fails after 25 minutes; however, it seems that g/522 will
> > run without problems for at least 3-4 days after reverting this patch
> > from -rc3.
> > 
> > So I guess I have a blunt force fix if we can't figure this one out
> > before 5.19 final, but I'd really rather not.  Will keep trying this
> > week.
> 
> I'm on holiday for the next week, so I'm not going to be able to spend
> any time on this until then.  I have a suspicion that this may be the
> same bug Zorro is seeing here:
> 
> https://lore.kernel.org/linux-mm/20220613010850.6kmpenitmuct2osb@zlang-mailbox/
> 
> At least I hope it is, and finding a folio that has been freed would
> explain (apparent) file corruption.

Hm.  I suppose it /could/ be a lost folio getting into the works
somewhere.

Today I remembered fsx -X, which makes this reproduce a bit faster (~3-8
minutes instead of 20-25).  That has helped me to narrow things down a
little more:

- Turning off INSERT/COLLAPSE_RANGE doesn't make the problem go away,
  but it does make reading the fsx log much easier.

- Turning off clone/dedupe (either via -J -B or formatting with -m
  reflink=0) makes the problem go away completely.  If you define
  letting fsx run for 90 minutes as "completely".

- Neutering vfs_dedupe_file_range_compare by replacing it with an -EBADE
  return doesn't affect the reproducibility, so it's not the comparison
  function misbehaving.

- I modified fsx.c so that when there's file corruption, it'll report
  both the first 16 bytes of corruption as well as every corruption that
  happens on a page boundary.

- I also modified run_fsx() to diff the good and junk files, and
  complain about any corruption happening on a page boundary.  Now I see
  things like this:

2153984(  0 mod 256): SKIPPED (no operation)
2153985(  1 mod 256): DEDUPE 0xf000 thru 0x23fff        (0x15000 bytes) to 0x2a000 thru 0x3efff ******BBBB
2153986(  2 mod 256): COPY 0xe794 thru 0x2ae41  (0x1c6ae bytes) to 0x60ac4 thru 0x7d171
2153987(  3 mod 256): TRUNCATE DOWN     from 0x7d172 to 0x535da
2153988(  4 mod 256): SKIPPED (no operation)
2153989(  5 mod 256): MAPREAD  0x40b93 thru 0x535d9     (0x12a47 bytes)
2153990(  6 mod 256): COPY 0x5edd thru 0x20282  (0x1a3a6 bytes) to 0x3a9aa thru 0x54d4f
2153991(  7 mod 256): SKIPPED (no operation)
2153992(  8 mod 256): SKIPPED (no operation)
2153993(  9 mod 256): ZERO     0x542d3 thru 0x67006     (0x12d34 bytes)
2153994( 10 mod 256): COPY 0x42cf6 thru 0x538a7 (0x10bb2 bytes) to 0x23fe7 thru 0x34b98 ******EEEE
2153995( 11 mod 256): MAPWRITE 0x5a1fc thru 0x6b067     (0x10e6c bytes)
2153996( 12 mod 256): SKIPPED (no operation)
2153997( 13 mod 256): CLONE 0x38000 thru 0x38fff        (0x1000 bytes) to 0x77000 thru 0x77fff
2153998( 14 mod 256): FALLOC   0x49bdd thru 0x62a55     (0x18e78 bytes) INTERIOR
2153999( 15 mod 256): CLONE 0xf000 thru 0x1bfff (0xd000 bytes) to 0x2c000 thru 0x38fff  ******JJJJ
Log of operations saved to "/mnt/junk.fsxops"; replay with --replay-ops
Correct content saved for comparison
(maybe hexdump "/mnt/junk" vs "/mnt/junk.fsxgood")
junk file 177
-02e000  ec  20  ec  5a  ec  78  ec  b2  ec  e6  ec  1e  ec  43  ec  0f
-02f000  ec  30  ec  32  ec  4c  ec  ac  ec  5c  ec  d2  ec  62  ec  d3
-030000  ec  73  ec  ce  ec  8c  ec  cb  ec  94  ec  59  ec  81  ec  34
+02e000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
+02f000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
+030000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8

When I remount the test filesystem, I see further corruption:

$ diff -Naurp <(od -tx1 -Ax -c $TEST_DIR/junk.fsxgood) <(od -tx1 -Ax -c $TEST_DIR/junk) | grep '^[+-]0..000'
-011000  ec  20  ec  5a  ec  78  ec  b2  ec  e6  ec  1e  ec  43  ec  0f
-012000  ec  30  ec  32  ec  4c  ec  ac  ec  5c  ec  d2  ec  62  ec  d3
-013000  ec  73  ec  ce  ec  8c  ec  cb  ec  94  ec  59  ec  81  ec  34
+011000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
+012000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
+013000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8
-02e000  ec  20  ec  5a  ec  78  ec  b2  ec  e6  ec  1e  ec  43  ec  0f
-02f000  ec  30  ec  32  ec  4c  ec  ac  ec  5c  ec  d2  ec  62  ec  d3
-030000  ec  73  ec  ce  ec  8c  ec  cb  ec  94  ec  59  ec  81  ec  34
+02e000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
+02f000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
+030000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8

This is really quite strange!  The same corruption patterns we saw at
pages 0x2e - 0x30 now appear at 0x11-0x13 after the remount!

By comparison, the junk.fsxgood file only contains this 77/db/f1
sequence at:

$ od -tx1 -Ax -c $TEST_DIR/junk.fsxgood | grep '77  db  f1'
008530  db  34  db  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d
03d000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db

Curiously, the same byte trios at 0x2f000 and 0x30000 have similar
repetitions at similar looking offsets:

$ od -tx1 -Ax -c $TEST_DIR/junk.fsxgood | grep 'b3  d8  35'
009530  d8  bb  d8  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b
03e000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
$ od -tx1 -Ax -c $TEST_DIR/junk.fsxgood | grep '23  d8  c8'
00a530  d8  f5  d8  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e
03f000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8

Though the only pattern that happens consistently is that garbage bytes
end up at the reflink dest, and later at the reflink source.  I never
see any VM_BUG_ON_FOLIO asserts, nor does KASAN report anything.

I also added a debug function to dump the folios it finds in the
pagecache for the fsx junk file, but nothing looks odd:

     522-5099  [001]   491.954659: console:              [U] FSX FAILURE
  xfs_io-5125  [002]   491.961232: console:              XFS (sda): EXPERIMENTAL online scrub feature in use. Use at your own risk!
  xfs_io-5125  [002]   491.961238: bprint:               filemap_dump: ino 0xb1 pos 0x0 pfn 0x515cc order 0
  xfs_io-5125  [002]   491.961238: bprint:               filemap_dump: ino 0xb1 pos 0x1000 pfn 0x515cd order 0
  xfs_io-5125  [002]   491.961239: bprint:               filemap_dump: ino 0xb1 pos 0x2000 pfn 0x515ce order 0
  xfs_io-5125  [002]   491.961239: bprint:               filemap_dump: ino 0xb1 pos 0x3000 pfn 0x515cf order 0
  xfs_io-5125  [002]   491.961239: bprint:               filemap_dump: ino 0xb1 pos 0x4000 pfn 0x50c48 order 0
  xfs_io-5125  [002]   491.961240: bprint:               filemap_dump: ino 0xb1 pos 0x5000 pfn 0x50c49 order 0
  xfs_io-5125  [002]   491.961240: bprint:               filemap_dump: ino 0xb1 pos 0x6000 pfn 0x50c4a order 0
  xfs_io-5125  [002]   491.961241: bprint:               filemap_dump: ino 0xb1 pos 0x7000 pfn 0xc8a8 order 0
  xfs_io-5125  [002]   491.961241: bprint:               filemap_dump: ino 0xb1 pos 0x8000 pfn 0x50988 order 2
  xfs_io-5125  [002]   491.961241: bprint:               filemap_dump: ino 0xb1 pos 0xc000 pfn 0x509e0 order 2
  xfs_io-5125  [002]   491.961242: bprint:               filemap_dump: ino 0xb1 pos 0x10000 pfn 0x4db64 order 2

  xfs_io-5125  [002]   491.961242: bprint:               filemap_dump: ino 0xb1 pos 0x14000 pfn 0x50c4c order 0
  xfs_io-5125  [002]   491.961243: bprint:               filemap_dump: ino 0xb1 pos 0x15000 pfn 0x12485 order 0
  xfs_io-5125  [002]   491.961243: bprint:               filemap_dump: ino 0xb1 pos 0x16000 pfn 0x50c4d order 0
  xfs_io-5125  [002]   491.961243: bprint:               filemap_dump: ino 0xb1 pos 0x17000 pfn 0x50c4e order 0
  xfs_io-5125  [002]   491.961244: bprint:               filemap_dump: ino 0xb1 pos 0x18000 pfn 0x4eef8 order 2
  xfs_io-5125  [002]   491.961244: bprint:               filemap_dump: ino 0xb1 pos 0x1c000 pfn 0x4eefc order 2
  xfs_io-5125  [002]   491.961245: bprint:               filemap_dump: ino 0xb1 pos 0x20000 pfn 0x4eef0 order 2
  xfs_io-5125  [002]   491.961245: bprint:               filemap_dump: ino 0xb1 pos 0x24000 pfn 0x50f2c order 2
  xfs_io-5125  [002]   491.961245: bprint:               filemap_dump: ino 0xb1 pos 0x28000 pfn 0x50f28 order 2
  xfs_io-5125  [002]   491.961246: bprint:               filemap_dump: ino 0xb1 pos 0x2c000 pfn 0x50f24 order 2

  xfs_io-5125  [002]   491.961246: bprint:               filemap_dump: ino 0xb1 pos 0x30000 pfn 0x50f20 order 2

I'll keep digging...

--D

Re: [PATCH v3 25/25] xfs: Support large folios

[Dave Chinner]

On Mon, Jun 27, 2022 at 03:16:19PM -0700, Darrick J. Wong wrote:
> On Mon, Jun 27, 2022 at 03:10:40PM +0100, Matthew Wilcox wrote:
> > On Sun, Jun 26, 2022 at 09:15:27PM -0700, Darrick J. Wong wrote:
> > > On Wed, Jun 22, 2022 at 05:42:11PM -0700, Darrick J. Wong wrote:
> > > > [resend with shorter 522.out file to keep us under the 300k maximum]
> > > > 
> > > > On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> > > > > Now that iomap has been converted, XFS is large folio safe.
> > > > > Indicate to the VFS that it can now create large folios for XFS.
> > > > > 
> > > > > Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> > > > > Reviewed-by: Christoph Hellwig <hch@lst.de>
> > > > > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> > > > > ---
> > > > >  fs/xfs/xfs_icache.c | 2 ++
> > > > >  1 file changed, 2 insertions(+)
> > > > > 
> > > > > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > > > > index da4af2142a2b..cdc39f576ca1 100644
> > > > > --- a/fs/xfs/xfs_icache.c
> > > > > +++ b/fs/xfs/xfs_icache.c
> > > > > @@ -87,6 +87,7 @@ xfs_inode_alloc(
> > > > >  	/* VFS doesn't initialise i_mode or i_state! */
> > > > >  	VFS_I(ip)->i_mode = 0;
> > > > >  	VFS_I(ip)->i_state = 0;
> > > > > +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
> > > > >  
> > > > >  	XFS_STATS_INC(mp, vn_active);
> > > > >  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> > > > > @@ -320,6 +321,7 @@ xfs_reinit_inode(
> > > > >  	inode->i_rdev = dev;
> > > > >  	inode->i_uid = uid;
> > > > >  	inode->i_gid = gid;
> > > > > +	mapping_set_large_folios(inode->i_mapping);
> > > > 
> > > > Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
> > > > reports file corruption after 20 minutes of runtime.  The corruption is
> > > > surprisingly reproducible (522.out.bad attached below) in that I ran it
> > > > three times and always got the same bad offset (0x6e000) and always the
> > > > same opcode (6213798(166 mod 256) MAPREAD).
> > > > 
> > > > I turned off multipage folios and now 522 has run for over an hour
> > > > without problems, so before I go do more debugging, does this ring a
> > > > bell to anyone?
> > > 
> > > I tried bisecting, but that didn't yield anything productive and
> > > 5.19-rc4 still fails after 25 minutes; however, it seems that g/522 will
> > > run without problems for at least 3-4 days after reverting this patch
> > > from -rc3.
> > > 
> > > So I guess I have a blunt force fix if we can't figure this one out
> > > before 5.19 final, but I'd really rather not.  Will keep trying this
> > > week.
> > 
> > I'm on holiday for the next week, so I'm not going to be able to spend
> > any time on this until then.  I have a suspicion that this may be the
> > same bug Zorro is seeing here:
> > 
> > https://lore.kernel.org/linux-mm/20220613010850.6kmpenitmuct2osb@zlang-mailbox/
> > 
> > At least I hope it is, and finding a folio that has been freed would
> > explain (apparent) file corruption.
> 
> Hm.  I suppose it /could/ be a lost folio getting into the works
> somewhere.
> 
> Today I remembered fsx -X, which makes this reproduce a bit faster (~3-8
> minutes instead of 20-25).  That has helped me to narrow things down a
> little more:
> 
> - Turning off INSERT/COLLAPSE_RANGE doesn't make the problem go away,
>   but it does make reading the fsx log much easier.
> 
> - Turning off clone/dedupe (either via -J -B or formatting with -m
>   reflink=0) makes the problem go away completely.  If you define
>   letting fsx run for 90 minutes as "completely".
> 
> - Neutering vfs_dedupe_file_range_compare by replacing it with an -EBADE
>   return doesn't affect the reproducibility, so it's not the comparison
>   function misbehaving.
> - I modified fsx.c so that when there's file corruption, it'll report
>   both the first 16 bytes of corruption as well as every corruption that
>   happens on a page boundary.
> 
> - I also modified run_fsx() to diff the good and junk files, and
>   complain about any corruption happening on a page boundary.  Now I see
>   things like this:
> 
> 2153984(  0 mod 256): SKIPPED (no operation)
> 2153985(  1 mod 256): DEDUPE 0xf000 thru 0x23fff        (0x15000 bytes) to 0x2a000 thru 0x3efff ******BBBB
> 2153986(  2 mod 256): COPY 0xe794 thru 0x2ae41  (0x1c6ae bytes) to 0x60ac4 thru 0x7d171
> 2153987(  3 mod 256): TRUNCATE DOWN     from 0x7d172 to 0x535da
> 2153988(  4 mod 256): SKIPPED (no operation)
> 2153989(  5 mod 256): MAPREAD  0x40b93 thru 0x535d9     (0x12a47 bytes)
> 2153990(  6 mod 256): COPY 0x5edd thru 0x20282  (0x1a3a6 bytes) to 0x3a9aa thru 0x54d4f
> 2153991(  7 mod 256): SKIPPED (no operation)
> 2153992(  8 mod 256): SKIPPED (no operation)
> 2153993(  9 mod 256): ZERO     0x542d3 thru 0x67006     (0x12d34 bytes)
> 2153994( 10 mod 256): COPY 0x42cf6 thru 0x538a7 (0x10bb2 bytes) to 0x23fe7 thru 0x34b98 ******EEEE
> 2153995( 11 mod 256): MAPWRITE 0x5a1fc thru 0x6b067     (0x10e6c bytes)
> 2153996( 12 mod 256): SKIPPED (no operation)
> 2153997( 13 mod 256): CLONE 0x38000 thru 0x38fff        (0x1000 bytes) to 0x77000 thru 0x77fff
> 2153998( 14 mod 256): FALLOC   0x49bdd thru 0x62a55     (0x18e78 bytes) INTERIOR
> 2153999( 15 mod 256): CLONE 0xf000 thru 0x1bfff (0xd000 bytes) to 0x2c000 thru 0x38fff  ******JJJJ
> Log of operations saved to "/mnt/junk.fsxops"; replay with --replay-ops
> Correct content saved for comparison
> (maybe hexdump "/mnt/junk" vs "/mnt/junk.fsxgood")
> junk file 177
> -02e000  ec  20  ec  5a  ec  78  ec  b2  ec  e6  ec  1e  ec  43  ec  0f
> -02f000  ec  30  ec  32  ec  4c  ec  ac  ec  5c  ec  d2  ec  62  ec  d3
> -030000  ec  73  ec  ce  ec  8c  ec  cb  ec  94  ec  59  ec  81  ec  34
> +02e000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
> +02f000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
> +030000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8
> 
> When I remount the test filesystem, I see further corruption:
> 
> $ diff -Naurp <(od -tx1 -Ax -c $TEST_DIR/junk.fsxgood) <(od -tx1 -Ax -c $TEST_DIR/junk) | grep '^[+-]0..000'
> -011000  ec  20  ec  5a  ec  78  ec  b2  ec  e6  ec  1e  ec  43  ec  0f
> -012000  ec  30  ec  32  ec  4c  ec  ac  ec  5c  ec  d2  ec  62  ec  d3
> -013000  ec  73  ec  ce  ec  8c  ec  cb  ec  94  ec  59  ec  81  ec  34
> +011000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
> +012000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
> +013000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8
> -02e000  ec  20  ec  5a  ec  78  ec  b2  ec  e6  ec  1e  ec  43  ec  0f
> -02f000  ec  30  ec  32  ec  4c  ec  ac  ec  5c  ec  d2  ec  62  ec  d3
> -030000  ec  73  ec  ce  ec  8c  ec  cb  ec  94  ec  59  ec  81  ec  34
> +02e000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
> +02f000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
> +030000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8
> 
> This is really quite strange!  The same corruption patterns we saw at
> pages 0x2e - 0x30 now appear at 0x11-0x13 after the remount!

Hmmmm - look at what the last operation before failure
does - it clones 0xf000-0x1bfff to 0x2c000-0x38fff. IOWs, those
ranges *should* be identical and the the corruption is actually
occuring at 0x11000-0x13fff. It's not until that range gets cloned
to 0x2e000-0x30fff that the corruption is detected.

So we're looking in the wrong spot for the page cache corruption -
we need to be looking at operations over the range 0x11000-0x13fff
for misbehaviour, not where fsx detected the corrupt data.

> By comparison, the junk.fsxgood file only contains this 77/db/f1
> sequence at:
> 
> $ od -tx1 -Ax -c $TEST_DIR/junk.fsxgood | grep '77  db  f1'
> 008530  db  34  db  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d
> 03d000  77  db  f1  db  ba  db  01  db  d5  db  9c  db  4d  db  de  db
> 
> Curiously, the same byte trios at 0x2f000 and 0x30000 have similar
> repetitions at similar looking offsets:
> 
> $ od -tx1 -Ax -c $TEST_DIR/junk.fsxgood | grep 'b3  d8  35'
> 009530  d8  bb  d8  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b
> 03e000  b3  d8  35  d8  e2  d8  bb  d8  a4  d8  c8  d8  5b  d8  83  d8
> $ od -tx1 -Ax -c $TEST_DIR/junk.fsxgood | grep '23  d8  c8'
> 00a530  d8  f5  d8  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e
> 03f000  23  d8  c8  d8  22  d8  da  d8  97  d8  e0  d8  7e  d8  61  d8
> 
> Though the only pattern that happens consistently is that garbage bytes
> end up at the reflink dest, and later at the reflink source.  I never
> see any VM_BUG_ON_FOLIO asserts, nor does KASAN report anything.

Smells like the page cache over the clone source is not getting
marked dirty and/or flushed to disk correctly before the clone is
run. It then shares the extent with stale data to the new location
(the destination) which then fails the contents validation.

Do we have a case where we are only writing back the head page of
the multipage folio?

> I also added a debug function to dump the folios it finds in the
> pagecache for the fsx junk file, but nothing looks odd:
> 
>      522-5099  [001]   491.954659: console:              [U] FSX FAILURE
>   xfs_io-5125  [002]   491.961232: console:              XFS (sda): EXPERIMENTAL online scrub feature in use. Use at your own risk!
>   xfs_io-5125  [002]   491.961238: bprint:               filemap_dump: ino 0xb1 pos 0x0 pfn 0x515cc order 0
>   xfs_io-5125  [002]   491.961238: bprint:               filemap_dump: ino 0xb1 pos 0x1000 pfn 0x515cd order 0
>   xfs_io-5125  [002]   491.961239: bprint:               filemap_dump: ino 0xb1 pos 0x2000 pfn 0x515ce order 0
>   xfs_io-5125  [002]   491.961239: bprint:               filemap_dump: ino 0xb1 pos 0x3000 pfn 0x515cf order 0
>   xfs_io-5125  [002]   491.961239: bprint:               filemap_dump: ino 0xb1 pos 0x4000 pfn 0x50c48 order 0
>   xfs_io-5125  [002]   491.961240: bprint:               filemap_dump: ino 0xb1 pos 0x5000 pfn 0x50c49 order 0
>   xfs_io-5125  [002]   491.961240: bprint:               filemap_dump: ino 0xb1 pos 0x6000 pfn 0x50c4a order 0
>   xfs_io-5125  [002]   491.961241: bprint:               filemap_dump: ino 0xb1 pos 0x7000 pfn 0xc8a8 order 0
>   xfs_io-5125  [002]   491.961241: bprint:               filemap_dump: ino 0xb1 pos 0x8000 pfn 0x50988 order 2
>   xfs_io-5125  [002]   491.961241: bprint:               filemap_dump: ino 0xb1 pos 0xc000 pfn 0x509e0 order 2
>   xfs_io-5125  [002]   491.961242: bprint:               filemap_dump: ino 0xb1 pos 0x10000 pfn 0x4db64 order 2

So this is the folio that likely has the problem (the source)...

>   xfs_io-5125  [002]   491.961242: bprint:               filemap_dump: ino 0xb1 pos 0x14000 pfn 0x50c4c order 0
>   xfs_io-5125  [002]   491.961243: bprint:               filemap_dump: ino 0xb1 pos 0x15000 pfn 0x12485 order 0
>   xfs_io-5125  [002]   491.961243: bprint:               filemap_dump: ino 0xb1 pos 0x16000 pfn 0x50c4d order 0
>   xfs_io-5125  [002]   491.961243: bprint:               filemap_dump: ino 0xb1 pos 0x17000 pfn 0x50c4e order 0
>   xfs_io-5125  [002]   491.961244: bprint:               filemap_dump: ino 0xb1 pos 0x18000 pfn 0x4eef8 order 2
>   xfs_io-5125  [002]   491.961244: bprint:               filemap_dump: ino 0xb1 pos 0x1c000 pfn 0x4eefc order 2
>   xfs_io-5125  [002]   491.961245: bprint:               filemap_dump: ino 0xb1 pos 0x20000 pfn 0x4eef0 order 2
>   xfs_io-5125  [002]   491.961245: bprint:               filemap_dump: ino 0xb1 pos 0x24000 pfn 0x50f2c order 2
>   xfs_io-5125  [002]   491.961245: bprint:               filemap_dump: ino 0xb1 pos 0x28000 pfn 0x50f28 order 2
>   xfs_io-5125  [002]   491.961246: bprint:               filemap_dump: ino 0xb1 pos 0x2c000 pfn 0x50f24 order 2

... not the one at the destination here.

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Dave Chinner]

[cc linux-mm@kvack.org]

On Mon, Jun 27, 2022 at 03:16:19PM -0700, Darrick J. Wong wrote:
> On Mon, Jun 27, 2022 at 03:10:40PM +0100, Matthew Wilcox wrote:
> > On Sun, Jun 26, 2022 at 09:15:27PM -0700, Darrick J. Wong wrote:
> > > On Wed, Jun 22, 2022 at 05:42:11PM -0700, Darrick J. Wong wrote:
> > > > [resend with shorter 522.out file to keep us under the 300k maximum]
> > > > 
> > > > On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> > > > > Now that iomap has been converted, XFS is large folio safe.
> > > > > Indicate to the VFS that it can now create large folios for XFS.
> > > > > 
> > > > > Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> > > > > Reviewed-by: Christoph Hellwig <hch@lst.de>
> > > > > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> > > > > ---
> > > > >  fs/xfs/xfs_icache.c | 2 ++
> > > > >  1 file changed, 2 insertions(+)
> > > > > 
> > > > > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > > > > index da4af2142a2b..cdc39f576ca1 100644
> > > > > --- a/fs/xfs/xfs_icache.c
> > > > > +++ b/fs/xfs/xfs_icache.c
> > > > > @@ -87,6 +87,7 @@ xfs_inode_alloc(
> > > > >  	/* VFS doesn't initialise i_mode or i_state! */
> > > > >  	VFS_I(ip)->i_mode = 0;
> > > > >  	VFS_I(ip)->i_state = 0;
> > > > > +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
> > > > >  
> > > > >  	XFS_STATS_INC(mp, vn_active);
> > > > >  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> > > > > @@ -320,6 +321,7 @@ xfs_reinit_inode(
> > > > >  	inode->i_rdev = dev;
> > > > >  	inode->i_uid = uid;
> > > > >  	inode->i_gid = gid;
> > > > > +	mapping_set_large_folios(inode->i_mapping);
> > > > 
> > > > Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
> > > > reports file corruption after 20 minutes of runtime.  The corruption is
> > > > surprisingly reproducible (522.out.bad attached below) in that I ran it
> > > > three times and always got the same bad offset (0x6e000) and always the
> > > > same opcode (6213798(166 mod 256) MAPREAD).
> > > > 
> > > > I turned off multipage folios and now 522 has run for over an hour
> > > > without problems, so before I go do more debugging, does this ring a
> > > > bell to anyone?
> > > 
> > > I tried bisecting, but that didn't yield anything productive and
> > > 5.19-rc4 still fails after 25 minutes; however, it seems that g/522 will
> > > run without problems for at least 3-4 days after reverting this patch
> > > from -rc3.
> > > 
> > > So I guess I have a blunt force fix if we can't figure this one out
> > > before 5.19 final, but I'd really rather not.  Will keep trying this
> > > week.
> > 
> > I'm on holiday for the next week, so I'm not going to be able to spend
> > any time on this until then.  I have a suspicion that this may be the
> > same bug Zorro is seeing here:
> > 
> > https://lore.kernel.org/linux-mm/20220613010850.6kmpenitmuct2osb@zlang-mailbox/
> > 
> > At least I hope it is, and finding a folio that has been freed would
> > explain (apparent) file corruption.
> 
> Hm.  I suppose it /could/ be a lost folio getting into the works
> somewhere.
> 
> Today I remembered fsx -X, which makes this reproduce a bit faster (~3-8
> minutes instead of 20-25).  That has helped me to narrow things down a
> little more:
> 
> - Turning off INSERT/COLLAPSE_RANGE doesn't make the problem go away,
>   but it does make reading the fsx log much easier.
> 
> - Turning off clone/dedupe (either via -J -B or formatting with -m
>   reflink=0) makes the problem go away completely.  If you define
>   letting fsx run for 90 minutes as "completely".

So using this technique, I've discovered that there's a dirty page
accounting leak that eventually results in fsx hanging in
balance_dirty_pages().

[15300.670773] sysrq: Show Blocked State
[15300.672712] task:fsx             state:D stack:11600 pid: 5607 ppid:  5601 flags:0x00004004
[15300.676785] Call Trace:
[15300.678061]  <TASK>
[15300.679171]  __schedule+0x310/0x9f0
[15300.681096]  schedule+0x4b/0xb0
[15300.683385]  schedule_timeout+0x88/0x160
[15300.685407]  ? do_raw_spin_unlock+0x4b/0xa0
[15300.687567]  ? timer_migration_handler+0x90/0x90
[15300.690277]  io_schedule_timeout+0x4c/0x70
[15300.692346]  balance_dirty_pages_ratelimited+0x259/0xb60
[15300.695205]  fault_dirty_shared_page+0xef/0x100
[15300.697650]  do_wp_page+0x414/0x760
[15300.699819]  __handle_mm_fault+0xc59/0x1730
[15300.702226]  ? do_mmap+0x348/0x540
[15300.704418]  handle_mm_fault+0x7a/0x1c0
[15300.706658]  exc_page_fault+0x1da/0x780
[15300.709020]  asm_exc_page_fault+0x27/0x30

# cat /proc/meminfo
MemTotal:       16292348 kB
MemFree:        15298308 kB
MemAvailable:   15219180 kB
Buffers:           71336 kB
Cached:           209288 kB
SwapCached:            0 kB
Active:           141840 kB
Inactive:         254748 kB
Active(anon):        572 kB
Inactive(anon):   128000 kB
Active(file):     141268 kB
Inactive(file):   126748 kB
Unevictable:       12344 kB
Mlocked:           12344 kB
SwapTotal:        497976 kB
SwapFree:         497976 kB
Dirty:           2825676 kB	<<<<<<<<<
Writeback:             0 kB
AnonPages:        125072 kB
Mapped:            65592 kB
Shmem:              2128 kB
KReclaimable:      49424 kB
Slab:             110992 kB
SReclaimable:      49424 kB
SUnreclaim:        61568 kB
KernelStack:        4720 kB
PageTables:         4000 kB
NFS_Unstable:          0 kB
Bounce:                0 kB
WritebackTmp:          0 kB
CommitLimit:     8644148 kB
Committed_AS:     277864 kB
VmallocTotal:   34359738367 kB
VmallocUsed:       46604 kB
VmallocChunk:          0 kB
Percpu:             5376 kB
AnonHugePages:     30720 kB
ShmemHugePages:        0 kB
ShmemPmdMapped:        0 kB
FileHugePages:         0 kB
FilePmdMapped:         0 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:       2048 kB
Hugetlb:               0 kB
DirectMap4k:       61276 kB
DirectMap2M:     6230016 kB
DirectMap1G:    29360128 kB

As you can see, the system only has 1GB of 16GB of memory used, but
it's got 2.8GB of dirty pages accounted and so any write that is
done will now hang on the dirty page throttle.

sysrq-m shows:

[15443.617242] sysrq: Show Memory
[15443.618465] Mem-Info:
[15443.619428] active_anon:143 inactive_anon:32000 isolated_anon:0
[15443.619428]  active_file:35317 inactive_file:31687 isolated_file:0
[15443.619428]  unevictable:3086 dirty:706420 writeback:0
[15443.619428]  slab_reclaimable:12356 slab_unreclaimable:15392
[15443.619428]  mapped:16398 shmem:532 pagetables:1000 bounce:0
[15443.619428]  kernel_misc_reclaimable:0
[15443.619428]  free:3825037 free_pcp:34496 free_cma:0
[15443.632592] Node 0 active_anon:152kB inactive_anon:17812kB active_file:27304kB inactive_file:19200kB unevictable:832kB isolated(anon
):0kB isolated(file):0kB mapped:8820kB dirty:632kB writeback:0kB shmem:224kB shmem_thp: 0kB shmem_pmdmapped: 0kB anon_thp: 0kB writebac
k_tmp:0kB kernel_stack:1332kB pagetables:812kB all_unreclaimable? no
[15443.643111] Node 1 active_anon:168kB inactive_anon:54348kB active_file:52160kB inactive_file:19808kB unevictable:6932kB isolated(ano
n):0kB isolated(file):0kB mapped:29512kB dirty:0kB writeback:0kB shmem:596kB shmem_thp: 0kB shmem_pmdmapped: 0kB anon_thp: 14336kB writ
eback_tmp:0kB kernel_stack:836kB pagetables:1212kB all_unreclaimable? no
[15443.653719] Node 2 active_anon:152kB inactive_anon:31780kB active_file:32604kB inactive_file:62196kB unevictable:3324kB isolated(ano
n):0kB isolated(file):0kB mapped:11560kB dirty:0kB writeback:0kB shmem:216kB shmem_thp: 0kB shmem_pmdmapped: 0kB anon_thp: 8192kB write
back_tmp:0kB kernel_stack:1268kB pagetables:1084kB all_unreclaimable? no
[15443.664282] Node 3 active_anon:100kB inactive_anon:24060kB active_file:29200kB inactive_file:25544kB unevictable:1256kB isolated(ano
n):0kB isolated(file):0kB mapped:15700kB dirty:2825048kB writeback:0kB shmem:1092kB shmem_thp: 0kB shmem_pmdmapped: 0kB anon_thp: 10240
kB writeback_tmp:0kB kernel_stack:1268kB pagetables:892kB all_unreclaimable? no
[15443.673605] Node 0 DMA free:15360kB boost:0kB min:124kB low:152kB high:180kB reserved_highatomic:0KB active_anon:0kB inactive_anon:0
kB active_file:0kB inactive_file:0kB unevictable:0kB writepending:0kB present:15992kB managed:15360kB mlocked:0kB bounce:0kB free_pcp:0
kB local_pcp:0kB free_cma:0kB
[15443.680976] lowmem_reserve[]: 0 2911 7902 7902 7902
[15443.682360] Node 0 DMA32 free:2981444kB boost:0kB min:24744kB low:30928kB high:37112kB reserved_highatomic:0KB active_anon:0kB inact
ive_anon:0kB active_file:0kB inactive_file:0kB unevictable:0kB writepending:0kB present:3129180kB managed:2986368kB mlocked:0kB bounce:
0kB free_pcp:4916kB local_pcp:0kB free_cma:0kB
[15443.689280] lowmem_reserve[]: 0 0 4990 4990 4990
[15443.690450] Node 0 Normal free:4968904kB boost:0kB min:42412kB low:53012kB high:63612kB reserved_highatomic:0KB active_anon:152kB in
active_anon:17812kB active_file:27304kB inactive_file:19200kB unevictable:832kB writepending:632kB present:5242880kB managed:5110756kB 
mlocked:832kB bounce:0kB free_pcp:41008kB local_pcp:5944kB free_cma:0kB
[15443.697102] lowmem_reserve[]: 0 0 0 0 0
[15443.697986] Node 1 Normal free:5806356kB boost:0kB min:51384kB low:64228kB high:77072kB reserved_highatomic:0KB active_anon:168kB in
active_anon:54348kB active_file:52160kB inactive_file:19808kB unevictable:6932kB writepending:0kB present:6291456kB managed:6192112kB m
locked:6932kB bounce:0kB free_pcp:68644kB local_pcp:15328kB free_cma:0kB
[15443.704154] lowmem_reserve[]: 0 0 0 0 0
[15443.705005] Node 2 Normal free:714616kB boost:0kB min:8556kB low:10692kB high:12828kB reserved_highatomic:0KB active_anon:152kB inac
tive_anon:31780kB active_file:32604kB inactive_file:62196kB unevictable:3324kB writepending:0kB present:1048576kB managed:1031152kB mlo
cked:3324kB bounce:0kB free_pcp:10904kB local_pcp:0kB free_cma:0kB
[15443.712094] lowmem_reserve[]: 0 0 0 0 0
[15443.713270] Node 3 Normal free:813468kB boost:0kB min:7936kB low:9920kB high:11904kB reserved_highatomic:0KB active_anon:100kB inact
ive_anon:24060kB active_file:29200kB inactive_file:25544kB unevictable:1256kB writepending:2825212kB present:1048576kB managed:956600kB
 mlocked:1256kB bounce:0kB free_pcp:12508kB local_pcp:388kB free_cma:0kB
[15443.721013] lowmem_reserve[]: 0 0 0 0 0
[15443.721958] Node 0 DMA: 0*4kB 0*8kB 0*16kB 0*32kB 0*64kB 0*128kB 0*256kB 0*512kB 1*1024kB (U) 1*2048kB (M) 3*4096kB (M) = 15360kB
[15443.725048] Node 0 DMA32: 3*4kB (UM) 1*8kB (M) 1*16kB (M) 1*32kB (M) 2*64kB (M) 1*128kB (M) 3*256kB (UM) 3*512kB (UM) 3*1024kB (UM) 
3*2048kB (UM) 725*4096kB (M) = 2981444kB
[15443.729512] Node 0 Normal: 1714*4kB (UME) 1504*8kB (UME) 988*16kB (UME) 562*32kB (UME) 268*64kB (UME) 96*128kB (UME) 27*256kB (UME) 
5*512kB (UM) 1*1024kB (E) 5*2048kB (UME) 1188*4096kB (M) = 4968904kB
[15443.734684] Node 1 Normal: 977*4kB (UM) 1086*8kB (UME) 406*16kB (UME) 210*32kB (UM) 133*64kB (UME) 116*128kB (UME) 37*256kB (UM) 18*
512kB (UM) 12*1024kB (UME) 2*2048kB (UM) 1397*4096kB (M) = 5806356kB
[15443.739997] Node 2 Normal: 456*4kB (UME) 307*8kB (UM) 136*16kB (UME) 138*32kB (UME) 44*64kB (UME) 10*128kB (UE) 21*256kB (UM) 12*512
kB (UM) 6*1024kB (UM) 7*2048kB (UME) 163*4096kB (UM) = 714616kB
[15443.745261] Node 3 Normal: 463*4kB (UM) 940*8kB (UM) 392*16kB (UME) 210*32kB (UME) 121*64kB (UME) 40*128kB (UME) 2*256kB (ME) 1*512k
B (U) 1*1024kB (E) 3*2048kB (UME) 188*4096kB (M) = 813468kB
[15443.750265] Node 0 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=1048576kB
[15443.752776] Node 0 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=2048kB
[15443.755614] Node 1 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=1048576kB
[15443.758256] Node 1 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=2048kB
[15443.761168] Node 2 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=1048576kB
[15443.763996] Node 2 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=2048kB
[15443.766634] Node 3 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=1048576kB
[15443.769423] Node 3 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=2048kB
[15443.772050] 70156 total pagecache pages
[15443.773364] 0 pages in swap cache
[15443.774535] Swap cache stats: add 0, delete 0, find 0/0
[15443.776213] Free swap  = 497976kB
[15443.777394] Total swap = 497976kB
[15443.778606] 4194165 pages RAM
[15443.779551] 0 pages HighMem/MovableOnly
[15443.780705] 121078 pages reserved

It is node 3 that fsx has been running on and it's the only
node that has been leaking dirty pages. Node 3 only
has 1GB of pages present, so having 2.8GB of dirty pages on the node
is just a little wrong. ZONE_NR_WRITE_PENDING, NR_FILE_DIRTY and
NR_DIRTY all match in terms of leaking dirty pages.

The reproducer for 5.19-rc4 is running fsx from fstests like so:

<create 8GB pmem/ramdisk>
mkfs.xfs -f /dev/pmem0
mount /dev/pmem0 /mnt/test
src/fstests/ltp/fsx q -N 100000000 -p 1000000 -o 128000 -l 600000 -C -I -X /mnt/test/junk

And this will leak around 300-400kB of dirty pages every second.

I suspect this is the same problem as the data corruption that
Darrick is seeing - that smells of a dirty multi-page folio that
hasn't been fully written back. e.g. a multipage folio gets marked
dirty so accounts mulitple pages dirty, but only a single page of
the folio is written and marked clean, leaking both dirty page
accounting and stale data contents on disk that fsx eventually trips
over.

I can't find a likely cause through reading the code, so maybe
someone who knows the mm accounting code better than I do can spot
the problem....

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Matthew Wilcox]

On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> So using this technique, I've discovered that there's a dirty page
> accounting leak that eventually results in fsx hanging in
> balance_dirty_pages().

Alas, I think this is only an accounting error, and not related to
the problem(s) that Darrick & Zorro are seeing.  I think what you're
seeing is dirty pages being dropped at truncation without the
appropriate accounting.  ie this should be the fix:

+++ b/mm/huge_memory.c
@@ -2443,6 +2443,8 @@ static void __split_huge_page(struct page *page, struct list_head *list,
                        __delete_from_page_cache(head + i, NULL);
                        if (shmem_mapping(head->mapping))
                                shmem_uncharge(head->mapping->host, 1);
+                       else
+                               folio_account_cleaned(page_folio(head + i));
                        put_page(head + i);
                } else if (!PageAnon(page)) {
                        __xa_store(&head->mapping->i_pages, head[i].index,

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Matthew Wilcox]

On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > So using this technique, I've discovered that there's a dirty page
> > accounting leak that eventually results in fsx hanging in
> > balance_dirty_pages().
> 
> Alas, I think this is only an accounting error, and not related to
> the problem(s) that Darrick & Zorro are seeing.  I think what you're
> seeing is dirty pages being dropped at truncation without the
> appropriate accounting.  ie this should be the fix:

Argh, try one that actually compiles.

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index f7248002dad9..0553ae90509f 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -18,6 +18,7 @@
 #include <linux/shrinker.h>
 #include <linux/mm_inline.h>
 #include <linux/swapops.h>
+#include <linux/backing-dev.h>
 #include <linux/dax.h>
 #include <linux/khugepaged.h>
 #include <linux/freezer.h>
@@ -2443,6 +2444,9 @@ static void __split_huge_page(struct page *page, struct list_head *list,
 			__delete_from_page_cache(head + i, NULL);
 			if (shmem_mapping(head->mapping))
 				shmem_uncharge(head->mapping->host, 1);
+			else
+				folio_account_cleaned(page_folio(head + i),
+					inode_to_wb(folio->mapping->host));
 			put_page(head + i);
 		} else if (!PageAnon(page)) {
 			__xa_store(&head->mapping->i_pages, head[i].index,

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Matthew Wilcox]

On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > So using this technique, I've discovered that there's a dirty page
> > > accounting leak that eventually results in fsx hanging in
> > > balance_dirty_pages().
> > 
> > Alas, I think this is only an accounting error, and not related to
> > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > seeing is dirty pages being dropped at truncation without the
> > appropriate accounting.  ie this should be the fix:
> 
> Argh, try one that actually compiles.

... that one's going to underflow the accounting.  Maybe I shouldn't
be writing code at 6am?

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index f7248002dad9..4eec6ee83e44 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -18,6 +18,7 @@
 #include <linux/shrinker.h>
 #include <linux/mm_inline.h>
 #include <linux/swapops.h>
+#include <linux/backing-dev.h>
 #include <linux/dax.h>
 #include <linux/khugepaged.h>
 #include <linux/freezer.h>
@@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
 		__split_huge_page_tail(head, i, lruvec, list);
 		/* Some pages can be beyond EOF: drop them from page cache */
 		if (head[i].index >= end) {
-			ClearPageDirty(head + i);
-			__delete_from_page_cache(head + i, NULL);
+			struct folio *tail = page_folio(head + i);
+
 			if (shmem_mapping(head->mapping))
 				shmem_uncharge(head->mapping->host, 1);
-			put_page(head + i);
+			else if (folio_test_clear_dirty(tail))
+				folio_account_cleaned(tail,
+					inode_to_wb(folio->mapping->host));
+			__filemap_remove_folio(tail, NULL);
+			folio_put(tail);
 		} else if (!PageAnon(page)) {
 			__xa_store(&head->mapping->i_pages, head[i].index,
 					head + i, 0);

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Darrick J. Wong]

On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > So using this technique, I've discovered that there's a dirty page
> > > > accounting leak that eventually results in fsx hanging in
> > > > balance_dirty_pages().
> > > 
> > > Alas, I think this is only an accounting error, and not related to
> > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > seeing is dirty pages being dropped at truncation without the
> > > appropriate accounting.  ie this should be the fix:
> > 
> > Argh, try one that actually compiles.
> 
> ... that one's going to underflow the accounting.  Maybe I shouldn't
> be writing code at 6am?

I dunno, it's been running on my test VMs for 160 minutes (same debug
setup as yesterday) and 100 minutes (regular g/522, no -C/-I flags to
fsx, no debugging junk) and neither have reported corruptions.

$ grep Dirty /proc/meminfo
Dirty:               100 kB

So, pretty good for writing code at 6am while on holiday.  I'll let this
run overnight, but I think you've fixed the problem, at least for me...

--D

> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index f7248002dad9..4eec6ee83e44 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -18,6 +18,7 @@
>  #include <linux/shrinker.h>
>  #include <linux/mm_inline.h>
>  #include <linux/swapops.h>
> +#include <linux/backing-dev.h>
>  #include <linux/dax.h>
>  #include <linux/khugepaged.h>
>  #include <linux/freezer.h>
> @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
>  		__split_huge_page_tail(head, i, lruvec, list);
>  		/* Some pages can be beyond EOF: drop them from page cache */
>  		if (head[i].index >= end) {
> -			ClearPageDirty(head + i);
> -			__delete_from_page_cache(head + i, NULL);
> +			struct folio *tail = page_folio(head + i);
> +
>  			if (shmem_mapping(head->mapping))
>  				shmem_uncharge(head->mapping->host, 1);
> -			put_page(head + i);
> +			else if (folio_test_clear_dirty(tail))
> +				folio_account_cleaned(tail,
> +					inode_to_wb(folio->mapping->host));
> +			__filemap_remove_folio(tail, NULL);
> +			folio_put(tail);
>  		} else if (!PageAnon(page)) {
>  			__xa_store(&head->mapping->i_pages, head[i].index,
>  					head + i, 0);

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Dave Chinner]

On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > So using this technique, I've discovered that there's a dirty page
> > > > accounting leak that eventually results in fsx hanging in
> > > > balance_dirty_pages().
> > > 
> > > Alas, I think this is only an accounting error, and not related to
> > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > seeing is dirty pages being dropped at truncation without the
> > > appropriate accounting.  ie this should be the fix:
> > 
> > Argh, try one that actually compiles.
> 
> ... that one's going to underflow the accounting.  Maybe I shouldn't
> be writing code at 6am?
> 
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index f7248002dad9..4eec6ee83e44 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -18,6 +18,7 @@
>  #include <linux/shrinker.h>
>  #include <linux/mm_inline.h>
>  #include <linux/swapops.h>
> +#include <linux/backing-dev.h>
>  #include <linux/dax.h>
>  #include <linux/khugepaged.h>
>  #include <linux/freezer.h>
> @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
>  		__split_huge_page_tail(head, i, lruvec, list);
>  		/* Some pages can be beyond EOF: drop them from page cache */
>  		if (head[i].index >= end) {
> -			ClearPageDirty(head + i);
> -			__delete_from_page_cache(head + i, NULL);
> +			struct folio *tail = page_folio(head + i);
> +
>  			if (shmem_mapping(head->mapping))
>  				shmem_uncharge(head->mapping->host, 1);
> -			put_page(head + i);
> +			else if (folio_test_clear_dirty(tail))
> +				folio_account_cleaned(tail,
> +					inode_to_wb(folio->mapping->host));
> +			__filemap_remove_folio(tail, NULL);
> +			folio_put(tail);
>  		} else if (!PageAnon(page)) {
>  			__xa_store(&head->mapping->i_pages, head[i].index,
>  					head + i, 0);
> 

Yup, that fixes the leak.

Tested-by: Dave Chinner <dchinner@redhat.com>

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Darrick J. Wong]

On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > So using this technique, I've discovered that there's a dirty page
> > > > > accounting leak that eventually results in fsx hanging in
> > > > > balance_dirty_pages().
> > > > 
> > > > Alas, I think this is only an accounting error, and not related to
> > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > seeing is dirty pages being dropped at truncation without the
> > > > appropriate accounting.  ie this should be the fix:
> > > 
> > > Argh, try one that actually compiles.
> > 
> > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > be writing code at 6am?
> > 
> > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > index f7248002dad9..4eec6ee83e44 100644
> > --- a/mm/huge_memory.c
> > +++ b/mm/huge_memory.c
> > @@ -18,6 +18,7 @@
> >  #include <linux/shrinker.h>
> >  #include <linux/mm_inline.h>
> >  #include <linux/swapops.h>
> > +#include <linux/backing-dev.h>
> >  #include <linux/dax.h>
> >  #include <linux/khugepaged.h>
> >  #include <linux/freezer.h>
> > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> >  		__split_huge_page_tail(head, i, lruvec, list);
> >  		/* Some pages can be beyond EOF: drop them from page cache */
> >  		if (head[i].index >= end) {
> > -			ClearPageDirty(head + i);
> > -			__delete_from_page_cache(head + i, NULL);
> > +			struct folio *tail = page_folio(head + i);
> > +
> >  			if (shmem_mapping(head->mapping))
> >  				shmem_uncharge(head->mapping->host, 1);
> > -			put_page(head + i);
> > +			else if (folio_test_clear_dirty(tail))
> > +				folio_account_cleaned(tail,
> > +					inode_to_wb(folio->mapping->host));
> > +			__filemap_remove_folio(tail, NULL);
> > +			folio_put(tail);
> >  		} else if (!PageAnon(page)) {
> >  			__xa_store(&head->mapping->i_pages, head[i].index,
> >  					head + i, 0);
> > 
> 
> Yup, that fixes the leak.
> 
> Tested-by: Dave Chinner <dchinner@redhat.com>

Four hours of generic/522 running is long enough to conclude that this
is likely the fix for my problem and migrate long soak testing to my
main g/522 rig and:

Tested-by: Darrick J. Wong <djwong@kernel.org>

--D

> Cheers,
> 
> Dave.
> -- 
> Dave Chinner
> david@fromorbit.com

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Brian Foster]

On Tue, Jun 28, 2022 at 04:21:55PM -0700, Darrick J. Wong wrote:
> On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> > On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > > So using this technique, I've discovered that there's a dirty page
> > > > > > accounting leak that eventually results in fsx hanging in
> > > > > > balance_dirty_pages().
> > > > > 
> > > > > Alas, I think this is only an accounting error, and not related to
> > > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > > seeing is dirty pages being dropped at truncation without the
> > > > > appropriate accounting.  ie this should be the fix:
> > > > 
> > > > Argh, try one that actually compiles.
> > > 
> > > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > > be writing code at 6am?
> > > 
> > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > > index f7248002dad9..4eec6ee83e44 100644
> > > --- a/mm/huge_memory.c
> > > +++ b/mm/huge_memory.c
> > > @@ -18,6 +18,7 @@
> > >  #include <linux/shrinker.h>
> > >  #include <linux/mm_inline.h>
> > >  #include <linux/swapops.h>
> > > +#include <linux/backing-dev.h>
> > >  #include <linux/dax.h>
> > >  #include <linux/khugepaged.h>
> > >  #include <linux/freezer.h>
> > > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> > >  		__split_huge_page_tail(head, i, lruvec, list);
> > >  		/* Some pages can be beyond EOF: drop them from page cache */
> > >  		if (head[i].index >= end) {
> > > -			ClearPageDirty(head + i);
> > > -			__delete_from_page_cache(head + i, NULL);
> > > +			struct folio *tail = page_folio(head + i);
> > > +
> > >  			if (shmem_mapping(head->mapping))
> > >  				shmem_uncharge(head->mapping->host, 1);
> > > -			put_page(head + i);
> > > +			else if (folio_test_clear_dirty(tail))
> > > +				folio_account_cleaned(tail,
> > > +					inode_to_wb(folio->mapping->host));
> > > +			__filemap_remove_folio(tail, NULL);
> > > +			folio_put(tail);
> > >  		} else if (!PageAnon(page)) {
> > >  			__xa_store(&head->mapping->i_pages, head[i].index,
> > >  					head + i, 0);
> > > 
> > 
> > Yup, that fixes the leak.
> > 
> > Tested-by: Dave Chinner <dchinner@redhat.com>
> 
> Four hours of generic/522 running is long enough to conclude that this
> is likely the fix for my problem and migrate long soak testing to my
> main g/522 rig and:
> 
> Tested-by: Darrick J. Wong <djwong@kernel.org>
> 

Just based on Willy's earlier comment.. what I would probably be a
little careful/curious about here is whether the accounting fix leads to
an indirect behavior change that does impact reproducibility of the
corruption problem. For example, does artificially escalated dirty page
tracking lead to increased reclaim/writeback activity than might
otherwise occur, and thus contend with the fs workload? Clearly it has
some impact based on Dave's balance_dirty_pages() problem reproducer,
but I don't know if it extends beyond that off the top of my head. That
might make some sense if the workload is fsx, since that doesn't
typically stress cache/memory usage the way a large fsstress workload or
something might.

So for example, interesting questions might be... Do your corruption
events happen to correspond with dirty page accounting crossing some
threshold based on available memory in your test environment? Does
reducing available memory affect reproducibility? Etc.

Brian

> --D
> 
> > Cheers,
> > 
> > Dave.
> > -- 
> > Dave Chinner
> > david@fromorbit.com
> 

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Darrick J. Wong]

On Wed, Jun 29, 2022 at 08:57:30AM -0400, Brian Foster wrote:
> On Tue, Jun 28, 2022 at 04:21:55PM -0700, Darrick J. Wong wrote:
> > On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> > > On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > > > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > > > So using this technique, I've discovered that there's a dirty page
> > > > > > > accounting leak that eventually results in fsx hanging in
> > > > > > > balance_dirty_pages().
> > > > > > 
> > > > > > Alas, I think this is only an accounting error, and not related to
> > > > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > > > seeing is dirty pages being dropped at truncation without the
> > > > > > appropriate accounting.  ie this should be the fix:
> > > > > 
> > > > > Argh, try one that actually compiles.
> > > > 
> > > > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > > > be writing code at 6am?
> > > > 
> > > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > > > index f7248002dad9..4eec6ee83e44 100644
> > > > --- a/mm/huge_memory.c
> > > > +++ b/mm/huge_memory.c
> > > > @@ -18,6 +18,7 @@
> > > >  #include <linux/shrinker.h>
> > > >  #include <linux/mm_inline.h>
> > > >  #include <linux/swapops.h>
> > > > +#include <linux/backing-dev.h>
> > > >  #include <linux/dax.h>
> > > >  #include <linux/khugepaged.h>
> > > >  #include <linux/freezer.h>
> > > > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> > > >  		__split_huge_page_tail(head, i, lruvec, list);
> > > >  		/* Some pages can be beyond EOF: drop them from page cache */
> > > >  		if (head[i].index >= end) {
> > > > -			ClearPageDirty(head + i);
> > > > -			__delete_from_page_cache(head + i, NULL);
> > > > +			struct folio *tail = page_folio(head + i);
> > > > +
> > > >  			if (shmem_mapping(head->mapping))
> > > >  				shmem_uncharge(head->mapping->host, 1);
> > > > -			put_page(head + i);
> > > > +			else if (folio_test_clear_dirty(tail))
> > > > +				folio_account_cleaned(tail,
> > > > +					inode_to_wb(folio->mapping->host));
> > > > +			__filemap_remove_folio(tail, NULL);
> > > > +			folio_put(tail);
> > > >  		} else if (!PageAnon(page)) {
> > > >  			__xa_store(&head->mapping->i_pages, head[i].index,
> > > >  					head + i, 0);
> > > > 
> > > 
> > > Yup, that fixes the leak.
> > > 
> > > Tested-by: Dave Chinner <dchinner@redhat.com>
> > 
> > Four hours of generic/522 running is long enough to conclude that this
> > is likely the fix for my problem and migrate long soak testing to my
> > main g/522 rig and:
> > 
> > Tested-by: Darrick J. Wong <djwong@kernel.org>
> > 
> 
> Just based on Willy's earlier comment.. what I would probably be a
> little careful/curious about here is whether the accounting fix leads to
> an indirect behavior change that does impact reproducibility of the
> corruption problem. For example, does artificially escalated dirty page
> tracking lead to increased reclaim/writeback activity than might
> otherwise occur, and thus contend with the fs workload? Clearly it has
> some impact based on Dave's balance_dirty_pages() problem reproducer,
> but I don't know if it extends beyond that off the top of my head. That
> might make some sense if the workload is fsx, since that doesn't
> typically stress cache/memory usage the way a large fsstress workload or
> something might.
> 
> So for example, interesting questions might be... Do your corruption
> events happen to correspond with dirty page accounting crossing some
> threshold based on available memory in your test environment? Does
> reducing available memory affect reproducibility? Etc.

Yeah, I wonder that too now.  I managed to trace generic/522 a couple of
times before willy's patch dropped.  From what I could tell, a large
folio X would get page P assigned to the fsx file's page cache to cover
range R, dirtied, and written to disk.  At some point later, we'd
reflink into part of the file range adjacent to P, but not P itself.
I /think/ that should have caused the whole folio to get invalidated?

Then some more things happened (none of which dirtied R, according to
fsx) and then suddenly writeback would trigger on some page (don't know
which) that would write to the disk blocks backing R.  I'm fairly sure
that's where the incorrect disk contents came from.

Next, we'd reflink part of the file range including R into a different
part of the file (call it R2).  fsx would read R2, bringing a new page
into cache, and it wouldn't match the fsxgood buffer, leading to fsx
aborting.

After a umount/mount cycle, reading R and R2 would both reveal the
incorrect contents that had caused fsx to abort.

Unfortunately the second ftrace attempt ate some trace data, so I was
unable to figure out if the same thing happened again.

At this point I really need to get on reviewing patches for 5.20, so
I'll try to keep poking at this (examining the trace data requires a lot
of concentration which isn't really possible while sawzall construction
is going on at home) but at worst I can ask Linus to merge a patch for
5.19 final that makes setting mapping_set_large_folio a
Kconfig/CONFIG_XFS_DEBUG option.

--D

> 
> Brian
> 
> > --D
> > 
> > > Cheers,
> > > 
> > > Dave.
> > > -- 
> > > Dave Chinner
> > > david@fromorbit.com
> > 
> 

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Brian Foster]

On Wed, Jun 29, 2022 at 01:22:06PM -0700, Darrick J. Wong wrote:
> On Wed, Jun 29, 2022 at 08:57:30AM -0400, Brian Foster wrote:
> > On Tue, Jun 28, 2022 at 04:21:55PM -0700, Darrick J. Wong wrote:
> > > On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> > > > On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > > > > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > > > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > > > > So using this technique, I've discovered that there's a dirty page
> > > > > > > > accounting leak that eventually results in fsx hanging in
> > > > > > > > balance_dirty_pages().
> > > > > > > 
> > > > > > > Alas, I think this is only an accounting error, and not related to
> > > > > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > > > > seeing is dirty pages being dropped at truncation without the
> > > > > > > appropriate accounting.  ie this should be the fix:
> > > > > > 
> > > > > > Argh, try one that actually compiles.
> > > > > 
> > > > > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > > > > be writing code at 6am?
> > > > > 
> > > > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > > > > index f7248002dad9..4eec6ee83e44 100644
> > > > > --- a/mm/huge_memory.c
> > > > > +++ b/mm/huge_memory.c
> > > > > @@ -18,6 +18,7 @@
> > > > >  #include <linux/shrinker.h>
> > > > >  #include <linux/mm_inline.h>
> > > > >  #include <linux/swapops.h>
> > > > > +#include <linux/backing-dev.h>
> > > > >  #include <linux/dax.h>
> > > > >  #include <linux/khugepaged.h>
> > > > >  #include <linux/freezer.h>
> > > > > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> > > > >  		__split_huge_page_tail(head, i, lruvec, list);
> > > > >  		/* Some pages can be beyond EOF: drop them from page cache */
> > > > >  		if (head[i].index >= end) {
> > > > > -			ClearPageDirty(head + i);
> > > > > -			__delete_from_page_cache(head + i, NULL);
> > > > > +			struct folio *tail = page_folio(head + i);
> > > > > +
> > > > >  			if (shmem_mapping(head->mapping))
> > > > >  				shmem_uncharge(head->mapping->host, 1);
> > > > > -			put_page(head + i);
> > > > > +			else if (folio_test_clear_dirty(tail))
> > > > > +				folio_account_cleaned(tail,
> > > > > +					inode_to_wb(folio->mapping->host));
> > > > > +			__filemap_remove_folio(tail, NULL);
> > > > > +			folio_put(tail);
> > > > >  		} else if (!PageAnon(page)) {
> > > > >  			__xa_store(&head->mapping->i_pages, head[i].index,
> > > > >  					head + i, 0);
> > > > > 
> > > > 
> > > > Yup, that fixes the leak.
> > > > 
> > > > Tested-by: Dave Chinner <dchinner@redhat.com>
> > > 
> > > Four hours of generic/522 running is long enough to conclude that this
> > > is likely the fix for my problem and migrate long soak testing to my
> > > main g/522 rig and:
> > > 
> > > Tested-by: Darrick J. Wong <djwong@kernel.org>
> > > 
> > 
> > Just based on Willy's earlier comment.. what I would probably be a
> > little careful/curious about here is whether the accounting fix leads to
> > an indirect behavior change that does impact reproducibility of the
> > corruption problem. For example, does artificially escalated dirty page
> > tracking lead to increased reclaim/writeback activity than might
> > otherwise occur, and thus contend with the fs workload? Clearly it has
> > some impact based on Dave's balance_dirty_pages() problem reproducer,
> > but I don't know if it extends beyond that off the top of my head. That
> > might make some sense if the workload is fsx, since that doesn't
> > typically stress cache/memory usage the way a large fsstress workload or
> > something might.
> > 
> > So for example, interesting questions might be... Do your corruption
> > events happen to correspond with dirty page accounting crossing some
> > threshold based on available memory in your test environment? Does
> > reducing available memory affect reproducibility? Etc.
> 
> Yeah, I wonder that too now.  I managed to trace generic/522 a couple of
> times before willy's patch dropped.  From what I could tell, a large
> folio X would get page P assigned to the fsx file's page cache to cover
> range R, dirtied, and written to disk.  At some point later, we'd
> reflink into part of the file range adjacent to P, but not P itself.
> I /think/ that should have caused the whole folio to get invalidated?
> 
> Then some more things happened (none of which dirtied R, according to
> fsx) and then suddenly writeback would trigger on some page (don't know
> which) that would write to the disk blocks backing R.  I'm fairly sure
> that's where the incorrect disk contents came from.
> 
> Next, we'd reflink part of the file range including R into a different
> part of the file (call it R2).  fsx would read R2, bringing a new page
> into cache, and it wouldn't match the fsxgood buffer, leading to fsx
> aborting.
> 
> After a umount/mount cycle, reading R and R2 would both reveal the
> incorrect contents that had caused fsx to abort.
> 

FWIW, I hadn't been able to reproduce this in my default environment to
this point. With the memory leak issue in the light, I was eventually
able to by reducing dirty_bytes to something the system would be more
likely to hit sooner (i.e. 16-32MB), but I also see stalling behavior
and whatnot due to the leak that requires backing off from the specified
dirty limit every so often.

If I apply the accounting patch to avoid the leak and set
dirty_background_bytes to something notably aggressive (1kB), the test
survived 100 iterations or so before I stopped it. If I then set
dirty_bytes to something similarly aggressive (1MB), I hit the failure
on the next iteration (assuming it's the same problem). It's spinning
again at ~25 or so iterations without a failure so far, so I'd have to
wait and see how reliable the reproducer really is. Though if it doesn't
reoccur soonish, perhaps I'll try reducing dirty_bytes a bit more...

My suspicion based on these characteristics would be that the blocking
limit triggers more aggressive reclaim/invalidation, and thus helps
detect the problem sooner. If reflink is involved purely as a cache
invalidation step (i.e. so a subsequent read will hit the disk and
detect a cache inconsistency), then it might be interesting to see if it
can still be reproduced without reflink operations enabled but instead
with some combination of the -f/-X fsx flags to perform more flush
invals and on-disk data checks..

Brian

> Unfortunately the second ftrace attempt ate some trace data, so I was
> unable to figure out if the same thing happened again.
> 
> At this point I really need to get on reviewing patches for 5.20, so
> I'll try to keep poking at this (examining the trace data requires a lot
> of concentration which isn't really possible while sawzall construction
> is going on at home) but at worst I can ask Linus to merge a patch for
> 5.19 final that makes setting mapping_set_large_folio a
> Kconfig/CONFIG_XFS_DEBUG option.
> 
> --D
> 
> > 
> > Brian
> > 
> > > --D
> > > 
> > > > Cheers,
> > > > 
> > > > Dave.
> > > > -- 
> > > > Dave Chinner
> > > > david@fromorbit.com
> > > 
> > 
> 

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Darrick J. Wong]

On Fri, Jul 01, 2022 at 12:03:23PM -0400, Brian Foster wrote:
> On Wed, Jun 29, 2022 at 01:22:06PM -0700, Darrick J. Wong wrote:
> > On Wed, Jun 29, 2022 at 08:57:30AM -0400, Brian Foster wrote:
> > > On Tue, Jun 28, 2022 at 04:21:55PM -0700, Darrick J. Wong wrote:
> > > > On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> > > > > On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > > > > > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > > > > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > > > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > > > > > So using this technique, I've discovered that there's a dirty page
> > > > > > > > > accounting leak that eventually results in fsx hanging in
> > > > > > > > > balance_dirty_pages().
> > > > > > > > 
> > > > > > > > Alas, I think this is only an accounting error, and not related to
> > > > > > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > > > > > seeing is dirty pages being dropped at truncation without the
> > > > > > > > appropriate accounting.  ie this should be the fix:
> > > > > > > 
> > > > > > > Argh, try one that actually compiles.
> > > > > > 
> > > > > > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > > > > > be writing code at 6am?
> > > > > > 
> > > > > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > > > > > index f7248002dad9..4eec6ee83e44 100644
> > > > > > --- a/mm/huge_memory.c
> > > > > > +++ b/mm/huge_memory.c
> > > > > > @@ -18,6 +18,7 @@
> > > > > >  #include <linux/shrinker.h>
> > > > > >  #include <linux/mm_inline.h>
> > > > > >  #include <linux/swapops.h>
> > > > > > +#include <linux/backing-dev.h>
> > > > > >  #include <linux/dax.h>
> > > > > >  #include <linux/khugepaged.h>
> > > > > >  #include <linux/freezer.h>
> > > > > > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> > > > > >  		__split_huge_page_tail(head, i, lruvec, list);
> > > > > >  		/* Some pages can be beyond EOF: drop them from page cache */
> > > > > >  		if (head[i].index >= end) {
> > > > > > -			ClearPageDirty(head + i);
> > > > > > -			__delete_from_page_cache(head + i, NULL);
> > > > > > +			struct folio *tail = page_folio(head + i);
> > > > > > +
> > > > > >  			if (shmem_mapping(head->mapping))
> > > > > >  				shmem_uncharge(head->mapping->host, 1);
> > > > > > -			put_page(head + i);
> > > > > > +			else if (folio_test_clear_dirty(tail))
> > > > > > +				folio_account_cleaned(tail,
> > > > > > +					inode_to_wb(folio->mapping->host));
> > > > > > +			__filemap_remove_folio(tail, NULL);
> > > > > > +			folio_put(tail);
> > > > > >  		} else if (!PageAnon(page)) {
> > > > > >  			__xa_store(&head->mapping->i_pages, head[i].index,
> > > > > >  					head + i, 0);
> > > > > > 
> > > > > 
> > > > > Yup, that fixes the leak.
> > > > > 
> > > > > Tested-by: Dave Chinner <dchinner@redhat.com>
> > > > 
> > > > Four hours of generic/522 running is long enough to conclude that this
> > > > is likely the fix for my problem and migrate long soak testing to my
> > > > main g/522 rig and:
> > > > 
> > > > Tested-by: Darrick J. Wong <djwong@kernel.org>
> > > > 
> > > 
> > > Just based on Willy's earlier comment.. what I would probably be a
> > > little careful/curious about here is whether the accounting fix leads to
> > > an indirect behavior change that does impact reproducibility of the
> > > corruption problem. For example, does artificially escalated dirty page
> > > tracking lead to increased reclaim/writeback activity than might
> > > otherwise occur, and thus contend with the fs workload? Clearly it has
> > > some impact based on Dave's balance_dirty_pages() problem reproducer,
> > > but I don't know if it extends beyond that off the top of my head. That
> > > might make some sense if the workload is fsx, since that doesn't
> > > typically stress cache/memory usage the way a large fsstress workload or
> > > something might.
> > > 
> > > So for example, interesting questions might be... Do your corruption
> > > events happen to correspond with dirty page accounting crossing some
> > > threshold based on available memory in your test environment? Does
> > > reducing available memory affect reproducibility? Etc.
> > 
> > Yeah, I wonder that too now.  I managed to trace generic/522 a couple of
> > times before willy's patch dropped.  From what I could tell, a large
> > folio X would get page P assigned to the fsx file's page cache to cover
> > range R, dirtied, and written to disk.  At some point later, we'd
> > reflink into part of the file range adjacent to P, but not P itself.
> > I /think/ that should have caused the whole folio to get invalidated?
> > 
> > Then some more things happened (none of which dirtied R, according to
> > fsx) and then suddenly writeback would trigger on some page (don't know
> > which) that would write to the disk blocks backing R.  I'm fairly sure
> > that's where the incorrect disk contents came from.
> > 
> > Next, we'd reflink part of the file range including R into a different
> > part of the file (call it R2).  fsx would read R2, bringing a new page
> > into cache, and it wouldn't match the fsxgood buffer, leading to fsx
> > aborting.
> > 
> > After a umount/mount cycle, reading R and R2 would both reveal the
> > incorrect contents that had caused fsx to abort.
> > 
> 
> FWIW, I hadn't been able to reproduce this in my default environment to
> this point. With the memory leak issue in the light, I was eventually
> able to by reducing dirty_bytes to something the system would be more
> likely to hit sooner (i.e. 16-32MB), but I also see stalling behavior
> and whatnot due to the leak that requires backing off from the specified
> dirty limit every so often.
> 
> If I apply the accounting patch to avoid the leak and set
> dirty_background_bytes to something notably aggressive (1kB), the test
> survived 100 iterations or so before I stopped it. If I then set
> dirty_bytes to something similarly aggressive (1MB), I hit the failure
> on the next iteration (assuming it's the same problem). It's spinning
> again at ~25 or so iterations without a failure so far, so I'd have to
> wait and see how reliable the reproducer really is. Though if it doesn't
> reoccur soonish, perhaps I'll try reducing dirty_bytes a bit more...
> 
> My suspicion based on these characteristics would be that the blocking
> limit triggers more aggressive reclaim/invalidation, and thus helps
> detect the problem sooner. If reflink is involved purely as a cache
> invalidation step (i.e. so a subsequent read will hit the disk and
> detect a cache inconsistency), then it might be interesting to see if it
> can still be reproduced without reflink operations enabled but instead
> with some combination of the -f/-X fsx flags to perform more flush
> invals and on-disk data checks..

Hm.  I didn't try -f or lowering dirty_bytes, but with the reflink
operations disabled, g522 ran for 3 hours before I gave up and killed
it.  I would've thought that the fallocate zero/collapse/insert range
functions (which use the same flush/unmap helper) would have sufficed to
make the problem happen, but ... it didn't.

I think I'll try changing dirty_bytes next, to see if I can reproduce
the problem that way.  I'm not surprised that you had to set dirty_bytes
to 1MB, since 522 is only ever creating a 600K file anyway.

(Hopefully willy will be back next week to help us shed some light on
this.)

--D

> Brian
> 
> > Unfortunately the second ftrace attempt ate some trace data, so I was
> > unable to figure out if the same thing happened again.
> > 
> > At this point I really need to get on reviewing patches for 5.20, so
> > I'll try to keep poking at this (examining the trace data requires a lot
> > of concentration which isn't really possible while sawzall construction
> > is going on at home) but at worst I can ask Linus to merge a patch for
> > 5.19 final that makes setting mapping_set_large_folio a
> > Kconfig/CONFIG_XFS_DEBUG option.
> > 
> > --D
> > 
> > > 
> > > Brian
> > > 
> > > > --D
> > > > 
> > > > > Cheers,
> > > > > 
> > > > > Dave.
> > > > > -- 
> > > > > Dave Chinner
> > > > > david@fromorbit.com
> > > > 
> > > 
> > 
> 

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Dave Chinner]

On Wed, Jun 29, 2022 at 08:57:30AM -0400, Brian Foster wrote:
> On Tue, Jun 28, 2022 at 04:21:55PM -0700, Darrick J. Wong wrote:
> > On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> > > On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > > > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > > > So using this technique, I've discovered that there's a dirty page
> > > > > > > accounting leak that eventually results in fsx hanging in
> > > > > > > balance_dirty_pages().
> > > > > > 
> > > > > > Alas, I think this is only an accounting error, and not related to
> > > > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > > > seeing is dirty pages being dropped at truncation without the
> > > > > > appropriate accounting.  ie this should be the fix:
> > > > > 
> > > > > Argh, try one that actually compiles.
> > > > 
> > > > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > > > be writing code at 6am?
> > > > 
> > > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > > > index f7248002dad9..4eec6ee83e44 100644
> > > > --- a/mm/huge_memory.c
> > > > +++ b/mm/huge_memory.c
> > > > @@ -18,6 +18,7 @@
> > > >  #include <linux/shrinker.h>
> > > >  #include <linux/mm_inline.h>
> > > >  #include <linux/swapops.h>
> > > > +#include <linux/backing-dev.h>
> > > >  #include <linux/dax.h>
> > > >  #include <linux/khugepaged.h>
> > > >  #include <linux/freezer.h>
> > > > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> > > >  		__split_huge_page_tail(head, i, lruvec, list);
> > > >  		/* Some pages can be beyond EOF: drop them from page cache */
> > > >  		if (head[i].index >= end) {
> > > > -			ClearPageDirty(head + i);
> > > > -			__delete_from_page_cache(head + i, NULL);
> > > > +			struct folio *tail = page_folio(head + i);
> > > > +
> > > >  			if (shmem_mapping(head->mapping))
> > > >  				shmem_uncharge(head->mapping->host, 1);
> > > > -			put_page(head + i);
> > > > +			else if (folio_test_clear_dirty(tail))
> > > > +				folio_account_cleaned(tail,
> > > > +					inode_to_wb(folio->mapping->host));
> > > > +			__filemap_remove_folio(tail, NULL);
> > > > +			folio_put(tail);
> > > >  		} else if (!PageAnon(page)) {
> > > >  			__xa_store(&head->mapping->i_pages, head[i].index,
> > > >  					head + i, 0);
> > > > 
> > > 
> > > Yup, that fixes the leak.
> > > 
> > > Tested-by: Dave Chinner <dchinner@redhat.com>
> > 
> > Four hours of generic/522 running is long enough to conclude that this
> > is likely the fix for my problem and migrate long soak testing to my
> > main g/522 rig and:
> > 
> > Tested-by: Darrick J. Wong <djwong@kernel.org>
> > 
> 
> Just based on Willy's earlier comment.. what I would probably be a
> little careful/curious about here is whether the accounting fix leads to
> an indirect behavior change that does impact reproducibility of the
> corruption problem. For example, does artificially escalated dirty page
> tracking lead to increased reclaim/writeback activity than might
> otherwise occur, and thus contend with the fs workload?

Yeah, I think you're right, Brian. There is an underlying problem
here, and the writeback/memory pressure bugs exposed it for everyone
to see.  IOWs, we do indeed have a pre-existing problem with partial
writes, iomap, unwritten extents, writeback and memory reclaim.

(Please s/page/folio/ rather than complain I'm calling things pages
and not folios, I'm juggling between RHEL-8 code and upstream
here and it's just easier to refer to everything as pages as I write
it.)

(I'm assuming people are familiar with the iomap buffered IO code
at this point.)

Let's do a partial write into a page. Let's say the second half of
the page. __iomap_begin_write() drops into iomap_adjust_read_range()
to determine the range that needs zeroing or reading from disk.  We
then call iomap_block_needs_zeroing() to determine if we zero -
which we do if it's a newly allocated or unwritten extent. Otherwise
we read it from disk.

Let's put this partial write over a large unwritten extent, which
means we zero the first part of the page, and that writing it back
runs unwritten extent conversion at IO completion. This changes the
extent backing this file offset from unwritten to written.

Then, add extreme memory pressure, so writeback is already running
and soon after the page has been dirtied it gets marked for
cleaning. Therefore, we have the possibility of background IO
submission and memory reclaim occurring at the same time as new
writes are occurring to the file.

To that end, let's add a large racing write that *ends* on this same
page that we have already partially filled with data - it will fill
the start of the page that currently contains zeros with real data.

Let's start that write() just before writeback of the already
uptodate partial page starts. iomap_apply will map the entire
write (and well beyond) as a single unwritten extent. This extent is
the same extent that the original page in the page cache already
covers, and this write would end by filling the remaining part of
that write.

While that second write is running around in the page cache
copy-in loop for the unwritten extent that backs that range, IO
submission runs and completes and converts the original partially
filled page to a written extent, then marks it clean.

[ Ayup, the extent map of the file just changed to be different
to the iomap that the current write() thinks the file layout has. ]

Further, because the partially written page is now clean,
memory reclaim can snaffle it up and it gets removed from the page
cache.

The second write finally gets to the last page of it's write and
doesn't find it in the page cache because memory reclaim removed it.
So it pulls a new page into the page cache in iomap_begin_write(),
and then in __iomap_begin_write we see that the we need to fill the
second half of the page with either zeros or data from disk.

We know that this data is on disk as the extent is now in written
state.  *However*, the cached iomap that we are currently using for
the write() says the range is -unwritten-, and so at that point
iomap_block_needs_zeroing() says "page needs zeroing". Hence
__iomap_begin_write zeroes the second half of the page instead of
reading it from disk, obliterating the data that the previous write
had already written there.

Ouchy, we have data corruption because the incoming write holds a
stale cached iomap......

At this point, I had a nasty feeling of deja vu.

Oh, yeah, we already infrastructure in place to avoid using stale
cached iomaps in ->writepages....

That is, iomap_writepage_map() calls ->map_block for every filesytem
block, even though the iomap_writepage_ctx has a cached iomap in it.
That's so the filesystem can check that the cached iomap is still
valid whilst the page we are writing back is held locked. This
protects writeback against races with truncate, hole punch, etc.

XFS does this via a call to xfs_imap_valid() - we keep a generation
number in the XFS extent trees that is bumped on every change so
that we can check whether a cached iomap is still valid. If the
generation numbers don't match, then we generate a new iomap for the
writepage context....

What is clear to me now is that we have the same stale cached iomap
problem with iomap_apply() because writeback can change the extent
map state in a way that influence incoming writes and those updates
are not in any way serialised against the incoming write IO path.

Hence we have to validate that the cached iomap is not stale before
we decide what to do with a new page in the page cache (zero or read
from disk), and we have to do this iomap validation when the newly
instantiated page is locked and ready for initialisation.

I have not thought past this point - I'm only *just* smart enough to
be able to dig out the root cause of this problem. No scratch that,
I'm not smart, just stubborn enough to ignore the fact I've got the
analysis wrong at least a dozen times already.

That said, this stale mapping problem existed long before we started
using unwritten extents for delayed allocation. The change to use
unwritten extents (to fix other data corruption issues) exposed us
to in-memory zeroing in this race condition case rather reading the
block of data from disk. We just hadn't armed the landmine....

I suspect we are going to need a new iomap validation operation, and
require the iomap actors to be able to handle iomap validation
failure.  What that looks like, I don't know as my brain
turned to goo and dribbled out my ears about 4 hours ago....

BTW, all the credit for finding this goes to Frank Sorenson - he did
all the hard work of reproducing the issue and narrowing down the
scope of the problem to a handful of XFS commits combined with
writeback and memory reclaim interactions. Without his hard work,
we'd still have no idea what was going on.....

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Darrick J. Wong]

On Wed, Aug 17, 2022 at 07:36:27PM +1000, Dave Chinner wrote:
> On Wed, Jun 29, 2022 at 08:57:30AM -0400, Brian Foster wrote:
> > On Tue, Jun 28, 2022 at 04:21:55PM -0700, Darrick J. Wong wrote:
> > > On Wed, Jun 29, 2022 at 08:17:57AM +1000, Dave Chinner wrote:
> > > > On Tue, Jun 28, 2022 at 02:18:24PM +0100, Matthew Wilcox wrote:
> > > > > On Tue, Jun 28, 2022 at 12:31:55PM +0100, Matthew Wilcox wrote:
> > > > > > On Tue, Jun 28, 2022 at 12:27:40PM +0100, Matthew Wilcox wrote:
> > > > > > > On Tue, Jun 28, 2022 at 05:31:20PM +1000, Dave Chinner wrote:
> > > > > > > > So using this technique, I've discovered that there's a dirty page
> > > > > > > > accounting leak that eventually results in fsx hanging in
> > > > > > > > balance_dirty_pages().
> > > > > > > 
> > > > > > > Alas, I think this is only an accounting error, and not related to
> > > > > > > the problem(s) that Darrick & Zorro are seeing.  I think what you're
> > > > > > > seeing is dirty pages being dropped at truncation without the
> > > > > > > appropriate accounting.  ie this should be the fix:
> > > > > > 
> > > > > > Argh, try one that actually compiles.
> > > > > 
> > > > > ... that one's going to underflow the accounting.  Maybe I shouldn't
> > > > > be writing code at 6am?
> > > > > 
> > > > > diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> > > > > index f7248002dad9..4eec6ee83e44 100644
> > > > > --- a/mm/huge_memory.c
> > > > > +++ b/mm/huge_memory.c
> > > > > @@ -18,6 +18,7 @@
> > > > >  #include <linux/shrinker.h>
> > > > >  #include <linux/mm_inline.h>
> > > > >  #include <linux/swapops.h>
> > > > > +#include <linux/backing-dev.h>
> > > > >  #include <linux/dax.h>
> > > > >  #include <linux/khugepaged.h>
> > > > >  #include <linux/freezer.h>
> > > > > @@ -2439,11 +2440,15 @@ static void __split_huge_page(struct page *page, struct list_head *list,
> > > > >  		__split_huge_page_tail(head, i, lruvec, list);
> > > > >  		/* Some pages can be beyond EOF: drop them from page cache */
> > > > >  		if (head[i].index >= end) {
> > > > > -			ClearPageDirty(head + i);
> > > > > -			__delete_from_page_cache(head + i, NULL);
> > > > > +			struct folio *tail = page_folio(head + i);
> > > > > +
> > > > >  			if (shmem_mapping(head->mapping))
> > > > >  				shmem_uncharge(head->mapping->host, 1);
> > > > > -			put_page(head + i);
> > > > > +			else if (folio_test_clear_dirty(tail))
> > > > > +				folio_account_cleaned(tail,
> > > > > +					inode_to_wb(folio->mapping->host));
> > > > > +			__filemap_remove_folio(tail, NULL);
> > > > > +			folio_put(tail);
> > > > >  		} else if (!PageAnon(page)) {
> > > > >  			__xa_store(&head->mapping->i_pages, head[i].index,
> > > > >  					head + i, 0);
> > > > > 
> > > > 
> > > > Yup, that fixes the leak.
> > > > 
> > > > Tested-by: Dave Chinner <dchinner@redhat.com>
> > > 
> > > Four hours of generic/522 running is long enough to conclude that this
> > > is likely the fix for my problem and migrate long soak testing to my
> > > main g/522 rig and:
> > > 
> > > Tested-by: Darrick J. Wong <djwong@kernel.org>
> > > 
> > 
> > Just based on Willy's earlier comment.. what I would probably be a
> > little careful/curious about here is whether the accounting fix leads to
> > an indirect behavior change that does impact reproducibility of the
> > corruption problem. For example, does artificially escalated dirty page
> > tracking lead to increased reclaim/writeback activity than might
> > otherwise occur, and thus contend with the fs workload?
> 
> Yeah, I think you're right, Brian. There is an underlying problem
> here, and the writeback/memory pressure bugs exposed it for everyone
> to see.  IOWs, we do indeed have a pre-existing problem with partial
> writes, iomap, unwritten extents, writeback and memory reclaim.
> 
> (Please s/page/folio/ rather than complain I'm calling things pages
> and not folios, I'm juggling between RHEL-8 code and upstream
> here and it's just easier to refer to everything as pages as I write
> it.)
> 
> (I'm assuming people are familiar with the iomap buffered IO code
> at this point.)
> 
> Let's do a partial write into a page. Let's say the second half of
> the page. __iomap_begin_write() drops into iomap_adjust_read_range()
> to determine the range that needs zeroing or reading from disk.  We
> then call iomap_block_needs_zeroing() to determine if we zero -
> which we do if it's a newly allocated or unwritten extent. Otherwise
> we read it from disk.
> 
> Let's put this partial write over a large unwritten extent, which
> means we zero the first part of the page, and that writing it back
> runs unwritten extent conversion at IO completion. This changes the
> extent backing this file offset from unwritten to written.
> 
> Then, add extreme memory pressure, so writeback is already running
> and soon after the page has been dirtied it gets marked for
> cleaning. Therefore, we have the possibility of background IO
> submission and memory reclaim occurring at the same time as new
> writes are occurring to the file.
> 
> To that end, let's add a large racing write that *ends* on this same
> page that we have already partially filled with data - it will fill
> the start of the page that currently contains zeros with real data.
> 
> Let's start that write() just before writeback of the already
> uptodate partial page starts. iomap_apply will map the entire
> write (and well beyond) as a single unwritten extent. This extent is
> the same extent that the original page in the page cache already
> covers, and this write would end by filling the remaining part of
> that write.
> 
> While that second write is running around in the page cache
> copy-in loop for the unwritten extent that backs that range, IO
> submission runs and completes and converts the original partially
> filled page to a written extent, then marks it clean.

So if I understand this correctly --

Thread 1 fallocates 1G of contiguous space and writes 38 bytes to the
end of that gigabyte.  We instantiate a folio X for the region, zero the
parts we're not going to write, and copy the bytes we did want to write
into folio X.  The folio is now uptodate and dirty.  Thread 1 goes away.

Thread 2 starts a (1G-38) write of that fallocated (and mostly
unwritten) space.  It proceeds very slowly, one page at a time; it'll be
a while before it gets to folio X.

ramsnake.exe fires up and pushes the system hard into memory reclaim.
Reclaim initiates dirty writeback of folio X, which writes it to disk
and does the unwritten extent conversion.  Reclaim then removes X from
the page cache, and frees X.

Thread 2 finally gets to the end of its 1G write.  It is still using the
cached 1G unwritten mapping from before, unaware that some of the
mapping has changed to written state.  It grabs a folio for (1G - 38),
but it gets folio Y instead of folio X.  Y is not uptodate, so thread 2
copies bytes from userspace and zeroes the last 38 bytes.

**WRONG**

We now have folio Y with zeroes in the last 38 bytes, instead of
whatever thread 1 wrote.  Writeback pushes Y to disk, clobbering those
38 bytes forever.

> [ Ayup, the extent map of the file just changed to be different
> to the iomap that the current write() thinks the file layout has. ]
> 
> Further, because the partially written page is now clean,
> memory reclaim can snaffle it up and it gets removed from the page
> cache.
> 
> The second write finally gets to the last page of it's write and
> doesn't find it in the page cache because memory reclaim removed it.
> So it pulls a new page into the page cache in iomap_begin_write(),
> and then in __iomap_begin_write we see that the we need to fill the
> second half of the page with either zeros or data from disk.
> 
> We know that this data is on disk as the extent is now in written
> state.  *However*, the cached iomap that we are currently using for
> the write() says the range is -unwritten-, and so at that point
> iomap_block_needs_zeroing() says "page needs zeroing". Hence
> __iomap_begin_write zeroes the second half of the page instead of
> reading it from disk, obliterating the data that the previous write
> had already written there.

Yup.

> Ouchy, we have data corruption because the incoming write holds a
> stale cached iomap......
> 
> At this point, I had a nasty feeling of deja vu.
> 
> Oh, yeah, we already infrastructure in place to avoid using stale
> cached iomaps in ->writepages....
> 
> That is, iomap_writepage_map() calls ->map_block for every filesytem
> block, even though the iomap_writepage_ctx has a cached iomap in it.
> That's so the filesystem can check that the cached iomap is still
> valid whilst the page we are writing back is held locked. This
> protects writeback against races with truncate, hole punch, etc.
> 
> XFS does this via a call to xfs_imap_valid() - we keep a generation
> number in the XFS extent trees that is bumped on every change so
> that we can check whether a cached iomap is still valid. If the
> generation numbers don't match, then we generate a new iomap for the
> writepage context....
> 
> What is clear to me now is that we have the same stale cached iomap
> problem with iomap_apply() because writeback can change the extent
> map state in a way that influence incoming writes and those updates
> are not in any way serialised against the incoming write IO path.
> 
> Hence we have to validate that the cached iomap is not stale before
> we decide what to do with a new page in the page cache (zero or read
> from disk), and we have to do this iomap validation when the newly
> instantiated page is locked and ready for initialisation.
> 
> I have not thought past this point - I'm only *just* smart enough to
> be able to dig out the root cause of this problem. No scratch that,
> I'm not smart, just stubborn enough to ignore the fact I've got the
> analysis wrong at least a dozen times already.
> 
> That said, this stale mapping problem existed long before we started
> using unwritten extents for delayed allocation. The change to use
> unwritten extents (to fix other data corruption issues) exposed us
> to in-memory zeroing in this race condition case rather reading the
> block of data from disk. We just hadn't armed the landmine....
> 
> I suspect we are going to need a new iomap validation operation, and
> require the iomap actors to be able to handle iomap validation
> failure.  What that looks like, I don't know as my brain
> turned to goo and dribbled out my ears about 4 hours ago....

Euughg.  I suppose this means that ->iomap_begin has to be able to stuff
xfs_ifork.if_seq into a cookie value that we can set in struct iomap
somewhere?  And then iomap has to be able to call back to XFS to
revalidate iomap.cookie?  And if iomap.cookie != xfs_ifork.if_seq, then
I guess iomap will just ... unlock and put the folio, and return EAGAIN
(or something) so that its caller will return however many bytes have
been dirtied to iomap_apply so that _apply will go get a fresh mapping?

> BTW, all the credit for finding this goes to Frank Sorenson - he did
> all the hard work of reproducing the issue and narrowing down the
> scope of the problem to a handful of XFS commits combined with
> writeback and memory reclaim interactions. Without his hard work,
> we'd still have no idea what was going on.....

Thanks a bunch to him!!!

--D

> Cheers,
> 
> Dave.
> -- 
> Dave Chinner
> david@fromorbit.com

Re: Multi-page folio issues in 5.19-rc4 (was [PATCH v3 25/25] xfs: Support large folios)

[Dave Chinner]

On Wed, Aug 17, 2022 at 04:53:31PM -0700, Darrick J. Wong wrote:
> On Wed, Aug 17, 2022 at 07:36:27PM +1000, Dave Chinner wrote:
> > On Wed, Jun 29, 2022 at 08:57:30AM -0400, Brian Foster wrote:
> > > Just based on Willy's earlier comment.. what I would probably be a
> > > little careful/curious about here is whether the accounting fix leads to
> > > an indirect behavior change that does impact reproducibility of the
> > > corruption problem. For example, does artificially escalated dirty page
> > > tracking lead to increased reclaim/writeback activity than might
> > > otherwise occur, and thus contend with the fs workload?
> > 
> > Yeah, I think you're right, Brian. There is an underlying problem
> > here, and the writeback/memory pressure bugs exposed it for everyone
> > to see.  IOWs, we do indeed have a pre-existing problem with partial
> > writes, iomap, unwritten extents, writeback and memory reclaim.
> > 
> > (Please s/page/folio/ rather than complain I'm calling things pages
> > and not folios, I'm juggling between RHEL-8 code and upstream
> > here and it's just easier to refer to everything as pages as I write
> > it.)
> > 
> > (I'm assuming people are familiar with the iomap buffered IO code
> > at this point.)
> > 
> > Let's do a partial write into a page. Let's say the second half of
> > the page. __iomap_begin_write() drops into iomap_adjust_read_range()
> > to determine the range that needs zeroing or reading from disk.  We
> > then call iomap_block_needs_zeroing() to determine if we zero -
> > which we do if it's a newly allocated or unwritten extent. Otherwise
> > we read it from disk.
> > 
> > Let's put this partial write over a large unwritten extent, which
> > means we zero the first part of the page, and that writing it back
> > runs unwritten extent conversion at IO completion. This changes the
> > extent backing this file offset from unwritten to written.
> > 
> > Then, add extreme memory pressure, so writeback is already running
> > and soon after the page has been dirtied it gets marked for
> > cleaning. Therefore, we have the possibility of background IO
> > submission and memory reclaim occurring at the same time as new
> > writes are occurring to the file.
> > 
> > To that end, let's add a large racing write that *ends* on this same
> > page that we have already partially filled with data - it will fill
> > the start of the page that currently contains zeros with real data.
> > 
> > Let's start that write() just before writeback of the already
> > uptodate partial page starts. iomap_apply will map the entire
> > write (and well beyond) as a single unwritten extent. This extent is
> > the same extent that the original page in the page cache already
> > covers, and this write would end by filling the remaining part of
> > that write.
> > 
> > While that second write is running around in the page cache
> > copy-in loop for the unwritten extent that backs that range, IO
> > submission runs and completes and converts the original partially
> > filled page to a written extent, then marks it clean.
> 
> So if I understand this correctly --
> 
> Thread 1 fallocates 1G of contiguous space and writes 38 bytes to the
> end of that gigabyte.  We instantiate a folio X for the region, zero the
> parts we're not going to write, and copy the bytes we did want to write
> into folio X.  The folio is now uptodate and dirty.  Thread 1 goes away.
> 
> Thread 2 starts a (1G-38) write of that fallocated (and mostly
> unwritten) space.  It proceeds very slowly, one page at a time; it'll be
> a while before it gets to folio X.
> 
> ramsnake.exe fires up and pushes the system hard into memory reclaim.
> Reclaim initiates dirty writeback of folio X, which writes it to disk
> and does the unwritten extent conversion.  Reclaim then removes X from
> the page cache, and frees X.
> 
> Thread 2 finally gets to the end of its 1G write.  It is still using the
> cached 1G unwritten mapping from before, unaware that some of the
> mapping has changed to written state.  It grabs a folio for (1G - 38),
> but it gets folio Y instead of folio X.  Y is not uptodate, so thread 2
> copies bytes from userspace and zeroes the last 38 bytes.
> 
> **WRONG**
> 
> We now have folio Y with zeroes in the last 38 bytes, instead of
> whatever thread 1 wrote.  Writeback pushes Y to disk, clobbering those
> 38 bytes forever.

Yes, that's pretty much it.

> > [ Ayup, the extent map of the file just changed to be different
> > to the iomap that the current write() thinks the file layout has. ]
> > 
> > Further, because the partially written page is now clean,
> > memory reclaim can snaffle it up and it gets removed from the page
> > cache.
> > 
> > The second write finally gets to the last page of it's write and
> > doesn't find it in the page cache because memory reclaim removed it.
> > So it pulls a new page into the page cache in iomap_begin_write(),
> > and then in __iomap_begin_write we see that the we need to fill the
> > second half of the page with either zeros or data from disk.
> > 
> > We know that this data is on disk as the extent is now in written
> > state.  *However*, the cached iomap that we are currently using for
> > the write() says the range is -unwritten-, and so at that point
> > iomap_block_needs_zeroing() says "page needs zeroing". Hence
> > __iomap_begin_write zeroes the second half of the page instead of
> > reading it from disk, obliterating the data that the previous write
> > had already written there.
> 
> Yup.
> 
> > Ouchy, we have data corruption because the incoming write holds a
> > stale cached iomap......
> > 
> > At this point, I had a nasty feeling of deja vu.
> > 
> > Oh, yeah, we already infrastructure in place to avoid using stale
> > cached iomaps in ->writepages....
> > 
> > That is, iomap_writepage_map() calls ->map_block for every filesytem
> > block, even though the iomap_writepage_ctx has a cached iomap in it.
> > That's so the filesystem can check that the cached iomap is still
> > valid whilst the page we are writing back is held locked. This
> > protects writeback against races with truncate, hole punch, etc.
> > 
> > XFS does this via a call to xfs_imap_valid() - we keep a generation
> > number in the XFS extent trees that is bumped on every change so
> > that we can check whether a cached iomap is still valid. If the
> > generation numbers don't match, then we generate a new iomap for the
> > writepage context....
> > 
> > What is clear to me now is that we have the same stale cached iomap
> > problem with iomap_apply() because writeback can change the extent
> > map state in a way that influence incoming writes and those updates
> > are not in any way serialised against the incoming write IO path.
> > 
> > Hence we have to validate that the cached iomap is not stale before
> > we decide what to do with a new page in the page cache (zero or read
> > from disk), and we have to do this iomap validation when the newly
> > instantiated page is locked and ready for initialisation.
> > 
> > I have not thought past this point - I'm only *just* smart enough to
> > be able to dig out the root cause of this problem. No scratch that,
> > I'm not smart, just stubborn enough to ignore the fact I've got the
> > analysis wrong at least a dozen times already.
> > 
> > That said, this stale mapping problem existed long before we started
> > using unwritten extents for delayed allocation. The change to use
> > unwritten extents (to fix other data corruption issues) exposed us
> > to in-memory zeroing in this race condition case rather reading the
> > block of data from disk. We just hadn't armed the landmine....
> > 
> > I suspect we are going to need a new iomap validation operation, and
> > require the iomap actors to be able to handle iomap validation
> > failure.  What that looks like, I don't know as my brain
> > turned to goo and dribbled out my ears about 4 hours ago....
> 
> Euughg.  I suppose this means that ->iomap_begin has to be able to stuff
> xfs_ifork.if_seq into a cookie value that we can set in struct iomap
> somewhere?  And then iomap has to be able to call back to XFS to
> revalidate iomap.cookie?  And if iomap.cookie != xfs_ifork.if_seq, then
> I guess iomap will just ... unlock and put the folio, and return EAGAIN
> (or something) so that its caller will return however many bytes have
> been dirtied to iomap_apply so that _apply will go get a fresh mapping?

Yeah, something like that. I have not had time to think this through
any further than what you've just written. It does not look like it
will be trivial, though, and it points out that every filesystem
using iomap for multi-page extent maps will need to implement iomap
invalidation detection in some way.

We already have that for XFS with the sequence numbers, but I'm
betting that none of the other filesystems that use iomap have the
internal infrastructure to track racing extent map changes...

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com

Re: [PATCH v3 25/25] xfs: Support large folios

[Dave Chinner]

On Sun, Jun 26, 2022 at 09:15:27PM -0700, Darrick J. Wong wrote:
> On Wed, Jun 22, 2022 at 05:42:11PM -0700, Darrick J. Wong wrote:
> > [resend with shorter 522.out file to keep us under the 300k maximum]
> > 
> > On Thu, Dec 16, 2021 at 09:07:15PM +0000, Matthew Wilcox (Oracle) wrote:
> > > Now that iomap has been converted, XFS is large folio safe.
> > > Indicate to the VFS that it can now create large folios for XFS.
> > > 
> > > Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>
> > > Reviewed-by: Christoph Hellwig <hch@lst.de>
> > > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> > > ---
> > >  fs/xfs/xfs_icache.c | 2 ++
> > >  1 file changed, 2 insertions(+)
> > > 
> > > diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> > > index da4af2142a2b..cdc39f576ca1 100644
> > > --- a/fs/xfs/xfs_icache.c
> > > +++ b/fs/xfs/xfs_icache.c
> > > @@ -87,6 +87,7 @@ xfs_inode_alloc(
> > >  	/* VFS doesn't initialise i_mode or i_state! */
> > >  	VFS_I(ip)->i_mode = 0;
> > >  	VFS_I(ip)->i_state = 0;
> > > +	mapping_set_large_folios(VFS_I(ip)->i_mapping);
> > >  
> > >  	XFS_STATS_INC(mp, vn_active);
> > >  	ASSERT(atomic_read(&ip->i_pincount) == 0);
> > > @@ -320,6 +321,7 @@ xfs_reinit_inode(
> > >  	inode->i_rdev = dev;
> > >  	inode->i_uid = uid;
> > >  	inode->i_gid = gid;
> > > +	mapping_set_large_folios(inode->i_mapping);
> > 
> > Hmm.  Ever since 5.19-rc1, I've noticed that fsx in generic/522 now
> > reports file corruption after 20 minutes of runtime.  The corruption is
> > surprisingly reproducible (522.out.bad attached below) in that I ran it
> > three times and always got the same bad offset (0x6e000) and always the
> > same opcode (6213798(166 mod 256) MAPREAD).
> > 
> > I turned off multipage folios and now 522 has run for over an hour
> > without problems, so before I go do more debugging, does this ring a
> > bell to anyone?
> 
> I tried bisecting, but that didn't yield anything productive and
> 5.19-rc4 still fails after 25 minutes; however, it seems that g/522 will
> run without problems for at least 3-4 days after reverting this patch
> from -rc3.

Took 63 million ops and just over 3 hours before it failed here with
a similar 16 byte map read corruption on the first 16 bytes of a
page. Given the number of fallocate operations that lead up to the
failure - 14 of last 23, plus 3 clone, 2 copy, 2 map read, 1 skip
and the map write that it suggests the stale data came from - this
smells of an invalidation issue...

Cheers,

Dave.
-- 
Dave Chinner
david@fromorbit.com