From 45122b59c01a5870b7584c2b0edeab257600dd9f Mon Sep 17 00:00:00 2001 From: longpanda Date: Sat, 11 Jun 2022 22:47:38 +0800 Subject: [PATCH] Add support for EasyOS 4.0 --- .../MOD_SRC/grub-2.04/grub-core/fs/squash4.c | 1043 +++++++++++++++++ .../grub-2.04/grub-core/fs/zfs/zfs_lz4.c | 285 +++++ GRUB2/MOD_SRC/grub-2.04/install.sh | 8 +- INSTALL/grub/arm64-efi/gfxterm_menu.mod | Bin 2252 -> 0 bytes INSTALL/grub/arm64-efi/moddep.lst | Bin 1644 -> 1648 bytes INSTALL/grub/arm64-efi/zfs.mod | Bin 19636 -> 19684 bytes INSTALL/grub/i386-efi/moddep.lst | 2 +- INSTALL/grub/i386-efi/smbios.mod | Bin 5452 -> 0 bytes INSTALL/grub/i386-efi/zfs.mod | Bin 41268 -> 41344 bytes INSTALL/grub/i386-pc/moddep.lst | 2 +- INSTALL/grub/i386-pc/zfs.mod | Bin 40196 -> 40288 bytes INSTALL/grub/mips64el-efi/gfxterm_menu.mod | Bin 2692 -> 0 bytes INSTALL/grub/mips64el-efi/moddep.lst | Bin 1640 -> 1640 bytes INSTALL/grub/mips64el-efi/zfs.mod | Bin 23004 -> 22916 bytes INSTALL/grub/x86_64-efi/moddep.lst | 2 +- INSTALL/grub/x86_64-efi/smbios.mod | Bin 8704 -> 0 bytes INSTALL/grub/x86_64-efi/zfs.mod | Bin 58496 -> 58656 bytes 17 files changed, 1335 insertions(+), 7 deletions(-) create mode 100644 GRUB2/MOD_SRC/grub-2.04/grub-core/fs/squash4.c create mode 100644 GRUB2/MOD_SRC/grub-2.04/grub-core/fs/zfs/zfs_lz4.c delete mode 100644 INSTALL/grub/arm64-efi/gfxterm_menu.mod delete mode 100644 INSTALL/grub/i386-efi/smbios.mod delete mode 100644 INSTALL/grub/mips64el-efi/gfxterm_menu.mod delete mode 100644 INSTALL/grub/x86_64-efi/smbios.mod diff --git a/GRUB2/MOD_SRC/grub-2.04/grub-core/fs/squash4.c b/GRUB2/MOD_SRC/grub-2.04/grub-core/fs/squash4.c new file mode 100644 index 00000000..afeea668 --- /dev/null +++ b/GRUB2/MOD_SRC/grub-2.04/grub-core/fs/squash4.c @@ -0,0 +1,1043 @@ +/* squash4.c - SquashFS */ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 2010 Free Software Foundation, Inc. + * + * GRUB is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "xz.h" +#include "xz_stream.h" + +GRUB_MOD_LICENSE ("GPLv3+"); + +/* + object format Pointed by + superblock RAW Fixed offset (0) + data RAW ? Fixed offset (60) + inode table Chunk superblock + dir table Chunk superblock + fragment table Chunk unk1 + unk1 RAW, Chunk superblock + unk2 RAW superblock + UID/GID Chunk exttblptr + exttblptr RAW superblock + + UID/GID table is the array ot uint32_t + unk1 contains pointer to fragment table followed by some chunk. + unk2 containts one uint64_t +*/ + +struct grub_squash_super +{ + grub_uint32_t magic; +#define SQUASH_MAGIC 0x73717368 + grub_uint32_t dummy1; + grub_uint32_t creation_time; + grub_uint32_t block_size; + grub_uint32_t dummy2; + grub_uint16_t compression; + grub_uint16_t dummy3; + grub_uint64_t dummy4; + grub_uint16_t root_ino_offset; + grub_uint32_t root_ino_chunk; + grub_uint16_t dummy5; + grub_uint64_t total_size; + grub_uint64_t exttbloffset; + grub_uint64_t dummy6; + grub_uint64_t inodeoffset; + grub_uint64_t diroffset; + grub_uint64_t unk1offset; + grub_uint64_t unk2offset; +} GRUB_PACKED; + +/* Chunk-based */ +struct grub_squash_inode +{ + /* Same values as direlem types. */ + grub_uint16_t type; + grub_uint16_t dummy[3]; + grub_uint32_t mtime; + grub_uint32_t dummy2; + union + { + struct { + grub_uint32_t chunk; + grub_uint32_t fragment; + grub_uint32_t offset; + grub_uint32_t size; + grub_uint32_t block_size[0]; + } GRUB_PACKED file; + struct { + grub_uint64_t chunk; + grub_uint64_t size; + grub_uint32_t dummy1[3]; + grub_uint32_t fragment; + grub_uint32_t offset; + grub_uint32_t dummy3; + grub_uint32_t block_size[0]; + } GRUB_PACKED long_file; + struct { + grub_uint32_t chunk; + grub_uint32_t dummy; + grub_uint16_t size; + grub_uint16_t offset; + } GRUB_PACKED dir; + struct { + grub_uint32_t dummy1; + grub_uint32_t size; + grub_uint32_t chunk; + grub_uint32_t dummy2; + grub_uint16_t dummy3; + grub_uint16_t offset; + } GRUB_PACKED long_dir; + struct { + grub_uint32_t dummy; + grub_uint32_t namelen; + char name[0]; + } GRUB_PACKED symlink; + } GRUB_PACKED; +} GRUB_PACKED; + +struct grub_squash_cache_inode +{ + struct grub_squash_inode ino; + grub_disk_addr_t ino_chunk; + grub_uint16_t ino_offset; + grub_uint32_t *block_sizes; + grub_disk_addr_t *cumulated_block_sizes; +}; + +/* Chunk-based. */ +struct grub_squash_dirent_header +{ + /* Actually the value is the number of elements - 1. */ + grub_uint32_t nelems; + grub_uint32_t ino_chunk; + grub_uint32_t dummy; +} GRUB_PACKED; + +struct grub_squash_dirent +{ + grub_uint16_t ino_offset; + grub_uint16_t dummy; + grub_uint16_t type; + /* Actually the value is the length of name - 1. */ + grub_uint16_t namelen; + char name[0]; +} GRUB_PACKED; + +enum + { + SQUASH_TYPE_DIR = 1, + SQUASH_TYPE_REGULAR = 2, + SQUASH_TYPE_SYMLINK = 3, + SQUASH_TYPE_LONG_DIR = 8, + SQUASH_TYPE_LONG_REGULAR = 9, + }; + + +struct grub_squash_frag_desc +{ + grub_uint64_t offset; + grub_uint32_t size; + grub_uint32_t dummy; +} GRUB_PACKED; + +enum + { + SQUASH_CHUNK_FLAGS = 0x8000, + SQUASH_CHUNK_UNCOMPRESSED = 0x8000 + }; + +enum + { + SQUASH_BLOCK_FLAGS = 0x1000000, + SQUASH_BLOCK_UNCOMPRESSED = 0x1000000 + }; + +enum + { + COMPRESSION_ZLIB = 1, + COMPRESSION_LZO = 3, + COMPRESSION_XZ = 4, + COMPRESSION_LZ4 = 5, + }; + + +#define SQUASH_CHUNK_SIZE 0x2000 +#define XZBUFSIZ 0x2000 + +struct grub_squash_data +{ + grub_disk_t disk; + struct grub_squash_super sb; + struct grub_squash_cache_inode ino; + grub_uint64_t fragments; + int log2_blksz; + grub_size_t blksz; + grub_ssize_t (*decompress) (char *inbuf, grub_size_t insize, grub_off_t off, + char *outbuf, grub_size_t outsize, + struct grub_squash_data *data); + struct xz_dec *xzdec; + char *xzbuf; +}; + +struct grub_fshelp_node +{ + struct grub_squash_data *data; + struct grub_squash_inode ino; + grub_size_t stsize; + struct + { + grub_disk_addr_t ino_chunk; + grub_uint16_t ino_offset; + } stack[1]; +}; + +static grub_err_t +read_chunk (struct grub_squash_data *data, void *buf, grub_size_t len, + grub_uint64_t chunk_start, grub_off_t offset) +{ + while (len > 0) + { + grub_uint64_t csize; + grub_uint16_t d; + grub_err_t err; + while (1) + { + err = grub_disk_read (data->disk, + chunk_start >> GRUB_DISK_SECTOR_BITS, + chunk_start & (GRUB_DISK_SECTOR_SIZE - 1), + sizeof (d), &d); + if (err) + return err; + if (offset < SQUASH_CHUNK_SIZE) + break; + offset -= SQUASH_CHUNK_SIZE; + chunk_start += 2 + (grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS); + } + + csize = SQUASH_CHUNK_SIZE - offset; + if (csize > len) + csize = len; + + if (grub_le_to_cpu16 (d) & SQUASH_CHUNK_UNCOMPRESSED) + { + grub_disk_addr_t a = chunk_start + 2 + offset; + err = grub_disk_read (data->disk, (a >> GRUB_DISK_SECTOR_BITS), + a & (GRUB_DISK_SECTOR_SIZE - 1), + csize, buf); + if (err) + return err; + } + else + { + char *tmp; + grub_size_t bsize = grub_le_to_cpu16 (d) & ~SQUASH_CHUNK_FLAGS; + grub_disk_addr_t a = chunk_start + 2; + tmp = grub_malloc (bsize); + if (!tmp) + return grub_errno; + /* FIXME: buffer uncompressed data. */ + err = grub_disk_read (data->disk, (a >> GRUB_DISK_SECTOR_BITS), + a & (GRUB_DISK_SECTOR_SIZE - 1), + bsize, tmp); + if (err) + { + grub_free (tmp); + return err; + } + + if (data->decompress (tmp, bsize, offset, + buf, csize, data) < 0) + { + grub_free (tmp); + return grub_errno; + } + grub_free (tmp); + } + len -= csize; + offset += csize; + buf = (char *) buf + csize; + } + return GRUB_ERR_NONE; +} + +static grub_ssize_t +zlib_decompress (char *inbuf, grub_size_t insize, grub_off_t off, + char *outbuf, grub_size_t outsize, + struct grub_squash_data *data __attribute__ ((unused))) +{ + return grub_zlib_decompress (inbuf, insize, off, outbuf, outsize); +} + +static grub_ssize_t +lzo_decompress (char *inbuf, grub_size_t insize, grub_off_t off, + char *outbuf, grub_size_t len, struct grub_squash_data *data) +{ + lzo_uint usize = data->blksz; + grub_uint8_t *udata; + + if (usize < 8192) + usize = 8192; + + udata = grub_malloc (usize); + if (!udata) + return -1; + + if (lzo1x_decompress_safe ((grub_uint8_t *) inbuf, + insize, udata, &usize, NULL) != LZO_E_OK) + { + grub_error (GRUB_ERR_BAD_FS, "incorrect compressed chunk"); + grub_free (udata); + return -1; + } + grub_memcpy (outbuf, udata + off, len); + grub_free (udata); + return len; +} + +static grub_ssize_t +xz_decompress (char *inbuf, grub_size_t insize, grub_off_t off, + char *outbuf, grub_size_t len, struct grub_squash_data *data) +{ + grub_size_t ret = 0; + grub_off_t pos = 0; + struct xz_buf buf; + + xz_dec_reset (data->xzdec); + buf.in = (grub_uint8_t *) inbuf; + buf.in_pos = 0; + buf.in_size = insize; + buf.out = (grub_uint8_t *) data->xzbuf; + buf.out_pos = 0; + buf.out_size = XZBUFSIZ; + + while (len) + { + enum xz_ret xzret; + + buf.out_pos = 0; + + xzret = xz_dec_run (data->xzdec, &buf); + + if (xzret != XZ_OK && xzret != XZ_STREAM_END) + { + grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "invalid xz chunk"); + return -1; + } + if (pos + buf.out_pos >= off) + { + grub_ssize_t outoff = pos - off; + grub_size_t l; + if (outoff >= 0) + { + l = buf.out_pos; + if (l > len) + l = len; + grub_memcpy (outbuf + outoff, buf.out, l); + } + else + { + outoff = -outoff; + l = buf.out_pos - outoff; + if (l > len) + l = len; + grub_memcpy (outbuf, buf.out + outoff, l); + } + ret += l; + len -= l; + } + pos += buf.out_pos; + if (xzret == XZ_STREAM_END) + break; + } + return ret; +} + +int LZ4_uncompress_unknownOutputSize(const char *source, char *dest, int isize, int maxOutputSize); +static grub_ssize_t lz4_decompress_wrap(char *inbuf, grub_size_t insize, grub_off_t off, + char *outbuf, grub_size_t len, struct grub_squash_data *data) +{ + char *udata = NULL; + int usize = data->blksz; + + if (usize < 8192) + usize = 8192; + + udata = grub_malloc (usize); + if (!udata) + return -1; + + LZ4_uncompress_unknownOutputSize(inbuf, udata, insize, usize); + grub_memcpy (outbuf, udata + off, len); + grub_free (udata); + return len; +} + +static struct grub_squash_data * +squash_mount (grub_disk_t disk) +{ + struct grub_squash_super sb; + grub_err_t err; + struct grub_squash_data *data; + grub_uint64_t frag; + + err = grub_disk_read (disk, 0, 0, sizeof (sb), &sb); + if (grub_errno == GRUB_ERR_OUT_OF_RANGE) + grub_error (GRUB_ERR_BAD_FS, "not a squash4"); + if (err) + return NULL; + if (sb.magic != grub_cpu_to_le32_compile_time (SQUASH_MAGIC) + || sb.block_size == 0 + || ((sb.block_size - 1) & sb.block_size)) + { + grub_error (GRUB_ERR_BAD_FS, "not squash4"); + return NULL; + } + + err = grub_disk_read (disk, + grub_le_to_cpu64 (sb.unk1offset) + >> GRUB_DISK_SECTOR_BITS, + grub_le_to_cpu64 (sb.unk1offset) + & (GRUB_DISK_SECTOR_SIZE - 1), sizeof (frag), &frag); + if (grub_errno == GRUB_ERR_OUT_OF_RANGE) + grub_error (GRUB_ERR_BAD_FS, "not a squash4"); + if (err) + return NULL; + + data = grub_zalloc (sizeof (*data)); + if (!data) + return NULL; + data->sb = sb; + data->disk = disk; + data->fragments = grub_le_to_cpu64 (frag); + + switch (sb.compression) + { + case grub_cpu_to_le16_compile_time (COMPRESSION_ZLIB): + data->decompress = zlib_decompress; + break; + case grub_cpu_to_le16_compile_time (COMPRESSION_LZO): + data->decompress = lzo_decompress; + break; + case grub_cpu_to_le16_compile_time (COMPRESSION_LZ4): + data->decompress = lz4_decompress_wrap; + break; + case grub_cpu_to_le16_compile_time (COMPRESSION_XZ): + data->decompress = xz_decompress; + data->xzbuf = grub_malloc (XZBUFSIZ); + if (!data->xzbuf) + { + grub_free (data); + return NULL; + } + data->xzdec = xz_dec_init (1 << 16); + if (!data->xzdec) + { + grub_free (data->xzbuf); + grub_free (data); + return NULL; + } + break; + default: + grub_free (data); + grub_error (GRUB_ERR_BAD_FS, "unsupported compression %d", + grub_le_to_cpu16 (sb.compression)); + return NULL; + } + + data->blksz = grub_le_to_cpu32 (data->sb.block_size); + for (data->log2_blksz = 0; + (1U << data->log2_blksz) < data->blksz; + data->log2_blksz++); + + return data; +} + +static char * +grub_squash_read_symlink (grub_fshelp_node_t node) +{ + char *ret; + grub_err_t err; + ret = grub_malloc (grub_le_to_cpu32 (node->ino.symlink.namelen) + 1); + + err = read_chunk (node->data, ret, + grub_le_to_cpu32 (node->ino.symlink.namelen), + grub_le_to_cpu64 (node->data->sb.inodeoffset) + + node->stack[node->stsize - 1].ino_chunk, + node->stack[node->stsize - 1].ino_offset + + (node->ino.symlink.name - (char *) &node->ino)); + if (err) + { + grub_free (ret); + return NULL; + } + ret[grub_le_to_cpu32 (node->ino.symlink.namelen)] = 0; + return ret; +} + +static int +grub_squash_iterate_dir (grub_fshelp_node_t dir, + grub_fshelp_iterate_dir_hook_t hook, void *hook_data) +{ + grub_uint32_t off; + grub_uint32_t endoff; + grub_uint64_t chunk; + unsigned i; + + /* FIXME: why - 3 ? */ + switch (dir->ino.type) + { + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_DIR): + off = grub_le_to_cpu16 (dir->ino.dir.offset); + endoff = grub_le_to_cpu16 (dir->ino.dir.size) + off - 3; + chunk = grub_le_to_cpu32 (dir->ino.dir.chunk); + break; + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_DIR): + off = grub_le_to_cpu16 (dir->ino.long_dir.offset); + endoff = grub_le_to_cpu16 (dir->ino.long_dir.size) + off - 3; + chunk = grub_le_to_cpu32 (dir->ino.long_dir.chunk); + break; + default: + grub_error (GRUB_ERR_BAD_FS, "unexpected ino type 0x%x", + grub_le_to_cpu16 (dir->ino.type)); + return 0; + } + + { + grub_fshelp_node_t node; + node = grub_malloc (sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); + if (!node) + return 0; + grub_memcpy (node, dir, + sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); + if (hook (".", GRUB_FSHELP_DIR, node, hook_data)) + return 1; + + if (dir->stsize != 1) + { + grub_err_t err; + + node = grub_malloc (sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); + if (!node) + return 0; + + grub_memcpy (node, dir, + sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); + + node->stsize--; + err = read_chunk (dir->data, &node->ino, sizeof (node->ino), + grub_le_to_cpu64 (dir->data->sb.inodeoffset) + + node->stack[node->stsize - 1].ino_chunk, + node->stack[node->stsize - 1].ino_offset); + if (err) + return 0; + + if (hook ("..", GRUB_FSHELP_DIR, node, hook_data)) + return 1; + } + } + + while (off < endoff) + { + struct grub_squash_dirent_header dh; + grub_err_t err; + + err = read_chunk (dir->data, &dh, sizeof (dh), + grub_le_to_cpu64 (dir->data->sb.diroffset) + + chunk, off); + if (err) + return 0; + off += sizeof (dh); + for (i = 0; i < (unsigned) grub_le_to_cpu32 (dh.nelems) + 1; i++) + { + char *buf; + int r; + struct grub_fshelp_node *node; + enum grub_fshelp_filetype filetype = GRUB_FSHELP_REG; + struct grub_squash_dirent di; + struct grub_squash_inode ino; + + err = read_chunk (dir->data, &di, sizeof (di), + grub_le_to_cpu64 (dir->data->sb.diroffset) + + chunk, off); + if (err) + return 0; + off += sizeof (di); + + err = read_chunk (dir->data, &ino, sizeof (ino), + grub_le_to_cpu64 (dir->data->sb.inodeoffset) + + grub_le_to_cpu32 (dh.ino_chunk), + grub_cpu_to_le16 (di.ino_offset)); + if (err) + return 0; + + buf = grub_malloc (grub_le_to_cpu16 (di.namelen) + 2); + if (!buf) + return 0; + err = read_chunk (dir->data, buf, + grub_le_to_cpu16 (di.namelen) + 1, + grub_le_to_cpu64 (dir->data->sb.diroffset) + + chunk, off); + if (err) + return 0; + + off += grub_le_to_cpu16 (di.namelen) + 1; + buf[grub_le_to_cpu16 (di.namelen) + 1] = 0; + if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_DIR) + filetype = GRUB_FSHELP_DIR; + if (grub_le_to_cpu16 (di.type) == SQUASH_TYPE_SYMLINK) + filetype = GRUB_FSHELP_SYMLINK; + + node = grub_malloc (sizeof (*node) + + (dir->stsize + 1) * sizeof (dir->stack[0])); + if (! node) + return 0; + + grub_memcpy (node, dir, + sizeof (*node) + dir->stsize * sizeof (dir->stack[0])); + + node->ino = ino; + node->stack[node->stsize].ino_chunk = grub_le_to_cpu32 (dh.ino_chunk); + node->stack[node->stsize].ino_offset = grub_le_to_cpu16 (di.ino_offset); + node->stsize++; + r = hook (buf, filetype, node, hook_data); + + grub_free (buf); + if (r) + return r; + } + } + return 0; +} + +static grub_err_t +make_root_node (struct grub_squash_data *data, struct grub_fshelp_node *root) +{ + grub_memset (root, 0, sizeof (*root)); + root->data = data; + root->stsize = 1; + root->stack[0].ino_chunk = grub_le_to_cpu32 (data->sb.root_ino_chunk); + root->stack[0].ino_offset = grub_cpu_to_le16 (data->sb.root_ino_offset); + return read_chunk (data, &root->ino, sizeof (root->ino), + grub_le_to_cpu64 (data->sb.inodeoffset) + + root->stack[0].ino_chunk, + root->stack[0].ino_offset); +} + +static void +squash_unmount (struct grub_squash_data *data) +{ + if (data->xzdec) + xz_dec_end (data->xzdec); + grub_free (data->xzbuf); + grub_free (data->ino.cumulated_block_sizes); + grub_free (data->ino.block_sizes); + grub_free (data); +} + + +/* Context for grub_squash_dir. */ +struct grub_squash_dir_ctx +{ + grub_fs_dir_hook_t hook; + void *hook_data; +}; + +/* Helper for grub_squash_dir. */ +static int +grub_squash_dir_iter (const char *filename, enum grub_fshelp_filetype filetype, + grub_fshelp_node_t node, void *data) +{ + struct grub_squash_dir_ctx *ctx = data; + struct grub_dirhook_info info; + + grub_memset (&info, 0, sizeof (info)); + info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR); + info.mtimeset = 1; + info.mtime = grub_le_to_cpu32 (node->ino.mtime); + grub_free (node); + return ctx->hook (filename, &info, ctx->hook_data); +} + +static grub_err_t +grub_squash_dir (grub_device_t device, const char *path, + grub_fs_dir_hook_t hook, void *hook_data) +{ + struct grub_squash_dir_ctx ctx = { hook, hook_data }; + struct grub_squash_data *data = 0; + struct grub_fshelp_node *fdiro = 0; + struct grub_fshelp_node root; + grub_err_t err; + + data = squash_mount (device->disk); + if (! data) + return grub_errno; + + err = make_root_node (data, &root); + if (err) + return err; + + grub_fshelp_find_file (path, &root, &fdiro, grub_squash_iterate_dir, + grub_squash_read_symlink, GRUB_FSHELP_DIR); + if (!grub_errno) + grub_squash_iterate_dir (fdiro, grub_squash_dir_iter, &ctx); + + squash_unmount (data); + + return grub_errno; +} + +static grub_err_t +grub_squash_open (struct grub_file *file, const char *name) +{ + struct grub_squash_data *data = 0; + struct grub_fshelp_node *fdiro = 0; + struct grub_fshelp_node root; + grub_err_t err; + + data = squash_mount (file->device->disk); + if (! data) + return grub_errno; + + err = make_root_node (data, &root); + if (err) + return err; + + grub_fshelp_find_file (name, &root, &fdiro, grub_squash_iterate_dir, + grub_squash_read_symlink, GRUB_FSHELP_REG); + if (grub_errno) + { + squash_unmount (data); + return grub_errno; + } + + file->data = data; + data->ino.ino = fdiro->ino; + data->ino.block_sizes = NULL; + data->ino.cumulated_block_sizes = NULL; + data->ino.ino_chunk = fdiro->stack[fdiro->stsize - 1].ino_chunk; + data->ino.ino_offset = fdiro->stack[fdiro->stsize - 1].ino_offset; + + switch (fdiro->ino.type) + { + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR): + file->size = grub_le_to_cpu64 (fdiro->ino.long_file.size); + break; + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR): + file->size = grub_le_to_cpu32 (fdiro->ino.file.size); + break; + default: + { + grub_uint16_t type = grub_le_to_cpu16 (fdiro->ino.type); + grub_free (fdiro); + squash_unmount (data); + return grub_error (GRUB_ERR_BAD_FS, "unexpected ino type 0x%x", type); + } + } + + grub_free (fdiro); + + return GRUB_ERR_NONE; +} + +static grub_ssize_t +direct_read (struct grub_squash_data *data, + struct grub_squash_cache_inode *ino, + grub_off_t off, char *buf, grub_size_t len) +{ + grub_err_t err; + grub_off_t cumulated_uncompressed_size = 0; + grub_uint64_t a = 0; + grub_size_t i; + grub_size_t origlen = len; + + switch (ino->ino.type) + { + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR): + a = grub_le_to_cpu64 (ino->ino.long_file.chunk); + break; + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR): + a = grub_le_to_cpu32 (ino->ino.file.chunk); + break; + } + + if (!ino->block_sizes) + { + grub_off_t total_size = 0; + grub_size_t total_blocks; + grub_size_t block_offset = 0; + switch (ino->ino.type) + { + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR): + total_size = grub_le_to_cpu64 (ino->ino.long_file.size); + block_offset = ((char *) &ino->ino.long_file.block_size + - (char *) &ino->ino); + break; + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR): + total_size = grub_le_to_cpu32 (ino->ino.file.size); + block_offset = ((char *) &ino->ino.file.block_size + - (char *) &ino->ino); + break; + } + total_blocks = ((total_size + data->blksz - 1) >> data->log2_blksz); + ino->block_sizes = grub_malloc (total_blocks + * sizeof (ino->block_sizes[0])); + ino->cumulated_block_sizes = grub_malloc (total_blocks + * sizeof (ino->cumulated_block_sizes[0])); + if (!ino->block_sizes || !ino->cumulated_block_sizes) + { + grub_free (ino->block_sizes); + grub_free (ino->cumulated_block_sizes); + ino->block_sizes = 0; + ino->cumulated_block_sizes = 0; + return -1; + } + err = read_chunk (data, ino->block_sizes, + total_blocks * sizeof (ino->block_sizes[0]), + grub_le_to_cpu64 (data->sb.inodeoffset) + + ino->ino_chunk, + ino->ino_offset + block_offset); + if (err) + { + grub_free (ino->block_sizes); + grub_free (ino->cumulated_block_sizes); + ino->block_sizes = 0; + ino->cumulated_block_sizes = 0; + return -1; + } + ino->cumulated_block_sizes[0] = 0; + for (i = 1; i < total_blocks; i++) + ino->cumulated_block_sizes[i] = ino->cumulated_block_sizes[i - 1] + + (grub_le_to_cpu32 (ino->block_sizes[i - 1]) & ~SQUASH_BLOCK_FLAGS); + } + + if (a == 0) + a = sizeof (struct grub_squash_super); + i = off >> data->log2_blksz; + cumulated_uncompressed_size = data->blksz * (grub_disk_addr_t) i; + while (cumulated_uncompressed_size < off + len) + { + grub_size_t boff, curread; + boff = off - cumulated_uncompressed_size; + curread = data->blksz - boff; + if (curread > len) + curread = len; + if (!ino->block_sizes[i]) + { + /* Sparse block */ + grub_memset (buf, '\0', curread); + } + else if (!(ino->block_sizes[i] + & grub_cpu_to_le32_compile_time (SQUASH_BLOCK_UNCOMPRESSED))) + { + char *block; + grub_size_t csize; + csize = grub_le_to_cpu32 (ino->block_sizes[i]) & ~SQUASH_BLOCK_FLAGS; + block = grub_malloc (csize); + if (!block) + return -1; + err = grub_disk_read (data->disk, + (ino->cumulated_block_sizes[i] + a) + >> GRUB_DISK_SECTOR_BITS, + (ino->cumulated_block_sizes[i] + a) + & (GRUB_DISK_SECTOR_SIZE - 1), + csize, block); + if (err) + { + grub_free (block); + return -1; + } + if (data->decompress (block, csize, boff, buf, curread, data) + != (grub_ssize_t) curread) + { + grub_free (block); + if (!grub_errno) + grub_error (GRUB_ERR_BAD_FS, "incorrect compressed chunk"); + return -1; + } + grub_free (block); + } + else + err = grub_disk_read (data->disk, + (ino->cumulated_block_sizes[i] + a + boff) + >> GRUB_DISK_SECTOR_BITS, + (ino->cumulated_block_sizes[i] + a + boff) + & (GRUB_DISK_SECTOR_SIZE - 1), + curread, buf); + if (err) + return -1; + off += curread; + len -= curread; + buf += curread; + cumulated_uncompressed_size += grub_le_to_cpu32 (data->sb.block_size); + i++; + } + return origlen; +} + + +static grub_ssize_t +grub_squash_read (grub_file_t file, char *buf, grub_size_t len) +{ + struct grub_squash_data *data = file->data; + struct grub_squash_cache_inode *ino = &data->ino; + grub_off_t off = file->offset; + grub_err_t err; + grub_uint64_t a, b; + grub_uint32_t fragment = 0; + int compressed = 0; + struct grub_squash_frag_desc frag; + grub_off_t direct_len; + grub_uint64_t mask = grub_le_to_cpu32 (data->sb.block_size) - 1; + grub_size_t orig_len = len; + + switch (ino->ino.type) + { + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR): + fragment = grub_le_to_cpu32 (ino->ino.long_file.fragment); + break; + case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR): + fragment = grub_le_to_cpu32 (ino->ino.file.fragment); + break; + } + + /* Squash may pack file tail as fragment. So read initial part directly and + get tail from fragments */ + direct_len = fragment == 0xffffffff ? file->size : file->size & ~mask; + if (off < direct_len) + { + grub_size_t read_len = direct_len - off; + grub_ssize_t res; + + if (read_len > len) + read_len = len; + res = direct_read (data, ino, off, buf, read_len); + if ((grub_size_t) res != read_len) + return -1; /* FIXME: is short read possible here? */ + len -= read_len; + if (!len) + return read_len; + buf += read_len; + off = 0; + } + else + off -= direct_len; + + err = read_chunk (data, &frag, sizeof (frag), + data->fragments, sizeof (frag) * fragment); + if (err) + return -1; + a = grub_le_to_cpu64 (frag.offset); + compressed = !(frag.size & grub_cpu_to_le32_compile_time (SQUASH_BLOCK_UNCOMPRESSED)); + if (ino->ino.type == grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR)) + b = grub_le_to_cpu32 (ino->ino.long_file.offset) + off; + else + b = grub_le_to_cpu32 (ino->ino.file.offset) + off; + + /* FIXME: cache uncompressed chunks. */ + if (compressed) + { + char *block; + block = grub_malloc (grub_le_to_cpu32 (frag.size)); + if (!block) + return -1; + err = grub_disk_read (data->disk, + a >> GRUB_DISK_SECTOR_BITS, + a & (GRUB_DISK_SECTOR_SIZE - 1), + grub_le_to_cpu32 (frag.size), block); + if (err) + { + grub_free (block); + return -1; + } + if (data->decompress (block, grub_le_to_cpu32 (frag.size), + b, buf, len, data) + != (grub_ssize_t) len) + { + grub_free (block); + if (!grub_errno) + grub_error (GRUB_ERR_BAD_FS, "incorrect compressed chunk"); + return -1; + } + grub_free (block); + } + else + { + err = grub_disk_read (data->disk, (a + b) >> GRUB_DISK_SECTOR_BITS, + (a + b) & (GRUB_DISK_SECTOR_SIZE - 1), len, buf); + if (err) + return -1; + } + return orig_len; +} + +static grub_err_t +grub_squash_close (grub_file_t file) +{ + squash_unmount (file->data); + return GRUB_ERR_NONE; +} + +static grub_err_t +grub_squash_mtime (grub_device_t dev, grub_int32_t *tm) +{ + struct grub_squash_data *data = 0; + + data = squash_mount (dev->disk); + if (! data) + return grub_errno; + *tm = grub_le_to_cpu32 (data->sb.creation_time); + squash_unmount (data); + return GRUB_ERR_NONE; +} + +static struct grub_fs grub_squash_fs = + { + .name = "squash4", + .fs_dir = grub_squash_dir, + .fs_open = grub_squash_open, + .fs_read = grub_squash_read, + .fs_close = grub_squash_close, + .fs_mtime = grub_squash_mtime, +#ifdef GRUB_UTIL + .reserved_first_sector = 0, + .blocklist_install = 0, +#endif + .next = 0 + }; + +GRUB_MOD_INIT(squash4) +{ + grub_fs_register (&grub_squash_fs); +} + +GRUB_MOD_FINI(squash4) +{ + grub_fs_unregister (&grub_squash_fs); +} + diff --git a/GRUB2/MOD_SRC/grub-2.04/grub-core/fs/zfs/zfs_lz4.c b/GRUB2/MOD_SRC/grub-2.04/grub-core/fs/zfs/zfs_lz4.c new file mode 100644 index 00000000..0309905a --- /dev/null +++ b/GRUB2/MOD_SRC/grub-2.04/grub-core/fs/zfs/zfs_lz4.c @@ -0,0 +1,285 @@ +/* + * LZ4 - Fast LZ compression algorithm + * Header File + * Copyright (C) 2011-2013, Yann Collet. + * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * You can contact the author at : + * - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html + * - LZ4 source repository : http://code.google.com/p/lz4/ + */ + +#include +#include +#include +#include + +int LZ4_uncompress_unknownOutputSize(const char *source, char *dest, + int isize, int maxOutputSize); + +/* + * CPU Feature Detection + */ + +/* 32 or 64 bits ? */ +#if (GRUB_CPU_SIZEOF_VOID_P == 8) +#define LZ4_ARCH64 1 +#else +#define LZ4_ARCH64 0 +#endif + +/* + * Compiler Options + */ + + +#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) + +#if (GCC_VERSION >= 302) || (defined (__INTEL_COMPILER) && __INTEL_COMPILER >= 800) || defined(__clang__) +#define expect(expr, value) (__builtin_expect((expr), (value))) +#else +#define expect(expr, value) (expr) +#endif + +#define likely(expr) expect((expr) != 0, 1) +#define unlikely(expr) expect((expr) != 0, 0) + +/* Basic types */ +#define BYTE grub_uint8_t +#define U16 grub_uint16_t +#define U32 grub_uint32_t +#define S32 grub_int32_t +#define U64 grub_uint64_t + +typedef struct _U16_S { + U16 v; +} GRUB_PACKED U16_S; +typedef struct _U32_S { + U32 v; +} GRUB_PACKED U32_S; +typedef struct _U64_S { + U64 v; +} GRUB_PACKED U64_S; + +#define A64(x) (((U64_S *)(x))->v) +#define A32(x) (((U32_S *)(x))->v) +#define A16(x) (((U16_S *)(x))->v) + +/* + * Constants + */ +#define MINMATCH 4 + +#define COPYLENGTH 8 +#define LASTLITERALS 5 + +#define ML_BITS 4 +#define ML_MASK ((1U< s_len) + return grub_error(GRUB_ERR_BAD_FS,"lz4 decompression failed."); + + /* + * Returns 0 on success (decompression function returned non-negative) + * and appropriate error on failure (decompression function returned negative). + */ + return (LZ4_uncompress_unknownOutputSize((char*)s_start + 4, d_start, bufsiz, + d_len) < 0)?grub_error(GRUB_ERR_BAD_FS,"lz4 decompression failed."):0; +} + +int +LZ4_uncompress_unknownOutputSize(const char *source, + char *dest, int isize, int maxOutputSize) +{ + /* Local Variables */ + const BYTE * ip = (const BYTE *) source; + const BYTE *const iend = ip + isize; + const BYTE * ref; + + BYTE * op = (BYTE *) dest; + BYTE *const oend = op + maxOutputSize; + BYTE *cpy; + + grub_size_t dec[] = { 0, 3, 2, 3, 0, 0, 0, 0 }; + + /* Main Loop */ + while (ip < iend) { + BYTE token; + int length; + + /* get runlength */ + token = *ip++; + if ((length = (token >> ML_BITS)) == RUN_MASK) { + int s = 255; + while ((ip < iend) && (s == 255)) { + s = *ip++; + length += s; + } + } + /* copy literals */ + if ((grub_addr_t) length > ~(grub_addr_t)op) + goto _output_error; + cpy = op + length; + if ((cpy > oend - COPYLENGTH) || + (ip + length > iend - COPYLENGTH)) { + if (cpy > oend) + /* + * Error: request to write beyond destination + * buffer. + */ + goto _output_error; + if (ip + length > iend) + /* + * Error : request to read beyond source + * buffer. + */ + goto _output_error; + grub_memcpy(op, ip, length); + op += length; + ip += length; + if (ip < iend) + /* Error : LZ4 format violation */ + goto _output_error; + /* Necessarily EOF, due to parsing restrictions. */ + break; + } + LZ4_WILDCOPY(ip, op, cpy); + ip -= (op - cpy); + op = cpy; + + /* get offset */ + LZ4_READ_LITTLEENDIAN_16(ref, cpy, ip); + ip += 2; + if (ref < (BYTE * const) dest) + /* + * Error: offset creates reference outside of + * destination buffer. + */ + goto _output_error; + + /* get matchlength */ + if ((length = (token & ML_MASK)) == ML_MASK) { + while (ip < iend) { + int s = *ip++; + length += s; + if (s == 255) + continue; + break; + } + } + /* copy repeated sequence */ + if unlikely(op - ref < STEPSIZE) { +#if LZ4_ARCH64 + grub_size_t dec2table[] = { 0, 0, 0, -1, 0, 1, 2, 3 }; + grub_size_t dec2 = dec2table[op - ref]; +#else + const int dec2 = 0; +#endif + *op++ = *ref++; + *op++ = *ref++; + *op++ = *ref++; + *op++ = *ref++; + ref -= dec[op - ref]; + A32(op) = A32(ref); + op += STEPSIZE - 4; + ref -= dec2; + } else { + LZ4_COPYSTEP(ref, op); + } + cpy = op + length - (STEPSIZE - 4); + if (cpy > oend - COPYLENGTH) { + if (cpy > oend) + /* + * Error: request to write outside of + * destination buffer. + */ + goto _output_error; + LZ4_SECURECOPY(ref, op, (oend - COPYLENGTH)); + while (op < cpy) + *op++ = *ref++; + op = cpy; + if (op == oend) + /* + * Check EOF (should never happen, since last + * 5 bytes are supposed to be literals). + */ + break; + continue; + } + LZ4_SECURECOPY(ref, op, cpy); + op = cpy; /* correction */ + } + + /* end of decoding */ + return (int)(((char *)op) - dest); + + /* write overflow error detected */ + _output_error: + return (int)(-(((char *)ip) - source)); +} diff --git a/GRUB2/MOD_SRC/grub-2.04/install.sh b/GRUB2/MOD_SRC/grub-2.04/install.sh index c95ca4c7..2f1f83f7 100644 --- a/GRUB2/MOD_SRC/grub-2.04/install.sh +++ b/GRUB2/MOD_SRC/grub-2.04/install.sh @@ -12,14 +12,14 @@ make install PATH=$VT_DIR/GRUB2/INSTALL/bin/:$VT_DIR/GRUB2/INSTALL/sbin/:$PATH net_modules_legacy="net tftp http" -all_modules_legacy="file setkey date drivemap blocklist regexp newc vga_text ntldr search at_keyboard usb_keyboard gcry_md5 hashsum gzio xzio lzopio lspci pci ext2 xfs ventoy chain read halt iso9660 linux16 test true sleep reboot echo videotest videoinfo videotest_checksum video_colors video_cirrus video_bochs vga vbe video_fb font video gettext extcmd terminal linux minicmd help configfile tr trig boot biosdisk disk ls tar squash4 password_pbkdf2 all_video png jpeg part_gpt part_msdos fat exfat ntfs loopback gzio normal udf gfxmenu gfxterm gfxterm_background gfxterm_menu smbios" +all_modules_legacy="file setkey date drivemap blocklist regexp newc vga_text ntldr search at_keyboard usb_keyboard gcry_md5 hashsum gzio xzio lzopio lspci pci ext2 xfs ventoy chain read halt iso9660 linux16 test true sleep reboot echo videotest videoinfo videotest_checksum video_colors video_cirrus video_bochs vga vbe video_fb font video gettext extcmd terminal linux minicmd help configfile tr trig boot biosdisk disk ls tar squash4 password_pbkdf2 all_video png jpeg part_gpt part_msdos fat exfat ntfs loopback gzio normal udf gfxmenu gfxterm gfxterm_background gfxterm_menu smbios zfs" net_modules_uefi="efinet net tftp http" -all_modules_uefi="file setkey blocklist ventoy test true regexp newc search at_keyboard usb_keyboard gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux relocator jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop efi_uga video_bochs video_cirrus video video_fb gfxterm_background gfxterm_menu mouse fwload smbios" +all_modules_uefi="file setkey blocklist ventoy test true regexp newc search at_keyboard usb_keyboard gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux relocator jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop efi_uga video_bochs video_cirrus video video_fb gfxterm_background gfxterm_menu mouse fwload smbios zfs" -all_modules_arm64_uefi="file setkey blocklist ventoy test true regexp newc search gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop video video_fb gfxterm_background gfxterm_menu" +all_modules_arm64_uefi="file setkey blocklist ventoy test true regexp newc search gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop video video_fb gfxterm_background gfxterm_menu zfs" -all_modules_mips64el_uefi="file setkey blocklist ventoy test true regexp newc search gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop video video_fb gfxterm_background gfxterm_menu" +all_modules_mips64el_uefi="file setkey blocklist ventoy test true regexp newc search gcry_md5 hashsum gzio xzio lzopio ext2 xfs read halt sleep serial terminfo png password_pbkdf2 gcry_sha512 pbkdf2 part_gpt part_msdos ls tar squash4 loopback part_apple minicmd diskfilter linux jpeg iso9660 udf hfsplus halt acpi mmap gfxmenu video_colors trig bitmap_scale gfxterm bitmap font fat exfat ntfs fshelp efifwsetup reboot echo configfile normal terminal gettext chain priority_queue bufio datetime cat extcmd crypto gzio boot all_video efi_gop video video_fb gfxterm_background gfxterm_menu zfs" if [ "$1" = "uefi" ]; then diff --git a/INSTALL/grub/arm64-efi/gfxterm_menu.mod b/INSTALL/grub/arm64-efi/gfxterm_menu.mod deleted file mode 100644 index 36084369c1aed3342499515fcf749f1170da53e1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2252 zcmV;-2s8KnH+ooF000E$*0e?f03iVu0001VFXf})CGQA}T>w9kMTBTQiKg0|rp>7s z0;NSvd&4F%(i>Ik)A2KsGsqMLIQf|VzS?|4>p`VvkfAN);qyW=c!syqF&G&-_qgSc zE2RVna5oi=3t|bAN1#ixOd9OFl;jpo^SiD2GsBRie*QzIW{2waV@N1X5bEh_T4Hma z#41>xkE^ptR9&_+ErPE1EDFfiktBPzhT;rb+RgfvLaE`xk^@m(#syN-9 zQd^>SmWFqdvBliKbT9p~%-RC1d}EZWLC<)ZfH+7nq`(@v|H-5lq29r$mOgh3P4!^2RK zI9<)>M}AZ=cT!wSL4sOW!5sjzCz_PLS%&&)6v;{DwBN8EpzZemIRdr}k|{)Uu19+m2spdQ1I% zxj_&&M;v>({eRfgq4Eo~fCnCKSYhi*HYPaPy25Hr8*XbXzA4pRLWftiH^3Au z!3|gw^9Y7EgM$Nk<*fx;c*B?||Mj_8VS}{L`Z@}a2r_)=C z#qp)F8xJVNc2~b$+X|TUY!z$3sJXbCp z*uvxjy%(Q(btY<+VPno<*y}SlP2N{`Wv@`;BIx6YUV(0}Di}S8`^*MT1 zp&~c!S{x2T(ZP)(fuw9LrH*dn*jIW= zWUD<8H=+VSKzYuMohnk@tVwl%YAe?kluoCo>})SrReXl|9;a9DB?GToYE`E5klyT4 zwNr7*vLs+vg$?BkSdTKa<+Vhl&cZ~QyX5mI1+64UXF_dGiFo!1r7gm~NR83g(rhEv zd^YrAwVdm@Z`!X+G*>fAyCt_i#?pI=DLL2cmCOi_>7xTT-&V1$SzcMrWmiB^CZONW z!K()N%i13tMcp44KV#m;Soc!S0NENnO6jDSQ#w`J`8MV&;D>X`Zk6O`b+gs)DxcZxI4%N|f)25cCP{|_njMvznZD{rQ5xKy^;QdkyvYSpI4Lh8 zP$o6Fskm_H$bSs;WIfH{!UyMtnBAPXU;JjgI6L*xR`9W+_%6NoI@;j_04221`HbAXN0 zWbu3U368GOsCKg*GixD!Ez>YYD@gEn&iIHn9ZDT#OvjNT7A-%6a0%1u-)9k|u+WW{ ze_KzvZGh_%{1E#D>YWV5E4a(SxX1iyAk}En%*}w_h6fVne#Fy>_pxBze6>7SC&EmQ zL*cb~lzV=!?LkZwDR80G>;xH`MCl5;0mOD2x0h72*+`Dr8z^cE>{;wjQ8Xm2;;=fj zGBON3732Dy7wFyg(fW&z$zE5>s+AgG-$l-g_sb7hH~mWv zqO$S4&!el$z)$R&?7|MmjxbrYmQ>iN8Rk@G8Oyj8IZey#VVlql+0a^v=FyX_yP*v0 z_YzAst;ThqbFKUSk*%);rkC^Ri>~h`!O-|Km^uJktAjrg4U~@g92MfTd;o^{WZm!F^8f&Ei74jB>w4t? a0jCl0O8@{rKV@LC#Ao{g000001X)@n=TheY diff --git a/INSTALL/grub/arm64-efi/moddep.lst b/INSTALL/grub/arm64-efi/moddep.lst index c92f6837368aa9a2410c0677992f19635bb4ebe5..13604371f333f0de83267143275776cf5a4e89cd 100644 GIT binary patch delta 353 zcmV-n0iOQs4Dbw)8UtYlF0ma01%Efgt|P_TKs_V(4VD1T$;UyUKyFWIaTxj6Z_SC^ zwCGxVUF$6aw`6`r_Jl8YGC!i&I}8`V%2+rg6zp^bDOOvLXX!aWfKbJ!Q@spVdL6Y2 zuyiAaCy=Aa!3GQ?Ou1#6zVTdzCY?FUFTJ%LA95W(Jo>G!ySHCMZ-(PM=YJf_H%xlE zEm+`C3ZoppUbNe6X@9JBdtitu!Nw>J5^4&}y!|dpC_?`zna)|i^Z>A>8cgQkdurW> z!O51_qgtO(^Uo~%j;~HXK$2kSSMtIf|)kgsDrC3Qtn5ncn z8D1DygTH&`l|)V)*Z=?k3G6IV_b;|%00GJj;vfJ3UCZtAvBYQl0ssI200dcD&3T~X delta 349 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 literal 19636 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 diff --git a/INSTALL/grub/i386-efi/moddep.lst b/INSTALL/grub/i386-efi/moddep.lst index 5ce89d84..1e8687a5 100644 --- a/INSTALL/grub/i386-efi/moddep.lst +++ b/INSTALL/grub/i386-efi/moddep.lst @@ -201,7 +201,7 @@ cbmemc: cbtable normal terminfo hfsplus: fshelp gcry_cast5: crypto extcmd: -squash4: fshelp lzopio xzio gzio +squash4: fshelp lzopio zfs xzio gzio part_plan: minix_be: gcry_whirlpool: crypto diff --git a/INSTALL/grub/i386-efi/smbios.mod b/INSTALL/grub/i386-efi/smbios.mod deleted file mode 100644 index 5d1555f68f647b53a574167c77d8b0f353f2e834..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5452 zcmb7Ie{56N6~1-?B#^}6SD=uNS4Kp-VlM&G5q@kD!IUE0nq&!RAq`Ia96zxA!h826 zq=ezgfG{o<>nc^9TCE7F+aH@cO;f1ai3Mm0EtR0H1PGYQv=oAjw2qZ-Fu?oHd-oaF z1KQp4?svX(zkBYvKi++DcX-#VbT}N$E)G_}?lHzHCtEEGO{ivNtdzARKW}ZWy>NhB zOV&5&p3VQ9(zK~OTn?V{uW(#%8oiy#WD@U{?;0}7Oj)X7MQTM&d3sD^`b6!}KKb8m z&$S9^acMZ0e?5&)!^8%mu2S zB+FE`HYbm{4j1ekGK%9%+9Lgn(SEd>ZN9Q9zDCr$pmVuzR7|Nf+NcSgB zWfI$p7@v`9EEz3@C^?KAgyfGTX{{YfY%4dzOc_nz&1ClZGe5g^*VbGh&HUO=j(e|U z5(A%3XM9q8`;`o*A?VdgSL|uIvOIBXtnpX!8l=Ph+_FjTTb2*1Y{%7Av(sz1^anY4{30~J=t0R7^z_oi9NXmC9RPQ_AyD^k{ z#)+51w7muXlH^pn5JJOaXn!&B zYEz1Bn3eKRw^Xh}t128H3Sp|DGIWr%cps=k_zR>NE_LGlVd0km;h&(g#@mSY#Cwv+ zW=f`x9A*>Nfq z1(ts{uuu4(fNlF*V4E)}+B$Oldtq-8`j>P3L$Gz>Kbhmd3EL2UXW_m0^I+Sh2KEL# zSSKdu_%{o`t-Bw7j84?=*QjWoJAf3T8AuoBemvCv86LWFt7_(N&3)W9d5B?4Y-ClD zh{381ruNEOD5CaBiY^6ZE_ZP`$aq+mntjWkezsYXV_fT(dQ>IGC7o+V7dJFn>I>*n zOyyEYHDZ>W_xH$B)X=%qDdQjSljWFHBL!kXX?|Uu88HkJd64MIy1E6HEE?cl;cTb? z#?}?C^vV)akh^7#sj*1Eq{d{)?e3Pjr1o${jZyxF9_YjX0WJk3u0&-hWl0T5G@V?n zPGU{oVkjCW8&h*8W)3a~%`V*-G$z99<_v@<6w)y+VyFh!m7r{@vx{RYLy8;;V)23x z5`_XvgvL>k2-g%D^P@DgQ6w`0tJ24_CR-r3M2Uq|4T)mb9@ggO60Lo^)aDLL))JE) zmCUKMOV#eq0e9bkJ2>FpGT_z++{WWr6LSV_ZZ}P&H=rrBaP3Twb}A~Sig?UtZbLR7 zUFuVK*v!#d1rm9fHQ+ajEt!XzIk9Frf^&vV%0`#^!dPk@tDprUR^}dt&2@M7bD2Gb zBx!Mo%+--^#4vZ6e7RfVVb;XVo_(qow0icbW>0gnAlP5l%vHRy6wX>X zC6*K0-h3$*h+;o&$|6e4*veKa5iV<{T$6Pp!lj6^Sw@9MDX7Z22lvs6sduiw{K~x5 zuX;Xz_muRvmuuaxr}wx&o%qWNwtw!Aj`-F*-ROO$*}Lp1|C-(fPvCys%DbXL`>-Lv zL(12GCE#O*|8h$K8(c+xS*nGkg%nL~Qt|N|@tXJ^u zf*&M~dHhcJ&kDRH@H^;B{TB;t5*Q>zzfA&lfo`lF>3=A26(M4^2(Ad;FZc^U%IkGP z{1AAPa0+AR2_Io>1W56&631_)8-&vs8;7xJ{0cly{QruXf>#TyCI3Xmo)o-M;2MF= z0yhAiWsE6;8v=I-+)ar5Q-sK4zra@rvF5J{egNpi;d+xeoHMHSw!}no z5jW2xaE{>B0&4^=71$t~TPYXOJa75s!z%K;e7Kp3Sj3*J|sTNoxaFM_Uf%IOHj(PO{C~hYp*DMU% zmL^9$95)d2kfo`?01v=6k>s_WTIR8wxFC&)+!0Z_e&cE=K#- zWfqi_p8bVe2>X5PwOy!<3VmnjtJQ#q%9l86ahxX{b+bQ?v-!J%zFX7>O=h``SbjSQ zJfx#ig(o*2#~G)!qj=aZQ&$A6#Y5fa(_L@#oZI74x-q){{o#-5CZ@J diff --git a/INSTALL/grub/i386-efi/zfs.mod b/INSTALL/grub/i386-efi/zfs.mod index b5fa5d532034a84f3facda0d0e3fe1a7e66ebefd..6953b93168607890059f9e127fc163e97b1a25d7 100644 GIT binary patch delta 4509 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 delta 5204 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 diff --git a/INSTALL/grub/i386-pc/moddep.lst b/INSTALL/grub/i386-pc/moddep.lst index 25bbd536..8e851501 100644 --- a/INSTALL/grub/i386-pc/moddep.lst +++ b/INSTALL/grub/i386-pc/moddep.lst @@ -208,7 +208,7 @@ cmosdump: hfsplus: fshelp gcry_cast5: crypto extcmd: -squash4: fshelp lzopio xzio gzio +squash4: fshelp lzopio zfs xzio gzio part_plan: minix_be: gcry_whirlpool: crypto diff --git a/INSTALL/grub/i386-pc/zfs.mod b/INSTALL/grub/i386-pc/zfs.mod index eb5d3264a874e9692beab894605c4051929459d8..9f13caf77c6ec09ac25995a8f8b2155aec14288c 100644 GIT binary patch delta 4138 zcmZ9P4Nz3q702&e0ihBQC9Z&R`4BgY6bcC_odz|=R3jp2&_ooK50ONX#;-(+R2PBe z)8PW5(u^jfW?G{-Fldw-jMOGE#eAtrB{qqXlA1)TDOycR|Nr~0>C7^-_qYFZ&OPVc z`|f-DC_QfZ{J3R%sKtBtk?^zGlUiNpT+_RZzqszXio0F!R~3637hQK<#ho?9Z=Y-y zLcHOP;nu#Y*_+FH2$Jm@3wyO1-XVvsB z$NSFil+3Ipi{J7P8Lq4I=lOSxK6PcZe@BsVs&BZ@EqocGM$4%_Z=YK=Ydn&AHiS68 z@pX2246gHbecJ!S;NYO^EoZlHT-UY_UkXS|TT$RE#B)B%;p`q>lXoXGtL^jL+@WpL zR!;YaPl)`D1*^rzCS@7G#C5N(wIB5tmLKq?#tGFONt+P@z9{vY!>4N-Dms{##f0ejr^K{tI2 z+EF0HA3zp7?dCrRojXH_EvQ2Ow{HGHNZ;vDqR~1D~{R?&=P}-69|oNhk@+2l*H<4$w(n~&>t-KZ?kiD%7d_?r^A{b zYTgF9_7S7ZY(XHijiU~hUS)P(g%_=+w*fgwn6qn1cz+Kv%O9yj$kR-C~Kkn69bcF02&RwG)TsjzXq z*TT$9H$leyhZ=L^!p*r!B-UL>Vof(m`t zmiLAqIyJEOB_wi`fy~iJ;&X(=S?D5B`x3~#?xzlymtEE*L|5X}a}Sg8owJT=`bU|w z9@31|Oi+|DmE7x8H5OK?-Atc=OgQDwgRHln8hsU0W4}~vPo+E2$mQ zuZme?)R`LoIlm7-S!-V*e#4hSUl05lN;_CNXb=W;Ka<^&scS16Zyddo|lN=Ra zuYlZ!4>Uia-GQGAu!I2#PniL~0xje5dq$1@$k6shv_}cCLhIF9Zz9q7R&B4-Y|{RA z?LVRI?`eKaJMOvbPvL!xo!!=k^|Q=IHiHZ(*Sb#YJzBq}b%)k}qQ;84Ni_5h?N~ss z_Fthr3I(-)K--6;$Px7;mtlr2#jHFYWTwd^wkBQMpP`P&ur27IFL%8?5Vf&M<;)dS@{K!J(iM~SxI}a93|BQ?Yy@3(uy6s zLhX?ArFt|zm}Xi-LFR}jkz*3=!Lmu(S@(C!D$ht&x0OC*IzcPu{8f2{_=xsk>DQp@ zCZ(I1(m+NppmxaA236Oktqrsy$9@uZ57HhiYa6T%STAbpXUZzXKS<>Ij&|(zfU?V; z20nzoYq0tx2vIYanWSH%bt*D^0mT{pv|>j7JkTEp59D=jqsGtPZ4&h@Pn+~rl*=2{ zYe*Cnvn0@(Ae$Olufz0R)4rSZIb>g>dMt%xn0ZdmH)p;Jvi{d3>OHf-te^ZWDHEI2 z^<8YLtS0MB^wI&vo-S$jX@1Knbn`tmaz-sQbsR`Ng~SQWA|vI=CM$n9LNcL{Z6Y}w zFQ{6VgWQR0B(mP1-A@SbMW%fw341!oTRf9Qo_y`E()@%(+`lyMfb1q4{{YCRcT6q7 z_nM`MF@$)PM9ogn5`bMHAI4p#?P8g!J;_iZ0=13@Id8S*o1_QsUeboU7qt9B{&$D< zi3vEv*|4Ic$sjwqKy49XSq?OI;FVl(H2z}&8FzvjalLtFT&7HK9%GD=h0RusWz9#8 zu`+pQT_E1u5UHlDAfeaFsXGIWadKd%EeNt*ySp{tR$($`*KxcQe7!5ebKF)ud}YAy z2xF;C*ljo3v{ a%DpWSUV$ZemmMPCZ3*{m*d@eo81g@9E3a<= delta 4931 zcmZ9Q3v^Cb7RS%ML=r(HRq`eHB$0fP7@A0im=aVJH5z78q_oYW6H$gvJ4O*-NhH2R z=r}=yu0~aj6g2wJaMV+KrgSD9!>hAA3j%>RGSwz}4rwQ_&=zxO_S?{n_C zkK`W>c4>qCMh|;y?ar7JdHDxIcXvE|F(P#LMC@0!r=JKd z|AVDe$)VQ1qrS`?))8O!vC7N?mBm5UpL{L8;zL!%$3Lu5O6?26;nqgqm%h(SZUp&? z_f}>ftD1XP$K_{PhxF|HN!9^V8oyyGScRaohd&*0(%DbP zKwrsK>d)|nD@&z7cPdn>1*9GUZp%~3wvEn)e)z+Dd4Bp8OF8wO7zTL#0xJFVYUmC{ zN^JpI@NGZ;Ht2$pN-ab#`cL}#zxLD3){pfS8@R^+Bq)#sF3jZN5B-ULI@M1P^V84x z>6iTU+#!C3GUyqjl-h-2oWU08oLr@*h&~9-%k}V*{k1;88)Vh@dHt59doD_|;&sj< zua%%17xfK`SE@chDXW!IgWBM#Jf|5tzkCVN2%vQ%cWEi ziP5uYN7gxxU00O4!=Ofnn5YR3bwg=JFmm_nK&!SF_w^#fWmI8?`Y;ePz9ftbM@ElQ znPieuzZDh>7YmmPHwm{3_X$se%zK8qw^FH(n0o2pXcm4#3?o4s?OmtFR%)jH39eQr zGav-y6iZ1g$uhF1Qmg5A>6XQwbc`PJD6D9AyYLg?9gqta-q~bxfy~yE+NE>KoY8Z- z7_S$kw}u+KW`l6E`1jI}+JAJY8_JyRuqOgmbas?X(oJRVWONjPs_ZBowEE$~lbCm& zu!w%tx=AMKf#uw0IprQN#$G@+j=2dkNBbxcb-R<$JweWD2#G$&h&@MGMU(lbloKShVTdB z|LBj`F_q5klY{3C+kX*cx#`qgH_^4icZBcJkM<()*kOD(p-0#oq<@s?vBHVMDdKO1 zCv-R$elkv&C?Djjpt3LS?Y2vw#!Dt=X+|zm^}yZD8(>#m8f(IDgn?%JKAmcAnW0SX#os^1AH+nFMalZq@d9suS3|s;7J+#b&MM+%77DqeB zY0j}?nR5-*&k%)$2@r+~JAs^d_~XXkMHnrN2kEaCy+*h}xLN#HMSm;2ExZRtGQq4t zC=h{7G1wI9L%Q_nXaHXmo)9()uLzrkNh3|66p)495WQOTei8-4Mu9z) zdK=_K&j`Pu9pjq45|B391UwGfaro?_#u8<$U!olo zxIrf2(ipqWU(q=i(mlq6#e+0=kJFF1&q>661$r5HRRaD+2MXV& zhFy&}4Fw28g`Ge)P$>Fk;e6WhLa8EApjzx72zSwr1}=!cHlD9-6fFD&9HH3ZAPd)1 z#xP%?pYJ}2;}7bN2TExZe|Zr&87H?1D##c9fS9rjpRFiY^r{ zA!D(zMc0t+m3l|?W)kCei9RMg?$~ujZG+W8XReJ6IK2>m%jg+vW3A!(_iH`YM7ah#(k;kZOEbdK-gSf$Ub^8{4S!`}k>{<_#Umlxn8!q)L`#zYLL ORqAC_diZ0>$^QZ3CYS91 diff --git a/INSTALL/grub/mips64el-efi/gfxterm_menu.mod b/INSTALL/grub/mips64el-efi/gfxterm_menu.mod deleted file mode 100644 index ddc1d5524606dc14d8854c4cb89dff2c802a3579..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2692 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 delta 351 zcmV-l0igcq4CoAy8UtAdCb1p;1b_23bYs<4)NO_~;TM||b%kIh!`#N+f`khh z0vZiTPsbCMt$`hpAZy~WxOE4Sw*uhuD*_rFd1yNC-#z(0jfe91$ZVdz;D5Fii915# zk3GQ7@IZiU-*{Al3zFpIv%|vm1ieS}TAet>OR&N(;;s1PMTVHzQ&d}ZJtpszf*Ii# z_U9fLkkkoX57wAR`V)&!Ycws12cAm0$7Ilo9NteS{&T)uDGK=eMc-j0+9*oX1FCgX zxI^$qsA3K}lm=o>56*$ULs0yC*>tNH*R=e)rlBlIu2ZO9aCj|#xy2WHwFrXPOG?}T x6k_-s;^iVyS%LZh008CI#G@-Tj?w@D!VKCV004fOAuF-OXZr#G00004Sz1sZr3e53 diff --git a/INSTALL/grub/mips64el-efi/zfs.mod b/INSTALL/grub/mips64el-efi/zfs.mod index 4d22ea773a3eb57326776a5fc5101df32000562a..46fe08692ca3e110a10a902fe3ff802f8c6c98ad 100644 GIT binary patch literal 22916 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 literal 23004 zcmV(vKw9kMTBTQiKg0|rkqDs zMx2l|XKNJ_e}1Fg}(Tv8}cP*tQDGKNW%1%-d#zo&(KK0V?QScAR4@FENc zqfZe`*dD$+vhWtOELbk!n9SPn7*)v6Mlw;(^*R5x1J!|(^-Ncwva z=|wh)6Xq74+D4e(MG8E@HEefyv3O08Xh~GxwDgDCy8Nll*!Wk|0t@pizXHJ67WaOc zq{nLF`Oy_7v5)$EnK?sAm!EM4u!6Esc(%L2cvUd~NPV+xvy`ZkC{PJVOpJWOa(>Bs$T9x#{a^9)9%QE;P6cptm|Y27Z;&Ed||$Lnez%=w>P zZ0^1OS$8o&9pr4HW>Y-e@#q1y|F3D%I|K9X4ot1@{s=XtiDiCfBqbY*w;bZ!4?;8D zs)0Q)Br!$!dX0bs8?#Cf*IPW7HOjD--XP+dDBGc>y9@i{5XKJ(Z~24wEsF-^<|&2# zEIp?j-U*(D4QQ7=GK7k17=wPO%_KsL17I*FmQv282RikKMa$!>Y7CXp(U^alv+&n+ zt!?_+tJ)=J=Ol+s>`zw<{B7~G=xR;4xmF{>`^{NmuNaKnBU)6ZM9GSu-v z8I8+7Ob7X-!H_1zr&ot!mB1#(0OT$koql1pcg1mUz_S}rj6i@35dxoPK54w{tdJ~t z=|REf`iPiE0@u1cRhV%8aVb?WoytK0QtORhzxzQ%JkF$~p7`gDAP~bJ25YzX>$E-boNXIKb<1L#KuI=!J9Zc9Ury{e%X>^<}C%))wU&u?X`rSnSAui0c zld=Id>Zp*tONt{`X*x>;v!p{OZ>3XYZcdtpGY?#J2D07x+Txl+v53yhIzdtIn0Rzv zB-i>ePp`a(s5pE-#HkGq6cO1%#S`Gb@ zKxQn|NzCJ$0?3|ltt2^&WBSG~Z>BjQR7nM;cLn6OB;PJ?m8VTI*uGyY>zfLNxt$JX1wD%cM)dgarp3Nct$)LEIa2{emwMSy8Xq@_7 zD8vpBYFHuCDQ>^TD1fy?J9PnmJoVfK@lVV5nGsTQ=Z)TGd= zV#`Dm%8|p|tM9a-W179ODGEJXK+NN~X0Lz|b7>&6Qa4aM${V-1I3e0&)D$xg6f8b6n2b%$F12*=%!SLwza9gOSxByKHje2D z1-hJzdjqLeuKgX@+W~GiAH_JYj%|3HC16zn^Jr?aAqH_WJrR?`jpCm|@e4m}MM)O7 zfR%ejI1&;RWm<5n_T5wts9qQBuzRoYo_<%>?xH3mLBo3De9a3aOWZO~Fc(Pe1DE1| z{{cB&%}EPcjAEcF?WGh$O~JNVMFh8>l3{dJsL?{knFEdt)TO>TlAJPEtcXe0$rc^C z`DLZT12Y*Rz7-W8Alsn^9aWqD$&Qv~-^&mZn5_h6=(eU^K(K`#q>TGMKxA59<=3+5 zQJ2hLLC_n=1f6pd9cfw*Xb?V2_UepzGuxMU zS=CCwNz=XyZY-Zz9 zUKj&UksUmBqpRTh3?5I<;gcC-C-tNY zFQyc4hMMgIa};H@&5jSLxqi2CB-8v1NG$33G$;=dqS-;%)8PUl0oTc)83ZVFJ{IFT zT)px6RnRBR5BhP%8^WI}zpc#Q>lYadU9?-R7$kPTdDKfD)$R8Oew5Owr|xN+8S=3E z(yVE6^ZU?b>WII|0UWE9WYvo-h_GNO;b#~`GkMJq4m&fq12mXtAKK^`g_e{DDP2Wc z5>u6`meAjbl8eV`4fHFoqfhcfXEw`Afu2Fg`M(NTKSLV`>l_-r4PaBq@kyT`eajTY ztfbFLRpDLNw?dxV+)46Di~yzSq6oT(*|3*QO}URT9i*l=@Xj*FO8XJRSn1XW9mBlN zlSaBQfTc0~K6~;velPAN)!=~%MDQKZ0mMZSVs%s71pi*$YYcq%4R51L?(2fG6sq0o zDg-bF=(%WsBhPel4G^h__Pr%K0w*c+77z5RXfVeV*wE$nx^@tE@6x=p{?f)|qL0MO z)9X+mL)0^@N`vU394ie3#x#1{Nxk1Ctd_f0h=rzf|5-4=R?+tUEw#o;@Vq$RPS$8s zJOM{}ke;(udc!b-w_6GCwz5jN+Dzvd)U*t?IUWgCIbMgg>AoTMz_qP$6=Qqu5qzS65mF&D?s>}9?t80E3jHbu|1iIQ0&QmF+ z|0P@_A0mC?@ntL{9`;4CBo$O(x1!xd6Ilb-#-U3lXyCOVc>wPxSSsK$@h`f_?3wNC zJInTi2HsVpoO*%^Gx@2U+Z=8s?tzu839{_<7|1q=( z!0Zj1xL_83GhpvZFv!7zbb!|_rF@&CoPV3j31c11*AsvgwBs*$tXYSLAq(utpg3#= zZbUC(%fSm%NvL1p6N;>5TeC>O>*|{O2s&+iU*0oThH`K!vl!j_9YR8?URIZQj0K*v zt=D614ijeOqfOx$?`EVz6Al+Sc*a34SmMq0N?wM$>J(yd->L z=!z37?ZP*9R=PX#2d@Xrk>+!9n9+CgKxkw5sQHenIBcTw<|*vrm1*=r^>(75g1qwB zIycr-8>tiS8q=*h>*f`+RFsg=)#^ble%2~zdzaI*i7c?JT%;|CWv5Up=D+^ptv*kw z$lcHiks0id)r%$W-uv&gF?e4+Ab(>u1A4#)n-%}GEZ?0~-+q*6x-_>JO6u1Ap*_Hb_?7I0x_u1?YAIM+7#cih_F%Hr1!8 zu}Bp3wR5zT|+z3?rxye)$4^yd6I*u8*?|rCtiXM97_h}RxeHRSt*9%D*sM1CAL=-O9 zLf7-6QXE>Moxd*o300iz{b#t(_DMM>8%n-B(+RM`bH6Q&fGCm>@U-u;MeRgdUSkb=t z)H!!hI!m?@(VaWA#Q>`w$?!(S(Wp$>(p{=-i~CIc8dukvBe-Yy92=%O2M6?WUW+QT zq>GVnr6g0t_ElD$gl%a4(=hsE9ZSpBE5(9WecLn(-N=#eprNUb{eNOXO;Vw<(tAmp zGVF~Ms8|egj}tEt2Kr}5!B4{)3{_3=Mr9T^wI*sV*3jdym@iW;49nWk#X~>mFfxr8 zAg<(%yd?5GP)gaL8I^aG_Ik4g^kxeFPEzP4q2*5l*uiQt76SJ5&Hh^fMZCd%d<;WW zas2|DF3hqf%{wgOSi(_s)KGes;{q2w1SQ`G6n%+vZ#y73sd_QxM{^NYO^3ZjTj$NE zkGxMkxavN%zYNQ*YtzVir^PORJ69BeY`^X{ftfseSxU=AWLrWpH(;NsboGt6@grz? z(s;E&snjPQme_z}vkrIg*~LLwu>H(hSytSHEw}U+24^lMW_mt`liFlE^VIg=0&s}fu$ieY7t?0A_5_f8OJUr^>84|MW;<7-Oq?bxH9b+r= z8N+jyqD!SXOSx!{{R`I-i*VQ0tu;aEa6T++5zPX6$Xx@sJRLIKur(4+P*hW(n!_6m zQ50QYKti=Dc2lVHv3tWU!UKU=bMtNy%7{<{VsNzFg7~2aI{p%+K&q*w1^>8i$n}9< zaQVO1P5MPEX$i0qw^vdGpF;6Px)e)~B|oDxvy=E60(|R<-b&1-oi`uL)WT&K6~_UG zg{4KV3L&tehC|GqSx9XvkNPUh(9`$IK3`%!o`TLJoM3`E=rvn8EXGol#Kr0oRs3Fm zfCg2Og4jo-@R;{SzGLi_ir=43<3|xidd;?L?4>_U>`G3PX z(2ooQze?iyHtJ zyz@@x%790881X93l@f&t?(26(Rc;UgL{i0K#6G<0yQ$eVL7wt{d=V*da?v3zPBUIq zuU!Y;4LR54BPojftcJf;dJM*MmBhCj^MKUxp*>vK!D58AuU_Crl-XLy3VCJenp3FL z;bQ}h^;i|B5w+6|;=*n>saZNngHfU3ncYe$Bh~{UbpF@@ z)Ay@FRGfU_8V6tUloc+Yq@JL|G+&khsECb&de(giA)%ULx~|v!iR;k8swkD4e^VopkA`6n-jv%RAD*g`PmNAE_0@_EL}in z0@mLzWhg)M`6@ww|E7c9V9L}4HDrp1-&tbT-~J9NgjBdb;LJE0_g>-d%>`wn{6^md z=r*{86V@Kgy9*-%+$x=d6JA@`rmf7po{$2P~d2V&UIGV!D#Y z_{y8ayY)0JWICwPJC?jeEl}4CCS2WsOb*5PGr(l`;*|P{q{#|Q{+1Z4PWyxAmZHkXW0hWf4P0aj`aFTB&#I$}g zPsx46OcT8)hpLEIeJS>^86pBAL)OH?&I_;n#Lp2Cb;aP(jHGzuhS@etak)A4cb7eN zpl>&Oamc*%1qIJ4dwXzNS`UCfm!)z`A<6iw!ID*oy**S9Vm zzRUgsOx{*UJ1H}(ofnho1$<$DNA(_ef4r}|!7+1PxQ~jDvY0v%6$+58pWB;ZGH76Bjn>?VE4lfbJTIMj65 z>o?U6kk_0Lm%`5bquDhe2ESnM#_sq_I;r^|s+J@n-OkyMp5bfsFx{Zk@T2dF&?d+q z8FqF{yL9?2k2NP_?Z8Sih#No52UW|iPq5v~$oKNiD6;409?>Kl5C}pcJrgO>8+RE4 zMcyMTQn6XlxLg}p%X$;k$Q^WiMbHfqfOI{`Z~Wfs90v|M!bKU?6!P4kUi@*3dv=rC z;P{<0twG1;y~{RD*QWvn^PxX-2iy+SKCZ$BBM0Xh+*9ly!UpIB6y*KC8pj_%BbUlp zP`A8PjfclT|Js7EO`54ThZfawxs~EPMfEc`3+LJn^@GUl7PdSU(Z<-_M{I0Ba<^kS z5mz`QoBXq1pm)nxO$Sa&%5BaJRx)4q%#1AzOUZkhCurDl>H!~v2()n2i(UdBSaA*W41a5qc0#X}x%HeocR+ZVqRMnn8lQZJ}5c99K4^_6}3d+Wzp zv9)V`j;4nBtzuM{i{=ggh#xXNT?s_^50p>6G_pgM8@1X`DA#Ta%!VYQ ziyrP`OOK_yg{~sx=X9#a&si={_#RiN{fZpm4ge?Z5fQwnW+{^8bJ4^P_*@7P^7rUc zoLoBBsLaZex$ry~YdF?$DGezX4pxZK(btV07!QvmxBh^(-lV_2D^2{btHyHdrY}lbrye0<%WDdK-QaT*H`oqINj8jN z8rXDpo|X%jUNrbx20qkU3-_T&>$oS&i+I}vaSyAT2l-MJ<<}e=WmJXwclRH-EppWLboq(k z>A)_SIEeyxS)Gu=PBd3%Nbo{#9jo=!9ndu!o0w$TM0Ovc_+iCI4|{kO{MPupG%L%~ zeMuz}35Exl+J?alX8rZ(5m+n>?U__E2ntes!QB}Sydzl=>l&PjJlNO>&indGwf?9` z!9fAx>O%<_xKh61^rfK$wlNn#88*^Jnf>mb{{Y8R4EXj%Yyfbq47zPw&m557X98UA zI)}d+ER@o63P(bcImrriM^qUS|C8(@bg@5!*@bZkiF!9Bi=ejYcY^T6?aF*`wGOdZ zAiv$1YU~hY1UQV0GLe4=o6f_0X{aeD-mQ>eW46oYKzSIX_8k>lejawO)wVf+##@m7 z-oCTY4l4NWOoO_w&SHS6#&CYb2hIyngaD*X=`I=2>8e>!@KG^R({Wt_B1e_F#%{WG z?aN-Y<+r0?m~8=7MHuQIOuAdtN~7XQ>yn8ssEWgiTP!52GZou)1PZO+?QU+N8ttrj z;CVsvzw*of0q;n*t6r_tuDt0n+sV+qAE*@GTi5Q>puS;nt&n%3>F;go;U7PY3$$#NBaRxz6~xRql*}- zCJ15$4FH^@oKR9TNsZ*0Zlk0GL&whwjltiY9tHr>>A=`4L3iKC*2R)R>sBfMsG&-p zA^A#YsSLm%hkyXQ&0;0h0CpZNY!330Glp$+=%~aVo^gpeANJU^lJz6(1sGLG2qATOw>)Yg1~Z zGoSm52%5>zT;dh8xL?sl45$ewDGg;giA*ecZK7Mtwrdfpnd4zm*04r;VROtqRe-uI zuX0m%EQ(_zf~nQq_4jtUx_*r-@U$KZ`hM@c_Y+#P*i;-;r_$MHmh2()Y>!Y@+F*D? zpWiK7qzt1IE7vde8ik6DT$u9HG)Bxoebhm)YncgU!)5 zs`t1FJ^J4<+(C9O`=a6U{mYp4FSF>&h7*Om=M}fQ$D#9^pZ!5P1!nly_B~{$9Y7Q- z3<3xIuyFE$f%6W)bqd)y#8P*H+6LDlXiWQ+_B(U5J3W$~qvBzX1;S11;+ji`0C{db z)_l=Ja*JW_+wqBQ3|U7<5L}P(EV&!;>;FD%1_mfO2lD6#MT6Gh{mxz3!%6o zd=AG|(8hNP3%xT%{wuD8>3?Z3Xv2OCLEK}dmr^a~5oGj=$^RY2`+8xaV2KpfU4j+0 zW%u|seuRcPy9^d@zn>g6`KTn~%Kmp9Ug_O$QO+0Qs`)x%)2s zd7KF00qH(!6hdVWuiEK%BM89v)Oo4{*rG`N1_a(6AtWsYyLFN9wiIDk#vqlw73HX1 zt5Zh`aC)KdEn&j0ef)RL(5i9^7-~15)*JOOx@9icFSjdzI-Swe&fgjTBmL6N;gP(y z@-0n@2+T6d*nTrJX^~Zflv6>s6LTZTOocpOv8=jjg*!_HsSVM33+pB4v7&3mH30%Jra8$ywT$@At!u&3!gZjQs71k;y+@SFgbOVQFMCf1b@xk#@L%i*+i}cGLPZb z^}pNYLf(Md&y7el8O`yqGc&}4U@2bPhBXKP@ZxQN&2El~cL&+#xkwYIold9%rNBou z1nB4Tj~1nytmPGKiJ1U^B+b#MLH z$uYBzi{A9hY8!6VWj7ZLA$ZtqTQfd}-qY_--e&w0Hwo%YI!AS>)VIDut=8R?x2Hh5j+~lbvkZ{$iWrO&gvu^DDa(7w!mAB{8 zb8;I4w3_M#zs~$cTO$*LUlz{-_Wthv8=xB$7;plmvGz+SIb?x+C>={Bm`4vf)iIL? zCFaZu!sl$lxQ;%A^YQI)_-7EQt1n;~EwV|?BALf_g7aEk$XS@Pc@Uva%GSYnPT$LCtl#oZ#YXr^MrG|shpWkz zSOnX%OO3#_7%HeNStuNGv-Trg6AL^eo`1*#+J@|fr-eQS2?h_C?Ako(uXi1~%wCnH zT|r5mj~!8p2j)NTkj{FAuFRw&%q-21ZD0}|i4QQ~=rC6Yb{G1#*^l zBp0WnF@>In&&+WX+Jg?`8W_jkAxPtQi27RvdtuPGH>)yTslLm6xoEEXi)%b8n~=jP|kw9mxC!49WGLoJVdCtEcw>Xl1sDTXRY_%13 zZaOUxUT=Leje2JqgE;H9gpf@=e&_)T*B>zaSC%UTh{t40{dM~?uV_Y0amI~Y;0%dZ z5y46>8UP_nqJy65#~CYLYrg;?(W6+zP_TGqew1rqFDc;rTSSX=1O zcEOc?v8!0d^)e7b&4%nvzP2C!XZp2BqU+HR5c+cuS+)+UPLUG~IRA-+G0sQL2b~>I zuwr5ZEVvGMcPw$)uS>M|K=)m7^a;F>fKg71s2ZAYoUACK+*Qa8g?b1Wzwd==9mAkR zZG<&+k(d2h>EZyRj~bbdtnE$jlN3NQ7FPM*$>zK|NcNzieil<}0dKj%qW4hc(8Cqt zXd2;17islZsDYzW^QC6MB}I1>Qpd(+b9SpWUs#W`?lQNT!!j_kYW5JLXQPcF>5utFq5nCE#F4Iy!#VH-=UnWx^*A5 zrt6HryI)b=B76W2G(vZYjq)XH5$SfC8bZirqc9==9V9F=RmHy}kC$?;3Q3*=rH^z? zvryG&fQXUCilUN)+HhX0R^539HGcjGH?Iyc#C-F(!1?HZpPL-4Xi2pVu}Gd!GG7`; zA8NSWF*cQaz{{BRm+{t{^-f}`wOaD`f>8>`I3R2hLy#(mfb<>U8k8o#gF0(SupUuN zz;q&0*zoC_eI-91O?cCcgE71ZJ$6-Y;&{l=w*qE_;W^rQjsar3*k&m^x`^sfQ{;%f zjrJ!kpjTaj<;I=8z#UP3(DmE{nkeRZ)J967$^3&RcV%B`wMA(xCT;9$!!fijjh7;t z;E398BS2wf3jx+q>Im*Q7Du|*yBv1)YD1CfrS_+TLHVYhhBCFewo3vHx-qWSHJWTW zS9Ypl^>_Ot32ZJI-n5&quPEVOSVSwh?g*E;0>$wRYarwEM7K|cuS;POG%k!9H=F&s^AXhja^Shgb6#++5y_0k!h+@+MQ`zCVO1#qxG;?f*_Gd^RU)2l(1gRn>##J$* zr8C^5D}M!+vnJ7?;xUHQ!}*1VfmhUaksqnqS8a^tbtxh_G{EcQT~ry8Nt67SNLllC z?9~bj({@MDpH*~B1#l4W#8|}gZO6V&En|{vUtk@ZC#jYt%1+>gnR*Anp2bW-*DK$1 z*6(ph>$b^YOgyU`A=U8IMBHOV;oxPg$v##5PHe#Ms{P1@>pJ9@h(IxlDhQisilDqI z%8>(=_HLeG_N9b(bCN+A^Ord{z=xrwx}O75RKRbhsM$Xtx$yc(jo*aTIkHbnO|zj_ zRvQa4DY!rXU=PrVRq5SI3Y*ynA?AC$DU>%x*J5jdRQ7bl8 ztJ@-Q#pyHPBdx?055D->(I4$aj-WPG`ETqfmyQ<@<{bW z1YU!J(eA!C`2|XflAK)(IE{sKs2j(R?xO<@10^CTSx3OoN-2VbK5$9R@kVkRDZ!5D zCp;u0Q3WPi`xa&ZpCpCBaMzMFJ>j>^thOd9F^1j-`DN_FFvn4(jY0&erL_6VCdsmD zkc>Xj5`bq5_Ndp=j{W=tr`0gvdrssR@Ey^S1DdLO{2DN7sn>F zFJ1ixm91NyLiq(Z&u}A^Z8E5k=v7rM|BG~V?f5}F*kmpCO5E_@11)W&Yr}9W(q#UO z=(4dfLKGpEw*;i?bV0KMZp<{*5?kFFI2}r`ax#h7N13UX$213jPXDzxNz6zBjL2HE8v`I zxjm1y7w{Ure$f6uu_GRr)rO|)RMRt@Wpp^(sy@3fS&gO?r+r9xN{$N7V1M%z((UI+ zxk&IMM5JL?QQ}XluBwI#Q3GtYesG$!2DhxYAE4A{`1$vfDNTA1GtCmIHVs9MSJs*s z=QE{#VsuRb#55?d9ec3s)Y*UMwwNAO-&D<~G!UB-=tH!T2<&ittq(Z?(&`R-(if`a zEfi!J>XoY25>jo;;bhafvBAFha2)xpuKfKV&0f?$pcKhtUR0#M>lZCJNP;l2g{5TI zc?p0*LC^t))~>%1>g^06Es!({p38s`6>fdXZWT~|b#qZIny|j88<75fn&J3TN2Fgd zGze|U>E5b;|6%640@SifA>uy?7c@%Lo&VcmmvV6Y-JG#w6iz}bB&qytPD7PorFmjf zFtj}N8^GP+ypqliF-|MU0u5Lx&OAdJqf#$cmxZ2yKTpMN!23 zSCnhYVSV%oo_N_Bel1`c0CBw(620_$GB9dQ3wZsIv-}9}1JK|gMJ(7+RhL6%{5`PI z2bx!@JAleIs1bkM!O#y%MsCVE6- zPCz!*pKSII^|l`jceJAan(L;}4DhC_YeN(s$}L#&r0l|G)`##p9foh`UzLa29#cWi z^k*a)oT<5y!~(D*!fzJ)3$_7Xm6oyJ@VMhbl$4NW1Sf%$_~T^rw0|)$FNIPG zkUY=V7%(v^LPK_8%U@|V{RhvJA4dlzxFHaDGY-4kk>Q)3D(t&m5TZ|;D1a@9W9h%G zhVX|#6g19u7yy%*y`X|b+$d;cED-#D8`+jf75UKetZ00Xm49qxIzJ^+5fIY^^u}^yl6(P} z{zu@ifD3wL9r)EPxb%JWavYRvpQ7pe2ZgNElFY4Q2t~<3UU*hOu&D*+b<&)03AhC0 zqW_6FwK`S=K}#@rR#JY!+dCA7HLf!uSU=J^_cz7SZ#@iW$B%TAg-|34$V^@$;j~tI z+^(|c?vCc)k}$5RDmY6K0AC>NKUj#uW$_q!t=zU(%M@`uytK=iIoa;VjHOuSHKIFJ z;nQg%D1yH-uefK2CR6PDUt-}=!z#&o5nYm(6TJ0E8G5C5oU24)Q?c8i9`T*Z^0J7! zsJz_CyIS(#(yO)v4F;fqhCmx0>WwKk4F1YWu1O0Z5)&TELjlOoVr3u^Tel%4`w#xc ztJ=+gf=X&5xf4nuBIle%fLw>fIn9+$R(a-aDevs$-O?(V_2mbbzYzLXw0|vtBJAbo zK#JRY8)tE7n+sW95?xxMBbwwJ>mlpDvsrz%P_t-91l8I(c%ucppWjSri|Wwgz@PHZ z0m4p!H97D{fv#zR>$xSFP$`;9F_%Jdw*~B~WhBvPRe3;MX8E@SyHDiB@B4|$v5$tc zdraU1QCd61EmzNg5N`6g^IXwM-&cA>9`d^7#5|i3=_O})g3bE6zAUZ} z1rcaE!)a#RxwAgfZ>CWXmd`%#SC+M~+|d2tp&k_!0BcA3EhyVn$&4I;`0W*0iLD9$ z%U&2tYFf_sNYet}dw>Klg`i@nj)`y^oL&wtq3n1V&>IIDyg@c2sS^>JPym>pRl{Xr zfwIiv@zC?x;o-2fOHNq3&{9Ob9h=!GY@iRGz=Zy1?=O2Be!70wRL&;J7eK{|ii3Th zdGiB|BRX*o^xap7TQSZT3f^$mmWn?4$NugFAdBs&u0>)CNC$0c_8$zfB#xHaMYRE~ zyJ)GdkTs~clH+Y*(d(QkL4fS);0YscSsh65{bv_|hsjNC^)5riC)9($XYm?D%HtS=fv87BiL_cX>v(UiL;FME;}Z&kad@9QuTxlGUji?*qi!+6&=krxaT>wUm@ zz$dYPe$8NiPRZ-pwvv-GTKCoWt=q_>Sa2lVutD@=l!2Ffwr@jwyY6E0ns{E`81f=_<1l1Ns@vpviLD8K7$w>kUN#6d}NhGu5&ja_sXIF%7-`rv2;SX zvhuPM`P~Br;v#n;c=un5a=g)5^UsJY+^OXs`IEqEuyl<%>Z=gBBfPFhM7NN% z)CV}Opg-cM>$(V7l32>Gi(GXY_=PGE1C^yE*fA;e6g9>Ar@LsYI}Mi1L5>wIV$~ci zq|NQ3OAf{VoTmeDq7&PilakA{GDC+zOzZf|JwALQPtf9jzc+B~_gjk!EzU*3lhIS2 zExuerm=lBLk*Cu&%`7rxCmM*haWBa(|4ta70Pq))11UYlCA)DnGRUv5W9yYMKz6VK%Z z&R?>u)nTehM<3T_`yLc#T`b&AQrCAU`3H=^|r^YVCCB?Ytu{CWWMjO5g(3;&HrAX$$ChQLK}_EK=dzsC)+WF zBT-8F(n6)r`<;w>9-g>IwR1baBp?{{o86cSn&8i@f4;KiHI9cqM~f>rCK!Xo46VK6 zO8jYDFaz-E%l&nm;Tv&xohbeC&)07Z(%E%Qs9%wImfSa7!}do0 z{%VEqa8F~=_q1cu+^FSJLVeo5!*|uEW0JWccae)h%r5q}p&LtDXacWM*YdX5T6f4) zV4$ZnJ^B0L>}H+rboB3YH&=}1`WlAVsktN41jltR{}1EDGz%HT?zup}5(L-pW1EHc zbub+R@C%I^3uEyQdm1aPyJ$qXdfk0*Y2|}deVL0{uR3&u^@ElStsLDiR5B0o=5smV zk6FYmf5RZU^?qGThRWIggBnrAJf+7BPo}+>xGuUnpd*i(8APuZ*0{LB{j!Lg&N=Aq z#o#45elH~!bral&Qal+ZZXj%tvU}Jarhmj`PGd6twqUoFC?$4bS0#KuR?M&eEH^pC zTJLZchKZxN!e-C+hI|R;hSa5P+w- zQU0K@zFfeEOXf)H_%_tyq$zs#87mI5W-kHxi0d4((HVDEiyLBJIhf#bjN!s=7#3WI zIQieQ#QVg`L{x$)|N3XKtN+huduN9e4qxRG5dCWz1!^B4dQvAGG#YN#re2I#)4nom zu#D%?1`7i~u_%50wP71^nZ?(ED-`cJi(p^}4?OO!mQVw5T|7suD###pgz-lT*5|lZPfJ(Ma(XU0#u__P z7<;)f(T2fiC&S}mybfGJrk;Cc1K{19|yXz>?qsjHj6O8-3PJ z#0Wq@*aEZawG`qHN;u;q-#qHFu?Ot&A^RAN(l0K^Jx0BrkCUzhv;0t+^5bHTJB$g$-XX;eCEq)z} z;x!r_Y{}esK##^vIQLRGBbq3&1ZL(B5bJR2?}x8D>k~qTcF7K6>-?JfV*dVFkyypd z`yZxWq;h`Ed+NQpzsu>G>CB)wKZ_K8;p<@Fw2sE9z6Uo1M?s9>^KajdRD$WsglpP# z$HM5~;om=a)oeBd>MLBtTCIA$G|2yUg9Hn$;kKQ->BX#Yv61}Ov$FY_Hi86}XahU} zRS_?4q5!1*{sQLd$faNyJwLJiEzh#yQZ))nxF&j3E&~!Rnay!i4}yIt`-ojD;b8Ku zO72B#>CU2k7DV4Iy|)2+@Lj_}aHX`*C5byV%p}dK$p+r^h$xw~dp4kSGMIcBD9a?! zBNWW-V7ngg5SxVjc<6rta1^K?BSOmdwYl*aIFFLPpCPB0a_Zo3hN4>gr zFU`kcwFa6wj4O?f=ey&BF2_nGa#MjN9pjvVDM5ZdRf>?A@qcSV-K|-Sc$96o5Ql$s zok>Kf5>GP&4Womi%JdRqj;xh_-<{q24x+||9YdGiWlDu`S+=-yj;u72jLy9se@NPp zxV<@1@^5SZP|{1wID`6_nipBBy_!C!$+aYNx|*uyVtRt!ejj6UaD z{F}myeLQ!lXh?(41>&|E&PPoh3ySJ>L|Hyy1{v3Ijy}_RmS3yi*0zjwbdZvpr6E^~ z-d6a{X1bBv#+8se1qpIl6 z)$r!OIur);Dn%-8!#S+05K+J;~{0*VC`ta$`96OtAAk z*$V6TVSf}koPPMr=X6Z;&B*1JUSY@7@SfJhZ%rD>^he%1ofY~*wNJ@jXIqj+=h%x5zf-0b?I0%99VyJC-Ch=&@WyT@KQINi@1MMlm3+ z0ul-ZG7B0ki!TQvD1j0~C$ca;JFJ;#6;xbHsnD|1!@+18`W0^j%mGCM-sX1XBz30? z*aBW<7tGv+cuzvW_d1=V&rA$oLC4_(MER!8k7&2>?;4BqPSN>X0>$Ao4V043EfT5z z(~pQ}ogVvBbI9UszgIRR<7`j3-u*FI6t={O7AJn|@sM!ZZ<9@Xc3Xpb6icCe8hZpp zX~%9SJ$eZY5j$}U&lzzSGvveki|uQ52`L~$j*jyg^8fBiYeT1Uqukt*0<28Uvc;!- z>LF8Q_PnRaf*e3?I4Y~f2cKw7XRzC#oi8y4Zmv)tMenVQ>f znn_RoCy;se0Tg$%_?h*p+l+$)4t?TFkOnw7Xq=GP(WU;M{p}m6=p5CU)i4N zzd0p(mhuHF3Roh!#Blx>BR7J!Dm4x_%5{yKOLINm&x@A<3>S*11C6A_&*8))52pr^ zLa=r4pisdORAWEg3gC?{Q#s7&(+Y~Uf<{qBx<$Oc_G}Q!>dHz-!lZE>@Ot_gjn5u7 zSSa>`=T10B#NufTjIOnhUqlC*QV5C^C}C2GHCWZFnp+QZS()4Tkp-TlD(rL)$=NOS z-LR6_D1O8@@h3VOz||o+eXi%q-3pA!;MaMZ*+lCX)=^{+%Bh$ zgQKK7S}#y<1mdJt&^*x*fpe=y&+T4}S;wFyK!3Cf^Tj=8OU5knS+Oo4lWd1pO9%Kp zHw>b2rz_F{X12UQ-dr8mSfLt}+GH`p2A|hKh1F?Pmjlp~byjT(HE^7)3u;4T<)o4h zj)yCTu|uE6PYq>jz?S0b{{G7}IHFE%nbf}O2&6ncD;pbV3B;;vx2muHO+~al0Wt^! zsu|?|uL5DX#PR(O8j|7nt=OnyQ!B)NXMq#D0FOfDTF*N6JIm$E31lz0c9M<+8R6$V zn`_0X9FP88RX!e72tQ0SskqU%eRt4V5mL%afl8;~rQe2rl1B$KuXrE$EpOUjNGfxcsBs=tg*$=E)X$~w`lN{bzIXq3%@^H1R*v_$6R%Fj6CRDPB-dv zSgicxeQd8aymLl8-1DwZreDpb%fapUcDzwpJ9!h~Obf(znD4(9P0A*3UUPk9!bAF9 z%Na|CaD>KpxSF0ZiPr_Z|BGpYt-&DYO88jaa%53ImjbTfHg5twCLrGs6IGYlCX*e+ z%674oMn}QM7$1g42bZKwqB_Js#B{jGq#guz_g_(z#1MVKs0drZ1`Y ztm1`kUNcm0vQzYkFSb_7>@YGZWsVBD3NScvk$W?50sQ7QzkAhPI-fcPWoL&^fbnB# zWzo+oUfEP{YDLx+>L=@dZv65^2|ed->znJnb;I}=^+SaMT1g}EV_MVLZ2k-5M4Z;@ zCAED9>}XOh9;8}?zfn~}a6c9&q0$4%#fjMpme~_LA|DERRh<&#XqaylfgmC+Rc}}0 z8m@Mb=-`sa3QGw|;8Z1W0RKQZ^zh~-7%*Bw$A6AP;RE$4X(Jtq?AeVRTxz$&7(Tej zoCHwY)5=34%WNXOH%XbPJW0zq6}GrTn3{(R486hNV&Uu=*j=F^H3or4GW`^c_y_so zRM~|o27HrjAR`*`P1t3p(Hm;2;Bd+niB42G-L)t@7Xk#or6!Ir7Q7Z$JSCr&D6i}Z zkB=apHvc!G8{DL=;kuGzkEOaP39!3&j~hD&ycjqzPvR?gg^;3p8e%#s07oWt%j)t2 z?%R)Ao^Rns+s&%Sv{v;B0+eu`!(fTyuf|s;~0L9(Q)L*a@is!ld=-22?OvJCihc7Ji)%+p4(jyZ`jXy$S(j{UQzNskY zq48l4Uhk!993?qv);a0ksboobY(-h+UnA)!x+B6#py1fgB@y&TQ!oO`jI+ShgIQBK zM)6VMnT+dxu%%b;N5Y{R*G&Pj#drG;LWS>q#rY(pf;v;T?_Q;QQuY9s6< zC^txd&6^y6HQUoG9KEo+J9u4o^?woa%ZZ!;C>h9~9n6)G;pyje8`htI=>_~wEXd@)|dvz$u^-K7}VQiM8tUQAOhEa+sf%IsP2sc zTqUbob$RpLmjRDdvec8eV)3G>zAA5Z7CHSsj?lw=j$&wslL0Zf=^$U;|QiCQI z`se3U+`#!7^qNjQV_xTiy>l$t>I8^`t!|3rj``{5fNF6t5HBoOVy;rs=tQEQ}BDdW_ zf!qi}yeIJ@w+IC7%xH+CN7E9}Wd!*BOq5O~MIjm1K+`qKA6c|a-?zPbl_Hb2IZ!i{ z`>fznXOu>63qV)akpyjMMrTG(BaOWl>1d@Eay)+CBE}Eq&*XDLu*^k-^LKUr5jNrwk|QT|ayDhC|ZdTSjhs|5xAyV!+wF zOwGN1w~fZnHxU6H#X<&KA3UPZ$8pR{O&+_hI|XUuSVZE2b{>|sChMN)Vf`h; z#tH7VMNAbQs0tZU^~{I@44z>$uiUbDN1FCskfsq(YGedYEe7oK8q?NosB^4Mvjm2cKCb{Md4we8NHzSdbtieCgCG#XruRId*+{zEqu$M)W84c>-YtkqAcP&#iS2bI#qW<=og<-MA7FT8)>ATbxSoNa!$GLTeDni zC|*hw^pZl%?M(0H5U8=tQ(735fs8q^JTSKXG_yE7&Ncyo&sO|B+K;U>)(Hz!ZX>s= zRzHU`r5+Y@M_5uWf^3{Js%{R4{h#O)ui1|^pbG?aYo7lTMCxtK8L2)n6Wo{s zRX5#FwDtp4K6ULOS8!NUqNhQHl9pAORd8jcNY??ETreumc-Dbq>>qb3cpMi^5e0nv zk{Lq^j|o{D%Jx)Y_kxvk%v-%WWwB3sYgoXuhx%&1W&SsWhI=}KtH%0=Dwm5%Zbc#iP+O>rD8x=ec{(eKM+O-?+~wOmYti*rSbpLccY%ZgBW7qo&WSK@K6Ki7js6@mOFr3qe_|Exp|qE z5VG_y=XTi6hTDKzgAB7WrW*57JAY4|5VYZzQg;r9dz~7b_?j!#-AWTencF`JkK^Dv z^N*+xW*XNMR4aU$xD!CWaNWF-=$-!PQo9-3$19{E=M<*CbG^z=R3bABCg>lNFEbUw zu%kfQxcvb?4NvADsPvCoo@*}?jfN~J`&AEL59>H z=JW-DF;;KK+i!$KXKlt0J)Cu?i z;)bGW3A|fSq8&5cLS%j9MEH@B^}ka~+7eY=dA!4lgpWGJG-4}3oq;w?3{QBLo+2I_ zjbx${1wdXyJf_qER{c#R_fyTWP=4QM5N#80ZCJvo3gKDqMmvN+ptjd^r~6`*dJgBe zRdO8IL8awf3M#cqpT=>)^Nz>*qt1U{Cah2BNjiMqZ{HiF=4Y#33eSN}TE<8b#!X!kO_oT5SL{5lY1jFWav-2XKieoRN# zHOqA)hZ|O=UEJatxyOApZ!s#wS8UOK6#|)xl>(aiXvc$VHMr=rokbIF*AZp670?6XXI6f`L#fki|?Q>v6T! zCMt$S__fn=;gmJCY6T<<0y$|?GzRt~*6?ELzc(P-C@MkT71tRWAcYLY4U=pqJy-$R zfNlv}nW`vdo-yLS^>{i_oY)%vUQ~e#dcmA<)8Dn%=vbdnA!=aJu`1;dZndt#KWlZ~ z11TYhv@lE;i6*kz(`8m&gpp3KuxW|R8Je%Df|RtHD3qcJhQ$Ud>tBXv)F{jvuXB}KlO{?``= z)Yu$kv=;Q0RUJEFTh0|FRqyzBn!C+IfEWgGH(TI%lY&E{Sj%4h=a?zO{-pX9y?L)| z?@>ZQrjQDAQ+`5K`)$rPUr6LZd=ZDavYOedEvC8xyzO_$gXfabC~!-aIS@A=%o?A{ z;_58eBrtm(mVdX&Ef{SaytNwOTWH@is5RUm)xN2zO9GjF=3UAP$X=@jFsj1}Bk?L&)KTFpJ+*euuxS?swtg~3od5rKoNrfOs3~=1sBSFNcmBe`nh{4gDzAJgqCbzR%uR`ZsJ`9P9(+!w4rXz z#DXM+KlS zPY{`Qy@+(u;iGj!M37s2ZM2zZ!&~F*+-!4pXG0}M1(qWB^r80)jdTaFHhJ2-AKr2( z{uOcuS5MeoF**@gTNNYKMzEH%QV^6gg)s*8`)IqqufsW*xsLGK zOZM#ozAG|1dw%{UgI!ZU5nH-rkZS8O+Q%TQDeB{{+%nnfYMac< zt8SjZPy9Ry`FNJgt1&ZPkU^c5!veO`>axA`fpD{r@n0HGEY7||ulT1nehB_9Ca1Lvs?@UD~j3DHHI~%1_(2(%;~L5oDD(oeo|yO z`e5kMDE-_5zawtaQ65C_0P^@6vQd7C9~|$pd9|~(H6@-3EHI;`pqmNhjfjFfqE+*R z0eau3JRI`#vt$VnNecJ#k^itO26R)3MYHQ<`>_qw7$Rgm9KoyHP`{y~^d_fZWZ!(4}6O zkwR7~qtm#dXlkg>n*RGS*j!*@$)b=7-(4S?f3WvCL(vFBRs^jEaQ3+VP`~a`@4YD8 zo1B+F*oVJ|Br$3+u-LzaEh2{R+k?CvwO;m#zi<{*)|r&5gfw%a2yOQLHY@`Ab%|iM zjW-0V5{t39|8Q@MKh`u^2W8nE^~;d`*9A4AevJkQ>qf2 zdvmS=7E8F?998Tm&L{RXu}Ecmx92E~Ar)SKjeKsNj?A{nH}CA=tiErIApds^00000 j8}izia#h2-00FhL0f5g1G-tHCvBYQl0ssI200dcDSe~ty diff --git a/INSTALL/grub/x86_64-efi/moddep.lst b/INSTALL/grub/x86_64-efi/moddep.lst index a0a40bcb..2f03bb96 100644 --- a/INSTALL/grub/x86_64-efi/moddep.lst +++ b/INSTALL/grub/x86_64-efi/moddep.lst @@ -202,7 +202,7 @@ cbmemc: cbtable normal terminfo hfsplus: fshelp gcry_cast5: crypto extcmd: -squash4: fshelp lzopio xzio gzio +squash4: fshelp lzopio zfs xzio gzio part_plan: minix_be: gcry_whirlpool: crypto diff --git a/INSTALL/grub/x86_64-efi/smbios.mod b/INSTALL/grub/x86_64-efi/smbios.mod deleted file mode 100644 index 0176d067fb2844d5f81439ec01c4e3d83d845e80..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8704 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 diff --git a/INSTALL/grub/x86_64-efi/zfs.mod b/INSTALL/grub/x86_64-efi/zfs.mod index b213ee3f045623eaeb8af7759b0401cb6b3306c4..86bd3a446a0056f0337ab9cba67aa9a4ebaf3583 100644 GIT binary patch delta 3843 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 delta 3633 zcmY*c3s6&M7S7LOM1c*pWiP?vt0{sJ16J2bN3^lfT<|h|((1IB?mBe##kPo;wIjnS zbs^9zI!Am}e5YtNKAIKrfg~tCi2@d1OoXbe2xO+~E-Tb!v*+Ao=jPrSzI*QZzw`a) zKmYk}F1xRW{^d&OhNKW@&++MR6_y%5H0ByV$bFw*Gq_cyQmO0p>UtA%^~Sk+V#cOdcF9pRUC@Xy+L!&PFmMs#2A&4F?1(YIdvF3OM{^A#ti= z__9k8e3>(Xw|+Ft8@iVd^2y!2^**0GtUif@&JaHNmSFfhZ+)s>`x1s2%O0wYWzW^c z9Hl)zkgkzk^DkiFahBC1h;K$@C3j|(jgBehsbb(-{$lC4?5Y)m?^HxqX0wV#tTH>K zVo^wCc4)TlgTa`JMWI#MVSHJ07@z#qx+qMrx(1^8s&VMS%p&nIXIa-Gadq5(1jFr> z9}9*Xmeo0iwxT&W!dq_%RTKF#7p~)CgkW7VEEw8x9aVxhLP&P;t|y_qINMzsfyKxY zqf&YHlsAkN#qhr7H!7F=c%SQyibCJO0E!k*7?_e}7%qB=ubSl-r0EN>Fe3x~ytVns z)c^W?8Oe_a!ZWPTk}s|Et(wWNxj-Ey_dwHFeEc}i_=z#kxYTG)bMmL9U5G>UJqXa# zoHE0azT!|gIR8Ax(YLBEhP64`D??fA3o6p_Uz9mrk-)y@*e@lV3Ta<+X|r%g#;cfW zXR)7g1fS`8E8w45=zl(ltxQ+06#E+qizFN#B@iW8{Oqs%H`QK=a|EV{9BY;A z`x5>nMLiEh?Rn2n|5G4J1ILj+UBcNCE|l;?3I8DBmlFOJjO#hgcbFrsrTlZhz^Z^w zBNVRZ*mZ|>eGGG)uKqWJqZ`v%qQkqfo3SKtgM}qR<|e%+DG)%n@qwCAJyJp3#9@GK z(-;b{*EC^3!Dc<$wVNq8b_>~=h^bI4**3&P=-gsLOxS9Pjt`PHLE1JB8n$ZLOz>>w zma|ZqD)U9>L6t|Ddiz*KtxP}#@)20&fSzt{vPtw?4j&D zdpL#W;{;h#3(HdXYo+G*P=-bntkacnTa#*dPP=Krpg>#sSR5Pa&2afE-0V5ugDxNxNV#!P#($s zS3a{=p+`K-DO&M!y}XQ6XgrL;;62=g zOuJoKxXr0DQv)8m8I{wIaJW^uN6ZRM-7J|o3EW3$Gh&aDa^_Jwc;Uy)*mC*DaKVn6 zW73JNJx*2WJzj^y;`bb$LfiM`@uIDRaEDpZ3;nOl6X>ACL6x&RnpnJ};BUC@M6jKZ zngM^{lOU&_wm83@N?L;+EqKt@LG(%Tq$5s+0z@s;BI>|>QaX+&slD?WP{+~O@Qg%H zoF>uOGZs8q;u&c#&zMjm{4DwN&yuI+tcgtq4|=fpjmi#wAzRKGJEoC1Dd$L`7!mjH z94UCuDLZMIAV=Y8ZKAd2G*MOZo0MJ4<;YA8*qdmnLx`A(la^QDq^NaHWe@eeEl1(v zom8?|7x6P)l%dU~qbLpUScEU`LJ)JlCn~ z({Jcer{D%1@e?<0W31Rles3EohqvpagMX5L4TbF-EN<6gt|jf1aZS5&Z71{PnKTgH zK{KUykXA0*NwBU%xvGZGWIlEjGPTg#L4BKflX_CTDgBb7t${f|kX`eG1-mY~Q@M+U zzms+FrO-*QhJsEDD)bUM@@~D&VBVc5Xt+HOhlXyO*fdDLqdcn50^dD!G^RlTjs||S zB<%@-j~f4I?H!uJeTPy?xocv2D88#_6Tyb|bnxEQ=LQ$9I`9!kvGg66N(NrjmizDY zNdI{J|2h`rC;k@!{!S>o$EBSr^7F_UJWJ^c*-uezfv9u9y13;2zy~Hd>F;(x<(rjq zl;j6v*PCnttm`td2@ZGHv=Ely81fut(ApIR$GWxBy{CH~dj%4D%Fqdrr!-EAO2kya_59YH^;S@gnR1QBsm>+V-1Ft`v&v;n%Z~=`- vID(iDhDQs=ePQ*>42QwmN52~P+x7m(!4QbIPK2IEabx)&ziS0B>!kky@*d8>