BDEPEND=nls? ( sys-devel/gettext ) virtual/pkgconfig sys-apps/texinfo virtual/pkgconfig virtual/pkgconfig
DEFINED_PHASES=compile configure install prepare
DEPEND=~sys-libs/e2fsprogs-libs-1.45.6 >=sys-apps/util-linux-2.16 cron? ( sys-fs/lvm2[-device-mapper-only(-)] ) fuse? ( sys-fs/fuse:0 ) nls? ( virtual/libintl )
DESCRIPTION=Standard EXT2/EXT3/EXT4 filesystem utilities
EAPI=7
HOMEPAGE=http://e2fsprogs.sourceforge.net/
IUSE=cron fuse nls static-libs elibc_FreeBSD split-usr
KEYWORDS=*
LICENSE=GPL-2 BSD
RDEPEND=~sys-libs/e2fsprogs-libs-1.45.6 >=sys-apps/util-linux-2.16 cron? ( sys-fs/lvm2[-device-mapper-only(-)] ) fuse? ( sys-fs/fuse:0 ) nls? ( virtual/libintl )
SLOT=0
SRC_URI=https://www.kernel.org/pub/linux/kernel/people/tytso/e2fsprogs/v1.45.6/e2fsprogs-1.45.6.tar.xz elibc_mintlib? ( mirror://gentoo/e2fsprogs-1.42.9-mint-r1.patch.xz )
_eclasses_=eutils	fcb2aa98e1948b835b5ae66ca52868c5	flag-o-matic	5d5921a298e95441da2f85be419894c0	multilib	2477ebe553d3e4d2c606191fe6c33602	systemd	71fd8d2065d102753fb9e4d20eaf3e9f	toolchain-funcs	f783d68a26b62d6b19e070e6bcada5e6	udev	452708c3f55cf6e918b045adb949a9e6	usr-ldscript	766f0a506b45f02361ad1b8ca205b7e1
_md5_=a7fcff8ac3e032570f7d69ad3ca2e65d
