DEFINED_PHASES=compile configure install prepare
DEPEND=~sys-libs/e2fsprogs-libs-1.43 >=sys-apps/util-linux-2.16 fuse? ( sys-fs/fuse ) nls? ( virtual/libintl ) nls? ( sys-devel/gettext ) virtual/pkgconfig sys-apps/texinfo
DESCRIPTION=Standard EXT2/EXT3/EXT4 filesystem utilities
EAPI=5
HOMEPAGE=http://e2fsprogs.sourceforge.net/
IUSE=fuse nls static-libs elibc_FreeBSD
KEYWORDS=*
LICENSE=GPL-2 BSD
RDEPEND=~sys-libs/e2fsprogs-libs-1.43 >=sys-apps/util-linux-2.16 fuse? ( sys-fs/fuse ) nls? ( virtual/libintl )
SLOT=0
SRC_URI=mirror://sourceforge/e2fsprogs/e2fsprogs-1.43.tar.xz mirror://kernel/linux/kernel/people/tytso/e2fsprogs/v1.43/e2fsprogs-1.43.tar.xz elibc_mintlib? ( mirror://gentoo/e2fsprogs-1.42.9-mint-r1.patch.xz )
_eclasses_=eutils	06133990e861be0fe60c2b428fd025d9	flag-o-matic	5d5921a298e95441da2f85be419894c0	multilib	3bf24e6abb9b76d9f6c20600f0b716bf	toolchain-funcs	48b38a216afb92db6314d6c3187abea3
_md5_=928d240a7d363b62f8cd6d2fd71247a2
