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.5 >=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.5 >=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=mirror://sourceforge/e2fsprogs/e2fsprogs-1.45.5.tar.xz https://www.kernel.org/pub/linux/kernel/people/tytso/e2fsprogs/v1.45.5/e2fsprogs-1.45.5.tar.xz elibc_mintlib? ( mirror://gentoo/e2fsprogs-1.42.9-mint-r1.patch.xz )
_eclasses_=eutils	06133990e861be0fe60c2b428fd025d9	flag-o-matic	5d5921a298e95441da2f85be419894c0	multilib	2477ebe553d3e4d2c606191fe6c33602	systemd	71fd8d2065d102753fb9e4d20eaf3e9f	toolchain-funcs	605c126bed8d87e4378d5ff1645330cb	udev	452708c3f55cf6e918b045adb949a9e6	usr-ldscript	766f0a506b45f02361ad1b8ca205b7e1
_md5_=9822dad9c7eeee2a23be335b56fc1e3c
