* Re: [PATCH 08/18] raid6: warn when using less than four devices
From: H. Peter Anvin @ 2026-06-27 1:14 UTC (permalink / raw)
To: Christoph Hellwig, Andrew Morton
Cc: Catalin Marinas, Will Deacon, Ard Biesheuvel, Huacai Chen,
WANG Xuerui, Madhavan Srinivasan, Michael Ellerman,
Nicholas Piggin, Christophe Leroy (CS GROUP), Paul Walmsley,
Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Heiko Carstens,
Vasily Gorbik, Alexander Gordeev, Christian Borntraeger,
Sven Schnelle, Thomas Gleixner, Ingo Molnar, Borislav Petkov,
Dave Hansen, x86, Herbert Xu, Dan Williams, Chris Mason,
David Sterba, Arnd Bergmann, Song Liu, Yu Kuai, Li Nan,
linux-kernel, linux-arm-kernel, loongarch, linuxppc-dev,
linux-riscv, linux-s390, linux-crypto, linux-btrfs, linux-arch,
linux-raid
In-Reply-To: <20260518051804.462141-9-hch@lst.de>
On 2026-05-17 22:17, Christoph Hellwig wrote:
> Quoting H. Peter Anvin who came up with the RAID6 P/Q algorithm, and
> who wrote the initial implementation, then still part of the md driver:
>
> The RAID-6 code has *never* supported only 3 units, and if it ever
> worked for *any* of the implementations it was purely by accident.
> Speaking as the original author I should know; this was deliberate as
> in some cases the degenerate case (3) would have required extra trays
Stupid autocorrect. That was of course supposed to be "tests" (as in extra
code paths) not "trays" :)
> in the code to no user benefit.
>
> While md never allowed less than 4 devices, btrfs does. This new
> warning will trigger for such file systems, but given how it already
> causes havoc that is a good thing. If btrfs wants to fix third, it
> should switch to transparently use three-way mirroring underneath,
> which will work as P and Q are copies of the single data device by
> the definition of the Linux RAID 6 P/Q algorithm.
For what it's worth, this is also true in the degenerate two-drive RAID-4|5
case (D = P).
-hpa
^ permalink raw reply
* Re: cleanup the RAID6 P/Q library v3
From: H. Peter Anvin @ 2026-06-27 0:52 UTC (permalink / raw)
To: Christoph Hellwig, Andrew Morton
Cc: Catalin Marinas, Will Deacon, Ard Biesheuvel, Huacai Chen,
WANG Xuerui, Madhavan Srinivasan, Michael Ellerman,
Nicholas Piggin, Christophe Leroy (CS GROUP), Paul Walmsley,
Palmer Dabbelt, Albert Ou, Alexandre Ghiti, Heiko Carstens,
Vasily Gorbik, Alexander Gordeev, Christian Borntraeger,
Sven Schnelle, Thomas Gleixner, Ingo Molnar, Borislav Petkov,
Dave Hansen, x86, Herbert Xu, Dan Williams, Chris Mason,
David Sterba, Arnd Bergmann, Song Liu, Yu Kuai, Li Nan,
linux-kernel, linux-arm-kernel, loongarch, linuxppc-dev,
linux-riscv, linux-s390, linux-crypto, linux-btrfs, linux-arch,
linux-raid
In-Reply-To: <20260519082432.GA14956@lst.de>
On 2026-05-19 01:24, Christoph Hellwig wrote:
>
> raid6: rework registration of optimized algorithms
>
> - avx2 instead of avx512 is probably the right thing for no
> benchmarking, but if it was intentional (it wasn't), that should
> be document. So I'll just switch back to the previous version to
> keep the state of the art
It is unlikely to be the right thing *going forward*, though.
The very unfortunate performance inversion is likely model-specific. It is one
of those things where you largely would have to have a list of quirks :(
-hpa
^ permalink raw reply
* [PATCH v2] btrfs: always wait for ordered extents to avoid OE races
From: Qu Wenruo @ 2026-06-26 23:32 UTC (permalink / raw)
To: linux-btrfs; +Cc: syzbot+ba2afde329fc27e3f22e
[BUG]
Syzbot reported a bug that there can be conflicting OEs for the same
range:
BTRFS critical (device loop4): panic in insert_ordered_extent:264: overlapping ordered extents, existing oe file_offset 16384 num_bytes 430080 flags 0x1089, new oe file_offset 16384 num_bytes 430080 flags 0x80 (errno=-17 Object alrea[ 179.162726][ T6897] BTRFS critical (device loop4): panic in insert_ordered_extent:264: overlapping ordered extents, existing oe file_offset 16384 num_bytes 430080 flags 0x1089, new oe file_offset 16384 num_bytes 430080 flags 0x80 (errno=-17 Object already exists)
------------[ cut here ]------------
kernel BUG at fs/btrfs/ordered-data.c:264!
Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 05/09/2026
RIP: 0010:btrfs_alloc_ordered_extent+0x943/0xad0
Call Trace:
<TASK>
cow_file_range+0x744/0x12a0
fallback_to_cow+0x5ea/0xa00
run_delalloc_nocow+0x110c/0x17a0
btrfs_run_delalloc_range+0xbe4/0x1c20
writepage_delalloc+0x104d/0x1ba0
btrfs_writepages+0x1667/0x28b0
do_writepages+0x338/0x560
filemap_fdatawrite_range+0x1f2/0x300
btrfs_fdatawrite_range+0x54/0xf0
btrfs_direct_write+0x6a0/0xc30
btrfs_do_write_iter+0x329/0x790
do_iter_readv_writev+0x624/0x8d0
vfs_writev+0x34c/0x990
__se_sys_pwritev2+0x17a/0x2a0
do_syscall_64+0x174/0x580
entry_SYSCALL_64_after_hwframe+0x77/0x7f
</TASK>
---[ end trace 0000000000000000 ]---
[CAUSE]
Since commit ff66fe666233 ("btrfs: fix incorrect buffered IO fallback
for append direct writes"), if the direct IO finished short, we will
revert the isize back to the original one, so that append writes can be
respected during the buffered fallback.
Normally we rely on lock_and_cleanup_extent_if_need() function during
buffered writeback to wait for any existing ordered extents.
But that ordered extent waiting only happens if the start_pos is inside
the isize.
Since we have reverted the isize during failed direct IO, we will not
wait for any ordered extents.
This means we can have a race where the direct IO OE is still in the
tree, finished but not yet removed, then we're inserting the OE for the
buffered write, causing the above crash.
[FIX]
Make the OE wait to be unconditional, to handle the reverted isize
situation.
And since lock_and_cleanup_extent_if_need() now either lock the
extents or return -EAGAIN, also remove the branches that handles
no-extent-locked cases, and rename it to remove the "_if_need" suffix.
The following micro benchmark shows the runtime difference for
btrfs_buffered_write(), doing `xfs_io -f -c "pwrite 0 1m"` workload,
all values are the average runtime in nano seconds.
function runtime | before | after
-----------------------------------+-------------+---------------
lock_and_cleanup_extent_if_need() | 58.2 | 183.0
btrfs_buffered_write() | 2115.6 | 2973.3
The overall runtime of btrfs_buffered_write() is still pretty
tiny (still less than 3 micro seconds), I'd say the extra cost is still
acceptable.
An alternative to fix this problem is to wait ordered extents during
iomap_end() where the isize revert is done.
But that solution will break nowait requirement, as if a nowait direct
IO finished short, we have to wait for the OEs unconditionally or the
next append buffered IO can still hit the same problem.
So here we have to move the wait cost to buffered write, but at least
the code is slightly more streamline.
Reported-by: syzbot+ba2afde329fc27e3f22e@syzkaller.appspotmail.com
Link: https://syzkaller.appspot.com/bug?extid=ba2afde329fc27e3f22e
Fixes: ff66fe666233 ("btrfs: fix incorrect buffered IO fallback for append direct writes")
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
Changelog:
v2:
- Further cleanup the handling of lock_and_cleanup_extent_if_need()
As it no longer return without locking extents, cleanup the caller
furthermore to remove unnecessary local variables.
- Add a micro bench mark for the performance impact
- Explain why we have to do the wait inside buffered write not
in direct write path
---
fs/btrfs/file.c | 104 +++++++++++++++++++-----------------------------
1 file changed, 41 insertions(+), 63 deletions(-)
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index df8f6f565070..62f41314df04 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -875,70 +875,64 @@ static noinline int prepare_one_folio(struct inode *inode, struct folio **folio_
/*
* Locks the extent and properly waits for data=ordered extents to finish
- * before allowing the folios to be modified if need.
+ * before allowing the folios to be modified.
*
* Return:
- * 1 - the extent is locked
- * 0 - the extent is not locked, and everything is OK
+ * 0 - the extent is locked
* -EAGAIN - need to prepare the folios again
*/
static noinline int
-lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct folio *folio,
- loff_t pos, size_t write_bytes,
- u64 *lockstart, u64 *lockend, bool nowait,
- struct extent_state **cached_state)
+lock_and_cleanup_extent(struct btrfs_inode *inode, struct folio *folio,
+ loff_t pos, size_t write_bytes,
+ u64 *lockstart, u64 *lockend, bool nowait,
+ struct extent_state **cached_state)
{
struct btrfs_fs_info *fs_info = inode->root->fs_info;
+ struct btrfs_ordered_extent *ordered;
u64 start_pos;
u64 last_pos;
- int ret = 0;
start_pos = round_down(pos, fs_info->sectorsize);
last_pos = round_up(pos + write_bytes, fs_info->sectorsize) - 1;
- if (start_pos < inode->vfs_inode.i_size) {
- struct btrfs_ordered_extent *ordered;
-
- if (nowait) {
- if (!btrfs_try_lock_extent(&inode->io_tree, start_pos,
- last_pos, cached_state)) {
- folio_unlock(folio);
- folio_put(folio);
- return -EAGAIN;
- }
- } else {
- btrfs_lock_extent(&inode->io_tree, start_pos, last_pos,
- cached_state);
- }
-
- ordered = btrfs_lookup_ordered_range(inode, start_pos,
- last_pos - start_pos + 1);
- if (ordered &&
- ordered->file_offset + ordered->num_bytes > start_pos &&
- ordered->file_offset <= last_pos) {
- btrfs_unlock_extent(&inode->io_tree, start_pos, last_pos,
- cached_state);
+ if (nowait) {
+ if (!btrfs_try_lock_extent(&inode->io_tree, start_pos,
+ last_pos, cached_state)) {
folio_unlock(folio);
folio_put(folio);
- btrfs_start_ordered_extent(ordered);
- btrfs_put_ordered_extent(ordered);
return -EAGAIN;
}
- if (ordered)
- btrfs_put_ordered_extent(ordered);
-
- *lockstart = start_pos;
- *lockend = last_pos;
- ret = 1;
+ } else {
+ btrfs_lock_extent(&inode->io_tree, start_pos, last_pos,
+ cached_state);
}
+ ordered = btrfs_lookup_ordered_range(inode, start_pos,
+ last_pos - start_pos + 1);
+ if (ordered &&
+ ordered->file_offset + ordered->num_bytes > start_pos &&
+ ordered->file_offset <= last_pos) {
+ btrfs_unlock_extent(&inode->io_tree, start_pos, last_pos,
+ cached_state);
+ folio_unlock(folio);
+ folio_put(folio);
+ btrfs_start_ordered_extent(ordered);
+ btrfs_put_ordered_extent(ordered);
+ return -EAGAIN;
+ }
+ if (ordered)
+ btrfs_put_ordered_extent(ordered);
+
+ *lockstart = start_pos;
+ *lockend = last_pos;
+
/*
* We should be called after prepare_one_folio() which should have locked
* all pages in the range.
*/
WARN_ON(!folio_test_locked(folio));
- return ret;
+ return 0;
}
/*
@@ -1195,7 +1189,6 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
const u64 reserved_start = round_down(start, fs_info->sectorsize);
u64 reserved_len;
struct folio *folio = NULL;
- int extents_locked;
u64 lockstart;
u64 lockend;
bool only_release_metadata = false;
@@ -1253,18 +1246,16 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
reserved_len = last_block - reserved_start;
}
- extents_locked = lock_and_cleanup_extent_if_need(inode, folio, start,
- write_bytes, &lockstart,
- &lockend, nowait,
- &cached_state);
- if (extents_locked < 0) {
- if (!nowait && extents_locked == -EAGAIN)
+ ret = lock_and_cleanup_extent(inode, folio, start, write_bytes,
+ &lockstart, &lockend, nowait, &cached_state);
+ if (ret < 0) {
+ if (!nowait)
goto again;
btrfs_delalloc_release_extents(inode, reserved_len);
release_space(inode, *data_reserved, reserved_start, reserved_len,
only_release_metadata);
- return extents_locked;
+ return ret;
}
copied = copy_folio_from_iter_atomic(folio, offset_in_folio(folio, start),
@@ -1288,11 +1279,8 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
/* No copied bytes, unlock, release reserved space and exit. */
if (copied == 0) {
- if (extents_locked)
- btrfs_unlock_extent(&inode->io_tree, lockstart, lockend,
- &cached_state);
- else
- btrfs_free_extent_state(cached_state);
+ btrfs_unlock_extent(&inode->io_tree, lockstart, lockend,
+ &cached_state);
btrfs_delalloc_release_extents(inode, reserved_len);
release_space(inode, *data_reserved, reserved_start, reserved_len,
only_release_metadata);
@@ -1311,17 +1299,7 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
ret = btrfs_dirty_folio(inode, folio, start, copied, &cached_state,
only_release_metadata);
- /*
- * If we have not locked the extent range, because the range's start
- * offset is >= i_size, we might still have a non-NULL cached extent
- * state, acquired while marking the extent range as delalloc through
- * btrfs_dirty_page(). Therefore free any possible cached extent state
- * to avoid a memory leak.
- */
- if (extents_locked)
- btrfs_unlock_extent(&inode->io_tree, lockstart, lockend, &cached_state);
- else
- btrfs_free_extent_state(cached_state);
+ btrfs_unlock_extent(&inode->io_tree, lockstart, lockend, &cached_state);
btrfs_delalloc_release_extents(inode, reserved_len);
if (ret) {
--
2.54.0
^ permalink raw reply related
* Re: [PATCH v2 1/2] fs: btrfs: implement opendir(), readdir() and closedir()
From: Qu Wenruo @ 2026-06-26 22:26 UTC (permalink / raw)
To: Alexey Charkov, Qu Wenruo, linux-btrfs, u-boot
Cc: Marek Behún, Tom Rini, Simon Glass, Timo tp Preißl,
Peng Fan, Patrice Chotard, Yao Zi
In-Reply-To: <20260626-btrfs-readdir-v2-1-7dd43f72d1b4@flipper.net>
在 2026/6/27 00:48, Alexey Charkov 写道:
> Add support for generic directory iteration with opendir(), readdir() and
> closedir() in the btrfs filesystem driver.
>
> Signed-off-by: Alexey Charkov <alchark@flipper.net>
> ---
> fs/btrfs/btrfs.c | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++++
> fs/btrfs/ctree.h | 2 ++
> fs/btrfs/dir-item.c | 73 +++++++++++++++++++++++++++++++++++++++
> fs/fs.c | 4 ++-
> include/btrfs.h | 5 +++
> 5 files changed, 181 insertions(+), 1 deletion(-)
>
> diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c
> index f3087f690fa4..6f034861da90 100644
> --- a/fs/btrfs/btrfs.c
> +++ b/fs/btrfs/btrfs.c
> @@ -8,7 +8,9 @@
> #include <config.h>
> #include <malloc.h>
> #include <u-boot/uuid.h>
> +#include <linux/kernel.h>
> #include <linux/time.h>
> +#include <fs.h>
> #include "btrfs.h"
> #include "crypto/hash.h"
> #include "disk-io.h"
> @@ -159,6 +161,102 @@ int btrfs_ls(const char *path)
> return 0;
> }
>
> +/*
> + * The fs layer closes and re-probes btrfs between readdir() calls (see
> + * fs_readdir() in fs/fs.c), freeing and reallocating fs_info, so root cannot
> + * be stored directly. The subvolume id and inode number are stable though, so
> + * re-resolve the root from the current fs_info by subvolume id, which avoids
> + * a full path walk and is much faster.
> + */
> +struct btrfs_dir_stream {
> + struct fs_dir_stream parent;
> + struct fs_dirent dirent;
> + u64 subvolid;
> + u64 ino;
> + u64 offset;
> +};
> +
> +int btrfs_opendir(const char *dirname, struct fs_dir_stream **dirsp)
> +{
> + struct btrfs_fs_info *fs_info = current_fs_info;
> + struct btrfs_dir_stream *dirs;
> + struct btrfs_root *root;
> + u64 ino;
> + u8 type;
> + int ret;
> +
> + *dirsp = NULL;
> + ASSERT(fs_info);
> +
> + ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
> + dirname, &root, &ino, &type, 40);
> + if (ret < 0)
> + return ret;
> + if (type != BTRFS_FT_DIR)
> + return -ENOTDIR;
> +
> + dirs = calloc(1, sizeof(*dirs));
> + if (!dirs)
> + return -ENOMEM;
> + dirs->subvolid = root->root_key.objectid;
> + dirs->ino = ino;
> +
> + *dirsp = &dirs->parent;
> + return 0;
> +}
> +
> +static unsigned int btrfs_dirent_type_to_fs_type(u8 dirent_type)
> +{
> + switch (dirent_type) {
> + case BTRFS_FT_DIR:
> + return FS_DT_DIR;
> + case BTRFS_FT_SYMLINK:
> + return FS_DT_LNK;
> + default:
> + return FS_DT_REG;
> + }
> +}
> +
> +int btrfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
> +{
> + struct btrfs_dir_stream *dirs = container_of(fs_dirs, struct btrfs_dir_stream, parent);
> + struct btrfs_fs_info *fs_info = current_fs_info;
> + struct fs_dirent *dent = &dirs->dirent;
> + struct btrfs_root *root;
> + struct btrfs_key key;
> + u8 type;
> + int ret;
> +
> + *dentp = NULL;
> + ASSERT(fs_info);
> +
> + key.objectid = dirs->subvolid;
> + key.type = BTRFS_ROOT_ITEM_KEY;
> + key.offset = (u64)-1;
> + root = btrfs_read_fs_root(fs_info, &key);
You can save the root pointer into btrfs_dir_stream, so we can avoid
subvolume root lookup for each dentry.
You do not need to bother the lifespan of subvolume roots either, they
are properly released during the close of the fs.
Otherwise looks good to me, except an unrelated question just lines below.
> + if (IS_ERR(root))
> + return PTR_ERR(root);
> +
> + memset(dent, 0, sizeof(*dent));
> + ret = btrfs_next_dir_entry(root, dirs->ino, &dirs->offset, dent->name,
> + sizeof(dent->name), &type);
> + if (ret < 0)
> + return ret;
> + if (ret > 0)
> + return -ENOENT;
I'm not sure what is the proper/preferred/sane handling of end of directory.
Ext4/fat returns -ENOENT, squashfs returned -1, erofs return 1, exfat
returns 0 but without populating @dentp.
Personally I found the exfat behavior more sane, but considering the
caller fs_ls_generic() doesn't really bother the return value but only
cares if @dent is populated, it should be fine either way.
But still, returning -ENOENT will populate errno, which may be confusing
for debugging.
Anyway it's an unrelated nitpick.
Thanks,
Qu
> +
> + dent->type = btrfs_dirent_type_to_fs_type(type);
> + *dentp = dent;
> + return 0;
> +}
> +
> +void btrfs_closedir(struct fs_dir_stream *fs_dirs)
> +{
> + struct btrfs_dir_stream *dirs = container_of(fs_dirs, struct btrfs_dir_stream, parent);
> +
> + free(dirs);
> +}
> +
> int btrfs_exists(const char *file)
> {
> struct btrfs_fs_info *fs_info = current_fs_info;
> diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
> index b7be09d5df83..7de35aa7efd5 100644
> --- a/fs/btrfs/ctree.h
> +++ b/fs/btrfs/ctree.h
> @@ -1225,6 +1225,8 @@ typedef int (*btrfs_iter_dir_callback_t)(struct btrfs_root *root,
> struct btrfs_dir_item *di);
> int btrfs_iter_dir(struct btrfs_root *root, u64 ino,
> btrfs_iter_dir_callback_t callback);
> +int btrfs_next_dir_entry(struct btrfs_root *root, u64 ino, u64 *offset,
> + char *namebuf, int namebuf_len, u8 *ftype);
> /* inode.c */
> int btrfs_lookup_path(struct btrfs_root *root, u64 ino, const char *filename,
> struct btrfs_root **root_ret, u64 *ino_ret,
> diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
> index 5f81d6414f06..b12298e20c41 100644
> --- a/fs/btrfs/dir-item.c
> +++ b/fs/btrfs/dir-item.c
> @@ -166,3 +166,76 @@ out:
> btrfs_release_path(&path);
> return ret;
> }
> +
> +/*
> + * btrfs_next_dir_entry() - read one directory entry at or after a cursor
> + *
> + * Streaming counterpart to btrfs_iter_dir() for the fs-layer readdir, which
> + * is re-entered once per entry: returns the first real entry whose
> + * BTRFS_DIR_INDEX_KEY offset is >= *offset and advances *offset past it.
> + *
> + * @root, @ino: directory to read
> + * @offset: in/out cursor; DIR_INDEX offset to resume from
> + * @namebuf: caller buffer that receives the NUL-terminated name
> + * @namebuf_len: size of @namebuf in bytes
> + * @ftype: receives the BTRFS_FT_* type of the entry
> + *
> + * Return: 0 if an entry was returned, 1 when the directory is exhausted,
> + * -ve on error.
> + */
> +int btrfs_next_dir_entry(struct btrfs_root *root, u64 ino, u64 *offset,
> + char *namebuf, int namebuf_len, u8 *ftype)
> +{
> + struct btrfs_path path;
> + struct btrfs_key key;
> + struct btrfs_dir_item *di;
> + int name_len;
> + int ret;
> +
> + btrfs_init_path(&path);
> + key.objectid = ino;
> + key.type = BTRFS_DIR_INDEX_KEY;
> + key.offset = *offset;
> +
> + ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
> + if (ret < 0)
> + goto out;
> +
> + if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
> + ret = btrfs_next_leaf(root, &path);
> + if (ret < 0)
> + goto out;
> + if (ret > 0) { /* end of tree */
> + ret = 1;
> + goto out;
> + }
> + }
> +
> + btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
> + if (key.objectid != ino || key.type != BTRFS_DIR_INDEX_KEY) {
> + ret = 1; /* no more entries for this dir */
> + goto out;
> + }
> +
> + di = btrfs_item_ptr(path.nodes[0], path.slots[0],
> + struct btrfs_dir_item);
> + if (verify_dir_item(root, path.nodes[0], di)) {
> + ret = -EUCLEAN;
> + goto out;
> + }
> +
> + *offset = key.offset + 1;
> +
> + name_len = btrfs_dir_name_len(path.nodes[0], di);
> + if (name_len > namebuf_len - 1)
> + name_len = namebuf_len - 1;
> + read_extent_buffer(path.nodes[0], namebuf,
> + (unsigned long)(di + 1), name_len);
> + namebuf[name_len] = '\0';
> + *ftype = btrfs_dir_type(path.nodes[0], di);
> + ret = 0;
> +
> +out:
> + btrfs_release_path(&path);
> + return ret;
> +}
> diff --git a/fs/fs.c b/fs/fs.c
> index 8ea50a6c13c4..4694a88f776b 100644
> --- a/fs/fs.c
> +++ b/fs/fs.c
> @@ -326,7 +326,9 @@ static struct fstype_info fstypes[] = {
> .read = btrfs_read,
> .write = fs_write_unsupported,
> .uuid = btrfs_uuid,
> - .opendir = fs_opendir_unsupported,
> + .opendir = btrfs_opendir,
> + .readdir = btrfs_readdir,
> + .closedir = btrfs_closedir,
> .unlink = fs_unlink_unsupported,
> .mkdir = fs_mkdir_unsupported,
> .ln = fs_ln_unsupported,
> diff --git a/include/btrfs.h b/include/btrfs.h
> index 2d73add18e09..6fff45a497ee 100644
> --- a/include/btrfs.h
> +++ b/include/btrfs.h
> @@ -10,6 +10,8 @@
>
> struct blk_desc;
> struct disk_partition;
> +struct fs_dir_stream;
> +struct fs_dirent;
>
> int btrfs_probe(struct blk_desc *fs_dev_desc,
> struct disk_partition *fs_partition);
> @@ -20,5 +22,8 @@ int btrfs_read(const char *, void *, loff_t, loff_t, loff_t *);
> void btrfs_close(void);
> int btrfs_uuid(char *);
> void btrfs_list_subvols(void);
> +int btrfs_opendir(const char *filename, struct fs_dir_stream **dirsp);
> +int btrfs_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
> +void btrfs_closedir(struct fs_dir_stream *dirs);
>
> #endif /* __U_BOOT_BTRFS_H__ */
>
^ permalink raw reply
* [PATCH v2 2/2] fs: btrfs: use fs_ls_generic() and drop custom implementation
From: Alexey Charkov @ 2026-06-26 15:18 UTC (permalink / raw)
To: Qu Wenruo, linux-btrfs, u-boot
Cc: Marek Behún, Tom Rini, Simon Glass, Timo tp Preißl,
Peng Fan, Patrice Chotard, Yao Zi, Alexey Charkov
In-Reply-To: <20260626-btrfs-readdir-v2-0-7dd43f72d1b4@flipper.net>
Now that generic callbacks for opendir/readdir/closedir are implemented,
the custom btrfs_ls() implementation is no longer needed, along with the
btrfs_iter_dir() callback iterator.
Use fs_ls_generic() instead.
Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
fs/btrfs/btrfs.c | 129 ----------------------------------------------------
fs/btrfs/ctree.h | 5 --
fs/btrfs/dir-item.c | 59 ++----------------------
fs/fs.c | 2 +-
include/btrfs.h | 1 -
5 files changed, 4 insertions(+), 192 deletions(-)
diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c
index 6f034861da90..e663dda12e80 100644
--- a/fs/btrfs/btrfs.c
+++ b/fs/btrfs/btrfs.c
@@ -17,107 +17,6 @@
struct btrfs_fs_info *current_fs_info;
-static int show_dir(struct btrfs_root *root, struct extent_buffer *eb,
- struct btrfs_dir_item *di)
-{
- struct btrfs_fs_info *fs_info = root->fs_info;
- struct btrfs_inode_item ii;
- struct btrfs_key key;
- static const char* dir_item_str[] = {
- [BTRFS_FT_REG_FILE] = " ",
- [BTRFS_FT_DIR] = "DIR",
- [BTRFS_FT_CHRDEV] = "CHR",
- [BTRFS_FT_BLKDEV] = "BLK",
- [BTRFS_FT_FIFO] = "FIF",
- [BTRFS_FT_SOCK] = "SCK",
- [BTRFS_FT_SYMLINK] = "SYM",
- };
- u8 type = btrfs_dir_type(eb, di);
- char namebuf[BTRFS_NAME_LEN];
- char *target = NULL;
- char filetime[32];
- time_t mtime;
- int ret = 0;
-
- /* skip XATTRs in directory listing */
- if (type == BTRFS_FT_XATTR)
- return 0;
-
- btrfs_dir_item_key_to_cpu(eb, di, &key);
-
- if (key.type == BTRFS_ROOT_ITEM_KEY) {
- struct btrfs_root *subvol;
-
- /* It's a subvolume, get its mtime from root item */
- subvol = btrfs_read_fs_root(fs_info, &key);
- if (IS_ERR(subvol)) {
- ret = PTR_ERR(subvol);
- error("Can't find root %llu", key.objectid);
- return ret;
- }
- mtime = btrfs_stack_timespec_sec(&subvol->root_item.otime);
- } else {
- struct btrfs_path path;
-
- /* It's regular inode, get its mtime from inode item */
- btrfs_init_path(&path);
- ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
- if (ret > 0)
- ret = -ENOENT;
- if (ret < 0) {
- error("Can't find inode %llu", key.objectid);
- btrfs_release_path(&path);
- return ret;
- }
- read_extent_buffer(path.nodes[0], &ii,
- btrfs_item_ptr_offset(path.nodes[0], path.slots[0]),
- sizeof(ii));
- btrfs_release_path(&path);
- mtime = btrfs_stack_timespec_sec(&ii.mtime);
- }
- ctime_r(&mtime, filetime);
-
- if (type == BTRFS_FT_SYMLINK) {
- target = malloc(fs_info->sectorsize);
- if (!target) {
- error("Can't alloc memory for symlink %llu",
- key.objectid);
- return -ENOMEM;
- }
- ret = btrfs_readlink(root, key.objectid, target);
- if (ret < 0) {
- error("Failed to read symlink %llu", key.objectid);
- goto out;
- }
- target[ret] = '\0';
- }
-
- if (type < ARRAY_SIZE(dir_item_str) && dir_item_str[type])
- printf("<%s> ", dir_item_str[type]);
- else
- printf("?%3u? ", type);
- if (type == BTRFS_FT_CHRDEV || type == BTRFS_FT_BLKDEV) {
- ASSERT(key.type == BTRFS_INODE_ITEM_KEY);
- printf("%4llu,%5llu ", btrfs_stack_inode_rdev(&ii) >> 20,
- btrfs_stack_inode_rdev(&ii) & 0xfffff);
- } else {
- if (key.type == BTRFS_INODE_ITEM_KEY)
- printf("%10llu ", btrfs_stack_inode_size(&ii));
- else
- printf("%10llu ", 0ULL);
- }
-
- read_extent_buffer(eb, namebuf, (unsigned long)(di + 1),
- btrfs_dir_name_len(eb, di));
- printf("%24.24s %.*s", filetime, btrfs_dir_name_len(eb, di), namebuf);
- if (type == BTRFS_FT_SYMLINK)
- printf(" -> %s", target ? target : "?");
- printf("\n");
-out:
- free(target);
- return ret;
-}
-
int btrfs_probe(struct blk_desc *fs_dev_desc,
struct disk_partition *fs_partition)
{
@@ -133,34 +32,6 @@ int btrfs_probe(struct blk_desc *fs_dev_desc,
return ret;
}
-int btrfs_ls(const char *path)
-{
- struct btrfs_fs_info *fs_info = current_fs_info;
- struct btrfs_root *root = fs_info->fs_root;
- u64 ino = BTRFS_FIRST_FREE_OBJECTID;
- u8 type;
- int ret;
-
- ASSERT(fs_info);
- ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
- path, &root, &ino, &type, 40);
- if (ret < 0) {
- printf("Cannot lookup path %s\n", path);
- return ret;
- }
-
- if (type != BTRFS_FT_DIR) {
- error("Not a directory: %s", path);
- return -ENOENT;
- }
- ret = btrfs_iter_dir(root, ino, show_dir);
- if (ret < 0) {
- error("An error occurred while listing directory %s", path);
- return ret;
- }
- return 0;
-}
-
/*
* The fs layer closes and re-probes btrfs between readdir() calls (see
* fs_readdir() in fs/fs.c), freeing and reallocating fs_info, so root cannot
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 7de35aa7efd5..3fa9a8c9c020 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1220,11 +1220,6 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
struct btrfs_path *path, u64 dir,
const char *name, int name_len,
int mod);
-typedef int (*btrfs_iter_dir_callback_t)(struct btrfs_root *root,
- struct extent_buffer *eb,
- struct btrfs_dir_item *di);
-int btrfs_iter_dir(struct btrfs_root *root, u64 ino,
- btrfs_iter_dir_callback_t callback);
int btrfs_next_dir_entry(struct btrfs_root *root, u64 ino, u64 *offset,
char *namebuf, int namebuf_len, u8 *ftype);
/* inode.c */
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index b12298e20c41..c7b87d60d986 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -114,65 +114,12 @@ struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,
return btrfs_match_dir_item_name(root, path, name, name_len);
}
-int btrfs_iter_dir(struct btrfs_root *root, u64 ino,
- btrfs_iter_dir_callback_t callback)
-{
- struct btrfs_path path;
- struct btrfs_key key;
- int ret;
-
- btrfs_init_path(&path);
- key.objectid = ino;
- key.type = BTRFS_DIR_INDEX_KEY;
- key.offset = 0;
-
- ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
- if (ret < 0)
- return ret;
- /* Should not happen */
- if (ret == 0) {
- ret = -EUCLEAN;
- goto out;
- }
- if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
- ret = btrfs_next_leaf(root, &path);
- if (ret < 0)
- goto out;
- if (ret > 0) {
- ret = 0;
- goto out;
- }
- }
- do {
- struct btrfs_dir_item *di;
-
- btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
- if (key.objectid != ino || key.type != BTRFS_DIR_INDEX_KEY)
- break;
- di = btrfs_item_ptr(path.nodes[0], path.slots[0],
- struct btrfs_dir_item);
- if (verify_dir_item(root, path.nodes[0], di)) {
- ret = -EUCLEAN;
- goto out;
- }
- ret = callback(root, path.nodes[0], di);
- if (ret < 0)
- goto out;
- } while (!(ret = btrfs_next_item(root, &path)));
-
- if (ret > 0)
- ret = 0;
-out:
- btrfs_release_path(&path);
- return ret;
-}
-
/*
* btrfs_next_dir_entry() - read one directory entry at or after a cursor
*
- * Streaming counterpart to btrfs_iter_dir() for the fs-layer readdir, which
- * is re-entered once per entry: returns the first real entry whose
- * BTRFS_DIR_INDEX_KEY offset is >= *offset and advances *offset past it.
+ * Iterator for the fs-layer readdir, which is re-entered once per entry:
+ * returns the first real entry whose BTRFS_DIR_INDEX_KEY offset is
+ * >= *offset and advances *offset past it.
*
* @root, @ino: directory to read
* @offset: in/out cursor; DIR_INDEX offset to resume from
diff --git a/fs/fs.c b/fs/fs.c
index 4694a88f776b..1ebda6f4ee2a 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -320,7 +320,7 @@ static struct fstype_info fstypes[] = {
.null_dev_desc_ok = false,
.probe = btrfs_probe,
.close = btrfs_close,
- .ls = btrfs_ls,
+ .ls = fs_ls_generic,
.exists = btrfs_exists,
.size = btrfs_size,
.read = btrfs_read,
diff --git a/include/btrfs.h b/include/btrfs.h
index 6fff45a497ee..3878b7817ea6 100644
--- a/include/btrfs.h
+++ b/include/btrfs.h
@@ -15,7 +15,6 @@ struct fs_dirent;
int btrfs_probe(struct blk_desc *fs_dev_desc,
struct disk_partition *fs_partition);
-int btrfs_ls(const char *);
int btrfs_exists(const char *);
int btrfs_size(const char *, loff_t *);
int btrfs_read(const char *, void *, loff_t, loff_t, loff_t *);
--
2.53.0
^ permalink raw reply related
* [PATCH v2 1/2] fs: btrfs: implement opendir(), readdir() and closedir()
From: Alexey Charkov @ 2026-06-26 15:18 UTC (permalink / raw)
To: Qu Wenruo, linux-btrfs, u-boot
Cc: Marek Behún, Tom Rini, Simon Glass, Timo tp Preißl,
Peng Fan, Patrice Chotard, Yao Zi, Alexey Charkov
In-Reply-To: <20260626-btrfs-readdir-v2-0-7dd43f72d1b4@flipper.net>
Add support for generic directory iteration with opendir(), readdir() and
closedir() in the btrfs filesystem driver.
Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
fs/btrfs/btrfs.c | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/btrfs/ctree.h | 2 ++
fs/btrfs/dir-item.c | 73 +++++++++++++++++++++++++++++++++++++++
fs/fs.c | 4 ++-
include/btrfs.h | 5 +++
5 files changed, 181 insertions(+), 1 deletion(-)
diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c
index f3087f690fa4..6f034861da90 100644
--- a/fs/btrfs/btrfs.c
+++ b/fs/btrfs/btrfs.c
@@ -8,7 +8,9 @@
#include <config.h>
#include <malloc.h>
#include <u-boot/uuid.h>
+#include <linux/kernel.h>
#include <linux/time.h>
+#include <fs.h>
#include "btrfs.h"
#include "crypto/hash.h"
#include "disk-io.h"
@@ -159,6 +161,102 @@ int btrfs_ls(const char *path)
return 0;
}
+/*
+ * The fs layer closes and re-probes btrfs between readdir() calls (see
+ * fs_readdir() in fs/fs.c), freeing and reallocating fs_info, so root cannot
+ * be stored directly. The subvolume id and inode number are stable though, so
+ * re-resolve the root from the current fs_info by subvolume id, which avoids
+ * a full path walk and is much faster.
+ */
+struct btrfs_dir_stream {
+ struct fs_dir_stream parent;
+ struct fs_dirent dirent;
+ u64 subvolid;
+ u64 ino;
+ u64 offset;
+};
+
+int btrfs_opendir(const char *dirname, struct fs_dir_stream **dirsp)
+{
+ struct btrfs_fs_info *fs_info = current_fs_info;
+ struct btrfs_dir_stream *dirs;
+ struct btrfs_root *root;
+ u64 ino;
+ u8 type;
+ int ret;
+
+ *dirsp = NULL;
+ ASSERT(fs_info);
+
+ ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
+ dirname, &root, &ino, &type, 40);
+ if (ret < 0)
+ return ret;
+ if (type != BTRFS_FT_DIR)
+ return -ENOTDIR;
+
+ dirs = calloc(1, sizeof(*dirs));
+ if (!dirs)
+ return -ENOMEM;
+ dirs->subvolid = root->root_key.objectid;
+ dirs->ino = ino;
+
+ *dirsp = &dirs->parent;
+ return 0;
+}
+
+static unsigned int btrfs_dirent_type_to_fs_type(u8 dirent_type)
+{
+ switch (dirent_type) {
+ case BTRFS_FT_DIR:
+ return FS_DT_DIR;
+ case BTRFS_FT_SYMLINK:
+ return FS_DT_LNK;
+ default:
+ return FS_DT_REG;
+ }
+}
+
+int btrfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
+{
+ struct btrfs_dir_stream *dirs = container_of(fs_dirs, struct btrfs_dir_stream, parent);
+ struct btrfs_fs_info *fs_info = current_fs_info;
+ struct fs_dirent *dent = &dirs->dirent;
+ struct btrfs_root *root;
+ struct btrfs_key key;
+ u8 type;
+ int ret;
+
+ *dentp = NULL;
+ ASSERT(fs_info);
+
+ key.objectid = dirs->subvolid;
+ key.type = BTRFS_ROOT_ITEM_KEY;
+ key.offset = (u64)-1;
+ root = btrfs_read_fs_root(fs_info, &key);
+ if (IS_ERR(root))
+ return PTR_ERR(root);
+
+ memset(dent, 0, sizeof(*dent));
+ ret = btrfs_next_dir_entry(root, dirs->ino, &dirs->offset, dent->name,
+ sizeof(dent->name), &type);
+ if (ret < 0)
+ return ret;
+ if (ret > 0)
+ return -ENOENT;
+
+ dent->type = btrfs_dirent_type_to_fs_type(type);
+ *dentp = dent;
+ return 0;
+}
+
+void btrfs_closedir(struct fs_dir_stream *fs_dirs)
+{
+ struct btrfs_dir_stream *dirs = container_of(fs_dirs, struct btrfs_dir_stream, parent);
+
+ free(dirs);
+}
+
int btrfs_exists(const char *file)
{
struct btrfs_fs_info *fs_info = current_fs_info;
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index b7be09d5df83..7de35aa7efd5 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -1225,6 +1225,8 @@ typedef int (*btrfs_iter_dir_callback_t)(struct btrfs_root *root,
struct btrfs_dir_item *di);
int btrfs_iter_dir(struct btrfs_root *root, u64 ino,
btrfs_iter_dir_callback_t callback);
+int btrfs_next_dir_entry(struct btrfs_root *root, u64 ino, u64 *offset,
+ char *namebuf, int namebuf_len, u8 *ftype);
/* inode.c */
int btrfs_lookup_path(struct btrfs_root *root, u64 ino, const char *filename,
struct btrfs_root **root_ret, u64 *ino_ret,
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 5f81d6414f06..b12298e20c41 100644
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -166,3 +166,76 @@ out:
btrfs_release_path(&path);
return ret;
}
+
+/*
+ * btrfs_next_dir_entry() - read one directory entry at or after a cursor
+ *
+ * Streaming counterpart to btrfs_iter_dir() for the fs-layer readdir, which
+ * is re-entered once per entry: returns the first real entry whose
+ * BTRFS_DIR_INDEX_KEY offset is >= *offset and advances *offset past it.
+ *
+ * @root, @ino: directory to read
+ * @offset: in/out cursor; DIR_INDEX offset to resume from
+ * @namebuf: caller buffer that receives the NUL-terminated name
+ * @namebuf_len: size of @namebuf in bytes
+ * @ftype: receives the BTRFS_FT_* type of the entry
+ *
+ * Return: 0 if an entry was returned, 1 when the directory is exhausted,
+ * -ve on error.
+ */
+int btrfs_next_dir_entry(struct btrfs_root *root, u64 ino, u64 *offset,
+ char *namebuf, int namebuf_len, u8 *ftype)
+{
+ struct btrfs_path path;
+ struct btrfs_key key;
+ struct btrfs_dir_item *di;
+ int name_len;
+ int ret;
+
+ btrfs_init_path(&path);
+ key.objectid = ino;
+ key.type = BTRFS_DIR_INDEX_KEY;
+ key.offset = *offset;
+
+ ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
+ if (ret < 0)
+ goto out;
+
+ if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
+ ret = btrfs_next_leaf(root, &path);
+ if (ret < 0)
+ goto out;
+ if (ret > 0) { /* end of tree */
+ ret = 1;
+ goto out;
+ }
+ }
+
+ btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
+ if (key.objectid != ino || key.type != BTRFS_DIR_INDEX_KEY) {
+ ret = 1; /* no more entries for this dir */
+ goto out;
+ }
+
+ di = btrfs_item_ptr(path.nodes[0], path.slots[0],
+ struct btrfs_dir_item);
+ if (verify_dir_item(root, path.nodes[0], di)) {
+ ret = -EUCLEAN;
+ goto out;
+ }
+
+ *offset = key.offset + 1;
+
+ name_len = btrfs_dir_name_len(path.nodes[0], di);
+ if (name_len > namebuf_len - 1)
+ name_len = namebuf_len - 1;
+ read_extent_buffer(path.nodes[0], namebuf,
+ (unsigned long)(di + 1), name_len);
+ namebuf[name_len] = '\0';
+ *ftype = btrfs_dir_type(path.nodes[0], di);
+ ret = 0;
+
+out:
+ btrfs_release_path(&path);
+ return ret;
+}
diff --git a/fs/fs.c b/fs/fs.c
index 8ea50a6c13c4..4694a88f776b 100644
--- a/fs/fs.c
+++ b/fs/fs.c
@@ -326,7 +326,9 @@ static struct fstype_info fstypes[] = {
.read = btrfs_read,
.write = fs_write_unsupported,
.uuid = btrfs_uuid,
- .opendir = fs_opendir_unsupported,
+ .opendir = btrfs_opendir,
+ .readdir = btrfs_readdir,
+ .closedir = btrfs_closedir,
.unlink = fs_unlink_unsupported,
.mkdir = fs_mkdir_unsupported,
.ln = fs_ln_unsupported,
diff --git a/include/btrfs.h b/include/btrfs.h
index 2d73add18e09..6fff45a497ee 100644
--- a/include/btrfs.h
+++ b/include/btrfs.h
@@ -10,6 +10,8 @@
struct blk_desc;
struct disk_partition;
+struct fs_dir_stream;
+struct fs_dirent;
int btrfs_probe(struct blk_desc *fs_dev_desc,
struct disk_partition *fs_partition);
@@ -20,5 +22,8 @@ int btrfs_read(const char *, void *, loff_t, loff_t, loff_t *);
void btrfs_close(void);
int btrfs_uuid(char *);
void btrfs_list_subvols(void);
+int btrfs_opendir(const char *filename, struct fs_dir_stream **dirsp);
+int btrfs_readdir(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
+void btrfs_closedir(struct fs_dir_stream *dirs);
#endif /* __U_BOOT_BTRFS_H__ */
--
2.53.0
^ permalink raw reply related
* [PATCH v2 0/2] fs: btrfs: add support for readdir
From: Alexey Charkov @ 2026-06-26 15:18 UTC (permalink / raw)
To: Qu Wenruo, linux-btrfs, u-boot
Cc: Marek Behún, Tom Rini, Simon Glass, Timo tp Preißl,
Peng Fan, Patrice Chotard, Yao Zi, Alexey Charkov
Btrfs in U-boot currently uses a custom callback for ls and doesn't expose
the standard opendir/readdir/closedir interface, making it harder to use
in generic code. One area where this would be useful is in discovering BLS
type 1 entries [1] on a Btrfs filesystem.
Add support for the standard interface, and implement ls in terms of it.
[1] https://lore.kernel.org/u-boot/20260604-bls-v1-0-4ce6d1ee4711@flipper.net/
Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
Changes in v2:
- Cache subvolume id and inode number instead of looking them up on every
readdir call (thanks Qu)
- Split out the dirent type conversion between btrfs and U-Boot filesystem
convention into a helper function (thanks Qu)
- Drop redundant check for XATTR entries in btrfs_next_dir_entry (thanks Qu)
- Remove btrfs_ls and show_dir which nothing calls after the second patch
- Use container_of instead of type-casting struct pointers
- Link to v1: https://patch.msgid.link/20260625-btrfs-readdir-v1-0-dd781a2b3965@flipper.net
To: Qu Wenruo <wqu@suse.com>
To: linux-btrfs@vger.kernel.org
To: u-boot@lists.denx.de
Cc: Marek Behún <kabel@kernel.org>
Cc: Tom Rini <trini@konsulko.com>
Cc: Alexey Charkov <alchark@flipper.net>
Cc: Peng Fan <peng.fan@nxp.com>
Cc: Simon Glass <sjg@chromium.org>
Cc: Timo tp Preißl <t.preissl@proton.me>
Cc: Patrice Chotard <patrice.chotard@foss.st.com>
Cc: Yao Zi <me@ziyao.cc>
---
Alexey Charkov (2):
fs: btrfs: implement opendir(), readdir() and closedir()
fs: btrfs: use fs_ls_generic() and drop custom implementation
fs/btrfs/btrfs.c | 199 ++++++++++++++++++++++------------------------------
fs/btrfs/ctree.h | 7 +-
fs/btrfs/dir-item.c | 76 ++++++++++++--------
fs/fs.c | 6 +-
include/btrfs.h | 6 +-
5 files changed, 143 insertions(+), 151 deletions(-)
---
base-commit: 19eafbadf20f56c1a24abe6b5e8774e776894261
change-id: 20260625-btrfs-readdir-8beac3ac5220
Best regards,
--
Alexey Charkov <alchark@flipper.net>
^ permalink raw reply
* [PATCH] btrfs: add EM_WARN_ON_ONCE() to dump the extent map on a warning
From: Jeff Layton @ 2026-06-26 11:21 UTC (permalink / raw)
To: Chris Mason, David Sterba
Cc: linux-btrfs, linux-kernel, kernel-team, Jeff Layton
When an extent_map trips a consistency check in the free path, the bare
WARN_ON() only gives a stack trace. For the checks in
btrfs_free_extent_map():
WARN_ON(btrfs_extent_map_in_tree(em));
WARN_ON(!list_empty(&em->list));
that means the report tells us an extent map was freed while still in the
tree, or while still linked onto a list (e.g. an inode's modified_extents
list), but nothing about the map itself: its flags, refcount, or its
geometry.
Borrow the pattern the mm code uses with VM_WARN_ON_ONCE_FOLIO() and
friends, which dump the offending object via dump_page() before the
warning. Add btrfs_dump_extent_map(), a helper that prints an extent
map's geometry, flags, refcount and list/tree membership, and an
EM_WARN_ON_ONCE(cond, em) macro that dumps the map before triggering the
warning and stack trace. As with the VM_*_ONCE helpers it fires only
once, which keeps these checks from spamming the log on a filesystem
that is repeatedly hitting them.
Unlike the existing dump_extent_map() helper (which is gated behind
CONFIG_BTRFS_DEBUG and calls ASSERT(0)) and unlike the VM_* helpers
(gated behind CONFIG_DEBUG_VM), EM_WARN_ON_ONCE() is always compiled in,
since the conditions it guards can be hit on production kernels and the
extra context is what makes those reports actionable. No btrfs_fs_info
is available at the call site, so the helper uses the plain printk helpers
rather than the device-aware btrfs_*() ones.
Convert both checks in btrfs_free_extent_map() to use it.
Signed-off-by: Jeff Layton <jlayton@kernel.org>
---
We've seen a number of crashes in our fleet that have shown WARN_ON()
pops from the list_empty() check here. I'm hoping this might give us a
bit more info.
---
fs/btrfs/extent_map.c | 20 ++++++++++++++++++--
fs/btrfs/extent_map.h | 22 ++++++++++++++++++++++
2 files changed, 40 insertions(+), 2 deletions(-)
diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 6b79bff241f2..670143f7d473 100644
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -63,8 +63,8 @@ void btrfs_free_extent_map(struct extent_map *em)
if (!em)
return;
if (refcount_dec_and_test(&em->refs)) {
- WARN_ON(btrfs_extent_map_in_tree(em));
- WARN_ON(!list_empty(&em->list));
+ EM_WARN_ON_ONCE(btrfs_extent_map_in_tree(em), em);
+ EM_WARN_ON_ONCE(!list_empty(&em->list), em);
kmem_cache_free(extent_map_cache, em);
}
}
@@ -316,6 +316,22 @@ static void dump_extent_map(struct btrfs_fs_info *fs_info, const char *prefix,
ASSERT(0);
}
+/*
+ * Dump the contents of an extent map to the kernel log. Used by
+ * EM_WARN_ON_ONCE() to print context about the offending map before its
+ * warning and stack trace.
+ */
+void btrfs_dump_extent_map(const struct extent_map *em, const char *prefix)
+{
+ pr_crit(
+"BTRFS: %s: em=%p start=%llu len=%llu disk_bytenr=%llu disk_num_bytes=%llu offset=%llu ram_bytes=%llu generation=%llu flags=0x%x refs=%u in_tree=%d list_empty=%d list=(next=%p prev=%p)\n",
+ prefix, em, em->start, em->len, em->disk_bytenr,
+ em->disk_num_bytes, em->offset, em->ram_bytes, em->generation,
+ em->flags, refcount_read(&em->refs),
+ btrfs_extent_map_in_tree(em), list_empty(&em->list),
+ em->list.next, em->list.prev);
+}
+
/* Internal sanity checks for btrfs debug builds. */
static void validate_extent_map(struct btrfs_fs_info *fs_info, struct extent_map *em)
{
diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index 6f685f3c9327..1d2efd4a5665 100644
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -8,6 +8,8 @@
#include <linux/rbtree.h>
#include <linux/list.h>
#include <linux/refcount.h>
+#include <linux/bug.h>
+#include <linux/stringify.h>
#include "fs.h"
struct btrfs_inode;
@@ -175,6 +177,26 @@ int btrfs_split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pr
struct extent_map *btrfs_alloc_extent_map(void);
void btrfs_free_extent_map(struct extent_map *em);
+void btrfs_dump_extent_map(const struct extent_map *em, const char *prefix);
+
+/*
+ * Warn once about a condition involving an extent map, dumping the offending
+ * map's contents (geometry, flags, refcount and list/tree membership) before
+ * the warning and stack trace, much like VM_WARN_ON_ONCE_FOLIO() does for
+ * folios.
+ */
+#define EM_WARN_ON_ONCE(cond, em) ({ \
+ static bool __section(".data..once") __warned; \
+ int __ret_warn_once = !!(cond); \
+ \
+ if (unlikely(__ret_warn_once && !__warned)) { \
+ btrfs_dump_extent_map((em), \
+ "EM_WARN_ON_ONCE(" __stringify(cond) ")"); \
+ __warned = true; \
+ WARN_ON(1); \
+ } \
+ unlikely(__ret_warn_once); \
+})
int __init btrfs_extent_map_init(void);
void __cold btrfs_extent_map_exit(void);
int btrfs_unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen);
---
base-commit: eae9071be4d8d386e6530120bdaee42f6da1f70f
change-id: 20260626-em-warn-on-dump-e82922269f25
Best regards,
--
Jeff Layton <jlayton@kernel.org>
^ permalink raw reply related
* Re: [RFC 08/15] btrfs: implement RAID stripe-tree RAID5 writes
From: Johannes Thumshirn @ 2026-06-26 10:51 UTC (permalink / raw)
To: XIAO WU, linux-btrfs
In-Reply-To: <tencent_276F7EF21CF219623E5C48630C8A64190D06@qq.com>
On 6/22/26 10:20 PM, XIAO WU wrote:
> Hi Johannes,
>
> I came across the Sashiko AI review [1] of this patch and was able to
> reproduce a null pointer dereference during mount on a RAID5 filesystem
> with the raid-stripe-tree feature enabled. I wanted to share the
> concrete evidence since it crashes deterministically with KASAN.
>
> > + set->stripe_units[i].pstripe = pstripe;
>
> The Sashik identified that btrfs_stripe_set_alloc() stores a
> direct pointer into bioc->stripes[] without taking a reference on the
> bioc. When the data bios complete first, the bioc can be freed before
> the async parity workqueue dereferences pstripe. The review also noted
> several other issues in the same patch:
>
> - raid56_write_end_io_work() completes the data ordered extent before
> the parity bio finishes — an fsync could return success while data
> remains without parity protection on disk.
>
> - btrfs_submit_raid56_write() overwrites bio->bi_end_io and may leak
> the base bioc allocation reference on every chunk write.
>
> - btrfs_rst_raid56_write() folds the full unsplit bio size into the
> parity buffer, which could cause double-folding on the remainder
> when the caller loops after btrfs_split_bio().
>
> - bio_set_dev(bio, pstripe->dev->bdev) followed by submit_bio()
> will panic on a degraded array where the missing device's bdev
> is NULL.
>
Hi,
Sorry for the late reply. Thanks for the report. As I wrote in the cover
letter this is a pure RFC and not intended to be used yet. I'll fix it
up so the 1st official submission won't have this bug.
> [Reproduction]
>
> The PoC creates three loopback devices, makes a RAID5 btrfs, then
> manually flips the raid-stripe-tree incompat flag in each superblock
> (recalculating CRC32C) before mounting. The null pointer dereference
> occurs deterministically during mount in btrfs_read_block_groups().
>
> [Crash log — kernel 7.1.0-g3b216e369cba, CONFIG_KASAN=y, SMP]
>
> BTRFS info (device loop0): first mount of filesystem df5f7a81-...
> BTRFS info (device loop0): using crc32c checksum algorithm
>
> Oops: general protection fault, probably for non-canonical address
> 0xdffffc0000000020: 0000 [#1] SMP KASAN NOPTI
> KASAN: null-ptr-deref in range [0x0000000000000100-0x0000000000000107]
>
> RIP: 0010:btrfs_update_global_block_rsv+0x452/0x960
> RAX: 0000000000000020 RBX: 0000000000000000 RCX: 0000000000000000
> RDX: dffffc0000000000 RBP: 0000000000000000
>
> Call Trace:
> <TASK>
> btrfs_update_global_block_rsv+0x452/0x960
> btrfs_read_block_groups+0x16ee/0x2e20
> open_ctree+0x4804/0x8370
> btrfs_get_tree+0x1346/0x2740
> vfs_get_tree+0x93/0x340
> path_mount+0x7c4/0x2390
> __x64_sys_mount+0x298/0x310
> do_syscall_64+0x129/0x850
> entry_SYSCALL_64_after_hwframe+0x77/0x7f
> </TASK>
>
> Kernel panic - not syncing: Fatal exception
>
> The PoC is attached below. It compiles with:
>
> gcc -o poc poc.c -static
>
> [1]
> https://sashiko.dev/#/patchset/20260619090211.497100-1-johannes.thumshirn%40wdc.com
> (Sashiko AI code review — "Use-After-Free", Severity: High)
>
> Thanks,
> XIAOWU
>
> /*
> * PoC: btrfs RAID stripe-tree RAID5 write Use-After-Free
> *
> * Bug: In btrfs_stripe_set_alloc(), raw pointer into bioc->stripes[] is
> * stored as pstripe without incrementing bioc refcount.
> */
> #define _GNU_SOURCE
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> #include <stdint.h>
> #include <unistd.h>
> #include <fcntl.h>
> #include <errno.h>
> #include <sys/mount.h>
> #include <sys/wait.h>
>
> #define MOUNT_POINT "/mnt"
>
> int main(void)
> {
> char cmd[1024];
>
> setbuf(stdout, NULL);
>
> system("losetup -D 2>/dev/null; umount /mnt 2>/dev/null");
>
> printf("[*] Creating backing files...\n");
> for (int i = 0; i < 3; i++) {
> snprintf(cmd, sizeof(cmd),
> "dd if=/dev/zero of=/tmp/disk%d.img bs=1M count=512
> 2>/dev/null", i);
> system(cmd);
> }
>
> printf("[*] Setting up loop devices...\n");
> for (int i = 0; i < 3; i++) {
> snprintf(cmd, sizeof(cmd), "losetup /dev/loop%d
> /tmp/disk%d.img 2>&1", i, i);
> system(cmd);
> }
>
> printf("[*] Creating RAID5 btrfs...\n");
> system("mkfs.btrfs -f -d raid5 -m raid5 /dev/loop0 /dev/loop1
> /dev/loop2 2>&1");
> system("sync");
>
> /*
> * Write Python script for superblock update to a file first
> * to avoid quoting issues.
> */
> printf("[*] Writing and running Python fix script...\n");
> system("cat > /tmp/fix_sb.py << 'SCRIPT'\n"
> "#!/usr/bin/env python3\n"
> "import struct, os, sys\n"
> "\n"
> "# CRC32C using polynomial 0x1EDC6F41 (reflected: 0x82F63B78)\n"
> "table = [0] * 256\n"
> "for i in range(256):\n"
> " crc = i\n"
> " for _ in range(8):\n"
> " if crc & 1:\n"
> " crc = (crc >> 1) ^ 0x82F63B78\n"
> " else:\n"
> " crc >>= 1\n"
> " table[i] = crc\n"
> "\n"
> "def crc32c_calc(data):\n"
> " crc = 0xFFFFFFFF\n"
> " for byte in data:\n"
> " crc = (crc >> 8) ^ table[(crc ^ byte) & 0xFF]\n"
> " return crc ^ 0xFFFFFFFF\n"
> "\n"
> "# Verify with known test vector\n"
> "test_csum = crc32c_calc(b'\\x00' * 4064) # 4096-32=4064\n"
> "print(f'Test CRC32C of 4064 zero bytes: {test_csum:08x}')\n"
> "\n"
> "for dev in ['/dev/loop0', '/dev/loop1', '/dev/loop2']:\n"
> " for sb_base in [65536, 67108864]:\n"
> " try:\n"
> " with open(dev, 'r+b') as f:\n"
> " f.seek(sb_base)\n"
> " sb = bytearray(f.read(4096))\n"
> " \n"
> " # incompat_flags at offset 0xBC (188)\n"
> " val = struct.unpack('<Q', sb[188:196])[0]\n"
> " new_val = val | (1 << 14)\n"
> " print(f'{dev}@{sb_base}: 0x{val:x} ->
> 0x{new_val:x}')\n"
> " struct.pack_into('<Q', sb, 188, new_val)\n"
> " \n"
> " # Compute CRC32C over bytes 32..4095\n"
> " csum = crc32c_calc(bytes(sb[32:4096]))\n"
> " struct.pack_into('<I', sb, 0, csum)\n"
> " \n"
> " f.seek(sb_base)\n"
> " f.write(bytes(sb))\n"
> " except Exception as e:\n"
> " print(f'Error: {e}', file=sys.stderr)\n"
> "os.sync()\n"
> "print('Done!')\n"
> "SCRIPT\n");
>
> system("python3 /tmp/fix_sb.py 2>&1");
>
> printf("[*] Attempting mount ro,rescue=ignorebadroots...\n");
> if (mount("/dev/loop0", MOUNT_POINT, "btrfs", MS_RDONLY,
> "rescue=ignorebadroots,rescue=usebackuproot") != 0) {
> perror("mount with rescue");
> /* Try without usebackuproot */
> if (mount("/dev/loop0", MOUNT_POINT, "btrfs", MS_RDONLY,
> "rescue=ignorebadroots") != 0) {
> perror("mount simple rescue");
> system("dmesg | tail -5");
> goto cleanup;
> }
> }
> printf("[+] Mounted ro!\n");
>
> /* Try to remount rw */
> if (mount("/dev/loop0", MOUNT_POINT, "btrfs", MS_REMOUNT, NULL) ==
> 0) {
> printf("[+] Remounted rw!\n");
> unsigned char *buf = malloc(262144);
> if (buf) {
> memset(buf, 0xA5, 262144);
> int fd = open(MOUNT_POINT "/test", O_CREAT | O_RDWR, 0644);
> if (fd >= 0) {
> for (int i = 0; i < 50; i++) {
> write(fd, buf, 262144);
> fsync(fd);
> }
> close(fd);
> }
> free(buf);
> }
> sync();
> usleep(500000);
> }
> umount(MOUNT_POINT);
>
> cleanup:
> system("losetup -D 2>/dev/null");
> for (int i = 0; i < 3; i++) {
> snprintf(cmd, sizeof(cmd), "rm -f /tmp/disk%d.img", i);
> system(cmd);
> }
> return 0;
> }
>
^ permalink raw reply
* Re: [PATCH 1/2] fs: btrfs: implement opendir(), readdir() and closedir()
From: Qu Wenruo @ 2026-06-26 10:23 UTC (permalink / raw)
To: Alexey Charkov
Cc: linux-btrfs, u-boot, Marek Behún, Tom Rini, Simon Glass,
Timo tp Preißl, Peng Fan, Patrice Chotard, Yao Zi
In-Reply-To: <CAKTNdwGH2OCWJ1A=jQWiLYQmxG8UFTBGwGh0Qno7OkUfxs4dtw@mail.gmail.com>
在 2026/6/26 18:51, Alexey Charkov 写道:
> On Fri, Jun 26, 2026 at 10:38 AM Qu Wenruo <wqu@suse.com> wrote:
[...]
>>
>> So it looks like u-boot only supports the above 3 types, and unlike
>> linux kernel the values doesn't match the btrfs internal ones.
>>
>> In that case, I'd still prefer a proper convertor function.
>
> Hmm, but the convertor function would still be the same switch
> statement, and it's only used in this single place. Would factoring it
> out actually improve readability?
This is mostly a cross-project tendency.
Inside kernel, we do not need a conversion because all the BTRFS_FT*
flags matches the FT_* inside kernel.
In progs we have btrfs_type_to_imode() to do the conversion to S_IF* flags.
Thus I'd prefer a convertor, even if there is only a single user.
>
>> [...]
>>> +
>>> + *offset = key.offset + 1;
>>> + type = btrfs_dir_type(path.nodes[0], di);
>>> +
>>> + /* XATTRs share the key space but are not directory entries. */
>>> + if (type == BTRFS_FT_XATTR) {
>>
>> This doesn't looks correct again.
>>
>> XATTR has their own keys, they should not show up among DIR_INDEX keys.
Firstly, xattr is per-inode, not per-dentry.
Thus I doubt if you can hit an XATTR type inside a DIR_INDEX.
The easily way to test the theory is just create a simple XATTR for
compression:
# mkfs.btrfs -f test.img
# mount test.img /mnt/btrfs
# touch /mnt/btrfs/foobar
# btrfs prop set /mnt/btrfs/foobar compression zstd
# sync
# btrfs ins dump-tree -t 5 test.img
[...]
item 6 key (257 XATTR_ITEM 550297449) itemoff 15812 itemsize 51
location key (0 UNKNOWN.0 0) type XATTR
transid 10 data_len 4 name_len 17
name: btrfs.compression
data zstd
You can see that XATTR_ITEM key is for that inode 257, not for the
parent directory inode (256).
Secondly, if you check the tree-checker.c from the kernel,
check_dir_item() will reject an XATTR dir type if the key is not
XATTR_ITEM_KEY.
So even if you really find a btrfs with XATTR dir type but with
DIR_INDEX key, btrfs will refuse to reject that tree block.
Thanks,
Qu
>
> Let me double check and adjust accordingly.
>
> Thanks a lot for your review!
>
> Best regards,
> Alexey
^ permalink raw reply
* Re: [PATCH] btrfs: always wait for ordered extents to avoid OE races
From: Qu Wenruo @ 2026-06-26 10:13 UTC (permalink / raw)
To: Filipe Manana; +Cc: linux-btrfs, syzbot+ba2afde329fc27e3f22e
In-Reply-To: <CAL3q7H6sNSPqkE+h7PgX+Vv+7o5zTokBi52F5SooMmxEEH-phQ@mail.gmail.com>
在 2026/6/26 18:45, Filipe Manana 写道:
> On Thu, Jun 25, 2026 at 11:39 PM Qu Wenruo <wqu@suse.com> wrote:
[...]
>> If acceptable, I'll add the microbenchmark into the commit message in
>> the next update.
>
> Instead of this approach, can we wait for the ordered extent(s) in DIO
> path that reverts i_size after the short write?
OK, I think that's possible.
I didn't see any special context requirement for iomap_end() callback.
But doing btrfs_start_ordered_extent() at the isize revert timing has
one extra problem, it will break nowait.
As btrfs_start_ordered_extent() will call wait_event().
At least the current one we won't directly sleep (the wait is happening
on the next buffered write).
Thanks,
Qu
^ permalink raw reply
* Re: [PATCH 1/2] fs: btrfs: implement opendir(), readdir() and closedir()
From: Alexey Charkov @ 2026-06-26 9:21 UTC (permalink / raw)
To: Qu Wenruo
Cc: linux-btrfs, u-boot, Marek Behún, Tom Rini, Simon Glass,
Timo tp Preißl, Peng Fan, Patrice Chotard, Yao Zi
In-Reply-To: <bbeac2f6-685d-4ace-b689-10d64c4e3ce5@suse.com>
On Fri, Jun 26, 2026 at 10:38 AM Qu Wenruo <wqu@suse.com> wrote:
>
>
>
> 在 2026/6/26 02:54, Alexey Charkov 写道:
> > Add support for generic directory iteration with opendir(), readdir() and
> > closedir() in the btrfs filesystem driver, following the ext4fs
> > implementation for opendir()/closedir() and the btrfs_iter_dir() function
> > for readdir().
> >
> > Signed-off-by: Alexey Charkov <alchark@flipper.net>
> > ---
> > fs/btrfs/btrfs.c | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++
> > fs/btrfs/ctree.h | 2 ++
> > fs/btrfs/dir-item.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++
> > fs/fs.c | 4 ++-
> > include/btrfs.h | 5 +++
> > 5 files changed, 193 insertions(+), 1 deletion(-)
> >
> > diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c
> > index f3087f690fa4..c647c8dedf4e 100644
> > --- a/fs/btrfs/btrfs.c
> > +++ b/fs/btrfs/btrfs.c
> > @@ -9,6 +9,7 @@
> > #include <malloc.h>
> > #include <u-boot/uuid.h>
> > #include <linux/time.h>
> > +#include <fs.h>
> > #include "btrfs.h"
> > #include "crypto/hash.h"
> > #include "disk-io.h"
> > @@ -159,6 +160,97 @@ int btrfs_ls(const char *path)
> > return 0;
> > }
> >
> > +struct btrfs_dir_stream {
> > + struct fs_dir_stream parent;
> > + struct fs_dirent dirent;
> > + char *dirname;
> > + u64 offset;
>
> This doesn't look correct to me, for an opened dir, we should have at
> least the root id or pointer, and an inode number.
>
> Not just an @dirname and re-do the path resolution again and again.
>
> In fact, I do not even think we should save @dirname here.
Thanks Qu, let me reshuffle these. I'm not a huge FS guru, so I was
just parroting what other existing U-Boot code does (ext4 in this
case). That might well not be the best approach here, even though it
worked for my use case.
> > +};
> > +
> > +int btrfs_opendir(const char *dirname, struct fs_dir_stream **dirsp)
> > +{
> > + struct btrfs_fs_info *fs_info = current_fs_info;
> > + struct btrfs_dir_stream *dirs;
> > + struct btrfs_root *root;
> > + u64 ino;
> > + u8 type;
> > + int ret;
> > +
> > + *dirsp = NULL;
> > + ASSERT(fs_info);
> > +
> > + ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
> > + dirname, &root, &ino, &type, 40);
>
> You just discard the most important @root and @ino.
>
> So what is the point here?
Thanks for the pointer, I will switch from repeated lookups to a
stored ino reference.
> > + if (ret < 0)
> > + return ret;
> > + if (type != BTRFS_FT_DIR)
> > + return -ENOTDIR;
> > +
> > + dirs = calloc(1, sizeof(*dirs));
> > + if (!dirs)
> > + return -ENOMEM;
> > + dirs->dirname = strdup(dirname);
> > + if (!dirs->dirname) {
> > + free(dirs);
> > + return -ENOMEM;
> > + }
> > +
> > + *dirsp = (struct fs_dir_stream *)dirs;
> > + return 0;
> > +}
> > +
> > +int btrfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
> > +{
> > + struct btrfs_dir_stream *dirs = (struct btrfs_dir_stream *)fs_dirs;
> > + struct btrfs_fs_info *fs_info = current_fs_info;
> > + struct fs_dirent *dent = &dirs->dirent;
> > + struct btrfs_root *root;
> > + u64 ino;
> > + u8 type;
> > + int ret;
> > +
> > + *dentp = NULL;
> > + ASSERT(fs_info);
> > +
> > + ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
> > + dirs->dirname, &root, &ino, &type, 40);
>
> No, doing the same path resolution again and again is not sane.
Ack
> > + if (ret < 0)
> > + return ret;
> > + if (type != BTRFS_FT_DIR)
> > + return -ENOTDIR;
> > +
> > + memset(dent, 0, sizeof(*dent));
> > + ret = btrfs_next_dir_entry(root, ino, &dirs->offset, dent->name,
> > + sizeof(dent->name), &type);
> > + if (ret < 0)
> > + return ret;
> > + if (ret > 0)
> > + return -ENOENT;
> > +
> > + switch (type) {
> > + case BTRFS_FT_DIR:
> > + dent->type = FS_DT_DIR;
> > + break;
> > + case BTRFS_FT_SYMLINK:
> > + dent->type = FS_DT_LNK;
> > + break;
> > + default:
> > + dent->type = FS_DT_REG;
> > + break;
>
> So it looks like u-boot only supports the above 3 types, and unlike
> linux kernel the values doesn't match the btrfs internal ones.
>
> In that case, I'd still prefer a proper convertor function.
Hmm, but the convertor function would still be the same switch
statement, and it's only used in this single place. Would factoring it
out actually improve readability?
> [...]
> > +
> > + *offset = key.offset + 1;
> > + type = btrfs_dir_type(path.nodes[0], di);
> > +
> > + /* XATTRs share the key space but are not directory entries. */
> > + if (type == BTRFS_FT_XATTR) {
>
> This doesn't looks correct again.
>
> XATTR has their own keys, they should not show up among DIR_INDEX keys.
Let me double check and adjust accordingly.
Thanks a lot for your review!
Best regards,
Alexey
^ permalink raw reply
* Re: [PATCH] btrfs: only account delalloc bytes for regular file inodes in btrfs_getattr()
From: Filipe Manana @ 2026-06-26 9:18 UTC (permalink / raw)
To: Dave Chen; +Cc: linux-btrfs, dsterba, cccheng
In-Reply-To: <20260626064524.2288234-1-davechen@synology.com>
On Fri, Jun 26, 2026 at 7:52 AM Dave Chen <davechen@synology.com> wrote:
>
> btrfs_getattr() unconditionally reads BTRFS_I(inode)->new_delalloc_bytes
> and adds it (sector-aligned) to stat->blocks for every inode type.
> However, new_delalloc_bytes lives in a union with last_dir_index_offset:
>
> union {
> u64 new_delalloc_bytes; /* files only */
> u64 last_dir_index_offset; /* directories only */
> };
>
> For a directory inode this memory holds last_dir_index_offset, which is
> set during directory logging (e.g. flush_dir_items_batch()) to the
> offset of the last logged BTRFS_DIR_INDEX_KEY. That offset grows with
> the number of entries ever created in the directory (dir indexes are
> monotonic and never reused), so it can be arbitrarily large.
>
> As a result, after a directory has been logged (e.g. via an fsync that
> triggers directory logging), btrfs_getattr() reports inflated st_blocks
> for that directory. The inflation is purely in-core and disappears
> after the inode is evicted and reloaded (btrfs_alloc_inode() zeroes the
> union), e.g. after a remount.
>
> Reproducer (on a btrfs filesystem):
>
> D=/mnt/btrfs/d
> mkdir -p $D
> for i in $(seq 1 20000); do touch $D/f$i; done
> sync # commit, push dir index high
> touch $D/trigger # dirty the dir in a new transaction
> xfs_io -c fsync $D # log the directory -> sets last_dir_index_offset
> stat -c '%b' $D # st_blocks is now inflated (e.g. 40)
> # umount + mount -> st_blocks drops back to the correct value
>
> The evict path already knows this union is type-dependent and guards the
> corresponding WARN_ON with !S_ISDIR() in btrfs_destroy_inode(); only
> btrfs_getattr() was missing the equivalent check.
>
> Only read new_delalloc_bytes for regular files, which are the only
> inodes that ever set it.
>
> Signed-off-by: Dave Chen <davechen@synology.com>
Reviewed-by: Filipe Manana <fdmanana@suse.com>
Will add it soon to github's for-next branch, thanks.
> ---
> fs/btrfs/inode.c | 3 ++-
> 1 file changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
> index 272598f6ae77..b446c3014b24 100644
> --- a/fs/btrfs/inode.c
> +++ b/fs/btrfs/inode.c
> @@ -8068,7 +8068,8 @@ static int btrfs_getattr(struct mnt_idmap *idmap,
> stat->result_mask |= STATX_SUBVOL;
>
> spin_lock(&BTRFS_I(inode)->lock);
> - delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes;
> + delalloc_bytes = S_ISREG(inode->i_mode) ?
> + BTRFS_I(inode)->new_delalloc_bytes : 0;
> inode_bytes = inode_get_bytes(inode);
> spin_unlock(&BTRFS_I(inode)->lock);
> stat->blocks = (ALIGN(inode_bytes, blocksize) +
> --
> 2.43.0
>
>
> Disclaimer: The contents of this e-mail message and any attachments are confidential and are intended solely for addressee. The information may also be legally privileged. This transmission is sent in trust, for the sole purpose of delivery to the intended recipient. If you have received this transmission in error, any use, reproduction or dissemination of this transmission is strictly prohibited. If you are not the intended recipient, please immediately notify the sender by reply e-mail or phone and delete this message and its attachments, if any.
>
^ permalink raw reply
* Re: [PATCH] btrfs: always wait for ordered extents to avoid OE races
From: Filipe Manana @ 2026-06-26 9:15 UTC (permalink / raw)
To: Qu Wenruo; +Cc: linux-btrfs, syzbot+ba2afde329fc27e3f22e
In-Reply-To: <9efd034f-fa6b-485c-aca7-a38f526d4083@suse.com>
On Thu, Jun 25, 2026 at 11:39 PM Qu Wenruo <wqu@suse.com> wrote:
>
>
>
> 在 2026/6/25 20:59, Filipe Manana 写道:
> [...]
> >
> >> @@ -896,42 +896,38 @@ lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct folio *folio,
> >> start_pos = round_down(pos, fs_info->sectorsize);
> >> last_pos = round_up(pos + write_bytes, fs_info->sectorsize) - 1;
> >>
> >> - if (start_pos < inode->vfs_inode.i_size) {
> >> - struct btrfs_ordered_extent *ordered;
> >> -
> >> - if (nowait) {
> >> - if (!btrfs_try_lock_extent(&inode->io_tree, start_pos,
> >> - last_pos, cached_state)) {
> >> - folio_unlock(folio);
> >> - folio_put(folio);
> >> - return -EAGAIN;
> >> - }
> >> - } else {
> >> - btrfs_lock_extent(&inode->io_tree, start_pos, last_pos,
> >> - cached_state);
> >> - }
> >> -
> >> - ordered = btrfs_lookup_ordered_range(inode, start_pos,
> >> - last_pos - start_pos + 1);
> >> - if (ordered &&
> >> - ordered->file_offset + ordered->num_bytes > start_pos &&
> >> - ordered->file_offset <= last_pos) {
> >> - btrfs_unlock_extent(&inode->io_tree, start_pos, last_pos,
> >> - cached_state);
> >> + if (nowait) {
> >> + if (!btrfs_try_lock_extent(&inode->io_tree, start_pos,
> >> + last_pos, cached_state)) {
> >> folio_unlock(folio);
> >> folio_put(folio);
> >> - btrfs_start_ordered_extent(ordered);
> >> - btrfs_put_ordered_extent(ordered);
> >> return -EAGAIN;
> >> }
> >> - if (ordered)
> >> - btrfs_put_ordered_extent(ordered);
> >> -
> >> - *lockstart = start_pos;
> >> - *lockend = last_pos;
> >> - ret = 1;
> >> + } else {
> >> + btrfs_lock_extent(&inode->io_tree, start_pos, last_pos,
> >> + cached_state);
> >> }
> >>
> >> + ordered = btrfs_lookup_ordered_range(inode, start_pos,
> >> + last_pos - start_pos + 1);
> >> + if (ordered &&
> >> + ordered->file_offset + ordered->num_bytes > start_pos &&
> >> + ordered->file_offset <= last_pos) {
> >> + btrfs_unlock_extent(&inode->io_tree, start_pos, last_pos,
> >> + cached_state);
> >> + folio_unlock(folio);
> >> + folio_put(folio);
> >> + btrfs_start_ordered_extent(ordered);
> >> + btrfs_put_ordered_extent(ordered);
> >> + return -EAGAIN;
> >> + }
> >> + if (ordered)
> >> + btrfs_put_ordered_extent(ordered);
> >> +
> >> + *lockstart = start_pos;
> >> + *lockend = last_pos;
> >> + ret = 1;
> >
> > And this is pointless, right below we can use "return 1;" and get rid
> > of the 'ret' variable.
> >
> > Since returning 1 no longer makes sense, just make it return 0 and remove 'ret'.
> >
> > Also in the caller, since lock_and_cleanup_extent_if_need() now always
> > returns with the extent range locked, we can get rid of it's local
> > variable named 'extents_locked' and use 'ret' as it does not make
> > sense anymore.
> >
> > Finally, with this change we now always look for ordered extents and
> > lock the range. Previously, we only did this if writes were within
> > i_size - which makes sense because, except for his new direct IO case
> > falling back to buffered IO, we could never find ordered extents
> > beyond i_size.
> >
> > Have you checked whether performance is affected?
>
> Here is the microbenchmark for the runtime of btrfs_buffered_write() and
> lock_and_cleanup_extent_if_need().
>
> The workload is a very basic xfs_io -f -c "pwrite 0 1m", which is always
> appending the isize for every 4K block.
>
> Before patch:
> - lock_and_cleanup_extent_if_need():
>
> runtime avg = 58.16 ns
> runtime stdev = 4.2
>
> - btrfs_buffered_write():
>
> runtime avg = 2115.6 ns
> runtime stdev = 1822.1
>
>
> Patched:
> - lock_and_cleanup_extent_if_need():
>
> runtime avg = 183.0 ns
> runtime stdev = 161.6
>
> - btrfs_buffered_write():
>
> runtime avg = 2973.3 ns
> runtime stdev = 4225.1
>
> So yes, the runtime of lock_and_cleanup_extent_if_need() has greatly
> increased, by more than 3 times, but still less than 1 micro second.
>
> The btrfs_buffered_write() itself is also much slower due to the extra
> extent unlock, the runtime is increased by 40%, but still less than 3 us.
>
> I'm not sure if the cost is acceptable or not. The increased runtime is
> pretty huge for the affected worst case scenario, and that's undeniable.
>
> But the overall runtime of btrfs_buffered_write() itself is still at
> single digit microsecond level.
>
> If acceptable, I'll add the microbenchmark into the commit message in
> the next update.
Instead of this approach, can we wait for the ordered extent(s) in DIO
path that reverts i_size after the short write?
>
> Thanks,
> Qu
>
> >
> > Thanks.
> >
> >> +
> >> /*
> >> * We should be called after prepare_one_folio() which should have locked
> >> * all pages in the range.
> >> @@ -1288,11 +1284,8 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
> >>
> >> /* No copied bytes, unlock, release reserved space and exit. */
> >> if (copied == 0) {
> >> - if (extents_locked)
> >> - btrfs_unlock_extent(&inode->io_tree, lockstart, lockend,
> >> - &cached_state);
> >> - else
> >> - btrfs_free_extent_state(cached_state);
> >> + btrfs_unlock_extent(&inode->io_tree, lockstart, lockend,
> >> + &cached_state);
> >> btrfs_delalloc_release_extents(inode, reserved_len);
> >> release_space(inode, *data_reserved, reserved_start, reserved_len,
> >> only_release_metadata);
> >> @@ -1311,17 +1304,7 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,
> >>
> >> ret = btrfs_dirty_folio(inode, folio, start, copied, &cached_state,
> >> only_release_metadata);
> >> - /*
> >> - * If we have not locked the extent range, because the range's start
> >> - * offset is >= i_size, we might still have a non-NULL cached extent
> >> - * state, acquired while marking the extent range as delalloc through
> >> - * btrfs_dirty_page(). Therefore free any possible cached extent state
> >> - * to avoid a memory leak.
> >> - */
> >> - if (extents_locked)
> >> - btrfs_unlock_extent(&inode->io_tree, lockstart, lockend, &cached_state);
> >> - else
> >> - btrfs_free_extent_state(cached_state);
> >> + btrfs_unlock_extent(&inode->io_tree, lockstart, lockend, &cached_state);
> >>
> >> btrfs_delalloc_release_extents(inode, reserved_len);
> >> if (ret) {
> >> --
> >> 2.54.0
> >>
> >>
>
^ permalink raw reply
* Re: [PATCH 01/19] btrfs: require at least 4 devices for RAID 6
From: patchwork-bot+linux-riscv @ 2026-06-26 8:21 UTC (permalink / raw)
To: Christoph Hellwig
Cc: linux-riscv, akpm, catalin.marinas, will, ardb, chenhuacai,
kernel, maddy, mpe, npiggin, chleroy, pjw, palmer, aou, alex, hca,
gor, agordeev, borntraeger, svens, tglx, mingo, bp, dave.hansen,
x86, hpa, herbert, dan.j.williams, clm, dsterba, arnd, song,
yukuai, linan122, linux-kernel, linux-arm-kernel, loongarch,
linuxppc-dev, linux-s390, linux-crypto, linux-btrfs, linux-arch,
linux-raid
In-Reply-To: <20260512052230.2947683-2-hch@lst.de>
Hello:
This series was applied to riscv/linux.git (fixes)
by Andrew Morton <akpm@linux-foundation.org>:
On Tue, 12 May 2026 07:20:41 +0200 you wrote:
> While the RAID6 algorithm could in theory support 3 devices by just
> copying the data disk to the two parity disks, this version is not only
> useless because it is a suboptimal version of 3-way mirroring, but also
> broken with various crashes and incorrect parity generation in various
> architecture-optimized implementations. Disallow it similar to mdraid
> which requires at least 4 devices for RAID 6.
>
> [...]
Here is the summary with links:
- [01/19] btrfs: require at least 4 devices for RAID 6
(no matching commit)
- [02/19] raid6: turn the userspace test harness into a kunit test
(no matching commit)
- [03/19] raid6: remove __KERNEL__ ifdefs
https://git.kernel.org/riscv/c/3d6beb659ddf
- [04/19] raid6: move to lib/raid/
(no matching commit)
- [05/19] raid6: remove unused defines in pq.h
https://git.kernel.org/riscv/c/06d2a66fb7c0
- [06/19] raid6: remove raid6_get_zero_page
https://git.kernel.org/riscv/c/885d31423183
- [07/19] raid6: use named initializers for struct raid6_calls
https://git.kernel.org/riscv/c/7e91f76a9668
- [08/19] raid6: improve the public interface
(no matching commit)
- [09/19] raid6: hide internals
(no matching commit)
- [10/19] raid6: rework the init helpers
(no matching commit)
- [11/19] raid6: use static_call for gen_syndrom and xor_syndrom
https://git.kernel.org/riscv/c/10f4b8e2a164
- [12/19] raid6: use static_call for raid6_recov_2data and raid6_recov_datap
(no matching commit)
- [13/19] raid6: update top of file comments
https://git.kernel.org/riscv/c/30bf04bd13a5
- [14/19] raid6_kunit: use KUNIT_CASE_PARAM
https://git.kernel.org/riscv/c/2175395f76c3
- [15/19] raid6_kunit: dynamically allocate data buffers using vmalloc
https://git.kernel.org/riscv/c/d67c25712fe3
- [16/19] raid6_kunit: cleanup dataptr handling
https://git.kernel.org/riscv/c/562bcbfcb99b
- [17/19] raid6_kunit: randomize parameters and increase limits
(no matching commit)
- [18/19] raid6_kunit: randomize parameters and increase limits
(no matching commit)
- [19/19] raid6_kunit: randomize buffer alignment
https://git.kernel.org/riscv/c/8cf0a6c4bb9e
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* Re: [PATCH 01/18] raid6: turn the userspace test harness into a kunit test
From: patchwork-bot+linux-riscv @ 2026-06-26 8:20 UTC (permalink / raw)
To: Christoph Hellwig
Cc: linux-riscv, akpm, catalin.marinas, will, ardb, chenhuacai,
kernel, maddy, mpe, npiggin, chleroy, pjw, palmer, aou, alex, hca,
gor, agordeev, borntraeger, svens, tglx, mingo, bp, dave.hansen,
x86, hpa, herbert, dan.j.williams, clm, dsterba, arnd, song,
yukuai, linan122, linux-kernel, linux-arm-kernel, loongarch,
linuxppc-dev, linux-s390, linux-crypto, linux-btrfs, linux-arch,
linux-raid
In-Reply-To: <20260518051804.462141-2-hch@lst.de>
Hello:
This series was applied to riscv/linux.git (fixes)
by Andrew Morton <akpm@linux-foundation.org>:
On Mon, 18 May 2026 07:17:44 +0200 you wrote:
> Currently the raid6 code can be compiled as userspace code to run the
> test suite. Convert that to be a kunit case with minimal changes to
> avoid mutating global state so that we can drop this requirement.
>
> Note that this is not a good kunit test case yet and will need a lot more
> work, but that is deferred until the raid6 code is moved to it's new
> place, which is easier if the userspace makefile doesn't need adjustments
> for the new location first.
>
> [...]
Here is the summary with links:
- [01/18] raid6: turn the userspace test harness into a kunit test
https://git.kernel.org/riscv/c/c4697486fc23
- [02/18] raid6: remove __KERNEL__ ifdefs
https://git.kernel.org/riscv/c/3d6beb659ddf
- [03/18] raid6: move to lib/raid/
https://git.kernel.org/riscv/c/3626738bc714
- [04/18] raid6: remove unused defines in pq.h
https://git.kernel.org/riscv/c/06d2a66fb7c0
- [05/18] raid6: remove raid6_get_zero_page
https://git.kernel.org/riscv/c/885d31423183
- [06/18] raid6: use named initializers for struct raid6_calls
https://git.kernel.org/riscv/c/7e91f76a9668
- [07/18] raid6: improve the public interface
https://git.kernel.org/riscv/c/35472bc6f31b
- [08/18] raid6: warn when using less than four devices
https://git.kernel.org/riscv/c/2790045a62eb
- [09/18] raid6: hide internals
(no matching commit)
- [10/18] raid6: rework registration of optimized algorithms
(no matching commit)
- [11/18] raid6: use static_call for gen_syndrom and xor_syndrom
https://git.kernel.org/riscv/c/10f4b8e2a164
- [12/18] raid6: use static_call for raid6_recov_2data and raid6_recov_datap
https://git.kernel.org/riscv/c/dd83de0341da
- [13/18] raid6: update top of file comments
https://git.kernel.org/riscv/c/30bf04bd13a5
- [14/18] raid6_kunit: use KUNIT_CASE_PARAM
https://git.kernel.org/riscv/c/2175395f76c3
- [15/18] raid6_kunit: dynamically allocate data buffers using vmalloc
https://git.kernel.org/riscv/c/d67c25712fe3
- [16/18] raid6_kunit: cleanup dataptr handling
https://git.kernel.org/riscv/c/562bcbfcb99b
- [17/18] raid6_kunit: randomize parameters and increase limits
https://git.kernel.org/riscv/c/fa0c812c0aa5
- [18/18] raid6_kunit: randomize buffer alignment
https://git.kernel.org/riscv/c/8cf0a6c4bb9e
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply
* [Bug] general protection fault in btrfs_backref_free_node
From: Yue Sun @ 2026-06-26 6:55 UTC (permalink / raw)
To: Chris Mason, David Sterba; +Cc: linux-btrfs, linux-kernel, syzkaller
Hello,
We hit a reproducible general protection fault in Btrfs relocation while
running a syzkaller-based workload.
Kernel tested:
7.1.0-02765-g6b5a2b7d9bc1-dirty
The same vulnerable source pattern is still present in current upstream as of:
7.1.0-11610-gab9de95c9cf9
ab9de95c9cf9 ("Merge tag 'rust-7.2-2' of git://git.kernel.org/pub/scm/linux/kernel/git/ojeda/linux")
Crash log:
--- begin crash log ---
BTRFS info (device loop0): balance: start -d -m
BTRFS info (device loop0): relocating block group 6881280 flags data|metadata
BTRFS info (device loop0): relocating block group 5242880 flags data|metadata
Oops: general protection fault, probably for non-canonical address 0xdffffc0000000000: 0000 [#1] SMP KASAN NOPTI
KASAN: null-ptr-deref in range [0x0000000000000000-0x0000000000000007]
CPU: 0 UID: 0 PID: 10422 Comm: syz.0.17 Not tainted 7.1.0-02765-g6b5a2b7d9bc1-dirty #44 PREEMPT(full)
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.15.0-1 04/01/2014
RIP: 0010:btrfs_backref_free_node fs/btrfs/backref.c:3057 [inline]
RIP: 0010:btrfs_backref_free_node+0xb9/0x200 fs/btrfs/backref.c:3051
Code: 00 fc ff df 48 89 fa 48 c1 ea 03 80 3c 02 00 0f 85 43 01 00 00 48 b8 00 00 00 00 00 fc ff df 48 8b 5d 68 48 89 da 48 c1 ea 03 <80> 3c 02 00 0f 85 2e 01 00 00 4c 8b 2b 48 85 db 0f 85 c0 00 00 00
RSP: 0018:ffa0000006b0f3c0 EFLAGS: 00010246
RAX: dffffc0000000000 RBX: 0000000000000000 RCX: ffffffff840eb78b
RDX: 0000000000000000 RSI: ffffffff840eafa5 RDI: ff110000742ab768
RBP: ff110000742ab700 R08: 0000000000000000 R09: 0000000000000000
R10: ff110000742ab700 R11: 00000000000a81f9 R12: ff11000107a92020
R13: ff1100005c182ea8 R14: 0000000000000000 R15: dffffc0000000000
FS: 0000555575536500(0000) GS:ff11000183985000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fa3d0e9d580 CR3: 000000002232a000 CR4: 0000000000753ef0
PKRU: 00000000
Call Trace:
<TASK>
btrfs_backref_cleanup_node+0x27/0x30 fs/btrfs/backref.c:3133
relocate_tree_block fs/btrfs/relocation.c:2604 [inline]
relocate_tree_blocks+0x11b0/0x1a20 fs/btrfs/relocation.c:2707
relocate_block_group+0x499/0xf30 fs/btrfs/relocation.c:3635
do_nonremap_reloc fs/btrfs/relocation.c:5323 [inline]
btrfs_relocate_block_group+0x1749/0x5fb0 fs/btrfs/relocation.c:5490
btrfs_relocate_chunk+0x12b/0x950 fs/btrfs/volumes.c:3647
__btrfs_balance fs/btrfs/volumes.c:4586 [inline]
btrfs_balance+0x1c7f/0x55c0 fs/btrfs/volumes.c:4973
btrfs_ioctl_balance fs/btrfs/ioctl.c:3474 [inline]
btrfs_ioctl+0x38a4/0x5d20 fs/btrfs/ioctl.c:5570
vfs_ioctl fs/ioctl.c:51 [inline]
__do_sys_ioctl fs/ioctl.c:597 [inline]
__se_sys_ioctl fs/ioctl.c:583 [inline]
__x64_sys_ioctl+0x18f/0x210 fs/ioctl.c:583
do_syscall_x64 arch/x86/entry/syscall_64.c:63 [inline]
do_syscall_64+0x11f/0x860 arch/x86/entry/syscall_64.c:94
entry_SYSCALL_64_after_hwframe+0x77/0x7f
RIP: 0033:0x7fb38e3b56dd
Code: 02 b8 ff ff ff ff c3 66 0f 1f 44 00 00 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 a8 ff ff ff f7 d8 64 89 01 48
RSP: 002b:00007fff04115788 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
RAX: ffffffffffffffda RBX: 00007fb38f6b0020 RCX: 00007fb38e3b56dd
RDX: 00002000000003c0 RSI: 00000000c4009420 RDI: 0000000000000004
RBP: 00007fb38e451b48 R08: 0000000000000000 R09: 0000000000000000
R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000000
R13: 0000000000000000 R14: 00007fb38f6b0020 R15: 00007fb38f6b002c
</TASK>
Modules linked in:
---[ end trace 0000000000000000 ]---
RIP: 0010:btrfs_backref_free_node fs/btrfs/backref.c:3057 [inline]
RIP: 0010:btrfs_backref_free_node+0xb9/0x200 fs/btrfs/backref.c:3051
Code: 00 fc ff df 48 89 fa 48 c1 ea 03 80 3c 02 00 0f 85 43 01 00 00 48 b8 00 00 00 00 00 fc ff df 48 8b 5d 68 48 89 da 48 c1 ea 03 <80> 3c 02 00 0f 85 2e 01 00 00 4c 8b 2b 48 85 db 0f 85 c0 00 00 00
RSP: 0018:ffa0000006b0f3c0 EFLAGS: 00010246
RAX: dffffc0000000000 RBX: 0000000000000000 RCX: ffffffff840eb78b
RDX: 0000000000000000 RSI: ffffffff840eafa5 RDI: ff110000742ab768
RBP: ff110000742ab700 R08: 0000000000000000 R09: 0000000000000000
R10: ff110000742ab700 R11: 00000000000a81f9 R12: ff11000107a92020
R13: ff1100005c182ea8 R14: 0000000000000000 R15: dffffc0000000000
FS: 0000555575536500(0000) GS:ff11000183985000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007fa3d0e4d060 CR3: 000000002232a000 CR4: 0000000000753ef0
PKRU: 00000000
----------------
Code disassembly (best guess), 3 bytes skipped:
0: df 48 89 fisttps -0x77(%rax)
3: fa cli
4: 48 c1 ea 03 shr $0x3,%rdx
8: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1)
c: 0f 85 43 01 00 00 jne 0x155
12: 48 b8 00 00 00 00 00 movabs $0xdffffc0000000000,%rax
19: fc ff df
1c: 48 8b 5d 68 mov 0x68(%rbp),%rbx
20: 48 89 da mov %rbx,%rdx
23: 48 c1 ea 03 shr $0x3,%rdx
* 27: 80 3c 02 00 cmpb $0x0,(%rdx,%rax,1) <-- trapping instruction
2b: 0f 85 2e 01 00 00 jne 0x15f
31: 4c 8b 2b mov (%rbx),%r13
34: 48 85 db test %rbx,%rbx
37: 0f 85 c0 00 00 00 jne 0xfd
--- end crash log ---
Root cause:
fs/btrfs/backref.c currently contains:
ASSERT(node->eb == NULL, "node->eb->start=%llu", node->eb->start);
When node->eb is NULL, the assertion condition is true, so the assertion
should pass. However ASSERT() performs a compile-time format check by calling
verify_assert_printk_format("check the format string" args) before the runtime
condition is tested. That causes node->eb->start to be evaluated even for the
passing case, dereferencing NULL and crashing.
Suggested fix direction:
The immediate single-site fix is to avoid printing node->eb->start when
node->eb is expected to be NULL. More generally, ASSERT() probably should not
evaluate diagnostic varargs unless the assertion fails, while still preserving
format checking.
Reproducer (C):
// autogenerated by syzkaller (https://github.com/google/syzkaller)
#define _GNU_SOURCE
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <setjmp.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/loop.h>
#ifndef __NR_memfd_create
#define __NR_memfd_create 319
#endif
static unsigned long long procid;
//% This code is derived from puff.{c,h}, found in the zlib development. The
//% original files come with the following copyright notice:
//% Copyright (C) 2002-2013 Mark Adler, all rights reserved
//% version 2.3, 21 Jan 2013
//% This software is provided 'as-is', without any express or implied
//% warranty. In no event will the author be held liable for any damages
//% arising from the use of this software.
//% Permission is granted to anyone to use this software for any purpose,
//% including commercial applications, and to alter it and redistribute it
//% freely, subject to the following restrictions:
//% 1. The origin of this software must not be misrepresented; you must not
//% claim that you wrote the original software. If you use this software
//% in a product, an acknowledgment in the product documentation would be
//% appreciated but is not required.
//% 2. Altered source versions must be plainly marked as such, and must not be
//% misrepresented as being the original software.
//% 3. This notice may not be removed or altered from any source distribution.
//% Mark Adler madler@alumni.caltech.edu
//% BEGIN CODE DERIVED FROM puff.{c,h}
#define MAXBITS 15
#define MAXLCODES 286
#define MAXDCODES 30
#define MAXCODES (MAXLCODES + MAXDCODES)
#define FIXLCODES 288
struct puff_state {
unsigned char* out;
unsigned long outlen;
unsigned long outcnt;
const unsigned char* in;
unsigned long inlen;
unsigned long incnt;
int bitbuf;
int bitcnt;
jmp_buf env;
};
static int puff_bits(struct puff_state* s, int need)
{
long val = s->bitbuf;
while (s->bitcnt < need) {
if (s->incnt == s->inlen)
longjmp(s->env, 1);
val |= (long)(s->in[s->incnt++]) << s->bitcnt;
s->bitcnt += 8;
}
s->bitbuf = (int)(val >> need);
s->bitcnt -= need;
return (int)(val & ((1L << need) - 1));
}
static int puff_stored(struct puff_state* s)
{
s->bitbuf = 0;
s->bitcnt = 0;
if (s->incnt + 4 > s->inlen)
return 2;
unsigned len = s->in[s->incnt++];
len |= s->in[s->incnt++] << 8;
if (s->in[s->incnt++] != (~len & 0xff) ||
s->in[s->incnt++] != ((~len >> 8) & 0xff))
return -2;
if (s->incnt + len > s->inlen)
return 2;
if (s->outcnt + len > s->outlen)
return 1;
for (; len--; s->outcnt++, s->incnt++) {
if (s->in[s->incnt])
s->out[s->outcnt] = s->in[s->incnt];
}
return 0;
}
struct puff_huffman {
short* count;
short* symbol;
};
static int puff_decode(struct puff_state* s, const struct puff_huffman* h)
{
int first = 0;
int index = 0;
int bitbuf = s->bitbuf;
int left = s->bitcnt;
int code = first = index = 0;
int len = 1;
short* next = h->count + 1;
while (1) {
while (left--) {
code |= bitbuf & 1;
bitbuf >>= 1;
int count = *next++;
if (code - count < first) {
s->bitbuf = bitbuf;
s->bitcnt = (s->bitcnt - len) & 7;
return h->symbol[index + (code - first)];
}
index += count;
first += count;
first <<= 1;
code <<= 1;
len++;
}
left = (MAXBITS + 1) - len;
if (left == 0)
break;
if (s->incnt == s->inlen)
longjmp(s->env, 1);
bitbuf = s->in[s->incnt++];
if (left > 8)
left = 8;
}
return -10;
}
static int puff_construct(struct puff_huffman* h, const short* length, int n)
{
int len;
for (len = 0; len <= MAXBITS; len++)
h->count[len] = 0;
int symbol;
for (symbol = 0; symbol < n; symbol++)
(h->count[length[symbol]])++;
if (h->count[0] == n)
return 0;
int left = 1;
for (len = 1; len <= MAXBITS; len++) {
left <<= 1;
left -= h->count[len];
if (left < 0)
return left;
}
short offs[MAXBITS + 1];
offs[1] = 0;
for (len = 1; len < MAXBITS; len++)
offs[len + 1] = offs[len] + h->count[len];
for (symbol = 0; symbol < n; symbol++)
if (length[symbol] != 0)
h->symbol[offs[length[symbol]]++] = symbol;
return left;
}
static int puff_codes(struct puff_state* s,
const struct puff_huffman* lencode,
const struct puff_huffman* distcode)
{
static const short lens[29] = {
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
static const short lext[29] = {
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
static const short dists[30] = {
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
8193, 12289, 16385, 24577};
static const short dext[30] = {
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
12, 12, 13, 13};
int symbol;
do {
symbol = puff_decode(s, lencode);
if (symbol < 0)
return symbol;
if (symbol < 256) {
if (s->outcnt == s->outlen)
return 1;
if (symbol)
s->out[s->outcnt] = symbol;
s->outcnt++;
} else if (symbol > 256) {
symbol -= 257;
if (symbol >= 29)
return -10;
int len = lens[symbol] + puff_bits(s, lext[symbol]);
symbol = puff_decode(s, distcode);
if (symbol < 0)
return symbol;
unsigned dist = dists[symbol] + puff_bits(s, dext[symbol]);
if (dist > s->outcnt)
return -11;
if (s->outcnt + len > s->outlen)
return 1;
while (len--) {
if (dist <= s->outcnt && s->out[s->outcnt - dist])
s->out[s->outcnt] = s->out[s->outcnt - dist];
s->outcnt++;
}
}
} while (symbol != 256);
return 0;
}
static int puff_fixed(struct puff_state* s)
{
static int virgin = 1;
static short lencnt[MAXBITS + 1], lensym[FIXLCODES];
static short distcnt[MAXBITS + 1], distsym[MAXDCODES];
static struct puff_huffman lencode, distcode;
if (virgin) {
lencode.count = lencnt;
lencode.symbol = lensym;
distcode.count = distcnt;
distcode.symbol = distsym;
short lengths[FIXLCODES];
int symbol;
for (symbol = 0; symbol < 144; symbol++)
lengths[symbol] = 8;
for (; symbol < 256; symbol++)
lengths[symbol] = 9;
for (; symbol < 280; symbol++)
lengths[symbol] = 7;
for (; symbol < FIXLCODES; symbol++)
lengths[symbol] = 8;
puff_construct(&lencode, lengths, FIXLCODES);
for (symbol = 0; symbol < MAXDCODES; symbol++)
lengths[symbol] = 5;
puff_construct(&distcode, lengths, MAXDCODES);
virgin = 0;
}
return puff_codes(s, &lencode, &distcode);
}
static int puff_dynamic(struct puff_state* s)
{
static const short order[19] =
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
int nlen = puff_bits(s, 5) + 257;
int ndist = puff_bits(s, 5) + 1;
int ncode = puff_bits(s, 4) + 4;
if (nlen > MAXLCODES || ndist > MAXDCODES)
return -3;
short lengths[MAXCODES];
int index;
for (index = 0; index < ncode; index++)
lengths[order[index]] = puff_bits(s, 3);
for (; index < 19; index++)
lengths[order[index]] = 0;
short lencnt[MAXBITS + 1], lensym[MAXLCODES];
struct puff_huffman lencode = {lencnt, lensym};
int err = puff_construct(&lencode, lengths, 19);
if (err != 0)
return -4;
index = 0;
while (index < nlen + ndist) {
int symbol;
int len;
symbol = puff_decode(s, &lencode);
if (symbol < 0)
return symbol;
if (symbol < 16)
lengths[index++] = symbol;
else {
len = 0;
if (symbol == 16) {
if (index == 0)
return -5;
len = lengths[index - 1];
symbol = 3 + puff_bits(s, 2);
} else if (symbol == 17)
symbol = 3 + puff_bits(s, 3);
else
symbol = 11 + puff_bits(s, 7);
if (index + symbol > nlen + ndist)
return -6;
while (symbol--)
lengths[index++] = len;
}
}
if (lengths[256] == 0)
return -9;
err = puff_construct(&lencode, lengths, nlen);
if (err && (err < 0 || nlen != lencode.count[0] + lencode.count[1]))
return -7;
short distcnt[MAXBITS + 1], distsym[MAXDCODES];
struct puff_huffman distcode = {distcnt, distsym};
err = puff_construct(&distcode, lengths + nlen, ndist);
if (err && (err < 0 || ndist != distcode.count[0] + distcode.count[1]))
return -8;
return puff_codes(s, &lencode, &distcode);
}
static int puff(
unsigned char* dest,
unsigned long* destlen,
const unsigned char* source,
unsigned long sourcelen)
{
struct puff_state s = {
.out = dest,
.outlen = *destlen,
.outcnt = 0,
.in = source,
.inlen = sourcelen,
.incnt = 0,
.bitbuf = 0,
.bitcnt = 0,
};
int err;
if (setjmp(s.env) != 0)
err = 2;
else {
int last;
do {
last = puff_bits(&s, 1);
int type = puff_bits(&s, 2);
err = type == 0 ? puff_stored(&s) : (type == 1 ? puff_fixed(&s) : (type == 2 ? puff_dynamic(&s) : -1));
if (err != 0)
break;
} while (!last);
}
*destlen = s.outcnt;
return err;
}
//% END CODE DERIVED FROM puff.{c,h}
#define ZLIB_HEADER_WIDTH 2
static int puff_zlib_to_file(const unsigned char* source, unsigned long sourcelen, int dest_fd)
{
if (sourcelen < ZLIB_HEADER_WIDTH)
return 0;
source += ZLIB_HEADER_WIDTH;
sourcelen -= ZLIB_HEADER_WIDTH;
const unsigned long max_destlen = 132 << 20;
void* ret = mmap(0, max_destlen, PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_ANON, -1, 0);
if (ret == MAP_FAILED)
return -1;
unsigned char* dest = (unsigned char*)ret;
unsigned long destlen = max_destlen;
int err = puff(dest, &destlen, source, sourcelen);
if (err) {
munmap(dest, max_destlen);
errno = -err;
return -1;
}
if (write(dest_fd, dest, destlen) != (ssize_t)destlen) {
munmap(dest, max_destlen);
return -1;
}
return munmap(dest, max_destlen);
}
static int setup_loop_device(unsigned char* data, unsigned long size, const char* loopname, int* loopfd_p)
{
int err = 0, loopfd = -1;
int memfd = syscall(__NR_memfd_create, "syzkaller", 0);
if (memfd == -1) {
err = errno;
goto error;
}
if (puff_zlib_to_file(data, size, memfd)) {
err = errno;
goto error_close_memfd;
}
loopfd = open(loopname, O_RDWR);
if (loopfd == -1) {
err = errno;
goto error_close_memfd;
}
if (ioctl(loopfd, LOOP_SET_FD, memfd)) {
if (errno != EBUSY) {
err = errno;
goto error_close_loop;
}
ioctl(loopfd, LOOP_CLR_FD, 0);
usleep(1000);
if (ioctl(loopfd, LOOP_SET_FD, memfd)) {
err = errno;
goto error_close_loop;
}
}
close(memfd);
*loopfd_p = loopfd;
return 0;
error_close_loop:
close(loopfd);
error_close_memfd:
close(memfd);
error:
errno = err;
return -1;
}
static void reset_loop_device(const char* loopname)
{
int loopfd = open(loopname, O_RDWR);
if (loopfd == -1) {
return;
}
if (ioctl(loopfd, LOOP_CLR_FD, 0)) {
}
close(loopfd);
}
static long syz_mount_image(
volatile long fsarg,
volatile long dir,
volatile long flags,
volatile long optsarg,
volatile long change_dir,
volatile unsigned long size,
volatile long image)
{
unsigned char* data = (unsigned char*)image;
int res = -1, err = 0, need_loop_device = !!size;
char* mount_opts = (char*)optsarg;
char* target = (char*)dir;
char* fs = (char*)fsarg;
char* source = NULL;
char loopname[64];
if (need_loop_device) {
int loopfd;
memset(loopname, 0, sizeof(loopname));
snprintf(loopname, sizeof(loopname), "/dev/loop%llu", procid);
if (setup_loop_device(data, size, loopname, &loopfd) == -1)
return -1;
close(loopfd);
source = loopname;
}
mkdir(target, 0777);
char opts[256];
memset(opts, 0, sizeof(opts));
if (strlen(mount_opts) > (sizeof(opts) - 32)) {
}
strncpy(opts, mount_opts, sizeof(opts) - 32);
if (strcmp(fs, "iso9660") == 0) {
flags |= MS_RDONLY;
} else if (strncmp(fs, "ext", 3) == 0) {
bool has_remount_ro = false;
char* remount_ro_start = strstr(opts, "errors=remount-ro");
if (remount_ro_start != NULL) {
char after = *(remount_ro_start + strlen("errors=remount-ro"));
char before = remount_ro_start == opts ? '\0' : *(remount_ro_start - 1);
has_remount_ro = ((before == '\0' || before == ',') && (after == '\0' || after == ','));
}
if (strstr(opts, "errors=panic") || !has_remount_ro)
strcat(opts, ",errors=continue");
} else if (strcmp(fs, "xfs") == 0) {
strcat(opts, ",nouuid");
} else if (strncmp(fs, "gfs2", 4) == 0 && (strstr(opts, "errors=panic") || strstr(opts, "debug"))) {
strcat(opts, ",errors=withdraw");
}
res = mount(source, target, fs, flags, opts);
if (res == -1) {
err = errno;
goto error_clear_loop;
}
res = open(target, O_RDONLY | O_DIRECTORY);
if (res == -1) {
err = errno;
goto error_clear_loop;
}
if (change_dir) {
res = chdir(target);
if (res == -1) {
err = errno;
}
}
error_clear_loop:
if (need_loop_device)
reset_loop_device(loopname);
errno = err;
return res;
}
uint64_t r[2] = {0xffffffffffffffff, 0x0};
int main(void)
{
syscall(__NR_mmap, /*addr=*/0x1ffffffff000ul, /*len=*/0x1000ul, /*prot=*/0ul, /*flags=MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE*/0x32ul, /*fd=*/(intptr_t)-1, /*offset=*/0ul);
syscall(__NR_mmap, /*addr=*/0x200000000000ul, /*len=*/0x1000000ul, /*prot=PROT_WRITE|PROT_READ|PROT_EXEC*/7ul, /*flags=MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE*/0x32ul, /*fd=*/(intptr_t)-1, /*offset=*/0ul);
syscall(__NR_mmap, /*addr=*/0x200001000000ul, /*len=*/0x1000ul, /*prot=*/0ul, /*flags=MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE*/0x32ul, /*fd=*/(intptr_t)-1, /*offset=*/0ul);
const char* reason;
(void)reason;
intptr_t res = 0;
if (write(1, "executing program\n", sizeof("executing program\n") - 1)) {}
// syz_mount_image$btrfs arguments: [
// fs: ptr[in, buffer] {
// buffer: {62 74 72 66 73 00} (length 0x6)
// }
// dir: ptr[in, buffer] {
// buffer: {2e 2f 66 69 6c 65 30 00} (length 0x8)
// }
// flags: mount_flags = 0x1000008 (8 bytes)
// opts: ptr[in, fs_options[btrfs_options]] {
// fs_options[btrfs_options] {
// elems: array[fs_opt_elem[btrfs_options]] {
// fs_opt_elem[btrfs_options] {
// elem: union btrfs_options {
// datacow: buffer: {64 61 74 61 63 6f 77} (length 0x7)
// }
// comma: const = 0x2c (1 bytes)
// }
// fs_opt_elem[btrfs_options] {
// elem: union btrfs_options {
// clear_cache: buffer: {63 6c 65 61 72 5f 63 61 63 68 65} (length 0xb)
// }
// comma: const = 0x2c (1 bytes)
// }
// fs_opt_elem[btrfs_options] {
// elem: union btrfs_options {
// metadata_ratio: fs_opt["metadata_ratio", fmt[hex, int32]] {
// name: buffer: {6d 65 74 61 64 61 74 61 5f 72 61 74 69 6f} (length 0xe)
// eq: const = 0x3d (1 bytes)
// val: int32 = 0x9 (18 bytes)
// }
// }
// comma: const = 0x2c (1 bytes)
// }
// fs_opt_elem[btrfs_options] {
// elem: union btrfs_options {
// rescan_uuid_tree: buffer: {72 65 73 63 61 6e 5f 75 75 69 64 5f 74 72 65 65} (length 0x10)
// }
// comma: const = 0x2c (1 bytes)
// }
// fs_opt_elem[btrfs_options] {
// elem: union btrfs_options {
// degraded: buffer: {64 65 67 72 61 64 65 64} (length 0x8)
// }
// comma: const = 0x2c (1 bytes)
// }
// fs_opt_elem[btrfs_options] {
// elem: union btrfs_options {
// space_cache_v1: buffer: {73 70 61 63 65 5f 63 61 63 68 65 3d 76 31} (length 0xe)
// }
// comma: const = 0x2c (1 bytes)
// }
// }
// common: array[fs_opt_elem[fs_options_common]] {
// }
// null: const = 0x0 (1 bytes)
// }
// }
// chdir: int8 = 0xfe (1 bytes)
// size: len = 0x51ab (8 bytes)
// img: ptr[in, buffer] {
// buffer: (compressed buffer with length 0x51ab)
// }
// ]
// returns fd_dir
memcpy((void*)0x2000000051c0, "btrfs\000", 6);
memcpy((void*)0x200000000000, "./file0\000", 8);
memcpy((void*)0x200000000080, "datacow", 7);
*(uint8_t*)0x200000000087 = 0x2c;
memcpy((void*)0x200000000088, "clear_cache", 11);
*(uint8_t*)0x200000000093 = 0x2c;
memcpy((void*)0x200000000094, "metadata_ratio", 14);
*(uint8_t*)0x2000000000a2 = 0x3d;
sprintf((char*)0x2000000000a3, "0x%016llx", (long long)9);
*(uint8_t*)0x2000000000b5 = 0x2c;
memcpy((void*)0x2000000000b6, "rescan_uuid_tree", 16);
*(uint8_t*)0x2000000000c6 = 0x2c;
memcpy((void*)0x2000000000c7, "degraded", 8);
*(uint8_t*)0x2000000000cf = 0x2c;
memcpy((void*)0x2000000000d0, "space_cache=v1", 14);
*(uint8_t*)0x2000000000de = 0x2c;
*(uint8_t*)0x2000000000df = 0;
memcpy((void*)0x200000005280, "\x78\x9c\xec\xdd\x5f\x68\x54\x57\x1e\x07\xf0\x33\xf9\xa3\xf1\x0f\x26\x3e\xc5\x5d\xf6\xc1\x7d\x58\x59\xc5\x05\x59\x11\x76\x51\xd8\x20\x18\x5d\x96\x85\xd9\xf5\x61\x59\xd8\xac\x59\x59\xc5\x3f\xbb\x25\x48\x03\xc1\xbe\x58\x4b\x69\x41\xc4\x60\xa0\xb6\x14\x8a\x0f\x7d\xe9\x4b\x49\xa5\x50\x5a\xaa\x04\x0b\x2d\x85\x8a\x20\x56\x5a\x14\x5b\x4b\x5e\x5a\x28\x84\x4a\xc1\x97\x96\x92\xb9\xf7\x4c\x66\xce\xf5\x66\xc6\x54\x1b\xab\x9f\x8f\x24\x77\xce\xfd\xdd\x73\xee\x99\xe1\x3e\xcc\x77\xcc\xb9\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x84\x70\x70\xcd\xca\xbf\xec\x5a\x3d\xbd\xae\xac\x3e\xdd\x3f\x76"
"\xea\xe8\xb2\xed\xe7\x4e\xef\x3f\x79\x63\x68\x68\xcb\x95\x10\x2a\xb5\xfd\x95\xbc\xbe\x67\xfb\xae\xbf\xef\xdf\xbd\xe7\xaf\x3d\xb1\xc3\xf0\xdf\xb2\x6d\x5f\x5f\xd9\x90\x59\xd7\xcf\xb3\xc6\x92\xa6\x9d\xb3\xfd\x9a\x7f\xfe\x13\x42\xe8\x4e\x06\xe8\xcc\xb7\x3b\x3a\x1b\xfa\x56\xd2\x13\x84\x23\xc5\x01\xe7\x75\xe0\x66\xff\xe8\xe6\xee\xc1\x6b\x13\x77\xce\x6c\xbc\x78\xfd\xd0\x86\xe2\x53\x67\x56\xcf\x62\x4f\x60\xb1\xe4\xd7\xd5\xf4\xdc\xb5\x34\x50\xfb\xdd\x91\x1c\x51\x6f\x37\x5c\x7a\x95\xa6\x4b\x34\xeb\x9f\x5e\x70\x3f\xc9\x93\x00\x00\xee\xc9\xa6\x6a\x6d\x53\x7f\x3b\x9a\xbf\xc5\xad\xb7\x8f\xa5\xf5\xa4\x3d\x90\xb4\xc7\x93\x76\x7c\x87\x30\xde\xd8\x58\x88\x6c\xdc\x25\x65\xf3\x5c\x9b\xd6\x17\x69\x9e\x03\x59\x54\x58\x5a\x3a\xcf\xa4\x9e\xbf\xfe\xf5\x76\x35\xed\x9f\xb4\x93\xa8\x71\x0f\xf3\x6c\x3e\x34\x8f\x34\x3d"
"\x65\xf3\x1c\x49\xea\x8b\x35\x4f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x87\xc9\xab\x1f\x5e\xba\xf4\xdc\xcb\xeb\xb7\x95\xd5\xa7\xfb\xc7\x4e\x1d\x5d\xb6\xfd\xdc\xe9\xfd\x27\x6f\x0c\x0d\x6d\xb9\x12\x42\x5f\x6d\x7f\x25\x2b\x57\x96\xff\xaa\xf3\x0f"
"\x9f\x2e\xdb\x79\xed\xf8\x91\x37\x7e\xb3\xaf\xe7\xed\x93\x9d\x79\xbf\xb8\xed\x6a\x38\x38\x7c\x12\x1f\xfc\xb1\x37\x84\xbd\x0d\x95\xe9\x38\xec\x97\xab\x42\xa8\x36\x17\x6a\xcd\xf0\x52\xb1\x70\xb0\xf6\xe0\xcf\xb1\x00\x00\x00\xc0\xa3\xe4\x17\xb5\xdf\x1d\xf5\x76\x16\x07\xbb\x9b\xda\x95\x5a\x9a\xac\xd4\xfe\x45\x59\x58\x3c\x70\xb3\x7f\x74\x73\xf7\xe0\xb5\x89\x3b\x67\x36\x5e\xbc\x7e\x68\xc3\xc2\xc7\xab\x96\x8c\x37\x70\xd7\xf1\xea\xed\xbe\xb9\x9f\x4a\x43\x30\x8e\xf1\x37\x1d\x6f\xae\x1e\x0f\x3d\x52\x18\x67\x7e\xe9\x88\x69\x9e\xff\x6c\xe6\xc9\x5b\x17\x26\x7e\xfb\xef\xb2\xfe\x85\xfc\xdf\x37\x7f\xfe\x8f\xaf\x9c\xfc\x0f\x00\x00\xc0\x8f\x21\xff\xa7\xe3\xcc\xaf\x55\xfe\xbf\xfa\xce\xf3\x4f\x75\x0d\xee\x7d\xaf\xac\x7f\x21\xff\xaf\x6d\x3a\x65\x21\xff\xc7\x19\xc7\xfc\xdf\x11\x16\x96\xff\x01\x00\x00\xe0\x61\xf6"
"\xa0\xf3\xff\x40\x61\x9c\xf9\xb5\xca\xff\xdf\x9d\x9f\x3a\x7f\xf9\xdb\xe3\xaf\x94\xf5\x2f\xe4\xff\x4d\xed\xe5\xff\xae\xc6\x69\xc7\x9d\x1f\xc5\x09\x1f\xee\x0d\x61\x53\xab\xa9\x03\x00\x00\x00\x25\xe2\xff\xbb\xcf\x7d\xb4\x10\xf3\x7a\xf6\xc9\x41\x9a\xd7\x3b\x66\x46\x7b\xa7\x7a\x6e\x5c\x2d\x1b\xaf\x90\xff\x07\xda\xcb\xff\xdd\xf7\xfd\x99\x01\x00\x00\x00\x0b\xf5\xbf\xb1\x7f\x1d\xbf\x30\x36\x7e\xb3\xac\x5e\xc8\xff\xd5\xf6\xf2\xff\xd2\x07\x3e\x73\x00\x00\x00\xa0\x5d\xfb\x4e\xfc\xff\xdc\xfa\x0d\x23\x2b\xcb\xea\x85\xfc\x3f\xdc\x5e\xfe\x5f\x9e\x6f\xf3\x95\x0f\x59\xa7\xf7\xe3\x5f\x21\x4c\xf4\x86\xd0\x33\xfb\x60\x24\x2b\x7c\x10\xc6\xff\x54\x2f\x00\x00\x00\x00\xf7\x49\xcc\xe9\x5f\x8d\x6e\xfd\xfe\xe3\xc1\xe9\x77\xcb\x8e\x2b\xe4\xff\x91\xf9\xef\xff\x1f\xef\x74\x10\xd7\xff\x37\xdd\xff\xaf\xb0\xfe\xbf\xa1\x90"
"\xdd\xf5\x6f\xab\x1b\x03\x00\x00\x00\xf0\x38\x2a\xae\xe7\x8f\xb7\xc7\xcf\xbe\xb9\xa0\xec\xfb\xf7\xdb\x5d\xff\x7f\xeb\x97\x3b\x76\xfd\x77\xe7\x3f\xbe\x28\x3b\x7f\x21\xff\x1f\x6b\x2f\xff\x77\x36\x6e\xef\xe7\xf7\xff\x01\x00\x00\xc0\x02\xfc\xdc\xbe\xff\xef\x9f\x85\x71\xe6\xd7\xea\xfe\xff\xdf\x0c\xdd\xfa\x7a\xdd\xe1\x67\x07\xcb\xfa\x17\xf2\xff\x78\x7b\xf9\x3f\x6e\x57\x34\x3e\xbd\xa9\xf8\xfa\x3c\xd3\x1b\xc2\x9a\xd9\x07\xf9\xdd\x04\x5f\x8b\xa7\x3b\x9c\x14\x26\xbb\x1b\x0a\xd9\x0b\x9f\xf4\xd8\x1d\x7b\xe4\x85\xc9\xa5\x0d\x85\x9a\x91\xa4\xc7\xef\x7b\x43\xf8\xf5\xec\x83\x63\x49\x61\x75\x2c\x8c\x27\x85\x99\x55\x79\xe1\x6c\x52\xb8\x1c\x0b\xf9\xf5\x50\x2f\xbc\x9e\x14\xa6\xe2\x95\xf6\xc2\xaa\x7c\xba\x69\xe1\xad\x58\xc8\x17\x58\x4c\xc6\x15\x14\x2b\xea\x4b\x22\x92\x1e\xb7\xcb\x7a\xcc\x16\xee\xda\xe3\x7a\xfd"
"\xe4\x00\x00\x00\x8f\x95\x18\x9e\xf3\x2c\xdb\xdd\xdc\x0c\x69\x94\x9d\xac\xb4\x3a\x60\x79\xab\x03\x3a\x5a\x1d\xd0\xd9\xea\x80\xae\xe4\x80\xf4\xc0\xb2\xfd\x61\xb8\xb9\x10\xf7\xbf\xb8\xed\x77\xb7\xaf\x3c\xf1\xe6\xd3\xa1\x44\x21\xff\x9f\x6d\x2f\xff\xc7\x97\x62\x49\xb6\x29\x5b\xff\x1f\xe2\xfa\xff\xfc\x7b\x0d\xeb\xeb\xff\x87\x63\xa1\x2f\x29\x4c\xc6\x42\x35\xbd\x63\x40\x35\x9e\x23\x0b\xbb\x27\xe2\x39\xfa\xaa\x79\x8f\x99\x35\xf5\x02\x00\x00\x00\x3c\xd2\xe2\xe7\x02\x9d\x8b\x3c\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x60\xef\xfe\x83\xec\xaa\xea\x03\x80\x9f\xfd\xfd\x23\x9b\xdd\x45\x1c\x01\x49\x35\x8a\x80\xe9\x90\xcd\x26\x31\x4a\x2b\x53\x02\xd5\x41\x71\xa6\x2e\x0e\x75\x9c\x3a\xd1\x44\x76\x83\xdb\x2c\x24\x26\x61\x20\x29\xed\x84\x40\x3b\x53\x98\x54\x54\xa6\xb5\xa3\x43\x43\x1d\x47\x69\x91\x46\x3a\x8e\x52\xb5\xa4\x4c\x81\x71\xa4\x53\x9b\xb6\x4c\xc5\x68\x65\xfc\x41\x6d\x6b\x19\xc6\x4a\x87\x52\x9b\xce\xdb\x7b\xcf\xdd\xfb\xce\xdd\x9b\xf7\x42\x76\x21\x4b\x3f\x9f\x3f\xf6\x9d\xf7\xbe\xe7\xe7\x7d\x3f\xf6\x9d\x7b\xef\x3b\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\x87\x7f\x19\x58\xf3\x1b\xfb\x57\xfc\xf4\xfc\xba\xf8\xf7\xcf\xb8\xe1\xc3\x7b\x07\x2e\xbd\xef\xa3\x5b\x0f\x1c\xdd\xb4\x69\xc3\x91\x10\x26\x66\x1f\xef\xc8\xc2\x1d\x83\x2b\xba\x2e\xfc\xe6\xc0\x65\x8f\xed\xdf\xf9\xf9\x73\xa7\xfa\xef\x3f\xd0\x9b\x97\xcb\xe3\x61\x59\xe3\x4f\x67\x7e\xe7\x96\xa2\xd6\xe5\x21\x7c\xb1\x23\x84\xee\x34\xb0\x7a\x28\x0b\xf4\xe4\xf7\x87\x62\x7d\x2b\x86\x42\x38\x2d\xcc\x05\x8a\x12\x53\x83\x59\x89\xb4\xe1\xf0\xd0\x40\x08\x07\xc3\x5c\xa0\xa8\xea\xfe\x81\x10\x86\x4a\x81\x2b\x8f\x3c\xf8\xc0\x81\x46\xe2\x8e\x81\x10"
"\xce\x0d\x21\xf4\xa5\x6d\x7c\xbb\x2f\x6b\x63\x20\x0d\x9c\xd7\x9b\x05\x06\xd3\xc0\xf6\xee\x2c\xf0\x5f\xc7\x32\x45\xe0\x4b\x9d\x59\x00\x4e\x5a\x7c\x33\x14\x2f\xfa\x43\x13\xcd\x19\x46\xe7\x2f\x57\xf3\xfa\xeb\x59\xb0\x8e\xbd\xb8\xd2\xe1\x75\xc5\xc4\x68\x7d\xbe\x1f\x5f\xb2\xc8\x9d\x2a\xe9\x4d\x1f\x98\x38\xa9\xa7\xad\x52\x1d\x8b\xa2\xf2\xf6\x38\xec\xdd\xb6\x04\xde\x6d\x95\xed\x7c\xbb\xa7\xad\xfc\x45\x2a\xff\x86\x72\x6c\x2e\xd4\x17\x3a\x27\xa7\xb6\x6e\xb9\x6e\x66\x77\x7c\xa4\x33\x8c\x8d\x75\xd5\xd5\xb4\x48\xcf\xf3\xe3\x4f\xdf\x78\xd5\x89\xa4\x97\xcc\xeb\x30\x76\x60\x74\x41\x5e\x87\xcf\xde\xf9\x9e\xeb\xcf\x9a\x7c\xcb\x8d\xb7\x6e\x3f\xe7\x89\xb5\xef\xbb\xe0\xe8\xc9\x76\xb3\x6e\xf3\x2e\xb6\xbe\x90\xbf\xe6\x96\xcc\xf3\x18\x6d\xf4\x79\xb2\x04\xde\x7e\x95\x6f\x49\x2b\x7d\xe9\x0a\x21\xfc\xdc\x07\xbb\x6f"
"\xea\xfa\xed\x23\x9f\xaa\x8b\x57\xe6\xff\xa3\xc7\x9f\xff\xc7\x97\x73\xbc\xed\x6c\xca\x1d\x6b\x7d\x6e\x38\x9b\x9b\xc7\x47\x86\x62\xe2\xa9\xe1\x6c\x6e\x0e\x00\x00\x00\x4b\xc6\x52\xd8\x6b\xfa\xa3\xb3\x5f\xf1\x7b\xab\x3a\xd7\x3c\x5e\x57\x5f\x65\xfe\xbf\xb2\xbd\xe3\xff\xf1\x90\x7f\x3e\x99\xcf\x46\x7b\x38\x84\x8d\xb3\x89\x9b\x47\x42\x38\x73\xf6\xf1\x2c\x70\x77\x6c\xee\x03\x23\x21\xbc\x66\x36\x35\xd1\x1c\xb8\x24\x09\x1c\x0e\xe1\xac\xd9\xc4\xaa\xa2\xaa\xa4\x44\x7f\x2c\xb1\x32\x09\x3c\x39\x9c\x07\x36\x26\x81\x87\x63\x60\x22\x09\x7c\x3a\x06\x6e\x4f\x02\xb7\xc4\xc0\xa1\x24\x70\x55\x0c\x1c\x4e\x02\x97\xc6\x40\x98\x6e\x1e\xc7\xcf\x0f\xe7\xe3\x68\x3b\x30\x10\x03\x9b\xb3\x8d\x78\x28\x9e\x85\xf0\x93\xe1\xd8\x5a\xb2\xad\xbe\x55\x54\x05\x00\x00\xb0\x40\xf2\xd9\x61\x4f\xf3\xdd\xd2\xb9\x0e\x27\x9b\x21\x4e\x2f"
"\x0f\x0d\xb4\xca\x10\xcf\xc0\xae\xcd\xd0\x97\xd4\x90\xce\x60\x8b\x69\x55\x6d\x0d\xdd\xad\x6a\xe8\x6c\x55\x43\x31\xee\x7d\xc7\x1f\x7e\xa5\xe6\x8e\x56\x35\x57\x4e\xc3\xe8\x68\xce\x70\xe9\x2b\xfe\xf0\xfc\x15\x5f\xbb\xe1\x0b\xa1\x46\x65\xfe\x3f\x7e\xfc\xf9\x7f\xdf\x3c\x1d\xe9\xa8\x1c\xff\x0f\xe1\x8a\xd9\xbf\x31\x77\x67\x1e\x99\x29\xe2\x9b\x27\x9a\x32\x00\x00\x00\x00\x27\x61\xed\x1b\x66\xbe\xf6\x27\x67\xbf\xe9\xcd\x75\xf1\xca\xfc\x7f\x63\x7b\xe7\xff\xc7\x7d\x22\x5d\xa5\xcc\xe1\xd1\xb8\x1b\x62\xdb\x48\x08\xe3\xcd\x81\xac\xda\x37\x57\x03\xd9\x51\xef\x65\x79\x00\x00\x00\x00\x96\x82\xe2\x78\x7c\x71\x2c\x7c\x3a\xbf\xcd\x4e\xd1\x4e\xe7\xd3\xd5\xfc\x13\x27\x98\x3f\x1e\xf8\xdf\x38\x6f\xfe\x5f\x0a\x93\xa7\x6f\xfb\xc1\x53\x1b\xea\xfa\x5b\x99\xff\x4f\xb4\x77\xfe\xff\x60\xf3\x6d\xd6\x89\x87\x63\x2f\x3e\x36"
"\x12\x42\x7f\x29\xf0\x48\xec\x65\x23\x30\x6b\x65\x0c\x7c\xf7\xe2\xe6\x40\x3e\xfe\x87\xe3\x06\xb8\x2d\x56\x95\x9f\x98\x50\x54\x75\x5b\x2c\xb1\x39\x06\xc6\x93\xc0\xc1\xba\x12\xdf\x28\x4a\x9c\xd9\x1c\xc8\x9f\xac\xa2\xf1\x9b\x8b\x71\x4c\xe7\x25\x4a\x01\x00\x00\x00\x78\xc1\xc5\xdd\x01\xf1\xb8\x7c\x3c\xff\xff\xc2\xb5\xdf\xfb\xd0\xa6\x8f\xef\xfd\x5c\x5d\xb9\xca\xfc\x7f\xf3\x89\x9d\xff\x3f\x3b\x0f\xae\x9c\xde\x3f\xb3\x2c\x84\x35\xdd\x21\x74\xa5\x3f\x0c\x78\x74\x30\x5b\x18\x30\x06\x86\x3a\xf2\xc4\x57\x07\xb3\xba\xba\xd2\xaa\x6e\x1a\x0c\xe1\xa2\xc6\xc0\xd2\xaa\x9e\xc8\xd7\xff\xef\x4e\xd7\x18\x3c\x32\x90\x55\x15\x03\x67\xbe\xf6\xb3\x4f\x9f\xd7\x48\x7c\x6a\x20\x84\x35\xe5\xc0\x63\xef\xbd\x6b\x76\xc7\xc8\xee\x24\x50\x34\xfe\xab\x03\x21\xbc\xba\x31\xda\xb4\xf1\x2f\xf4\x67\x8d\xf7\xa4\x8d\xff\x41\x7f\x08"
"\xaf\x2a\x05\x8a\xaa\x3e\xd0\x1f\x42\xa3\xb1\xde\xb4\xaa\x07\xfb\xf2\xeb\x18\xa4\x55\xfd\x59\x5f\x08\xa7\x97\x02\x45\x55\x6f\xec\x0b\x61\x4f\x00\x60\x89\x8a\xff\x4a\x27\xcb\x0f\xee\xda\xb3\x77\xdb\x96\x99\x99\xa9\x9d\x8b\x98\x88\xfb\xf0\x07\xc2\xd6\xe9\x99\xa9\xb1\xab\xb6\xcf\x4c\xf6\xd5\xf4\x69\x32\xe9\x73\xd3\x32\x46\x37\x55\xc7\xd4\xd9\xe6\xd8\x8f\xe6\x4b\x14\xdd\x73\xf9\xd8\x48\x3b\xe9\xe2\x77\x82\xe3\xe5\xbe\xe4\xfb\xf1\x2b\x27\x0e\xe6\xf7\xe3\x77\xa1\x9e\xd9\x71\xae\xeb\x69\xba\xbb\x3e\x1d\xf2\xeb\xcf\xa9\x36\x91\x0e\xe9\xc5\x18\xf2\x60\xb9\x92\xb9\x27\xb1\x52\x7f\xcc\xdf\x1b\x96\x85\xfe\xeb\x76\x4d\xed\x1c\xbb\x61\xcb\xee\xdd\x3b\xd7\x66\x7f\xdb\xcd\xbe\x2e\xfb\x1b\x0f\x33\x65\xdb\x6a\x6d\xba\xad\x06\xe7\xeb\x5b\x1b\x2f\x8f\x76\x17\x43\x7f\xbe\xdb\xaa\xe9\x32\x57\x6b\x76\x5f\xb3\x63"
"\xcd\xae\x3d\x7b\x57\x4f\x5f\xb3\xe5\xea\xa9\xab\xa7\xae\x7d\xc3\xf8\xba\xf1\x75\xeb\xc7\x37\xbc\xe9\xc2\x35\x8d\x51\x8d\x67\x7f\x5b\x0c\xf5\xfc\xf9\xaa\x4e\x86\x7a\xec\xae\xea\x10\xda\xbd\x06\xd4\xf3\x1d\xea\x2b\xbb\x4b\x95\xbc\x10\x9f\x1a\x12\x12\x12\x4b\x2d\xb1\xe5\xe2\xaf\xfe\xe5\xbd\x67\x7d\x62\x59\xdd\xc7\x4f\x65\xfe\xbf\xe3\xf8\xf3\xff\xf8\xa9\x13\x3f\xf9\xf3\xf5\x19\xea\x8e\xff\x8f\xc6\xc3\xfc\xd9\xe3\x73\x87\xf9\x37\xc7\xc0\xc1\x76\x8f\xff\x8f\xd6\x1d\xcd\x2f\x4e\x0c\x58\x99\x04\xf6\xc5\xc0\x3e\x87\xf9\x01\x00\x00\x78\x69\x88\xbb\x1b\xe3\xde\xcc\xb8\x57\xba\xe7\xa6\xd5\x63\x7f\xfc\xc9\x47\x9e\xac\x2b\x57\x99\xff\xef\x6b\xef\xf7\xff\x0b\xb4\xfe\x7f\xb1\x74\xfd\xe5\x75\xcb\xfc\xaf\x8a\x25\xc6\xeb\xd6\xff\x4f\x97\xf9\x2f\xd6\xff\xdf\x57\xb7\xfe\x7f\xba\xcc\x7f\xb1\xfe\xff\xc1\x17\x61"
"\xfd\xff\xeb\x8a\x40\xb2\x49\x7e\x62\xfd\x7f\x00\x00\xe0\xa5\xe0\x85\x5b\xff\xbf\xe5\xf2\xfe\xe9\x05\x02\x2a\x19\x5a\x2e\xef\x9f\x5e\x20\xa0\x92\xa1\xe5\x32\xfe\xed\x5e\x20\xe0\x84\xd7\xff\x7f\xfb\x73\xaf\xeb\xb9\xe6\x23\xaf\xbe\x25\xd4\xa8\xcc\xff\x6f\x6f\x6f\xfe\x6f\xe1\x7e\x00\x00\x00\x38\x75\xdc\x75\x64\x43\xc7\x83\xff\xfa\x3f\x0f\xd5\xc5\x2b\xf3\xff\x83\xed\xcd\xff\x5f\xf8\xf5\xff\x42\xdd\xf9\xff\x2b\xeb\x02\x13\x75\x0b\x03\x5a\xff\x0f\x00\x00\x80\x25\xaa\x6e\xfd\xbf\xf5\xaf\xfb\xf1\xe6\xcf\xfd\x6c\xc5\x0f\xeb\xca\x55\xe6\xff\x87\xda\x9b\xff\xc7\xd3\x2e\x3a\x9b\x72\xc7\x5a\x9f\x1b\xce\xd6\xb4\x0b\xe9\x9a\x76\x4f\x0d\x17\x3f\x19\x00\x00\x00\x80\xa5\xa1\x33\x8c\x8d\xb5\xbb\xa2\x69\xd3\xca\xa8\x97\x3c\xff\x36\x1f\xcf\x97\x02\x3d\x5e\xba\xec\xaf\xbe\x7c\xcd\x3f\x3e\xf2\xd6\xf7\xf6\xd7\xd5"
"\x57\x99\xff\x1f\x6e\x6f\xfe\xdf\xf4\xbb\x8c\x67\xef\x7c\xcf\xf5\x67\x4d\xbe\xe5\xc6\xe7\x6e\xdd\x7e\xce\x13\x6b\xdf\x77\xc1\xd1\xb9\xe3\xff\x00\x00\x00\xc0\xe2\x69\x77\xbf\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xe2\x7b\x7a\xef\xe4\xbb\xfe\xf9\xec\x3b\x3f\x53\x17\xaf\xfc\xfe\x3f\x5c\x31\xfb\x78\xdd\xef\xff\xe3\x75\xff\xe2\xef\x0b\x5e\xde\x94\x3b\xd6\xda\x7a\xfd\xbf\xfc\xfe\x95\xef\xb8\x77\xcf\xec\x92\x85\x8f\x0e\x87\x70\x4e\x39\xb0\x6d\xff\xb6\xd3\x42\x7e\x6d\xfe\xf3\xcb\x81\x07\x36\xad\x3a\xa3\x91\xd8\x9f\x96\xf8\xca\x77\x2e\xfd\x41\x23\xf1\xfe\x34\xf0\xb6\xd5\x2f\x7b\xa6\x91\xb8\x28\x09\x6c\x8e\x8b\x24\x9e\x95\x06\xe2\x55\x15\x9f\x59\x9e\x04\xe2\xf2\x8a\x7f\x9f\x06\xe2\xf6\x38\x94\x06\x7a\xf3\xc0\xef\x2e\xcf\xc6\xd1\x91\x6e\xab\x1f\x0d\x65\xdb\xaa\x23\xdd\x56\x8f\x0f\x85\x30"
"\x52\x0a\x14\xdb\xea\x8b\x43\x59\x1b\x1d\xe9\x00\xef\x48\x02\xc5\x00\x3f\x94\x06\xe2\x00\x7f\x25\x0f\x74\xa6\xbd\xba\x77\x59\xd6\xab\x18\x18\x8a\x45\xff\x68\x59\xd6\x2b\x00\x00\x4e\x59\xf1\x5b\x60\x4f\xd8\x3a\x3d\x33\x35\x1e\xbf\xc2\xc7\xdb\x57\x76\x37\xdf\x46\x4d\x4b\x96\xdd\x54\xad\xb6\xa3\xcd\xe6\x8f\xe6\x4b\x93\xdd\x73\xf9\xd8\x48\x3b\xe9\xae\xf4\xbb\xe8\xdc\xb5\xc6\x7b\x42\x5f\x63\x08\x6b\x2b\x5f\x57\xcb\x59\x3a\x66\x47\xb9\x30\xb5\xb4\xd8\x74\x2f\xaf\x19\x72\xab\xd5\xde\xda\xfd\x75\xf6\x89\x6e\xba\xde\xfa\x11\x0d\x64\x23\x1a\xbb\x6a\xfb\xcc\x64\x4f\xcb\x81\xaf\x6f\x9d\x65\x5d\x77\xcb\x2c\x6b\x2b\x93\x9d\x72\x96\xce\xd9\x4d\xda\x46\x2d\x6d\xf4\xa5\x8d\x11\xb5\xb9\x6d\xda\xe8\x72\xbc\xdf\x19\xc6\xc6\xba\x92\x5c\xbf\x18\x83\xa3\xa1\xc9\x42\xbd\x22\xca\xeb\xfc\xd5\xbd\x0a\xca\x79\xf6\x4d"
"\xbe\xf1\x6f\xbe\x71\xec\xd8\xa1\xba\xfa\x2a\xf3\xff\xd1\xf6\xe6\xff\x7d\xe5\x71\x3d\x93\x5f\x0c\x60\x5f\xbc\xb2\xde\xcd\x23\x21\x9c\xd9\xe6\x88\x00\x00\x00\x80\x76\x7d\xeb\xcb\xff\xb4\x6e\xfb\x27\x7e\xe7\x9e\xf4\xf6\x8a\xed\xd7\xde\x7a\xc1\xe0\x8f\x2e\xae\x2b\x57\x99\xff\xaf\x6c\x6f\xfe\x1f\x77\x8c\xe5\x87\x82\xb3\xbd\x1d\x87\xe3\xf5\xff\x8b\xf9\xff\x68\x16\xb8\x3b\x36\xf7\x81\x91\x10\x5e\x33\x9b\x9a\x88\x25\xb2\x0b\xea\x5f\x1e\x4b\x8c\x67\x81\xbb\xe3\x0e\x93\x55\xb1\xc4\xe6\x89\xe6\xaa\xfa\x63\xe0\x50\x12\x78\x72\x38\x0f\x1c\x4e\x02\x0f\xc7\x40\xbe\x97\xe2\xb3\x21\xdf\x95\xf3\x91\xe1\x10\x36\xcc\xa6\xae\x68\x2e\xb1\x23\x96\x18\x4d\x02\xef\x8c\x81\x95\x49\x60\x2c\x06\xc6\x93\xc0\xf2\x18\xd8\x98\x04\xfe\x7d\x79\x1e\x98\x48\x02\x5f\x8f\x81\x30\xdd\xbc\xad\xfe\x7c\xb9\xbd\x2b\x00\x00\xc0\xf3"
"\x90\xcf\xb3\x7a\x9a\xef\x86\x74\x9e\x77\xa8\xbb\x55\x86\x8e\x56\x19\x06\x5b\x65\xe8\x6c\x95\xa1\xaf\x55\x86\xba\x51\xc4\xfb\xf7\xc5\x0c\x3d\xc9\xc9\x2b\x1d\xa5\x4c\x3d\x69\xad\x03\x49\x2d\x95\x0c\xf1\x62\xf8\x27\xdc\xaf\x4a\x86\xf0\x8d\xe6\x9c\x69\xc1\x4a\xd3\xf1\xfc\x83\xe2\x7c\x83\x8e\xe6\x0c\xff\x76\xd9\xeb\xbf\x7d\xde\xae\x55\xed\x5f\xff\x7f\xbc\xbd\xf9\xff\x60\xf3\x6d\xd6\xfa\xc3\x71\xfe\x3f\x77\xfd\xbf\x2c\xf0\x48\xec\xde\xc7\xe2\xa9\xe3\x2b\x63\xe0\xbb\x17\x37\x07\xf2\x1d\x03\x0f\xc7\xc9\xee\x6d\x45\x55\x13\x79\x89\x7c\xd2\x7e\x5b\x2c\xb1\x31\x06\x56\x26\x81\x1d\x31\xb0\x31\x09\x6c\xbe\x22\x0f\x1c\x3c\xa3\x39\x90\xcf\xb4\x8b\xc6\x6f\x2e\x1a\x9f\xce\x4b\x94\x02\x00\x00\x00\xf0\x82\x8b\x3b\x08\xe2\x6e\x9a\x38\xff\xff\xd3\xff\xbe\xfb\x73\x07\xfe\xe1\xda\xbf\xae\x2b\x57\x99\xff\x6f\x6c"
"\x6f\xfe\x1f\xdb\x5b\x56\x6e\xec\x96\xa2\xd6\xe5\x21\x7c\xb1\x63\xae\x37\x45\x60\xf5\x50\x16\x88\xfb\x31\x86\xe2\xcf\xe3\x57\x0c\x85\x70\x5a\x69\x07\x47\x51\x62\x6a\x30\x2b\xd1\x9b\x34\x1c\x1e\x1a\xc8\x7e\xa1\xde\x9b\x56\x75\xff\x40\xb6\xc6\x40\xbc\x7f\xe5\x91\x07\x1f\x38\xd0\x48\xdc\x31\x10\xc2\xb9\xa5\xbd\x2f\x45\x1b\xdf\xee\xcb\xda\x18\x48\x03\xe7\xf5\x66\x81\xc1\x34\xb0\xbd\x3b\x0b\xc4\x3d\x3f\x45\xe0\x4b\x9d\x59\x00\x4e\x5a\xb1\x57\x30\xbe\xa0\xf2\x53\x5d\x0a\xa3\xf3\x97\xab\x79\xfd\xbd\x54\xae\x09\x9a\x0e\xaf\xb2\x0f\x74\x9e\x7c\xf3\xfd\xe6\x6a\xb1\xf4\xa5\x0f\xe4\xfb\x54\x0b\x27\xf6\xb4\x55\xaa\x63\x51\x54\xde\x1e\x87\xbd\xdb\x96\xe2\xbb\x6d\xd4\xbb\xad\xfc\x45\x2a\xff\x86\x72\x6c\x2e\xd4\x17\x3a\x27\xa7\xb6\x6e\xb9\x6e\x66\x77\x7c\xa4\xfc\x4b\xd6\x8a\x45\x7a\x9e\xcb\xbf\x52\x6d\x27"
"\xbd\x00\xaf\xc3\x7d\xcf\xbf\xb7\xad\xf5\xa5\x1d\x18\x4f\x3e\x3e\xc6\xe7\x2f\x37\xff\xeb\xb0\x23\x56\xf7\xec\x9d\xef\xb9\xfe\xac\xc9\xb7\xdc\x78\xeb\xf6\x73\x9e\x58\xfb\xbe\x0b\x8e\xb6\xdd\x8d\x1a\xf1\x87\xc2\xef\xfe\xe4\xcb\x46\xcb\x9b\x77\xb1\xf5\x85\xfc\x35\xb7\xe4\x3e\x4f\x26\x7c\x9e\x2c\xc5\x7f\x03\x2b\x3d\x6d\x8d\x19\xec\x53\xbf\xff\xd5\xff\xf8\xe9\xe3\x3f\xab\x8b\x57\xe6\xff\x13\xed\xcd\xff\xbb\x93\xdb\x59\xcf\xc6\x8d\xb9\x6b\x24\x84\xd7\x97\x36\xee\xa3\x71\xf3\xff\xf2\x48\xf6\x39\x58\x0a\x64\x9f\x92\xa7\x57\x03\xd9\x21\xf7\xef\x0d\xd7\x7e\x72\x02\x00\x00\xc0\x42\x2b\x76\x77\x14\xfb\x0b\xa6\xf3\xdb\xec\x84\xf0\x74\x9e\x5c\xcd\x3f\x71\x82\xf9\xe3\xfe\x8a\x8d\xf3\xe6\x6f\xb7\xdf\x5b\x6f\x7e\x68\xff\x0f\xff\xee\x8e\xaf\xd4\xc5\x2b\xf3\xff\xcd\xc7\x9f\xff\xf7\x27\xdd\x74\xfc\xdf\xf1\x7f"
"\x16\x89\xe3\xff\xf3\x3a\xd5\x77\x45\xf7\xa7\x0f\xec\x3b\xa9\x5d\xd1\x95\xea\x58\x14\x8e\xff\xcf\xeb\x54\x7f\xb7\x39\xfe\x3f\x2f\xc7\xff\x1d\xff\x9f\x8f\xe3\xff\x2d\x38\xfe\x3f\xaf\x53\xfd\x69\xab\x7c\x4b\xda\xe1\x4b\x57\x08\xe1\xeb\xef\xbf\xf3\xed\xf7\x6c\xff\xb5\xf3\xea\xe2\x95\xf9\xff\x8e\xf6\xe6\xff\xd6\xff\x9b\x7f\xd1\xbe\x62\xfd\xbf\xcd\x75\xeb\xff\xed\xa8\x5b\xff\x6f\x9f\xf5\xff\x00\x00\x80\x45\x55\xb3\xd0\x5c\x3a\xcf\xab\xac\xde\x57\xc9\x90\xae\xde\x57\xc9\xd0\x72\x81\xc0\x96\x4b\x0c\x5a\xff\xef\x84\xd7\xff\x7b\xeb\x3b\xff\xf7\xfa\x63\xaf\xb8\x64\x67\xa8\x51\x99\xff\xef\x6b\x6f\xfe\x1f\x5f\x0e\xcb\xca\xad\x2f\x95\xf5\xff\x56\x5e\x51\x53\xd5\xed\x31\xb0\xc3\xc2\x80\x00\x00\x00\x9c\x8a\xea\x76\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xe2\x7a\xf7\x2f\x3c\xb9\x7c\xd3\x6f\x5e\x38\x5d\x17\xff\xfe\x19\x37\x7c\x78\xef\xc0\xa5\xf7\x7d\x74\xeb\x81\xa3\x9b\x36\x6d\x38\x12\x42\x96\xb5\x23\x0b\x77\x0c\xae\xe8\xba\xf0\x9b\x03\x97\x3d\xb6\x7f\xe7\xe7\xcf\x9d\xea\xbf\xff\x40\x5f\x5e\xae\x27\xbf\x3d\xbb\x29\x77\xac\xf5\xb9\xe1\x10\x0e\x96\x1e\x19\x8a\x89\xa7\x86\x1b\x77\xe6\x02\x57\xbe\xe3\xde\x3d\xdd\x8d\xc4\xa3\xc3\x21\x9c\x53\x0e\x6c\xdb\xbf\xed\xb4\x46\xe2\xd3\xc3\x21\x9c\x5f\x0e\x3c\xb0\x69\xd5\x19\x8d\xc4\xfe\xb4\xc4\x57\xbe\x73\xe9\x0f\x1a\x89\xf7\xa7\x81\xb7\xad"
"\x7e\xd9\x33\x8d\xc4\x45\x79\xa0\x23\xed\xee\x27\x97\x67\xdd\xed\x48\xbb\x7b\x60\x79\x08\x23\xa5\x40\xd1\xdd\x5f\x5f\xde\x5c\x55\xd1\xc6\x65\x79\xa0\x33\x6d\xe3\x33\x43\x59\x1b\x31\x30\x14\x8b\x7e\x7c\x28\x6b\x23\x06\x66\x62\x89\xe9\xfe\x10\xd6\x74\x87\xd0\x95\x56\xf5\xb5\xbe\xac\xaa\xae\xb4\xaa\xbf\xe8\xcb\xaa\xea\x4a\xab\xfa\xad\xbe\x10\x2e\x0a\x21\x74\xa7\x55\x7d\xa7\x37\xab\xaa\x3b\x1d\xf9\xdf\xf6\x66\x55\xc5\xc0\x99\xaf\xfd\xec\xd3\xe7\x35\x12\x07\x7b\x43\x58\x53\x0e\x3c\xf6\xde\xbb\x36\x34\x12\x1f\x4a\x02\x45\xe3\xef\xea\x0d\xe1\xd5\x8d\x97\x4c\xda\xf8\x7d\x3d\x59\xe3\x3d\x69\xe3\x77\xf4\x84\xf0\xaa\x10\x42\x6f\x5a\xe2\x3f\xbb\xb3\x12\xbd\x69\x89\x27\xba\x43\x38\xbd\x14\x28\x1a\xff\x60\x77\x08\x7b\x02\x2f\x09\xf1\xc3\x67\xb2\xfc\xe0\xae\x3d\x7b\xb7\x6d\x99\x99\x99\xda\xb9\x88\x89\xde"
"\xbc\xad\x81\xb0\x75\x7a\x66\x6a\xec\xaa\xed\x33\x93\x7d\x49\x9f\xea\x74\x94\xd2\xc7\x6e\x3a\x7e\xfc\x78\x8e\x3e\x7d\xe3\x55\x8d\xdb\x7b\x2e\x1f\x1b\x69\x27\xdd\x9d\x97\xeb\x99\xed\xf2\xba\x9e\xa6\xbb\xeb\x17\xaa\xf7\xed\x3a\xd1\xde\xc7\x7e\x0d\x96\x2b\x99\x7b\x3e\x2a\xf5\xc7\xfc\xbd\x61\x59\xe8\xbf\x6e\xd7\xd4\xce\xb1\x1b\xb6\xec\xde\xbd\x73\x6d\xf6\xb7\xdd\xec\xeb\xb2\xbf\x5d\x79\x34\xdb\x56\x6b\x17\x6a\x5b\x75\xb6\x28\x1f\x3d\xdf\x6d\x75\x7e\xb9\x92\x35\xbb\xaf\xd9\xb1\x66\xd7\x9e\xbd\xab\xa7\xaf\xd9\x72\xf5\xd4\xd5\x53\xd7\xbe\x61\x7c\xdd\xf8\xba\xf5\xe3\x1b\xde\x74\xe1\x9a\xc6\xa8\xc6\xb3\xbf\x0b\x31\xd4\xbb\x8e\x1f\x5f\x8c\xa1\xbe\xb2\xbb\x54\xc9\x0b\xf1\x01\x20\x21\x21\xb1\xd4\x12\x9d\x4d\x9f\x6e\xe3\xa7\xfa\x3f\xbd\xca\x17\xfd\xb9\x8e\xf6\x84\xbe\xd9\x0f\xe8\xca\xb4\xa2\x9c\xa5\x63"
"\x76\x94\x0b\x31\xe8\x4b\xaa\xf1\xae\x45\x1a\x74\x65\x4a\x52\x19\xd1\xda\xca\xc4\xa1\x92\x65\x5d\xeb\x2c\xeb\x2b\x93\x89\xb9\x2c\x03\x59\x96\xd9\xef\x75\x95\xc9\x61\xb9\xa6\xce\xd9\x4d\x1a\xef\x77\x86\xb1\xb1\xda\xcd\x32\xda\x7c\xb7\xbc\x79\x7f\x3c\xcf\xe6\x6d\xd7\xe3\xf9\xa6\x6b\x37\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x1f\x3b\x70\x20\x00\x00\x00\x00\x00\xe4\xff\xda\x08\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55"
"\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\xd8\x81\x03\x01\x00\x00\x00\x00\x20\xff\xd7\x46\xa8\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xc2\x0e\x1c\x0b\x00\x00\x00\x00\x08\xf3\xb7\x0e\xa3\x67\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x52\x00\x00\x00\xff\xff\xb7\x46\xca\x9d", 20907);
syz_mount_image(/*fs=*/0x2000000051c0, /*dir=*/0x200000000000, /*flags=MS_STRICTATIME|MS_NOEXEC*/0x1000008, /*opts=*/0x200000000080, /*chdir=*/0xfe, /*size=*/0x51ab, /*img=*/0x200000005280);
// open arguments: [
// file: ptr[in, buffer] {
// buffer: {2e 2f 66 69 6c 65 30 00} (length 0x8)
// }
// flags: open_flags = 0x0 (8 bytes)
// mode: open_mode = 0x0 (8 bytes)
// ]
// returns fd
memcpy((void*)0x2000000025c0, "./file0\000", 8);
res = syscall(__NR_open, /*file=*/0x2000000025c0ul, /*flags=*/0ul, /*mode=*/0ul);
if (res != -1)
r[0] = res;
// ioctl$BTRFS_IOC_GET_SUBVOL_INFO arguments: [
// fd: fd (resource)
// cmd: const = 0x81f8943c (4 bytes)
// arg: ptr[out, btrfs_ioctl_get_subvol_info_args] {
// btrfs_ioctl_get_subvol_info_args {
// treeid: treeid (resource)
// name: buffer: (DirOut)
// parent_id: treeid (resource)
// dirid: dirid (resource)
// generation: transid (resource)
// flags: int64 = 0x0 (8 bytes)
// uuid: buffer: (DirOut)
// parent_uuid: buffer: (DirOut)
// received_uuid: buffer: (DirOut)
// ctransid: transid (resource)
// otransid: transid (resource)
// stransid: transid (resource)
// rtransid: transid (resource)
// ctime: btrfs_ioctl_timespec {
// sec: int64 = 0x0 (8 bytes)
// msec: int32 = 0x0 (4 bytes)
// pad = 0x0 (4 bytes)
// }
// otime: btrfs_ioctl_timespec {
// sec: int64 = 0x0 (8 bytes)
// msec: int32 = 0x0 (4 bytes)
// pad = 0x0 (4 bytes)
// }
// stime: btrfs_ioctl_timespec {
// sec: int64 = 0x0 (8 bytes)
// msec: int32 = 0x0 (4 bytes)
// pad = 0x0 (4 bytes)
// }
// rtime: btrfs_ioctl_timespec {
// sec: int64 = 0x0 (8 bytes)
// msec: int32 = 0x0 (4 bytes)
// pad = 0x0 (4 bytes)
// }
// reserved: buffer: (DirOut)
// }
// }
// ]
res = syscall(__NR_ioctl, /*fd=*/r[0], /*cmd=*/0x81f8943c, /*arg=*/0x200000001840ul);
if (res != -1)
r[1] = *(uint64_t*)0x200000001840;
// ioctl$BTRFS_IOC_INO_LOOKUP arguments: [
// fd: fd (resource)
// cmd: const = 0xc4009420 (4 bytes)
// arg: ptr[in, btrfs_ioctl_ino_lookup_args] {
// btrfs_ioctl_ino_lookup_args {
// treeid: treeid (resource)
// objectid: int64 = 0x0 (8 bytes)
// name: buffer: {00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0
// 0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0
// 0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0
// 0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0
// 0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0
// 0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
// 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00} (length 0xff0)
// }
// }
// ]
*(uint64_t*)0x2000000003c0 = r[1];
*(uint64_t*)0x2000000003c8 = 0;
memset((void*)0x2000000003d0, 0, 4080);
syscall(__NR_ioctl, /*fd=*/r[0], /*cmd=*/0xc4009420, /*arg=*/0x2000000003c0ul);
return 0;
}
If you have any questions, please let me know.
Best regards,
Yue
^ permalink raw reply
* [PATCH] btrfs: only account delalloc bytes for regular file inodes in btrfs_getattr()
From: Dave Chen @ 2026-06-26 6:45 UTC (permalink / raw)
To: linux-btrfs, dsterba; +Cc: cccheng, Dave Chen
btrfs_getattr() unconditionally reads BTRFS_I(inode)->new_delalloc_bytes
and adds it (sector-aligned) to stat->blocks for every inode type.
However, new_delalloc_bytes lives in a union with last_dir_index_offset:
union {
u64 new_delalloc_bytes; /* files only */
u64 last_dir_index_offset; /* directories only */
};
For a directory inode this memory holds last_dir_index_offset, which is
set during directory logging (e.g. flush_dir_items_batch()) to the
offset of the last logged BTRFS_DIR_INDEX_KEY. That offset grows with
the number of entries ever created in the directory (dir indexes are
monotonic and never reused), so it can be arbitrarily large.
As a result, after a directory has been logged (e.g. via an fsync that
triggers directory logging), btrfs_getattr() reports inflated st_blocks
for that directory. The inflation is purely in-core and disappears
after the inode is evicted and reloaded (btrfs_alloc_inode() zeroes the
union), e.g. after a remount.
Reproducer (on a btrfs filesystem):
D=/mnt/btrfs/d
mkdir -p $D
for i in $(seq 1 20000); do touch $D/f$i; done
sync # commit, push dir index high
touch $D/trigger # dirty the dir in a new transaction
xfs_io -c fsync $D # log the directory -> sets last_dir_index_offset
stat -c '%b' $D # st_blocks is now inflated (e.g. 40)
# umount + mount -> st_blocks drops back to the correct value
The evict path already knows this union is type-dependent and guards the
corresponding WARN_ON with !S_ISDIR() in btrfs_destroy_inode(); only
btrfs_getattr() was missing the equivalent check.
Only read new_delalloc_bytes for regular files, which are the only
inodes that ever set it.
Signed-off-by: Dave Chen <davechen@synology.com>
---
fs/btrfs/inode.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 272598f6ae77..b446c3014b24 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -8068,7 +8068,8 @@ static int btrfs_getattr(struct mnt_idmap *idmap,
stat->result_mask |= STATX_SUBVOL;
spin_lock(&BTRFS_I(inode)->lock);
- delalloc_bytes = BTRFS_I(inode)->new_delalloc_bytes;
+ delalloc_bytes = S_ISREG(inode->i_mode) ?
+ BTRFS_I(inode)->new_delalloc_bytes : 0;
inode_bytes = inode_get_bytes(inode);
spin_unlock(&BTRFS_I(inode)->lock);
stat->blocks = (ALIGN(inode_bytes, blocksize) +
--
2.43.0
Disclaimer: The contents of this e-mail message and any attachments are confidential and are intended solely for addressee. The information may also be legally privileged. This transmission is sent in trust, for the sole purpose of delivery to the intended recipient. If you have received this transmission in error, any use, reproduction or dissemination of this transmission is strictly prohibited. If you are not the intended recipient, please immediately notify the sender by reply e-mail or phone and delete this message and its attachments, if any.
^ permalink raw reply related
* Re: [PATCH 1/2] fs: btrfs: implement opendir(), readdir() and closedir()
From: Qu Wenruo @ 2026-06-26 6:38 UTC (permalink / raw)
To: Alexey Charkov, linux-btrfs, u-boot
Cc: Marek Behún, Tom Rini, Simon Glass, Timo tp Preißl,
Peng Fan, Patrice Chotard, Yao Zi
In-Reply-To: <20260625-btrfs-readdir-v1-1-dd781a2b3965@flipper.net>
在 2026/6/26 02:54, Alexey Charkov 写道:
> Add support for generic directory iteration with opendir(), readdir() and
> closedir() in the btrfs filesystem driver, following the ext4fs
> implementation for opendir()/closedir() and the btrfs_iter_dir() function
> for readdir().
>
> Signed-off-by: Alexey Charkov <alchark@flipper.net>
> ---
> fs/btrfs/btrfs.c | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++
> fs/btrfs/ctree.h | 2 ++
> fs/btrfs/dir-item.c | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++
> fs/fs.c | 4 ++-
> include/btrfs.h | 5 +++
> 5 files changed, 193 insertions(+), 1 deletion(-)
>
> diff --git a/fs/btrfs/btrfs.c b/fs/btrfs/btrfs.c
> index f3087f690fa4..c647c8dedf4e 100644
> --- a/fs/btrfs/btrfs.c
> +++ b/fs/btrfs/btrfs.c
> @@ -9,6 +9,7 @@
> #include <malloc.h>
> #include <u-boot/uuid.h>
> #include <linux/time.h>
> +#include <fs.h>
> #include "btrfs.h"
> #include "crypto/hash.h"
> #include "disk-io.h"
> @@ -159,6 +160,97 @@ int btrfs_ls(const char *path)
> return 0;
> }
>
> +struct btrfs_dir_stream {
> + struct fs_dir_stream parent;
> + struct fs_dirent dirent;
> + char *dirname;
> + u64 offset;
This doesn't look correct to me, for an opened dir, we should have at
least the root id or pointer, and an inode number.
Not just an @dirname and re-do the path resolution again and again.
In fact, I do not even think we should save @dirname here.
> +};
> +
> +int btrfs_opendir(const char *dirname, struct fs_dir_stream **dirsp)
> +{
> + struct btrfs_fs_info *fs_info = current_fs_info;
> + struct btrfs_dir_stream *dirs;
> + struct btrfs_root *root;
> + u64 ino;
> + u8 type;
> + int ret;
> +
> + *dirsp = NULL;
> + ASSERT(fs_info);
> +
> + ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
> + dirname, &root, &ino, &type, 40);
You just discard the most important @root and @ino.
So what is the point here?
> + if (ret < 0)
> + return ret;
> + if (type != BTRFS_FT_DIR)
> + return -ENOTDIR;
> +
> + dirs = calloc(1, sizeof(*dirs));
> + if (!dirs)
> + return -ENOMEM;
> + dirs->dirname = strdup(dirname);
> + if (!dirs->dirname) {
> + free(dirs);
> + return -ENOMEM;
> + }
> +
> + *dirsp = (struct fs_dir_stream *)dirs;
> + return 0;
> +}
> +
> +int btrfs_readdir(struct fs_dir_stream *fs_dirs, struct fs_dirent **dentp)
> +{
> + struct btrfs_dir_stream *dirs = (struct btrfs_dir_stream *)fs_dirs;
> + struct btrfs_fs_info *fs_info = current_fs_info;
> + struct fs_dirent *dent = &dirs->dirent;
> + struct btrfs_root *root;
> + u64 ino;
> + u8 type;
> + int ret;
> +
> + *dentp = NULL;
> + ASSERT(fs_info);
> +
> + ret = btrfs_lookup_path(fs_info->fs_root, BTRFS_FIRST_FREE_OBJECTID,
> + dirs->dirname, &root, &ino, &type, 40);
No, doing the same path resolution again and again is not sane.
> + if (ret < 0)
> + return ret;
> + if (type != BTRFS_FT_DIR)
> + return -ENOTDIR;
> +
> + memset(dent, 0, sizeof(*dent));
> + ret = btrfs_next_dir_entry(root, ino, &dirs->offset, dent->name,
> + sizeof(dent->name), &type);
> + if (ret < 0)
> + return ret;
> + if (ret > 0)
> + return -ENOENT;
> +
> + switch (type) {
> + case BTRFS_FT_DIR:
> + dent->type = FS_DT_DIR;
> + break;
> + case BTRFS_FT_SYMLINK:
> + dent->type = FS_DT_LNK;
> + break;
> + default:
> + dent->type = FS_DT_REG;
> + break;
So it looks like u-boot only supports the above 3 types, and unlike
linux kernel the values doesn't match the btrfs internal ones.
In that case, I'd still prefer a proper convertor function.
[...]
> +
> + *offset = key.offset + 1;
> + type = btrfs_dir_type(path.nodes[0], di);
> +
> + /* XATTRs share the key space but are not directory entries. */
> + if (type == BTRFS_FT_XATTR) {
This doesn't looks correct again.
XATTR has their own keys, they should not show up among DIR_INDEX keys.
Thanks,
Qu
^ permalink raw reply
* Re: [PATCH v2 5/8] btrfs-progs: print encryptin type field of file extents
From: Qu Wenruo @ 2026-06-25 23:50 UTC (permalink / raw)
To: Daniel Vacek, David Sterba
Cc: linux-fscrypt, linux-btrfs, linux-kernel, Sweet Tea Dorminy
In-Reply-To: <20260624165144.556908-6-neelx@suse.com>
在 2026/6/25 02:21, Daniel Vacek 写道:
> From: Sweet Tea Dorminy <sweettea-kernel@dorminy.me>
>
> Encrypted file extents now have the 'encryption' field set to an
> encryption type. Let's print it.
>
> Signed-off-by: Sweet Tea Dorminy <sweettea-kernel@dorminy.me>
> Signed-off-by: Daniel Vacek <neelx@suse.com>
> ---
> check/main.c | 1 -
> kernel-shared/print-tree.c | 2 ++
> 2 files changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/check/main.c b/check/main.c
> index dedb4db4..a32247b3 100644
> --- a/check/main.c
> +++ b/check/main.c
> @@ -1778,7 +1778,6 @@ static int process_file_extent(struct btrfs_root *root,
> rec->errors |= I_ERR_BAD_FILE_EXTENT;
> if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
> (btrfs_file_extent_compression(eb, fi) ||
> - btrfs_file_extent_encryption(eb, fi) ||
May I ask why preallocated file extent would have encryption value set?
My common sense says that encryption policy should only be set for
regular file extents.
Thanks,
Qu
> btrfs_file_extent_other_encoding(eb, fi)))
> rec->errors |= I_ERR_BAD_FILE_EXTENT;
> if (compression && rec->nodatasum)
> diff --git a/kernel-shared/print-tree.c b/kernel-shared/print-tree.c
> index 0afa3696..159f0825 100644
> --- a/kernel-shared/print-tree.c
> +++ b/kernel-shared/print-tree.c
> @@ -471,6 +471,8 @@ static void print_file_extent_item(struct extent_buffer *eb,
> printf("\t\textent compression %hhu (%s)\n",
> btrfs_file_extent_compression(eb, fi),
> compress_str);
> + printf("\t\textent encryption %hhu\n",
> + btrfs_file_extent_encryption(eb, fi));
> }
>
> /* Caller should ensure sizeof(*ret) >= 16("DATA|TREE_BLOCK") */
^ permalink raw reply
* Re: [PATCH v2 1/8] btrfs-progs: check: fix max inline extent size
From: Qu Wenruo @ 2026-06-25 23:40 UTC (permalink / raw)
To: Daniel Vacek, David Sterba
Cc: linux-fscrypt, linux-btrfs, linux-kernel, Josef Bacik
In-Reply-To: <20260624165144.556908-2-neelx@suse.com>
在 2026/6/25 02:21, Daniel Vacek 写道:
> From: Josef Bacik <josef@toxicpanda.com>
>
> Fscrypt will use our entire inline extent range for symlinks, which
> uncovered a bug in btrfs check where we set the maximum inline extent
> size to
>
> min(sectorsize - 1, BTRFS_MAX_INLINE_DATA_SIZE)
>
> which isn't correct, we have always allowed sectorsize sized inline
> extents, so fix check to use the correct maximum inline extent size.
No, we only allow sector sized inline extent when it is compressed.
The de-compressed size can be sector sized, but the compressed size
still can not reach sector size.
So this doesn't seems correct to me.
>
> Signed-off-by: Josef Bacik <josef@toxicpanda.com>
> Signed-off-by: Daniel Vacek <neelx@suse.com>
> ---
> check/main.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/check/main.c b/check/main.c
> index 5e29e2c5..dedb4db4 100644
> --- a/check/main.c
> +++ b/check/main.c
> @@ -1720,7 +1720,7 @@ static int process_file_extent(struct btrfs_root *root,
> u64 disk_bytenr = 0;
> u64 extent_offset = 0;
> u64 mask = gfs_info->sectorsize - 1;
> - u32 max_inline_size = min_t(u32, mask,
> + u32 max_inline_size = min_t(u32, gfs_info->sectorsize,
> BTRFS_MAX_INLINE_DATA_SIZE(gfs_info));
> u8 compression;
> int extent_type;
^ permalink raw reply
* Re: [PATCH 5/6] btrfs: defrag: use simple list_del() in defrag_collect_targets()
From: Anand Suveer Jain @ 2026-06-25 23:10 UTC (permalink / raw)
To: fdmanana, linux-btrfs
In-Reply-To: <ef417c92283d2b96cdc44c7bba0ac2d47c4f324b.1782321584.git.fdmanana@suse.com>
On 26/6/26 03:20, fdmanana@kernel.org wrote:
> From: Filipe Manana <fdmanana@suse.com>
>
> When freeing the entries from the list there is no need to initialize
> the list member in an entry, since we are immediately freeing it. So use
> simple list_del() instead of list_del_init().
>
> Signed-off-by: Filipe Manana <fdmanana@suse.com>
> ---
> fs/btrfs/defrag.c | 2 +-
> 1 file changed, 1 insertion(+), 1 deletion(-)
>
> diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
> index e454b59d6477..7b3f779775a0 100644
> --- a/fs/btrfs/defrag.c
> +++ b/fs/btrfs/defrag.c
> @@ -1093,7 +1093,7 @@ static int defrag_collect_targets(struct btrfs_inode *inode,
> struct defrag_target_range *tmp;
>
> list_for_each_entry_safe(entry, tmp, target_list, list) {
> - list_del_init(&entry->list);
> + list_del(&entry->list);
> kfree(entry);
> }
> }
Nice cleanup.
Reviewed-by: Anand Jain <asj@kernel.org>
^ permalink raw reply
* Re: [PATCH 6/6] btrfs: defrag: remove pointless list_del_init() in defrag_one_cluster()
From: Anand Suveer Jain @ 2026-06-25 23:03 UTC (permalink / raw)
To: fdmanana, linux-btrfs
In-Reply-To: <d8b39c1c786efa00d5de3d5ca999e23fcbc6c277.1782321584.git.fdmanana@suse.com>
On 26/6/26 03:20, fdmanana@kernel.org wrote:
> From: Filipe Manana <fdmanana@suse.com>
>
> There's no need to call list_del_init() against each entry when freeing
> the list, as the list is local and we are freeing the entry.
>
> Signed-off-by: Filipe Manana <fdmanana@suse.com>
> ---
> fs/btrfs/defrag.c | 4 +---
> 1 file changed, 1 insertion(+), 3 deletions(-)
>
> diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
> index 7b3f779775a0..6ec5dd760d42 100644
> --- a/fs/btrfs/defrag.c
> +++ b/fs/btrfs/defrag.c
> @@ -1319,10 +1319,8 @@ static int defrag_one_cluster(struct btrfs_inode *inode,
> inode->root->fs_info->sectorsize_bits;
> }
> out:
> - list_for_each_entry_safe(entry, tmp, &target_list, list) {
> - list_del_init(&entry->list);
> + list_for_each_entry_safe(entry, tmp, &target_list, list)
> kfree(entry);
> - }
> if (ret >= 0)
> *last_scanned_ret = max(*last_scanned_ret, start + len);
> return ret;
LGTM
Reviewed-by: Anand Jain <asj@kernel.org>
^ permalink raw reply
* Re: [PATCH 3/6] btrfs: defrag: use a single list for each loop in defrag_one_range()
From: Anand Suveer Jain @ 2026-06-25 23:02 UTC (permalink / raw)
To: fdmanana, linux-btrfs
In-Reply-To: <20e1226097db10e92c2059cb5ce51205348362a7.1782321584.git.fdmanana@suse.com>
On 26/6/26 03:20, fdmanana@kernel.org wrote:
> From: Filipe Manana <fdmanana@suse.com>
>
> There's no need to have one list for each loop to defrag each subrange and
> then another one to free each subrange (struct defrag_target_range).
> We can do it in a single loop, freeing each subrange after defragging,
> plus no need to delete each subrange from the list since we immediately
> free it.
>
> Signed-off-by: Filipe Manana <fdmanana@suse.com>
> ---
> fs/btrfs/defrag.c | 6 +-----
> 1 file changed, 1 insertion(+), 5 deletions(-)
>
> diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
> index 0697b285e05f..ad1d04d8f165 100644
> --- a/fs/btrfs/defrag.c
> +++ b/fs/btrfs/defrag.c
> @@ -1234,16 +1234,12 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len,
> if (ret < 0)
> goto unlock_extent;
>
> - list_for_each_entry(entry, &target_list, list) {
> + list_for_each_entry_safe(entry, tmp, &target_list, list) {
> defrag_one_locked_target(inode, entry, folios, nr_pages, &cached_state);
> if (entry->start > last_defrag_end)
> btrfs_delalloc_release_space(inode, data_reserved, last_defrag_end,
> entry->start - last_defrag_end, true);
> last_defrag_end = entry->start + entry->len;
> - }
> -
> - list_for_each_entry_safe(entry, tmp, &target_list, list) {
> - list_del_init(&entry->list);
> kfree(entry);
> }
> unlock_extent:
LGTM.
Reviewed-by: Anand Jain <asj@kernel.org>
^ permalink raw reply
* Re: [PATCH 0/6] btrfs: defrag/autodefrag fixes and cleanups
From: Qu Wenruo @ 2026-06-25 23:00 UTC (permalink / raw)
To: fdmanana, linux-btrfs
In-Reply-To: <cover.1782321584.git.fdmanana@suse.com>
在 2026/6/26 04:50, fdmanana@kernel.org 写道:
> From: Filipe Manana <fdmanana@suse.com>
>
> There are a couple bugs related to defrag and autodefrag, one of them
> reported by syzbot and the other can often be triggered by fsstress with
> the mount option "-o autodefrag" (or fstests on random tests that use
> fsstress with multiple processes). Details in the change logs.
Reviewed-by: Qu Wenruo <wqu@suse.com>
Thanks,
Qu
>
> Filipe Manana (6):
> btrfs: defrag: fix deadlock between defrag and delalloc space reservation
> btrfs: fix pending delayed iputs when using autodefrag
> btrfs: defrag: use a single list for each loop in defrag_one_range()
> btrfs: defrag: use auto kfree in defrag_one_range() for folios array
> btrfs: defrag: use simple list_del() in defrag_collect_targets()
> btrfs: defrag: remove pointless list_del_init() in defrag_one_cluster()
>
> fs/btrfs/defrag.c | 61 ++++++++++++++++++++++++++--------------------
> fs/btrfs/disk-io.c | 15 ++++++++++++
> 2 files changed, 49 insertions(+), 27 deletions(-)
>
^ permalink raw reply
page: next (older)
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox