diff --git a/metadata/md5-cache/app-admin/eselect-1.3.1 b/metadata/md5-cache/app-admin/eselect-1.3.1
index de895f3..7c8ae53 100644
--- a/metadata/md5-cache/app-admin/eselect-1.3.1
+++ b/metadata/md5-cache/app-admin/eselect-1.3.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/proj/en/eselect/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=!app-admin/eselect-news sys-apps/sed || ( sys-apps/coreutils sys-freebsd/freebsd-bin app-misc/realpath ) sys-apps/file sys-libs/ncurses
 SLOT=0
 SRC_URI=mirror://gentoo/eselect-1.3.1.tar.xz
 _eclasses_=bash-completion-r1	3480f8385cb9e31797e7b659e366e2d2
-_md5_=817cb900adbf524e965d7024cd709abd
+_md5_=c061a684bbf6171c79ee41a613bbc8ef
diff --git a/metadata/md5-cache/app-admin/eselect-ctags-1.13 b/metadata/md5-cache/app-admin/eselect-ctags-1.13
index 1f7cd44..73466ee 100644
--- a/metadata/md5-cache/app-admin/eselect-ctags-1.13
+++ b/metadata/md5-cache/app-admin/eselect-ctags-1.13
@@ -1,9 +1,9 @@
 DEFINED_PHASES=compile install
 DESCRIPTION=Manages ctags implementations
 HOMEPAGE=http://www.gentoo.org/proj/en/lisp/emacs/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=app-admin/eselect-1.2.3 !<=app-admin/eselect-emacs-1.3
 SLOT=0
 SRC_URI=mirror://gentoo/eselect-emacs-1.13.tar.bz2
-_md5_=515a0c53900be9a035ce7ef40ac3b83a
+_md5_=f7fae61d7898420233eb394efa8a0646
diff --git a/metadata/md5-cache/app-admin/eselect-emacs-1.13 b/metadata/md5-cache/app-admin/eselect-emacs-1.13
index fd9bcc9..a155f29 100644
--- a/metadata/md5-cache/app-admin/eselect-emacs-1.13
+++ b/metadata/md5-cache/app-admin/eselect-emacs-1.13
@@ -1,9 +1,9 @@
 DEFINED_PHASES=install
 DESCRIPTION=Manage multiple Emacs versions on one system
 HOMEPAGE=http://www.gentoo.org/proj/en/lisp/emacs/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=app-admin/eselect-1.2.6 ~app-admin/eselect-ctags-1.13
 SLOT=0
 SRC_URI=mirror://gentoo/eselect-emacs-1.13.tar.bz2
-_md5_=25784aaa147254ba957d8a8b50e5ac92
+_md5_=b6d925d28f3d74bef45bebef3a4d8ddb
diff --git a/metadata/md5-cache/app-admin/eselect-fontconfig-1.0 b/metadata/md5-cache/app-admin/eselect-fontconfig-1.0
index 18fe66d..ccbbfc5 100644
--- a/metadata/md5-cache/app-admin/eselect-fontconfig-1.0
+++ b/metadata/md5-cache/app-admin/eselect-fontconfig-1.0
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=An eselect module to manage /etc/fonts/conf.d symlinks.
 HOMEPAGE=http://www.gentoo.org
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=app-admin/eselect >=media-libs/fontconfig-2.4
 SLOT=0
-_md5_=64e8c9d7f0ac280964a1c85df3c8f2ba
+_md5_=23047b8903df02c4b31ca7d81a941c7f
diff --git a/metadata/md5-cache/app-admin/eselect-opengl-1.2.4 b/metadata/md5-cache/app-admin/eselect-opengl-1.2.4
index c2b8dba..40c0bf2 100644
--- a/metadata/md5-cache/app-admin/eselect-opengl-1.2.4
+++ b/metadata/md5-cache/app-admin/eselect-opengl-1.2.4
@@ -3,10 +3,10 @@
 DESCRIPTION=Utility to change the OpenGL interface being used
 EAPI=4
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=app-admin/eselect-1.2.4
 SLOT=0
 SRC_URI=http://dev.gentooexperimental.org/~scarabeus//glext.h.67.xz http://dev.gentooexperimental.org/~scarabeus//glxext.h.32.xz mirror://gentoo/eselect-opengl-1.2.4.tar.xz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=149b77cd327a06286ef082333d6d6c16
+_md5_=98eea34007bd9b631fff52db170f5804
diff --git a/metadata/md5-cache/app-admin/eselect-python-20100321 b/metadata/md5-cache/app-admin/eselect-python-20100321
index be3d3e3..5f0faec 100644
--- a/metadata/md5-cache/app-admin/eselect-python-20100321
+++ b/metadata/md5-cache/app-admin/eselect-python-20100321
@@ -3,10 +3,10 @@
 DESCRIPTION=Eselect module for management of multiple Python versions
 EAPI=1
 HOMEPAGE=http://www.gentoo.org
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=>=app-admin/eselect-1.2.3
 SLOT=0
 SRC_URI=mirror://gentoo/eselect-python-20100321.tar.bz2
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=0c526d77eb02783dc3bbe8963f14a878
+_md5_=8cca6ea687abb001f6c0f45222d66c66
diff --git a/metadata/md5-cache/app-admin/eselect-vi-1.1.7-r1 b/metadata/md5-cache/app-admin/eselect-vi-1.1.7-r1
index 6ef2dac..7e8073c 100644
--- a/metadata/md5-cache/app-admin/eselect-vi-1.1.7-r1
+++ b/metadata/md5-cache/app-admin/eselect-vi-1.1.7-r1
@@ -2,10 +2,10 @@
 DESCRIPTION=Manages the /usr/bin/vi symlink
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=app-admin/eselect-1.0.6
 SLOT=0
 SRC_URI=mirror://gentoo/vi.eselect-1.1.7.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a7b002e5c7aca686ce80c6ae0c276c95
+_md5_=c4171ab1d20af5f5740890afe8e7e119
diff --git a/metadata/md5-cache/app-admin/perl-cleaner-2.7 b/metadata/md5-cache/app-admin/perl-cleaner-2.7
index 94c59b4..6e8c992 100644
--- a/metadata/md5-cache/app-admin/perl-cleaner-2.7
+++ b/metadata/md5-cache/app-admin/perl-cleaner-2.7
@@ -2,9 +2,9 @@
 DEPEND=app-shells/bash
 DESCRIPTION=User land tool for cleaning up old perl installs
 HOMEPAGE=http://www.gentoo.org/proj/en/perl/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=app-shells/bash dev-lang/perl
 SLOT=0
 SRC_URI=mirror://gentoo/perl-cleaner-2.7.tar.bz2 http://dev.gentoo.org/~tove/files/perl-cleaner-2.7.tar.bz2
-_md5_=2daf132d1d4634d7cd1ecbeae5ff8aea
+_md5_=f01bd2aaa4b17dcb138f52d656f87428
diff --git a/metadata/md5-cache/app-admin/python-updater-0.10 b/metadata/md5-cache/app-admin/python-updater-0.10
index 0b8fd6c..3485e79 100644
--- a/metadata/md5-cache/app-admin/python-updater-0.10
+++ b/metadata/md5-cache/app-admin/python-updater-0.10
@@ -1,9 +1,9 @@
 DEFINED_PHASES=compile install
 DESCRIPTION=Script used to reinstall Python packages after changing of active Python versions
 HOMEPAGE=http://www.gentoo.org/proj/en/Python/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=dev-lang/python || ( >=sys-apps/portage-2.1.6 >=sys-apps/paludis-0.56.0 )
 SLOT=0
 SRC_URI=http://people.apache.org/~Arfrever/gentoo/python-updater-0.10.tar.bz2
-_md5_=c07fae21349cc8d1fae296be252f1189
+_md5_=049fe86de6815041ac2ea85324cd29bb
diff --git a/metadata/md5-cache/app-admin/rsyslog-3.22.1 b/metadata/md5-cache/app-admin/rsyslog-3.22.1
index f14a28f..dab0563 100644
--- a/metadata/md5-cache/app-admin/rsyslog-3.22.1
+++ b/metadata/md5-cache/app-admin/rsyslog-3.22.1
@@ -4,7 +4,7 @@
 EAPI=2
 HOMEPAGE=http://www.rsyslog.com/
 IUSE=debug kerberos dbi gnutls mysql postgres relp snmp zlib
-KEYWORDS=~amd64 ~arm ~hppa ~sparc ~x86
+KEYWORDS=~amd64 ~arm hppa sparc ~x86
 LICENSE=GPL-3 LGPL-3
 PROVIDE=virtual/logger
 RDEPEND=kerberos? ( virtual/krb5 ) dbi? ( dev-db/libdbi ) gnutls? ( net-libs/gnutls ) mysql? ( virtual/mysql ) postgres? ( virtual/postgresql-base ) relp? ( >=dev-libs/librelp-0.1.1 ) snmp? ( net-analyzer/net-snmp ) zlib? ( sys-libs/zlib )
@@ -12,4 +12,4 @@
 SLOT=0
 SRC_URI=http://download.rsyslog.com/rsyslog/rsyslog-3.22.1.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=6f1f6d0204325399230da12d411ef033
+_md5_=e6426337dc196feab78f67476d207718
diff --git a/metadata/md5-cache/app-admin/rsyslog-5.8.11 b/metadata/md5-cache/app-admin/rsyslog-5.8.11
index 8d11d07..ee81109 100644
--- a/metadata/md5-cache/app-admin/rsyslog-5.8.11
+++ b/metadata/md5-cache/app-admin/rsyslog-5.8.11
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.rsyslog.com/
 IUSE=dbi debug doc extras kerberos mysql oracle postgres relp snmp ssl static-libs zeromq zlib
-KEYWORDS=amd64 arm ~hppa x86
+KEYWORDS=amd64 arm hppa x86
 LICENSE=GPL-3 LGPL-3 Apache-2.0
 RDEPEND=dbi? ( dev-db/libdbi ) extras? ( net-libs/libnet ) kerberos? ( virtual/krb5 ) mysql? ( virtual/mysql ) postgres? ( dev-db/postgresql-base ) oracle? ( dev-db/oracle-instantclient-basic ) relp? ( >=dev-libs/librelp-0.1.3 ) snmp? ( net-analyzer/net-snmp ) ssl? ( net-libs/gnutls dev-libs/libgcrypt ) zeromq? ( net-libs/zeromq ) zlib? ( sys-libs/zlib )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://www.rsyslog.com/files/download/rsyslog/rsyslog-5.8.11.tar.gz zeromq? ( https://github.com/aggregateknowledge/rsyslog-zeromq/tarball/44b551abc29dd5b541884bd51b45b413855a93d8 -> rsyslog-zeromq.tar.gz )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	systemd	b5da52630b2559da43198bfb56ccacba	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=05d5a9f41a21bc9c0ec0c7233f165bc9
+_md5_=878bdbdf584c9cc5642bf9f563dc4e45
diff --git a/metadata/md5-cache/app-admin/sudo-1.8.6_p7 b/metadata/md5-cache/app-admin/sudo-1.8.6_p7
index 240b82f..3b92023 100644
--- a/metadata/md5-cache/app-admin/sudo-1.8.6_p7
+++ b/metadata/md5-cache/app-admin/sudo-1.8.6_p7
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.sudo.ws/
 IUSE=ldap nls pam offensive selinux skey
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~sparc-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~sparc-solaris
 LICENSE=ISC BSD
 RDEPEND=pam? ( virtual/pam ) skey? ( >=sys-auth/skey-1.1.5-r1 ) ldap? ( >=net-nds/openldap-2.1.30-r1 dev-libs/cyrus-sasl ) sys-libs/zlib selinux? ( sec-policy/selinux-sudo ) ldap? ( dev-lang/perl ) pam? ( sys-auth/pambase ) >=app-misc/editor-wrapper-3 virtual/editor virtual/mta
 REQUIRED_USE=pam? ( !skey ) skey? ( !pam )
 SLOT=0
 SRC_URI=http://www.sudo.ws/sudo/dist/sudo-1.8.6p7.tar.gz ftp://ftp.sudo.ws/pub/sudo/sudo-1.8.6p7.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	pam	3f746974e1cc47cabe3bd488c08cdc8e	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c0bf319eef8e20605424cadf352136eb
+_md5_=7f201ce37160a5a7cb0d22c41636630f
diff --git a/metadata/md5-cache/app-admin/webapp-config-1.50.16-r4 b/metadata/md5-cache/app-admin/webapp-config-1.50.16-r4
index 821306a..4b058d6 100644
--- a/metadata/md5-cache/app-admin/webapp-config-1.50.16-r4
+++ b/metadata/md5-cache/app-admin/webapp-config-1.50.16-r4
@@ -3,10 +3,10 @@
 DESCRIPTION=Gentoo's installer for web-based applications
 EAPI=3
 HOMEPAGE=http://sourceforge.net/projects/webapp-config/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=>=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=mirror://gentoo/webapp-config-1.50.16.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2c4c1586b6bbd6463058103b4a4c3dab
+_md5_=a1f9fcf1d49eefcebc838b08cd516931
diff --git a/metadata/md5-cache/app-arch/bzip2-1.0.6-r3 b/metadata/md5-cache/app-arch/bzip2-1.0.6-r3
index d1d5900..b54d689 100644
--- a/metadata/md5-cache/app-arch/bzip2-1.0.6-r3
+++ b/metadata/md5-cache/app-arch/bzip2-1.0.6-r3
@@ -3,9 +3,9 @@
 EAPI=2
 HOMEPAGE=http://www.bzip.org/
 IUSE=static static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ~ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=BZIP2
 SLOT=0
 SRC_URI=http://www.bzip.org/1.0.6/bzip2-1.0.6.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a5b82bb3c4c68c4f31155e5f89dc7761
+_md5_=1ac3e41d9a6548cb6c9259994f221823
diff --git a/metadata/md5-cache/app-arch/cabextract-1.4 b/metadata/md5-cache/app-arch/cabextract-1.4
index fe289c5..da34061 100644
--- a/metadata/md5-cache/app-arch/cabextract-1.4
+++ b/metadata/md5-cache/app-arch/cabextract-1.4
@@ -3,9 +3,9 @@
 EAPI=4
 HOMEPAGE=http://www.cabextract.org.uk/
 IUSE=extra-tools
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=extra-tools? ( dev-lang/perl )
 SLOT=0
 SRC_URI=http://www.cabextract.org.uk/cabextract-1.4.tar.gz
-_md5_=f03414625584437b0789e313286221fe
+_md5_=851bf3799364567fc5df993e6aeffdfe
diff --git a/metadata/md5-cache/app-arch/cpio-2.11 b/metadata/md5-cache/app-arch/cpio-2.11
index 7f0eb5a..76af05e 100644
--- a/metadata/md5-cache/app-arch/cpio-2.11
+++ b/metadata/md5-cache/app-arch/cpio-2.11
@@ -3,9 +3,9 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/cpio/cpio.html
 IUSE=nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 SLOT=0
 SRC_URI=mirror://gnu/cpio/cpio-2.11.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=80e1d04510bf0d404d46a3d4c0119a43
+_md5_=52d853cd02357517746c5b63ccd962ea
diff --git a/metadata/md5-cache/app-arch/gzip-1.5 b/metadata/md5-cache/app-arch/gzip-1.5
index 5569854..d019b1d 100644
--- a/metadata/md5-cache/app-arch/gzip-1.5
+++ b/metadata/md5-cache/app-arch/gzip-1.5
@@ -3,9 +3,9 @@
 DESCRIPTION=Standard GNU compressor
 HOMEPAGE=http://www.gnu.org/software/gzip/
 IUSE=nls pic static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 SLOT=0
 SRC_URI=mirror://gnu-alpha/gzip/gzip-1.5.tar.xz mirror://gnu/gzip/gzip-1.5.tar.xz mirror://gentoo/gzip-1.5.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	unpacker	50e1227854e96469a19a63f053496328	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a6203e65eabde664ff8a2fe3e39922ff
+_md5_=042b2d421244f72f446e9d03b24ca9ca
diff --git a/metadata/md5-cache/app-arch/lzop-1.03 b/metadata/md5-cache/app-arch/lzop-1.03
index f7a9c40..f9bbb3d 100644
--- a/metadata/md5-cache/app-arch/lzop-1.03
+++ b/metadata/md5-cache/app-arch/lzop-1.03
@@ -3,9 +3,9 @@
 DESCRIPTION=Utility for fast (even real-time) compression/decompression
 EAPI=2
 HOMEPAGE=http://www.lzop.org/
-KEYWORDS=amd64 arm hppa ia64 ~mips ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=dev-libs/lzo-2
 SLOT=0
 SRC_URI=http://www.lzop.org/download/lzop-1.03.tar.gz
-_md5_=5427508dd0750d74b6a420b8c9a6f715
+_md5_=9cbb3d07c192320e1a70107945f11b6b
diff --git a/metadata/md5-cache/app-arch/pigz-2.2.5 b/metadata/md5-cache/app-arch/pigz-2.2.5
index c4c7d36..183c8fb 100644
--- a/metadata/md5-cache/app-arch/pigz-2.2.5
+++ b/metadata/md5-cache/app-arch/pigz-2.2.5
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.zlib.net/pigz/
 IUSE=static symlink test
-KEYWORDS=~alpha amd64 ~mips ~sparc x86 ~amd64-linux ~sparc64-solaris
+KEYWORDS=alpha amd64 mips sparc x86 ~amd64-linux ~sparc64-solaris
 LICENSE=ZLIB
 RDEPEND=!static? ( sys-libs/zlib )
 SLOT=0
 SRC_URI=http://www.zlib.net/pigz/pigz-2.2.5.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ca02bfd6cff22eb1f4df4a034e2b2cff
+_md5_=cd9d87979aff597867cdcba03fb4a113
diff --git a/metadata/md5-cache/app-arch/rpm2targz-9.0.0.4g b/metadata/md5-cache/app-arch/rpm2targz-9.0.0.4g
index c125866..8e26a08 100644
--- a/metadata/md5-cache/app-arch/rpm2targz-9.0.0.4g
+++ b/metadata/md5-cache/app-arch/rpm2targz-9.0.0.4g
@@ -2,10 +2,10 @@
 DEPEND=app-arch/xz-utils
 DESCRIPTION=Convert a .rpm file to a .tar.gz archive
 HOMEPAGE=http://www.slackware.com/config/packages.php
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=as-is
 RDEPEND=app-arch/cpio
 SLOT=0
 SRC_URI=mirror://gentoo/rpm2targz-9.0.0.4g.tar.lzma
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=358c728354094790e8702435e3b5cf19
+_md5_=23023b7ad2d936012abbb150ebdd7b94
diff --git a/metadata/md5-cache/app-arch/sharutils-4.7 b/metadata/md5-cache/app-arch/sharutils-4.7
index 8bdabec..412f306 100644
--- a/metadata/md5-cache/app-arch/sharutils-4.7
+++ b/metadata/md5-cache/app-arch/sharutils-4.7
@@ -3,10 +3,10 @@
 DESCRIPTION=Tools to deal with shar archives
 HOMEPAGE=http://www.gnu.org/software/sharutils/
 IUSE=nls
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-3
 RDEPEND=sys-apps/texinfo nls? ( >=sys-devel/gettext-0.10.35 )
 SLOT=0
 SRC_URI=mirror://gnu/sharutils/REL-4.7/sharutils-4.7.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=37eb27edf8649967bdc23871d76f5d4f
+_md5_=fc1e26499eed6ee835202f020f48e32e
diff --git a/metadata/md5-cache/app-arch/unrar-4.2.4 b/metadata/md5-cache/app-arch/unrar-4.2.4
index a4084fd..1bc01d0 100644
--- a/metadata/md5-cache/app-arch/unrar-4.2.4
+++ b/metadata/md5-cache/app-arch/unrar-4.2.4
@@ -2,10 +2,10 @@
 DESCRIPTION=Uncompress rar files
 EAPI=4
 HOMEPAGE=http://www.rarlab.com/rar_add.htm
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=unRAR
 RDEPEND=!<=app-arch/unrar-gpl-0.0.1_p20080417
 SLOT=0
 SRC_URI=http://www.rarlab.com/rar/unrarsrc-4.2.4.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=afb7bf5ce4ca3478e7eb204a50c52ccf
+_md5_=07bdbaab83752cbc98ffddc4aa70a873
diff --git a/metadata/md5-cache/app-arch/unzip-6.0-r1 b/metadata/md5-cache/app-arch/unzip-6.0-r1
index 08aedd5..e753420 100644
--- a/metadata/md5-cache/app-arch/unzip-6.0-r1
+++ b/metadata/md5-cache/app-arch/unzip-6.0-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=unzipper for pkzip-compressed files
 HOMEPAGE=http://www.info-zip.org/
 IUSE=bzip2 unicode
-KEYWORDS=~alpha amd64 arm hppa ~ia64 m68k ~ppc ppc64 s390 sh ~sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k ppc ppc64 s390 sh sparc x86
 LICENSE=Info-ZIP
 RDEPEND=bzip2? ( app-arch/bzip2 )
 SLOT=0
 SRC_URI=mirror://sourceforge/infozip/unzip60.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=857f3b89bd5ed59207a08ae884bf7020
+_md5_=d4f5e044df980e17981c20901e220da6
diff --git a/metadata/md5-cache/app-arch/xz-utils-4.999.9_beta b/metadata/md5-cache/app-arch/xz-utils-4.999.9_beta
index e426622..b4a0cb3 100644
--- a/metadata/md5-cache/app-arch/xz-utils-4.999.9_beta
+++ b/metadata/md5-cache/app-arch/xz-utils-4.999.9_beta
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://tukaani.org/xz/
 IUSE=nls static-libs +threads
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 ~s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=LGPL-2.1
 RDEPEND=!app-arch/lzma !app-arch/lzma-utils !<app-arch/p7zip-4.57
 SLOT=0
 SRC_URI=http://tukaani.org/xz/xz-4.999.9beta.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2bd0dc965b6866b98546c4db4d45ece4
+_md5_=0879554c26e695042b33bb95f51566f7
diff --git a/metadata/md5-cache/app-arch/zip-3.0 b/metadata/md5-cache/app-arch/zip-3.0
index d8dd668..ac3b04a 100644
--- a/metadata/md5-cache/app-arch/zip-3.0
+++ b/metadata/md5-cache/app-arch/zip-3.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Info ZIP (encryption support)
 HOMEPAGE=http://www.info-zip.org/
 IUSE=bzip2 crypt unicode
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=Info-ZIP
 RDEPEND=bzip2? ( app-arch/bzip2 )
 SLOT=0
 SRC_URI=mirror://sourceforge/infozip/zip30.zip
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e3a9afc7286f4317ee1bc228279ff288
+_md5_=56f003e791f43b038079d53697ee2f4c
diff --git a/metadata/md5-cache/app-crypt/mit-krb5-1.9.2-r2 b/metadata/md5-cache/app-crypt/mit-krb5-1.9.2-r2
index 9bcd6dd..8f38461 100644
--- a/metadata/md5-cache/app-crypt/mit-krb5-1.9.2-r2
+++ b/metadata/md5-cache/app-crypt/mit-krb5-1.9.2-r2
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://web.mit.edu/kerberos/www/
 IUSE=doc +keyutils openldap +pkinit +threads test xinetd
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=as-is
 RDEPEND=!!app-crypt/heimdal >=sys-libs/e2fsprogs-libs-1.41.0 keyutils? ( sys-apps/keyutils ) openldap? ( net-nds/openldap ) xinetd? ( sys-apps/xinetd )
 SLOT=0
 SRC_URI=http://web.mit.edu/kerberos/dist/krb5/1.9/krb5-1.9.2-signed.tar
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=292c6a2149db45bad9867d8004a9c277
+_md5_=a56e57cbc9a4ef546d2eac217c56350a
diff --git a/metadata/md5-cache/app-editors/emacs-23.3-r2 b/metadata/md5-cache/app-editors/emacs-23.3-r2
index 26e8a03..5c017a2 100644
--- a/metadata/md5-cache/app-editors/emacs-23.3-r2
+++ b/metadata/md5-cache/app-editors/emacs-23.3-r2
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.gnu.org/software/emacs/
 IUSE=alsa aqua athena dbus gconf gif gpm gtk gzip-el hesiod jpeg kerberos livecd m17n-lib motif png sound source svg tiff toolkit-scroll-bars X Xaw3d xft +xpm
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ~ppc ~ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-3 FDL-1.3 BSD as-is MIT W3C unicode PSF-2
 RDEPEND=sys-libs/ncurses >=app-admin/eselect-emacs-1.2 net-libs/liblockfile hesiod? ( net-dns/hesiod ) kerberos? ( virtual/krb5 ) alsa? ( media-libs/alsa-lib ) gpm? ( sys-libs/gpm ) dbus? ( sys-apps/dbus ) X? ( x11-libs/libXmu x11-libs/libXt x11-misc/xbitmaps gconf? ( >=gnome-base/gconf-2.26.2 ) gif? ( media-libs/giflib ) jpeg? ( virtual/jpeg ) png? ( >=media-libs/libpng-1.4:0 ) svg? ( >=gnome-base/librsvg-2.0 ) tiff? ( media-libs/tiff ) xpm? ( x11-libs/libXpm ) xft? ( media-libs/fontconfig media-libs/freetype x11-libs/libXft m17n-lib? ( >=dev-libs/libotf-0.9.4 >=dev-libs/m17n-lib-1.5.1 ) ) gtk? ( x11-libs/gtk+:2 ) !gtk? ( Xaw3d? ( x11-libs/libXaw3d ) !Xaw3d? ( athena? ( x11-libs/libXaw ) !athena? ( motif? ( >=x11-libs/openmotif-2.3:0 ) ) ) ) ) !<app-editors/emacs-vcs-23.3 >=app-emacs/emacs-common-gentoo-1[X?]
 REQUIRED_USE=aqua? ( !X )
 SLOT=23
 SRC_URI=mirror://gnu/emacs/emacs-23.3a.tar.bz2 mirror://gentoo/emacs-23.3-patches-1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=29123e0cb0450f086e4afc7eb98dd29d
+_md5_=8e34986c04ee5b6103d7211c07e3864f
diff --git a/metadata/md5-cache/app-editors/vim-7.3.409 b/metadata/md5-cache/app-editors/vim-7.3.409
index 0c481e6..f54568f 100644
--- a/metadata/md5-cache/app-editors/vim-7.3.409
+++ b/metadata/md5-cache/app-editors/vim-7.3.409
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://www.vim.org/
 IUSE=bash-completion nls acl cscope debug gpm perl python ruby X minimal vim-pager
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=vim
 PDEPEND=bash-completion? ( app-shells/bash-completion )
 RDEPEND=bash-completion? ( app-admin/eselect ) >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* ) python? ( =dev-lang/python-2*[threads] ) >=app-admin/eselect-vi-1.1 >=sys-libs/ncurses-5.2-r2 nls? ( virtual/libintl ) cscope? ( dev-util/cscope ) gpm? ( >=sys-libs/gpm-1.19.3 ) perl? ( dev-lang/perl ) acl? ( kernel_linux? ( sys-apps/acl ) ) ruby? ( =dev-lang/ruby-1.8* ) !<app-vim/align-30-r1 !app-vim/vimspell !<app-vim/vimbuddy-0.9.1-r1 !<app-vim/autoalign-11 !<app-vim/supertab-0.41 X? ( x11-libs/libXt ) !minimal? ( ~app-editors/vim-core-7.3.409 dev-util/ctags ) !<app-editors/nvi-1.81.5-r4
 SLOT=0
 SRC_URI=ftp://ftp.vim.org/pub/vim/unix/vim-7.3.tar.bz2 http://dev.gentoo.org/~lack/vim/vim-patches-7.3.409.patch.bz2
 _eclasses_=bash-completion	f0fab76a98c0e4b3d72b6beb28d3f653	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	prefix	21058c21ca48453d771df15500873ede	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	vim	e85238aa6257d0fc3529af5ef64ada23	vim-doc	6bd5bb2529af326fe3359e975a3439d0
-_md5_=973bcc3a7990f954bff68f82a5b32461
+_md5_=fc77df56b63bd79c6ec6ee5c1792e0f3
diff --git a/metadata/md5-cache/app-editors/vim-core-7.3.409 b/metadata/md5-cache/app-editors/vim-core-7.3.409
index 3ab44f6..874bf04 100644
--- a/metadata/md5-cache/app-editors/vim-core-7.3.409
+++ b/metadata/md5-cache/app-editors/vim-core-7.3.409
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://www.vim.org/
 IUSE=bash-completion nls acl livecd
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=vim
 PDEPEND=bash-completion? ( app-shells/bash-completion ) !livecd? ( app-vim/gentoo-syntax )
 RDEPEND=bash-completion? ( app-admin/eselect ) >=app-admin/eselect-python-20091230 >=app-admin/eselect-vi-1.1 >=sys-libs/ncurses-5.2-r2 nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=ftp://ftp.vim.org/pub/vim/unix/vim-7.3.tar.bz2 http://dev.gentoo.org/~lack/vim/vim-core-7.3-gentoo-patches-r1.tar.bz2 http://dev.gentoo.org/~lack/vim/vim-patches-7.3.409.patch.bz2
 _eclasses_=bash-completion	f0fab76a98c0e4b3d72b6beb28d3f653	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	prefix	21058c21ca48453d771df15500873ede	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	vim	e85238aa6257d0fc3529af5ef64ada23	vim-doc	6bd5bb2529af326fe3359e975a3439d0
-_md5_=dcf96d6f244e9f634fa7e0ece7008d87
+_md5_=d015e35a9129ee290a818d6b885ea47e
diff --git a/metadata/md5-cache/app-emacs/emacs-common-gentoo-1.3-r1 b/metadata/md5-cache/app-emacs/emacs-common-gentoo-1.3-r1
index 7238f05..517a438 100644
--- a/metadata/md5-cache/app-emacs/emacs-common-gentoo-1.3-r1
+++ b/metadata/md5-cache/app-emacs/emacs-common-gentoo-1.3-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.gentoo.org/proj/en/lisp/emacs/
 IUSE=X emacs22icons
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-3
 PDEPEND=virtual/emacs
 SLOT=0
 SRC_URI=mirror://gentoo/emacs-common-gentoo-1.3.tar.gz
 _eclasses_=elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome2-utils	794d2847b4af390a1e020924876c8297	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=45c6d8f0a4e471badd4865b31571cf71
+_md5_=7162c067d5b9fa5507ed08954c037327
diff --git a/metadata/md5-cache/app-misc/ckermit-8.0.211-r4 b/metadata/md5-cache/app-misc/ckermit-8.0.211-r4
index 3015d0c..ea54360 100644
--- a/metadata/md5-cache/app-misc/ckermit-8.0.211-r4
+++ b/metadata/md5-cache/app-misc/ckermit-8.0.211-r4
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.kermit-project.org/
 IUSE=ncurses
-KEYWORDS=amd64 arm ~hppa ppc ppc64 x86
+KEYWORDS=amd64 arm hppa ppc ppc64 x86
 LICENSE=Kermit
 RDEPEND=ncurses? ( >=sys-libs/ncurses-5.2 ) net-dialup/lrzsz
 SLOT=0
 SRC_URI=ftp://kermit.columbia.edu/kermit/archives/cku211.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=b2934b80e599c4367a9cdab3f55c9790
+_md5_=de4104bb4548f29717660291dabc6c55
diff --git a/metadata/md5-cache/app-misc/editor-wrapper-4 b/metadata/md5-cache/app-misc/editor-wrapper-4
index 13a1d3a..7c031b7 100644
--- a/metadata/md5-cache/app-misc/editor-wrapper-4
+++ b/metadata/md5-cache/app-misc/editor-wrapper-4
@@ -2,7 +2,7 @@
 DESCRIPTION=Wrapper scripts that will execute EDITOR or PAGER
 EAPI=4
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=MIT
 SLOT=0
-_md5_=ee90453669d3d94843fbd2e9cdfba7ac
+_md5_=e0ebcb1d1eab0f8207692fd5a2e6cb0f
diff --git a/metadata/md5-cache/app-misc/mc-4.8.10 b/metadata/md5-cache/app-misc/mc-4.8.10
index f744ffe..9f5a85e 100644
--- a/metadata/md5-cache/app-misc/mc-4.8.10
+++ b/metadata/md5-cache/app-misc/mc-4.8.10
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.midnight-commander.org
 IUSE=+edit gpm mclib nls samba sftp +slang spell test X +xdg
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x86-solaris
 LICENSE=GPL-3
 RDEPEND=>=dev-libs/glib-2.8:2 gpm? ( sys-libs/gpm ) kernel_linux? ( sys-fs/e2fsprogs ) samba? ( net-fs/samba ) sftp? ( net-libs/libssh2 ) slang? ( >=sys-libs/slang-2 ) !slang? ( sys-libs/ncurses ) spell? ( app-text/aspell ) X? ( x11-libs/libX11 x11-libs/libICE x11-libs/libXau x11-libs/libXdmcp x11-libs/libSM )
 REQUIRED_USE=spell? ( edit )
 SLOT=0
 SRC_URI=http://www.midnight-commander.org/downloads/mc-4.8.10.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=cfb3ce273fda15638cfc6ef591159a9a
+_md5_=61ba759cfc43c36041f6254d811ebce6
diff --git a/metadata/md5-cache/app-misc/mime-types-8 b/metadata/md5-cache/app-misc/mime-types-8
index a0b7c33..21f3b74 100644
--- a/metadata/md5-cache/app-misc/mime-types-8
+++ b/metadata/md5-cache/app-misc/mime-types-8
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=Provides /etc/mime.types file
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/mime-types-8.tar.bz2
-_md5_=41b441a95edf7c74135fc00a6fbe6e51
+_md5_=6f9fb97f167a1fc88206b92e2539161c
diff --git a/metadata/md5-cache/app-misc/pax-utils-0.4 b/metadata/md5-cache/app-misc/pax-utils-0.4
index e9a91d6..3596a87 100644
--- a/metadata/md5-cache/app-misc/pax-utils-0.4
+++ b/metadata/md5-cache/app-misc/pax-utils-0.4
@@ -3,10 +3,10 @@
 DESCRIPTION=ELF related utils for ELF 32/64 binaries that can check files for security relevant properties
 HOMEPAGE=http://hardened.gentoo.org/pax-utils.xml
 IUSE=caps
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=caps? ( sys-libs/libcap )
 SLOT=0
 SRC_URI=mirror://gentoo/pax-utils-0.4.tar.xz http://dev.gentoo.org/~solar/pax/pax-utils-0.4.tar.xz http://dev.gentoo.org/~vapier/dist/pax-utils-0.4.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	unpacker	50e1227854e96469a19a63f053496328	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=3f03b4b0b5d5cefd4fca8a4081a9ddb6
+_md5_=c18511d4b301163c4f21a80b6bc8fc45
diff --git a/metadata/md5-cache/app-misc/screen-4.0.3-r4 b/metadata/md5-cache/app-misc/screen-4.0.3-r4
index 58c458e..bc77722 100644
--- a/metadata/md5-cache/app-misc/screen-4.0.3-r4
+++ b/metadata/md5-cache/app-misc/screen-4.0.3-r4
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/screen/
 IUSE=debug nethack pam selinux multiuser
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~hppa-hpux ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~hppa-hpux ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=sys-libs/ncurses-5.2 pam? ( virtual/pam ) selinux? ( sec-policy/selinux-screen )
 SLOT=0
 SRC_URI=ftp://ftp.uni-erlangen.de/pub/utilities/screen/screen-4.0.3.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	pam	3f746974e1cc47cabe3bd488c08cdc8e	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a1c9d09a1f23751558d4361cd464184c
+_md5_=e1344d0e47222bb5ce905bf73bc71a6a
diff --git a/metadata/md5-cache/app-misc/tmux-1.6 b/metadata/md5-cache/app-misc/tmux-1.6
index 20170ef..d067b56 100644
--- a/metadata/md5-cache/app-misc/tmux-1.6
+++ b/metadata/md5-cache/app-misc/tmux-1.6
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://tmux.sourceforge.net
 IUSE=vim-syntax
-KEYWORDS=amd64 arm ~mips ~ppc ~ppc64 x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=amd64 arm mips ppc ppc64 x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=ISC
 RDEPEND=|| ( >=dev-libs/libevent-2.0.10 <dev-libs/libevent-2 ) sys-libs/ncurses vim-syntax? ( || ( app-editors/vim app-editors/gvim ) )
 SLOT=0
 SRC_URI=mirror://sourceforge/tmux/tmux-1.6.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=576c0ff85307d4f03266619286a3937c
+_md5_=99a597f3b7cb575fddd6f1d53d4d5158
diff --git a/metadata/md5-cache/app-office/dia-0.97.2 b/metadata/md5-cache/app-office/dia-0.97.2
index b6df14a..4f52876 100644
--- a/metadata/md5-cache/app-office/dia-0.97.2
+++ b/metadata/md5-cache/app-office/dia-0.97.2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://live.gnome.org/Dia
 IUSE=cairo doc gnome python debug
-KEYWORDS=~alpha amd64 ~hppa ~ia64 ~ppc ppc64 ~sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos
+KEYWORDS=alpha amd64 hppa ia64 ppc ppc64 sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos
 LICENSE=GPL-2
 RDEPEND=>=dev-libs/glib-2 dev-libs/libxml2 dev-libs/libxslt dev-libs/popt >=media-libs/freetype-2 >=media-libs/libart_lgpl-2 media-libs/libpng sys-libs/zlib x11-libs/gtk+:2 x11-libs/pango cairo? ( x11-libs/cairo ) doc? ( app-text/docbook-xml-dtd:4.5 app-text/docbook-xsl-stylesheets ) gnome? ( >=gnome-base/libgnome-2 >=gnome-base/libgnomeui-2 ) python? ( >=dev-python/pygtk-2 ) >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* )
 SLOT=0
 SRC_URI=mirror://gnome/sources/dia/0.97/dia-0.97.2.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=2db60ffb4930d47d82b037f4be70d861
+_md5_=1fb6582be42e5b022b83b01800a07a10
diff --git a/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r2 b/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r2
index 46e5e3e..1336aa1 100644
--- a/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r2
+++ b/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r2
@@ -3,10 +3,10 @@
 DESCRIPTION=Collection of administration scripts for Gentoo
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/proj/en/portage/tools/index.xml
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=sys-apps/portage >=dev-lang/python-2.6[xml] !>=dev-lang/python-2.6[-xml] !<=app-portage/gentoolkit-dev-0.2.7 || ( >=sys-apps/coreutils-8.15 app-misc/realpath sys-freebsd/freebsd-bin ) sys-apps/gawk sys-apps/grep virtual/python-argparse >=app-admin/eselect-python-20091230 dev-lang/python[xml] dev-lang/python >=app-admin/eselect-python-20091230 dev-lang/python[xml]
 SLOT=0
 SRC_URI=mirror://gentoo/gentoolkit-0.3.0.7.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=1b4820b372134d12b47272dff4a2cdc2
+_md5_=853d8389c954d23181f78f754e0dab38
diff --git a/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r3 b/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r3
index 46e5e3e..1336aa1 100644
--- a/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r3
+++ b/metadata/md5-cache/app-portage/gentoolkit-0.3.0.7-r3
@@ -3,10 +3,10 @@
 DESCRIPTION=Collection of administration scripts for Gentoo
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/proj/en/portage/tools/index.xml
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=sys-apps/portage >=dev-lang/python-2.6[xml] !>=dev-lang/python-2.6[-xml] !<=app-portage/gentoolkit-dev-0.2.7 || ( >=sys-apps/coreutils-8.15 app-misc/realpath sys-freebsd/freebsd-bin ) sys-apps/gawk sys-apps/grep virtual/python-argparse >=app-admin/eselect-python-20091230 dev-lang/python[xml] dev-lang/python >=app-admin/eselect-python-20091230 dev-lang/python[xml]
 SLOT=0
 SRC_URI=mirror://gentoo/gentoolkit-0.3.0.7.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=1b4820b372134d12b47272dff4a2cdc2
+_md5_=853d8389c954d23181f78f754e0dab38
diff --git a/metadata/md5-cache/app-portage/gentoolkit-dev-0.2.8 b/metadata/md5-cache/app-portage/gentoolkit-dev-0.2.8
index 1ca2dac..00e41f5 100644
--- a/metadata/md5-cache/app-portage/gentoolkit-dev-0.2.8
+++ b/metadata/md5-cache/app-portage/gentoolkit-dev-0.2.8
@@ -3,10 +3,10 @@
 DESCRIPTION=Collection of developer scripts for Gentoo
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/proj/en/portage/tools/index.xml
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=sys-apps/portage dev-lang/perl sys-apps/diffutils >=app-admin/eselect-python-20091230 || ( =dev-lang/python-3.2* =dev-lang/python-3.1* =dev-lang/python-2.7* =dev-lang/python-2.6* ) || ( =dev-lang/python-3.2*[xml] =dev-lang/python-3.1*[xml] =dev-lang/python-2.7*[xml] =dev-lang/python-2.6*[xml] )
 SLOT=0
 SRC_URI=mirror://gentoo/gentoolkit-dev-0.2.8.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=52c08a734a4249c45bea23161b8113a6
+_md5_=22fbcf49dbda67827fcdbd9ed178cd8d
diff --git a/metadata/md5-cache/app-portage/portage-utils-0.10 b/metadata/md5-cache/app-portage/portage-utils-0.10
index 4be6a7a..55413ac 100644
--- a/metadata/md5-cache/app-portage/portage-utils-0.10
+++ b/metadata/md5-cache/app-portage/portage-utils-0.10
@@ -3,9 +3,9 @@
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/
 IUSE=static
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/portage-utils-0.10.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b8f0f30fb9a2b0645fe5c4e6ef450543
+_md5_=b6a19c5c9ac2a501bb1210256fe3b328
diff --git a/metadata/md5-cache/app-shells/bash-4.2_p20 b/metadata/md5-cache/app-shells/bash-4.2_p20
index b904ec1..fec7d4e 100644
--- a/metadata/md5-cache/app-shells/bash-4.2_p20
+++ b/metadata/md5-cache/app-shells/bash-4.2_p20
@@ -4,10 +4,10 @@
 EAPI=1
 HOMEPAGE=http://tiswww.case.edu/php/chet/bash/bashtop.html
 IUSE=afs bashlogger examples mem-scramble +net nls plugins vanilla
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=>=sys-libs/ncurses-5.2-r2 >=sys-libs/readline-6.2 nls? ( virtual/libintl ) !<sys-apps/portage-2.1.7.16 !<sys-apps/paludis-0.26.0_alpha5
 SLOT=0
 SRC_URI=mirror://gnu/bash/bash-4.2.tar.gz ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-001 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-002 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-003 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-004 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-005 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-006 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-007 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-008 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-009 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-010 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-011 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-012 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-013 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-014 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-015 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-016 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-017 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-018 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-019 ftp://ftp.cwru.edu/pub/bash/bash-4.2-patches/bash42-020 mirror://gnu/bash/bash-4.2-patches/bash42-001 mirror://gnu/bash/bash-4.2-patches/bash42-002 mirror://gnu/bash/bash-4.2-patches/bash42-003 mirror://gnu/bash/bash-4.2-patches/bash42-004 mirror://gnu/bash/bash-4.2-patches/bash42-005 mirror://gnu/bash/bash-4.2-patches/bash42-006 mirror://gnu/bash/bash-4.2-patches/bash42-007 mirror://gnu/bash/bash-4.2-patches/bash42-008 mirror://gnu/bash/bash-4.2-patches/bash42-009 mirror://gnu/bash/bash-4.2-patches/bash42-010 mirror://gnu/bash/bash-4.2-patches/bash42-011 mirror://gnu/bash/bash-4.2-patches/bash42-012 mirror://gnu/bash/bash-4.2-patches/bash42-013 mirror://gnu/bash/bash-4.2-patches/bash42-014 mirror://gnu/bash/bash-4.2-patches/bash42-015 mirror://gnu/bash/bash-4.2-patches/bash42-016 mirror://gnu/bash/bash-4.2-patches/bash42-017 mirror://gnu/bash/bash-4.2-patches/bash42-018 mirror://gnu/bash/bash-4.2-patches/bash42-019 mirror://gnu/bash/bash-4.2-patches/bash42-020
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=60730591ff6c58c562e531ba0b144eb6
+_md5_=8c1956007739aa81fae9a3d30e1ee0e3
diff --git a/metadata/md5-cache/app-shells/bash-completion-1.3 b/metadata/md5-cache/app-shells/bash-completion-1.3
index fd3d87a..06b1e90 100644
--- a/metadata/md5-cache/app-shells/bash-completion-1.3
+++ b/metadata/md5-cache/app-shells/bash-completion-1.3
@@ -2,11 +2,11 @@
 DESCRIPTION=Programmable Completion for bash
 EAPI=3
 HOMEPAGE=http://bash-completion.alioth.debian.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris
 LICENSE=GPL-2
 PDEPEND=app-shells/gentoo-bashcomp
 RDEPEND=app-admin/eselect || ( >=app-shells/bash-3.2 app-shells/zsh ) sys-apps/miscfiles
 SLOT=0
 SRC_URI=http://bash-completion.alioth.debian.org/files/bash-completion-1.3.tar.bz2
 _eclasses_=prefix	21058c21ca48453d771df15500873ede
-_md5_=7151a8f38e11a8a226961e562dfc932a
+_md5_=2ca714146f60ca133aecf711d155d13a
diff --git a/metadata/md5-cache/app-shells/dash-0.5.5.1.7 b/metadata/md5-cache/app-shells/dash-0.5.5.1.7
index 7d9bbd1..069a4d7 100644
--- a/metadata/md5-cache/app-shells/dash-0.5.5.1.7
+++ b/metadata/md5-cache/app-shells/dash-0.5.5.1.7
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://gondor.apana.org.au/~herbert/dash/
 IUSE=libedit static
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86
 LICENSE=BSD
 RDEPEND=!static? ( libedit? ( dev-libs/libedit ) )
 SLOT=0
 SRC_URI=http://gondor.apana.org.au/~herbert/dash/files/dash-0.5.5.1.tar.gz mirror://debian/pool/main/d/dash/dash_0.5.5.1-7.diff.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=dde512f5af56741bb111e7997e19744d
+_md5_=eaf34a583742941b6590cc02a701085a
diff --git a/metadata/md5-cache/app-shells/gentoo-bashcomp-20101217 b/metadata/md5-cache/app-shells/gentoo-bashcomp-20101217
index 70e71c2..5dc2ccd 100644
--- a/metadata/md5-cache/app-shells/gentoo-bashcomp-20101217
+++ b/metadata/md5-cache/app-shells/gentoo-bashcomp-20101217
@@ -2,10 +2,10 @@
 DESCRIPTION=Gentoo-specific bash command-line completions (emerge, ebuild, equery, repoman, layman, etc)
 EAPI=3
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris
 LICENSE=GPL-2
 RDEPEND=app-shells/bash-completion
 SLOT=0
 SRC_URI=mirror://gentoo/gentoo-bashcomp-20101217.tar.bz2 http://dev.gentoo.org/~darkside/tmp/gentoo-bashcomp-20101217.tar.bz2
 _eclasses_=prefix	21058c21ca48453d771df15500873ede
-_md5_=b1db2ac5f29d8b0d9ba3db59140c9770
+_md5_=10b96c88736515b510fbebb6ae77e887
diff --git a/metadata/md5-cache/app-text/asciidoc-8.2.6 b/metadata/md5-cache/app-text/asciidoc-8.2.6
index 2973bca..2b4b1fc 100644
--- a/metadata/md5-cache/app-text/asciidoc-8.2.6
+++ b/metadata/md5-cache/app-text/asciidoc-8.2.6
@@ -3,9 +3,9 @@
 DESCRIPTION=A text document format for writing short documents, articles, books and UNIX man pages
 HOMEPAGE=http://www.methods.co.nz/asciidoc/
 IUSE=examples vim-syntax
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=>=virtual/python-2.3 dev-libs/libxslt
 SLOT=0
 SRC_URI=http://www.methods.co.nz/asciidoc/asciidoc-8.2.6.tar.gz
-_md5_=3356de7a720ec635c5099dbc9ce99fb9
+_md5_=14fdb9db8c97af8999ffbcdfe01e3d13
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-3.0-r3 b/metadata/md5-cache/app-text/docbook-sgml-dtd-3.0-r3
index 80e5198..e2fcd70 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-3.0-r3
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-3.0-r3
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 3.0
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=3.0
 SRC_URI=http://www.oasis-open.org/docbook/sgml/3.0/docbk30.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d74317af10157a636e3274c32d4fd063
+_md5_=51f66bc66467b24103f26a443f40606a
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-3.1-r3 b/metadata/md5-cache/app-text/docbook-sgml-dtd-3.1-r3
index b8d36b6..94bf3ce 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-3.1-r3
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-3.1-r3
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 3.1
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=3.1
 SRC_URI=http://www.oasis-open.org/docbook/sgml/3.1/docbk31.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=10bb1970ba0c625800d3e29377d8ff4b
+_md5_=13054265bea41ea4b21dac45d22bdf72
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.0-r3 b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.0-r3
index 40263ec..75396ec 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.0-r3
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.0-r3
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 4.0
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=4.0
 SRC_URI=http://www.oasis-open.org/docbook/sgml/4.0/docbk40.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=de72fbfe8b7f2c221cdef2f949c28fbb
+_md5_=ee32db4225795b974174074a823019e6
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.1-r3 b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.1-r3
index 398a8fd..b69a4ad 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.1-r3
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.1-r3
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 4.1
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=4.1
 SRC_URI=http://www.oasis-open.org/docbook/sgml/4.1/docbk41.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=94ccc532c64c515434d904f197e39914
+_md5_=4d3f14175cf6777f9a838ca247f23dc4
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.2-r2 b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.2-r2
index 5a0cab9..5ea309b 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.2-r2
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.2-r2
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 4.2
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=4.2
 SRC_URI=http://www.oasis-open.org/docbook/sgml/4.2/docbook-4.2.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8b7051a2d839f7ec3d1cd7fb0f657218
+_md5_=9d96e586d596ae725d342f9b27ffd5ab
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.3-r2 b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.3-r2
index 7cc7739..5ddf343 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.3-r2
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.3-r2
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 4.3
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=4.3
 SRC_URI=http://www.docbook.org/sgml/4.3/docbook-4.3.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2748623b7f1e0866fc4e70a7a3da7b4b
+_md5_=be6e61dd7e07c7eca6699184aa207bbe
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.4 b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.4
index 764f648..d9882b7 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.4
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.4
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 4.4
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=4.4
 SRC_URI=http://www.docbook.org/sgml/4.4/docbook-4.4.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6038353811a8d13c00a863954723110f
+_md5_=7f1483b94480f62f6d64876166bab408
diff --git a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.5 b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.5
index a02e05b..c4e0628 100644
--- a/metadata/md5-cache/app-text/docbook-sgml-dtd-4.5
+++ b/metadata/md5-cache/app-text/docbook-sgml-dtd-4.5
@@ -2,10 +2,10 @@
 DEPEND=>=app-arch/unzip-5.41 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook SGML DTD 4.5
 HOMEPAGE=http://www.docbook.org/sgml/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=as-is
 RDEPEND=app-text/sgml-common
 SLOT=4.5
 SRC_URI=http://www.docbook.org/sgml/4.5/docbook-4.5.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=4e6ca605fb0ab414de8e4d711f325892
+_md5_=5296726386a06e98d375ed2d249cbb27
diff --git a/metadata/md5-cache/app-text/docbook-xml-dtd-4.1.2-r6 b/metadata/md5-cache/app-text/docbook-xml-dtd-4.1.2-r6
index 881be66..4d55064 100644
--- a/metadata/md5-cache/app-text/docbook-xml-dtd-4.1.2-r6
+++ b/metadata/md5-cache/app-text/docbook-xml-dtd-4.1.2-r6
@@ -2,9 +2,9 @@
 DEPEND=>=app-arch/unzip-5.41 >=dev-libs/libxml2-2.4 >=app-text/docbook-xsl-stylesheets-1.65 >=app-text/build-docbook-catalog-1.2 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook DTD for XML
 HOMEPAGE=http://www.docbook.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=4.1.2
 SRC_URI=http://www.docbook.org/xml/4.1.2/docbkx412.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6550065abfd5d365b57e9ae0fd0a3cb0
+_md5_=68944027b619a85137e11d7de64d0b3c
diff --git a/metadata/md5-cache/app-text/docbook-xml-dtd-4.2-r2 b/metadata/md5-cache/app-text/docbook-xml-dtd-4.2-r2
index c1c5ae1..f86ac49 100644
--- a/metadata/md5-cache/app-text/docbook-xml-dtd-4.2-r2
+++ b/metadata/md5-cache/app-text/docbook-xml-dtd-4.2-r2
@@ -2,9 +2,9 @@
 DEPEND=>=app-arch/unzip-5.41 >=dev-libs/libxml2-2.4 >=app-text/docbook-xsl-stylesheets-1.65 >=app-text/build-docbook-catalog-1.2 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook DTD for XML
 HOMEPAGE=http://www.docbook.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=4.2
 SRC_URI=http://www.docbook.org/xml/4.2/docbook-xml-4.2.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d5e396eba1163378f0d990d85e2579e1
+_md5_=07d4652348873c89329af122d47fa39b
diff --git a/metadata/md5-cache/app-text/docbook-xml-dtd-4.3-r1 b/metadata/md5-cache/app-text/docbook-xml-dtd-4.3-r1
index 664734e..e642339 100644
--- a/metadata/md5-cache/app-text/docbook-xml-dtd-4.3-r1
+++ b/metadata/md5-cache/app-text/docbook-xml-dtd-4.3-r1
@@ -2,9 +2,9 @@
 DEPEND=>=app-arch/unzip-5.41 >=dev-libs/libxml2-2.4 >=app-text/docbook-xsl-stylesheets-1.65 >=app-text/build-docbook-catalog-1.2 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook DTD for XML
 HOMEPAGE=http://www.docbook.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=4.3
 SRC_URI=http://www.docbook.org/xml/4.3/docbook-xml-4.3.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c03974e6ca1931cd137d2964a8b0fb2e
+_md5_=e3f7810393cda516a0e93fbfb028544b
diff --git a/metadata/md5-cache/app-text/docbook-xml-dtd-4.4-r1 b/metadata/md5-cache/app-text/docbook-xml-dtd-4.4-r1
index a678783..ab36b1f 100644
--- a/metadata/md5-cache/app-text/docbook-xml-dtd-4.4-r1
+++ b/metadata/md5-cache/app-text/docbook-xml-dtd-4.4-r1
@@ -2,9 +2,9 @@
 DEPEND=>=app-arch/unzip-5.41 >=dev-libs/libxml2-2.4 >=app-text/docbook-xsl-stylesheets-1.65 >=app-text/build-docbook-catalog-1.2 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook DTD for XML
 HOMEPAGE=http://www.docbook.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=4.4
 SRC_URI=http://www.docbook.org/xml/4.4/docbook-xml-4.4.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6520fb1aedc68e6baecd000c7254199a
+_md5_=18317c3129b800d3a07c83f6009695b1
diff --git a/metadata/md5-cache/app-text/docbook-xml-dtd-4.5 b/metadata/md5-cache/app-text/docbook-xml-dtd-4.5
index 64b0248..b08f2f5 100644
--- a/metadata/md5-cache/app-text/docbook-xml-dtd-4.5
+++ b/metadata/md5-cache/app-text/docbook-xml-dtd-4.5
@@ -2,9 +2,9 @@
 DEPEND=>=app-arch/unzip-5.41 >=dev-libs/libxml2-2.4 >=app-text/docbook-xsl-stylesheets-1.65 >=app-text/build-docbook-catalog-1.2 >=app-text/sgml-common-0.6.3-r2
 DESCRIPTION=Docbook DTD for XML
 HOMEPAGE=http://www.docbook.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=4.5
 SRC_URI=http://www.docbook.org/xml/4.5/docbook-xml-4.5.zip
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=273ac0260326863a9c9b53e60dd9f7f8
+_md5_=b6178b8520411deae8b5e65e059c5837
diff --git a/metadata/md5-cache/app-text/docbook-xsl-stylesheets-1.75.2 b/metadata/md5-cache/app-text/docbook-xsl-stylesheets-1.75.2
index d84fc34..bb6ac2c 100644
--- a/metadata/md5-cache/app-text/docbook-xsl-stylesheets-1.75.2
+++ b/metadata/md5-cache/app-text/docbook-xsl-stylesheets-1.75.2
@@ -1,10 +1,10 @@
 DEFINED_PHASES=compile install postinst postrm test
 DESCRIPTION=XSL Stylesheets for Docbook
 HOMEPAGE=http://wiki.docbook.org/topic/DocBookXslStylesheets
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh ~sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD
 RDEPEND=>=app-text/build-docbook-catalog-1.1
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://sourceforge/docbook/docbook-xsl-1.75.2.tar.bz2
-_md5_=6da202c87f662d6655ccb4f26d25b863
+_md5_=14aac575b13e919d92608748ccc0391e
diff --git a/metadata/md5-cache/app-text/dos2unix-5.3.1 b/metadata/md5-cache/app-text/dos2unix-5.3.1
index 17f47fa..89ec6e3 100644
--- a/metadata/md5-cache/app-text/dos2unix-5.3.1
+++ b/metadata/md5-cache/app-text/dos2unix-5.3.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.xs4all.nl/~waterlan/dos2unix.html http://sourceforge.net/projects/dos2unix/
 IUSE=debug nls
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris
 LICENSE=BSD-2
 RDEPEND=!app-text/hd2u !app-text/unix2dos virtual/libintl
 SLOT=0
 SRC_URI=http://www.xs4all.nl/~waterlan/dos2unix/dos2unix-5.3.1.tar.gz mirror://sourceforge/dos2unix/dos2unix-5.3.1.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9e833e2549e1ef6349e1e596e81179ac
+_md5_=67115be30fbcee8564cd5d8b56efebac
diff --git a/metadata/md5-cache/app-text/ghostscript-gpl-9.05 b/metadata/md5-cache/app-text/ghostscript-gpl-9.05
index a647c44..0ffdfba 100644
--- a/metadata/md5-cache/app-text/ghostscript-gpl-9.05
+++ b/metadata/md5-cache/app-text/ghostscript-gpl-9.05
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://ghostscript.com/
 IUSE=bindist cups dbus djvu gtk idn jpeg2k static-libs X linguas_ja linguas_ko linguas_zh_CN linguas_zh_TW
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3 CPL-1.0
 RDEPEND=app-text/libpaper media-libs/fontconfig >=media-libs/freetype-2.4.2:2 media-libs/jbig2dec media-libs/lcms:2 media-libs/libpng:0 media-libs/tiff:0 >=sys-libs/zlib-1.2.3 virtual/jpeg !bindist? ( djvu? ( app-text/djvu ) ) cups? ( >=net-print/cups-1.3.8 ) dbus? ( sys-apps/dbus ) gtk? ( x11-libs/gtk+:2 ) idn? ( net-dns/libidn ) jpeg2k? ( media-libs/jasper ) X? ( x11-libs/libXt x11-libs/libXext ) >=app-text/poppler-data-0.4.4 >=media-fonts/urw-fonts-2.4.9 linguas_ja? ( media-fonts/kochi-substitute ) linguas_ko? ( media-fonts/baekmuk-fonts ) linguas_zh_CN? ( media-fonts/arphicfonts ) linguas_zh_TW? ( media-fonts/arphicfonts ) !!media-fonts/gnu-gs-fonts-std !!media-fonts/gnu-gs-fonts-other
 SLOT=0
 SRC_URI=mirror://sourceforge/ghostscript/ghostscript-9.05.tar.bz2 mirror://gentoo/ghostscript-gpl-9.05-patchset-1.tar.bz2 !bindist? ( djvu? ( mirror://sourceforge/djvu/gsdjvu-1.5.tar.gz ) )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=a97eb25ed8b612c3a091a8f70034172b
+_md5_=6f901c386c812ad651882dfda9204608
diff --git a/metadata/md5-cache/app-text/gnome-doc-utils-0.16.1 b/metadata/md5-cache/app-text/gnome-doc-utils-0.16.1
index a429602..2be46c1 100644
--- a/metadata/md5-cache/app-text/gnome-doc-utils-0.16.1
+++ b/metadata/md5-cache/app-text/gnome-doc-utils-0.16.1
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnome.org/
 IUSE=debug
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 ~s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-2 LGPL-2.1
 RDEPEND=>=dev-libs/libxml2-2.6.12[python] >=dev-libs/libxslt-1.1.8 >=dev-lang/python-2 >=app-admin/eselect-python-20091230
 SLOT=0
 SRC_URI=mirror://gnome/sources/gnome-doc-utils/0.16/gnome-doc-utils-0.16.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=4ced8a62a2d1a9a6311bcf0bec911ce3
+_md5_=4a63aeb1a54af58272e8dec75aa3969c
diff --git a/metadata/md5-cache/app-text/htmltidy-20090325 b/metadata/md5-cache/app-text/htmltidy-20090325
index 5509a5b..d965567 100644
--- a/metadata/md5-cache/app-text/htmltidy-20090325
+++ b/metadata/md5-cache/app-text/htmltidy-20090325
@@ -4,9 +4,9 @@
 EAPI=2
 HOMEPAGE=http://tidy.sourceforge.net/
 IUSE=debug doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/tidy-20090325.tar.bz2 mirror://gentoo/tidy-20090325-doc.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c95a6a9b4b4526629a019f49a78c365f
+_md5_=cb0caa87b5974b3140d8fbabff4eb65c
diff --git a/metadata/md5-cache/app-text/libpaper-1.1.23 b/metadata/md5-cache/app-text/libpaper-1.1.23
index 6eba5a0..7196d94 100644
--- a/metadata/md5-cache/app-text/libpaper-1.1.23
+++ b/metadata/md5-cache/app-text/libpaper-1.1.23
@@ -1,9 +1,9 @@
 DEFINED_PHASES=install postinst unpack
 DESCRIPTION=Library for handling paper characteristics
 HOMEPAGE=http://packages.debian.org/unstable/source/libpaper
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/libpaper_1.1.23.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=386345ca9fd4dd70cdd308960a403db3
+_md5_=2786224423872ef8d66570dfcee43c0b
diff --git a/metadata/md5-cache/app-text/openjade-1.3.2-r3 b/metadata/md5-cache/app-text/openjade-1.3.2-r3
index b7ee391..a8ea7eb 100644
--- a/metadata/md5-cache/app-text/openjade-1.3.2-r3
+++ b/metadata/md5-cache/app-text/openjade-1.3.2-r3
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://openjade.sourceforge.net
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=as-is
 RDEPEND=app-text/sgml-common >=app-text/opensp-1.5.1
 SLOT=0
 SRC_URI=mirror://sourceforge/openjade/openjade-1.3.2.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	sgml-catalog	a4d9b97f60f3331317a2d4279eecbe7d	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=11e59140942f008b6ee9071336cec8b6
+_md5_=6ca9b86e41667a3d9335797ce747bade
diff --git a/metadata/md5-cache/app-text/opensp-1.5.2-r1 b/metadata/md5-cache/app-text/opensp-1.5.2-r1
index e6ecc35..1e8a217 100644
--- a/metadata/md5-cache/app-text/opensp-1.5.2-r1
+++ b/metadata/md5-cache/app-text/opensp-1.5.2-r1
@@ -3,9 +3,9 @@
 DESCRIPTION=A free, object-oriented toolkit for SGML parsing and entity management
 HOMEPAGE=http://openjade.sourceforge.net/
 IUSE=doc nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=JamesClark
 SLOT=0
 SRC_URI=mirror://sourceforge/openjade/OpenSP-1.5.2.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=183d3567cb275daf67f6d24fb44fea41
+_md5_=42f5756ef3febb764efac8f9afea03c1
diff --git a/metadata/md5-cache/app-text/poppler-data-0.4.4 b/metadata/md5-cache/app-text/poppler-data-0.4.4
index 4325b2c..8ca5c97 100644
--- a/metadata/md5-cache/app-text/poppler-data-0.4.4
+++ b/metadata/md5-cache/app-text/poppler-data-0.4.4
@@ -2,8 +2,8 @@
 DESCRIPTION=Data files for poppler to support uncommon encodings without xpdfrc
 EAPI=3
 HOMEPAGE=http://poppler.freedesktop.org/
-KEYWORDS=~alpha amd64 ~arm hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD GPL-2 MIT
 SLOT=0
 SRC_URI=http://poppler.freedesktop.org/poppler-data-0.4.4.tar.gz
-_md5_=79c0117ba52e39d131edbbe31c83519c
+_md5_=65bfd04aaa2ad8caaf62a3a629a4801f
diff --git a/metadata/md5-cache/app-text/rarian-0.8.1 b/metadata/md5-cache/app-text/rarian-0.8.1
index 2586566..00279aa 100644
--- a/metadata/md5-cache/app-text/rarian-0.8.1
+++ b/metadata/md5-cache/app-text/rarian-0.8.1
@@ -3,10 +3,10 @@
 DESCRIPTION=A documentation metadata library
 HOMEPAGE=http://www.freedesktop.org
 IUSE=debug
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=LGPL-2.1
 RDEPEND=dev-libs/libxslt
 SLOT=0
 SRC_URI=mirror://gnome/sources/rarian/0.8/rarian-0.8.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=7c415cb66597054431ae1f02abb04c0f
+_md5_=771a975e86c8d0aba40ba76eb7f5c8cf
diff --git a/metadata/md5-cache/app-text/scrollkeeper-9999-r1 b/metadata/md5-cache/app-text/scrollkeeper-9999-r1
index 4561fbe..6e9435f 100644
--- a/metadata/md5-cache/app-text/scrollkeeper-9999-r1
+++ b/metadata/md5-cache/app-text/scrollkeeper-9999-r1
@@ -2,9 +2,9 @@
 DEPEND==app-text/scrollkeeper-dtd-1.0
 DESCRIPTION=Dummy scrollkeeper for testing rarian
 HOMEPAGE=http://gnome.gentoo.org
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 PDEPEND=app-text/rarian
 RDEPEND==app-text/scrollkeeper-dtd-1.0
 SLOT=0
-_md5_=058c1e314c3e6cb679c8277646031afc
+_md5_=3ac4191914b09be25fb5a668c51914f9
diff --git a/metadata/md5-cache/app-text/sgml-common-0.6.3-r5 b/metadata/md5-cache/app-text/sgml-common-0.6.3-r5
index 8a6b4af..aa2ec65 100644
--- a/metadata/md5-cache/app-text/sgml-common-0.6.3-r5
+++ b/metadata/md5-cache/app-text/sgml-common-0.6.3-r5
@@ -2,9 +2,9 @@
 DEPEND=|| ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool
 DESCRIPTION=Base ISO character entities and utilities for SGML
 HOMEPAGE=http://www.iso.ch/cate/3524030.html
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://kde/devel/docbook/SOURCES/sgml-common-0.6.3.tgz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c7d5669011d4bf0528faacca273e6901
+_md5_=3e1ee7c639c33499742c5fded77c8078
diff --git a/metadata/md5-cache/app-text/texi2html-1.78 b/metadata/md5-cache/app-text/texi2html-1.78
index 4516389..7f5f6ac 100644
--- a/metadata/md5-cache/app-text/texi2html-1.78
+++ b/metadata/md5-cache/app-text/texi2html-1.78
@@ -3,9 +3,9 @@
 DESCRIPTION=Perl script that converts Texinfo to HTML
 EAPI=3
 HOMEPAGE=http://www.nongnu.org/texi2html/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=dev-lang/perl-5.6.1
 SLOT=0
 SRC_URI=http://download.savannah.gnu.org/releases/texi2html/texi2html-1.78.tar.bz2
-_md5_=448f0c329d32f7f1c45bda839d11dd14
+_md5_=9d7f5afce6b9915da495b05cd61ae857
diff --git a/metadata/md5-cache/app-text/xmlto-0.0.24-r1 b/metadata/md5-cache/app-text/xmlto-0.0.24-r1
index 7090870..42f2e3b 100644
--- a/metadata/md5-cache/app-text/xmlto-0.0.24-r1
+++ b/metadata/md5-cache/app-text/xmlto-0.0.24-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=https://fedorahosted.org/xmlto/
 IUSE=latex
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x86-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=app-shells/bash || ( sys-apps/which sys-freebsd/freebsd-ubin ) dev-libs/libxslt >=app-text/docbook-xsl-stylesheets-1.62.0-r1 ~app-text/docbook-xml-dtd-4.2 || ( sys-apps/util-linux app-misc/getopt ) || ( >=sys-apps/coreutils-6.10-r1 sys-freebsd/freebsd-ubin ) latex? ( >=app-text/passivetex-1.25 >=dev-tex/xmltex-1.9-r2 )
 SLOT=0
 SRC_URI=https://fedorahosted.org/releases/x/m/xmlto/xmlto-0.0.24.tar.bz2 mirror://gentoo/xmlto-0.0.24-mans.tar.bz2 http://dev.gentoo.org/~vapier/dist/xmlto-0.0.24-mans.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f2e97d05a149bd614f541e6a19e22163
+_md5_=9b48619bde8e0c62a590b5cc81c09a54
diff --git a/metadata/md5-cache/app-vim/gentoo-syntax-20101212 b/metadata/md5-cache/app-vim/gentoo-syntax-20101212
index 1979f44..e60f54c 100644
--- a/metadata/md5-cache/app-vim/gentoo-syntax-20101212
+++ b/metadata/md5-cache/app-vim/gentoo-syntax-20101212
@@ -3,10 +3,10 @@
 DESCRIPTION=vim plugin: Gentoo Ebuild, Eclass, GLEP, ChangeLog and Portage Files syntax highlighting, filetype and indent settings
 HOMEPAGE=http://www.gentoo.org/
 IUSE=ignore-glep31
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=vim
 RDEPEND=|| ( >=app-editors/vim-7.0 >=app-editors/gvim-7.0 )
 SLOT=0
 SRC_URI=mirror://gentoo/gentoo-syntax-20101212.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	vim-doc	6bd5bb2529af326fe3359e975a3439d0	vim-plugin	395396a7fc48fd6a6b2306d493fdca89
-_md5_=e70a8280ec3f001cd167eaf953dd7893
+_md5_=ed622920938671bd35e212badb85b51e
diff --git a/metadata/md5-cache/dev-cpp/ctemplate-1.0 b/metadata/md5-cache/dev-cpp/ctemplate-1.0
index 19da0dd..04be036 100644
--- a/metadata/md5-cache/dev-cpp/ctemplate-1.0
+++ b/metadata/md5-cache/dev-cpp/ctemplate-1.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://code.google.com/p/google-ctemplate/
 IUSE=doc emacs vim-syntax static-libs test
-KEYWORDS=amd64 arm ~ppc x86 ~amd64-linux ~x86-linux
+KEYWORDS=amd64 arm ppc x86 ~amd64-linux ~x86-linux
 LICENSE=BSD
 RDEPEND=vim-syntax? ( >=app-editors/vim-core-7 ) emacs? ( virtual/emacs ) >=app-admin/eselect-python-20091230
 SLOT=0
 SRC_URI=http://google-ctemplate.googlecode.com/files/ctemplate-1.0.tar.gz
 _eclasses_=elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c169b8730521c80c2466008fb5631eae
+_md5_=b732cdee18a3353141d4ec9c0b9a53ae
diff --git a/metadata/md5-cache/dev-cpp/gmock-1.6.0 b/metadata/md5-cache/dev-cpp/gmock-1.6.0
index 19b1963..ae7cc93 100644
--- a/metadata/md5-cache/dev-cpp/gmock-1.6.0
+++ b/metadata/md5-cache/dev-cpp/gmock-1.6.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://code.google.com/p/googlemock/
 IUSE=static-libs
-KEYWORDS=amd64 arm ~mips ppc ~ppc64 x86
+KEYWORDS=amd64 arm mips ppc ppc64 x86
 LICENSE=BSD
 RDEPEND==dev-cpp/gtest-1.6.0*
 SLOT=0
 SRC_URI=http://googlemock.googlecode.com/files/gmock-1.6.0.zip
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a80e3d41ac6ab5cb9d6a8a7b531a2d78
+_md5_=f28c2d0be3f04fcff7e69cd0fee66a46
diff --git a/metadata/md5-cache/dev-cpp/gtest-1.6.0-r1 b/metadata/md5-cache/dev-cpp/gtest-1.6.0-r1
index af653f0..f89acb3 100644
--- a/metadata/md5-cache/dev-cpp/gtest-1.6.0-r1
+++ b/metadata/md5-cache/dev-cpp/gtest-1.6.0-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://code.google.com/p/googletest/
 IUSE=examples static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~ppc-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~ppc-macos
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=http://googletest.googlecode.com/files/gtest-1.6.0.zip
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9dd1da433e4fd0d5a29ceafa248b6592
+_md5_=b21b62bbfa40e187bf46305a2a1cda67
diff --git a/metadata/md5-cache/dev-db/freetds-0.91 b/metadata/md5-cache/dev-db/freetds-0.91
index a9d409c..f9cc06d 100644
--- a/metadata/md5-cache/dev-db/freetds-0.91
+++ b/metadata/md5-cache/dev-db/freetds-0.91
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.freetds.org/
 IUSE=kerberos odbc iodbc mssql
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~x86-fbsd ~ppc-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~ppc-macos
 LICENSE=GPL-2
 RDEPEND=iodbc? ( dev-db/libiodbc ) kerberos? ( virtual/krb5 ) odbc? ( dev-db/unixODBC )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://ibiblio.org/pub/Linux/ALPHA/freetds/stable/freetds-0.91.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=7d148eee379c322540060b1de8cb6a18
+_md5_=15e17ef5b5ec3ec7e2f3a4d2ffde2ee8
diff --git a/metadata/md5-cache/dev-db/m17n-db-1.6.2 b/metadata/md5-cache/dev-db/m17n-db-1.6.2
index 31aff4a..a9d2954 100644
--- a/metadata/md5-cache/dev-db/m17n-db-1.6.2
+++ b/metadata/md5-cache/dev-db/m17n-db-1.6.2
@@ -3,9 +3,9 @@
 DESCRIPTION=Database for the m17n library
 EAPI=4
 HOMEPAGE=http://www.m17n.org/m17n-lib/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~sh ~sparc ~x86
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 ppc ppc64 sh sparc ~x86
 LICENSE=LGPL-2.1
 RDEPEND=virtual/libintl
 SLOT=0
 SRC_URI=http://www.m17n.org/m17n-lib-download/m17n-db-1.6.2.tar.gz
-_md5_=c66af5717bcdacf09e81c0f56c993cb7
+_md5_=01b0ac363c63355c409572cb36086858
diff --git a/metadata/md5-cache/dev-db/sqlite-3.6.22-r2 b/metadata/md5-cache/dev-db/sqlite-3.6.22-r2
index 17eeb02..21f7447 100644
--- a/metadata/md5-cache/dev-db/sqlite-3.6.22-r2
+++ b/metadata/md5-cache/dev-db/sqlite-3.6.22-r2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.sqlite.org/
 IUSE=debug doc extensions +fts3 icu +readline secure-delete soundex tcl +threadsafe test
-KEYWORDS=~alpha amd64 ~arm ~hppa ~ia64 ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 RDEPEND=icu? ( dev-libs/icu ) readline? ( sys-libs/readline ) tcl? ( dev-lang/tcl )
 SLOT=3
 SRC_URI=tcl? ( http://www.sqlite.org/sqlite-3.6.22.tar.gz ) !tcl? ( test? ( http://www.sqlite.org/sqlite-3.6.22.tar.gz ) !test? ( http://www.sqlite.org/sqlite-amalgamation-3.6.22.tar.gz ) ) doc? ( http://www.sqlite.org/sqlite_docs_3_6_22.zip )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=e7271c016240dd7a52e403b0721233a2
+_md5_=0ddc83e212b580c77532d3f0708db208
diff --git a/metadata/md5-cache/dev-embedded/libftdi-1.0 b/metadata/md5-cache/dev-embedded/libftdi-1.0
index 21a2dc4..891ba0b 100644
--- a/metadata/md5-cache/dev-embedded/libftdi-1.0
+++ b/metadata/md5-cache/dev-embedded/libftdi-1.0
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.intra2net.com/en/developer/libftdi/
 IUSE=cxx doc examples python static-libs tools
-KEYWORDS=amd64 arm ~ppc ~ppc64 ~sparc x86
+KEYWORDS=amd64 arm ppc ppc64 sparc x86
 LICENSE=LGPL-2
 RDEPEND=virtual/libusb:1 cxx? ( dev-libs/boost ) python? ( dev-lang/python ) tools? ( dev-libs/confuse )
 SLOT=0
 SRC_URI=http://www.intra2net.com/en/developer/libftdi/download/libftdi1-1.0.tar.bz2
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	cmake-utils	00f9fd5a80cf3605f6d9a2e808c48a92	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2452dab6702aaf710ebdef00288808f9
+_md5_=cf5f6eefe578ace0e6442357f1bf5462
diff --git a/metadata/md5-cache/dev-java/java-config-wrapper-0.16 b/metadata/md5-cache/dev-java/java-config-wrapper-0.16
index a3fc5d9..65d96f9 100644
--- a/metadata/md5-cache/dev-java/java-config-wrapper-0.16
+++ b/metadata/md5-cache/dev-java/java-config-wrapper-0.16
@@ -2,9 +2,9 @@
 DEPEND=!<dev-java/java-config-1.3
 DESCRIPTION=Wrapper for java-config
 HOMEPAGE=http://www.gentoo.org/proj/en/java
-KEYWORDS=alpha amd64 arm ~hppa ia64 ppc ppc64 x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=app-portage/portage-utils
 SLOT=0
 SRC_URI=mirror://gentoo/java-config-wrapper-0.16.tar.bz2
-_md5_=a61e352e87980922284857aa1b2949e8
+_md5_=864eeb359f43abe695f5a9cabcec3c22
diff --git a/metadata/md5-cache/dev-lang/perl-5.12.4-r1 b/metadata/md5-cache/dev-lang/perl-5.12.4-r1
index fa7c6b3..acdf8a4 100644
--- a/metadata/md5-cache/dev-lang/perl-5.12.4-r1
+++ b/metadata/md5-cache/dev-lang/perl-5.12.4-r1
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.perl.org/
 IUSE=berkdb build debug doc gdbm ithreads
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 PDEPEND=>=app-admin/perl-cleaner-2.5
 RDEPEND=berkdb? ( sys-libs/db ) gdbm? ( >=sys-libs/gdbm-1.8.3 ) >=sys-devel/libperl-5.10.1 !!<sys-devel/libperl-5.10.1 app-arch/bzip2 sys-libs/zlib
 SLOT=0
 SRC_URI=mirror://cpan/src/perl-5.12.4.tar.bz2 mirror://cpan/authors/id/L/LB/LBROCARD/perl-5.12.4.tar.bz2 mirror://gentoo/perl-5.12.4-1.tar.bz2 http://dev.gentoo.org/~tove/distfiles/dev-lang/perl/perl-5.12.4-1.tar.bz2
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=931be1ceeb6f77201d0fde6a515d90a6
+_md5_=b7784e7e7127efa52326dfb23f80ddef
diff --git a/metadata/md5-cache/dev-lang/swig-2.0.4-r1 b/metadata/md5-cache/dev-lang/swig-2.0.4-r1
index 41e0ea2..fc8342e 100644
--- a/metadata/md5-cache/dev-lang/swig-2.0.4-r1
+++ b/metadata/md5-cache/dev-lang/swig-2.0.4-r1
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://www.swig.org/
 IUSE=ccache doc pcre
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-3 as-is
 RDEPEND=pcre? ( dev-libs/libpcre ) ccache? ( sys-libs/zlib )
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://sourceforge/swig/swig-2.0.4.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9d0664987e89b1341dbdd77c159640cf
+_md5_=221e5cf4aa59bb779f914a754dcf27e5
diff --git a/metadata/md5-cache/dev-lang/tcl-8.5.7 b/metadata/md5-cache/dev-lang/tcl-8.5.7
index 89e93ea..13a61f0 100644
--- a/metadata/md5-cache/dev-lang/tcl-8.5.7
+++ b/metadata/md5-cache/dev-lang/tcl-8.5.7
@@ -3,9 +3,9 @@
 DESCRIPTION=Tool Command Language
 HOMEPAGE=http://www.tcl.tk/
 IUSE=debug threads
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=BSD
 SLOT=0
 SRC_URI=mirror://sourceforge/tcl/tcl8.5.7-src.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=54a5cb9c0123f752b2f9e8be0dc1419e
+_md5_=bb3f6281d4663f3c3b75279f30025b69
diff --git a/metadata/md5-cache/dev-libs/apr-1.3.9 b/metadata/md5-cache/dev-libs/apr-1.3.9
index 40e49b5..42c150a 100644
--- a/metadata/md5-cache/dev-libs/apr-1.3.9
+++ b/metadata/md5-cache/dev-libs/apr-1.3.9
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://apr.apache.org/
 IUSE=doc older-kernels-compatibility +urandom
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=Apache-2.0
 RESTRICT=test
 SLOT=1
 SRC_URI=mirror://apache/apr/apr-1.3.9.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=bf1083c5d9ff66f8bdcf20a52538987e
+_md5_=7674d8da61d0a234fd1b52f24dc4e076
diff --git a/metadata/md5-cache/dev-libs/apr-util-1.3.9 b/metadata/md5-cache/dev-libs/apr-util-1.3.9
index 09b6bb4..afb575e 100644
--- a/metadata/md5-cache/dev-libs/apr-util-1.3.9
+++ b/metadata/md5-cache/dev-libs/apr-util-1.3.9
@@ -4,11 +4,11 @@
 EAPI=2
 HOMEPAGE=http://apr.apache.org/
 IUSE=berkdb doc freetds gdbm ldap mysql odbc postgres sqlite sqlite3
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=Apache-2.0
 RDEPEND=dev-libs/expat >=dev-libs/apr-1.3.8:1 berkdb? ( =sys-libs/db-4* ) freetds? ( dev-db/freetds ) gdbm? ( sys-libs/gdbm ) ldap? ( =net-nds/openldap-2* ) mysql? ( =virtual/mysql-5* ) odbc? ( dev-db/unixODBC ) postgres? ( virtual/postgresql-base ) sqlite? ( dev-db/sqlite:0 ) sqlite3? ( dev-db/sqlite:3 )
 RESTRICT=test
 SLOT=1
 SRC_URI=mirror://apache/apr/apr-util-1.3.9.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	db-use	8d7baa3efc7c38c7d5c5e7353c5460dc	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=d4ebf3ed0fda756e16fe3a7a82a47164
+_md5_=1af9ba5ff21b6d7c9375c0e201116a82
diff --git a/metadata/md5-cache/dev-libs/atk-1.32.0-r1 b/metadata/md5-cache/dev-libs/atk-1.32.0-r1
index abd8967..c471311 100644
--- a/metadata/md5-cache/dev-libs/atk-1.32.0-r1
+++ b/metadata/md5-cache/dev-libs/atk-1.32.0-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://projects.gnome.org/accessibility/
 IUSE=doc +introspection nls
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 ~s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=LGPL-2
 RDEPEND=dev-libs/glib:2 introspection? ( >=dev-libs/gobject-introspection-0.6.7 )
 SLOT=0
 SRC_URI=mirror://gnome/sources/atk/1.32/atk-1.32.0.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=244f36a75e9ff6b8a04d05e15bdad07e
+_md5_=2daf45a52660924fce4521099bfe2ece
diff --git a/metadata/md5-cache/dev-libs/check-0.9.8 b/metadata/md5-cache/dev-libs/check-0.9.8
index 6b4b34a..3cc4b89 100644
--- a/metadata/md5-cache/dev-libs/check-0.9.8
+++ b/metadata/md5-cache/dev-libs/check-0.9.8
@@ -2,9 +2,9 @@
 DEPEND=|| ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool
 DESCRIPTION=A unit test framework for C
 HOMEPAGE=http://sourceforge.net/projects/check/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://sourceforge/check/check-0.9.8.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=3b1b56f93d344b426c625fe4e0282bd3
+_md5_=4ab7b10837fbd2783b603beff8b5a8c1
diff --git a/metadata/md5-cache/dev-libs/confuse-2.7 b/metadata/md5-cache/dev-libs/confuse-2.7
index fa4f44e..2349903 100644
--- a/metadata/md5-cache/dev-libs/confuse-2.7
+++ b/metadata/md5-cache/dev-libs/confuse-2.7
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://www.nongnu.org/confuse/
 IUSE=nls static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~x86-solaris
 LICENSE=ISC
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://nongnu/confuse/confuse-2.7.tar.gz
-_md5_=3017105f7748c08e4ca7a8c8e7e881f9
+_md5_=4e329042634120dea7b486e623924715
diff --git a/metadata/md5-cache/dev-libs/dbus-glib-0.100.2 b/metadata/md5-cache/dev-libs/dbus-glib-0.100.2
index fa5d9a9..2b36471 100644
--- a/metadata/md5-cache/dev-libs/dbus-glib-0.100.2
+++ b/metadata/md5-cache/dev-libs/dbus-glib-0.100.2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://dbus.freedesktop.org/
 IUSE=debug doc static-libs test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=|| ( GPL-2 AFL-2.1 )
 RDEPEND=>=dev-libs/expat-2 >=dev-libs/glib-2.26:2 >=sys-apps/dbus-1.6.2
 SLOT=0
 SRC_URI=http://dbus.freedesktop.org/releases/dbus-glib/dbus-glib-0.100.2.tar.gz
 _eclasses_=bash-completion-r1	3480f8385cb9e31797e7b659e366e2d2	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a917269d6173dcd0a586d83b83c4a7f5
+_md5_=e6eacb4b0df018553ef9a789851c1ec5
diff --git a/metadata/md5-cache/dev-libs/engine_pkcs11-0.1.8 b/metadata/md5-cache/dev-libs/engine_pkcs11-0.1.8
index b9836d5..f4fd83e 100644
--- a/metadata/md5-cache/dev-libs/engine_pkcs11-0.1.8
+++ b/metadata/md5-cache/dev-libs/engine_pkcs11-0.1.8
@@ -4,9 +4,9 @@
 EAPI=2
 HOMEPAGE=http://www.opensc-project.org/engine_pkcs11
 IUSE=doc
-KEYWORDS=~alpha ~amd64 ~hppa ~ia64 ppc ppc64 ~sparc ~x86
+KEYWORDS=alpha ~amd64 hppa ia64 ppc ppc64 sparc ~x86
 LICENSE=LGPL-2.1
 RDEPEND=>=dev-libs/libp11-0.2.5 dev-libs/openssl
 SLOT=0
 SRC_URI=http://www.opensc-project.org/files/engine_pkcs11/engine_pkcs11-0.1.8.tar.gz
-_md5_=336814f10764235385605e309cd71d73
+_md5_=3b21d1f57d72b1d073b9797fbd83b9ca
diff --git a/metadata/md5-cache/dev-libs/expat-2.1.0 b/metadata/md5-cache/dev-libs/expat-2.1.0
index 333e7ff..d556067 100644
--- a/metadata/md5-cache/dev-libs/expat-2.1.0
+++ b/metadata/md5-cache/dev-libs/expat-2.1.0
@@ -3,9 +3,9 @@
 EAPI=4
 HOMEPAGE=http://expat.sourceforge.net/
 IUSE=elibc_FreeBSD examples static-libs unicode
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=MIT
 SLOT=0
 SRC_URI=mirror://sourceforge/expat/expat-2.1.0.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f04ec6cf9af520d2d2be201ce05a2633
+_md5_=ee439d80ce2a9e21e9493d63e6bd4d2a
diff --git a/metadata/md5-cache/dev-libs/fribidi-0.10.7 b/metadata/md5-cache/dev-libs/fribidi-0.10.7
index d2bbd38..9c75216 100644
--- a/metadata/md5-cache/dev-libs/fribidi-0.10.7
+++ b/metadata/md5-cache/dev-libs/fribidi-0.10.7
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=A free implementation of the unicode bidirectional algorithm
 HOMEPAGE=http://fribidi.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=LGPL-2.1
 SLOT=0
 SRC_URI=http://fribidi.org/download/fribidi-0.10.7.tar.gz
-_md5_=3d2dddea5e67fc154e9990517797df96
+_md5_=7c167dceb3ef19a3df0676e26e41918a
diff --git a/metadata/md5-cache/dev-libs/glib-2.32.4-r1 b/metadata/md5-cache/dev-libs/glib-2.32.4-r1
index c135a5c..929c145 100644
--- a/metadata/md5-cache/dev-libs/glib-2.32.4-r1
+++ b/metadata/md5-cache/dev-libs/glib-2.32.4-r1
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.gtk.org/
 IUSE=debug doc fam kernel_linux selinux static-libs systemtap test utils xattr test
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=LGPL-2+
 PDEPEND=x11-misc/shared-mime-info !<gnome-base/gvfs-1.6.4-r990
 RDEPEND=virtual/libiconv virtual/libffi sys-libs/zlib || ( >=dev-libs/elfutils-0.142 >=dev-libs/libelf-0.8.12 ) xattr? ( sys-apps/attr ) fam? ( virtual/fam ) utils? ( >=dev-util/gdbus-codegen-2.32.4 ) >=app-admin/eselect-python-20091230 utils? ( =dev-lang/python-2* )
 SLOT=2
 SRC_URI=mirror://gnome/sources/glib/2.32/glib-2.32.4.tar.xz http://dev.gentoo.org/~tetromino/distfiles/glib/glib-2.32.4-AS_IF-patches.tar.xz http://pkgconfig.freedesktop.org/releases/pkg-config-0.26.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	pax-utils	3551398d6ede2b572568832730cc2a45	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	virtualx	e9162f65645513120b4e12863a5fa972
-_md5_=1408502a7ce9d8ea5417989643ad88eb
+_md5_=fe54dc028aa2b74bbba7ea299995e0a7
diff --git a/metadata/md5-cache/dev-libs/gmp-5.0.2_p1 b/metadata/md5-cache/dev-libs/gmp-5.0.2_p1
index 0ac2d39..b9446b3 100644
--- a/metadata/md5-cache/dev-libs/gmp-5.0.2_p1
+++ b/metadata/md5-cache/dev-libs/gmp-5.0.2_p1
@@ -3,9 +3,9 @@
 DESCRIPTION=Library for arithmetic on arbitrary precision integers, rational numbers, and floating-point numbers
 HOMEPAGE=http://gmplib.org/
 IUSE=doc cxx static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ~ppc ~ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=LGPL-3
 SLOT=0
 SRC_URI=mirror://gnu/gmp/gmp-5.0.2.tar.bz2 doc? ( http://gmplib.org/gmp-man-5.0.2.pdf )
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ea535a83364e4771064d2c40c84a1996
+_md5_=e1939b46ccee8ab064972f6d1b8dd942
diff --git a/metadata/md5-cache/dev-libs/libaio-0.3.109-r3 b/metadata/md5-cache/dev-libs/libaio-0.3.109-r3
index fc67f51..9fe3133 100644
--- a/metadata/md5-cache/dev-libs/libaio-0.3.109-r3
+++ b/metadata/md5-cache/dev-libs/libaio-0.3.109-r3
@@ -3,9 +3,9 @@
 EAPI=3
 HOMEPAGE=http://www.kernel.org/pub/linux/kernel/people/andrea/libaio/ http://lse.sourceforge.net/io/aio.html
 IUSE=multilib static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=LGPL-2
 SLOT=0
 SRC_URI=mirror://kernel/linux/libs/aio/libaio-0.3.109.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c1eddf32122c2acc7671312faec409d4
+_md5_=d26e72cd2a934553ee01c5dbcda0a9b9
diff --git a/metadata/md5-cache/dev-libs/libatomic_ops-7.2d b/metadata/md5-cache/dev-libs/libatomic_ops-7.2d
index 00765b1..06f2799 100644
--- a/metadata/md5-cache/dev-libs/libatomic_ops-7.2d
+++ b/metadata/md5-cache/dev-libs/libatomic_ops-7.2d
@@ -2,9 +2,9 @@
 DESCRIPTION=Implementation for atomic memory update operations
 EAPI=4
 HOMEPAGE=http://www.hpl.hp.com/research/linux/atomic_ops/
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~sh ~sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT boehm-gc GPL-2+
 SLOT=0
 SRC_URI=http://www.hpl.hp.com/personal/Hans_Boehm/gc/gc_source/gc-7.2d.tar.gz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=04b557753b83ad4b2c35e72fb8ded5f3
+_md5_=3b73c9a4b49403029fd6be75a5ffa81e
diff --git a/metadata/md5-cache/dev-libs/libchewing-0.3.2-r1 b/metadata/md5-cache/dev-libs/libchewing-0.3.2-r1
index 3a0082c..8d01089 100644
--- a/metadata/md5-cache/dev-libs/libchewing-0.3.2-r1
+++ b/metadata/md5-cache/dev-libs/libchewing-0.3.2-r1
@@ -4,9 +4,9 @@
 EAPI=2
 HOMEPAGE=http://chewing.csie.net/
 IUSE=debug test static-libs
-KEYWORDS=~amd64 ~ppc ~x86
+KEYWORDS=~amd64 ppc ~x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://chewing.csie.net/download/libchewing/libchewing-0.3.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=31a2e3a22110d5a4115cd93d196b6ff0
+_md5_=c910dbea13de509f5895c431016bc1f6
diff --git a/metadata/md5-cache/dev-libs/libdaemon-0.14-r1 b/metadata/md5-cache/dev-libs/libdaemon-0.14-r1
index c209b44..ac413b7 100644
--- a/metadata/md5-cache/dev-libs/libdaemon-0.14-r1
+++ b/metadata/md5-cache/dev-libs/libdaemon-0.14-r1
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://0pointer.de/lennart/projects/libdaemon/
 IUSE=doc examples static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd
 LICENSE=LGPL-2.1
 SLOT=0
 SRC_URI=http://0pointer.de/lennart/projects/libdaemon/libdaemon-0.14.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d92171ad83535b66c44a2c10943dd8e0
+_md5_=58d6cfcfd12db55e4951d908bd8093c6
diff --git a/metadata/md5-cache/dev-libs/libevent-1.4.13 b/metadata/md5-cache/dev-libs/libevent-1.4.13
index 950f84a..6cbb0f8 100644
--- a/metadata/md5-cache/dev-libs/libevent-1.4.13
+++ b/metadata/md5-cache/dev-libs/libevent-1.4.13
@@ -2,10 +2,10 @@
 DEPEND=|| ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool
 DESCRIPTION=A library to execute a function when a specific event occurs on a file descriptor
 HOMEPAGE=http://monkey.org/~provos/libevent/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x64-solaris ~x86-solaris
 LICENSE=BSD
 RDEPEND=!dev-libs/9libs
 SLOT=0
 SRC_URI=http://monkey.org/~provos/libevent-1.4.13-stable.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=59370dd94fd3cfc134759824d0bfbf36
+_md5_=574b6d92848e690acfae8c0cc3fc91ad
diff --git a/metadata/md5-cache/dev-libs/libevent-2.0.21 b/metadata/md5-cache/dev-libs/libevent-2.0.21
index 4d0960c..11c7fe1 100644
--- a/metadata/md5-cache/dev-libs/libevent-2.0.21
+++ b/metadata/md5-cache/dev-libs/libevent-2.0.21
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://libevent.org/
 IUSE=+ssl static-libs test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD
 RDEPEND=ssl? ( dev-libs/openssl ) !<=dev-libs/9libs-1.0
 SLOT=0
 SRC_URI=mirror://github/libevent/libevent/libevent-2.0.21-stable.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=db97f86a85cab9a18ffb06e006afaa1d
+_md5_=807e54850b6616d62e58be70ecfad8e0
diff --git a/metadata/md5-cache/dev-libs/libgpg-error-1.10-r1 b/metadata/md5-cache/dev-libs/libgpg-error-1.10-r1
index bd19b26..107b07f 100644
--- a/metadata/md5-cache/dev-libs/libgpg-error-1.10-r1
+++ b/metadata/md5-cache/dev-libs/libgpg-error-1.10-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.gnupg.org/related_software/libgpg-error
 IUSE=common-lisp nls static-libs
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2 LGPL-2.1
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://gnupg/libgpg-error/libgpg-error-1.10.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e7f3571a9fe6b50bd0c533acadd11bee
+_md5_=a791f04ab05d4210dc511ef7c3802521
diff --git a/metadata/md5-cache/dev-libs/libgpg-error-1.7 b/metadata/md5-cache/dev-libs/libgpg-error-1.7
index 19d82e4..6dd933a 100644
--- a/metadata/md5-cache/dev-libs/libgpg-error-1.7
+++ b/metadata/md5-cache/dev-libs/libgpg-error-1.7
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnupg.org/related_software/libgpg-error
 IUSE=common-lisp nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-2 LGPL-2.1
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://gnupg/libgpg-error/libgpg-error-1.7.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=cd58ff3006139d5bf8cc49806e8f10ed
+_md5_=569e91fa6f6de4afb70ffaa76fcaf84d
diff --git a/metadata/md5-cache/dev-libs/libnl-1.1-r1 b/metadata/md5-cache/dev-libs/libnl-1.1-r1
index 1bec35a..fb8ce5b 100644
--- a/metadata/md5-cache/dev-libs/libnl-1.1-r1
+++ b/metadata/md5-cache/dev-libs/libnl-1.1-r1
@@ -1,9 +1,9 @@
 DEFINED_PHASES=install unpack
 DESCRIPTION=A library for applications dealing with netlink socket
 HOMEPAGE=http://people.suug.ch/~tgr/libnl/
-KEYWORDS=amd64 arm hppa ~ia64 ppc ppc64 ~sh ~sparc x86
+KEYWORDS=amd64 arm hppa ia64 ppc ppc64 sh sparc x86
 LICENSE=LGPL-2.1
 SLOT=0
 SRC_URI=http://people.suug.ch/~tgr/libnl/files/libnl-1.1.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=4e1ba9b7324b53c32ad36bc51d46e17f
+_md5_=46acdfa356e097c3bdcccfc1568716ae
diff --git a/metadata/md5-cache/dev-libs/libnl-3.2.14 b/metadata/md5-cache/dev-libs/libnl-3.2.14
index e58f055..d7e3cc0 100644
--- a/metadata/md5-cache/dev-libs/libnl-3.2.14
+++ b/metadata/md5-cache/dev-libs/libnl-3.2.14
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://www.infradead.org/~tgr/libnl/
 IUSE=doc static-libs utils
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 ~s390 ~sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=LGPL-2.1
 SLOT=3
 SRC_URI=http://www.infradead.org/~tgr/libnl/files/libnl-3.2.14.tar.gz http://www.infradead.org/~tgr/libnl/files/libnl-doc-3.2.14.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=dfada5325af839925584404b8712878e
+_md5_=d8f930af1a77d16fec72fee5e0b25630
diff --git a/metadata/md5-cache/dev-libs/libpcre-8.30-r2 b/metadata/md5-cache/dev-libs/libpcre-8.30-r2
index 23356e6..04d854c 100644
--- a/metadata/md5-cache/dev-libs/libpcre-8.30-r2
+++ b/metadata/md5-cache/dev-libs/libpcre-8.30-r2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.pcre.org/
 IUSE=bzip2 +cxx +jit pcre16 +readline +recursion-limit static-libs unicode zlib
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD
 RDEPEND=bzip2? ( app-arch/bzip2 ) zlib? ( sys-libs/zlib ) readline? ( sys-libs/readline )
 SLOT=3
 SRC_URI=mirror://sourceforge/pcre/pcre-8.30.tar.bz2 ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.30.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ee4015e299b83d374708114c7c7f38c5
+_md5_=909a0cb34c226eae4a96c7948f473037
diff --git a/metadata/md5-cache/dev-libs/libtommath-0.42.0-r1 b/metadata/md5-cache/dev-libs/libtommath-0.42.0-r1
index 2df0a29..b8fefb3 100644
--- a/metadata/md5-cache/dev-libs/libtommath-0.42.0-r1
+++ b/metadata/md5-cache/dev-libs/libtommath-0.42.0-r1
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://www.libtom.org/
 IUSE=doc examples static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos
 LICENSE=WTFPL-2
 SLOT=0
 SRC_URI=http://www.libtom.org/files/ltm-0.42.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d6a679c2aa7579ef523a901415f06ef4
+_md5_=1b1b246e93485df1544ccc3af1db7e45
diff --git a/metadata/md5-cache/dev-libs/libusb-0.1.12-r7 b/metadata/md5-cache/dev-libs/libusb-0.1.12-r7
index 150eacc..33aea67 100644
--- a/metadata/md5-cache/dev-libs/libusb-0.1.12-r7
+++ b/metadata/md5-cache/dev-libs/libusb-0.1.12-r7
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://libusb.sourceforge.net/
 IUSE=debug doc +cxx static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=LGPL-2
 RDEPEND=!dev-libs/libusb-compat
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://sourceforge/libusb/libusb-0.1.12.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ede73358d8182e07a140bb07b080918b
+_md5_=b2b5fe4cb8206c6bd76c1f5d15b05686
diff --git a/metadata/md5-cache/dev-libs/libusb-1.0.9 b/metadata/md5-cache/dev-libs/libusb-1.0.9
index 42af993..45e2970 100644
--- a/metadata/md5-cache/dev-libs/libusb-1.0.9
+++ b/metadata/md5-cache/dev-libs/libusb-1.0.9
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://libusb.org/
 IUSE=debug doc static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 -amd64-fbsd -x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 -amd64-fbsd -x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=LGPL-2.1
 RDEPEND=!dev-libs/libusbx:1
 SLOT=1
 SRC_URI=mirror://sourceforge/libusb/libusb-1.0.9.tar.bz2
-_md5_=7fdb0854e64b472e1f22ce162bed4019
+_md5_=12ce1e4331a9182ad6c0b752a611c3ad
diff --git a/metadata/md5-cache/dev-libs/libxml2-2.9.1-r1 b/metadata/md5-cache/dev-libs/libxml2-2.9.1-r1
index 3dfe0e1..ba2daee 100644
--- a/metadata/md5-cache/dev-libs/libxml2-2.9.1-r1
+++ b/metadata/md5-cache/dev-libs/libxml2-2.9.1-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.xmlsoft.org/
 IUSE=debug examples icu ipv6 lzma readline static-libs test
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=sys-libs/zlib icu? ( dev-libs/icu ) lzma? ( app-arch/xz-utils ) readline? ( sys-libs/readline )
 SLOT=2
 SRC_URI=ftp://xmlsoft.org/libxml2/libxml2-2.9.1.tar.gz test? ( http://www.w3.org/XML/2004/xml-schema-test-suite/xmlschema2002-01-16/xsts-2002-01-16.tar.gz http://www.w3.org/XML/2004/xml-schema-test-suite/xmlschema2004-01-14/xsts-2004-01-14.tar.gz http://www.w3.org/XML/Test/xmlts20080827.tar.gz )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	prefix	21058c21ca48453d771df15500873ede	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=3a19ded92b8f93ee7f7dd0ef1b0da515
+_md5_=d7898ad1d8b0de3f7c366e53493b2a54
diff --git a/metadata/md5-cache/dev-libs/libxslt-1.1.26-r1 b/metadata/md5-cache/dev-libs/libxslt-1.1.26-r1
index 0b591ee..11e1275 100644
--- a/metadata/md5-cache/dev-libs/libxslt-1.1.26-r1
+++ b/metadata/md5-cache/dev-libs/libxslt-1.1.26-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.xmlsoft.org/
 IUSE=crypt debug python
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=dev-libs/libxml2-2.6.27:2 crypt? ( >=dev-libs/libgcrypt-1.1.42 ) >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* )
 SLOT=0
 SRC_URI=ftp://xmlsoft.org/libxslt/libxslt-1.1.26.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=620b657d862902a2dd4701c51ee3c48d
+_md5_=4c00be242dce7bd2b71dea690c349654
diff --git a/metadata/md5-cache/dev-libs/libyaml-0.1.4 b/metadata/md5-cache/dev-libs/libyaml-0.1.4
index 0f57be0..0392db5 100644
--- a/metadata/md5-cache/dev-libs/libyaml-0.1.4
+++ b/metadata/md5-cache/dev-libs/libyaml-0.1.4
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://pyyaml.org/wiki/LibYAML
 IUSE=doc examples test static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ia64 ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://pyyaml.org/download/libyaml/yaml-0.1.4.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6a798a117101aee2d2ba14eeda4117f2
+_md5_=b7558427ed9bf20b62174a402c557b29
diff --git a/metadata/md5-cache/dev-libs/lzo-2.06 b/metadata/md5-cache/dev-libs/lzo-2.06
index ad1c074..babc71a 100644
--- a/metadata/md5-cache/dev-libs/lzo-2.06
+++ b/metadata/md5-cache/dev-libs/lzo-2.06
@@ -3,8 +3,8 @@
 EAPI=4
 HOMEPAGE=http://www.oberhumer.com/opensource/lzo/
 IUSE=examples static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=2
 SRC_URI=http://www.oberhumer.com/opensource/lzo/download/lzo-2.06.tar.gz
-_md5_=d3a7b438c4d3b3d0d17e24bd92b7896d
+_md5_=754cc9edc987285deded8388d502faaa
diff --git a/metadata/md5-cache/dev-libs/m17n-lib-1.6.2 b/metadata/md5-cache/dev-libs/m17n-lib-1.6.2
index ed312cb..2d2a486 100644
--- a/metadata/md5-cache/dev-libs/m17n-lib-1.6.2
+++ b/metadata/md5-cache/dev-libs/m17n-lib-1.6.2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.m17n.org/m17n-lib/
 IUSE=gd X
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~sh ~sparc ~x86
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 ppc ppc64 sh sparc ~x86
 LICENSE=LGPL-2.1
 RDEPEND=X? ( x11-libs/libXaw x11-libs/libXft x11-libs/libX11 gd? ( media-libs/gd[png] ) dev-libs/fribidi >=media-libs/freetype-2.1 media-libs/fontconfig >=dev-libs/libotf-0.9.4 ) dev-libs/libxml2 ~dev-db/m17n-db-1.6.2
 SLOT=0
 SRC_URI=http://www.m17n.org/m17n-lib-download/m17n-lib-1.6.2.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8a33aa210013b04c3d7b29a3fe6fc446
+_md5_=5d4439bc802472a7b0850ee2ce361505
diff --git a/metadata/md5-cache/dev-libs/mpc-0.8.2 b/metadata/md5-cache/dev-libs/mpc-0.8.2
index 89d9667..be74b5f 100644
--- a/metadata/md5-cache/dev-libs/mpc-0.8.2
+++ b/metadata/md5-cache/dev-libs/mpc-0.8.2
@@ -2,10 +2,10 @@
 DEPEND=>=dev-libs/gmp-4.2.3 >=dev-libs/mpfr-2.3.1
 DESCRIPTION=A library for multiprecision complex arithmetic with exact rounding.
 HOMEPAGE=http://mpc.multiprecision.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=LGPL-2.1
 RDEPEND=>=dev-libs/gmp-4.2.3 >=dev-libs/mpfr-2.3.1
 SLOT=0
 SRC_URI=http://www.multiprecision.org/mpc/download/mpc-0.8.2.tar.gz
 _eclasses_=libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=7b8c05192cd1caa6037bcb0bca318e0a
+_md5_=9335919ce0034f9453acfd664afb397c
diff --git a/metadata/md5-cache/dev-libs/mpfr-3.0.1_p4 b/metadata/md5-cache/dev-libs/mpfr-3.0.1_p4
index 771f205..54c352f 100644
--- a/metadata/md5-cache/dev-libs/mpfr-3.0.1_p4
+++ b/metadata/md5-cache/dev-libs/mpfr-3.0.1_p4
@@ -2,10 +2,10 @@
 DEPEND=>=dev-libs/gmp-4.1.4-r2
 DESCRIPTION=library for multiple-precision floating-point computations with exact rounding
 HOMEPAGE=http://www.mpfr.org/
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=LGPL-2.1
 RDEPEND=>=dev-libs/gmp-4.1.4-r2
 SLOT=0
 SRC_URI=http://www.mpfr.org/mpfr-3.0.1/mpfr-3.0.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b4687288c2da6398a8d785da0099e90a
+_md5_=66fb1d08ddb9c0eb561a1bba8a06c1c6
diff --git a/metadata/md5-cache/dev-libs/nspr-4.10 b/metadata/md5-cache/dev-libs/nspr-4.10
index 447468e..251738a 100644
--- a/metadata/md5-cache/dev-libs/nspr-4.10
+++ b/metadata/md5-cache/dev-libs/nspr-4.10
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://www.mozilla.org/projects/nspr/
 IUSE=debug
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( MPL-2.0 GPL-2 LGPL-2.1 )
 SLOT=0
 SRC_URI=ftp://ftp.mozilla.org/pub/mozilla.org/nspr/releases/v4.10/src/nspr-4.10.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=ff71b24f2e5c575a40d3c249a80f134f
+_md5_=efdabb0f3a7dec50471cb747a04bb7ed
diff --git a/metadata/md5-cache/dev-libs/openssl-0.9.8x b/metadata/md5-cache/dev-libs/openssl-0.9.8x
index ed5a8c3..5567ea2 100644
--- a/metadata/md5-cache/dev-libs/openssl-0.9.8x
+++ b/metadata/md5-cache/dev-libs/openssl-0.9.8x
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.openssl.org/
 IUSE=bindist gmp kerberos sse2 test zlib
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=openssl
 RDEPEND=gmp? ( dev-libs/gmp ) zlib? ( sys-libs/zlib ) kerberos? ( app-crypt/mit-krb5 ) !=dev-libs/openssl-0.9.8*:0
 SLOT=0.9.8
 SRC_URI=mirror://openssl/source/openssl-0.9.8x.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d39e6085b7abfe4c84fb5adfa903f4c3
+_md5_=70790b543663d8e4d031d4416646997c
diff --git a/metadata/md5-cache/dev-libs/pkcs11-helper-1.07 b/metadata/md5-cache/dev-libs/pkcs11-helper-1.07
index c2738e7..f99c95e 100644
--- a/metadata/md5-cache/dev-libs/pkcs11-helper-1.07
+++ b/metadata/md5-cache/dev-libs/pkcs11-helper-1.07
@@ -3,10 +3,10 @@
 DESCRIPTION=PKCS#11 helper library
 HOMEPAGE=http://www.opensc-project.org/pkcs11-helper
 IUSE=doc gnutls nss
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=|| ( BSD GPL-2 )
 RDEPEND=>=dev-libs/openssl-0.9.7 gnutls? ( >=net-libs/gnutls-1.4.4 ) nss? ( dev-libs/nss )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://www.opensc-project.org/files/pkcs11-helper/pkcs11-helper-1.07.tar.bz2
-_md5_=08216d6c1e58b2fa4e914292a1a7c016
+_md5_=0c3b52e363f90ef96503a0fd5f714143
diff --git a/metadata/md5-cache/dev-libs/popt-1.16-r1 b/metadata/md5-cache/dev-libs/popt-1.16-r1
index 89c6265..d71bec2 100644
--- a/metadata/md5-cache/dev-libs/popt-1.16-r1
+++ b/metadata/md5-cache/dev-libs/popt-1.16-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://rpm5.org/
 IUSE=nls static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=MIT
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=http://rpm5.org/files/popt/popt-1.16.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=78e54b82cfb01ad08dd2cc4056c66544
+_md5_=9386dc44922cc99928431a245920c789
diff --git a/metadata/md5-cache/dev-libs/udis86-1.7 b/metadata/md5-cache/dev-libs/udis86-1.7
index eead53e..7c31760 100644
--- a/metadata/md5-cache/dev-libs/udis86-1.7
+++ b/metadata/md5-cache/dev-libs/udis86-1.7
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://udis86.sourceforge.net/
 IUSE=pic test
-KEYWORDS=amd64 ~hppa ppc ~ppc64 x86 ~x86-fbsd
+KEYWORDS=amd64 hppa ppc ppc64 x86 ~x86-fbsd
 LICENSE=BSD
 SLOT=0
 SRC_URI=mirror://sourceforge/udis86/udis86-1.7.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=106370f6cd38b77fe5451531f6acb3d3
+_md5_=67ba30abc7e5bae39ea7ab06533c4e04
diff --git a/metadata/md5-cache/dev-libs/xmlrpc-c-1.18.02 b/metadata/md5-cache/dev-libs/xmlrpc-c-1.18.02
index 79db009..b9f41ce 100644
--- a/metadata/md5-cache/dev-libs/xmlrpc-c-1.18.02
+++ b/metadata/md5-cache/dev-libs/xmlrpc-c-1.18.02
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://xmlrpc-c.sourceforge.net/
 IUSE=+curl +cxx tools +cgi abyss threads
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86
 LICENSE=BSD
 RDEPEND=dev-libs/libxml2 tools? ( dev-perl/frontier-rpc ) curl? ( net-misc/curl )
 SLOT=0
 SRC_URI=mirror://gentoo/xmlrpc-c/xmlrpc-c-1.18.02.tar.bz2
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c94da80195b1446bf64b8e6cfbf00127
+_md5_=b7e27139cab29167210ac87b170c8ed8
diff --git a/metadata/md5-cache/dev-perl/Crypt-PasswdMD5-1.300.0 b/metadata/md5-cache/dev-perl/Crypt-PasswdMD5-1.300.0
index c2fa2f1..22c5a4c 100644
--- a/metadata/md5-cache/dev-perl/Crypt-PasswdMD5-1.300.0
+++ b/metadata/md5-cache/dev-perl/Crypt-PasswdMD5-1.300.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Provides interoperable MD5-based crypt() functions
 EAPI=4
 HOMEPAGE=http://search.cpan.org/dist/Crypt-PasswdMD5/
-KEYWORDS=amd64 ~ppc ~ppc64 ~sparc x86
+KEYWORDS=amd64 ppc ppc64 sparc x86
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 ) BEER-WARE
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/L/LU/LUISMUNOZ/Crypt-PasswdMD5-1.3.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e19201bdf12e1539ddd42007965d1099
+_md5_=28b2eb52d55d65d00bd8b4fbb0bb16d8
diff --git a/metadata/md5-cache/dev-perl/Digest-SHA1-2.12 b/metadata/md5-cache/dev-perl/Digest-SHA1-2.12
index e152abe..8b1eb47 100644
--- a/metadata/md5-cache/dev-perl/Digest-SHA1-2.12
+++ b/metadata/md5-cache/dev-perl/Digest-SHA1-2.12
@@ -3,10 +3,10 @@
 DESCRIPTION=NIST SHA message digest algorithm
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/Digest-SHA1/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=virtual/perl-digest-base dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/G/GA/GAAS/Digest-SHA1-2.12.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=21db77a308806521294a39cb9fad3057
+_md5_=2b840b6b79a55b9a331f7ea38b5ffab8
diff --git a/metadata/md5-cache/dev-perl/GD-2.460.0 b/metadata/md5-cache/dev-perl/GD-2.460.0
index 7762dca..ef12caa 100644
--- a/metadata/md5-cache/dev-perl/GD-2.460.0
+++ b/metadata/md5-cache/dev-perl/GD-2.460.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://search.cpan.org/dist/GD/
 IUSE=animgif gif jpeg png truetype xpm
-KEYWORDS=alpha amd64 ~arm hppa ia64 ~mips ppc ppc64 sparc x86 ~x86-fbsd ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 mips ppc ppc64 sparc x86 ~x86-fbsd ~x86-solaris
 LICENSE=|| ( Artistic-2 GPL-1 GPL-2 GPL-3 )
 RDEPEND=>=media-libs/gd-2.0.33 png? ( media-libs/gd[png] media-libs/libpng sys-libs/zlib ) jpeg? ( media-libs/gd[jpeg] virtual/jpeg ) truetype? ( media-libs/gd[truetype] media-libs/freetype:2 ) xpm? ( media-libs/gd[xpm] x11-libs/libXpm ) gif? ( media-libs/giflib ) dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/L/LD/LDS/GD-2.46.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=1f89459a8cdb02eb42d7a06ab86b4ba5
+_md5_=56f66c089ca8d8b34078ce11d2ba57d8
diff --git a/metadata/md5-cache/dev-perl/Locale-gettext-1.50.0 b/metadata/md5-cache/dev-perl/Locale-gettext-1.50.0
index 693d259..5def9b5 100644
--- a/metadata/md5-cache/dev-perl/Locale-gettext-1.50.0
+++ b/metadata/md5-cache/dev-perl/Locale-gettext-1.50.0
@@ -3,10 +3,10 @@
 DESCRIPTION=A Perl module for accessing the GNU locale utilities
 EAPI=4
 HOMEPAGE=http://search.cpan.org/dist/gettext/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=sys-devel/gettext dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/P/PV/PVANDRY/gettext-1.05.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9529ad95f40146d5eff368aaeee76047
+_md5_=ded1f98048df8ecf0006db84c98b3d0a
diff --git a/metadata/md5-cache/dev-perl/Text-Unidecode-0.40.0 b/metadata/md5-cache/dev-perl/Text-Unidecode-0.40.0
index 01959f8..057134e 100644
--- a/metadata/md5-cache/dev-perl/Text-Unidecode-0.40.0
+++ b/metadata/md5-cache/dev-perl/Text-Unidecode-0.40.0
@@ -3,10 +3,10 @@
 DESCRIPTION=US-ASCII transliterations of Unicode text
 EAPI=4
 HOMEPAGE=http://search.cpan.org/dist/Text-Unidecode/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/S/SB/SBURKE/Text-Unidecode-0.04.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f09aaeecb1f5000e4d34c4495f2381df
+_md5_=9ce1d45edd68d72aa4c816bb9dc0dcb5
diff --git a/metadata/md5-cache/dev-perl/URI-1.55 b/metadata/md5-cache/dev-perl/URI-1.55
index 8497b2a..1ebd8e7 100644
--- a/metadata/md5-cache/dev-perl/URI-1.55
+++ b/metadata/md5-cache/dev-perl/URI-1.55
@@ -3,10 +3,10 @@
 DESCRIPTION=A URI Perl Module
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/URI/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=virtual/perl-MIME-Base64 dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/G/GA/GAAS/URI-1.55.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=08d18b62934a92e2f6705a060c5e8706
+_md5_=60d7793652012223287c76ca70b8b995
diff --git a/metadata/md5-cache/dev-perl/XML-Parser-2.410.0 b/metadata/md5-cache/dev-perl/XML-Parser-2.410.0
index b1b8f06..48a01eb 100644
--- a/metadata/md5-cache/dev-perl/XML-Parser-2.410.0
+++ b/metadata/md5-cache/dev-perl/XML-Parser-2.410.0
@@ -3,10 +3,10 @@
 DESCRIPTION=A Perl extension interface to James Clark's XML parser, expat
 EAPI=4
 HOMEPAGE=http://search.cpan.org/dist/XML-Parser/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=>=dev-libs/expat-1.95.1-r1 dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/T/TO/TODDR/XML-Parser-2.41.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6f9526487d0041966bd90011e69391f5
+_md5_=b2bcd651dd6b402d5cf22e87fa426086
diff --git a/metadata/md5-cache/dev-perl/libintl-perl-1.200.0 b/metadata/md5-cache/dev-perl/libintl-perl-1.200.0
index dc26ec6..175ab90 100644
--- a/metadata/md5-cache/dev-perl/libintl-perl-1.200.0
+++ b/metadata/md5-cache/dev-perl/libintl-perl-1.200.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Perl internationalization library that aims to be compatible with the Uniforum message translations system
 EAPI=4
 HOMEPAGE=http://guido-flohr.net/projects/libintl-perl http://search.cpan.org/dist/libintl-perl/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=LGPL-2.1
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/G/GU/GUIDO/libintl-perl-1.20.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6b8dce258e7b891d090c9f52e87594b7
+_md5_=91cd14bea9e85dc4d082bdaedea2dcf7
diff --git a/metadata/md5-cache/dev-perl/yaml-0.71 b/metadata/md5-cache/dev-perl/yaml-0.71
index d790c7e..00a7903 100644
--- a/metadata/md5-cache/dev-perl/yaml-0.71
+++ b/metadata/md5-cache/dev-perl/yaml-0.71
@@ -3,10 +3,10 @@
 DESCRIPTION=YAML Ain't Markup Language (tm)
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/YAML/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/A/AD/ADAMK/YAML-0.71.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a970b9a5063a3c0c975b4127ea4a4a30
+_md5_=4be614813cded50a42cadc33657ae4b0
diff --git a/metadata/md5-cache/dev-python/argparse-1.2.1 b/metadata/md5-cache/dev-python/argparse-1.2.1
index 455c091..60a0bf9 100644
--- a/metadata/md5-cache/dev-python/argparse-1.2.1
+++ b/metadata/md5-cache/dev-python/argparse-1.2.1
@@ -3,10 +3,10 @@
 DESCRIPTION=Provides an easy, declarative interface for creating command line tools.
 EAPI=3
 HOMEPAGE=http://code.google.com/p/argparse/ http://pypi.python.org/pypi/argparse
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x86-solaris
 LICENSE=PSF-2
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=http://argparse.googlecode.com/files/argparse-1.2.1.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=9f3ffa322c6d551693c14afed374ed61
+_md5_=a2b1940eb663f3aaf9e8ccc59f230f66
diff --git a/metadata/md5-cache/dev-python/astng-0.21.1 b/metadata/md5-cache/dev-python/astng-0.21.1
index 4a2b268..9342b13 100644
--- a/metadata/md5-cache/dev-python/astng-0.21.1
+++ b/metadata/md5-cache/dev-python/astng-0.21.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.logilab.org/projects/astng/ http://pypi.python.org/pypi/logilab-astng
 IUSE=test
-KEYWORDS=~amd64 ~ia64 ~ppc ~ppc64 ~sparc ~x86 ~x64-macos ~x86-macos
+KEYWORDS=~amd64 ia64 ppc ppc64 sparc ~x86 ~x64-macos ~x86-macos
 LICENSE=LGPL-2.1
 RDEPEND=>=dev-python/logilab-common-0.53.0 >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=ftp://ftp.logilab.org/pub/astng/logilab-astng-0.21.1.tar.gz mirror://pypi/l/logilab-astng/logilab-astng-0.21.1.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=039bfd2ffc518979a5853cad7b3cfafd
+_md5_=1326fd7b5b3a6ae7e56fdd44bb191547
diff --git a/metadata/md5-cache/dev-python/beaker-1.5.4-r1 b/metadata/md5-cache/dev-python/beaker-1.5.4-r1
index 26ed3ab..63b66c6 100644
--- a/metadata/md5-cache/dev-python/beaker-1.5.4-r1
+++ b/metadata/md5-cache/dev-python/beaker-1.5.4-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://beaker.groovie.org/ http://pypi.python.org/pypi/Beaker
 IUSE=test test
-KEYWORDS=amd64 arm ppc ~sparc x86 ~amd64-linux ~x86-linux ~x64-macos ~x86-macos
+KEYWORDS=amd64 arm ppc sparc x86 ~amd64-linux ~x86-linux ~x64-macos ~x86-macos
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/B/Beaker/Beaker-1.5.4.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=cb629575fb613679a5a41a09c9e95f32
+_md5_=21c0358e6563bb0870b21b46a2d29b3b
diff --git a/metadata/md5-cache/dev-python/boto-2.5.2 b/metadata/md5-cache/dev-python/boto-2.5.2
index 0e93f92..70ab875 100644
--- a/metadata/md5-cache/dev-python/boto-2.5.2
+++ b/metadata/md5-cache/dev-python/boto-2.5.2
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=https://github.com/boto/boto http://pypi.python.org/pypi/boto
 IUSE=test
-KEYWORDS=amd64 ~ppc ~sparc x86 ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=amd64 ppc sparc x86 ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=MIT
 RDEPEND=dev-python/m2crypto >=app-admin/eselect-python-20091230 || ( =dev-lang/python-2.7* =dev-lang/python-2.6* =dev-lang/python-2.5* )
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://github/boto/boto/boto-2.5.2.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=291fe1517c8abf2f0f525eb945aa1ab8
+_md5_=6d00a1feb47c19be07cde97916c69810
diff --git a/metadata/md5-cache/dev-python/ctypesgen-0_p72 b/metadata/md5-cache/dev-python/ctypesgen-0_p72
index a17bf48..9f1423e 100644
--- a/metadata/md5-cache/dev-python/ctypesgen-0_p72
+++ b/metadata/md5-cache/dev-python/ctypesgen-0_p72
@@ -3,10 +3,10 @@
 DESCRIPTION=Python wrapper generator for ctypes
 EAPI=3
 HOMEPAGE=http://code.google.com/p/ctypesgen/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 || ( =dev-lang/python-2.7* =dev-lang/python-2.6* =dev-lang/python-2.5* )
 SLOT=0
 SRC_URI=mirror://gentoo/ctypesgen-0_p72.tar.bz2
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=9e1fb2db94fbbdd4f5e6cf2fab874078
+_md5_=582c661cdafec89c55340d84d9e24616
diff --git a/metadata/md5-cache/dev-python/dbus-python-0.84.0 b/metadata/md5-cache/dev-python/dbus-python-0.84.0
index afc3453..5248e6f 100644
--- a/metadata/md5-cache/dev-python/dbus-python-0.84.0
+++ b/metadata/md5-cache/dev-python/dbus-python-0.84.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.freedesktop.org/wiki/Software/DBusBindings http://dbus.freedesktop.org/doc/dbus-python/
 IUSE=doc examples test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ~ppc ~ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=MIT
 RDEPEND=>=dev-libs/dbus-glib-0.88 >=sys-apps/dbus-1.4.1 >=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=http://dbus.freedesktop.org/releases/dbus-python/dbus-python-0.84.0.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=936062a77efb89bbd31d13d0fdbe64c3
+_md5_=49d3dfd52d95267921bdd3cfec7cb68e
diff --git a/metadata/md5-cache/dev-python/django-1.4.1 b/metadata/md5-cache/dev-python/django-1.4.1
index b1c8d5c..ea948f1 100644
--- a/metadata/md5-cache/dev-python/django-1.4.1
+++ b/metadata/md5-cache/dev-python/django-1.4.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.djangoproject.com/ http://pypi.python.org/pypi/Django
 IUSE=doc mysql postgres sqlite test vhosts
-KEYWORDS=amd64 ~ia64 ~ppc ~ppc64 ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=amd64 ia64 ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=BSD
 RDEPEND=dev-python/imaging sqlite? ( || ( dev-lang/python:2.7[sqlite] dev-lang/python:2.6[sqlite] dev-lang/python:2.5[sqlite] dev-python/pysqlite:2 ) ) postgres? ( dev-python/psycopg:2 ) mysql? ( >=dev-python/mysql-python-1.2.1_p2 ) >=app-admin/eselect-python-20091230 =dev-lang/python-2* >=app-admin/webapp-config-1.50.15
 SLOT=0
 SRC_URI=https://www.djangoproject.com/m/releases/1.4/Django-1.4.1.tar.gz
 _eclasses_=bash-completion-r1	3480f8385cb9e31797e7b659e366e2d2	distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	webapp	b5c5b98a2289a6050810cf6022ac00be
-_md5_=40c51a2549cb73e7c41c23f05d749e2a
+_md5_=b9080657a3df0872034741dd4b9f1008
diff --git a/metadata/md5-cache/dev-python/flup-1.0.2 b/metadata/md5-cache/dev-python/flup-1.0.2
index ca16f09..0ecb0ec 100644
--- a/metadata/md5-cache/dev-python/flup-1.0.2
+++ b/metadata/md5-cache/dev-python/flup-1.0.2
@@ -3,10 +3,10 @@
 DESCRIPTION=Random assortment of WSGI servers
 EAPI=2
 HOMEPAGE=http://trac.saddi.com/flup http://pypi.python.org/pypi/flup
-KEYWORDS=amd64 ~arm ~ia64 ppc ~ppc64 ~sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux ~x86-macos
+KEYWORDS=amd64 ~arm ia64 ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux ~x86-macos
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=http://www.saddi.com/software/flup/dist/flup-1.0.2.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=022099933d91461a60d96d958a54ed7c
+_md5_=4a382048958e258ade19e2e85d415790
diff --git a/metadata/md5-cache/dev-python/imaging-1.1.7-r1 b/metadata/md5-cache/dev-python/imaging-1.1.7-r1
index 43584c0..66e5630 100644
--- a/metadata/md5-cache/dev-python/imaging-1.1.7-r1
+++ b/metadata/md5-cache/dev-python/imaging-1.1.7-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.pythonware.com/products/pil/index.htm
 IUSE=doc examples lcms scanner tk X
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ppc ppc64 ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x86-solaris
 LICENSE=as-is
 RDEPEND=virtual/jpeg media-libs/freetype:2 lcms? ( media-libs/lcms:0 ) scanner? ( media-gfx/sane-backends ) X? ( x11-misc/xdg-utils ) >=app-admin/eselect-python-20091230 =dev-lang/python-2* tk? ( =dev-lang/python-2*[tk] )
 SLOT=0
 SRC_URI=http://www.effbot.org/downloads/Imaging-1.1.7.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d5f4b5a6eb7b127feffdbf9f0df95d71
+_md5_=f074d5a530a806584e7d8233e73b2684
diff --git a/metadata/md5-cache/dev-python/logilab-common-0.53.0 b/metadata/md5-cache/dev-python/logilab-common-0.53.0
index 3dc5dbc..f287fdb 100644
--- a/metadata/md5-cache/dev-python/logilab-common-0.53.0
+++ b/metadata/md5-cache/dev-python/logilab-common-0.53.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.logilab.org/projects/common/ http://pypi.python.org/pypi/logilab-common
 IUSE=test
-KEYWORDS=~amd64 ~ia64 ~ppc ~ppc64 ~s390 ~sparc ~x86 ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=~amd64 ia64 ppc ppc64 s390 sparc ~x86 ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=LGPL-2.1
 RDEPEND=dev-python/setuptools >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=ftp://ftp.logilab.org/pub/common/logilab-common-0.53.0.tar.gz mirror://pypi/l/logilab-common/logilab-common-0.53.0.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2d28d90edb0501c86f8ced905677c481
+_md5_=85ad432e229986d7eb6307716a716058
diff --git a/metadata/md5-cache/dev-python/m2crypto-0.21.1 b/metadata/md5-cache/dev-python/m2crypto-0.21.1
index 17a2645..668d6ea 100644
--- a/metadata/md5-cache/dev-python/m2crypto-0.21.1
+++ b/metadata/md5-cache/dev-python/m2crypto-0.21.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://chandlerproject.org/bin/view/Projects/MeTooCrypto http://pypi.python.org/pypi/M2Crypto
 IUSE=doc examples
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=BSD
 RDEPEND=>=dev-libs/openssl-0.9.8 >=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=mirror://pypi/M/M2Crypto/M2Crypto-0.21.1.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=510fa4db78b76fbca399ab1eff762bf8
+_md5_=c8cf156e4747508b6dfd7951cd0498b6
diff --git a/metadata/md5-cache/dev-python/mako-0.7.0 b/metadata/md5-cache/dev-python/mako-0.7.0
index 02430d3..9ed3263 100644
--- a/metadata/md5-cache/dev-python/mako-0.7.0
+++ b/metadata/md5-cache/dev-python/mako-0.7.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.makotemplates.org/ http://pypi.python.org/pypi/Mako
 IUSE=doc test
-KEYWORDS=amd64 arm ~hppa ppc ~sparc x86 ~amd64-linux ~x86-linux ~x64-macos ~x86-macos
+KEYWORDS=amd64 arm hppa ppc sparc x86 ~amd64-linux ~x86-linux ~x64-macos ~x86-macos
 LICENSE=MIT
 RDEPEND=>=dev-python/beaker-1.1 >=dev-python/markupsafe-0.9.2 >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=http://www.makotemplates.org/downloads/Mako-0.7.0.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8fa7ec69adfa19c0c5afbe8b65b37ac5
+_md5_=adc6fd3b8511b8c30836f6ea4bf7c706
diff --git a/metadata/md5-cache/dev-python/markupsafe-0.15 b/metadata/md5-cache/dev-python/markupsafe-0.15
index 24f1d48..8060006 100644
--- a/metadata/md5-cache/dev-python/markupsafe-0.15
+++ b/metadata/md5-cache/dev-python/markupsafe-0.15
@@ -3,10 +3,10 @@
 DESCRIPTION=Implements a XML/HTML/XHTML Markup safe string for Python
 EAPI=3
 HOMEPAGE=http://pypi.python.org/pypi/MarkupSafe
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/M/MarkupSafe/MarkupSafe-0.15.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=dd64fbe7f9c2d9102da63c5ec8eea4f1
+_md5_=7a4a79d08fcdbec8d8614f091bb131a4
diff --git a/metadata/md5-cache/dev-python/mock-1.0.1 b/metadata/md5-cache/dev-python/mock-1.0.1
index eeb0d6c..949b119 100644
--- a/metadata/md5-cache/dev-python/mock-1.0.1
+++ b/metadata/md5-cache/dev-python/mock-1.0.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.voidspace.org.uk/python/mock/ http://pypi.python.org/pypi/mock
 IUSE=doc test test
-KEYWORDS=~alpha amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x64-macos
+KEYWORDS=alpha amd64 ~arm hppa ia64 ppc ppc64 s390 sh sparc ~x86 ~x64-macos
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/m/mock/mock-1.0.1.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=9998553f8ec3d91a21e740e93b840024
+_md5_=4fdeb70b6affe3a2c2667ace87604406
diff --git a/metadata/md5-cache/dev-python/mox-0.5.3 b/metadata/md5-cache/dev-python/mox-0.5.3
index a98fbd8..a15a995 100644
--- a/metadata/md5-cache/dev-python/mox-0.5.3
+++ b/metadata/md5-cache/dev-python/mox-0.5.3
@@ -3,10 +3,10 @@
 DESCRIPTION=A mock object framework for Python, loosely based on EasyMock for Java
 EAPI=3
 HOMEPAGE=http://code.google.com/p/pymox/
-KEYWORDS=amd64 ppc ~sparc x86
+KEYWORDS=amd64 ppc sparc x86
 LICENSE=Apache-2.0
 RDEPEND=>=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=http://pymox.googlecode.com/files/mox-0.5.3.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=2170c92d6e1a6751c2d9a0afae12aa4e
+_md5_=0f0ab918ee4a182d289a85d203907a54
diff --git a/metadata/md5-cache/dev-python/nose-1.1.2 b/metadata/md5-cache/dev-python/nose-1.1.2
index c9ae51f..0b1cc88 100644
--- a/metadata/md5-cache/dev-python/nose-1.1.2
+++ b/metadata/md5-cache/dev-python/nose-1.1.2
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://pypi.python.org/pypi/nose http://readthedocs.org/docs/nose/ https://bitbucket.org/jpellerin/nose
 IUSE=coverage doc examples test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=LGPL-2.1
 RDEPEND=coverage? ( dev-python/coverage ) dev-python/setuptools >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/n/nose/nose-1.1.2.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c0d43eb864baad8e00b5278b4a388bb6
+_md5_=da18ba7a196284f5ddb375eb676cdabc
diff --git a/metadata/md5-cache/dev-python/pycairo-1.8.8 b/metadata/md5-cache/dev-python/pycairo-1.8.8
index 84c0c06..127ef78 100644
--- a/metadata/md5-cache/dev-python/pycairo-1.8.8
+++ b/metadata/md5-cache/dev-python/pycairo-1.8.8
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://cairographics.org/pycairo/ http://pypi.python.org/pypi/pycairo
 IUSE=doc examples svg
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( LGPL-2.1 MPL-1.1 )
 RDEPEND=>=x11-libs/cairo-1.8.8[svg?] >=app-admin/eselect-python-20091230 || ( =dev-lang/python-2.7* =dev-lang/python-2.6* )
 SLOT=0
 SRC_URI=http://cairographics.org/releases/pycairo-1.8.8.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c34c2540cb0ed6beed6e66329b63a15f
+_md5_=26b6874ddfa1e07cca1309fd297b5b72
diff --git a/metadata/md5-cache/dev-python/pyinotify-0.9.3 b/metadata/md5-cache/dev-python/pyinotify-0.9.3
index 41079e4..6e23d3b 100644
--- a/metadata/md5-cache/dev-python/pyinotify-0.9.3
+++ b/metadata/md5-cache/dev-python/pyinotify-0.9.3
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://trac.dbzteam.org/pyinotify http://pypi.python.org/pypi/pyinotify
 IUSE=examples
-KEYWORDS=amd64 ~ppc ~x86 ~amd64-linux ~x86-linux
+KEYWORDS=amd64 ppc ~x86 ~amd64-linux ~x86-linux
 LICENSE=MIT
 RDEPEND=>=app-admin/eselect-python-20091230 || ( =dev-lang/python-3.2* =dev-lang/python-3.1* =dev-lang/python-2.7* =dev-lang/python-2.6* =dev-lang/python-2.5* )
 SLOT=0
 SRC_URI=http://seb.dbzteam.org/pub/pyinotify/releases/pyinotify-0.9.3.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=835f8f8dd04ebf768c17a227173958b2
+_md5_=51483137529e1e719f9ecfcbddaa8c38
diff --git a/metadata/md5-cache/dev-python/pyopenssl-0.10 b/metadata/md5-cache/dev-python/pyopenssl-0.10
index 74335cf..a475d09 100644
--- a/metadata/md5-cache/dev-python/pyopenssl-0.10
+++ b/metadata/md5-cache/dev-python/pyopenssl-0.10
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://pyopenssl.sourceforge.net/ http://pypi.python.org/pypi/pyOpenSSL
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~x86-macos ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~x86-macos ~x64-solaris
 LICENSE=LGPL-2.1
 RDEPEND=>=dev-libs/openssl-0.9.6g >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=http://pypi.python.org/packages/source/p/pyOpenSSL/pyOpenSSL-0.10.tar.gz mirror://sourceforge/pyopenssl/pyOpenSSL-0.10.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=07783879c0970663547c23b2b1fb9caf
+_md5_=1fb33e6f20a8da7b120460356461e3aa
diff --git a/metadata/md5-cache/dev-python/pyserial-2.5_rc2 b/metadata/md5-cache/dev-python/pyserial-2.5_rc2
index 6a21e4a..b4c32ab 100644
--- a/metadata/md5-cache/dev-python/pyserial-2.5_rc2
+++ b/metadata/md5-cache/dev-python/pyserial-2.5_rc2
@@ -3,10 +3,10 @@
 DESCRIPTION=Python Serial Port Extension
 EAPI=2
 HOMEPAGE=http://pyserial.sourceforge.net/ http://pyserial.wiki.sourceforge.net/pySerial http://pypi.python.org/pypi/pyserial
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=PYTHON
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=http://pypi.python.org/packages/source/p/pyserial/pyserial-2.5-rc2.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=9db9942a89e6fcc657ee301e6d289325
+_md5_=0a64ba9ce74b4410c78c1af16dfa58a4
diff --git a/metadata/md5-cache/dev-python/python-dateutil-2.1 b/metadata/md5-cache/dev-python/python-dateutil-2.1
index 6b1a425..8ff6412 100644
--- a/metadata/md5-cache/dev-python/python-dateutil-2.1
+++ b/metadata/md5-cache/dev-python/python-dateutil-2.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=https://launchpad.net/dateutil http://pypi.python.org/pypi/python-dateutil
 IUSE=examples
-KEYWORDS=amd64 ia64 ppc ~ppc64 x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=amd64 ia64 ppc ppc64 x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=BSD
 RDEPEND=dev-python/six sys-libs/timezone-data !<dev-python/python-dateutil-2.1 >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/p/python-dateutil/python-dateutil-2.1.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c1953645ebc8bbbca73ad23e6a22d80c
+_md5_=24b578ae08fafab2106b8001d14efe4b
diff --git a/metadata/md5-cache/dev-python/python-xlib-0.14 b/metadata/md5-cache/dev-python/python-xlib-0.14
index 4122255..70e95c5 100644
--- a/metadata/md5-cache/dev-python/python-xlib-0.14
+++ b/metadata/md5-cache/dev-python/python-xlib-0.14
@@ -3,10 +3,10 @@
 DESCRIPTION=A fully functional X client library for Python, written in Python
 HOMEPAGE=http://python-xlib.sourceforge.net/
 IUSE=doc
-KEYWORDS=alpha amd64 ~arm ia64 ppc ~ppc64 x86
+KEYWORDS=alpha amd64 ~arm ia64 ppc ppc64 x86
 LICENSE=GPL-2
 RDEPEND=doc? ( virtual/latex-base >=sys-apps/texinfo-4.8-r2 ) >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://sourceforge/python-xlib/python-xlib-0.14.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=cbf00ad84b34f35cdcbdc2aedb613e80
+_md5_=b3539f6317a14973f789ea0cf2b21226
diff --git a/metadata/md5-cache/dev-python/pyusb-0.4.3 b/metadata/md5-cache/dev-python/pyusb-0.4.3
index 039d431..4a40fcd 100644
--- a/metadata/md5-cache/dev-python/pyusb-0.4.3
+++ b/metadata/md5-cache/dev-python/pyusb-0.4.3
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://pyusb.sourceforge.net/
 IUSE=examples
-KEYWORDS=~amd64 ~ppc ~x86
+KEYWORDS=~amd64 ppc ~x86
 LICENSE=BSD
 RDEPEND=virtual/libusb:0 >=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://sourceforge/pyusb/pyusb-0.4.3.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=eff452d6814c8be932279aae0c74d506
+_md5_=8d73e097241cf4351228632d87864ad6
diff --git a/metadata/md5-cache/dev-python/setproctitle-1.1.6 b/metadata/md5-cache/dev-python/setproctitle-1.1.6
index 5bafba9..d424d0f 100644
--- a/metadata/md5-cache/dev-python/setproctitle-1.1.6
+++ b/metadata/md5-cache/dev-python/setproctitle-1.1.6
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://code.google.com/p/py-setproctitle/ http://pypi.python.org/pypi/setproctitle
 IUSE=test
-KEYWORDS=amd64 arm ~sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=amd64 arm sparc x86 ~amd64-linux ~x86-linux
 LICENSE=BSD
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/s/setproctitle/setproctitle-1.1.6.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=9368c3df1c222c403963685bb25b114b
+_md5_=373a8ab6e5d2517c587007abfe1263e6
diff --git a/metadata/md5-cache/dev-python/setuptools-0.6.14 b/metadata/md5-cache/dev-python/setuptools-0.6.14
index 85f2026..801ddfd 100644
--- a/metadata/md5-cache/dev-python/setuptools-0.6.14
+++ b/metadata/md5-cache/dev-python/setuptools-0.6.14
@@ -3,10 +3,10 @@
 DESCRIPTION=Distribute (fork of Setuptools) is a collection of extensions to Distutils
 EAPI=3
 HOMEPAGE=http://pypi.python.org/pypi/distribute
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=PSF-2
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/d/distribute/distribute-0.6.14.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=46ddc53417e3769cd2dd80321c61a3a2
+_md5_=416b607eff284bba91c6983c988dbe88
diff --git a/metadata/md5-cache/dev-python/simplejson-2.5.0 b/metadata/md5-cache/dev-python/simplejson-2.5.0
index cf0a41f..da4df84 100644
--- a/metadata/md5-cache/dev-python/simplejson-2.5.0
+++ b/metadata/md5-cache/dev-python/simplejson-2.5.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Simple, fast, extensible JSON encoder/decoder for Python
 EAPI=3
 HOMEPAGE=http://undefined.org/python/#simplejson http://pypi.python.org/pypi/simplejson
-KEYWORDS=amd64 arm ppc ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=amd64 arm ppc sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=MIT
 RDEPEND=>=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=mirror://pypi/s/simplejson/simplejson-2.5.0.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=4f90ffca5356c353d94b70230e26bcfc
+_md5_=3dfc3974c54da618155b4f437333297e
diff --git a/metadata/md5-cache/dev-python/six-1.1.0 b/metadata/md5-cache/dev-python/six-1.1.0
index 63009de..84972fc 100644
--- a/metadata/md5-cache/dev-python/six-1.1.0
+++ b/metadata/md5-cache/dev-python/six-1.1.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://pypi.python.org/pypi/six
 IUSE=doc
-KEYWORDS=amd64 ia64 ppc ~ppc64 x86 ~x86-fbsd ~amd64-linux ~x86-linux ~x86-macos
+KEYWORDS=amd64 ia64 ppc ppc64 x86 ~x86-fbsd ~amd64-linux ~x86-linux ~x86-macos
 LICENSE=MIT
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/s/six/six-1.1.0.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=e8caf2d6ec2d3e8fe8b8ce1af68a98ba
+_md5_=463e3772ab4c23592d12f390c40ec68b
diff --git a/metadata/md5-cache/dev-python/twisted-11.0.0 b/metadata/md5-cache/dev-python/twisted-11.0.0
index 8852947..a97623f 100644
--- a/metadata/md5-cache/dev-python/twisted-11.0.0
+++ b/metadata/md5-cache/dev-python/twisted-11.0.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.twistedmatrix.com/ http://pypi.python.org/pypi/Twisted
 IUSE=crypt gtk serial
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=>=net-zope/zope-interface-3.0.1 crypt? ( >=dev-python/pyopenssl-0.5.1 ) gtk? ( >=dev-python/pygtk-1.99 ) serial? ( dev-python/pyserial ) >=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=http://tmrc.mit.edu/mirror/twisted/Core/11.0/TwistedCore-11.0.0.tar.bz2
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	twisted	b8ba94e8ee03d301a1eebc496249b8f3	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=7d1b57dffa655a29a95e72c2f513d80f
+_md5_=bbce9f7a87d8e056885601f2cc191168
diff --git a/metadata/md5-cache/dev-tcltk/expect-5.44.1.15 b/metadata/md5-cache/dev-tcltk/expect-5.44.1.15
index e056c86..b8d159a 100644
--- a/metadata/md5-cache/dev-tcltk/expect-5.44.1.15
+++ b/metadata/md5-cache/dev-tcltk/expect-5.44.1.15
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://expect.nist.gov/
 IUSE=debug doc threads X
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~x86-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~x86-macos ~x86-solaris
 LICENSE=BSD
 RDEPEND=>=dev-lang/tcl-8.2[threads?] X? ( >=dev-lang/tk-8.2[threads?] )
 SLOT=0
 SRC_URI=mirror://sourceforge/expect/expect-5.44.1.15.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b850af58b0ec4088611c5b46a59874f8
+_md5_=d2a11fc33ff16e4e94718cbd260cb278
diff --git a/metadata/md5-cache/dev-util/ccache-3.1.9 b/metadata/md5-cache/dev-util/ccache-3.1.9
index c7ea6b3..e1e1cfb 100644
--- a/metadata/md5-cache/dev-util/ccache-3.1.9
+++ b/metadata/md5-cache/dev-util/ccache-3.1.9
@@ -3,10 +3,10 @@
 DESCRIPTION=fast compiler cache
 EAPI=4
 HOMEPAGE=http://ccache.samba.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=sys-libs/zlib
 SLOT=0
 SRC_URI=http://samba.org/ftp/ccache/ccache-3.1.9.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d5fc682c1d10cbf15649cebf48aa070a
+_md5_=ac6bc1af0477aefce3dfb6212b1d6035
diff --git a/metadata/md5-cache/dev-util/cmake-2.8.6-r4 b/metadata/md5-cache/dev-util/cmake-2.8.6-r4
index d007bbc..7131706 100644
--- a/metadata/md5-cache/dev-util/cmake-2.8.6-r4
+++ b/metadata/md5-cache/dev-util/cmake-2.8.6-r4
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.cmake.org/
 IUSE=emacs ncurses qt4 vim-syntax test
-KEYWORDS=~alpha amd64 ~arm hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=CMake
 RDEPEND=>=app-arch/libarchive-2.8.0 >=net-misc/curl-7.20.0-r1[ssl] >=dev-libs/expat-2.0.1 dev-util/pkgconfig sys-libs/zlib ncurses? ( sys-libs/ncurses ) qt4? ( x11-libs/qt-gui:4 ) emacs? ( virtual/emacs ) vim-syntax? ( || ( app-editors/vim app-editors/gvim ) )
 SLOT=0
 SRC_URI=http://www.cmake.org/files/v2.8/cmake-2.8.6.tar.gz
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	cmake-utils	00f9fd5a80cf3605f6d9a2e808c48a92	elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	virtualx	e9162f65645513120b4e12863a5fa972
-_md5_=1b754512430451214b181ca9f5d4f60e
+_md5_=7f449ac727bff042089c253d3431d87b
diff --git a/metadata/md5-cache/dev-util/cscope-15.7a-r1 b/metadata/md5-cache/dev-util/cscope-15.7a-r1
index 3bbdb78..07ac4a1 100644
--- a/metadata/md5-cache/dev-util/cscope-15.7a-r1
+++ b/metadata/md5-cache/dev-util/cscope-15.7a-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://cscope.sourceforge.net/
 IUSE=emacs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=BSD GPL-2
 RDEPEND=>=sys-libs/ncurses-5.2 emacs? ( virtual/emacs )
 SLOT=0
 SRC_URI=mirror://sourceforge/cscope/cscope-15.7a.tar.bz2
 _eclasses_=elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=85f8ee6426f36f2946ecda24b25f77a8
+_md5_=49f9d39fa2fd2dda8dce10adec944f6b
diff --git a/metadata/md5-cache/dev-util/ctags-5.7 b/metadata/md5-cache/dev-util/ctags-5.7
index 76cd849..f043f85 100644
--- a/metadata/md5-cache/dev-util/ctags-5.7
+++ b/metadata/md5-cache/dev-util/ctags-5.7
@@ -3,10 +3,10 @@
 DESCRIPTION=Exuberant Ctags creates tags files for code browsing in editors
 HOMEPAGE=http://ctags.sourceforge.net
 IUSE=ada
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=app-admin/eselect-ctags
 SLOT=0
 SRC_URI=mirror://sourceforge/ctags/ctags-5.7.tar.gz ada? ( mirror://sourceforge/gnuada/ctags-ada-mode-4.3.3.tar.bz2 )
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f0a0ded3355a3fac4c7de74c32a07c7c
+_md5_=ea6961acd39220b787f10903823560b8
diff --git a/metadata/md5-cache/dev-util/diffstat-1.55 b/metadata/md5-cache/dev-util/diffstat-1.55
index 0e2d8c3..30dd910 100644
--- a/metadata/md5-cache/dev-util/diffstat-1.55
+++ b/metadata/md5-cache/dev-util/diffstat-1.55
@@ -2,8 +2,8 @@
 DESCRIPTION=Display a histogram of diff changes
 EAPI=4
 HOMEPAGE=http://invisible-island.net/diffstat/diffstat.html
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ~ppc ppc64 ~s390 ~sh ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=0
 SRC_URI=ftp://invisible-island.net/diffstat/diffstat-1.55.tgz
-_md5_=a4feeb72a61e130643c300ff1eb9c45b
+_md5_=1a9f530340cb077ff9f446bfa65a0a08
diff --git a/metadata/md5-cache/dev-util/gdbus-codegen-2.30.2 b/metadata/md5-cache/dev-util/gdbus-codegen-2.30.2
index bb01aad..d62dcf9 100644
--- a/metadata/md5-cache/dev-util/gdbus-codegen-2.30.2
+++ b/metadata/md5-cache/dev-util/gdbus-codegen-2.30.2
@@ -3,11 +3,11 @@
 DESCRIPTION=GDBus code and documentation generator
 EAPI=4
 HOMEPAGE=http://www.gtk.org/
-KEYWORDS=~alpha amd64 ~arm hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd ~x86-linux
+KEYWORDS=alpha amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~sparc-fbsd ~x86-fbsd ~x86-linux
 LICENSE=LGPL-2
 PDEPEND=>=dev-libs/glib-2.30.2:2
 RDEPEND=>=app-admin/eselect-python-20091230 || ( =dev-lang/python-2.7* =dev-lang/python-2.6* =dev-lang/python-2.5* ) || ( =dev-lang/python-2.7*[xml] =dev-lang/python-2.6*[xml] =dev-lang/python-2.5*[xml] )
 SLOT=0
 SRC_URI=mirror://gnome/sources/glib/2.30/glib-2.30.2.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	gnome.org	8fef8f967214f56e08fa92d61163d891	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=829dd72c51042cba7840f30b75f47aec
+_md5_=7337a60404e9a2dd180b296bc982abbb
diff --git a/metadata/md5-cache/dev-util/gperf-3.0.3 b/metadata/md5-cache/dev-util/gperf-3.0.3
index 47665cb..5a47b36 100644
--- a/metadata/md5-cache/dev-util/gperf-3.0.3
+++ b/metadata/md5-cache/dev-util/gperf-3.0.3
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=A perfect hash function generator
 HOMEPAGE=http://www.gnu.org/software/gperf/gperf.html
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gnu/gperf/gperf-3.0.3.tar.gz
-_md5_=1ae6fb83a06e69d9221c4e15d86009d1
+_md5_=8c3caccb930e72956a08ca60eb486274
diff --git a/metadata/md5-cache/dev-util/gperf-3.0.4 b/metadata/md5-cache/dev-util/gperf-3.0.4
index a80df8d..6dce17f 100644
--- a/metadata/md5-cache/dev-util/gperf-3.0.4
+++ b/metadata/md5-cache/dev-util/gperf-3.0.4
@@ -2,8 +2,8 @@
 DESCRIPTION=A perfect hash function generator
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/gperf/gperf.html
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gnu/gperf/gperf-3.0.4.tar.gz
-_md5_=09050e3a8074526827bc09a95788e422
+_md5_=aab8fc2ca6e0ec7492a05126b95e1555
diff --git a/metadata/md5-cache/dev-util/gtk-doc-1.18 b/metadata/md5-cache/dev-util/gtk-doc-1.18
index 34d1502..40ed331 100644
--- a/metadata/md5-cache/dev-util/gtk-doc-1.18
+++ b/metadata/md5-cache/dev-util/gtk-doc-1.18
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.gtk.org/gtk-doc/
 IUSE=debug doc emacs highlight vim test debug
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=GPL-2 FDL-1.1
 RDEPEND=>=dev-libs/glib-2.6:2 >=dev-lang/perl-5.6 >=app-text/openjade-1.3.1 dev-libs/libxslt >=dev-libs/libxml2-2.3.6:2 ~app-text/docbook-xml-dtd-4.3 app-text/docbook-xsl-stylesheets ~app-text/docbook-sgml-dtd-3.0 >=app-text/docbook-dsssl-stylesheets-1.40 emacs? ( virtual/emacs ) highlight? ( vim? ( || ( app-editors/vim app-editors/gvim ) ) !vim? ( dev-util/source-highlight ) ) !!<dev-tex/tex4ht-20090611_p1038-r1 >=app-admin/eselect-python-20091230 =dev-lang/python-2*
 SLOT=0
 SRC_URI=mirror://gnome/sources/gtk-doc/1.18/gtk-doc-1.18.tar.xz
 _eclasses_=elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=952ee29ca59d5f01c57c1b10f488337a
+_md5_=9866559ae2a1232ed73f331843dd5253
diff --git a/metadata/md5-cache/dev-util/gtk-doc-am-1.18 b/metadata/md5-cache/dev-util/gtk-doc-am-1.18
index 62a81e1..5c74097 100644
--- a/metadata/md5-cache/dev-util/gtk-doc-am-1.18
+++ b/metadata/md5-cache/dev-util/gtk-doc-am-1.18
@@ -3,7 +3,7 @@
 DESCRIPTION=Automake files from gtk-doc
 EAPI=4
 HOMEPAGE=http://www.gtk.org/gtk-doc/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2 FDL-1.1
 PDEPEND=dev-util/pkgconfig
 RDEPEND=>=dev-lang/perl-5.6
@@ -11,4 +11,4 @@
 SLOT=0
 SRC_URI=mirror://gnome/sources/gtk-doc/1.18/gtk-doc-1.18.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=f29bcf6ec0c4b24e053abd8585c58439
+_md5_=01415ef6873cd303a4a7fbe809379164
diff --git a/metadata/md5-cache/dev-util/lcov-1.10 b/metadata/md5-cache/dev-util/lcov-1.10
index c2dd654..667e7fb 100644
--- a/metadata/md5-cache/dev-util/lcov-1.10
+++ b/metadata/md5-cache/dev-util/lcov-1.10
@@ -2,10 +2,10 @@
 DESCRIPTION=A graphical front-end for GCC's coverage testing tool gcov
 EAPI=4
 HOMEPAGE=http://ltp.sourceforge.net/coverage/lcov.php
-KEYWORDS=amd64 ~arm ~ppc ~x86 ~x86-linux ~x64-macos
+KEYWORDS=amd64 ~arm ppc ~x86 ~x86-linux ~x64-macos
 LICENSE=GPL-2
 RDEPEND=>=dev-lang/perl-5 dev-perl/GD[png]
 SLOT=0
 SRC_URI=mirror://sourceforge/ltp/lcov-1.10.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=bce5c6fb75ecc3bd8d438bbb7fcc3099
+_md5_=8fc77da205c78f29ad6c3104330973d2
diff --git a/metadata/md5-cache/dev-util/pkgconfig-0.26 b/metadata/md5-cache/dev-util/pkgconfig-0.26
index ec014ac..c2fb8a5 100644
--- a/metadata/md5-cache/dev-util/pkgconfig-0.26
+++ b/metadata/md5-cache/dev-util/pkgconfig-0.26
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://pkgconfig.freedesktop.org/wiki/
 IUSE=elibc_FreeBSD hardened
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=dev-libs/glib:2 >=dev-libs/popt-1.15
 SLOT=0
 SRC_URI=http://pkgconfig.freedesktop.org/releases/pkg-config-0.26.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=17199039e97ad6cb2fabcdf4091d0b50
+_md5_=6190af3bcaa0d3062708c720bfa9c21b
diff --git a/metadata/md5-cache/dev-util/scons-2.0.1 b/metadata/md5-cache/dev-util/scons-2.0.1
index 1aa6738..db51f64 100644
--- a/metadata/md5-cache/dev-util/scons-2.0.1
+++ b/metadata/md5-cache/dev-util/scons-2.0.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.scons.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=>=app-admin/eselect-python-20091230 =dev-lang/python-2* =dev-lang/python-2*[threads]
 SLOT=0
 SRC_URI=mirror://sourceforge/scons/scons-2.0.1.tar.gz doc? ( http://www.scons.org/doc/2.0.1/PDF/scons-user.pdf -> scons-2.0.1-user.pdf http://www.scons.org/doc/2.0.1/HTML/scons-user.html -> scons-2.0.1-user.html )
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f42708b0baf1c554c883f5f98aea0143
+_md5_=3b1a544704c31dce01e850d0e4cce101
diff --git a/metadata/md5-cache/dev-util/strace-4.7 b/metadata/md5-cache/dev-util/strace-4.7
index 4b36c33..46c30fb 100644
--- a/metadata/md5-cache/dev-util/strace-4.7
+++ b/metadata/md5-cache/dev-util/strace-4.7
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://sourceforge.net/projects/strace/
 IUSE=static aio
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~arm-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~arm-linux ~ia64-linux ~x86-linux
 LICENSE=BSD
 SLOT=0
 SRC_URI=mirror://sourceforge/strace/strace-4.7.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c392a2cf35efacc282cb2dc9f7025d91
+_md5_=7e7809b5c9d626ab165ee180184c60a8
diff --git a/metadata/md5-cache/dev-util/valgrind-3.8.1 b/metadata/md5-cache/dev-util/valgrind-3.8.1
index 678a83a..e2d3909 100644
--- a/metadata/md5-cache/dev-util/valgrind-3.8.1
+++ b/metadata/md5-cache/dev-util/valgrind-3.8.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.valgrind.org
 IUSE=mpi
-KEYWORDS=-* amd64 arm ~ppc ~ppc64 x86 ~amd64-linux ~x86-linux ~x86-macos ~x64-macos
+KEYWORDS=-* amd64 arm ppc ppc64 x86 ~amd64-linux ~x86-linux ~x86-macos ~x64-macos
 LICENSE=GPL-2
 RDEPEND=mpi? ( virtual/mpi )
 SLOT=0
 SRC_URI=http://www.valgrind.org/downloads/valgrind-3.8.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	pax-utils	3551398d6ede2b572568832730cc2a45	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=08c25cbccc93540c402054693ef164d0
+_md5_=c8792020e05311d4ce3bf9fd72a60af9
diff --git a/metadata/md5-cache/dev-vcs/cvs-1.12.12-r6 b/metadata/md5-cache/dev-vcs/cvs-1.12.12-r6
index be58869..369c2dc 100644
--- a/metadata/md5-cache/dev-vcs/cvs-1.12.12-r6
+++ b/metadata/md5-cache/dev-vcs/cvs-1.12.12-r6
@@ -3,10 +3,10 @@
 DESCRIPTION=Concurrent Versions System - source code revision control tools
 HOMEPAGE=http://www.nongnu.org/cvs/
 IUSE=crypt doc kerberos nls pam server
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-2 LGPL-2
 RDEPEND=>=sys-libs/zlib-1.1.4 kerberos? ( virtual/krb5 ) pam? ( virtual/pam )
 SLOT=0
 SRC_URI=mirror://gnu/non-gnu/cvs/source/feature/1.12.12/cvs-1.12.12.tar.bz2 doc? ( mirror://gnu/non-gnu/cvs/source/feature/1.12.12/cederqvist-1.12.12.html.tar.bz2 mirror://gnu/non-gnu/cvs/source/feature/1.12.12/cederqvist-1.12.12.pdf mirror://gnu/non-gnu/cvs/source/feature/1.12.12/cederqvist-1.12.12.ps )
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	pam	3f746974e1cc47cabe3bd488c08cdc8e	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9817fa51f5fa215f80a6a261ff35bfd6
+_md5_=137aa867facb8417f063b28322d99018
diff --git a/metadata/md5-cache/dev-vcs/cvsps-2.1 b/metadata/md5-cache/dev-vcs/cvsps-2.1
index 7122509..c70bc26 100644
--- a/metadata/md5-cache/dev-vcs/cvsps-2.1
+++ b/metadata/md5-cache/dev-vcs/cvsps-2.1
@@ -2,10 +2,10 @@
 DEPEND=sys-libs/zlib
 DESCRIPTION=Generates patchset information from a CVS repository
 HOMEPAGE=http://www.cobite.com/cvsps/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=sys-libs/zlib
 SLOT=0
 SRC_URI=http://www.cobite.com/cvsps/cvsps-2.1.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=94d56111062bc3f4e4fd3d206089755f
+_md5_=9ebd61c75ff4d5ba7fbc083561024fe4
diff --git a/metadata/md5-cache/dev-vcs/git-1.7.12.4 b/metadata/md5-cache/dev-vcs/git-1.7.12.4
index 8794ea3..98b90ce 100644
--- a/metadata/md5-cache/dev-vcs/git-1.7.12.4
+++ b/metadata/md5-cache/dev-vcs/git-1.7.12.4
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.git-scm.com/
 IUSE=+blksha1 +curl cgi doc emacs +gpg gtk highlight +iconv +nls +pcre +perl +python ppcsha1 tk +threads +webdav xinetd cvs subversion test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 ~s390 ~sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=dev-libs/openssl sys-libs/zlib pcre? ( dev-libs/libpcre ) perl? ( dev-lang/perl[-build] ) tk? ( dev-lang/tk ) curl? ( net-misc/curl webdav? ( dev-libs/expat ) ) emacs? ( virtual/emacs ) gpg? ( app-crypt/gnupg ) perl? ( dev-perl/Error dev-perl/Net-SMTP-SSL dev-perl/Authen-SASL cgi? ( virtual/perl-CGI highlight? ( app-text/highlight ) ) cvs? ( >=dev-vcs/cvsps-2.1 dev-perl/DBI dev-perl/DBD-SQLite ) subversion? ( dev-vcs/subversion[-dso,perl] dev-perl/libwww-perl dev-perl/TermReadKey ) ) python? ( gtk? ( >=dev-python/pygtk-2.8 dev-python/pygtksourceview:2 ) ) >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* )
 REQUIRED_USE=cgi? ( perl ) cvs? ( perl ) subversion? ( perl ) webdav? ( curl )
 SLOT=0
 SRC_URI=http://git-core.googlecode.com/files/git-1.7.12.4.tar.gz mirror://kernel/software/scm/git/git-1.7.12.4.tar.gz http://git-core.googlecode.com/files/git-manpages-1.7.12.4.tar.gz mirror://kernel/software/scm/git/git-manpages-1.7.12.4.tar.gz doc? ( mirror://kernel/software/scm/git/git-htmldocs-1.7.12.4.tar.gz http://git-core.googlecode.com/files/git-htmldocs-1.7.12.4.tar.gz )
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	bash-completion-r1	3480f8385cb9e31797e7b659e366e2d2	elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=02c334dca117293f3b6ce44647823f66
+_md5_=30c38d10f0fdc2278da0442ffe9bafaf
diff --git a/metadata/md5-cache/dev-vcs/subversion-1.6.17-r7 b/metadata/md5-cache/dev-vcs/subversion-1.6.17-r7
index 562bdfb..0926b57 100644
--- a/metadata/md5-cache/dev-vcs/subversion-1.6.17-r7
+++ b/metadata/md5-cache/dev-vcs/subversion-1.6.17-r7
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://subversion.apache.org/
 IUSE=apache2 berkdb ctypes-python debug doc +dso emacs extras gnome-keyring java kde nls perl python ruby sasl vim-syntax +webdav-neon webdav-serf apache2 bash-completion elibc_FreeBSD java
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ~ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=Subversion
 PDEPEND=bash-completion? ( app-shells/bash-completion )
 RDEPEND=>=dev-db/sqlite-3.4 >=dev-libs/apr-1.3:1 >=dev-libs/apr-util-1.3:1 dev-libs/expat sys-libs/zlib berkdb? ( >=sys-libs/db-4.0.14 ) ctypes-python? ( =dev-lang/python-2* ) emacs? ( virtual/emacs ) gnome-keyring? ( dev-libs/glib:2 sys-apps/dbus gnome-base/gnome-keyring ) kde? ( sys-apps/dbus x11-libs/qt-core x11-libs/qt-dbus x11-libs/qt-gui >=kde-base/kdelibs-4 ) perl? ( dev-lang/perl ) python? ( =dev-lang/python-2* ) ruby? ( >=dev-lang/ruby-1.8.2 ) sasl? ( dev-libs/cyrus-sasl ) webdav-neon? ( >=net-libs/neon-0.28 ) webdav-serf? ( >=net-libs/serf-0.3.0 ) apache2? ( www-servers/apache[apache2_modules_dav] ) java? ( >=virtual/jre-1.5 ) kde? ( kde-base/kwalletd ) nls? ( virtual/libintl ) perl? ( dev-perl/URI ) apache2? ( =www-servers/apache-2* ) bash-completion? ( app-admin/eselect ) java? ( >=dev-java/java-config-2.1.9-r1 ) dev-lang/perl[-build] >=app-admin/eselect-python-20091230
 SLOT=0
 SRC_URI=http://subversion.tigris.org/downloads/subversion-1.6.17.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	base	fc89786f3f7e7bcf03334359bd5b639b	bash-completion	f0fab76a98c0e4b3d72b6beb28d3f653	db-use	8d7baa3efc7c38c7d5c5e7353c5460dc	depend.apache	a471783c63e68987a2b20eb46f9edf68	elisp-common	3322f14f031ddc95feccd9089c9adc59	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	java-pkg-opt-2	31a1663247652448431dcc8c194e2752	java-utils-2	6beafc7c3d1dbae83a4478182b158f66	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=1c2caba3a386199916c63b921311512b
+_md5_=aae8254fa84349242f84e81450046ec6
diff --git a/metadata/md5-cache/gnome-base/libglade-2.6.4 b/metadata/md5-cache/gnome-base/libglade-2.6.4
index 023185b..af991d9 100644
--- a/metadata/md5-cache/gnome-base/libglade-2.6.4
+++ b/metadata/md5-cache/gnome-base/libglade-2.6.4
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnome.org/
 IUSE=doc debug
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=LGPL-2
 RDEPEND=>=dev-libs/glib-2.10 >=x11-libs/gtk+-2.8.10 >=dev-libs/atk-1.9 >=dev-libs/libxml2-2.4.10 >=dev-lang/python-2.0-r7
 SLOT=2.0
 SRC_URI=mirror://gnome/sources/libglade/2.6/libglade-2.6.4.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=5c462cbe23182dfff994aa63c5188e07
+_md5_=a08fd11f74fbacc7869f44642b6e51c0
diff --git a/metadata/md5-cache/media-fonts/corefonts-1-r4 b/metadata/md5-cache/media-fonts/corefonts-1-r4
index 46fab53..fc68a44 100644
--- a/metadata/md5-cache/media-fonts/corefonts-1-r4
+++ b/metadata/md5-cache/media-fonts/corefonts-1-r4
@@ -3,9 +3,9 @@
 DESCRIPTION=Microsoft's TrueType core fonts
 HOMEPAGE=http://corefonts.sourceforge.net/
 IUSE=X X
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MSttfEULA
 SLOT=0
 SRC_URI=mirror://sourceforge/corefonts/andale32.exe mirror://sourceforge/corefonts/arial32.exe mirror://sourceforge/corefonts/arialb32.exe mirror://sourceforge/corefonts/comic32.exe mirror://sourceforge/corefonts/courie32.exe mirror://sourceforge/corefonts/georgi32.exe mirror://sourceforge/corefonts/impact32.exe mirror://sourceforge/corefonts/times32.exe mirror://sourceforge/corefonts/trebuc32.exe mirror://sourceforge/corefonts/verdan32.exe mirror://sourceforge/corefonts/webdin32.exe
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	font	bc3df4ed373e09f86a90e8fad39034d6	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f08adf593b89dcbac700ac77f960e356
+_md5_=5ead9b8cd82415d6dbf9c8a61daf82bd
diff --git a/metadata/md5-cache/media-fonts/dejavu-2.33 b/metadata/md5-cache/media-fonts/dejavu-2.33
index 1a3e516..a3b1548 100644
--- a/metadata/md5-cache/media-fonts/dejavu-2.33
+++ b/metadata/md5-cache/media-fonts/dejavu-2.33
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://dejavu.sourceforge.net/
 IUSE=fontforge X
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x86-solaris
 LICENSE=BitstreamVera
 SLOT=0
 SRC_URI=!fontforge? ( mirror://sourceforge/dejavu/dejavu-fonts-ttf-2.33.tar.bz2 ) fontforge? ( mirror://sourceforge/dejavu/dejavu-fonts-2.33.tar.bz2 )
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	font	bc3df4ed373e09f86a90e8fad39034d6	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=0b47728990bb556c2e7b08376212fd70
+_md5_=f87bb300fc4817fee44c1554d8db9737
diff --git a/metadata/md5-cache/media-fonts/encodings-1.0.3 b/metadata/md5-cache/media-fonts/encodings-1.0.3
index 8b93a35..5baf8f1 100644
--- a/metadata/md5-cache/media-fonts/encodings-1.0.3
+++ b/metadata/md5-cache/media-fonts/encodings-1.0.3
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org font encodings
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=debug
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=!<=x11-base/xorg-x11-6.9
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/font/encodings-1.0.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	x-modular	9f4ee0c44a3a3b7ecdf52cefc1e10280
-_md5_=daf3bca37c798853530bf5b734b2154a
+_md5_=9726b61e31f80649e6b9c04cb76b60cf
diff --git a/metadata/md5-cache/media-fonts/font-util-1.2.0 b/metadata/md5-cache/media-fonts/font-util-1.2.0
index 6f2b020..3c24ca6 100644
--- a/metadata/md5-cache/media-fonts/font-util-1.2.0
+++ b/metadata/md5-cache/media-fonts/font-util-1.2.0
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org font utilities
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/font/font-util-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=6ec8b9592edcd7a87c90b0eb99bf2589
+_md5_=5b8d258588483f1a48b015977250818d
diff --git a/metadata/md5-cache/media-fonts/urw-fonts-2.4.9 b/metadata/md5-cache/media-fonts/urw-fonts-2.4.9
index 037be8a..d85418c 100644
--- a/metadata/md5-cache/media-fonts/urw-fonts-2.4.9
+++ b/metadata/md5-cache/media-fonts/urw-fonts-2.4.9
@@ -3,10 +3,10 @@
 DESCRIPTION=free good quality fonts gpl'd by URW++
 HOMEPAGE=http://www.urwpp.de/
 IUSE=X
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=!media-fonts/gnu-gs-fonts-std !media-fonts/gnu-gs-fonts-other
 SLOT=0
 SRC_URI=mirror://gentoo/urw-fonts-2.4-9.fc13.src.rpm
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	font	bc3df4ed373e09f86a90e8fad39034d6	multilib	ded93e450747134a079e647d888aa80b	rpm	e703d62d2e2b396a7fb0262b79fdba53	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=537343e7d73ce5bd50a17ef371824559
+_md5_=ea7c3573f361dc196dc8426c5aa0bdf3
diff --git a/metadata/md5-cache/media-gfx/imagemagick-6.7.8.7 b/metadata/md5-cache/media-gfx/imagemagick-6.7.8.7
index 5e68bff..065ee7d 100644
--- a/metadata/md5-cache/media-gfx/imagemagick-6.7.8.7
+++ b/metadata/md5-cache/media-gfx/imagemagick-6.7.8.7
@@ -4,7 +4,7 @@
 EAPI=4
 HOMEPAGE=http://www.imagemagick.org/
 IUSE=autotrace bzip2 corefonts cxx djvu fftw fontconfig fpx graphviz hdri jbig jpeg jpeg2k lcms lqr lzma opencl openexr openmp pango perl png postscript q32 q64 q8 raw static-libs svg test tiff truetype webp wmf X xml zlib
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=imagemagick
 RDEPEND=>=sys-devel/libtool-2.2.6b autotrace? ( >=media-gfx/autotrace-0.31.1 ) bzip2? ( app-arch/bzip2 ) corefonts? ( media-fonts/corefonts ) djvu? ( app-text/djvu ) fftw? ( sci-libs/fftw:3.0 ) fontconfig? ( media-libs/fontconfig ) fpx? ( >=media-libs/libfpx-1.3.0-r1 ) graphviz? ( media-gfx/graphviz ) jbig? ( media-libs/jbigkit ) jpeg? ( virtual/jpeg ) jpeg2k? ( media-libs/jasper ) lcms? ( media-libs/lcms:2 ) lqr? ( media-libs/liblqr ) opencl? ( virtual/opencl ) openexr? ( media-libs/openexr ) pango? ( x11-libs/pango ) perl? ( >=dev-lang/perl-5.8.8 ) png? ( media-libs/libpng:0 ) postscript? ( app-text/ghostscript-gpl ) raw? ( media-gfx/ufraw ) svg? ( gnome-base/librsvg ) tiff? ( media-libs/tiff:0 ) truetype? ( media-fonts/urw-fonts >=media-libs/freetype-2 ) webp? ( media-libs/libwebp ) wmf? ( media-libs/libwmf ) X? ( x11-libs/libICE x11-libs/libSM x11-libs/libXext x11-libs/libXt ) xml? ( dev-libs/libxml2 ) lzma? ( app-arch/xz-utils ) zlib? ( sys-libs/zlib )
 REQUIRED_USE=corefonts? ( truetype ) test? ( corefonts )
@@ -12,4 +12,4 @@
 SLOT=0
 SRC_URI=mirror://imagemagick/ImageMagick-6.7.8-7.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=ddf0ef3f108fce205b25230e262fe2ee
+_md5_=91253c40067723481291a73b10292770
diff --git a/metadata/md5-cache/media-gfx/sane-backends-1.0.23-r1 b/metadata/md5-cache/media-gfx/sane-backends-1.0.23-r1
index 6f3a3f6..5909e35 100644
--- a/metadata/md5-cache/media-gfx/sane-backends-1.0.23-r1
+++ b/metadata/md5-cache/media-gfx/sane-backends-1.0.23-r1
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.sane-project.org/
 IUSE=avahi doc gphoto2 ipv6 threads usb v4l xinetd snmp +sane_backends_abaton +sane_backends_agfafocus +sane_backends_apple +sane_backends_artec +sane_backends_artec_eplus48u +sane_backends_as6e +sane_backends_avision +sane_backends_bh +sane_backends_canon +sane_backends_canon630u +sane_backends_canon_dr +sane_backends_canon_pp +sane_backends_cardscan +sane_backends_coolscan +sane_backends_coolscan2 +sane_backends_coolscan3 +sane_backends_dc210 +sane_backends_dc240 +sane_backends_dc25 +sane_backends_dell1600n_net +sane_backends_dmc +sane_backends_epjitsu +sane_backends_epson +sane_backends_epson2 +sane_backends_fujitsu +sane_backends_genesys +sane_backends_gt68xx +sane_backends_hp +sane_backends_hp3500 +sane_backends_hp3900 +sane_backends_hp4200 +sane_backends_hp5400 +sane_backends_hp5590 +sane_backends_hpljm1005 +sane_backends_hpsj5s +sane_backends_hs2p +sane_backends_ibm +sane_backends_kodak +sane_backends_kodakaio +sane_backends_kvs1025 +sane_backends_kvs20xx sane_backends_kvs40xx +sane_backends_leo +sane_backends_lexmark +sane_backends_ma1509 +sane_backends_magicolor +sane_backends_matsushita +sane_backends_microtek +sane_backends_microtek2 +sane_backends_mustek +sane_backends_mustek_pp +sane_backends_mustek_usb sane_backends_mustek_usb2 +sane_backends_nec +sane_backends_net +sane_backends_niash +sane_backends_p5 +sane_backends_pie +sane_backends_pixma +sane_backends_plustek +sane_backends_plustek_pp -sane_backends_pnm +sane_backends_qcam +sane_backends_ricoh +sane_backends_rts8891 +sane_backends_s9036 +sane_backends_sceptre +sane_backends_sharp +sane_backends_sm3600 +sane_backends_sm3840 +sane_backends_snapscan +sane_backends_sp15c +sane_backends_st400 +sane_backends_stv680 +sane_backends_tamarack +sane_backends_teco1 +sane_backends_teco2 +sane_backends_teco3 +sane_backends_test +sane_backends_u12 +sane_backends_umax +sane_backends_umax1220u +sane_backends_umax_pp +sane_backends_xerox_mfp
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~ppc ~ppc64 ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=GPL-2 public-domain
 RDEPEND=sane_backends_dc210? ( virtual/jpeg ) sane_backends_dc240? ( virtual/jpeg ) sane_backends_dell1600n_net? ( virtual/jpeg media-libs/tiff ) avahi? ( >=net-dns/avahi-0.6.24 ) sane_backends_canon_pp? ( sys-libs/libieee1284 ) sane_backends_hpsj5s? ( sys-libs/libieee1284 ) sane_backends_mustek_pp? ( sys-libs/libieee1284 ) usb? ( virtual/libusb:0 ) gphoto2? ( media-libs/libgphoto2 virtual/jpeg ) v4l? ( media-libs/libv4l ) xinetd? ( sys-apps/xinetd ) snmp? ( net-analyzer/net-snmp ) !<sys-fs/udev-114
 REQUIRED_USE=sane_backends_mustek_usb2? ( threads ) sane_backends_kvs40xx? ( threads )
 SLOT=0
 SRC_URI=https://alioth.debian.org/frs/download.php/3752/sane-backends-1.0.23.tar.gz.1 https://alioth.debian.org/frs/download.php/3753/sane-backends-1.0.23.tar.gz.2 https://alioth.debian.org/frs/download.php/3754/sane-backends-1.0.23.tar.gz.3
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	udev	f7490675e06a5e4db55adf394f078b7b	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9309c72be6ac6b3191605e2034d83f2a
+_md5_=01924f4d69323cf2bd235bc067640ac6
diff --git a/metadata/md5-cache/media-libs/alsa-lib-1.0.25-r1 b/metadata/md5-cache/media-libs/alsa-lib-1.0.25-r1
index 8362716..f8ee021 100644
--- a/metadata/md5-cache/media-libs/alsa-lib-1.0.25-r1
+++ b/metadata/md5-cache/media-libs/alsa-lib-1.0.25-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.alsa-project.org/
 IUSE=doc debug alisp python
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ~ppc ppc64 sh sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=LGPL-2.1
 RDEPEND=>=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* )
 SLOT=0
 SRC_URI=mirror://alsaproject/lib/alsa-lib-1.0.25.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=753dcf4703d81c2aa2db6f404398835d
+_md5_=bcbba2df035bb5636632a9837197a1f5
diff --git a/metadata/md5-cache/media-libs/audiofile-0.3.4 b/metadata/md5-cache/media-libs/audiofile-0.3.4
index 14e718a..e944e68 100644
--- a/metadata/md5-cache/media-libs/audiofile-0.3.4
+++ b/metadata/md5-cache/media-libs/audiofile-0.3.4
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://www.68k.org/~michael/audiofile/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-2 LGPL-2
 SLOT=0
 SRC_URI=mirror://gnome/sources/audiofile/0.3/audiofile-0.3.4.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	gnome.org	8fef8f967214f56e08fa92d61163d891	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=8b7be700f29bfb1927bc2b9cad0ea755
+_md5_=9099195af7d0e2eac410d3a90905221c
diff --git a/metadata/md5-cache/media-libs/flac-1.2.1-r3 b/metadata/md5-cache/media-libs/flac-1.2.1-r3
index eb7c9b4..fea8d0a 100644
--- a/metadata/md5-cache/media-libs/flac-1.2.1-r3
+++ b/metadata/md5-cache/media-libs/flac-1.2.1-r3
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://flac.sourceforge.net
 IUSE=3dnow altivec +cxx debug ogg sse static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=BSD FDL-1.2 GPL-2 LGPL-2.1
 RDEPEND=ogg? ( >=media-libs/libogg-1.1.3 )
 SLOT=0
 SRC_URI=mirror://sourceforge/flac/flac-1.2.1.tar.gz mirror://gentoo/flac-1.2.1-embedded-m4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=77dee8cb0d2e30372ef90122bd58e137
+_md5_=6b9dd0cd405cc6921609e3dd145c7805
diff --git a/metadata/md5-cache/media-libs/freeglut-2.4.0-r2 b/metadata/md5-cache/media-libs/freeglut-2.4.0-r2
index 9c05bf6..b6476f8 100644
--- a/metadata/md5-cache/media-libs/freeglut-2.4.0-r2
+++ b/metadata/md5-cache/media-libs/freeglut-2.4.0-r2
@@ -2,10 +2,10 @@
 DEPEND=virtual/opengl virtual/glu !media-libs/glut || ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool
 DESCRIPTION=A completely OpenSourced alternative to the OpenGL Utility Toolkit (GLUT) library
 HOMEPAGE=http://freeglut.sourceforge.net/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~sh ~sparc ~x86 ~x86-fbsd
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 mips ppc ppc64 sh sparc ~x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=virtual/opengl virtual/glu !media-libs/glut
 SLOT=0
 SRC_URI=mirror://sourceforge/freeglut/freeglut-2.4.0.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=71cc41b3d0bd2476478e6816573e2f57
+_md5_=d8f57088cb01e6b879c53e50908d6989
diff --git a/metadata/md5-cache/media-libs/gd-2.0.35-r3 b/metadata/md5-cache/media-libs/gd-2.0.35-r3
index 47fcb0e..8dfa33f 100644
--- a/metadata/md5-cache/media-libs/gd-2.0.35-r3
+++ b/metadata/md5-cache/media-libs/gd-2.0.35-r3
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://libgd.org/ http://www.boutell.com/gd/
 IUSE=fontconfig jpeg png static-libs truetype xpm zlib
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=|| ( as-is BSD )
 RDEPEND=fontconfig? ( media-libs/fontconfig ) jpeg? ( virtual/jpeg ) png? ( >=media-libs/libpng-1.2 ) truetype? ( >=media-libs/freetype-2.1.5 ) xpm? ( x11-libs/libXpm x11-libs/libXt ) zlib? ( sys-libs/zlib )
 SLOT=2
 SRC_URI=http://libgd.org/releases/gd-2.0.35.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=dc34849b436bae8647097e7cf36b0859
+_md5_=dc82cd5c91432ecb29a91224b0ccd226
diff --git a/metadata/md5-cache/media-libs/giflib-4.1.6-r1 b/metadata/md5-cache/media-libs/giflib-4.1.6-r1
index 597f733..2192ded 100644
--- a/metadata/md5-cache/media-libs/giflib-4.1.6-r1
+++ b/metadata/md5-cache/media-libs/giflib-4.1.6-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=Library to handle, display and manipulate GIF images
 HOMEPAGE=http://sourceforge.net/projects/giflib/
 IUSE=rle X
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=!media-libs/libungif X? ( x11-libs/libXt x11-libs/libX11 x11-libs/libICE x11-libs/libSM ) rle? ( media-libs/urt )
 SLOT=0
 SRC_URI=mirror://sourceforge/giflib/giflib-4.1.6.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=35204d44e212a474ffa88d82de3e5bcc
+_md5_=ab2ac8582f970408873982be1e57b322
diff --git a/metadata/md5-cache/media-libs/glew-1.5.6 b/metadata/md5-cache/media-libs/glew-1.5.6
index 1878b8a..22e1543 100644
--- a/metadata/md5-cache/media-libs/glew-1.5.6
+++ b/metadata/md5-cache/media-libs/glew-1.5.6
@@ -3,10 +3,10 @@
 DESCRIPTION=The OpenGL Extension Wrangler Library
 EAPI=3
 HOMEPAGE=http://glew.sourceforge.net/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD MIT
 RDEPEND=x11-libs/libXmu x11-libs/libXi virtual/glu virtual/opengl x11-libs/libXext x11-libs/libX11
 SLOT=0
 SRC_URI=mirror://sourceforge/glew/glew-1.5.6.tgz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=489b3ba97337dfa43842c924d9f19308
+_md5_=b71adcc87e32b13fbda19c34697c5b57
diff --git a/metadata/md5-cache/media-libs/jbig2dec-0.11-r1 b/metadata/md5-cache/media-libs/jbig2dec-0.11-r1
index fee559b..b29427b 100644
--- a/metadata/md5-cache/media-libs/jbig2dec-0.11-r1
+++ b/metadata/md5-cache/media-libs/jbig2dec-0.11-r1
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://jbig2dec.sourceforge.net/
 IUSE=png static-libs test
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ppc ppc64 ~sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=png? ( >=media-libs/libpng-1.2:0 )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://ghostscript.com/~giles/jbig2/jbig2dec/jbig2dec-0.11.tar.gz test? ( http://jbig2dec.sourceforge.net/ubc/jb2streams.zip )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=546f888f1134478389ee068da19a454c
+_md5_=a0ecb83933527ed36403ab5dff45720e
diff --git a/metadata/md5-cache/media-libs/jpeg-8b b/metadata/md5-cache/media-libs/jpeg-8b
index 7533f71..9aef502 100644
--- a/metadata/md5-cache/media-libs/jpeg-8b
+++ b/metadata/md5-cache/media-libs/jpeg-8b
@@ -3,9 +3,9 @@
 EAPI=3
 HOMEPAGE=http://jpegclub.org/ http://www.ijg.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 SLOT=0
 SRC_URI=http://www.ijg.org/files/jpegsrc.v8b.tar.gz mirror://debian/pool/main/libj/libjpeg7/libjpeg7_7-1.diff.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a71029597bf29eda093c2e93bb6f859f
+_md5_=a73e89daac7dc7fa91d584149952cc13
diff --git a/metadata/md5-cache/media-libs/lcms-2.3 b/metadata/md5-cache/media-libs/lcms-2.3
index 1e67b9f..54c2941 100644
--- a/metadata/md5-cache/media-libs/lcms-2.3
+++ b/metadata/md5-cache/media-libs/lcms-2.3
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://www.littlecms.com/
 IUSE=doc jpeg static-libs test tiff zlib
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=MIT
 RDEPEND=jpeg? ( virtual/jpeg ) tiff? ( media-libs/tiff:0 ) zlib? ( sys-libs/zlib )
 SLOT=2
 SRC_URI=mirror://sourceforge/lcms/lcms2-2.3.tar.gz
-_md5_=4037a0e24b703a2c0278286dd7fc4230
+_md5_=2e53438bad1c6438dc6449e5f3ef6771
diff --git a/metadata/md5-cache/media-libs/libao-1.1.0-r1 b/metadata/md5-cache/media-libs/libao-1.1.0-r1
index b49330a..04a7ece 100644
--- a/metadata/md5-cache/media-libs/libao-1.1.0-r1
+++ b/metadata/md5-cache/media-libs/libao-1.1.0-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.xiph.org/ao/
 IUSE=alsa nas mmap pulseaudio static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~ppc-macos ~x64-macos ~x86-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~ppc-macos ~x64-macos ~x86-macos ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=alsa? ( media-libs/alsa-lib ) nas? ( media-libs/nas ) pulseaudio? ( media-sound/pulseaudio )
 SLOT=0
 SRC_URI=http://downloads.xiph.org/releases/ao/libao-1.1.0.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f5c6c2cb62bc6334a1eee4c3f321eb2f
+_md5_=8e6ddd91fa8e52be137a669ded001a95
diff --git a/metadata/md5-cache/media-libs/libart_lgpl-2.3.21-r1 b/metadata/md5-cache/media-libs/libart_lgpl-2.3.21-r1
index c0823db..4355700 100644
--- a/metadata/md5-cache/media-libs/libart_lgpl-2.3.21-r1
+++ b/metadata/md5-cache/media-libs/libart_lgpl-2.3.21-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=a LGPL version of libart
 EAPI=3
 HOMEPAGE=http://www.levien.com/libart
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=LGPL-2.1
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://gnome/sources/libart_lgpl/2.3/libart_lgpl-2.3.21.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=a1a4c2b9c9fdcb63ab9189449619d0fd
+_md5_=ec1117fb963ef54d91ccc3cf0e22b9ff
diff --git a/metadata/md5-cache/media-libs/libdvdnav-4.2.0 b/metadata/md5-cache/media-libs/libdvdnav-4.2.0
index 1cf5e84..ceccea8 100644
--- a/metadata/md5-cache/media-libs/libdvdnav-4.2.0
+++ b/metadata/md5-cache/media-libs/libdvdnav-4.2.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Library for DVD navigation tools
 EAPI=4
 HOMEPAGE=http://dvdnav.mplayerhq.hu/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=media-libs/libdvdread-4.2.0
 SLOT=0
 SRC_URI=http://dvdnav.mplayerhq.hu/releases/libdvdnav-4.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=51423d4e3652bbf849fffca1f110223b
+_md5_=62b8952f7c7b470761ed93d4a384763f
diff --git a/metadata/md5-cache/media-libs/libdvdread-4.2.0 b/metadata/md5-cache/media-libs/libdvdread-4.2.0
index 0f3eeb6..607545c 100644
--- a/metadata/md5-cache/media-libs/libdvdread-4.2.0
+++ b/metadata/md5-cache/media-libs/libdvdread-4.2.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://dvdnav.mplayerhq.hu/
 IUSE=+css
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=!<media-libs/libdvdnav-4.2.0 css? ( media-libs/libdvdcss )
 SLOT=0
 SRC_URI=http://dvdnav.mplayerhq.hu/releases/libdvdread-4.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=8715bfb0be201084c667ed1a3f51f715
+_md5_=5467de8af49aceb562b2f5c504910316
diff --git a/metadata/md5-cache/media-libs/libexif-0.6.21 b/metadata/md5-cache/media-libs/libexif-0.6.21
index dacf94b..d179475 100644
--- a/metadata/md5-cache/media-libs/libexif-0.6.21
+++ b/metadata/md5-cache/media-libs/libexif-0.6.21
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://libexif.sourceforge.net/
 IUSE=doc nls static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~x64-solaris ~x86-solaris
 LICENSE=LGPL-2.1
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://sourceforge/libexif/libexif-0.6.21.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=1fcec07ae9406838818173ed961ac27f
+_md5_=5c8af36c249a2e5bf1261ed5fc58537c
diff --git a/metadata/md5-cache/media-libs/libid3tag-0.15.1b-r2 b/metadata/md5-cache/media-libs/libid3tag-0.15.1b-r2
index 5af7178..63f3310 100644
--- a/metadata/md5-cache/media-libs/libid3tag-0.15.1b-r2
+++ b/metadata/md5-cache/media-libs/libid3tag-0.15.1b-r2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.underbit.com/products/mad/
 IUSE=debug static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=>=sys-libs/zlib-1.1.3
 SLOT=0
 SRC_URI=mirror://sourceforge/mad/libid3tag-0.15.1b.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=012f3a23ff6a2949ebc4327918d5bc5c
+_md5_=1c5b33cbf818535ab5fb9a4e82a235f5
diff --git a/metadata/md5-cache/media-libs/libjpeg-turbo-1.2.0-r1 b/metadata/md5-cache/media-libs/libjpeg-turbo-1.2.0-r1
index e00c565..97d5721 100644
--- a/metadata/md5-cache/media-libs/libjpeg-turbo-1.2.0-r1
+++ b/metadata/md5-cache/media-libs/libjpeg-turbo-1.2.0-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://libjpeg-turbo.virtualgl.org/ http://sourceforge.net/projects/libjpeg-turbo/
 IUSE=java static-libs elibc_FreeBSD java
-KEYWORDS=amd64 arm hppa ~mips ppc ppc64 x86 ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=amd64 arm hppa mips ppc ppc64 x86 ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=BSD
 RDEPEND=!media-libs/jpeg:0 java? ( >=virtual/jre-1.5 ) java? ( >=dev-java/java-config-2.1.9-r1 )
 SLOT=0
 SRC_URI=mirror://sourceforge/libjpeg-turbo/libjpeg-turbo-1.2.0.tar.gz mirror://debian/pool/main/libj/libjpeg8/libjpeg8_8d-1.debian.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	java-pkg-opt-2	31a1663247652448431dcc8c194e2752	java-utils-2	6beafc7c3d1dbae83a4478182b158f66	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=57f56b90aa0c74c0754822d55350632a
+_md5_=e665e507185de122d1848ba31d88de95
diff --git a/metadata/md5-cache/media-libs/libogg-1.3.0 b/metadata/md5-cache/media-libs/libogg-1.3.0
index fc0ca47..6286a77 100644
--- a/metadata/md5-cache/media-libs/libogg-1.3.0
+++ b/metadata/md5-cache/media-libs/libogg-1.3.0
@@ -3,8 +3,8 @@
 EAPI=4
 HOMEPAGE=http://xiph.org/ogg/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD
 SLOT=0
 SRC_URI=http://downloads.xiph.org/releases/ogg/libogg-1.3.0.tar.xz
-_md5_=e6a5434c8fc40c28a8dd9ae7f4636b6f
+_md5_=b7ad6400ef3f522712dc21da51efa303
diff --git a/metadata/md5-cache/media-libs/libsamplerate-0.1.7 b/metadata/md5-cache/media-libs/libsamplerate-0.1.7
index 3110105..8bce187 100644
--- a/metadata/md5-cache/media-libs/libsamplerate-0.1.7
+++ b/metadata/md5-cache/media-libs/libsamplerate-0.1.7
@@ -3,10 +3,10 @@
 DESCRIPTION=Secret Rabbit Code (aka libsamplerate) is a Sample Rate Converter for audio
 HOMEPAGE=http://www.mega-nerd.com/SRC/
 IUSE=sndfile
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=GPL-2
 RDEPEND=sndfile? ( >=media-libs/libsndfile-1.0.2 )
 SLOT=0
 SRC_URI=http://www.mega-nerd.com/SRC/libsamplerate-0.1.7.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=97edc3cf9f08c899d19bb5c53ab57845
+_md5_=22dca2fd3525c64f9289759cb3e25c2a
diff --git a/metadata/md5-cache/media-libs/libsdl-1.2.15-r2 b/metadata/md5-cache/media-libs/libsdl-1.2.15-r2
index 9c47438..5e9044c 100644
--- a/metadata/md5-cache/media-libs/libsdl-1.2.15-r2
+++ b/metadata/md5-cache/media-libs/libsdl-1.2.15-r2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.libsdl.org/
 IUSE=oss alsa nas X dga xv xinerama fbcon directfb ggi svga tslib aalib opengl libcaca +audio +video +joystick custom-cflags pulseaudio ps3 static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd
 LICENSE=LGPL-2.1
 RDEPEND=audio? ( >=media-libs/audiofile-0.1.9 ) alsa? ( media-libs/alsa-lib ) nas? ( media-libs/nas x11-libs/libXt x11-libs/libXext x11-libs/libX11 ) X? ( x11-libs/libXt x11-libs/libXext x11-libs/libX11 x11-libs/libXrandr ) directfb? ( >=dev-libs/DirectFB-0.9.19 ) ggi? ( >=media-libs/libggi-2.0_beta3 ) svga? ( >=media-libs/svgalib-1.4.2 ) aalib? ( media-libs/aalib ) libcaca? ( >=media-libs/libcaca-0.9-r1 ) opengl? ( virtual/opengl virtual/glu ) ppc64? ( ps3? ( sys-libs/libspe2 ) ) tslib? ( x11-libs/tslib ) pulseaudio? ( media-sound/pulseaudio )
 SLOT=0
 SRC_URI=http://www.libsdl.org/release/SDL-1.2.15.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=fe5a1656fe5a13c34a2e608328dc3ef1
+_md5_=0b1da027c38436addd1d797c0a99c400
diff --git a/metadata/md5-cache/media-libs/libsndfile-1.0.25 b/metadata/md5-cache/media-libs/libsndfile-1.0.25
index ced5488..be221cf 100644
--- a/metadata/md5-cache/media-libs/libsndfile-1.0.25
+++ b/metadata/md5-cache/media-libs/libsndfile-1.0.25
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.mega-nerd.com/libsndfile
 IUSE=alsa minimal sqlite static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=LGPL-2.1
 RDEPEND=!minimal? ( >=media-libs/flac-1.2.1 >=media-libs/libogg-1.1.3 >=media-libs/libvorbis-1.2.3 ) alsa? ( media-libs/alsa-lib ) sqlite? ( >=dev-db/sqlite-3.2 )
 SLOT=0
 SRC_URI=http://www.mega-nerd.com/libsndfile/files/libsndfile-1.0.25.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e7c4290ad1b6ec07d026241ba116c44d
+_md5_=5d380b436964034b4b2d6ed286993114
diff --git a/metadata/md5-cache/media-libs/libv4l-0.8.8 b/metadata/md5-cache/media-libs/libv4l-0.8.8
index 0d75a6b..dad0b2e 100644
--- a/metadata/md5-cache/media-libs/libv4l-0.8.8
+++ b/metadata/md5-cache/media-libs/libv4l-0.8.8
@@ -3,10 +3,10 @@
 DESCRIPTION=Separate libraries ebuild from upstream v4l-utils package
 EAPI=4
 HOMEPAGE=http://git.linuxtv.org/v4l-utils.git
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~ppc ~ppc64 ~sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 sparc x86 ~amd64-linux ~x86-linux
 LICENSE=LGPL-2.1
 RDEPEND=virtual/jpeg
 SLOT=0
 SRC_URI=http://linuxtv.org/downloads/v4l-utils/v4l-utils-0.8.8.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=660e85bb4ad9a481e5841691f04c7dce
+_md5_=0b4b1ec915aa16715c2955f03f154726
diff --git a/metadata/md5-cache/media-libs/libvorbis-1.3.3 b/metadata/md5-cache/media-libs/libvorbis-1.3.3
index b458852..2e6c316 100644
--- a/metadata/md5-cache/media-libs/libvorbis-1.3.3
+++ b/metadata/md5-cache/media-libs/libvorbis-1.3.3
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xiph.org/vorbis
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=BSD
 RDEPEND=media-libs/libogg
 SLOT=0
 SRC_URI=http://downloads.xiph.org/releases/vorbis/libvorbis-1.3.3.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=5ba17cbdb083dea9eb7135b6be92b6cf
+_md5_=145b493594ecf5079b43316fe387ecd3
diff --git a/metadata/md5-cache/media-libs/libvpx-1.1.0 b/metadata/md5-cache/media-libs/libvpx-1.1.0
index 6833768..8f0e1f4 100644
--- a/metadata/md5-cache/media-libs/libvpx-1.1.0
+++ b/metadata/md5-cache/media-libs/libvpx-1.1.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.webmproject.org
 IUSE=altivec debug doc mmx postproc sse sse2 sse3 ssse3 sse4_1 static-libs +threads
-KEYWORDS=~alpha amd64 arm ~ia64 ~ppc ~ppc64 x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm ia64 ppc ppc64 x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=BSD
 REQUIRED_USE=sse2? ( mmx )
 SLOT=0
 SRC_URI=http://webm.googlecode.com/files/libvpx-v1.1.0.tar.bz2
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c7575f0a44eeba7e440b97231710c057
+_md5_=bb8f5de5fd6bcd59fdcbba9a9a7779dc
diff --git a/metadata/md5-cache/media-libs/speex-1.2_rc1 b/metadata/md5-cache/media-libs/speex-1.2_rc1
index d320f32..d5f5390 100644
--- a/metadata/md5-cache/media-libs/speex-1.2_rc1
+++ b/metadata/md5-cache/media-libs/speex-1.2_rc1
@@ -3,10 +3,10 @@
 DESCRIPTION=Audio compression format designed for speech.
 HOMEPAGE=http://www.speex.org
 IUSE=ogg sse
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=BSD
 RDEPEND=ogg? ( media-libs/libogg )
 SLOT=0
 SRC_URI=http://downloads.xiph.org/releases/speex/speex-1.2rc1.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9fe8c6fde431a22cd50d9bb22d589d52
+_md5_=ef033f043869b898dfd81cf514810975
diff --git a/metadata/md5-cache/media-libs/tiff-4.0.0-r1 b/metadata/md5-cache/media-libs/tiff-4.0.0-r1
index a0cd366..585c514 100644
--- a/metadata/md5-cache/media-libs/tiff-4.0.0-r1
+++ b/metadata/md5-cache/media-libs/tiff-4.0.0-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.remotesensing.org/libtiff/
 IUSE=+cxx jbig jpeg lzma static-libs zlib
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=as-is
 RDEPEND=jpeg? ( virtual/jpeg ) jbig? ( media-libs/jbigkit ) lzma? ( app-arch/xz-utils ) zlib? ( sys-libs/zlib )
 SLOT=0
 SRC_URI=http://download.osgeo.org/libtiff/tiff-4.0.0.tar.gz ftp://ftp.remotesensing.org/pub/libtiff/tiff-4.0.0.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b73f7bdff7ff29b5802967d4b390b96b
+_md5_=3259f484ce36a4a16e14d27fbbec732c
diff --git a/metadata/md5-cache/media-plugins/alsa-plugins-1.0.25-r1 b/metadata/md5-cache/media-plugins/alsa-plugins-1.0.25-r1
index 5a88aa2..8b4f43a 100644
--- a/metadata/md5-cache/media-plugins/alsa-plugins-1.0.25-r1
+++ b/metadata/md5-cache/media-plugins/alsa-plugins-1.0.25-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.alsa-project.org/
 IUSE=debug ffmpeg jack libsamplerate pulseaudio speex
-KEYWORDS=alpha amd64 arm hppa ia64 ~ppc ppc64 sh sparc x86 ~amd64-linux
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 sh sparc x86 ~amd64-linux
 LICENSE=GPL-2 LGPL-2.1
 RDEPEND=>=media-libs/alsa-lib-1.0.25 ffmpeg? ( virtual/ffmpeg media-libs/alsa-lib ) jack? ( >=media-sound/jack-audio-connection-kit-0.98 ) libsamplerate? ( media-libs/libsamplerate media-libs/alsa-lib ) pulseaudio? ( media-sound/pulseaudio ) speex? ( media-libs/speex media-libs/alsa-lib )
 SLOT=0
 SRC_URI=mirror://alsaproject/plugins/alsa-plugins-1.0.25.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=48d0b047ba69627db62845e282dac22d
+_md5_=e3a1da8364439d273d9e845ffa389cce
diff --git a/metadata/md5-cache/media-sound/alsa-headers-1.0.25 b/metadata/md5-cache/media-sound/alsa-headers-1.0.25
index 7d2da7e..b62b1d5 100644
--- a/metadata/md5-cache/media-sound/alsa-headers-1.0.25
+++ b/metadata/md5-cache/media-sound/alsa-headers-1.0.25
@@ -2,10 +2,10 @@
 DESCRIPTION=Header files for Advanced Linux Sound Architecture kernel modules
 EAPI=4
 HOMEPAGE=http://www.alsa-project.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ~ppc ppc64 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos
 LICENSE=GPL-2
 RESTRICT=binchecks strip
 SLOT=0
 SRC_URI=mirror://alsaproject/driver/alsa-driver-1.0.25.tar.bz2
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b3f4fa8815b82fdfedda8a385d4bd32d
+_md5_=2b9d28e505f64682abf6a7364a0d462e
diff --git a/metadata/md5-cache/media-sound/alsa-utils-1.0.25-r1 b/metadata/md5-cache/media-sound/alsa-utils-1.0.25-r1
index d420adb..0702c0c 100644
--- a/metadata/md5-cache/media-sound/alsa-utils-1.0.25-r1
+++ b/metadata/md5-cache/media-sound/alsa-utils-1.0.25-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.alsa-project.org/
 IUSE=doc nls minimal
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ~ppc ppc64 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86
 LICENSE=GPL-2
 RDEPEND=>=sys-libs/ncurses-5.1 dev-util/dialog >=media-libs/alsa-lib-1.0.25 media-libs/libsamplerate !minimal? ( sys-apps/pciutils )
 SLOT=0.9
 SRC_URI=mirror://alsaproject/utils/alsa-utils-1.0.25.tar.bz2 mirror://alsaproject/driver/alsa-driver-1.0.25.tar.bz2
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	systemd	b5da52630b2559da43198bfb56ccacba	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a9aa392e347f04d3cb1bce0d98546d00
+_md5_=430737fb58c99a37c8d9be448e489a95
diff --git a/metadata/md5-cache/media-sound/gsm-1.0.13 b/metadata/md5-cache/media-sound/gsm-1.0.13
index 7a85d93..830fa95 100644
--- a/metadata/md5-cache/media-sound/gsm-1.0.13
+++ b/metadata/md5-cache/media-sound/gsm-1.0.13
@@ -2,9 +2,9 @@
 DESCRIPTION=Lossy speech compression library and tool.
 EAPI=2
 HOMEPAGE=http://packages.qa.debian.org/libg/libgsm.html
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 ~s390 sparc x86 ~amd64-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sparc x86 ~amd64-fbsd ~x86-fbsd
 LICENSE=gsm
 SLOT=0
 SRC_URI=mirror://gentoo/gsm-1.0.13.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=809535a008710e87a28922e63da8ca71
+_md5_=1a9bd8454663281ba7ad9be636025522
diff --git a/metadata/md5-cache/media-sound/sox-14.3.2-r1 b/metadata/md5-cache/media-sound/sox-14.3.2-r1
index f4fb3b6..1aa0aac 100644
--- a/metadata/md5-cache/media-sound/sox-14.3.2-r1
+++ b/metadata/md5-cache/media-sound/sox-14.3.2-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://sox.sourceforge.net
 IUSE=alsa amr ao debug encode ffmpeg flac id3tag ladspa mad ogg openmp oss png pulseaudio sndfile static-libs wavpack
-KEYWORDS=alpha amd64 arm hppa ~ia64 ~mips ppc ppc64 sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-solaris
 LICENSE=LGPL-2.1
 RDEPEND=>=sys-devel/libtool-2.2.6b alsa? ( media-libs/alsa-lib ) amr? ( media-libs/opencore-amr ) encode? ( >=media-sound/lame-3.98.4 ) flac? ( media-libs/flac ) mad? ( media-libs/libmad ) sndfile? ( media-libs/libsndfile ) ogg? ( media-libs/libvorbis media-libs/libogg ) ao? ( media-libs/libao ) ffmpeg? ( virtual/ffmpeg ) ladspa? ( media-libs/ladspa-sdk ) >=media-sound/gsm-1.0.12-r1 id3tag? ( media-libs/libid3tag ) png? ( media-libs/libpng sys-libs/zlib ) pulseaudio? ( media-sound/pulseaudio ) wavpack? ( media-sound/wavpack )
 SLOT=0
 SRC_URI=mirror://sourceforge/sox/sox-14.3.2.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e6a0f6b9d0be796a7722ac2061a2b20b
+_md5_=69c3e976ee7f40406a1bf82f651fa4d9
diff --git a/metadata/md5-cache/media-video/mplayer-1.0_rc4_p20120405 b/metadata/md5-cache/media-video/mplayer-1.0_rc4_p20120405
index 9da2dc5..9622a0d 100644
--- a/metadata/md5-cache/media-video/mplayer-1.0_rc4_p20120405
+++ b/metadata/md5-cache/media-video/mplayer-1.0_rc4_p20120405
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.mplayerhq.hu/
 IUSE=3dnow 3dnowext +a52 aalib +alsa altivec aqua +ass bidi bindist bl bluray bs2b cddb +cdio cdparanoia cpudetection debug dga directfb doc +dts +dv dvb +dvd +dvdnav dxr3 +enca +encode faac +faad fbcon ftp gif ggi gsm +iconv ipv6 jack joystick jpeg jpeg2k kernel_linux ladspa libcaca libmpeg2 lirc +live lzo mad md5sum +mmx mmxext mng +mp3 nas +network nut openal +opengl +osdmenu oss png pnm pulseaudio pvr +quicktime radio +rar +real +rtc rtmp samba +shm sdl +speex sse sse2 ssse3 tga +theora +tremor +truetype +toolame +twolame +unicode v4l vdpau vidix +vorbis win32codecs +X +x264 xanim xinerama +xscreensaver +xv +xvid xvmc zoran video_cards_s3virge video_cards_mga video_cards_tdfx
-KEYWORDS=amd64 ~hppa ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=amd64 hppa ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=sys-libs/ncurses app-arch/bzip2 sys-libs/zlib >=media-video/ffmpeg-0.10.2 !bindist? ( x86? ( win32codecs? ( media-libs/win32codecs ) ) ) a52? ( media-libs/a52dec ) aalib? ( media-libs/aalib ) alsa? ( media-libs/alsa-lib ) ass? ( >=media-libs/libass-0.9.10[enca?] ) bidi? ( dev-libs/fribidi ) bluray? ( >=media-libs/libbluray-0.2.1 ) bs2b? ( media-libs/libbs2b ) cdio? ( dev-libs/libcdio ) cdparanoia? ( !cdio? ( media-sound/cdparanoia ) ) dga? ( x11-libs/libXxf86dga ) directfb? ( dev-libs/DirectFB ) dts? ( media-libs/libdca ) dv? ( media-libs/libdv ) dvb? ( virtual/linuxtv-dvb-headers ) dvd? ( >=media-libs/libdvdread-4.1.3 ) dvdnav? ( >=media-libs/libdvdnav-4.1.3 ) encode? ( !twolame? ( toolame? ( media-sound/toolame ) ) twolame? ( media-sound/twolame ) faac? ( media-libs/faac ) mp3? ( media-sound/lame ) x264? ( >=media-libs/x264-0.0.20100423 ) xvid? ( media-libs/xvid ) ) enca? ( app-i18n/enca ) faad? ( media-libs/faad2 ) ggi? ( media-libs/libggi media-libs/libggiwmh ) gif? ( media-libs/giflib ) gsm? ( media-sound/gsm ) iconv? ( virtual/libiconv ) jack? ( media-sound/jack-audio-connection-kit ) jpeg? ( virtual/jpeg ) jpeg2k? ( media-libs/openjpeg ) ladspa? ( media-libs/ladspa-sdk ) libcaca? ( media-libs/libcaca ) libmpeg2? ( media-libs/libmpeg2 ) lirc? ( app-misc/lirc ) live? ( media-plugins/live ) lzo? ( >=dev-libs/lzo-2 ) mad? ( media-libs/libmad ) mng? ( media-libs/libmng ) mp3? ( media-sound/mpg123 ) nas? ( media-libs/nas ) nut? ( >=media-libs/libnut-661 ) openal? ( media-libs/openal ) opengl? ( virtual/opengl ) png? ( media-libs/libpng ) pnm? ( media-libs/netpbm ) pulseaudio? ( media-sound/pulseaudio ) rar? ( || ( app-arch/unrar app-arch/rar ) ) rtmp? ( media-video/rtmpdump ) samba? ( net-fs/samba ) sdl? ( media-libs/libsdl ) speex? ( media-libs/speex ) theora? ( media-libs/libtheora[encode?] ) truetype? ( virtual/ttf-fonts media-libs/fontconfig >=media-libs/freetype-2.2.1:2 ) vdpau? ( x11-libs/libvdpau ) vorbis? ( media-libs/libvorbis ) X? ( x11-libs/libXext x11-libs/libXxf86vm ) xanim? ( media-video/xanim ) xinerama? ( x11-libs/libXinerama ) xscreensaver? ( x11-libs/libXScrnSaver ) xv? ( x11-libs/libXv ) xvmc? ( x11-libs/libXvMC )
 REQUIRED_USE=bindist? ( !faac !win32codecs ) dvdnav? ( dvd ) ass? ( truetype ) truetype? ( iconv ) dxr3? ( X ) ggi? ( X ) xinerama? ( X ) dga? ( X ) opengl? ( X ) osdmenu? ( X ) vdpau? ( X ) vidix? ( X ) xscreensaver? ( X ) xv? ( X ) xvmc? ( xv )
 SLOT=0
 SRC_URI=mirror://gentoo/mplayer-1.0_rc4_p20120405.tar.xz !truetype? ( mirror://mplayer/releases/fonts/font-arial-iso-8859-1.tar.bz2 mirror://mplayer/releases/fonts/font-arial-iso-8859-2.tar.bz2 mirror://mplayer/releases/fonts/font-arial-cp1250.tar.bz2 )
 _eclasses_=base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2c26c840992f5f768b201bb8be2c747c
+_md5_=7c58b397951c9f636bf177bbc2e0e7e9
diff --git a/metadata/md5-cache/net-analyzer/tcpdump-4.3.0 b/metadata/md5-cache/net-analyzer/tcpdump-4.3.0
index a87a56c..4f90cbd 100644
--- a/metadata/md5-cache/net-analyzer/tcpdump-4.3.0
+++ b/metadata/md5-cache/net-analyzer/tcpdump-4.3.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.tcpdump.org/
 IUSE=+chroot smi ssl ipv6 -samba suid test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux
 LICENSE=BSD
 RDEPEND=net-libs/libpcap smi? ( net-libs/libsmi ) ssl? ( >=dev-libs/openssl-0.9.6m )
 SLOT=0
 SRC_URI=http://www.tcpdump.org/release/tcpdump-4.3.0.tar.gz http://www.jp.tcpdump.org/release/tcpdump-4.3.0.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=652c9ab5d4d5f4b5fdf0d28b8e1c75f6
+_md5_=56efd62deadf83b287bd8354467c3f05
diff --git a/metadata/md5-cache/net-dialup/lrzsz-0.12.20-r2 b/metadata/md5-cache/net-dialup/lrzsz-0.12.20-r2
index acf6c1b..8243793 100644
--- a/metadata/md5-cache/net-dialup/lrzsz-0.12.20-r2
+++ b/metadata/md5-cache/net-dialup/lrzsz-0.12.20-r2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.ohse.de/uwe/software/lrzsz.html
 IUSE=nls
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=http://www.ohse.de/uwe/releases/lrzsz-0.12.20.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8d2fba0500c7a54ac44c2d7aa0e15b0f
+_md5_=d58bee94756d0954ccf256dcbfd067f2
diff --git a/metadata/md5-cache/net-dialup/minicom-2.6 b/metadata/md5-cache/net-dialup/minicom-2.6
index c543256..cbb27a4 100644
--- a/metadata/md5-cache/net-dialup/minicom-2.6
+++ b/metadata/md5-cache/net-dialup/minicom-2.6
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://alioth.debian.org/projects/minicom
 IUSE=nls linguas_cs linguas_da linguas_de linguas_es linguas_fi linguas_fr linguas_hu linguas_id linguas_ja linguas_nb linguas_pl linguas_pt_BR linguas_ro linguas_ru linguas_rw linguas_sv linguas_vi linguas_zh_TW
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=sys-libs/ncurses net-dialup/lrzsz
 SLOT=0
 SRC_URI=http://alioth.debian.org/download.php/3689/minicom-2.6.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=56689c3665f6b75e85566ba4d4cd82b9
+_md5_=e877dbe7f69fe9aeb8820f74a9eaa613
diff --git a/metadata/md5-cache/net-dns/avahi-0.6.31-r1 b/metadata/md5-cache/net-dns/avahi-0.6.31-r1
index f9d8a3d..4d98141 100644
--- a/metadata/md5-cache/net-dns/avahi-0.6.31-r1
+++ b/metadata/md5-cache/net-dns/avahi-0.6.31-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://avahi.org/
 IUSE=autoipd bookmarks dbus doc gdbm gtk gtk3 howl-compat +introspection ipv6 kernel_linux mdnsresponder-compat mono python qt4 test utils
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-linux
 LICENSE=LGPL-2.1
 RDEPEND=>=dev-libs/libdaemon-0.14 dev-libs/expat dev-libs/glib:2 gdbm? ( sys-libs/gdbm ) qt4? ( dev-qt/qtcore:4 ) gtk? ( >=x11-libs/gtk+-2.14.0:2 ) gtk3? ( x11-libs/gtk+:3 ) dbus? ( >=sys-apps/dbus-0.30 python? ( dev-python/dbus-python ) ) mono? ( >=dev-lang/mono-1.1.10 gtk? ( >=dev-dotnet/gtk-sharp-2 ) ) howl-compat? ( >=sys-apps/dbus-0.30 ) introspection? ( >=dev-libs/gobject-introspection-0.9.5 ) mdnsresponder-compat? ( >=sys-apps/dbus-0.30 ) python? ( gtk? ( >=dev-python/pygtk-2 ) ) bookmarks? ( dev-python/twisted dev-python/twisted-web ) kernel_linux? ( sys-libs/libcap ) howl-compat? ( !net-misc/howl ) mdnsresponder-compat? ( !net-misc/mDNSResponder ) >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* ) python? ( =dev-lang/python-2*[gdbm] )
 SLOT=0
 SRC_URI=http://avahi.org/download/avahi-0.6.31.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	mono	1b3a5799422dfe677c9d09f162d99cc0	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	systemd	b5da52630b2559da43198bfb56ccacba	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b99686934fd257d5edcbf009d6906b3b
+_md5_=957819d34d6689ea6cb4e5e95b423672
diff --git a/metadata/md5-cache/net-dns/c-ares-1.7.4 b/metadata/md5-cache/net-dns/c-ares-1.7.4
index a462158..2170fd1 100644
--- a/metadata/md5-cache/net-dns/c-ares-1.7.4
+++ b/metadata/md5-cache/net-dns/c-ares-1.7.4
@@ -2,8 +2,8 @@
 DESCRIPTION=C library that resolves names asynchronously
 EAPI=2
 HOMEPAGE=http://daniel.haxx.se/projects/c-ares/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc64-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc64-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://daniel.haxx.se/projects/c-ares/c-ares-1.7.4.tar.gz
-_md5_=b967e4cd099d4f9e0a8bbbda1fbc7c0e
+_md5_=586e9771eadd36336d5599df36c00358
diff --git a/metadata/md5-cache/net-dns/c-ares-1.7.5 b/metadata/md5-cache/net-dns/c-ares-1.7.5
index 3ff96d7..d4b4b22 100644
--- a/metadata/md5-cache/net-dns/c-ares-1.7.5
+++ b/metadata/md5-cache/net-dns/c-ares-1.7.5
@@ -3,8 +3,8 @@
 EAPI=4
 HOMEPAGE=http://c-ares.haxx.se/
 IUSE=static-libs
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc64-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc64-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://c-ares.haxx.se/download/c-ares-1.7.5.tar.gz
-_md5_=ede63ec82049ae184b13cc647465e054
+_md5_=25317b3307c726b030c2b77662d94850
diff --git a/metadata/md5-cache/net-dns/dnsmasq-2.50 b/metadata/md5-cache/net-dns/dnsmasq-2.50
index e410efd..3da503f 100644
--- a/metadata/md5-cache/net-dns/dnsmasq-2.50
+++ b/metadata/md5-cache/net-dns/dnsmasq-2.50
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.thekelleys.org.uk/dnsmasq/
 IUSE=dbus +dhcp ipv6 nls tftp
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=dbus? ( sys-apps/dbus ) nls? ( sys-devel/gettext )
 SLOT=0
 SRC_URI=http://www.thekelleys.org.uk/dnsmasq/dnsmasq-2.50.tar.lzma
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b036a09e78ac9ce2c63320855d8ea326
+_md5_=e017612e4156c50b6a76f4c85294deab
diff --git a/metadata/md5-cache/net-ftp/tftp-hpa-5.2 b/metadata/md5-cache/net-ftp/tftp-hpa-5.2
index ec1bcab..84a13a0 100644
--- a/metadata/md5-cache/net-ftp/tftp-hpa-5.2
+++ b/metadata/md5-cache/net-ftp/tftp-hpa-5.2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.kernel.org/pub/software/network/tftp/
 IUSE=ipv6 readline selinux tcpd
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~ppc-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~ppc-macos
 LICENSE=BSD
 RDEPEND=selinux? ( sec-policy/selinux-tftp ) readline? ( sys-libs/readline ) tcpd? ( sys-apps/tcp-wrappers ) !net-ftp/atftp !net-ftp/netkit-tftp
 SLOT=0
 SRC_URI=mirror://kernel/software/network/tftp/tftp-hpa/tftp-hpa-5.2.tar.xz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=2185f65ef0f96850bd13ceb18ce4879a
+_md5_=71bbed3c860f51b2dfa6e0850db87f4b
diff --git a/metadata/md5-cache/net-libs/gnutls-2.10.5 b/metadata/md5-cache/net-libs/gnutls-2.10.5
index a5f8a12..15b32e7 100644
--- a/metadata/md5-cache/net-libs/gnutls-2.10.5
+++ b/metadata/md5-cache/net-libs/gnutls-2.10.5
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.gnutls.org/
 IUSE=bindist +cxx doc examples guile lzo nls test zlib
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=LGPL-2.1 GPL-3
 RDEPEND=>=dev-libs/libgcrypt-1.4.0 >=dev-libs/libtasn1-0.3.4 nls? ( virtual/libintl ) guile? ( >=dev-scheme/guile-1.8[networking] ) zlib? ( >=sys-libs/zlib-1.2.3.1 ) !bindist? ( lzo? ( >=dev-libs/lzo-2 ) )
 SLOT=0
 SRC_URI=mirror://gnu/gnutls/gnutls-2.10.5.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=e178d6431d861b933c9ad098f1ebb913
+_md5_=23dd60bae4fdac5ea85f218a8b445c7f
diff --git a/metadata/md5-cache/net-libs/liblockfile-1.08 b/metadata/md5-cache/net-libs/liblockfile-1.08
index bc5929e..6cb788f 100644
--- a/metadata/md5-cache/net-libs/liblockfile-1.08
+++ b/metadata/md5-cache/net-libs/liblockfile-1.08
@@ -3,9 +3,9 @@
 DESCRIPTION=Implements functions designed to lock the standard mailboxes
 EAPI=2
 HOMEPAGE=http://www.debian.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=LGPL-2
 SLOT=0
 SRC_URI=mirror://debian/pool/main/libl/liblockfile/liblockfile_1.08.orig.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f84b135f20cd66ab2f07cc99348f0e4c
+_md5_=c417627096a72796ed35b750b0361cf5
diff --git a/metadata/md5-cache/net-libs/libnetfilter_queue-1.0.1 b/metadata/md5-cache/net-libs/libnetfilter_queue-1.0.1
index a7826f9..c53ebad 100644
--- a/metadata/md5-cache/net-libs/libnetfilter_queue-1.0.1
+++ b/metadata/md5-cache/net-libs/libnetfilter_queue-1.0.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.netfilter.org/projects/libnetfilter_queue/
 IUSE=static-libs
-KEYWORDS=amd64 arm ~ppc ~sparc x86
+KEYWORDS=amd64 arm ppc sparc x86
 LICENSE=GPL-2
 RDEPEND=>=net-libs/libnfnetlink-0.0.41
 SLOT=0
 SRC_URI=http://www.netfilter.org/projects/libnetfilter_queue/files/libnetfilter_queue-1.0.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=e02b89318c5fb3c8916884941917a200
+_md5_=b5ae3993e4b0d556730c744b39bd0f07
diff --git a/metadata/md5-cache/net-libs/libnfnetlink-1.0.1 b/metadata/md5-cache/net-libs/libnfnetlink-1.0.1
index aebccfa..413db58 100644
--- a/metadata/md5-cache/net-libs/libnfnetlink-1.0.1
+++ b/metadata/md5-cache/net-libs/libnfnetlink-1.0.1
@@ -3,9 +3,9 @@
 EAPI=4
 HOMEPAGE=http://www.netfilter.org/projects/libnfnetlink/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://www.netfilter.org/projects/libnfnetlink/files/libnfnetlink-1.0.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=be6e45243c0129315c0d88eda0d52fc6
+_md5_=a3cd811010582118175c334837859982
diff --git a/metadata/md5-cache/net-libs/libnfsidmap-0.24 b/metadata/md5-cache/net-libs/libnfsidmap-0.24
index f34c202..efd80a5 100644
--- a/metadata/md5-cache/net-libs/libnfsidmap-0.24
+++ b/metadata/md5-cache/net-libs/libnfsidmap-0.24
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.citi.umich.edu/projects/nfsv4/linux/
 IUSE=ldap static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=BSD
 RDEPEND=ldap? ( net-nds/openldap ) !<net-fs/nfs-utils-1.2.2 !net-fs/idmapd
 SLOT=0
 SRC_URI=http://www.citi.umich.edu/projects/nfsv4/linux/libnfsidmap/libnfsidmap-0.24.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=accc06ffb8606bb01973f5652b2d92b0
+_md5_=4f89022387ed5846113ef7a170839ca4
diff --git a/metadata/md5-cache/net-libs/libpcap-1.1.1-r1 b/metadata/md5-cache/net-libs/libpcap-1.1.1-r1
index 13dec78..22c0935 100644
--- a/metadata/md5-cache/net-libs/libpcap-1.1.1-r1
+++ b/metadata/md5-cache/net-libs/libpcap-1.1.1-r1
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.tcpdump.org/
 IUSE=bluetooth ipv6 libnl
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=BSD
 RDEPEND=bluetooth? ( net-wireless/bluez ) libnl? ( dev-libs/libnl )
 SLOT=0
 SRC_URI=http://www.tcpdump.org/release/libpcap-1.1.1.tar.gz http://www.jp.tcpdump.org/release/libpcap-1.1.1.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=623af10309fe95a5e7c08f08f62d11d6
+_md5_=0e651e98bad5ff55ccedb18cbeee6cc3
diff --git a/metadata/md5-cache/net-libs/libsoup-2.32.2 b/metadata/md5-cache/net-libs/libsoup-2.32.2
index c026b43..ba0a805 100644
--- a/metadata/md5-cache/net-libs/libsoup-2.32.2
+++ b/metadata/md5-cache/net-libs/libsoup-2.32.2
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://live.gnome.org/LibSoup
 IUSE=debug doc +introspection ssl test debug
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=LGPL-2
 RDEPEND=>=dev-libs/glib-2.21.3 >=dev-libs/libxml2-2 introspection? ( >=dev-libs/gobject-introspection-0.9.5 ) ssl? ( >=net-libs/gnutls-2.1.7 )
 SLOT=2.4
 SRC_URI=mirror://gnome/sources/libsoup/2.32/libsoup-2.32.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	fdo-mime	9c46e30acd923ff12e325dbe96bb98b9	gnome.org	8fef8f967214f56e08fa92d61163d891	gnome2	7976d3f4d0c0816c67033d3dcd4d9472	gnome2-utils	794d2847b4af390a1e020924876c8297	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=ea490e69344eda87153a50ee65ca7c47
+_md5_=10c7543dccf3614d259d0a4562cdadc5
diff --git a/metadata/md5-cache/net-libs/libtirpc-0.2.0 b/metadata/md5-cache/net-libs/libtirpc-0.2.0
index 358b7a6..a15eb65 100644
--- a/metadata/md5-cache/net-libs/libtirpc-0.2.0
+++ b/metadata/md5-cache/net-libs/libtirpc-0.2.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Transport Independent RPC library (SunRPC replacement)
 HOMEPAGE=http://libtirpc.sourceforge.net/
 IUSE=kerberos
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc ~x86
 LICENSE=GPL-2
 RDEPEND=kerberos? ( net-libs/libgssglue )
 SLOT=0
 SRC_URI=mirror://sourceforge/libtirpc/libtirpc-0.2.0.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e031cab8b954440e157af7a3ed9bb91d
+_md5_=201eb755c64643f390f65dd62942a51b
diff --git a/metadata/md5-cache/net-libs/neon-0.29.6 b/metadata/md5-cache/net-libs/neon-0.29.6
index 4a5822e..8ff91eb 100644
--- a/metadata/md5-cache/net-libs/neon-0.29.6
+++ b/metadata/md5-cache/net-libs/neon-0.29.6
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://www.webdav.org/neon/
 IUSE=doc expat gnutls kerberos libproxy nls pkcs11 ssl static-libs zlib linguas_cs linguas_de linguas_fr linguas_ja linguas_nn linguas_pl linguas_ru linguas_tr linguas_zh_CN
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=expat? ( dev-libs/expat ) !expat? ( dev-libs/libxml2 ) gnutls? ( app-misc/ca-certificates >=net-libs/gnutls-2.0 pkcs11? ( dev-libs/pakchois ) ) !gnutls? ( ssl? ( >=dev-libs/openssl-0.9.6f pkcs11? ( dev-libs/pakchois ) ) ) kerberos? ( virtual/krb5 ) libproxy? ( net-libs/libproxy ) nls? ( virtual/libintl ) zlib? ( sys-libs/zlib )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://www.webdav.org/neon/neon-0.29.6.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=e094419a551eea5e194fdd6b6aff073c
+_md5_=82400258ce49b9d362314a3acc46e4c4
diff --git a/metadata/md5-cache/net-libs/serf-0.3.0 b/metadata/md5-cache/net-libs/serf-0.3.0
index 224c679..fbd96f4 100644
--- a/metadata/md5-cache/net-libs/serf-0.3.0
+++ b/metadata/md5-cache/net-libs/serf-0.3.0
@@ -2,10 +2,10 @@
 DEPEND=dev-libs/apr dev-libs/apr-util dev-libs/openssl sys-libs/zlib || ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool
 DESCRIPTION=HTTP client library
 HOMEPAGE=http://code.google.com/p/serf/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=Apache-2.0
 RDEPEND=dev-libs/apr dev-libs/apr-util dev-libs/openssl sys-libs/zlib
 SLOT=0
 SRC_URI=http://serf.googlecode.com/files/serf-0.3.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=bf8b559377fc991cf2f305247fed7cee
+_md5_=27a3d4aa556e7785907959839941d1c4
diff --git a/metadata/md5-cache/net-misc/corkscrew-2.0 b/metadata/md5-cache/net-misc/corkscrew-2.0
index 6268195..87d9e0f 100644
--- a/metadata/md5-cache/net-misc/corkscrew-2.0
+++ b/metadata/md5-cache/net-misc/corkscrew-2.0
@@ -3,9 +3,9 @@
 DESCRIPTION=a tool for tunneling SSH through HTTP proxies
 EAPI=3
 HOMEPAGE=http://www.agroman.net/corkscrew/
-KEYWORDS=amd64 ~arm ~ppc ~sparc x86
+KEYWORDS=amd64 ~arm ppc sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://www.agroman.net/corkscrew/corkscrew-2.0.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=615750f65e04bb4d61fb488db4a9e905
+_md5_=1c604b2eee13ced55cb24899b30ec091
diff --git a/metadata/md5-cache/net-misc/dhcp-4.2.2-r1 b/metadata/md5-cache/net-misc/dhcp-4.2.2-r1
index daa9bea..326fa9a 100644
--- a/metadata/md5-cache/net-misc/dhcp-4.2.2-r1
+++ b/metadata/md5-cache/net-misc/dhcp-4.2.2-r1
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.isc.org/products/DHCP
 IUSE=+client ipv6 kernel_linux ldap selinux +server ssl vim-syntax
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha ~amd64 ~arm hppa mips ppc ppc64 s390 sh sparc ~x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=as-is BSD
 RDEPEND=selinux? ( sec-policy/selinux-dhcp ) kernel_linux? ( sys-apps/net-tools ) ldap? ( net-nds/openldap ssl? ( dev-libs/openssl ) ) vim-syntax? ( app-vim/dhcpd-syntax )
 SLOT=0
 SRC_URI=ftp://ftp.isc.org/isc/dhcp/dhcp-4.2.2.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=80798577b19c9ec068c9fafc1de52fa0
+_md5_=70492e18f60ddf5ffcd9da5f7ac0139a
diff --git a/metadata/md5-cache/net-misc/dropbear-2012.55 b/metadata/md5-cache/net-misc/dropbear-2012.55
index 5fb7dad..1d77e3f 100644
--- a/metadata/md5-cache/net-misc/dropbear-2012.55
+++ b/metadata/md5-cache/net-misc/dropbear-2012.55
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://matt.ucc.asn.au/dropbear/dropbear.html
 IUSE=bsdpty minimal multicall pam static syslog zlib savedconfig
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=MIT
 RDEPEND=!static? ( zlib? ( sys-libs/zlib ) dev-libs/libtommath ) pam? ( virtual/pam ) pam? ( >=sys-auth/pambase-20080219.1 )
 REQUIRED_USE=pam? ( !static )
 SLOT=0
 SRC_URI=http://matt.ucc.asn.au/dropbear/releases/dropbear-2012.55.tar.bz2 http://matt.ucc.asn.au/dropbear/testing/dropbear-2012.55.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	pam	3f746974e1cc47cabe3bd488c08cdc8e	portability	536c5e70c5fb252ed3b769e04aa3f05b	savedconfig	973a6df1a0949eba28a185eac79de815	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e203f11bfbcf5015b1304e0217723a20
+_md5_=a9ce23bedf12b440d63987b53e0afb8a
diff --git a/metadata/md5-cache/net-misc/rsync-3.0.8 b/metadata/md5-cache/net-misc/rsync-3.0.8
index 09244a3..6b8db6e 100644
--- a/metadata/md5-cache/net-misc/rsync-3.0.8
+++ b/metadata/md5-cache/net-misc/rsync-3.0.8
@@ -3,10 +3,10 @@
 DESCRIPTION=File transfer program to keep remote files into sync
 HOMEPAGE=http://rsync.samba.org/
 IUSE=acl iconv ipv6 static xattr
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=>=dev-libs/popt-1.5 acl? ( virtual/acl ) xattr? ( kernel_linux? ( sys-apps/attr ) ) iconv? ( virtual/libiconv )
 SLOT=0
 SRC_URI=http://rsync.samba.org/ftp/rsync/src/rsync-3.0.8.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=92930e40d2200edf8ee8340ff123d9c1
+_md5_=b44e35dca5087a7d139483df1afb35e4
diff --git a/metadata/md5-cache/net-misc/socat-1.7.2.1 b/metadata/md5-cache/net-misc/socat-1.7.2.1
index 419e93a..b875c65 100644
--- a/metadata/md5-cache/net-misc/socat-1.7.2.1
+++ b/metadata/md5-cache/net-misc/socat-1.7.2.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.dest-unreach.org/socat/
 IUSE=ssl readline ipv6 tcpd
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc sparc x86 ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc sparc x86 ~ppc-macos ~x64-macos ~x86-macos
 LICENSE=GPL-2
 RDEPEND=ssl? ( >=dev-libs/openssl-0.9.6 ) readline? ( >=sys-libs/ncurses-5.1 >=sys-libs/readline-4.1 ) tcpd? ( sys-apps/tcp-wrappers )
 SLOT=0
 SRC_URI=http://www.dest-unreach.org/socat/download/socat-1.7.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=513eb4f1c0c825f162692e6c57568f47
+_md5_=b0167311968c03350e16bb75fc78be7a
diff --git a/metadata/md5-cache/net-misc/wget-1.12-r2 b/metadata/md5-cache/net-misc/wget-1.12-r2
index 775dbea..8552d8c 100644
--- a/metadata/md5-cache/net-misc/wget-1.12-r2
+++ b/metadata/md5-cache/net-misc/wget-1.12-r2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/wget/
 IUSE=debug idn ipv6 nls ntlm +ssl static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=idn? ( net-dns/libidn ) ssl? ( >=dev-libs/openssl-0.9.6b )
 SLOT=0
 SRC_URI=mirror://gnu/wget/wget-1.12.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6b64be6246d7bd41855ee3700d748bff
+_md5_=faa7dd2431b3b72938c6dc57842b827f
diff --git a/metadata/md5-cache/net-nds/rpcbind-0.2.0 b/metadata/md5-cache/net-nds/rpcbind-0.2.0
index 73a8dc4..89c8c0a 100644
--- a/metadata/md5-cache/net-nds/rpcbind-0.2.0
+++ b/metadata/md5-cache/net-nds/rpcbind-0.2.0
@@ -3,10 +3,10 @@
 DESCRIPTION=portmap replacement which supports RPC over various protocols
 EAPI=2
 HOMEPAGE=http://sourceforge.net/projects/rpcbind/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86
 LICENSE=BSD
 RDEPEND=net-libs/libtirpc
 SLOT=0
 SRC_URI=mirror://sourceforge/rpcbind/rpcbind-0.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=1ae0fadafb1ff999f6c48ffd6cc106ba
+_md5_=fe300a29fed0e78cd3a815b045a6f725
diff --git a/metadata/md5-cache/net-proxy/tsocks-1.8_beta5-r4 b/metadata/md5-cache/net-proxy/tsocks-1.8_beta5-r4
index 501046b..98b52dc 100644
--- a/metadata/md5-cache/net-proxy/tsocks-1.8_beta5-r4
+++ b/metadata/md5-cache/net-proxy/tsocks-1.8_beta5-r4
@@ -3,9 +3,9 @@
 DESCRIPTION=Transparent SOCKS v4 proxying library
 HOMEPAGE=http://tsocks.sourceforge.net/
 IUSE=tordns
-KEYWORDS=~alpha ~amd64 ~ppc ~ppc64 ~sparc ~x86 ~x86-fbsd
+KEYWORDS=alpha ~amd64 ppc ppc64 sparc ~x86 ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://sourceforge/tsocks/tsocks-1.8beta5.tar.gz tordns? ( mirror://gentoo/tsocks-1.8b5-tordns1-gentoo-r1.patch.gz )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=7b6cf904928673fe9850c38c06776557
+_md5_=89981510b7b5aeccfba1aea763f15bad
diff --git a/metadata/md5-cache/net-wireless/wireless-tools-29 b/metadata/md5-cache/net-wireless/wireless-tools-29
index 7976402..bb80544 100644
--- a/metadata/md5-cache/net-wireless/wireless-tools-29
+++ b/metadata/md5-cache/net-wireless/wireless-tools-29
@@ -3,9 +3,9 @@
 DESCRIPTION=A collection of tools to configure IEEE 802.11 wireless LAN cards
 HOMEPAGE=http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/Tools.html
 IUSE=multicall nls
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ppc ppc64 sh ~sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/wireless_tools.29.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f403b075d7c5d3797884dd9e077e8219
+_md5_=a81a72041b1e688e141eebe83cbc4cec
diff --git a/metadata/md5-cache/net-zope/zope-fixers-1.0 b/metadata/md5-cache/net-zope/zope-fixers-1.0
index 2e03d02..35df260 100644
--- a/metadata/md5-cache/net-zope/zope-fixers-1.0
+++ b/metadata/md5-cache/net-zope/zope-fixers-1.0
@@ -3,10 +3,10 @@
 DESCRIPTION=2to3 fixers for Zope
 EAPI=3
 HOMEPAGE=http://pypi.python.org/pypi/zope.fixers
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=ZPL
 RDEPEND=>=app-admin/eselect-python-20091230 || ( =dev-lang/python-3.2* =dev-lang/python-3.1* =dev-lang/python-2.7* =dev-lang/python-2.6* )
 SLOT=0
 SRC_URI=mirror://pypi/z/zope.fixers/zope.fixers-1.0.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=68a6ef41a462f689f7d8af3b4d5073d6
+_md5_=7335bfcccec7f7fd9eecda56c3cdfec3
diff --git a/metadata/md5-cache/net-zope/zope-interface-3.8.0 b/metadata/md5-cache/net-zope/zope-interface-3.8.0
index 445d7ee..ab36a5d 100644
--- a/metadata/md5-cache/net-zope/zope-interface-3.8.0
+++ b/metadata/md5-cache/net-zope/zope-interface-3.8.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Interfaces for Python
 EAPI=3
 HOMEPAGE=http://pypi.python.org/pypi/zope.interface
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=ZPL
 RDEPEND=>=app-admin/eselect-python-20091230 dev-lang/python
 SLOT=0
 SRC_URI=mirror://pypi/z/zope.interface/zope.interface-3.8.0.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=d4cca3eacf07ddd118fa5228152f8db9
+_md5_=00138531d359b58043e86e6361cc9470
diff --git a/metadata/md5-cache/perl-core/Compress-Raw-Bzip2-2.024 b/metadata/md5-cache/perl-core/Compress-Raw-Bzip2-2.024
index dfe8d8a..e029910 100644
--- a/metadata/md5-cache/perl-core/Compress-Raw-Bzip2-2.024
+++ b/metadata/md5-cache/perl-core/Compress-Raw-Bzip2-2.024
@@ -3,10 +3,10 @@
 DESCRIPTION=Low-Level Interface to bzip2 compression library
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/Compress-Raw-Bzip2/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=app-arch/bzip2 dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/P/PM/PMQS/Compress-Raw-Bzip2-2.024.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c293fc3d3c23935bced6c20f8ad94ec5
+_md5_=52f4d28f8e985afb7b901b4eab8cf247
diff --git a/metadata/md5-cache/perl-core/Compress-Raw-Zlib-2.024 b/metadata/md5-cache/perl-core/Compress-Raw-Zlib-2.024
index 50f8c7d..f59ccb9 100644
--- a/metadata/md5-cache/perl-core/Compress-Raw-Zlib-2.024
+++ b/metadata/md5-cache/perl-core/Compress-Raw-Zlib-2.024
@@ -3,10 +3,10 @@
 DESCRIPTION=Low-Level Interface to zlib compression library
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/Compress-Raw-Zlib/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=>=sys-libs/zlib-1.2.2.1 dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/P/PM/PMQS/Compress-Raw-Zlib-2.024.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d7e2c7337ea42e13fcc80d90f00b6e2a
+_md5_=52326245d4fb952952128450beb20c20
diff --git a/metadata/md5-cache/perl-core/ExtUtils-CBuilder-0.27.03 b/metadata/md5-cache/perl-core/ExtUtils-CBuilder-0.27.03
index bdd0152..91fa082 100644
--- a/metadata/md5-cache/perl-core/ExtUtils-CBuilder-0.27.03
+++ b/metadata/md5-cache/perl-core/ExtUtils-CBuilder-0.27.03
@@ -3,10 +3,10 @@
 DESCRIPTION=Compile and link C code for Perl modules
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/ExtUtils-CBuilder/
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/D/DA/DAGOLDEN/ExtUtils-CBuilder-0.2703.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=7ae0defa1e9922d72802df0ff359e51c
+_md5_=814394a7f9d42e927beb8962883e0923
diff --git a/metadata/md5-cache/perl-core/ExtUtils-ParseXS-2.22.05 b/metadata/md5-cache/perl-core/ExtUtils-ParseXS-2.22.05
index 93d0d57..9860039 100644
--- a/metadata/md5-cache/perl-core/ExtUtils-ParseXS-2.22.05
+++ b/metadata/md5-cache/perl-core/ExtUtils-ParseXS-2.22.05
@@ -3,10 +3,10 @@
 DESCRIPTION=Converts Perl XS code into C code
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/ExtUtils-ParseXS/
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/D/DA/DAGOLDEN/ExtUtils-ParseXS-2.2205.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=eda46c4c7cf7b7ab8ebbb710011f4759
+_md5_=c9526f08b4751ebb8b7210261a8033a7
diff --git a/metadata/md5-cache/perl-core/File-Spec-3.31 b/metadata/md5-cache/perl-core/File-Spec-3.31
index b05c0ef..b833b10 100644
--- a/metadata/md5-cache/perl-core/File-Spec-3.31
+++ b/metadata/md5-cache/perl-core/File-Spec-3.31
@@ -3,10 +3,10 @@
 DESCRIPTION=Handling files and directories portably
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/PathTools/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/S/SM/SMUELLER/PathTools-3.31.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=76e489d91cf17fd98aadb5d19bf87215
+_md5_=0f969e0fd71b606365bd7e73152f798d
diff --git a/metadata/md5-cache/perl-core/IO-Compress-2.024 b/metadata/md5-cache/perl-core/IO-Compress-2.024
index ef67a24..b1dd0db 100644
--- a/metadata/md5-cache/perl-core/IO-Compress-2.024
+++ b/metadata/md5-cache/perl-core/IO-Compress-2.024
@@ -3,10 +3,10 @@
 DESCRIPTION=allow reading and writing of compressed data
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/IO-Compress/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=virtual/perl-Scalar-List-Utils >=virtual/perl-Compress-Raw-Zlib-2.024 >=virtual/perl-Compress-Raw-Bzip2-2.024 !perl-core/Compress-Zlib !perl-core/IO-Compress-Zlib !perl-core/IO-Compress-Bzip2 !perl-core/IO-Compress-Base dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/P/PM/PMQS/IO-Compress-2.024.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e16427acc48f4836ff37c580b164513b
+_md5_=a3054101c107836db9a3ee083ec60ef4
diff --git a/metadata/md5-cache/perl-core/IO-Zlib-1.100.0 b/metadata/md5-cache/perl-core/IO-Zlib-1.100.0
index a7a2544..b697fb1 100644
--- a/metadata/md5-cache/perl-core/IO-Zlib-1.100.0
+++ b/metadata/md5-cache/perl-core/IO-Zlib-1.100.0
@@ -3,10 +3,10 @@
 DESCRIPTION=IO:: style interface to Compress::Zlib
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/IO-Zlib/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=virtual/perl-IO-Compress dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/T/TO/TOMHUGHES/IO-Zlib-1.10.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=5a87a9e6f441f570c579f05761a4cbe7
+_md5_=b336a1a763388eaec8af18f5fc89a88f
diff --git a/metadata/md5-cache/perl-core/Module-Build-0.36.07 b/metadata/md5-cache/perl-core/Module-Build-0.36.07
index 6ae1ddb..166220a 100644
--- a/metadata/md5-cache/perl-core/Module-Build-0.36.07
+++ b/metadata/md5-cache/perl-core/Module-Build-0.36.07
@@ -3,10 +3,10 @@
 DESCRIPTION=Build and install Perl modules
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/Module-Build/
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-perl/YAML-Tiny >=virtual/perl-ExtUtils-CBuilder-0.27 >=virtual/perl-ExtUtils-ParseXS-2.22.05 >=virtual/perl-Archive-Tar-1.09 >=virtual/perl-Test-Harness-3.16 dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/D/DA/DAGOLDEN/Module-Build-0.3607.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=d3eea2a071dc4034aef50833752df159
+_md5_=5f6b5709bf1ce9a327119501b5f1bffe
diff --git a/metadata/md5-cache/perl-core/Scalar-List-Utils-1.230.0 b/metadata/md5-cache/perl-core/Scalar-List-Utils-1.230.0
index e7544b3..9c667c3 100644
--- a/metadata/md5-cache/perl-core/Scalar-List-Utils-1.230.0
+++ b/metadata/md5-cache/perl-core/Scalar-List-Utils-1.230.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Scalar-List-Utils module for perl
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/Scalar-List-Utils/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/G/GB/GBARR/Scalar-List-Utils-1.23.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=5c8b2d3b8bdcfb31b998a8d8ecea1907
+_md5_=f66266a324c335999eba16434f94e819
diff --git a/metadata/md5-cache/perl-core/Test-Harness-3.17 b/metadata/md5-cache/perl-core/Test-Harness-3.17
index 2be75d6..3976e6d 100644
--- a/metadata/md5-cache/perl-core/Test-Harness-3.17
+++ b/metadata/md5-cache/perl-core/Test-Harness-3.17
@@ -2,10 +2,10 @@
 DEPEND=dev-lang/perl
 DESCRIPTION=Runs perl standard test scripts with statistics
 HOMEPAGE=http://search.cpan.org/dist/Test-Harness/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/A/AN/ANDYA/Test-Harness-3.17.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e3631d187c83c2cdf5e613d190aa4c8f
+_md5_=e4c1b3c0e5bae20eaf5f4decf79cfe91
diff --git a/metadata/md5-cache/perl-core/Test-Simple-0.980.0 b/metadata/md5-cache/perl-core/Test-Simple-0.980.0
index 36063ec..6a88569 100644
--- a/metadata/md5-cache/perl-core/Test-Simple-0.980.0
+++ b/metadata/md5-cache/perl-core/Test-Simple-0.980.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Basic utilities for writing tests
 EAPI=3
 HOMEPAGE=http://search.cpan.org/dist/Test-Simple/
-KEYWORDS=~alpha amd64 ~arm ~hppa ~ia64 ~m68k ~mips ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/M/MS/MSCHWERN/Test-Simple-0.98.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8fa9fd600d261316451b870ee0d8c247
+_md5_=cd66c241e5ec9ad74950df51b8c736cc
diff --git a/metadata/md5-cache/perl-core/digest-base-1.160.0 b/metadata/md5-cache/perl-core/digest-base-1.160.0
index 7e669ae..defac4a 100644
--- a/metadata/md5-cache/perl-core/digest-base-1.160.0
+++ b/metadata/md5-cache/perl-core/digest-base-1.160.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Modules that calculate message digests
 EAPI=2
 HOMEPAGE=http://search.cpan.org/dist/Digest/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 RDEPEND=virtual/perl-MIME-Base64 dev-lang/perl[-build]
 SLOT=0
 SRC_URI=mirror://cpan/authors/id/G/GA/GAAS/Digest-1.16.tar.gz
 _eclasses_=alternatives	eb864f6e50a20036e4cd47c8fd8f64d1	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	perl-module	62eaf4b4e2dfe2d7766c20bfd93e7199	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=6e251cec58c10651fca5664c456a50d8
+_md5_=ac426ffa7bfa0b6005b57468e1c74164
diff --git a/metadata/md5-cache/sci-libs/fftw-3.2.2 b/metadata/md5-cache/sci-libs/fftw-3.2.2
index 7723323..f88c8ed 100644
--- a/metadata/md5-cache/sci-libs/fftw-3.2.2
+++ b/metadata/md5-cache/sci-libs/fftw-3.2.2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.fftw.org/
 IUSE=altivec doc fortran openmp sse sse2 threads
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 LICENSE=GPL-2
 RDEPEND=fortran? ( virtual/fortran )
 SLOT=3.0
 SRC_URI=http://www.fftw.org/fftw-3.2.2.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	fortran-2	19652e219ec9b62d7d89735821d7afb6	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d9885b46ebffda1fda5d79ce22fe6608
+_md5_=b3f6310ba5db0a3fa5ea9e5eb56f3b6e
diff --git a/metadata/md5-cache/sys-apps/acl-2.2.51 b/metadata/md5-cache/sys-apps/acl-2.2.51
index 2644042..1d41e04 100644
--- a/metadata/md5-cache/sys-apps/acl-2.2.51
+++ b/metadata/md5-cache/sys-apps/acl-2.2.51
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://savannah.nongnu.org/projects/acl
 IUSE=nfs nls static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ~ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=LGPL-2.1
 RDEPEND=>=sys-apps/attr-2.4 nfs? ( net-libs/libnfsidmap )
 SLOT=0
 SRC_URI=http://download.savannah.gnu.org/releases/acl/acl-2.2.51.src.tar.gz nfs? ( http://www.citi.umich.edu/projects/nfsv4/linux/acl-patches/2.2.42-2/acl-2.2.42-CITI_NFS4_ALL-2.dif )
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=72d30e1108922869f65cb2ffcd89ef2a
+_md5_=b6879f3a5bef98ebef5a6078abf31267
diff --git a/metadata/md5-cache/sys-apps/attr-2.4.46 b/metadata/md5-cache/sys-apps/attr-2.4.46
index a4bcc84..fdef13c 100644
--- a/metadata/md5-cache/sys-apps/attr-2.4.46
+++ b/metadata/md5-cache/sys-apps/attr-2.4.46
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://savannah.nongnu.org/projects/attr
 IUSE=nls static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ~ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=LGPL-2.1
 SLOT=0
 SRC_URI=mirror://nongnu/attr/attr-2.4.46.src.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=70e4098d790defd26a8e51cc5ae4f3fe
+_md5_=0e4e9e587df624e5dc8fa9ae4a7d5933
diff --git a/metadata/md5-cache/sys-apps/busybox-1.20.1 b/metadata/md5-cache/sys-apps/busybox-1.20.1
index 36dec25..876db69 100644
--- a/metadata/md5-cache/sys-apps/busybox-1.20.1
+++ b/metadata/md5-cache/sys-apps/busybox-1.20.1
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://www.busybox.net/
 IUSE=ipv6 livecd make-symlinks math mdev -pam selinux sep-usr static savedconfig
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=selinux? ( sys-libs/libselinux ) pam? ( sys-libs/pam )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://www.busybox.net/downloads/busybox-1.20.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	portability	536c5e70c5fb252ed3b769e04aa3f05b	savedconfig	973a6df1a0949eba28a185eac79de815	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=eb89ec4fec07401435dfa5cb7b5a60ca
+_md5_=f2f6e81148285256cd3d69c9ea25e7cb
diff --git a/metadata/md5-cache/sys-apps/coreutils-8.20-r1 b/metadata/md5-cache/sys-apps/coreutils-8.20-r1
index 967f46f..3106166 100644
--- a/metadata/md5-cache/sys-apps/coreutils-8.20-r1
+++ b/metadata/md5-cache/sys-apps/coreutils-8.20-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/coreutils/
 IUSE=acl caps gmp nls selinux static userland_BSD vanilla xattr
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd
 LICENSE=GPL-3
 RDEPEND=!static? ( acl? ( sys-apps/acl ) caps? ( sys-libs/libcap ) gmp? ( dev-libs/gmp ) xattr? ( !userland_BSD? ( sys-apps/attr ) ) ) selinux? ( sys-libs/libselinux ) nls? ( >=sys-devel/gettext-0.15 ) !app-misc/realpath !<sys-apps/util-linux-2.13 !sys-apps/stat !net-mail/base64 !sys-apps/mktemp !<app-forensics/tct-1.18-r1 !<net-fs/netatalk-2.0.3-r4 !<sci-chemistry/ccp4-6.1.1
 SLOT=0
 SRC_URI=mirror://gnu-alpha/coreutils/coreutils-8.20.tar.xz mirror://gnu/coreutils/coreutils-8.20.tar.xz mirror://gentoo/coreutils-8.20.tar.xz mirror://gentoo/coreutils-8.20-patches-1.2.tar.xz http://dev.gentoo.org/~ryao/dist/coreutils-8.20-patches-1.2.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=a3a2cff83ab096cad7b658c9bb321931
+_md5_=550e360ff7ec085c5e74bd367dfd3cf7
diff --git a/metadata/md5-cache/sys-apps/debianutils-3.4.4 b/metadata/md5-cache/sys-apps/debianutils-3.4.4
index fb7871e..4a7b563 100644
--- a/metadata/md5-cache/sys-apps/debianutils-3.4.4
+++ b/metadata/md5-cache/sys-apps/debianutils-3.4.4
@@ -2,10 +2,10 @@
 DESCRIPTION=A selection of tools from Debian
 HOMEPAGE=http://packages.qa.debian.org/d/debianutils.html
 IUSE=kernel_linux static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=BSD GPL-2 SMAIL
 PDEPEND=|| ( >=sys-apps/coreutils-6.10-r1 sys-apps/mktemp sys-freebsd/freebsd-ubin )
 SLOT=0
 SRC_URI=mirror://debian/pool/main/d/debianutils/debianutils_3.4.4.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9aa97274817e7d5923344881c3041db3
+_md5_=28b949a1d4412bb3eb02149faf11f933
diff --git a/metadata/md5-cache/sys-apps/diffutils-3.2 b/metadata/md5-cache/sys-apps/diffutils-3.2
index b55574e..5f1c113 100644
--- a/metadata/md5-cache/sys-apps/diffutils-3.2
+++ b/metadata/md5-cache/sys-apps/diffutils-3.2
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://www.gnu.org/software/diffutils/
 IUSE=nls static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gnu-alpha/diffutils/diffutils-3.2.tar.gz mirror://gnu/diffutils/diffutils-3.2.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b4b0d8102ccd3e61664db0f81011c65a
+_md5_=1a1787a46049dc0c57ca77c11a427aed
diff --git a/metadata/md5-cache/sys-apps/eject-2.1.5-r2 b/metadata/md5-cache/sys-apps/eject-2.1.5-r2
index 4fdcb88..0c3b535 100644
--- a/metadata/md5-cache/sys-apps/eject-2.1.5-r2
+++ b/metadata/md5-cache/sys-apps/eject-2.1.5-r2
@@ -2,9 +2,9 @@
 DESCRIPTION=A command to eject a disc from the CD-ROM drive
 HOMEPAGE=http://eject.sourceforge.net/
 IUSE=nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/eject-2.1.5.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=0dbf103c64901aa9334cf18de6b6aa60
+_md5_=de980ca4e83e9111ffc375a3fdc5c631
diff --git a/metadata/md5-cache/sys-apps/file-5.09 b/metadata/md5-cache/sys-apps/file-5.09
index 984e1ce..7f11b40 100644
--- a/metadata/md5-cache/sys-apps/file-5.09
+++ b/metadata/md5-cache/sys-apps/file-5.09
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=ftp://ftp.astron.com/pub/file/
 IUSE=python static-libs zlib
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=BSD-2
 RDEPEND=zlib? ( sys-libs/zlib ) >=app-admin/eselect-python-20091230 python? ( dev-lang/python )
 SLOT=0
 SRC_URI=ftp://ftp.astron.com/pub/file/file-5.09.tar.gz ftp://ftp.gw.com/mirrors/pub/unix/file/file-5.09.tar.gz
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ca8ca4fbd5c712ff566af42938af5857
+_md5_=04e46678c91b94687491418c26730721
diff --git a/metadata/md5-cache/sys-apps/findutils-4.4.2-r1 b/metadata/md5-cache/sys-apps/findutils-4.4.2-r1
index ecaca03..d7c418f 100644
--- a/metadata/md5-cache/sys-apps/findutils-4.4.2-r1
+++ b/metadata/md5-cache/sys-apps/findutils-4.4.2-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=GNU utilities for finding files
 HOMEPAGE=http://www.gnu.org/software/findutils/
 IUSE=nls selinux static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 RDEPEND=selinux? ( sys-libs/libselinux ) nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://gnu-alpha/findutils/findutils-4.4.2.tar.gz mirror://gnu/findutils/findutils-4.4.2.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=4512e0c1929b2f55a210597633f8e8e8
+_md5_=16ad9861625436eb1571a8e9c4b7080f
diff --git a/metadata/md5-cache/sys-apps/gawk-3.1.8 b/metadata/md5-cache/sys-apps/gawk-3.1.8
index 1295302..df4f48d 100644
--- a/metadata/md5-cache/sys-apps/gawk-3.1.8
+++ b/metadata/md5-cache/sys-apps/gawk-3.1.8
@@ -4,9 +4,9 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/gawk/gawk.html
 IUSE=nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gnu/gawk/gawk-3.1.8.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=106ce824db99d18279a2bf3d829f0672
+_md5_=f642d02668caaa9098df945609090dbc
diff --git a/metadata/md5-cache/sys-apps/grep-2.14 b/metadata/md5-cache/sys-apps/grep-2.14
index a6dfebb..4db7da1 100644
--- a/metadata/md5-cache/sys-apps/grep-2.14
+++ b/metadata/md5-cache/sys-apps/grep-2.14
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/grep/
 IUSE=nls pcre
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-3
 RDEPEND=nls? ( virtual/libintl ) pcre? ( >=dev-libs/libpcre-7.8-r1 ) virtual/libiconv
 SLOT=0
 SRC_URI=mirror://gnu/grep/grep-2.14.tar.xz mirror://gentoo/grep-2.14.tar.xz
-_md5_=0163cd290605529b5748f9cc74fbc971
+_md5_=ab29fc343586d8df418a89f5ef2675c8
diff --git a/metadata/md5-cache/sys-apps/groff-1.20.1-r3 b/metadata/md5-cache/sys-apps/groff-1.20.1-r3
index 6482ba7..355bf03 100644
--- a/metadata/md5-cache/sys-apps/groff-1.20.1-r3
+++ b/metadata/md5-cache/sys-apps/groff-1.20.1-r3
@@ -3,10 +3,10 @@
 DESCRIPTION=Text formatter used for man pages
 HOMEPAGE=http://www.gnu.org/software/groff/groff.html
 IUSE=examples X linguas_ja
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=>=sys-apps/texinfo-4.7-r1 X? ( x11-libs/libX11 x11-libs/libXt x11-libs/libXmu x11-libs/libXaw x11-libs/libSM x11-libs/libICE )
 SLOT=0
 SRC_URI=mirror://gnu/groff/groff-1.20.1.tar.gz linguas_ja? ( mirror://gentoo/groff-1.20.1-r2-japanese.patch.bz2 )
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=55cc97364be03bc18fb25de84317c2fa
+_md5_=58694b1caa0c9709f3a44d0d1d9e6173
diff --git a/metadata/md5-cache/sys-apps/hdparm-9.39 b/metadata/md5-cache/sys-apps/hdparm-9.39
index 182d42e..ccd0524 100644
--- a/metadata/md5-cache/sys-apps/hdparm-9.39
+++ b/metadata/md5-cache/sys-apps/hdparm-9.39
@@ -2,9 +2,9 @@
 DESCRIPTION=Utility to change hard drive performance parameters
 EAPI=4
 HOMEPAGE=http://sourceforge.net/projects/hdparm/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=BSD GPL-2
 SLOT=0
 SRC_URI=mirror://sourceforge/hdparm/hdparm-9.39.tar.gz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=f48ef3c979afa97a12492b5dc6f793cc
+_md5_=ff00bd62fe9e5b7f79de2804a388a34e
diff --git a/metadata/md5-cache/sys-apps/help2man-1.36.4-r1 b/metadata/md5-cache/sys-apps/help2man-1.36.4-r1
index cf63fbe..da90fcc 100644
--- a/metadata/md5-cache/sys-apps/help2man-1.36.4-r1
+++ b/metadata/md5-cache/sys-apps/help2man-1.36.4-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=GNU utility to convert program --help output to a man page
 HOMEPAGE=http://www.gnu.org/software/help2man
 IUSE=nls elibc_glibc
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=dev-lang/perl
 SLOT=0
 SRC_URI=mirror://gnu/help2man/help2man-1.36.4.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d1e79f3f53d263ac859f03a83cc436eb
+_md5_=799cce07dadd4ccf228b64562eee1ebb
diff --git a/metadata/md5-cache/sys-apps/hwids-20120922 b/metadata/md5-cache/sys-apps/hwids-20120922
index ad855d1..a035057 100644
--- a/metadata/md5-cache/sys-apps/hwids-20120922
+++ b/metadata/md5-cache/sys-apps/hwids-20120922
@@ -2,9 +2,9 @@
 DESCRIPTION=Hardware (PCI, USB) IDs databases
 EAPI=4
 HOMEPAGE=https://github.com/gentoo/hwids
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=|| ( GPL-2 BSD )
 RDEPEND=!<sys-apps/pciutils-3.1.9-r2 !<sys-apps/usbutils-005-r1
 SLOT=0
 SRC_URI=https://github.com/gentoo/hwids/tarball/hwids-20120922 -> hwids-20120922.tar.gz
-_md5_=d231d5daab95187158aeea69e57a48fc
+_md5_=20372fd730f89c04da42343b132ecb31
diff --git a/metadata/md5-cache/sys-apps/i2c-tools-3.0.2 b/metadata/md5-cache/sys-apps/i2c-tools-3.0.2
index 993030e..96fa6c6 100644
--- a/metadata/md5-cache/sys-apps/i2c-tools-3.0.2
+++ b/metadata/md5-cache/sys-apps/i2c-tools-3.0.2
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.lm-sensors.org/wiki/I2CTools
 IUSE=python
-KEYWORDS=amd64 ~arm ~sparc x86
+KEYWORDS=amd64 ~arm sparc x86
 LICENSE=GPL-2
 RDEPEND=!<sys-apps/lm_sensors-3 >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* )
 SLOT=0
 SRC_URI=http://dl.lm-sensors.org/i2c-tools/releases/i2c-tools-3.0.2.tar.bz2
 _eclasses_=distutils	b4c334e216d998c4ce4b750cb091e42e	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d70a221205ede91577f97b3bca868177
+_md5_=8cf95b9778a9588e6dd7b81a9777cd89
diff --git a/metadata/md5-cache/sys-apps/iproute2-2.6.38 b/metadata/md5-cache/sys-apps/iproute2-2.6.38
index 9289fb2..ef5e743 100644
--- a/metadata/md5-cache/sys-apps/iproute2-2.6.38
+++ b/metadata/md5-cache/sys-apps/iproute2-2.6.38
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.linuxfoundation.org/collaborate/workgroups/networking/iproute2
 IUSE=atm berkdb minimal
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 RDEPEND=!net-misc/arpd !minimal? ( berkdb? ( sys-libs/db ) ) atm? ( net-dialup/linux-atm )
 SLOT=0
 SRC_URI=mirror://kernel/linux/utils/net/iproute2/iproute2-2.6.38.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=637c8a0731881e114b434666dd87ec65
+_md5_=f4e9865354d50f55c26bc3c8b9c3bce9
diff --git a/metadata/md5-cache/sys-apps/kbd-1.15.3 b/metadata/md5-cache/sys-apps/kbd-1.15.3
index 9937c2a..ddaf09d 100644
--- a/metadata/md5-cache/sys-apps/kbd-1.15.3
+++ b/metadata/md5-cache/sys-apps/kbd-1.15.3
@@ -3,8 +3,8 @@
 DESCRIPTION=Keyboard and console utilities
 HOMEPAGE=http://freshmeat.net/projects/kbd/
 IUSE=nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=ftp://ftp.altlinux.org/pub/people/legion/kbd/kbd-1.15.3.tar.gz
-_md5_=22e42dab8a55aaf5b20735ec71ae95cc
+_md5_=bb5445675632123ec76ce637d3faa36a
diff --git a/metadata/md5-cache/sys-apps/less-441 b/metadata/md5-cache/sys-apps/less-441
index 831847f..033b900 100644
--- a/metadata/md5-cache/sys-apps/less-441
+++ b/metadata/md5-cache/sys-apps/less-441
@@ -3,10 +3,10 @@
 DESCRIPTION=Excellent text file viewer
 HOMEPAGE=http://www.greenwoodsoftware.com/less/
 IUSE=unicode
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=|| ( GPL-3 BSD-2 )
 RDEPEND=>=sys-libs/ncurses-5.2
 SLOT=0
 SRC_URI=http://www.greenwoodsoftware.com/less/less-441.tar.gz http://www-zeuthen.desy.de/~friebel/unix/less/code2color
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=3d93384e6ba86910ec71dcb657a344ff
+_md5_=530a8fbedf858a605494eddc9718675a
diff --git a/metadata/md5-cache/sys-apps/man-1.6f-r4 b/metadata/md5-cache/sys-apps/man-1.6f-r4
index 5401bbd..0962097 100644
--- a/metadata/md5-cache/sys-apps/man-1.6f-r4
+++ b/metadata/md5-cache/sys-apps/man-1.6f-r4
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://primates.ximian.com/~flucifredi/man/
 IUSE=lzma nls
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=|| ( >=sys-apps/groff-1.19.2-r1 app-doc/heirloom-doctools ) !sys-apps/man-db !app-arch/lzma lzma? ( app-arch/xz-utils )
 SLOT=0
 SRC_URI=http://primates.ximian.com/~flucifredi/man/man-1.6f.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=3addd652b3d55a57260aa0818f18c7fe
+_md5_=c0ce11d95026e11e7c63e18bb1b2dd43
diff --git a/metadata/md5-cache/sys-apps/man-pages-3.32 b/metadata/md5-cache/sys-apps/man-pages-3.32
index e824f24..1888d86 100644
--- a/metadata/md5-cache/sys-apps/man-pages-3.32
+++ b/metadata/md5-cache/sys-apps/man-pages-3.32
@@ -3,11 +3,11 @@
 EAPI=3
 HOMEPAGE=http://www.kernel.org/doc/man-pages/
 IUSE=nls linguas_cs linguas_da linguas_de linguas_fr linguas_it linguas_ja linguas_nl linguas_pl linguas_ro linguas_ru linguas_zh_CN
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ~ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=as-is GPL-2 BSD
 PDEPEND=nls? ( linguas_cs? ( app-i18n/man-pages-cs ) linguas_da? ( app-i18n/man-pages-da ) linguas_de? ( app-i18n/man-pages-de ) linguas_fr? ( app-i18n/man-pages-fr ) linguas_it? ( app-i18n/man-pages-it ) linguas_ja? ( app-i18n/man-pages-ja ) linguas_nl? ( app-i18n/man-pages-nl ) linguas_pl? ( app-i18n/man-pages-pl ) linguas_ro? ( app-i18n/man-pages-ro ) linguas_ru? ( app-i18n/man-pages-ru ) linguas_zh_CN? ( app-i18n/man-pages-zh_CN ) ) sys-apps/man-pages-posix
 RDEPEND=virtual/man !<dev-libs/libaio-0.3.109-r2
 RESTRICT=binchecks
 SLOT=0
 SRC_URI=mirror://kernel/linux/docs/manpages/Archive/man-pages-3.32.tar.bz2 mirror://gentoo/man-pages-gentoo-2.tar.bz2 http://dev.gentoo.org/~cardoe/files/man-pages-gentoo-2.tar.bz2
-_md5_=89e42437dcfc2e670b71c4c5b4217c54
+_md5_=06a1c06204ef480d47bbf69ea2e475c9
diff --git a/metadata/md5-cache/sys-apps/man-pages-posix-2003a b/metadata/md5-cache/sys-apps/man-pages-posix-2003a
index ff3c23a..911d192 100644
--- a/metadata/md5-cache/sys-apps/man-pages-posix-2003a
+++ b/metadata/md5-cache/sys-apps/man-pages-posix-2003a
@@ -1,11 +1,11 @@
 DEFINED_PHASES=compile install unpack
 DESCRIPTION=POSIX man-pages (0p, 1p, 3p)
 HOMEPAGE=http://www.kernel.org/doc/man-pages/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=man-pages-posix
 RDEPEND=virtual/man !<sys-apps/man-pages-3
 RESTRICT=binchecks
 SLOT=0
 SRC_URI=mirror://kernel/linux/docs/man-pages/man-pages-posix/man-pages-posix-2003-a.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=3da72bbca88a1a5e6f10f8a37f9ff506
+_md5_=137924e8b9016bbcca7c23aa7338653c
diff --git a/metadata/md5-cache/sys-apps/mawk-1.3.4_p20100625 b/metadata/md5-cache/sys-apps/mawk-1.3.4_p20100625
index 8a3d121..01d240b 100644
--- a/metadata/md5-cache/sys-apps/mawk-1.3.4_p20100625
+++ b/metadata/md5-cache/sys-apps/mawk-1.3.4_p20100625
@@ -2,9 +2,9 @@
 DESCRIPTION=an (often faster than gawk) awk-interpreter
 EAPI=2
 HOMEPAGE=http://invisible-island.net/mawk/mawk.html
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~ppc ~sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 ppc sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~x86-macos
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=ftp://invisible-island.net/mawk/mawk-1.3.4-20100625.tgz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ba8d97f02b825132b2876a3dbcb3c750
+_md5_=119e9a050985d6c92bf8aeae6d8652cd
diff --git a/metadata/md5-cache/sys-apps/memtester-4.2.2 b/metadata/md5-cache/sys-apps/memtester-4.2.2
index 8b7300d..d964db5 100644
--- a/metadata/md5-cache/sys-apps/memtester-4.2.2
+++ b/metadata/md5-cache/sys-apps/memtester-4.2.2
@@ -2,9 +2,9 @@
 DESCRIPTION=userspace utility for testing the memory subsystem for faults
 EAPI=4
 HOMEPAGE=http://pyropus.ca/software/memtester/
-KEYWORDS=amd64 arm ~ia64 ~mips ppc ppc64 sparc x86
+KEYWORDS=amd64 arm ia64 mips ppc ppc64 sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://pyropus.ca/software/memtester/memtester-4.2.2.tar.gz http://pyropus.ca/software/memtester/old-versions/memtester-4.2.2.tar.gz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=932f9e07d08d4a570d7313d03d08f777
+_md5_=d292891e9dd315fa12523ffc777bc846
diff --git a/metadata/md5-cache/sys-apps/miscfiles-1.4.2-r1 b/metadata/md5-cache/sys-apps/miscfiles-1.4.2-r1
index 0d74c8a..44e0aa0 100644
--- a/metadata/md5-cache/sys-apps/miscfiles-1.4.2-r1
+++ b/metadata/md5-cache/sys-apps/miscfiles-1.4.2-r1
@@ -2,10 +2,10 @@
 DESCRIPTION=Miscellaneous files
 HOMEPAGE=http://www.gnu.org/directory/miscfiles.html
 IUSE=minimal
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2 unicode
 RDEPEND=!<sys-freebsd/freebsd-share-7.2-r1
 SLOT=0
 SRC_URI=mirror://gnu/miscfiles/miscfiles-1.4.2.tar.gz mirror://gentoo/UnicodeData-5.2.0.txt.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ae16fad28eb935780fbca8ed7a0c8247
+_md5_=fe5ca5d9283c1dcf042dd423cf62d5ec
diff --git a/metadata/md5-cache/sys-apps/module-init-tools-3.16-r1 b/metadata/md5-cache/sys-apps/module-init-tools-3.16-r1
index 293dfa5..55db4c5 100644
--- a/metadata/md5-cache/sys-apps/module-init-tools-3.16-r1
+++ b/metadata/md5-cache/sys-apps/module-init-tools-3.16-r1
@@ -3,11 +3,11 @@
 DESCRIPTION=tools for managing linux kernel modules
 HOMEPAGE=http://modules.wiki.kernel.org/
 IUSE=static
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 RDEPEND=sys-libs/zlib !<sys-apps/baselayout-2.0.1 !sys-apps/modutils
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://kernel/linux/utils/kernel/module-init-tools/module-init-tools-3.16.tar.bz2 mirror://gentoo/module-init-tools-3.16-man.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=7dc33caf8cb9736052242f01c5af689a
+_md5_=57e27f592ea615cbef654ad7bc08ebeb
diff --git a/metadata/md5-cache/sys-apps/net-tools-1.60_p20110409135728 b/metadata/md5-cache/sys-apps/net-tools-1.60_p20110409135728
index 8047cdf..febaf9c 100644
--- a/metadata/md5-cache/sys-apps/net-tools-1.60_p20110409135728
+++ b/metadata/md5-cache/sys-apps/net-tools-1.60_p20110409135728
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://net-tools.berlios.de/
 IUSE=nls static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-linux
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/net-tools-1.60_p20110409135728.tar.xz mirror://gentoo/net-tools-1.60_p20110409135728-patches-1.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=0ca8b178e794b6e75b371ab684159265
+_md5_=d44eda76ef938ca2d05453daf55cd1df
diff --git a/metadata/md5-cache/sys-apps/pciutils-3.1.10 b/metadata/md5-cache/sys-apps/pciutils-3.1.10
index 4487181..c33b9bf 100644
--- a/metadata/md5-cache/sys-apps/pciutils-3.1.10
+++ b/metadata/md5-cache/sys-apps/pciutils-3.1.10
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://mj.ucw.cz/sw/pciutils/ http://git.kernel.org/?p=utils/pciutils/pciutils.git
 IUSE=static-libs zlib
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=static-libs? ( zlib? ( sys-libs/zlib[static-libs(+)] ) ) !static-libs? ( zlib? ( sys-libs/zlib ) ) sys-apps/hwids
 SLOT=0
 SRC_URI=ftp://atrey.karlin.mff.cuni.cz/pub/linux/pci/pciutils-3.1.10.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=38a1de6c4ad9d220aa75e187cf7b9fa0
+_md5_=799979f94a26002e1ab21a74a6c09741
diff --git a/metadata/md5-cache/sys-apps/pv-1.3.4 b/metadata/md5-cache/sys-apps/pv-1.3.4
index a9e1cad..1c00211 100644
--- a/metadata/md5-cache/sys-apps/pv-1.3.4
+++ b/metadata/md5-cache/sys-apps/pv-1.3.4
@@ -3,9 +3,9 @@
 EAPI=4
 HOMEPAGE=http://www.ivarch.com/programs/pv.shtml
 IUSE=nls linguas_de linguas_fr linguas_pl linguas_pt
-KEYWORDS=alpha amd64 arm hppa ~mips ppc ppc64 sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa mips ppc ppc64 sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc64-solaris ~x86-solaris
 LICENSE=Artistic-2
 SLOT=0
 SRC_URI=http://www.ivarch.com/programs/sources/pv-1.3.4.tar.gz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=932531f37a678aff44499ce78e19fa4e
+_md5_=e168c08fce801bea5ac70eda8e813fd3
diff --git a/metadata/md5-cache/sys-apps/sed-4.2.1-r1 b/metadata/md5-cache/sys-apps/sed-4.2.1-r1
index 9c326a8..b103955 100644
--- a/metadata/md5-cache/sys-apps/sed-4.2.1-r1
+++ b/metadata/md5-cache/sys-apps/sed-4.2.1-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=Super-useful stream editor
 HOMEPAGE=http://sed.sourceforge.net/
 IUSE=acl nls selinux static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=acl? ( virtual/acl ) nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://gnu/sed/sed-4.2.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=fdaf151e6272cb4d81e4a56ea0ec50dc
+_md5_=a7e869bb8704b1440ca78707617139b0
diff --git a/metadata/md5-cache/sys-apps/smartmontools-5.42 b/metadata/md5-cache/sys-apps/smartmontools-5.42
index 1e55f15..aebe685 100644
--- a/metadata/md5-cache/sys-apps/smartmontools-5.42
+++ b/metadata/md5-cache/sys-apps/smartmontools-5.42
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://smartmontools.sourceforge.net/
 IUSE=static minimal caps
-KEYWORDS=alpha amd64 arm hppa ia64 ppc ~ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~x64-macos
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~x64-macos
 LICENSE=GPL-2
 RDEPEND=!minimal? ( caps? ( sys-libs/libcap-ng ) ) !minimal? ( virtual/mailx )
 SLOT=0
 SRC_URI=mirror://sourceforge/smartmontools/smartmontools-5.42.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=1a1d55452f2347c803703f16b334a6fa
+_md5_=953a56353670fc183b1261788b775aed
diff --git a/metadata/md5-cache/sys-apps/texinfo-4.13 b/metadata/md5-cache/sys-apps/texinfo-4.13
index 4968c59..6901000 100644
--- a/metadata/md5-cache/sys-apps/texinfo-4.13
+++ b/metadata/md5-cache/sys-apps/texinfo-4.13
@@ -3,10 +3,10 @@
 DESCRIPTION=The GNU info program and utilities
 HOMEPAGE=http://www.gnu.org/software/texinfo/
 IUSE=nls static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~sparc-fbsd x86 ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=!=app-text/tetex-2* >=sys-libs/ncurses-5.2-r2 nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://gnu/texinfo/texinfo-4.13.tar.lzma
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d2428005fedac86d74f00de5dfbe9aa7
+_md5_=67c7e0e5ae1d7476f44b01215349940a
diff --git a/metadata/md5-cache/sys-apps/usbutils-006 b/metadata/md5-cache/sys-apps/usbutils-006
index b9934d1..f540743 100644
--- a/metadata/md5-cache/sys-apps/usbutils-006
+++ b/metadata/md5-cache/sys-apps/usbutils-006
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://linux-usb.sourceforge.net/
 IUSE=python zlib
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=virtual/libusb:1 zlib? ( sys-libs/zlib ) sys-apps/hwids >=app-admin/eselect-python-20091230 python? ( || ( =dev-lang/python-2.7* =dev-lang/python-2.6* ) )
 SLOT=0
 SRC_URI=mirror://kernel/linux/utils/usb/usbutils/usbutils-006.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8fbc1a48b18c7ba30e88057a8be3cd61
+_md5_=0fabe1d1a040a963eea4448da371a89a
diff --git a/metadata/md5-cache/sys-apps/util-linux-2.21.2 b/metadata/md5-cache/sys-apps/util-linux-2.21.2
index 9a4de9c..df4443b 100644
--- a/metadata/md5-cache/sys-apps/util-linux-2.21.2
+++ b/metadata/md5-cache/sys-apps/util-linux-2.21.2
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.kernel.org/pub/linux/utils/util-linux/
 IUSE=+cramfs crypt ddate ncurses nls old-linux perl selinux slang static-libs +suid uclibc udev unicode
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=GPL-2 GPL-3 LGPL-2.1 BSD-4 MIT public-domain
 RDEPEND=!sys-process/schedutils !sys-apps/setarch !<sys-apps/sysvinit-2.88-r3 !<sys-libs/e2fsprogs-libs-1.41.8 !<sys-fs/e2fsprogs-1.41.8 cramfs? ( sys-libs/zlib ) ncurses? ( >=sys-libs/ncurses-5.2-r2 ) perl? ( dev-lang/perl ) selinux? ( sys-libs/libselinux ) slang? ( sys-libs/slang ) udev? ( virtual/udev )
 SLOT=0
 SRC_URI=mirror://kernel/linux/utils/util-linux/v2.21/util-linux-2.21.2.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=cdc6318773c110e3928e6255ef7a61ed
+_md5_=9e276d19e7cdec3bfc3a84af0800c103
diff --git a/metadata/md5-cache/sys-apps/util-linux-2.21.2-r1 b/metadata/md5-cache/sys-apps/util-linux-2.21.2-r1
index 9a4de9c..df4443b 100644
--- a/metadata/md5-cache/sys-apps/util-linux-2.21.2-r1
+++ b/metadata/md5-cache/sys-apps/util-linux-2.21.2-r1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.kernel.org/pub/linux/utils/util-linux/
 IUSE=+cramfs crypt ddate ncurses nls old-linux perl selinux slang static-libs +suid uclibc udev unicode
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=GPL-2 GPL-3 LGPL-2.1 BSD-4 MIT public-domain
 RDEPEND=!sys-process/schedutils !sys-apps/setarch !<sys-apps/sysvinit-2.88-r3 !<sys-libs/e2fsprogs-libs-1.41.8 !<sys-fs/e2fsprogs-1.41.8 cramfs? ( sys-libs/zlib ) ncurses? ( >=sys-libs/ncurses-5.2-r2 ) perl? ( dev-lang/perl ) selinux? ( sys-libs/libselinux ) slang? ( sys-libs/slang ) udev? ( virtual/udev )
 SLOT=0
 SRC_URI=mirror://kernel/linux/utils/util-linux/v2.21/util-linux-2.21.2.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=cdc6318773c110e3928e6255ef7a61ed
+_md5_=9e276d19e7cdec3bfc3a84af0800c103
diff --git a/metadata/md5-cache/sys-apps/which-2.20 b/metadata/md5-cache/sys-apps/which-2.20
index 1c63eba..49b8b6e 100644
--- a/metadata/md5-cache/sys-apps/which-2.20
+++ b/metadata/md5-cache/sys-apps/which-2.20
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=Prints out location of specified executables that are in your path
 HOMEPAGE=http://www.xs4all.nl/~carlo17/which/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-3
 SLOT=0
 SRC_URI=http://www.xs4all.nl/~carlo17/which/which-2.20.tar.gz
-_md5_=209cc3d20358033a513d958202b1f548
+_md5_=54effa2f812ca8f032676ebbb2a5a1d5
diff --git a/metadata/md5-cache/sys-auth/consolekit-0.4.5 b/metadata/md5-cache/sys-auth/consolekit-0.4.5
index 10fbc6c..9cea5e9 100644
--- a/metadata/md5-cache/sys-auth/consolekit-0.4.5
+++ b/metadata/md5-cache/sys-auth/consolekit-0.4.5
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.freedesktop.org/wiki/Software/ConsoleKit
 IUSE=debug doc kernel_linux pam policykit test
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~sh ~sparc ~x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 ppc ppc64 sh sparc ~x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=>=dev-libs/dbus-glib-0.88 >=dev-libs/glib-2.20:2 sys-libs/zlib x11-libs/libX11 pam? ( virtual/pam ) policykit? ( >=sys-auth/polkit-0.101-r1 )
 SLOT=0
 SRC_URI=http://www.freedesktop.org/software/ConsoleKit/dist/ConsoleKit-0.4.5.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	pam	3f746974e1cc47cabe3bd488c08cdc8e	systemd	b5da52630b2559da43198bfb56ccacba	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=7a4f082e3a9db77fea6abd6c709b1020
+_md5_=d1b55a023178361c6d749886c27427c5
diff --git a/metadata/md5-cache/sys-block/parted-3.1 b/metadata/md5-cache/sys-block/parted-3.1
index 383c996..53e9081 100644
--- a/metadata/md5-cache/sys-block/parted-3.1
+++ b/metadata/md5-cache/sys-block/parted-3.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/parted
 IUSE=+debug device-mapper nls readline selinux static-libs test
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-3
 RDEPEND=>=sys-fs/e2fsprogs-1.27 >=sys-libs/ncurses-5.2 nls? ( >=sys-devel/gettext-0.12.1-r2 ) readline? ( >=sys-libs/readline-5.2 ) selinux? ( sys-libs/libselinux ) device-mapper? ( || ( >=sys-fs/lvm2-2.02.45 sys-fs/device-mapper ) )
 SLOT=0
 SRC_URI=mirror://gnu/parted/parted-3.1.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8811155e34f743f03bc703b0b6015ea0
+_md5_=e271b868405ba997c9d2b64381acd69b
diff --git a/metadata/md5-cache/sys-devel/autoconf-2.13 b/metadata/md5-cache/sys-devel/autoconf-2.13
index 7737106..b856122 100644
--- a/metadata/md5-cache/sys-devel/autoconf-2.13
+++ b/metadata/md5-cache/sys-devel/autoconf-2.13
@@ -2,10 +2,10 @@
 DEPEND=>=sys-apps/texinfo-4.3 sys-devel/autoconf-wrapper =sys-devel/m4-1.4* dev-lang/perl
 DESCRIPTION=Used to create autoconfiguration files
 HOMEPAGE=http://www.gnu.org/software/autoconf/autoconf.html
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=>=sys-apps/texinfo-4.3 sys-devel/autoconf-wrapper =sys-devel/m4-1.4* dev-lang/perl
 SLOT=2.1
 SRC_URI=mirror://gnu/autoconf/autoconf-2.13.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=e40f9d8db5da3b7ed02efbdc83149456
+_md5_=4bf2f9bb9a8e7e54d442b00f9ffe0163
diff --git a/metadata/md5-cache/sys-devel/autoconf-2.68 b/metadata/md5-cache/sys-devel/autoconf-2.68
index 943a12d..a6bf2ec 100644
--- a/metadata/md5-cache/sys-devel/autoconf-2.68
+++ b/metadata/md5-cache/sys-devel/autoconf-2.68
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/autoconf/autoconf.html
 IUSE=emacs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 PDEPEND=emacs? ( app-emacs/autoconf-mode )
 RDEPEND=>=sys-apps/texinfo-4.3 >=sys-devel/m4-1.4.6 dev-lang/perl >=sys-devel/autoconf-wrapper-10
 SLOT=2.5
 SRC_URI=mirror://gnu/autoconf/autoconf-2.68.tar.bz2 ftp://alpha.gnu.org/pub/gnu/autoconf/autoconf-2.68.tar.bz2
-_md5_=c3d9b3fa9c2b37c16dbcd9650ba2fcf7
+_md5_=f05aa14c5d5776fcac1e728d33a05367
diff --git a/metadata/md5-cache/sys-devel/autoconf-wrapper-10-r1 b/metadata/md5-cache/sys-devel/autoconf-wrapper-10-r1
index 5012794..e30f7a7 100644
--- a/metadata/md5-cache/sys-devel/autoconf-wrapper-10-r1
+++ b/metadata/md5-cache/sys-devel/autoconf-wrapper-10-r1
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=wrapper for autoconf to manage multiple autoconf versions
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=fbd70fa37fb9ab30f7468823bc83a975
+_md5_=82733ff7dac6697d0b0fc0d5bca12a12
diff --git a/metadata/md5-cache/sys-devel/automake-wrapper-5 b/metadata/md5-cache/sys-devel/automake-wrapper-5
index 6230c31..b46531d 100644
--- a/metadata/md5-cache/sys-devel/automake-wrapper-5
+++ b/metadata/md5-cache/sys-devel/automake-wrapper-5
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install unpack
 DESCRIPTION=wrapper for automake to manage multiple automake versions
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ~ppc ~ppc64 s390 sh ~sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=725f632268b9c959019f824c8f2492c8
+_md5_=3c72ae9e00e2dccbea999ab84464fe48
diff --git a/metadata/md5-cache/sys-devel/bc-1.06.95 b/metadata/md5-cache/sys-devel/bc-1.06.95
index 15d4d67..28b3443 100644
--- a/metadata/md5-cache/sys-devel/bc-1.06.95
+++ b/metadata/md5-cache/sys-devel/bc-1.06.95
@@ -3,10 +3,10 @@
 DESCRIPTION=Handy console-based calculator utility
 HOMEPAGE=http://www.gnu.org/software/bc/bc.html
 IUSE=libedit readline static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2 LGPL-2.1
 RDEPEND=readline? ( >=sys-libs/readline-4.1 >=sys-libs/ncurses-5.2 ) libedit? ( dev-libs/libedit )
 SLOT=0
 SRC_URI=mirror://gnu-alpha/bc/bc-1.06.95.tar.bz2 mirror://gnu/bc/bc-1.06.95.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=0e81231e2a0f5d0bfa53491e29db93d7
+_md5_=de5efeeae662fc4219031a5c993ddc1b
diff --git a/metadata/md5-cache/sys-devel/binutils-config-3-r3 b/metadata/md5-cache/sys-devel/binutils-config-3-r3
index a4c4fed..e9f8a53 100644
--- a/metadata/md5-cache/sys-devel/binutils-config-3-r3
+++ b/metadata/md5-cache/sys-devel/binutils-config-3-r3
@@ -1,8 +1,8 @@
 DEFINED_PHASES=install
 DESCRIPTION=Utility to change the binutils version being used
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=userland_GNU? ( !<sys-apps/findutils-4.2 )
 SLOT=0
-_md5_=52bb5f9f832a0576a92781ebc46be639
+_md5_=dca0a916d810416b1f3e8fe72592f48c
diff --git a/metadata/md5-cache/sys-devel/bison-2.4.3 b/metadata/md5-cache/sys-devel/bison-2.4.3
index 97855b8..58e8de3 100644
--- a/metadata/md5-cache/sys-devel/bison-2.4.3
+++ b/metadata/md5-cache/sys-devel/bison-2.4.3
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/bison/bison.html
 IUSE=nls static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=sys-devel/m4
 SLOT=0
 SRC_URI=mirror://gnu/bison/bison-2.4.3.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=b3e8fd2b3aa92e8400fbabc0f9016b4e
+_md5_=a22729a4b9d76e069dd17b07b309528a
diff --git a/metadata/md5-cache/sys-devel/flex-2.5.35_p10 b/metadata/md5-cache/sys-devel/flex-2.5.35_p10
index e53aa45..eb550e2 100644
--- a/metadata/md5-cache/sys-devel/flex-2.5.35_p10
+++ b/metadata/md5-cache/sys-devel/flex-2.5.35_p10
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://flex.sourceforge.net/
 IUSE=nls static test
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ~ppc ~ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=FLEX
 RDEPEND=sys-devel/m4
 SLOT=0
 SRC_URI=mirror://sourceforge/flex/flex-2.5.35.tar.bz2 mirror://debian/pool/main/f/flex/flex_2.5.35-10.diff.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f8416155a7f9b85cd4032d33f4184de8
+_md5_=b1153b0d58c968985dcbc6c798961d69
diff --git a/metadata/md5-cache/sys-devel/gcc-config-1.7.3 b/metadata/md5-cache/sys-devel/gcc-config-1.7.3
index 3de2146..9d64652 100644
--- a/metadata/md5-cache/sys-devel/gcc-config-1.7.3
+++ b/metadata/md5-cache/sys-devel/gcc-config-1.7.3
@@ -1,9 +1,9 @@
 DEFINED_PHASES=compile install postinst unpack
 DESCRIPTION=utility to manage compilers
 HOMEPAGE=http://git.overlays.gentoo.org/gitweb/?p=proj/gcc-config.git
-KEYWORDS=~alpha amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/gcc-config-1.7.3.tar.xz http://dev.gentoo.org/~vapier/dist/gcc-config-1.7.3.tar.xz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	unpacker	50e1227854e96469a19a63f053496328
-_md5_=a592ef9d2e42f56645022b3505cc6a08
+_md5_=d6eb6cbbf47f9baff91b062df0b801ce
diff --git a/metadata/md5-cache/sys-devel/gettext-0.18.1.1-r3 b/metadata/md5-cache/sys-devel/gettext-0.18.1.1-r3
index a64c402..4580208 100644
--- a/metadata/md5-cache/sys-devel/gettext-0.18.1.1-r3
+++ b/metadata/md5-cache/sys-devel/gettext-0.18.1.1-r3
@@ -4,11 +4,11 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/gettext/
 IUSE=acl doc emacs +git java nls +cxx openmp static-libs elibc_glibc elibc_FreeBSD java
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3 LGPL-2
 PDEPEND=emacs? ( app-emacs/po-mode )
 RDEPEND=virtual/libiconv dev-libs/libxml2 sys-libs/ncurses dev-libs/expat acl? ( virtual/acl ) java? ( >=virtual/jdk-1.4 ) git? ( dev-vcs/git ) java? ( >=virtual/jre-1.4 ) java? ( >=dev-java/java-config-2.1.9-r1 )
 SLOT=0
 SRC_URI=mirror://gnu/gettext/gettext-0.18.1.1.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	java-pkg-opt-2	31a1663247652448431dcc8c194e2752	java-utils-2	6beafc7c3d1dbae83a4478182b158f66	libtool	0fd90d183673bf1107465ec45849d1ea	mono	1b3a5799422dfe677c9d09f162d99cc0	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=d0721a63fb32ace91d6af50f3b6c3f1a
+_md5_=e924ff8bbf625df2484c4f2a506d6949
diff --git a/metadata/md5-cache/sys-devel/gnuconfig-20120818 b/metadata/md5-cache/sys-devel/gnuconfig-20120818
index d33c66b..b005706 100644
--- a/metadata/md5-cache/sys-devel/gnuconfig-20120818
+++ b/metadata/md5-cache/sys-devel/gnuconfig-20120818
@@ -2,9 +2,9 @@
 DESCRIPTION=Updated config.sub and config.guess file from GNU
 EAPI=2
 HOMEPAGE=http://savannah.gnu.org/projects/config
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gentoo/gnuconfig-20120818.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ff0350a8bb16293034802fc39f4da2a2
+_md5_=03fe7db99233720f1aaf3396ed3f2d17
diff --git a/metadata/md5-cache/sys-devel/libperl-5.10.1 b/metadata/md5-cache/sys-devel/libperl-5.10.1
index 8c5622a..66d39b4 100644
--- a/metadata/md5-cache/sys-devel/libperl-5.10.1
+++ b/metadata/md5-cache/sys-devel/libperl-5.10.1
@@ -1,9 +1,9 @@
 DEFINED_PHASES=postinst
 DESCRIPTION=Larry Wall's Practical Extraction and Report Language
 HOMEPAGE=http://www.gentoo.org/
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=|| ( Artistic GPL-1 GPL-2 GPL-3 )
 PDEPEND=>=dev-lang/perl-5.10.1
 SLOT=1
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=1cefee686616bc8a2451a99f16228995
+_md5_=25ab3ce30fa65fcaebf24c16cd17ce50
diff --git a/metadata/md5-cache/sys-devel/libtool-2.4-r1 b/metadata/md5-cache/sys-devel/libtool-2.4-r1
index 37c1005..b6ea1fa 100644
--- a/metadata/md5-cache/sys-devel/libtool-2.4-r1
+++ b/metadata/md5-cache/sys-devel/libtool-2.4-r1
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/libtool/
 IUSE=test vanilla
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=sys-devel/gnuconfig !<sys-devel/autoconf-2.62:2.5 !<sys-devel/automake-1.11.1:1.11 !=sys-devel/libtool-2*:1.5
 SLOT=2
 SRC_URI=mirror://gnu/libtool/libtool-2.4.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2bcbcfd74e08e81449f113f841d67fa7
+_md5_=4a3d4bfdc690b15adf54060d3135ffc7
diff --git a/metadata/md5-cache/sys-devel/m4-1.4.15 b/metadata/md5-cache/sys-devel/m4-1.4.15
index 9cd2391..aec40db 100644
--- a/metadata/md5-cache/sys-devel/m4-1.4.15
+++ b/metadata/md5-cache/sys-devel/m4-1.4.15
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/m4/m4.html
 IUSE=examples
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 SLOT=0
 SRC_URI=mirror://gnu/m4/m4-1.4.15.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=296e703ecf44fab62137c129ecaad489
+_md5_=f8d9ec448e5063568d9778877ef855d0
diff --git a/metadata/md5-cache/sys-devel/make-3.82-r1 b/metadata/md5-cache/sys-devel/make-3.82-r1
index e931421..124c9a9 100644
--- a/metadata/md5-cache/sys-devel/make-3.82-r1
+++ b/metadata/md5-cache/sys-devel/make-3.82-r1
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.gnu.org/software/make/make.html
 IUSE=nls static
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://gnu//make/make-3.82.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=015dd591c74335f0dd9390d9bc999466
+_md5_=3f28f58214618123d425a8ec665b0204
diff --git a/metadata/md5-cache/sys-devel/patch-2.6.1 b/metadata/md5-cache/sys-devel/patch-2.6.1
index 4976a56..8d64afa 100644
--- a/metadata/md5-cache/sys-devel/patch-2.6.1
+++ b/metadata/md5-cache/sys-devel/patch-2.6.1
@@ -3,9 +3,9 @@
 DESCRIPTION=Utility to apply diffs to files
 HOMEPAGE=http://www.gnu.org/software/patch/patch.html
 IUSE=static test
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=mirror://gnu/patch/patch-2.6.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ce2f0493516923cdd9146a0076799a12
+_md5_=d9b70a2c2124e83e1a272929e6c674b2
diff --git a/metadata/md5-cache/sys-devel/smatch-1.57-r1 b/metadata/md5-cache/sys-devel/smatch-1.57-r1
index 7aef49b..c4d4f7b 100644
--- a/metadata/md5-cache/sys-devel/smatch-1.57-r1
+++ b/metadata/md5-cache/sys-devel/smatch-1.57-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=static analysis tool for C
 EAPI=4
 HOMEPAGE=http://smatch.sourceforge.net/
-KEYWORDS=amd64 ~arm ~hppa ~ia64 ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86
+KEYWORDS=amd64 ~arm hppa ia64 ppc ppc64 s390 sh sparc ~x86
 LICENSE=OSL-1.1
 RDEPEND=dev-db/sqlite
 SLOT=0
 SRC_URI=mirror://gentoo/smatch-1.57.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=7b53578cb48f4d8ab7d2e2e5d7ba142d
+_md5_=5f38029f213f134d6b8ac53a88412a40
diff --git a/metadata/md5-cache/sys-fs/avfs-1.0.1 b/metadata/md5-cache/sys-fs/avfs-1.0.1
index 63eb360..e5742a2 100644
--- a/metadata/md5-cache/sys-fs/avfs-1.0.1
+++ b/metadata/md5-cache/sys-fs/avfs-1.0.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://sourceforge.net/projects/avf
 IUSE=static-libs +lzma
-KEYWORDS=~alpha amd64 arm ~hppa ~ppc ~ppc64 x86
+KEYWORDS=alpha amd64 arm hppa ppc ppc64 x86
 LICENSE=GPL-2
 RDEPEND=>=sys-fs/fuse-2.4 sys-libs/zlib app-arch/bzip2 lzma? ( app-arch/xz-utils )
 SLOT=0
 SRC_URI=mirror://sourceforge/avf/avfs-1.0.1.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=1f2fcc1da607647da3641c8f24f6313b
+_md5_=ffdf47a01d1ef15225b940ca43c63644
diff --git a/metadata/md5-cache/sys-fs/dd-rescue-1.28 b/metadata/md5-cache/sys-fs/dd-rescue-1.28
index 07b9b17..e9f4f4a 100644
--- a/metadata/md5-cache/sys-fs/dd-rescue-1.28
+++ b/metadata/md5-cache/sys-fs/dd-rescue-1.28
@@ -3,9 +3,9 @@
 EAPI=4
 HOMEPAGE=http://www.garloff.de/kurt/linux/ddrescue/
 IUSE=static kernel_linux elibc_glibc
-KEYWORDS=amd64 arm ~mips ppc ~sparc x86 ~amd64-linux ~x86-linux ~ppc-macos
+KEYWORDS=amd64 arm mips ppc sparc x86 ~amd64-linux ~x86-linux ~ppc-macos
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://www.garloff.de/kurt/linux/ddrescue/dd_rescue-1.28.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=4bcd9aab9a11ad2c3d7b86dfa5308309
+_md5_=666fd1130d48734434ee2653d1ae7b5a
diff --git a/metadata/md5-cache/sys-fs/dosfstools-3.0.9 b/metadata/md5-cache/sys-fs/dosfstools-3.0.9
index d388b20..7efa8cb 100644
--- a/metadata/md5-cache/sys-fs/dosfstools-3.0.9
+++ b/metadata/md5-cache/sys-fs/dosfstools-3.0.9
@@ -2,10 +2,10 @@
 DESCRIPTION=DOS filesystem tools - provides mkdosfs, mkfs.msdos, mkfs.vfat
 EAPI=2
 HOMEPAGE=http://www.daniel-baumann.ch/software/dosfstools/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-3
 RESTRICT=test
 SLOT=0
 SRC_URI=http://www.daniel-baumann.ch/software/dosfstools/dosfstools-3.0.9.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=dbf07eb5a86772025c09afda675c297b
+_md5_=49b4887bf8b33db5a430c59e1ca2d3a2
diff --git a/metadata/md5-cache/sys-fs/e2fsprogs-1.42 b/metadata/md5-cache/sys-fs/e2fsprogs-1.42
index 8fb0f28..be773e5 100644
--- a/metadata/md5-cache/sys-fs/e2fsprogs-1.42
+++ b/metadata/md5-cache/sys-fs/e2fsprogs-1.42
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://e2fsprogs.sourceforge.net/
 IUSE=nls static-libs elibc_FreeBSD
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 -x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~m68k-mint
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 -x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~m68k-mint
 LICENSE=GPL-2 BSD
 RDEPEND=~sys-libs/e2fsprogs-libs-1.42 >=sys-apps/util-linux-2.16 nls? ( virtual/libintl )
 SLOT=0
 SRC_URI=mirror://sourceforge/e2fsprogs/e2fsprogs-1.42.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=5bc9e384967fdd7f9a3a203be3a5b5ee
+_md5_=efb5ffc66abec7bdbaa88b03ab0e2810
diff --git a/metadata/md5-cache/sys-fs/lvm2-2.02.88 b/metadata/md5-cache/sys-fs/lvm2-2.02.88
index 1aa4b04..3fedd06 100644
--- a/metadata/md5-cache/sys-fs/lvm2-2.02.88
+++ b/metadata/md5-cache/sys-fs/lvm2-2.02.88
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://sources.redhat.com/lvm2/
 IUSE=readline +static +static-libs clvm cman +lvm1 selinux
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-linux
 LICENSE=GPL-2
 RDEPEND=!!sys-fs/device-mapper readline? ( sys-libs/readline ) clvm? ( =sys-cluster/dlm-2* cman? ( =sys-cluster/cman-2* ) ) >=sys-fs/udev-151-r4 !<sys-apps/openrc-0.4 !!sys-fs/lvm-user !!sys-fs/clvm >=sys-apps/util-linux-2.16 !<sys-fs/cryptsetup-1.1.2
 SLOT=0
 SRC_URI=ftp://sources.redhat.com/pub/lvm2/LVM2.2.02.88.tgz ftp://sources.redhat.com/pub/lvm2/old/LVM2.2.02.88.tgz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=999f1e16a58b27afc7fc8708b6f9196d
+_md5_=8084d15836cf350eb1346ae0da3a4fde
diff --git a/metadata/md5-cache/sys-fs/mtd-utils-1.4.8 b/metadata/md5-cache/sys-fs/mtd-utils-1.4.8
index 25077ee..201caee 100644
--- a/metadata/md5-cache/sys-fs/mtd-utils-1.4.8
+++ b/metadata/md5-cache/sys-fs/mtd-utils-1.4.8
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://git.infradead.org/?p=mtd-utils.git;a=summary
 IUSE=xattr
-KEYWORDS=amd64 arm ~mips ppc x86 ~amd64-linux ~x86-linux
+KEYWORDS=amd64 arm mips ppc x86 ~amd64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=!sys-fs/mtd dev-libs/lzo sys-libs/zlib >=sys-apps/util-linux-2.16
 SLOT=0
 SRC_URI=http://git.infradead.org/mtd-utils.git/snapshot/v1.4.8.tar.gz -> mtd-utils-1.4.8.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=2ca383ae703f5d8faefd719104547fc0
+_md5_=47f4dbc73b46f729fb9c549637ee2026
diff --git a/metadata/md5-cache/sys-fs/squashfs-tools-4.2 b/metadata/md5-cache/sys-fs/squashfs-tools-4.2
index e61111a..f8f74be 100644
--- a/metadata/md5-cache/sys-fs/squashfs-tools-4.2
+++ b/metadata/md5-cache/sys-fs/squashfs-tools-4.2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://squashfs.sourceforge.net
 IUSE=+gzip +lzma lzo xattr
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-linux
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~x86-linux
 LICENSE=GPL-2
 RDEPEND=gzip? ( sys-libs/zlib ) lzma? ( app-arch/xz-utils ) lzo? ( dev-libs/lzo ) !lzma? ( !lzo? ( sys-libs/zlib ) ) xattr? ( sys-apps/attr )
 SLOT=0
 SRC_URI=mirror://sourceforge/squashfs/squashfs4.2.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ae8f0d1a35c84794e4db45408b23f66a
+_md5_=ba25642ae7ed4f6f945509cb9f9a2b3d
diff --git a/metadata/md5-cache/sys-fs/sshfs-fuse-2.4 b/metadata/md5-cache/sys-fs/sshfs-fuse-2.4
index b6eddc1..d468ef5 100644
--- a/metadata/md5-cache/sys-fs/sshfs-fuse-2.4
+++ b/metadata/md5-cache/sys-fs/sshfs-fuse-2.4
@@ -3,9 +3,9 @@
 DESCRIPTION=Fuse-filesystem utilizing the sftp service.
 EAPI=4
 HOMEPAGE=http://fuse.sourceforge.net/sshfs.html
-KEYWORDS=amd64 arm ~hppa ~ppc ~ppc64 x86 ~x86-fbsd ~x86-linux
+KEYWORDS=amd64 arm hppa ppc ppc64 x86 ~x86-fbsd ~x86-linux
 LICENSE=GPL-2
 RDEPEND=>=sys-fs/fuse-2.6.0_pre3 >=dev-libs/glib-2.4.2 >=net-misc/openssh-4.3
 SLOT=0
 SRC_URI=mirror://sourceforge/fuse/sshfs-fuse-2.4.tar.gz
-_md5_=6dcfa5b0e02074c6f01a9215f518c8b4
+_md5_=d9cca7eb2b05e9f522fc2dc7ec163b2c
diff --git a/metadata/md5-cache/sys-fs/udev-171-r2 b/metadata/md5-cache/sys-fs/udev-171-r2
index 68524d3..67ac6bf 100644
--- a/metadata/md5-cache/sys-fs/udev-171-r2
+++ b/metadata/md5-cache/sys-fs/udev-171-r2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html
 IUSE=build selinux test debug +rule_generator hwdb acl gudev introspection keymap floppy edd action_modeswitch extras
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-linux
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc ~x86 ~x86-linux
 LICENSE=GPL-2
 RDEPEND=selinux? ( sys-libs/libselinux ) extras? ( sys-apps/acl dev-libs/glib:2 dev-libs/gobject-introspection virtual/libusb:0 ) acl? ( sys-apps/acl dev-libs/glib:2 ) gudev? ( dev-libs/glib:2 ) introspection? ( dev-libs/gobject-introspection ) action_modeswitch? ( virtual/libusb:0 ) >=sys-apps/util-linux-2.16 >=sys-libs/glibc-2.10 hwdb? ( >=sys-apps/usbutils-0.82 sys-apps/pciutils ) extras? ( >=sys-apps/usbutils-0.82 sys-apps/pciutils ) !sys-apps/coldplug !<sys-fs/lvm2-2.02.45 !sys-fs/device-mapper >=sys-apps/baselayout-1.12.5
 SLOT=0
 SRC_URI=mirror://kernel/linux/utils/kernel/hotplug/udev-171.tar.bz2 test? ( mirror://gentoo/udev-171-testsys.tar.bz2 ) mirror://gentoo/udev-171-gentoo-patchset-v1.tar.bz2 mirror://gentoo/udev-gentoo-scripts-v4.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	systemd	b5da52630b2559da43198bfb56ccacba	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=6bebc6e2979f72b3b88b6781794d81c1
+_md5_=12f120e99df65810ca4824029a909548
diff --git a/metadata/md5-cache/sys-kernel/linux-headers-3.4 b/metadata/md5-cache/sys-kernel/linux-headers-3.4
index 357ee4b..c8a70df 100644
--- a/metadata/md5-cache/sys-kernel/linux-headers-3.4
+++ b/metadata/md5-cache/sys-kernel/linux-headers-3.4
@@ -3,10 +3,10 @@
 DESCRIPTION=Linux system headers
 EAPI=3
 HOMEPAGE=http://www.kernel.org/ http://www.gentoo.org/
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=GPL-2
 RESTRICT=binchecks strip
 SLOT=0
 SRC_URI=mirror://gentoo/gentoo-headers-base-3.4.tar.xz mirror://gentoo/gentoo-headers-3.4-1.tar.xz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	kernel-2	f6bc76f6aacd763879420dba9fa0168e	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=e29f313c7bb80ecce7297404fa61b621
+_md5_=027e1cec7234fc890693093b70e55a95
diff --git a/metadata/md5-cache/sys-libs/cracklib-2.8.13-r1 b/metadata/md5-cache/sys-libs/cracklib-2.8.13-r1
index 3dcef59..9dd7e0b 100644
--- a/metadata/md5-cache/sys-libs/cracklib-2.8.13-r1
+++ b/metadata/md5-cache/sys-libs/cracklib-2.8.13-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=Password Checking Library
 HOMEPAGE=http://sourceforge.net/projects/cracklib
 IUSE=nls python
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=CRACKLIB
 RDEPEND=python? ( <dev-lang/python-3 )
 SLOT=0
 SRC_URI=mirror://sourceforge/cracklib/cracklib-2.8.13.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=5f5d7de030569cc894ae83dc9f16f4fb
+_md5_=6bab9c311db1c5a6a29f74f0b254ae59
diff --git a/metadata/md5-cache/sys-libs/e2fsprogs-libs-1.42 b/metadata/md5-cache/sys-libs/e2fsprogs-libs-1.42
index aaa6c7c..815046a 100644
--- a/metadata/md5-cache/sys-libs/e2fsprogs-libs-1.42
+++ b/metadata/md5-cache/sys-libs/e2fsprogs-libs-1.42
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://e2fsprogs.sourceforge.net/
 IUSE=nls static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~m68k ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=!sys-libs/com_err !sys-libs/ss !<sys-fs/e2fsprogs-1.41.8
 SLOT=0
 SRC_URI=mirror://sourceforge/e2fsprogs/e2fsprogs-libs-1.42.tar.gz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=e31c7e3af9b8f2766ebcbeef46a42f91
+_md5_=4bf9a6b714bdaeb70b683d264582037c
diff --git a/metadata/md5-cache/sys-libs/gdbm-1.9.1-r2 b/metadata/md5-cache/sys-libs/gdbm-1.9.1-r2
index 614419c..34ef283 100644
--- a/metadata/md5-cache/sys-libs/gdbm-1.9.1-r2
+++ b/metadata/md5-cache/sys-libs/gdbm-1.9.1-r2
@@ -3,9 +3,9 @@
 EAPI=3
 HOMEPAGE=http://www.gnu.org/software/gdbm/
 IUSE=+berkdb exporter static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 ~s390 ~sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-linux
 LICENSE=GPL-3
 SLOT=0
 SRC_URI=mirror://gnu/gdbm/gdbm-1.9.1.tar.gz exporter? ( mirror://gnu/gdbm/gdbm-1.8.3.tar.gz )
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=8194b8851b75b8dcb15c69eed6777c83
+_md5_=080c96e88d36c00606557126dbdcc4a8
diff --git a/metadata/md5-cache/sys-libs/libcap-2.17 b/metadata/md5-cache/sys-libs/libcap-2.17
index cec1003..8f67722 100644
--- a/metadata/md5-cache/sys-libs/libcap-2.17
+++ b/metadata/md5-cache/sys-libs/libcap-2.17
@@ -3,10 +3,10 @@
 DESCRIPTION=POSIX 1003.1e capabilities
 HOMEPAGE=http://www.friedhoff.org/posixfilecaps.html
 IUSE=pam
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2 BSD
 RDEPEND=sys-apps/attr pam? ( virtual/pam )
 SLOT=0
 SRC_URI=mirror://kernel/linux/libs/security/linux-privs/libcap2/libcap-2.17.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	pam	3f746974e1cc47cabe3bd488c08cdc8e	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=9e04973604ff0c40dfbeaa8680d3912e
+_md5_=65b35228f3fa753fb4255f0fe3d82138
diff --git a/metadata/md5-cache/sys-libs/libcap-ng-0.6.6 b/metadata/md5-cache/sys-libs/libcap-ng-0.6.6
index 600812a..a3f8df0 100644
--- a/metadata/md5-cache/sys-libs/libcap-ng-0.6.6
+++ b/metadata/md5-cache/sys-libs/libcap-ng-0.6.6
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://people.redhat.com/sgrubb/libcap-ng/
 IUSE=python static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86
 LICENSE=LGPL-2.1
 RDEPEND=sys-apps/attr python? ( dev-lang/python ) >=app-admin/eselect-python-20091230
 SLOT=0
 SRC_URI=http://people.redhat.com/sgrubb/libcap-ng/libcap-ng-0.6.6.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=aa5a8a32f2851d539a6a746a813839f7
+_md5_=0052162de2c6a2c2c927acdf04b8e1de
diff --git a/metadata/md5-cache/sys-libs/mtdev-1.1.2 b/metadata/md5-cache/sys-libs/mtdev-1.1.2
index 225319b..e6b92c7 100644
--- a/metadata/md5-cache/sys-libs/mtdev-1.1.2
+++ b/metadata/md5-cache/sys-libs/mtdev-1.1.2
@@ -4,8 +4,8 @@
 EAPI=4
 HOMEPAGE=http://bitmath.org/code/mtdev/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ppc ppc64 ~sh ~sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://bitmath.org/code/mtdev/mtdev-1.1.2.tar.bz2
-_md5_=b0514955e875e24dd54116ec8c18120b
+_md5_=7b5fcc58f07eb4efce39b495c1ed9590
diff --git a/metadata/md5-cache/sys-libs/ncurses-5.9-r2 b/metadata/md5-cache/sys-libs/ncurses-5.9-r2
index 2127a8e..c6738c3 100644
--- a/metadata/md5-cache/sys-libs/ncurses-5.9-r2
+++ b/metadata/md5-cache/sys-libs/ncurses-5.9-r2
@@ -4,10 +4,10 @@
 EAPI=1
 HOMEPAGE=http://www.gnu.org/software/ncurses/ http://dickey.his.com/ncurses/
 IUSE=ada +cxx debug doc gpm minimal profile static-libs tinfo trace unicode
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=MIT
 RDEPEND=gpm? ( sys-libs/gpm ) !<x11-terms/rxvt-unicode-9.06-r3
 SLOT=5
 SRC_URI=mirror://gnu/ncurses/ncurses-5.9.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=0518c981fdd12e974a28799a8df65f2a
+_md5_=ac184368b221d93072682af075a28f58
diff --git a/metadata/md5-cache/sys-libs/pam-1.1.5 b/metadata/md5-cache/sys-libs/pam-1.1.5
index e0232c7..3022ace 100644
--- a/metadata/md5-cache/sys-libs/pam-1.1.5
+++ b/metadata/md5-cache/sys-libs/pam-1.1.5
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=https://fedorahosted.org/linux-pam/
 IUSE=cracklib nls elibc_FreeBSD selinux vim-syntax audit test elibc_glibc debug berkdb nis
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=|| ( BSD GPL-2 )
 PDEPEND=sys-auth/pambase vim-syntax? ( app-vim/pam-syntax )
 RDEPEND=nls? ( virtual/libintl ) cracklib? ( >=sys-libs/cracklib-2.8.3 ) audit? ( sys-process/audit ) selinux? ( >=sys-libs/libselinux-1.28 ) berkdb? ( sys-libs/db ) elibc_glibc? ( >=sys-libs/glibc-2.7 nis? ( || ( >=net-libs/libtirpc-0.2.2-r1 <sys-libs/glibc-2.14 ) ) ) !sys-auth/openpam !sys-auth/pam_userdb
 SLOT=0
 SRC_URI=https://fedorahosted.org/releases/l/i/linux-pam/Linux-PAM-1.1.5.tar.bz2 https://fedorahosted.org/releases/l/i/linux-pam/Linux-PAM-1.1.5-docs.tar.bz2
 _eclasses_=db-use	8d7baa3efc7c38c7d5c5e7353c5460dc	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	pam	3f746974e1cc47cabe3bd488c08cdc8e	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=fea68a694a7fab904ed38795a05d0b0c
+_md5_=83856bfccfeddbd23223b8279f5f91d2
diff --git a/metadata/md5-cache/sys-libs/readline-6.2_p1 b/metadata/md5-cache/sys-libs/readline-6.2_p1
index 94c0e7d..54c9896 100644
--- a/metadata/md5-cache/sys-libs/readline-6.2_p1
+++ b/metadata/md5-cache/sys-libs/readline-6.2_p1
@@ -2,10 +2,10 @@
 DEPEND=>=sys-libs/ncurses-5.2-r2
 DESCRIPTION=Another cute console display library
 HOMEPAGE=http://cnswww.cns.cwru.edu/php/chet/readline/rltop.html
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-3
 RDEPEND=>=sys-libs/ncurses-5.2-r2
 SLOT=0
 SRC_URI=mirror://gnu/readline/readline-6.2.tar.gz ftp://ftp.cwru.edu/pub/bash/readline-6.2-patches/readline62-001 mirror://gnu/readline/readline-6.2-patches/readline62-001
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=f8d2a9c8bd547cceb0ad680315bdc470
+_md5_=55d422945b86806878206bc2bacb033c
diff --git a/metadata/md5-cache/sys-libs/slang-2.2.2 b/metadata/md5-cache/sys-libs/slang-2.2.2
index 7519734..4899c9c 100644
--- a/metadata/md5-cache/sys-libs/slang-2.2.2
+++ b/metadata/md5-cache/sys-libs/slang-2.2.2
@@ -4,10 +4,10 @@
 EAPI=2
 HOMEPAGE=http://www.jedsoft.org/slang/
 IUSE=cjk pcre png readline zlib
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 LICENSE=GPL-2
 RDEPEND=sys-libs/ncurses pcre? ( dev-libs/libpcre ) png? ( media-libs/libpng ) cjk? ( dev-libs/oniguruma ) readline? ( sys-libs/readline ) zlib? ( sys-libs/zlib )
 SLOT=0
 SRC_URI=mirror://slang/v2.2/slang-2.2.2.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=c772662b2a2efa70a3c59e40130684b5
+_md5_=6b58b42e20f07b67d5dab07f70f322d6
diff --git a/metadata/md5-cache/sys-libs/zlib-1.2.7 b/metadata/md5-cache/sys-libs/zlib-1.2.7
index 139d7e5..70c4a27 100644
--- a/metadata/md5-cache/sys-libs/zlib-1.2.7
+++ b/metadata/md5-cache/sys-libs/zlib-1.2.7
@@ -3,10 +3,10 @@
 DESCRIPTION=Standard (de)compression library
 HOMEPAGE=http://www.zlib.net/
 IUSE=minizip static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd
 LICENSE=ZLIB
 RDEPEND=!<dev-libs/libxml2-2.7.7
 SLOT=0
 SRC_URI=http://zlib.net/zlib-1.2.7.tar.gz http://www.gzip.org/zlib/zlib-1.2.7.tar.gz http://www.zlib.net/current/beta/zlib-1.2.7.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=2eaf8ad2e3e277970d8a745ba34febf9
+_md5_=24c7a5c232ec919c61072be13a17f90f
diff --git a/metadata/md5-cache/sys-process/audit-2.1.3-r1 b/metadata/md5-cache/sys-process/audit-2.1.3-r1
index aa19d79..764b07e 100644
--- a/metadata/md5-cache/sys-process/audit-2.1.3-r1
+++ b/metadata/md5-cache/sys-process/audit-2.1.3-r1
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://people.redhat.com/sgrubb/audit/
 IUSE=ldap prelude python
-KEYWORDS=alpha amd64 hppa ia64 ~mips ppc ppc64 sparc x86
+KEYWORDS=alpha amd64 hppa ia64 mips ppc ppc64 sparc x86
 LICENSE=GPL-2
 RDEPEND=ldap? ( net-nds/openldap ) prelude? ( dev-libs/libprelude ) sys-libs/libcap-ng >=app-admin/eselect-python-20091230 python? ( =dev-lang/python-2* )
 RESTRICT=test
 SLOT=0
 SRC_URI=http://people.redhat.com/sgrubb/audit/audit-2.1.3.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	python	6bbd984910e27780e5d0ea543d83ef84	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=4056330e8de2d95c1a53d5226c3398f3
+_md5_=e07951ff22e85cd810b84686e4fd48f2
diff --git a/metadata/md5-cache/sys-process/htop-1.0.2-r1 b/metadata/md5-cache/sys-process/htop-1.0.2-r1
index 7215f84..a87094e 100644
--- a/metadata/md5-cache/sys-process/htop-1.0.2-r1
+++ b/metadata/md5-cache/sys-process/htop-1.0.2-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://htop.sourceforge.net
 IUSE=kernel_FreeBSD kernel_linux openvz unicode vserver
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~sh ~sparc x86 ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-linux ~x86-linux
 LICENSE=BSD GPL-2
 RDEPEND=sys-libs/ncurses[unicode?]
 SLOT=0
 SRC_URI=mirror://sourceforge/htop/htop-1.0.2.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=d4fcb49c7be0adcedc5af490ac4062f9
+_md5_=ae9b9f41ed6df1fb9da7f1a00506c6ce
diff --git a/metadata/md5-cache/sys-process/lsof-4.81-r2 b/metadata/md5-cache/sys-process/lsof-4.81-r2
index d3eda1d..109fdd1 100644
--- a/metadata/md5-cache/sys-process/lsof-4.81-r2
+++ b/metadata/md5-cache/sys-process/lsof-4.81-r2
@@ -3,10 +3,10 @@
 DESCRIPTION=Lists open files for running Unix processes
 HOMEPAGE=ftp://lsof.itap.purdue.edu/pub/tools/unix/lsof/
 IUSE=static selinux
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=lsof
 RDEPEND=selinux? ( sys-libs/libselinux )
 SLOT=0
 SRC_URI=ftp://lsof.itap.purdue.edu/pub/tools/unix/lsof/lsof_4.81.tar.bz2 ftp://vic.cc.purdue.edu/pub/tools/unix/lsof/lsof_4.81.tar.bz2 ftp://ftp.cerias.purdue.edu/pub/tools/unix/sysutils/lsof/lsof_4.81.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	fixheadtails	059c47dd86229aa6382393274677acfe	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=065aee59f3afe31b9359b24b0b753aaa
+_md5_=6dad3ce7bc030183e3a61b28f155a4b0
diff --git a/metadata/md5-cache/sys-process/lsof-4.82 b/metadata/md5-cache/sys-process/lsof-4.82
index b178c90..37271cb 100644
--- a/metadata/md5-cache/sys-process/lsof-4.82
+++ b/metadata/md5-cache/sys-process/lsof-4.82
@@ -3,10 +3,10 @@
 DESCRIPTION=Lists open files for running Unix processes
 HOMEPAGE=ftp://lsof.itap.purdue.edu/pub/tools/unix/lsof/
 IUSE=static selinux
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=lsof
 RDEPEND=selinux? ( sys-libs/libselinux )
 SLOT=0
 SRC_URI=ftp://lsof.itap.purdue.edu/pub/tools/unix/lsof/lsof_4.82.tar.bz2 ftp://vic.cc.purdue.edu/pub/tools/unix/lsof/lsof_4.82.tar.bz2 ftp://ftp.cerias.purdue.edu/pub/tools/unix/sysutils/lsof/lsof_4.82.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=171b4de60541a684168b65c4c11a5153
+_md5_=4889b12e0f1eed910a7e2103d490f022
diff --git a/metadata/md5-cache/sys-process/procps-3.3.4 b/metadata/md5-cache/sys-process/procps-3.3.4
index 639cc15..167eb94 100644
--- a/metadata/md5-cache/sys-process/procps-3.3.4
+++ b/metadata/md5-cache/sys-process/procps-3.3.4
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://procps.sourceforge.net/ http://gitorious.org/procps http://packages.debian.org/sid/procps
 IUSE=+ncurses static-libs unicode
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=GPL-2
 RDEPEND=ncurses? ( >=sys-libs/ncurses-5.2-r2[unicode?] )
 RESTRICT=test
 SLOT=0
 SRC_URI=mirror://debian/pool/main/p/procps/procps_3.3.4.orig.tar.xz
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=04f0c8b9d283555af884d7703cb2321b
+_md5_=dd69abea4d23c9927ad94105c024c220
diff --git a/metadata/md5-cache/sys-process/psmisc-22.10 b/metadata/md5-cache/sys-process/psmisc-22.10
index 97989f0..2609ffa 100644
--- a/metadata/md5-cache/sys-process/psmisc-22.10
+++ b/metadata/md5-cache/sys-process/psmisc-22.10
@@ -3,10 +3,10 @@
 DESCRIPTION=A set of tools that use the proc filesystem
 HOMEPAGE=http://psmisc.sourceforge.net/
 IUSE=ipv6 nls selinux X
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 LICENSE=GPL-2
 RDEPEND=>=sys-libs/ncurses-5.2-r2 selinux? ( sys-libs/libselinux )
 SLOT=0
 SRC_URI=mirror://sourceforge/psmisc/psmisc-22.10.tar.gz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=bfc7f204fa44cbcef6b4d75c8da8059a
+_md5_=37ee2070badaaf74259344ac4cccd998
diff --git a/metadata/md5-cache/virtual/acl-0 b/metadata/md5-cache/virtual/acl-0
index b359889..2b39fc7 100644
--- a/metadata/md5-cache/virtual/acl-0
+++ b/metadata/md5-cache/virtual/acl-0
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for acl support (sys/acl.h)
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux
 RDEPEND=kernel_linux? ( sys-apps/acl ) kernel_FreeBSD? ( sys-freebsd/freebsd-lib )
 SLOT=0
-_md5_=0a9c280959d7801fe1e0104f20e5576d
+_md5_=03f25a1320bb16f10a1e28efa7dbd6ff
diff --git a/metadata/md5-cache/virtual/emacs-23 b/metadata/md5-cache/virtual/emacs-23
index ff96451..c23d5e4 100644
--- a/metadata/md5-cache/virtual/emacs-23
+++ b/metadata/md5-cache/virtual/emacs-23
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for GNU Emacs
 EAPI=4
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x86-solaris
 RDEPEND=|| ( app-editors/emacs:23 >=app-editors/emacs-vcs-23.1 )
 SLOT=0
-_md5_=98532cddf88fa7f71939dc0de1ca2599
+_md5_=04282a34fc3e0d7404a9ee55a85dfe8b
diff --git a/metadata/md5-cache/virtual/ffmpeg-0.10.3 b/metadata/md5-cache/virtual/ffmpeg-0.10.3
index ce62436..f7cf597 100644
--- a/metadata/md5-cache/virtual/ffmpeg-0.10.3
+++ b/metadata/md5-cache/virtual/ffmpeg-0.10.3
@@ -2,7 +2,7 @@
 DESCRIPTION=Virtual package for FFmpeg implementation
 EAPI=4
 IUSE=X +encode gsm jpeg2k mp3 sdl speex theora threads truetype vaapi vdpau x264
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~x64-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~x64-macos ~x86-solaris
 RDEPEND=|| ( >=media-video/ffmpeg-0.10.3[X?,encode?,gsm?,jpeg2k?,mp3?,sdl?,speex?,theora?,threads?,truetype?,vaapi?,vdpau?,x264?] >=media-video/libav-0.8.4[X?,encode?,gsm?,jpeg2k?,mp3?,sdl?,speex?,theora?,threads?,truetype?,vaapi?,vdpau?,x264?] )
 SLOT=0
-_md5_=75bcd55fa3f709359dbdfe394c9eea80
+_md5_=83746cefb0c3883973a21ee893db6af7
diff --git a/metadata/md5-cache/virtual/jpeg-0 b/metadata/md5-cache/virtual/jpeg-0
index e4b8481..43349d6 100644
--- a/metadata/md5-cache/virtual/jpeg-0
+++ b/metadata/md5-cache/virtual/jpeg-0
@@ -2,7 +2,7 @@
 DESCRIPTION=Virtual for jpeg library
 EAPI=2
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( media-libs/libjpeg-turbo:0[static-libs?] media-libs/jpeg:0[static-libs?] )
 SLOT=0
-_md5_=1c5c1eb4b2515c897232b99e55fb4734
+_md5_=9bdfae40dace36731e772292e834543f
diff --git a/metadata/md5-cache/virtual/krb5-0 b/metadata/md5-cache/virtual/krb5-0
index 8b0a208..e0f2a6e 100644
--- a/metadata/md5-cache/virtual/krb5-0
+++ b/metadata/md5-cache/virtual/krb5-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Kerberos V implementation
 EAPI=3
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos
 RDEPEND=|| ( app-crypt/mit-krb5 app-crypt/heimdal )
 SLOT=0
-_md5_=a4d44d7315d3ef001bfc0b4369d163a1
+_md5_=336351bb8d3f73c1af17ba05064db540
diff --git a/metadata/md5-cache/virtual/libc-0 b/metadata/md5-cache/virtual/libc-0
index 422136e..88785d3 100644
--- a/metadata/md5-cache/virtual/libc-0
+++ b/metadata/md5-cache/virtual/libc-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for the C library
 EAPI=1
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=!prefix? ( elibc_glibc? ( sys-libs/glibc:2.2 ) elibc_uclibc? ( sys-libs/uclibc ) elibc_FreeBSD? ( sys-freebsd/freebsd-lib ) )
 SLOT=0
-_md5_=93ed54bbdb6a9881e6c3d27a2ab703d9
+_md5_=8c3ff18a59d9ed25766fde010cbd3712
diff --git a/metadata/md5-cache/virtual/libffi-0 b/metadata/md5-cache/virtual/libffi-0
index 9152bce..b489efb 100644
--- a/metadata/md5-cache/virtual/libffi-0
+++ b/metadata/md5-cache/virtual/libffi-0
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for dev-libs/libffi
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=dev-libs/libffi
 SLOT=0
-_md5_=691013de0a50638d466ca3a2d0eb8ba4
+_md5_=fd7c0c7d6e5ddd51418c360e2f7533ff
diff --git a/metadata/md5-cache/virtual/libusb-0 b/metadata/md5-cache/virtual/libusb-0
index d9708c3..4808ab0 100644
--- a/metadata/md5-cache/virtual/libusb-0
+++ b/metadata/md5-cache/virtual/libusb-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for libusb
 EAPI=2
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 RDEPEND=|| ( >=dev-libs/libusb-compat-0.1.4 >=dev-libs/libusb-0.1.12-r7:0 >=sys-freebsd/freebsd-lib-8.0[usb] )
 SLOT=0
-_md5_=ac91afaa372652991bfc85c8841c8a55
+_md5_=fe8789694ac3adf122393b585b6f9bf9
diff --git a/metadata/md5-cache/virtual/libusb-1 b/metadata/md5-cache/virtual/libusb-1
index 8f19f6b..c97c67e 100644
--- a/metadata/md5-cache/virtual/libusb-1
+++ b/metadata/md5-cache/virtual/libusb-1
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for libusb
 EAPI=2
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~arm-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~arm-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos
 RDEPEND=|| ( >=dev-libs/libusbx-1.0.15:1 >=dev-libs/libusb-1.0.9:1 >=sys-freebsd/freebsd-lib-9.1_rc3-r1[usb] )
 SLOT=1
-_md5_=00ad3c12aedf1f9e34db52199f36c9a8
+_md5_=534a6e75596fb873f447613f4b4d382f
diff --git a/metadata/md5-cache/virtual/logger-0 b/metadata/md5-cache/virtual/logger-0
index d1363f9..5e13ef0 100644
--- a/metadata/md5-cache/virtual/logger-0
+++ b/metadata/md5-cache/virtual/logger-0
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for system loggers
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( app-admin/metalog app-admin/rsyslog app-admin/socklog app-admin/sysklogd app-admin/syslog-ng app-admin/syslogread app-admin/busybox-sysklogd sys-freebsd/freebsd-usbin )
 SLOT=0
-_md5_=97517e64277c4556d236abec320057f4
+_md5_=9974942babb7173ce1a382d5df852bfe
diff --git a/metadata/md5-cache/virtual/man-0 b/metadata/md5-cache/virtual/man-0
index 752910e..e7f3792 100644
--- a/metadata/md5-cache/virtual/man-0
+++ b/metadata/md5-cache/virtual/man-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for man
 EAPI=3
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( sys-apps/man sys-apps/man-db )
 SLOT=0
-_md5_=7eda944d3361ec0dac53f52c88389cbd
+_md5_=2b0c1958b35fca434147009a88b4c3ce
diff --git a/metadata/md5-cache/virtual/modutils-0 b/metadata/md5-cache/virtual/modutils-0
index 55ab784..624d3f4 100644
--- a/metadata/md5-cache/virtual/modutils-0
+++ b/metadata/md5-cache/virtual/modutils-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for utilities to manage Linux kernel modules
 EAPI=2
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 RDEPEND=|| ( sys-apps/kmod[tools] >=sys-apps/module-init-tools-3.2 sys-apps/modutils )
 SLOT=0
-_md5_=382e3878f4091eb753913a34df424280
+_md5_=8786a79748633ea7cbb0461f9bed6f29
diff --git a/metadata/md5-cache/virtual/mta-0 b/metadata/md5-cache/virtual/mta-0
index 2f1fc9b..7069d80 100644
--- a/metadata/md5-cache/virtual/mta-0
+++ b/metadata/md5-cache/virtual/mta-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Message Transfer Agents
 EAPI=3
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( >=mail-mta/ssmtp-2.64-r2[mta] <mail-mta/ssmtp-2.64-r2 mail-mta/courier mail-mta/esmtp mail-mta/exim mail-mta/mini-qmail >=mail-mta/msmtp-1.4.19-r1[mta] <mail-mta/msmtp-1.4.19-r1 mail-mta/nbsmtp mail-mta/netqmail mail-mta/nullmailer mail-mta/postfix mail-mta/qmail-ldap mail-mta/sendmail mail-mta/citadel[-postfix] )
 SLOT=0
-_md5_=ff35cd5fe7027612a6e84384da95f764
+_md5_=e00edbdfa52eadb9a187e0abbff8d48e
diff --git a/metadata/md5-cache/virtual/os-headers-0 b/metadata/md5-cache/virtual/os-headers-0
index a33b894..67cfac0 100644
--- a/metadata/md5-cache/virtual/os-headers-0
+++ b/metadata/md5-cache/virtual/os-headers-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for operating system headers
 EAPI=1
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=!prefix? ( || ( sys-kernel/linux-headers:0 sys-freebsd/freebsd-lib ) )
 SLOT=0
-_md5_=d42ff8e20332e2eed94baf509c788344
+_md5_=e88d53f264d12fc71ce6670858e6c330
diff --git a/metadata/md5-cache/virtual/pager-0 b/metadata/md5-cache/virtual/pager-0
index 3c20c36..1d7f97a 100644
--- a/metadata/md5-cache/virtual/pager-0
+++ b/metadata/md5-cache/virtual/pager-0
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for command-line pagers
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( sys-apps/less sys-apps/more sys-apps/most sys-apps/util-linux app-text/lv )
 SLOT=0
-_md5_=441ae1f1659778afa1b60f05d11e845e
+_md5_=2edb3a8b8aa14f5b6ed2397256eb1423
diff --git a/metadata/md5-cache/virtual/pam-0 b/metadata/md5-cache/virtual/pam-0
index f3253bd..4e1cc21 100644
--- a/metadata/md5-cache/virtual/pam-0
+++ b/metadata/md5-cache/virtual/pam-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for PAM (Pluggable Authentication Modules)
 EAPI=3
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~amd64-linux ~ia64-linux ~x86-linux
 RDEPEND=|| ( >=sys-libs/pam-0.78 sys-auth/openpam )
 SLOT=0
-_md5_=d60ebf8e7a0be8717b3dd26f87c46c14
+_md5_=9b5fc31b2eb18555cd0e29287adb5d94
diff --git a/metadata/md5-cache/virtual/perl-Compress-Raw-Bzip2-2.024 b/metadata/md5-cache/virtual/perl-Compress-Raw-Bzip2-2.024
index 860c364..99b7491 100644
--- a/metadata/md5-cache/virtual/perl-Compress-Raw-Bzip2-2.024
+++ b/metadata/md5-cache/virtual/perl-Compress-Raw-Bzip2-2.024
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Compress-Raw-Bzip2
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~perl-core/Compress-Raw-Bzip2-2.024 )
 SLOT=0
-_md5_=2e17acebb409beeb982c564463b3156f
+_md5_=443bd222d2f3ec27bbce1db1ba297768
diff --git a/metadata/md5-cache/virtual/perl-Compress-Raw-Zlib-2.024 b/metadata/md5-cache/virtual/perl-Compress-Raw-Zlib-2.024
index 0ccdda6..d3a7621 100644
--- a/metadata/md5-cache/virtual/perl-Compress-Raw-Zlib-2.024
+++ b/metadata/md5-cache/virtual/perl-Compress-Raw-Zlib-2.024
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Low-Level Interface to zlib compression library
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~perl-core/Compress-Raw-Zlib-2.024 )
 SLOT=0
-_md5_=1420bc7e3c0696aef8d91f241597f529
+_md5_=b50d24735765f6be59a9858245cd8484
diff --git a/metadata/md5-cache/virtual/perl-ExtUtils-CBuilder-0.27.03 b/metadata/md5-cache/virtual/perl-ExtUtils-CBuilder-0.27.03
index c9da33a..1ccb971 100644
--- a/metadata/md5-cache/virtual/perl-ExtUtils-CBuilder-0.27.03
+++ b/metadata/md5-cache/virtual/perl-ExtUtils-CBuilder-0.27.03
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Compile and link C code for Perl modules
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=~perl-core/ExtUtils-CBuilder-0.27.03
 SLOT=0
-_md5_=50834e7c1edd7dc3e7726fd542a1e98a
+_md5_=aab8816ff6ea14dc75465977ae8a7a73
diff --git a/metadata/md5-cache/virtual/perl-ExtUtils-ParseXS-2.22.05 b/metadata/md5-cache/virtual/perl-ExtUtils-ParseXS-2.22.05
index fc6bda1..051301e 100644
--- a/metadata/md5-cache/virtual/perl-ExtUtils-ParseXS-2.22.05
+++ b/metadata/md5-cache/virtual/perl-ExtUtils-ParseXS-2.22.05
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Converts Perl XS code into C code
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=~perl-core/ExtUtils-ParseXS-2.22.05
 SLOT=0
-_md5_=b612db7ecf72566c902b27b7cbfc62b4
+_md5_=eee0582c39d7a2f38d88d402f1ec6217
diff --git a/metadata/md5-cache/virtual/perl-File-Spec-3.31 b/metadata/md5-cache/virtual/perl-File-Spec-3.31
index bdfc736..1673843 100644
--- a/metadata/md5-cache/virtual/perl-File-Spec-3.31
+++ b/metadata/md5-cache/virtual/perl-File-Spec-3.31
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for File-Spec
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( ~dev-lang/perl-5.12.1 ~perl-core/File-Spec-3.31 )
 SLOT=0
-_md5_=b71cc9362833993f80b40081dda7f3d0
+_md5_=a4907bb154ef58c6c9aad69c58d0110b
diff --git a/metadata/md5-cache/virtual/perl-IO-Compress-2.024 b/metadata/md5-cache/virtual/perl-IO-Compress-2.024
index 71f8f88..2ebb0f6 100644
--- a/metadata/md5-cache/virtual/perl-IO-Compress-2.024
+++ b/metadata/md5-cache/virtual/perl-IO-Compress-2.024
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for IO-Compress
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~perl-core/IO-Compress-2.024 )
 SLOT=0
-_md5_=71223955d693a0cd2482200aec515997
+_md5_=37af1ae0192e44caebef8d346b946172
diff --git a/metadata/md5-cache/virtual/perl-IO-Zlib-1.100.0-r1 b/metadata/md5-cache/virtual/perl-IO-Zlib-1.100.0-r1
index 0643063..18a7de8 100644
--- a/metadata/md5-cache/virtual/perl-IO-Zlib-1.100.0-r1
+++ b/metadata/md5-cache/virtual/perl-IO-Zlib-1.100.0-r1
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for IO-Zlib
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( =dev-lang/perl-5.14* ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~perl-core/IO-Zlib-1.100.0 )
 SLOT=0
-_md5_=4c186cfd4c4203a7f4ba4a65ea670d57
+_md5_=0f018cc09cfb2b31613d83324aac3b18
diff --git a/metadata/md5-cache/virtual/perl-MIME-Base64-3.08 b/metadata/md5-cache/virtual/perl-MIME-Base64-3.08
index 7975f51..a0a331f 100644
--- a/metadata/md5-cache/virtual/perl-MIME-Base64-3.08
+++ b/metadata/md5-cache/virtual/perl-MIME-Base64-3.08
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for MIME-Base64
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~dev-lang/perl-5.10.1 ~perl-core/MIME-Base64-3.08 )
 SLOT=0
-_md5_=51963c8cba95144774a41dd42edbac40
+_md5_=b318c6d0a911a37c16819d465183c3ca
diff --git a/metadata/md5-cache/virtual/perl-Module-Build-0.36.07 b/metadata/md5-cache/virtual/perl-Module-Build-0.36.07
index 3722bdb..d224e0c 100644
--- a/metadata/md5-cache/virtual/perl-Module-Build-0.36.07
+++ b/metadata/md5-cache/virtual/perl-Module-Build-0.36.07
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Build and install Perl modules
-KEYWORDS=alpha amd64 arm hppa ia64 ~m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=~perl-core/Module-Build-0.36.07
 SLOT=0
-_md5_=a3a9da52d0f34e68bdf68bf5f304856e
+_md5_=a0d58d56e5c5d9d71b5234a12ed8aeec
diff --git a/metadata/md5-cache/virtual/perl-Package-Constants-0.20.0-r1 b/metadata/md5-cache/virtual/perl-Package-Constants-0.20.0-r1
index 518ad70..7840f81 100644
--- a/metadata/md5-cache/virtual/perl-Package-Constants-0.20.0-r1
+++ b/metadata/md5-cache/virtual/perl-Package-Constants-0.20.0-r1
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Package-Constants
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( =dev-lang/perl-5.14* ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~dev-lang/perl-5.10.1 ~perl-core/Package-Constants-0.20.0 )
 SLOT=0
-_md5_=a4b84077902110758225ee17bdcfcd41
+_md5_=216b790bc6fad9ca5c04149dee52d17b
diff --git a/metadata/md5-cache/virtual/perl-Scalar-List-Utils-1.230.0-r1 b/metadata/md5-cache/virtual/perl-Scalar-List-Utils-1.230.0-r1
index b78f47d..de0a530 100644
--- a/metadata/md5-cache/virtual/perl-Scalar-List-Utils-1.230.0-r1
+++ b/metadata/md5-cache/virtual/perl-Scalar-List-Utils-1.230.0-r1
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Scalar-List-Utils
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( =dev-lang/perl-5.14* ~perl-core/Scalar-List-Utils-1.230.0 )
 SLOT=0
-_md5_=b4342c994bf9817f4a4c29916506210e
+_md5_=076641f1add1b70c455d30373755e1ba
diff --git a/metadata/md5-cache/virtual/perl-Test-Harness-3.17 b/metadata/md5-cache/virtual/perl-Test-Harness-3.17
index 0edcaea..b1d9d08 100644
--- a/metadata/md5-cache/virtual/perl-Test-Harness-3.17
+++ b/metadata/md5-cache/virtual/perl-Test-Harness-3.17
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Test-Harness
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~dev-lang/perl-5.10.1 ~perl-core/Test-Harness-3.17 )
 SLOT=0
-_md5_=70d180807cf0f073383613fdd4303671
+_md5_=53261a900e9bbf630b2c07436c7e3f6a
diff --git a/metadata/md5-cache/virtual/perl-Test-Simple-0.980.0-r1 b/metadata/md5-cache/virtual/perl-Test-Simple-0.980.0-r1
index f31f2d1..f8e467f 100644
--- a/metadata/md5-cache/virtual/perl-Test-Simple-0.980.0-r1
+++ b/metadata/md5-cache/virtual/perl-Test-Simple-0.980.0-r1
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Test-Simple
-KEYWORDS=~alpha amd64 ~arm ~hppa ~ia64 ~m68k ~mips ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( =dev-lang/perl-5.14* ~perl-core/Test-Simple-0.980.0 )
 SLOT=0
-_md5_=ae048536f47807d08027b01c04d25518
+_md5_=3ace2d9d8cd151b43764cc3280818853
diff --git a/metadata/md5-cache/virtual/perl-digest-base-1.160.0-r1 b/metadata/md5-cache/virtual/perl-digest-base-1.160.0-r1
index fd6c28d..30f6c1c 100644
--- a/metadata/md5-cache/virtual/perl-digest-base-1.160.0-r1
+++ b/metadata/md5-cache/virtual/perl-digest-base-1.160.0-r1
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for digest-base
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( =dev-lang/perl-5.14* ~dev-lang/perl-5.12.4 ~dev-lang/perl-5.12.3 ~dev-lang/perl-5.12.2 ~dev-lang/perl-5.10.1 ~perl-core/digest-base-1.160.0 )
 SLOT=0
-_md5_=c8c04f30ef3fd85c0497307589390b04
+_md5_=5d30ac7df6b1012153454107af5a60ee
diff --git a/metadata/md5-cache/virtual/pkgconfig-0 b/metadata/md5-cache/virtual/pkgconfig-0
index cf98f97..6720488 100644
--- a/metadata/md5-cache/virtual/pkgconfig-0
+++ b/metadata/md5-cache/virtual/pkgconfig-0
@@ -2,7 +2,7 @@
 DEPEND=|| ( dev-util/pkgconfig dev-util/pkg-config-lite dev-util/pkgconf[pkg-config] dev-util/pkgconfig-openbsd[pkg-config] )
 DESCRIPTION=virtual for pkg-config
 EAPI=2
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~sparc-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 RDEPEND=|| ( dev-util/pkgconfig dev-util/pkg-config-lite dev-util/pkgconf[pkg-config] dev-util/pkgconfig-openbsd[pkg-config] )
 SLOT=0
-_md5_=1127274fa62c9bbeba3308c6eae8672d
+_md5_=ba35234d68c9703b6489fe53a837533c
diff --git a/metadata/md5-cache/virtual/python-argparse-0 b/metadata/md5-cache/virtual/python-argparse-0
index da58ee9..41fec59 100644
--- a/metadata/md5-cache/virtual/python-argparse-0
+++ b/metadata/md5-cache/virtual/python-argparse-0
@@ -2,9 +2,9 @@
 DESCRIPTION=A virtual for the Python argparse module
 EAPI=4
 IUSE=python_targets_python2_5 python_targets_python2_6 python_targets_python2_7 python_targets_python3_1 python_targets_python3_2 python_targets_python3_3 python_targets_pypy1_8 python_targets_pypy1_9 python_targets_jython2_5
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~sparc64-solaris ~x86-solaris
 RDEPEND=python_targets_python2_5? ( dev-python/argparse ) python_targets_python2_6? ( dev-python/argparse ) python_targets_jython2_5? ( dev-python/argparse )
 REQUIRED_USE=|| ( python_targets_python2_5 python_targets_python2_6 python_targets_python2_7 python_targets_python3_1 python_targets_python3_2 python_targets_python3_3 python_targets_pypy1_8 python_targets_pypy1_9 python_targets_jython2_5 )
 SLOT=0
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	python-r1	e8d8e8cfcf00614a58f2db821a59fa27	python-utils-r1	003399fd79dd7f27db6df90c2d78b3cb	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=7cf394ee8b8957855cf9dd5100559393
+_md5_=01104e5c663973e12545d21f3251dff6
diff --git a/metadata/md5-cache/virtual/ttf-fonts-1 b/metadata/md5-cache/virtual/ttf-fonts-1
index eee09ca..5d16cb8 100644
--- a/metadata/md5-cache/virtual/ttf-fonts-1
+++ b/metadata/md5-cache/virtual/ttf-fonts-1
@@ -1,6 +1,6 @@
 DEFINED_PHASES=-
 DESCRIPTION=Virtual for Serif/Sans/Monospace font packages
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~m68k-mint ~sparc-solaris ~x86-solaris
 RDEPEND=|| ( media-fonts/dejavu media-fonts/ttf-bitstream-vera media-fonts/liberation-fonts media-fonts/droid media-fonts/freefont-ttf media-fonts/corefonts )
 SLOT=0
-_md5_=b7fe45d4cf138076f63de8eefe2a6c14
+_md5_=01d91cc4fdecf9cbbfe0f7ffcdc04a17
diff --git a/metadata/md5-cache/virtual/udev-171 b/metadata/md5-cache/virtual/udev-171
index 185d22c..2ba0aa4 100644
--- a/metadata/md5-cache/virtual/udev-171
+++ b/metadata/md5-cache/virtual/udev-171
@@ -2,7 +2,7 @@
 DESCRIPTION=Virtual for udev implementation and number of its features
 EAPI=2
 IUSE=gudev hwdb introspection keymap +kmod selinux static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86
 RDEPEND=~sys-fs/udev-171[gudev?,hwdb?,introspection?,keymap?,selinux?]
 SLOT=0
-_md5_=c9f618d9783eaa9b10aea168ad8626d5
+_md5_=511c1879aa58f6457df54c2ff52c1c71
diff --git a/metadata/md5-cache/virtual/yacc-0 b/metadata/md5-cache/virtual/yacc-0
index d4d2dde..f31d1e1 100644
--- a/metadata/md5-cache/virtual/yacc-0
+++ b/metadata/md5-cache/virtual/yacc-0
@@ -1,7 +1,7 @@
 DEFINED_PHASES=-
 DEPEND=|| ( sys-devel/bison dev-util/yacc )
 DESCRIPTION=virtual for yacc (yet another compiler compiler)
-KEYWORDS=alpha amd64 arm hppa ia64 m68k ~mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 m68k mips ppc ppc64 s390 sh sparc x86 ~sparc-fbsd ~x86-fbsd
 RDEPEND=|| ( sys-devel/bison dev-util/yacc )
 SLOT=0
-_md5_=4efecb7131ff78aeecdf63a98db0e43c
+_md5_=5645f38e92e2e76874d54982dc54136c
diff --git a/metadata/md5-cache/x11-apps/iceauth-1.0.4 b/metadata/md5-cache/x11-apps/iceauth-1.0.4
index ad2ea68..4d01bf0 100644
--- a/metadata/md5-cache/x11-apps/iceauth-1.0.4
+++ b/metadata/md5-cache/x11-apps/iceauth-1.0.4
@@ -3,10 +3,10 @@
 DESCRIPTION=ICE authority file utility
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libICE
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/iceauth-1.0.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=5a55cdda86f471a257af57cd51918436
+_md5_=605233d3b9ea6def9044be81c5b44455
diff --git a/metadata/md5-cache/x11-apps/mesa-progs-8.0.1 b/metadata/md5-cache/x11-apps/mesa-progs-8.0.1
index f8735d1..775c908 100644
--- a/metadata/md5-cache/x11-apps/mesa-progs-8.0.1
+++ b/metadata/md5-cache/x11-apps/mesa-progs-8.0.1
@@ -3,10 +3,10 @@
 DESCRIPTION=Mesa's OpenGL utility and demo programs (glxgears and glxinfo)
 EAPI=3
 HOMEPAGE=http://mesa3d.sourceforge.net/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux
 LICENSE=LGPL-2
 RDEPEND=virtual/opengl
 SLOT=0
 SRC_URI=ftp://ftp.freedesktop.org/pub/mesa/demos/8.0.1/mesa-demos-8.0.1.tar.bz2
 _eclasses_=multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c
-_md5_=1f3ab0757e249258a284af835191d7a1
+_md5_=c216e1561386d8bd6851989f49d4abee
diff --git a/metadata/md5-cache/x11-apps/mkfontdir-1.0.6 b/metadata/md5-cache/x11-apps/mkfontdir-1.0.6
index a6624eb..f9454b2 100644
--- a/metadata/md5-cache/x11-apps/mkfontdir-1.0.6
+++ b/metadata/md5-cache/x11-apps/mkfontdir-1.0.6
@@ -3,10 +3,10 @@
 DESCRIPTION=create an index of X font files in a directory
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-apps/mkfontscale
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/mkfontdir-1.0.6.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=db4dd882c62f76714476f0f5236c7e5e
+_md5_=af1413772a572dd55130a401a62acb39
diff --git a/metadata/md5-cache/x11-apps/mkfontscale-1.0.7 b/metadata/md5-cache/x11-apps/mkfontscale-1.0.7
index 80db97e..1e74b50 100644
--- a/metadata/md5-cache/x11-apps/mkfontscale-1.0.7
+++ b/metadata/md5-cache/x11-apps/mkfontscale-1.0.7
@@ -3,10 +3,10 @@
 DESCRIPTION=create an index of scalable font files for X
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=debug
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libfontenc =media-libs/freetype-2* !<=x11-base/xorg-x11-6.9
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/mkfontscale-1.0.7.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	x-modular	9f4ee0c44a3a3b7ecdf52cefc1e10280
-_md5_=8cb475cb4cbaabe0ec1b049f4439ec20
+_md5_=54cc10c79e4339fa3d78e600600eb1b2
diff --git a/metadata/md5-cache/x11-apps/rgb-1.0.4 b/metadata/md5-cache/x11-apps/rgb-1.0.4
index a710f64..53d328b 100644
--- a/metadata/md5-cache/x11-apps/rgb-1.0.4
+++ b/metadata/md5-cache/x11-apps/rgb-1.0.4
@@ -3,9 +3,9 @@
 DESCRIPTION=uncompile an rgb color-name database
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/rgb-1.0.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=80336dcba27598231f867dd6dca2c8cf
+_md5_=4546f88b31061ba479b28cc41c3804e6
diff --git a/metadata/md5-cache/x11-apps/setxkbmap-1.2.0 b/metadata/md5-cache/x11-apps/setxkbmap-1.2.0
index 306f3b1..ed9e9ba 100644
--- a/metadata/md5-cache/x11-apps/setxkbmap-1.2.0
+++ b/metadata/md5-cache/x11-apps/setxkbmap-1.2.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Controls the keyboard layout of a running X server.
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=MIT
 RDEPEND=x11-libs/libxkbfile x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/setxkbmap-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=4709fb56b6aac63f940e6d16d3b4f44f
+_md5_=efb671b182af1ee4340a4551206cac58
diff --git a/metadata/md5-cache/x11-apps/xauth-1.0.6 b/metadata/md5-cache/x11-apps/xauth-1.0.6
index 37af012..bc0fe06 100644
--- a/metadata/md5-cache/x11-apps/xauth-1.0.6
+++ b/metadata/md5-cache/x11-apps/xauth-1.0.6
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=ipv6
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXau x11-libs/libXext x11-libs/libXmu
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xauth-1.0.6.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=774611d3f78c2e2160f801bccebf0989
+_md5_=242f13c59885ce9d2ebe3e6b2b021c88
diff --git a/metadata/md5-cache/x11-apps/xcursorgen-1.0.4 b/metadata/md5-cache/x11-apps/xcursorgen-1.0.4
index 1ea47fe..b990bf0 100644
--- a/metadata/md5-cache/x11-apps/xcursorgen-1.0.4
+++ b/metadata/md5-cache/x11-apps/xcursorgen-1.0.4
@@ -3,10 +3,10 @@
 DESCRIPTION=create an X cursor file from a collection of PNG images
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=media-libs/libpng x11-libs/libX11 x11-libs/libXcursor
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xcursorgen-1.0.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=c1399a9e32e72b08fb8e38cd2933f6d3
+_md5_=4843e242940bb39965175215d79acdb4
diff --git a/metadata/md5-cache/x11-apps/xdpyinfo-1.3.0 b/metadata/md5-cache/x11-apps/xdpyinfo-1.3.0
index d2f4ded..84ef97d 100644
--- a/metadata/md5-cache/x11-apps/xdpyinfo-1.3.0
+++ b/metadata/md5-cache/x11-apps/xdpyinfo-1.3.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=dga dmx xinerama
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~sparc-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~sparc-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXcomposite x11-libs/libXext x11-libs/libXi x11-libs/libXrender x11-libs/libXtst x11-libs/libXxf86vm x11-libs/libxcb dga? ( x11-libs/libXxf86dga ) dmx? ( x11-libs/libdmx ) xinerama? ( x11-libs/libXinerama )
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xdpyinfo-1.3.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=4e8e36ecb742b1cd1169866024284cee
+_md5_=34004e15d913060bb57544f71e252bbf
diff --git a/metadata/md5-cache/x11-apps/xdriinfo-1.0.4 b/metadata/md5-cache/x11-apps/xdriinfo-1.0.4
index 9fe7c24..59d65fd 100644
--- a/metadata/md5-cache/x11-apps/xdriinfo-1.0.4
+++ b/metadata/md5-cache/x11-apps/xdriinfo-1.0.4
@@ -3,10 +3,10 @@
 DESCRIPTION=query configuration information of DRI drivers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 virtual/opengl
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xdriinfo-1.0.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=17fc27666168d578760e35ecf0f3984a
+_md5_=38980b5c4c0bfd30b2d8326a3ad83364
diff --git a/metadata/md5-cache/x11-apps/xev-1.2.0 b/metadata/md5-cache/x11-apps/xev-1.2.0
index 11911aa..255baf3 100644
--- a/metadata/md5-cache/x11-apps/xev-1.2.0
+++ b/metadata/md5-cache/x11-apps/xev-1.2.0
@@ -3,10 +3,10 @@
 DESCRIPTION=print contents of X events
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXrandr
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xev-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=6de4ea717ccd207ce964f46234c4b511
+_md5_=cbcf9fdc61a116b697f40b85e022987a
diff --git a/metadata/md5-cache/x11-apps/xhost-1.0.4 b/metadata/md5-cache/x11-apps/xhost-1.0.4
index 497db6d..cc5b11d 100644
--- a/metadata/md5-cache/x11-apps/xhost-1.0.4
+++ b/metadata/md5-cache/x11-apps/xhost-1.0.4
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=ipv6
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXmu x11-libs/libXau
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xhost-1.0.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=ded148184b0a111ed54a2f5468b8b800
+_md5_=5dfe67ef64000847b30f79d0339c1568
diff --git a/metadata/md5-cache/x11-apps/xinput-1.6.0 b/metadata/md5-cache/x11-apps/xinput-1.6.0
index 83cf2c0..40c1240 100644
--- a/metadata/md5-cache/x11-apps/xinput-1.6.0
+++ b/metadata/md5-cache/x11-apps/xinput-1.6.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Utility to set XInput device parameters
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ppc ppc64 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~amd64-fbsd ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=x11-libs/libX11-1.3 x11-libs/libXext >=x11-libs/libXi-1.5.99.1 x11-libs/libXinerama
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xinput-1.6.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=2f3f8f877e76ddc49174c19cec4744d3
+_md5_=1f9e016b93ca97d80ba7a3dbac45506a
diff --git a/metadata/md5-cache/x11-apps/xkbcomp-1.2.3 b/metadata/md5-cache/x11-apps/xkbcomp-1.2.3
index 1495711..5a27b5d 100644
--- a/metadata/md5-cache/x11-apps/xkbcomp-1.2.3
+++ b/metadata/md5-cache/x11-apps/xkbcomp-1.2.3
@@ -3,10 +3,10 @@
 DESCRIPTION=compile XKB keyboard description
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libxkbfile
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xkbcomp-1.2.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=9d699bb34a042aa5bbdcbd3bcf982ed5
+_md5_=0c29500d93d0c149811849e6b4321329
diff --git a/metadata/md5-cache/x11-apps/xlsatoms-1.1.0 b/metadata/md5-cache/x11-apps/xlsatoms-1.1.0
index 340ede4..c930ea1 100644
--- a/metadata/md5-cache/x11-apps/xlsatoms-1.1.0
+++ b/metadata/md5-cache/x11-apps/xlsatoms-1.1.0
@@ -3,10 +3,10 @@
 DESCRIPTION=list interned atoms defined on server
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=x11-libs/libxcb
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xlsatoms-1.1.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=6bed074ae4d8962ad8ff26f1841a9e9c
+_md5_=98a66dfb43db0088d8bcb7dae83905c6
diff --git a/metadata/md5-cache/x11-apps/xlsclients-1.1.2 b/metadata/md5-cache/x11-apps/xlsclients-1.1.2
index 86c5331..ab8e4df 100644
--- a/metadata/md5-cache/x11-apps/xlsclients-1.1.2
+++ b/metadata/md5-cache/x11-apps/xlsclients-1.1.2
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org xlsclients application
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=x11-libs/libxcb-1.7 >=x11-libs/xcb-util-0.3.8
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xlsclients-1.1.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=211be1116cc5980d88a9e36362c6a192
+_md5_=14e1795aff5858c413f504da70441e51
diff --git a/metadata/md5-cache/x11-apps/xmodmap-1.0.5 b/metadata/md5-cache/x11-apps/xmodmap-1.0.5
index 6ffc720..511e180 100644
--- a/metadata/md5-cache/x11-apps/xmodmap-1.0.5
+++ b/metadata/md5-cache/x11-apps/xmodmap-1.0.5
@@ -3,10 +3,10 @@
 DESCRIPTION=utility for modifying keymaps and pointer button mappings in X
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xmodmap-1.0.5.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=37bb6f9f7e07efb3f370ade52673881e
+_md5_=7d413eec552b84743fc618f6278e7215
diff --git a/metadata/md5-cache/x11-apps/xprop-1.2.1 b/metadata/md5-cache/x11-apps/xprop-1.2.1
index 67e38fe..a303450 100644
--- a/metadata/md5-cache/x11-apps/xprop-1.2.1
+++ b/metadata/md5-cache/x11-apps/xprop-1.2.1
@@ -3,10 +3,10 @@
 DESCRIPTION=property displayer for X
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xprop-1.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=40db7abde8954cb8685eefa189c32c14
+_md5_=6b508ba95845c19969a8ee5ad3477a3c
diff --git a/metadata/md5-cache/x11-apps/xrandr-1.3.5 b/metadata/md5-cache/x11-apps/xrandr-1.3.5
index 585b646..c7f57a7 100644
--- a/metadata/md5-cache/x11-apps/xrandr-1.3.5
+++ b/metadata/md5-cache/x11-apps/xrandr-1.3.5
@@ -3,10 +3,10 @@
 DESCRIPTION=primitive command line interface to RandR extension
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=MIT
 RDEPEND=>=x11-libs/libXrandr-1.3 x11-libs/libXrender x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xrandr-1.3.5.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=f43d2f417da10604e6674016abff6d09
+_md5_=86844e611c5799c9b1600cacc092c7ca
diff --git a/metadata/md5-cache/x11-apps/xrdb-1.0.9 b/metadata/md5-cache/x11-apps/xrdb-1.0.9
index 67a2826..1cd4752 100644
--- a/metadata/md5-cache/x11-apps/xrdb-1.0.9
+++ b/metadata/md5-cache/x11-apps/xrdb-1.0.9
@@ -3,10 +3,10 @@
 DESCRIPTION=X server resource database utility
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libXmu x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xrdb-1.0.9.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=2d2bd593b16f751c85ce28ea654590f9
+_md5_=cb479512feca10c0370dcfca3551dd5b
diff --git a/metadata/md5-cache/x11-apps/xset-1.2.2 b/metadata/md5-cache/x11-apps/xset-1.2.2
index 22fe0b6..198405b 100644
--- a/metadata/md5-cache/x11-apps/xset-1.2.2
+++ b/metadata/md5-cache/x11-apps/xset-1.2.2
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org xset application
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXmu x11-libs/libXext
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xset-1.2.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=e013d60c2eecfb61465dc5184b3ab856
+_md5_=bdfea7e41e44a5064a06838e2d3f042f
diff --git a/metadata/md5-cache/x11-apps/xsetroot-1.1.0 b/metadata/md5-cache/x11-apps/xsetroot-1.1.0
index 80af8b7..9d294f1 100644
--- a/metadata/md5-cache/x11-apps/xsetroot-1.1.0
+++ b/metadata/md5-cache/x11-apps/xsetroot-1.1.0
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org xsetroot application
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux
 LICENSE=MIT
 RDEPEND=x11-libs/libXmu x11-libs/libX11 x11-misc/xbitmaps x11-libs/libXcursor
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xsetroot-1.1.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=56f1e434b4f1262572e611be7f98621e
+_md5_=318d11a1fc2d0079ebe673f24fdad635
diff --git a/metadata/md5-cache/x11-apps/xwd-1.0.4 b/metadata/md5-cache/x11-apps/xwd-1.0.4
index a111b7f..7a6a781 100644
--- a/metadata/md5-cache/x11-apps/xwd-1.0.4
+++ b/metadata/md5-cache/x11-apps/xwd-1.0.4
@@ -3,10 +3,10 @@
 DESCRIPTION=dump an image of an X window
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xwd-1.0.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=8f1834e447c8f8beaae104b8103f619e
+_md5_=7e17f1db4e39fbd2358888fea88f038d
diff --git a/metadata/md5-cache/x11-apps/xwininfo-1.1.2 b/metadata/md5-cache/x11-apps/xwininfo-1.1.2
index e4b0ea1..f96ae0e 100644
--- a/metadata/md5-cache/x11-apps/xwininfo-1.1.2
+++ b/metadata/md5-cache/x11-apps/xwininfo-1.1.2
@@ -3,10 +3,10 @@
 DESCRIPTION=window information utility for X
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-libs/libxcb-1.6
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/app/xwininfo-1.1.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=3e6b7c04b165e2f1917c01ed6e97baf4
+_md5_=79db81494c3372a83885af3c1aecd004
diff --git a/metadata/md5-cache/x11-drivers/xf86-input-keyboard-1.6.0 b/metadata/md5-cache/x11-drivers/xf86-input-keyboard-1.6.0
index abe10a5..ecd4a97 100644
--- a/metadata/md5-cache/x11-drivers/xf86-input-keyboard-1.6.0
+++ b/metadata/md5-cache/x11-drivers/xf86-input-keyboard-1.6.0
@@ -3,10 +3,10 @@
 DESCRIPTION=Keyboard input driver
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ppc ppc64 ~sh ~sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=x11-base/xorg-server-1.6.3 x11-base/xorg-server[xorg]
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/driver/xf86-input-keyboard-1.6.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=e9c40d405ee97b8bea3bda3fddff33be
+_md5_=11bb31115bc7902e0434b99f06760f92
diff --git a/metadata/md5-cache/x11-drivers/xf86-input-mouse-1.7.1 b/metadata/md5-cache/x11-drivers/xf86-input-mouse-1.7.1
index f3b59cd..5e045d6 100644
--- a/metadata/md5-cache/x11-drivers/xf86-input-mouse-1.7.1
+++ b/metadata/md5-cache/x11-drivers/xf86-input-mouse-1.7.1
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org driver for mouse input devices
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=x11-base/xorg-server-1.5.99.901 x11-base/xorg-server[xorg]
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/driver/xf86-input-mouse-1.7.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=29083de5c3f9aab7589528a1ce4c9c74
+_md5_=dfdd6d217c207b5b546e4db0a81d57cb
diff --git a/metadata/md5-cache/x11-drivers/xf86-input-synaptics-1.6.2 b/metadata/md5-cache/x11-drivers/xf86-input-synaptics-1.6.2
index c37976d..0478761 100644
--- a/metadata/md5-cache/x11-drivers/xf86-input-synaptics-1.6.2
+++ b/metadata/md5-cache/x11-drivers/xf86-input-synaptics-1.6.2
@@ -3,10 +3,10 @@
 DESCRIPTION=Driver for Synaptics touchpads
 EAPI=4
 HOMEPAGE=http://cgit.freedesktop.org/xorg/driver/xf86-input-synaptics/
-KEYWORDS=amd64 arm ~mips ppc ppc64 x86
+KEYWORDS=amd64 arm mips ppc ppc64 x86
 LICENSE=MIT
 RDEPEND=sys-libs/mtdev >=x11-base/xorg-server-1.8 >=x11-libs/libXi-1.2 >=x11-libs/libXtst-1.1.0 x11-base/xorg-server[xorg]
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/driver/xf86-input-synaptics-1.6.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=3cc647b88d2206b88a0d66232bf743b5
+_md5_=aa7547b77d0023fa5fa40f2e793f9d4d
diff --git a/metadata/md5-cache/x11-drivers/xf86-video-ati-6.14.4 b/metadata/md5-cache/x11-drivers/xf86-video-ati-6.14.4
index 0d14c29..f0a0f4e 100644
--- a/metadata/md5-cache/x11-drivers/xf86-video-ati-6.14.4
+++ b/metadata/md5-cache/x11-drivers/xf86-video-ati-6.14.4
@@ -3,10 +3,10 @@
 DESCRIPTION=ATI video driver
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha amd64 ~ia64 ~ppc ~ppc64 ~sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 ia64 ppc ppc64 sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=x11-libs/libdrm-2.4.31[video_cards_radeon] x11-base/xorg-server[-minimal] x11-libs/libdrm x11-base/xorg-server[xorg] x11-libs/libpciaccess
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/driver/xf86-video-ati-6.14.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=3814a7ea5d6fa002d97a01fda2bcb953
+_md5_=3961bf68b1446527c66b8c7f155d3aab
diff --git a/metadata/md5-cache/x11-drivers/xf86-video-fbdev-0.4.1 b/metadata/md5-cache/x11-drivers/xf86-video-fbdev-0.4.1
index f20a902..6a8b463 100644
--- a/metadata/md5-cache/x11-drivers/xf86-video-fbdev-0.4.1
+++ b/metadata/md5-cache/x11-drivers/xf86-video-fbdev-0.4.1
@@ -3,10 +3,10 @@
 DESCRIPTION=video driver for framebuffer device
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=debug
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd
 LICENSE=MIT
 RDEPEND=>=x11-base/xorg-server-1.0.99 !<=x11-base/xorg-x11-6.9
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/driver/xf86-video-fbdev-0.4.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	x-modular	9f4ee0c44a3a3b7ecdf52cefc1e10280
-_md5_=919552cf49d2d15524afe557a777200c
+_md5_=b8aab580fb379498958b069d15ce7924
diff --git a/metadata/md5-cache/x11-drivers/xf86-video-nouveau-0.0.16_pre20120508 b/metadata/md5-cache/x11-drivers/xf86-video-nouveau-0.0.16_pre20120508
index 56127c1..a95a1e6 100644
--- a/metadata/md5-cache/x11-drivers/xf86-video-nouveau-0.0.16_pre20120508
+++ b/metadata/md5-cache/x11-drivers/xf86-video-nouveau-0.0.16_pre20120508
@@ -3,10 +3,10 @@
 DESCRIPTION=Accelerated Open Source driver for nVidia cards
 EAPI=4
 HOMEPAGE=http://nouveau.freedesktop.org/
-KEYWORDS=amd64 ppc ~ppc64 x86
+KEYWORDS=amd64 ppc ppc64 x86
 LICENSE=MIT
 RDEPEND=>=x11-libs/libdrm-2.4.34[video_cards_nouveau] x11-base/xorg-server[-minimal] x11-libs/libdrm x11-base/xorg-server[xorg] x11-libs/libpciaccess
 SLOT=0
 SRC_URI=mirror://gentoo/xf86-video-nouveau-0.0.16_pre20120508.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	linux-info	923a15fa2808bce496fb21a26482e53a	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=e0541d996893c1d057be2f88ad8480be
+_md5_=ceb62410e7dd12ee76f3df58e6e98549
diff --git a/metadata/md5-cache/x11-libs/cairo-1.12.12 b/metadata/md5-cache/x11-libs/cairo-1.12.12
index 9ae3e92..852041e 100644
--- a/metadata/md5-cache/x11-libs/cairo-1.12.12
+++ b/metadata/md5-cache/x11-libs/cairo-1.12.12
@@ -4,7 +4,7 @@
 EAPI=4
 HOMEPAGE=http://cairographics.org/
 IUSE=X aqua debug directfb doc drm gallium +glib legacy-drivers opengl openvg qt4 static-libs +svg xcb
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=|| ( LGPL-2.1 MPL-1.1 )
 RDEPEND=media-libs/fontconfig media-libs/freetype:2 media-libs/libpng:0 sys-libs/zlib >=x11-libs/pixman-0.28.0 directfb? ( dev-libs/DirectFB ) glib? ( >=dev-libs/glib-2.28.6:2 ) opengl? ( || ( media-libs/mesa[egl] media-libs/opengl-apple ) ) openvg? ( media-libs/mesa[openvg] ) qt4? ( >=dev-qt/qtgui-4.8:4 ) X? ( >=x11-libs/libXrender-0.6 x11-libs/libXext x11-libs/libX11 drm? ( >=virtual/udev-136 gallium? ( media-libs/mesa[gallium] ) ) ) xcb? ( x11-libs/libxcb x11-libs/xcb-util )
 REQUIRED_USE=drm? ( X ) gallium? ( drm )
@@ -12,4 +12,4 @@
 SLOT=0
 SRC_URI=http://cairographics.org/releases/cairo-1.12.12.tar.xz
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=ec23444ccf9eb249124be3181cd52f8d
+_md5_=1c8e7e8d0ce956db492375869f08987e
diff --git a/metadata/md5-cache/x11-libs/gdk-pixbuf-2.22.1-r2 b/metadata/md5-cache/x11-libs/gdk-pixbuf-2.22.1-r2
index 2e42e24..028fba8 100644
--- a/metadata/md5-cache/x11-libs/gdk-pixbuf-2.22.1-r2
+++ b/metadata/md5-cache/x11-libs/gdk-pixbuf-2.22.1-r2
@@ -4,11 +4,11 @@
 EAPI=3
 HOMEPAGE=http://www.gtk.org/
 IUSE=+X debug doc +introspection jpeg jpeg2k svg tiff test
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=LGPL-2
 PDEPEND=svg? ( gnome-base/librsvg )
 RDEPEND=>=dev-libs/glib-2.25.15 >=media-libs/libpng-1.2.44 introspection? ( >=dev-libs/gobject-introspection-0.9.3 ) jpeg? ( virtual/jpeg ) jpeg2k? ( media-libs/jasper ) tiff? ( >=media-libs/tiff-3.9.2 ) X? ( x11-libs/libX11 ) !<gnome-base/gail-1000 !<gnome-base/librsvg-2.31.0 !<x11-libs/gtk+-2.21.3:2 !<x11-libs/gtk+-2.90.4:3
 SLOT=2
 SRC_URI=mirror://gnome/sources/gdk-pixbuf/2.22/gdk-pixbuf-2.22.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	gnome.org	8fef8f967214f56e08fa92d61163d891	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed
-_md5_=a3f790a5e0f8e2c4a6992e51a910903d
+_md5_=d26abeed90b26ffb0479f56fffed521b
diff --git a/metadata/md5-cache/x11-libs/gtk+-2.18.7 b/metadata/md5-cache/x11-libs/gtk+-2.18.7
index 448b872..3dc42f4 100644
--- a/metadata/md5-cache/x11-libs/gtk+-2.18.7
+++ b/metadata/md5-cache/x11-libs/gtk+-2.18.7
@@ -4,11 +4,11 @@
 EAPI=2
 HOMEPAGE=http://www.gtk.org/
 IUSE=aqua cups debug doc jpeg jpeg2k tiff test vim-syntax xinerama test
-KEYWORDS=~alpha amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~sh ~sparc ~x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 ~arm hppa ia64 mips ppc ppc64 sh sparc ~x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=LGPL-2
 PDEPEND=vim-syntax? ( app-vim/gtk-syntax )
 RDEPEND=!aqua? ( x11-libs/libXrender x11-libs/libX11 x11-libs/libXi x11-libs/libXt x11-libs/libXext >=x11-libs/libXrandr-1.2 x11-libs/libXcursor x11-libs/libXfixes x11-libs/libXcomposite x11-libs/libXdamage >=x11-libs/cairo-1.6[X,svg] ) aqua? ( >=x11-libs/cairo-1.6[aqua,svg] ) xinerama? ( x11-libs/libXinerama ) >=dev-libs/glib-2.21.3 >=x11-libs/pango-1.20 >=dev-libs/atk-1.13 media-libs/fontconfig x11-misc/shared-mime-info >=media-libs/libpng-1.2.1 cups? ( net-print/cups ) jpeg? ( >=media-libs/jpeg-6b-r2:0 ) jpeg2k? ( media-libs/jasper ) tiff? ( >=media-libs/tiff-3.5.7 ) !<gnome-base/gail-1000
 SLOT=2
 SRC_URI=mirror://gnome/sources/gtk+/2.18/gtk+-2.18.7.tar.bz2
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	gnome.org	8fef8f967214f56e08fa92d61163d891	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	virtualx	e9162f65645513120b4e12863a5fa972
-_md5_=26e31ef1291dbbfe49cf11eed702d098
+_md5_=be0c04bc382e5e1d37424b0cee0bbdbf
diff --git a/metadata/md5-cache/x11-libs/libICE-1.0.7 b/metadata/md5-cache/x11-libs/libICE-1.0.7
index 4fef883..515fd7a 100644
--- a/metadata/md5-cache/x11-libs/libICE-1.0.7
+++ b/metadata/md5-cache/x11-libs/libICE-1.0.7
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc ipv6 static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/xtrans x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libICE-1.0.7.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=8deca2fe3d2137c9b30b7df999c7bc18
+_md5_=bff0ac32bcb010a0c2592adfb9812684
diff --git a/metadata/md5-cache/x11-libs/libSM-1.2.0 b/metadata/md5-cache/x11-libs/libSM-1.2.0
index bba0d4f..529f3fa 100644
--- a/metadata/md5-cache/x11-libs/libSM-1.2.0
+++ b/metadata/md5-cache/x11-libs/libSM-1.2.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc ipv6 +uuid static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-libs/libICE-1.0.5 x11-libs/xtrans x11-proto/xproto !elibc_FreeBSD? ( !elibc_IRIX? ( !elibc_SunOS? ( uuid? ( >=sys-apps/util-linux-2.16 ) ) ) )
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libSM-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=86b9f8c65e52233aa2c01aefed85d768
+_md5_=b3eef95903d161052959ad7a0f047b04
diff --git a/metadata/md5-cache/x11-libs/libX11-1.6.0 b/metadata/md5-cache/x11-libs/libX11-1.6.0
index eeaa2b7..4789c5e 100644
--- a/metadata/md5-cache/x11-libs/libX11-1.6.0
+++ b/metadata/md5-cache/x11-libs/libX11-1.6.0
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=ipv6 test static-libs doc
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-libs/libxcb-1.8.1 x11-libs/xtrans >=x11-proto/xproto-7.0.17 x11-proto/xf86bigfontproto x11-proto/inputproto x11-proto/kbproto x11-proto/xextproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libX11-1.6.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=6171a670f8eb11ee35878ae6dc019f41
+_md5_=6f1f0c6f63c2e5d781859a1207f0c60d
diff --git a/metadata/md5-cache/x11-libs/libXScrnSaver-1.2.1 b/metadata/md5-cache/x11-libs/libXScrnSaver-1.2.1
index 5a0bf9b..cb1a4fb 100644
--- a/metadata/md5-cache/x11-libs/libXScrnSaver-1.2.1
+++ b/metadata/md5-cache/x11-libs/libXScrnSaver-1.2.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXext >=x11-proto/scrnsaverproto-1.2
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXScrnSaver-1.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=3adc0bcce26824512d68653a49888e05
+_md5_=dd71ea0d1a2c3c5f0258345631f800b7
diff --git a/metadata/md5-cache/x11-libs/libXau-1.0.6 b/metadata/md5-cache/x11-libs/libXau-1.0.6
index 7eb506a..c07db82 100644
--- a/metadata/md5-cache/x11-libs/libXau-1.0.6
+++ b/metadata/md5-cache/x11-libs/libXau-1.0.6
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXau-1.0.6.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=9fb05282fdf0245aad39d0801a8589fe
+_md5_=e708a27fa94d6cb456269e5b46e179a6
diff --git a/metadata/md5-cache/x11-libs/libXaw-1.0.9 b/metadata/md5-cache/x11-libs/libXaw-1.0.9
index 742b906..83c9cde 100644
--- a/metadata/md5-cache/x11-libs/libXaw-1.0.9
+++ b/metadata/md5-cache/x11-libs/libXaw-1.0.9
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXext x11-libs/libXt x11-libs/libXmu x11-libs/libXpm x11-proto/xproto x11-proto/xextproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXaw-1.0.9.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=f342ff9a9b8c1b1cd2d6b4ad5ff2426b
+_md5_=f88bd082d5a12c5f74fd0f8cb5607503
diff --git a/metadata/md5-cache/x11-libs/libXcursor-1.1.14 b/metadata/md5-cache/x11-libs/libXcursor-1.1.14
index f3df634..06a4c56 100644
--- a/metadata/md5-cache/x11-libs/libXcursor-1.1.14
+++ b/metadata/md5-cache/x11-libs/libXcursor-1.1.14
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=>=x11-libs/libXrender-0.8.2 x11-libs/libXfixes x11-libs/libX11
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXcursor-1.1.14.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=09d89e64ca493bfacf03f2cfcf594bb9
+_md5_=8e9d9f4f262b5c0ff5f4e7d576a1bd34
diff --git a/metadata/md5-cache/x11-libs/libXdamage-1.1.3 b/metadata/md5-cache/x11-libs/libXdamage-1.1.3
index 53de05c..cc05608 100644
--- a/metadata/md5-cache/x11-libs/libXdamage-1.1.3
+++ b/metadata/md5-cache/x11-libs/libXdamage-1.1.3
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXfixes >=x11-proto/damageproto-1.1 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXdamage-1.1.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=38276451b0953760ba2be53ebc371386
+_md5_=f434bf967148cab9ce7382fb80509211
diff --git a/metadata/md5-cache/x11-libs/libXdmcp-1.1.0 b/metadata/md5-cache/x11-libs/libXdmcp-1.1.0
index 3a9d15d..f9c51b6 100644
--- a/metadata/md5-cache/x11-libs/libXdmcp-1.1.0
+++ b/metadata/md5-cache/x11-libs/libXdmcp-1.1.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXdmcp-1.1.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=1e9940b102689d4e135888c24132c3bc
+_md5_=08cb3e08107536ed46f6967e670c23fc
diff --git a/metadata/md5-cache/x11-libs/libXext-1.3.2 b/metadata/md5-cache/x11-libs/libXext-1.3.2
index 00d0855..036c008 100644
--- a/metadata/md5-cache/x11-libs/libXext-1.3.2
+++ b/metadata/md5-cache/x11-libs/libXext-1.3.2
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs doc
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-libs/libX11-1.2 >=x11-proto/xextproto-7.1.99
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXext-1.3.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=1ee302e3fafcae0ce12a587872a566cb
+_md5_=0d40b2f17aab3bdfb575dc30b17d13ac
diff --git a/metadata/md5-cache/x11-libs/libXfixes-5.0.1 b/metadata/md5-cache/x11-libs/libXfixes-5.0.1
index 19263e4..a50669d 100644
--- a/metadata/md5-cache/x11-libs/libXfixes-5.0.1
+++ b/metadata/md5-cache/x11-libs/libXfixes-5.0.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 >=x11-proto/fixesproto-5 x11-proto/xproto x11-proto/xextproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXfixes-5.0.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=1b07bfef6021c6f5649f8f2f408cb129
+_md5_=72d57a7a23a85b2e04f84b4f6c203551
diff --git a/metadata/md5-cache/x11-libs/libXfont-1.4.4 b/metadata/md5-cache/x11-libs/libXfont-1.4.4
index ec69f23..7468e15 100644
--- a/metadata/md5-cache/x11-libs/libXfont-1.4.4
+++ b/metadata/md5-cache/x11-libs/libXfont-1.4.4
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=ipv6 static-libs doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/xtrans x11-libs/libfontenc >=media-libs/freetype-2 app-arch/bzip2 x11-proto/xproto x11-proto/fontsproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXfont-1.4.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=86db6b16606392085b377b4a7040a75e
+_md5_=87fb65c46440198f8d8a7f75db131d30
diff --git a/metadata/md5-cache/x11-libs/libXft-2.2.0 b/metadata/md5-cache/x11-libs/libXft-2.2.0
index fd2acf0..d31e5fd 100644
--- a/metadata/md5-cache/x11-libs/libXft-2.2.0
+++ b/metadata/md5-cache/x11-libs/libXft-2.2.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-libs/libXrender-0.8.2 x11-libs/libX11 x11-libs/libXext media-libs/freetype media-libs/fontconfig x11-proto/xproto virtual/ttf-fonts
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXft-2.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=0c20e5bd8a0b4eb68ebccfd428e2455b
+_md5_=ccc89df1f9d41d8d94731a9dccbdd558
diff --git a/metadata/md5-cache/x11-libs/libXi-1.7.1.901 b/metadata/md5-cache/x11-libs/libXi-1.7.1.901
index ad74d13..54baa6a 100644
--- a/metadata/md5-cache/x11-libs/libXi-1.7.1.901
+++ b/metadata/md5-cache/x11-libs/libXi-1.7.1.901
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs doc
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-libs/libX11-1.4.99.1 >=x11-libs/libXext-1.1 >=x11-libs/libXfixes-5 >=x11-proto/inputproto-2.2.99.1 >=x11-proto/xproto-7.0.13 >=x11-proto/xextproto-7.0.3
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXi-1.7.1.901.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=dd31e2933830e891a7938ac142fb44d2
+_md5_=4aeef10b4f62604fe799fdf1bd3050f0
diff --git a/metadata/md5-cache/x11-libs/libXinerama-1.1.3 b/metadata/md5-cache/x11-libs/libXinerama-1.1.3
index 5dc6d07..9aafad6 100644
--- a/metadata/md5-cache/x11-libs/libXinerama-1.1.3
+++ b/metadata/md5-cache/x11-libs/libXinerama-1.1.3
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXext x11-proto/xextproto >=x11-proto/xineramaproto-1.2
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXinerama-1.1.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=da1dff628780291ae479aadf189e8138
+_md5_=bcb7fa182083d580e3ddc263168a5967
diff --git a/metadata/md5-cache/x11-libs/libXmu-1.1.0 b/metadata/md5-cache/x11-libs/libXmu-1.1.0
index e12d795..98c8486 100644
--- a/metadata/md5-cache/x11-libs/libXmu-1.1.0
+++ b/metadata/md5-cache/x11-libs/libXmu-1.1.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc ipv6 static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libXt x11-libs/libXext x11-libs/libX11 x11-proto/xextproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXmu-1.1.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=0af04ec0528c0e44ccd22aac8efe71f7
+_md5_=c05b17c155cfb37e3dd5ebfc090dc323
diff --git a/metadata/md5-cache/x11-libs/libXpm-3.5.9 b/metadata/md5-cache/x11-libs/libXpm-3.5.9
index 07792f0..5de8989 100644
--- a/metadata/md5-cache/x11-libs/libXpm-3.5.9
+++ b/metadata/md5-cache/x11-libs/libXpm-3.5.9
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXt x11-libs/libXext x11-proto/xextproto x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXpm-3.5.9.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=1ecaf7d6f8709046d32e7f1504278228
+_md5_=ff8e86482eaae53fea84b4fbe3a7734a
diff --git a/metadata/md5-cache/x11-libs/libXrandr-1.4.1 b/metadata/md5-cache/x11-libs/libXrandr-1.4.1
index 313a948..0c02719 100644
--- a/metadata/md5-cache/x11-libs/libXrandr-1.4.1
+++ b/metadata/md5-cache/x11-libs/libXrandr-1.4.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXext x11-libs/libXrender x11-proto/randrproto x11-proto/renderproto x11-proto/xextproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXrandr-1.4.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=69e6705163a0d4c8adcbf274dfe33e11
+_md5_=b115881e40d85025bba53f9b6720b809
diff --git a/metadata/md5-cache/x11-libs/libXrender-0.9.8 b/metadata/md5-cache/x11-libs/libXrender-0.9.8
index 9754c67..80b5cbb 100644
--- a/metadata/md5-cache/x11-libs/libXrender-0.9.8
+++ b/metadata/md5-cache/x11-libs/libXrender-0.9.8
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 >=x11-proto/renderproto-0.9.3 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXrender-0.9.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=34b3cad4811f2d579ef035e796538d8d
+_md5_=fdfb1adb4b7877dbc4c7732561c14a0f
diff --git a/metadata/md5-cache/x11-libs/libXt-1.1.4 b/metadata/md5-cache/x11-libs/libXt-1.1.4
index 3acc923..47ed51e 100644
--- a/metadata/md5-cache/x11-libs/libXt-1.1.4
+++ b/metadata/md5-cache/x11-libs/libXt-1.1.4
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libSM x11-libs/libICE x11-proto/xproto x11-proto/kbproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXt-1.1.4.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=a72953c64b4e5d02b3cd20da27f37a68
+_md5_=5c398ff4cdc0d46fb4a71335fc7dda38
diff --git a/metadata/md5-cache/x11-libs/libXtst-1.2.0 b/metadata/md5-cache/x11-libs/libXtst-1.2.0
index ea09b20..6dbf3c4 100644
--- a/metadata/md5-cache/x11-libs/libXtst-1.2.0
+++ b/metadata/md5-cache/x11-libs/libXtst-1.2.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 >=x11-libs/libXext-1.0.99.4 x11-libs/libXi x11-proto/inputproto >=x11-proto/recordproto-1.13.99.1 >=x11-proto/xextproto-7.0.99.3
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXtst-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=a600198db5ffc168fe971448945e6d98
+_md5_=38ac5c84650ee3e6b47b65e02c02420e
diff --git a/metadata/md5-cache/x11-libs/libXv-1.0.9 b/metadata/md5-cache/x11-libs/libXv-1.0.9
index 5000424..947c077 100644
--- a/metadata/md5-cache/x11-libs/libXv-1.0.9
+++ b/metadata/md5-cache/x11-libs/libXv-1.0.9
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXext x11-proto/videoproto x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXv-1.0.9.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=1d0f93e14122127f06ff6ea7f6486dfc
+_md5_=a8bd8fa3967065d51a0aed592c5a7b75
diff --git a/metadata/md5-cache/x11-libs/libXvMC-1.0.8 b/metadata/md5-cache/x11-libs/libXvMC-1.0.8
index bf9da0a..1057e62 100644
--- a/metadata/md5-cache/x11-libs/libXvMC-1.0.8
+++ b/metadata/md5-cache/x11-libs/libXvMC-1.0.8
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-solaris
 LICENSE=MIT
 PDEPEND=app-admin/eselect-xvmc
 RDEPEND=x11-libs/libX11 x11-libs/libXext x11-libs/libXv x11-proto/videoproto x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXvMC-1.0.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=c7c14a3856a793b7ae5d7c92895a17d3
+_md5_=b57c9c09d721f405037a14387fe09a88
diff --git a/metadata/md5-cache/x11-libs/libXxf86vm-1.1.3 b/metadata/md5-cache/x11-libs/libXxf86vm-1.1.3
index 8373df8..f681090 100644
--- a/metadata/md5-cache/x11-libs/libXxf86vm-1.1.3
+++ b/metadata/md5-cache/x11-libs/libXxf86vm-1.1.3
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-libs/libXext >=x11-proto/xf86vidmodeproto-2.3 x11-proto/xextproto x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libXxf86vm-1.1.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=4fd649ee97a4687fefee1d1dcf322b3f
+_md5_=a3762713db7aee6fbac5203d689287cc
diff --git a/metadata/md5-cache/x11-libs/libfontenc-1.1.0 b/metadata/md5-cache/x11-libs/libfontenc-1.1.0
index ce4bbd3..9bb825d 100644
--- a/metadata/md5-cache/x11-libs/libfontenc-1.1.0
+++ b/metadata/md5-cache/x11-libs/libfontenc-1.1.0
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=sys-libs/zlib x11-proto/xproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libfontenc-1.1.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=0a976b838101054d8443ae33f09d1474
+_md5_=d49eefacdeff217e5d3944c32906551d
diff --git a/metadata/md5-cache/x11-libs/libvdpau-0.5 b/metadata/md5-cache/x11-libs/libvdpau-0.5
index ad7940b..4a2bbe5 100644
--- a/metadata/md5-cache/x11-libs/libvdpau-0.5
+++ b/metadata/md5-cache/x11-libs/libvdpau-0.5
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.freedesktop.org/wiki/Software/VDPAU
 IUSE=doc dri
-KEYWORDS=~alpha amd64 x86 ~amd64-fbsd ~x86-fbsd
+KEYWORDS=alpha amd64 x86 ~amd64-fbsd ~x86-fbsd
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 dri? ( x11-libs/libXext ) !=x11-drivers/nvidia-drivers-180* !=x11-drivers/nvidia-drivers-185* !=x11-drivers/nvidia-drivers-190*
 SLOT=0
 SRC_URI=http://people.freedesktop.org/~aplattner/vdpau/libvdpau-0.5.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=050844658eadd23e9d4e87197b229dff
+_md5_=3ed13ec266e4216c7b7159326d31c30d
diff --git a/metadata/md5-cache/x11-libs/libxcb-1.9.1 b/metadata/md5-cache/x11-libs/libxcb-1.9.1
index 434e7b5..5ae4e4f 100644
--- a/metadata/md5-cache/x11-libs/libxcb-1.9.1
+++ b/metadata/md5-cache/x11-libs/libxcb-1.9.1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xcb.freedesktop.org/
 IUSE=selinux xkb static-libs doc
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=dev-libs/libpthread-stubs x11-libs/libXau x11-libs/libXdmcp
 SLOT=0
 SRC_URI=http://xcb.freedesktop.org/dist/libxcb-1.9.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=fb7c235fa095e7059b66b0e0bbfeb595
+_md5_=19068c52db1e9ab71f10b535dd24defd
diff --git a/metadata/md5-cache/x11-libs/libxkbfile-1.0.7 b/metadata/md5-cache/x11-libs/libxkbfile-1.0.7
index 282d55e..6acc7e7 100644
--- a/metadata/md5-cache/x11-libs/libxkbfile-1.0.7
+++ b/metadata/md5-cache/x11-libs/libxkbfile-1.0.7
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=static-libs
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=x11-libs/libX11 x11-proto/kbproto
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/libxkbfile-1.0.7.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=21a1e9959b897ca195dccd2aef0beb35
+_md5_=60eb0b969c9b02902b7fe10c43a2ec3d
diff --git a/metadata/md5-cache/x11-libs/pixman-0.28.2 b/metadata/md5-cache/x11-libs/pixman-0.28.2
index fb0df1d..605c68b 100644
--- a/metadata/md5-cache/x11-libs/pixman-0.28.2
+++ b/metadata/md5-cache/x11-libs/pixman-0.28.2
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=altivec iwmmxt mmxext neon sse2 static-libs
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/pixman-0.28.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	versionator	865bc8b2fc9fcfb6d520bdf5a110f5ed	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=44c0106f459537510eb3fcf9cd3a4bdf
+_md5_=982e0c7b124caa0c4f2dd82ff4da0455
diff --git a/metadata/md5-cache/x11-libs/xcb-util-0.3.8 b/metadata/md5-cache/x11-libs/xcb-util-0.3.8
index 95016fa..6fa7a08 100644
--- a/metadata/md5-cache/x11-libs/xcb-util-0.3.8
+++ b/metadata/md5-cache/x11-libs/xcb-util-0.3.8
@@ -4,11 +4,11 @@
 EAPI=4
 HOMEPAGE=http://xcb.freedesktop.org/
 IUSE=test static-libs doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=MIT
 PDEPEND=>=x11-libs/xcb-util-image-0.3.8 >=x11-libs/xcb-util-keysyms-0.3.8 >=x11-libs/xcb-util-renderutil-0.3.8 >=x11-libs/xcb-util-wm-0.3.8
 RDEPEND=>=x11-libs/libxcb-1.7 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xcb.freedesktop.org/dist//xcb-util-0.3.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=f28612d19a749a5bfc7ea0d6e7a1d793
+_md5_=7cd388d8179907e32b8290b3d722a6bf
diff --git a/metadata/md5-cache/x11-libs/xcb-util-image-0.3.8 b/metadata/md5-cache/x11-libs/xcb-util-image-0.3.8
index 6d54ce8..a53ca54 100644
--- a/metadata/md5-cache/x11-libs/xcb-util-image-0.3.8
+++ b/metadata/md5-cache/x11-libs/xcb-util-image-0.3.8
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xcb.freedesktop.org/
 IUSE=test static-libs doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=MIT
 RDEPEND=>=x11-libs/xcb-util-0.3.8 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xcb.freedesktop.org/dist//xcb-util-image-0.3.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=1c9b09a1aa0b69b2aaffa2b8f4ed8394
+_md5_=a286ce813bbed1c65b4b359f2501da96
diff --git a/metadata/md5-cache/x11-libs/xcb-util-keysyms-0.3.8 b/metadata/md5-cache/x11-libs/xcb-util-keysyms-0.3.8
index 0c9cbaf..b15e465 100644
--- a/metadata/md5-cache/x11-libs/xcb-util-keysyms-0.3.8
+++ b/metadata/md5-cache/x11-libs/xcb-util-keysyms-0.3.8
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xcb.freedesktop.org/
 IUSE=test static-libs doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=MIT
 RDEPEND=>=x11-libs/xcb-util-0.3.8 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xcb.freedesktop.org/dist//xcb-util-keysyms-0.3.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=bba85c9fcd08a12a76efde0b30e000cc
+_md5_=c051f8650b2d5c55ef9bc2edf3094573
diff --git a/metadata/md5-cache/x11-libs/xcb-util-renderutil-0.3.8 b/metadata/md5-cache/x11-libs/xcb-util-renderutil-0.3.8
index dec4457..ded03c0 100644
--- a/metadata/md5-cache/x11-libs/xcb-util-renderutil-0.3.8
+++ b/metadata/md5-cache/x11-libs/xcb-util-renderutil-0.3.8
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xcb.freedesktop.org/
 IUSE=test static-libs doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=MIT
 RDEPEND=>=x11-libs/xcb-util-0.3.8 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xcb.freedesktop.org/dist//xcb-util-renderutil-0.3.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=a5e3b0dc2f6976fab946d3c511b824d4
+_md5_=b0c8cf884b1a89ec6949c79bbfb36c55
diff --git a/metadata/md5-cache/x11-libs/xcb-util-wm-0.3.8 b/metadata/md5-cache/x11-libs/xcb-util-wm-0.3.8
index 467a549..b2ae2de 100644
--- a/metadata/md5-cache/x11-libs/xcb-util-wm-0.3.8
+++ b/metadata/md5-cache/x11-libs/xcb-util-wm-0.3.8
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://xcb.freedesktop.org/
 IUSE=test static-libs doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~ia64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris
 LICENSE=MIT
 RDEPEND=>=x11-libs/xcb-util-0.3.8 x11-proto/xproto
 SLOT=0
 SRC_URI=http://xcb.freedesktop.org/dist//xcb-util-wm-0.3.8.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=bd322634de15bb2152c9622e2b87324f
+_md5_=8a86158eba7e1177ab403ec095382a51
diff --git a/metadata/md5-cache/x11-libs/xtrans-1.2.6 b/metadata/md5-cache/x11-libs/xtrans-1.2.6
index 8818383..b80961c 100644
--- a/metadata/md5-cache/x11-libs/xtrans-1.2.6
+++ b/metadata/md5-cache/x11-libs/xtrans-1.2.6
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/lib/xtrans-1.2.6.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=6c4e67b18fd1855ee7ed14b921b7fcd8
+_md5_=330bb335b49bacfbb6453ea832a6d55f
diff --git a/metadata/md5-cache/x11-misc/makedepend-1.0.3 b/metadata/md5-cache/x11-misc/makedepend-1.0.3
index dcb3507..1df3150 100644
--- a/metadata/md5-cache/x11-misc/makedepend-1.0.3
+++ b/metadata/md5-cache/x11-misc/makedepend-1.0.3
@@ -3,9 +3,9 @@
 DESCRIPTION=create dependencies in makefiles
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/util/makedepend-1.0.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=8cb2677a6632566e394878c188c3471a
+_md5_=2b356e79f4f3f68a1acb0dc8438d53b8
diff --git a/metadata/md5-cache/x11-misc/read-edid-1.4.2 b/metadata/md5-cache/x11-misc/read-edid-1.4.2
index 252790c..a69e4af 100644
--- a/metadata/md5-cache/x11-misc/read-edid-1.4.2
+++ b/metadata/md5-cache/x11-misc/read-edid-1.4.2
@@ -1,8 +1,8 @@
 DEFINED_PHASES=compile install
 DESCRIPTION=Get EDID information from a PnP monitor
 HOMEPAGE=http://www.polypux.org/projects/read-edid/
-KEYWORDS=alpha amd64 ppc ~sparc x86
+KEYWORDS=alpha amd64 ppc sparc x86
 LICENSE=GPL-2
 SLOT=0
 SRC_URI=http://www.polypux.org/projects/read-edid/read-edid-1.4.2.tar.gz
-_md5_=27c9d9ef8d671a28aed088c101bc1ad9
+_md5_=30404d5356febf406c973dda69e36951
diff --git a/metadata/md5-cache/x11-misc/shared-mime-info-0.90 b/metadata/md5-cache/x11-misc/shared-mime-info-0.90
index 58f0abd..0309217 100644
--- a/metadata/md5-cache/x11-misc/shared-mime-info-0.90
+++ b/metadata/md5-cache/x11-misc/shared-mime-info-0.90
@@ -3,10 +3,10 @@
 DESCRIPTION=The Shared MIME-info Database specification
 EAPI=3
 HOMEPAGE=http://freedesktop.org/wiki/Software/shared-mime-info
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=>=dev-libs/glib-2.6:2 >=dev-libs/libxml2-2.4
 SLOT=0
 SRC_URI=http://people.freedesktop.org/~hadess/shared-mime-info-0.90.tar.bz2
 _eclasses_=fdo-mime	9c46e30acd923ff12e325dbe96bb98b9
-_md5_=59cdb416637b33f898f537023bbd71bf
+_md5_=504e4311bd67601d8d0c306bf3e91255
diff --git a/metadata/md5-cache/x11-misc/util-macros-1.17 b/metadata/md5-cache/x11-misc/util-macros-1.17
index 71e82fc..b5fc52d 100644
--- a/metadata/md5-cache/x11-misc/util-macros-1.17
+++ b/metadata/md5-cache/x11-misc/util-macros-1.17
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org autotools utility macros
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 ~s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/util/util-macros-1.17.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=306c214cd222bd8e53eb137b813d12de
+_md5_=26ea1474969cb3df6c0845fdc26c1197
diff --git a/metadata/md5-cache/x11-misc/x11vnc-0.9.13-r1 b/metadata/md5-cache/x11-misc/x11vnc-0.9.13-r1
index c8455bf..4c9a519 100644
--- a/metadata/md5-cache/x11-misc/x11vnc-0.9.13-r1
+++ b/metadata/md5-cache/x11-misc/x11vnc-0.9.13-r1
@@ -4,10 +4,10 @@
 EAPI=4
 HOMEPAGE=http://www.karlrunge.com/x11vnc/
 IUSE=avahi crypt fbcon +jpeg ssl system-libvncserver threads tk xinerama +zlib
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~ppc ~ppc64 ~sh ~sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 ppc ppc64 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=GPL-2
 RDEPEND=system-libvncserver? ( >=net-libs/libvncserver-0.9.7[threads=,jpeg=,zlib=] ) !system-libvncserver? ( zlib? ( sys-libs/zlib ) jpeg? ( virtual/jpeg:0 ) ) ssl? ( dev-libs/openssl ) tk? ( dev-lang/tk ) avahi? ( >=net-dns/avahi-0.6.4 ) xinerama? ( x11-libs/libXinerama ) x11-libs/libXfixes x11-libs/libXrandr x11-libs/libX11 >=x11-libs/libXtst-1.1.0 x11-libs/libXdamage x11-libs/libXext
 SLOT=0
 SRC_URI=mirror://sourceforge/libvncserver/x11vnc-0.9.13.tar.gz
 _eclasses_=eutils	d40dc948067bd3db1c8ebf7d51897313	multilib	ded93e450747134a079e647d888aa80b	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29
-_md5_=073e290c22b17b0fd2153b33787eb3fe
+_md5_=21cb89e229bf6a4d4fd1db48d9655037
diff --git a/metadata/md5-cache/x11-misc/xbitmaps-1.1.1 b/metadata/md5-cache/x11-misc/xbitmaps-1.1.1
index 40828f9..fb80734 100644
--- a/metadata/md5-cache/x11-misc/xbitmaps-1.1.1
+++ b/metadata/md5-cache/x11-misc/xbitmaps-1.1.1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org bitmaps data
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/data/xbitmaps-1.1.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=c1edb0b9af314d6e0d646ce109848dd5
+_md5_=9d005232b0309acc851ab6749f13fd4a
diff --git a/metadata/md5-cache/x11-proto/bigreqsproto-1.1.1 b/metadata/md5-cache/x11-proto/bigreqsproto-1.1.1
index fbc1d5e..28097b6 100644
--- a/metadata/md5-cache/x11-proto/bigreqsproto-1.1.1
+++ b/metadata/md5-cache/x11-proto/bigreqsproto-1.1.1
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/bigreqsproto-1.1.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=f05a5e25c2172d5abf1d3dc382d9c1e8
+_md5_=8345dd91b9366386994f69ed9044b63a
diff --git a/metadata/md5-cache/x11-proto/compositeproto-0.4.2 b/metadata/md5-cache/x11-proto/compositeproto-0.4.2
index 1cf0d36..335ea8f 100644
--- a/metadata/md5-cache/x11-proto/compositeproto-0.4.2
+++ b/metadata/md5-cache/x11-proto/compositeproto-0.4.2
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Composite protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/compositeproto-0.4.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=ee684d74f06fb4c2b433d0534808a6e2
+_md5_=f5f1adf9a56e036612f30a344ec388b9
diff --git a/metadata/md5-cache/x11-proto/damageproto-1.2.1 b/metadata/md5-cache/x11-proto/damageproto-1.2.1
index 8fbf456..aef358b 100644
--- a/metadata/md5-cache/x11-proto/damageproto-1.2.1
+++ b/metadata/md5-cache/x11-proto/damageproto-1.2.1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Damage protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/damageproto-1.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=93d60c7a14b2d4ff137179b1d8a8b8e8
+_md5_=bbcff9250f955431c291b0fcb7f7be19
diff --git a/metadata/md5-cache/x11-proto/dri2proto-2.6 b/metadata/md5-cache/x11-proto/dri2proto-2.6
index 6e951f5..61ffe90 100644
--- a/metadata/md5-cache/x11-proto/dri2proto-2.6
+++ b/metadata/md5-cache/x11-proto/dri2proto-2.6
@@ -2,10 +2,10 @@
 DEPEND=|| ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool >=sys-devel/libtool-1.5 >=sys-devel/m4-1.4 virtual/pkgconfig >=x11-misc/util-macros-1.3.0
 DESCRIPTION=X.Org DRI2 protocol headers
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~amd64-linux ~ia64-linux ~x86-linux ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=!<=x11-base/xorg-x11-6.9
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/dri2proto-2.6.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	x-modular	9f4ee0c44a3a3b7ecdf52cefc1e10280
-_md5_=5dececb8b155d621cb7329a89c27dff6
+_md5_=a9138b1dc5b6173af6fa2902183f0663
diff --git a/metadata/md5-cache/x11-proto/fixesproto-5.0 b/metadata/md5-cache/x11-proto/fixesproto-5.0
index 9d6f00b..a586881 100644
--- a/metadata/md5-cache/x11-proto/fixesproto-5.0
+++ b/metadata/md5-cache/x11-proto/fixesproto-5.0
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org Fixes protocol headers
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=>=x11-proto/xextproto-7.0.99.1
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/fixesproto-5.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=9487d93e216390a756f60383f5c7711e
+_md5_=1f1c1071e3c84b98e6789126a16e91bf
diff --git a/metadata/md5-cache/x11-proto/fontsproto-2.1.1 b/metadata/md5-cache/x11-proto/fontsproto-2.1.1
index 5a566e0..3b347f0 100644
--- a/metadata/md5-cache/x11-proto/fontsproto-2.1.1
+++ b/metadata/md5-cache/x11-proto/fontsproto-2.1.1
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/fontsproto-2.1.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=b7a6149c3244e1affd4898d9ecd4e9d7
+_md5_=35327ecd9646ad48dbf4d80084ed31c3
diff --git a/metadata/md5-cache/x11-proto/glproto-1.4.14 b/metadata/md5-cache/x11-proto/glproto-1.4.14
index d089823..66c997b 100644
--- a/metadata/md5-cache/x11-proto/glproto-1.4.14
+++ b/metadata/md5-cache/x11-proto/glproto-1.4.14
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org GL protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=SGI-B-2.0
 RDEPEND=app-admin/eselect-opengl
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/glproto-1.4.14.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=da16a52b386d0143f287b1da7412b5e2
+_md5_=23786e6a490f6d594134efd8217f708a
diff --git a/metadata/md5-cache/x11-proto/glproto-1.4.14-r1 b/metadata/md5-cache/x11-proto/glproto-1.4.14-r1
index b431eba..672a9cc 100644
--- a/metadata/md5-cache/x11-proto/glproto-1.4.14-r1
+++ b/metadata/md5-cache/x11-proto/glproto-1.4.14-r1
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org GL protocol headers
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha ~amd64 ~arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc ~x86 ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha ~amd64 ~arm hppa ia64 mips ppc ppc64 s390 sh sparc ~x86 ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=SGI-B-2.0
 RDEPEND=>=app-admin/eselect-opengl-1.2.3
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/glproto-1.4.14.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=39da346e144fc9fc228a94e2c3787936
+_md5_=428c2b784589ce5064d22a464223796a
diff --git a/metadata/md5-cache/x11-proto/inputproto-2.3 b/metadata/md5-cache/x11-proto/inputproto-2.3
index 8c22c06..da4c355 100644
--- a/metadata/md5-cache/x11-proto/inputproto-2.3
+++ b/metadata/md5-cache/x11-proto/inputproto-2.3
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Input protocol headers
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/inputproto-2.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=2a51f3a8e9e8ed73ce98d362ebb714b4
+_md5_=41474cd8b1b63138b5a67ffa36a70ae0
diff --git a/metadata/md5-cache/x11-proto/kbproto-1.0.5 b/metadata/md5-cache/x11-proto/kbproto-1.0.5
index 0d27624..db8d094 100644
--- a/metadata/md5-cache/x11-proto/kbproto-1.0.5
+++ b/metadata/md5-cache/x11-proto/kbproto-1.0.5
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org KB protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/kbproto-1.0.5.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=04ba13b7c8c735d949679703f7cba8f1
+_md5_=d101d1e8fccf0cf8643f587c3b0126bc
diff --git a/metadata/md5-cache/x11-proto/randrproto-1.4.0-r1 b/metadata/md5-cache/x11-proto/randrproto-1.4.0-r1
index 5272c21..3600a6f 100644
--- a/metadata/md5-cache/x11-proto/randrproto-1.4.0-r1
+++ b/metadata/md5-cache/x11-proto/randrproto-1.4.0-r1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Randr protocol headers
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha amd64 arm ~hppa ~ia64 ~mips ~ppc ~ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~arm-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/randrproto-1.4.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=4775fc2b6cc2b71863598f95dde9b027
+_md5_=7112277946f1aad9d04cbbbc0b86937d
diff --git a/metadata/md5-cache/x11-proto/recordproto-1.14.1 b/metadata/md5-cache/x11-proto/recordproto-1.14.1
index dc459b8..d9a4465 100644
--- a/metadata/md5-cache/x11-proto/recordproto-1.14.1
+++ b/metadata/md5-cache/x11-proto/recordproto-1.14.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=!<x11-libs/libXtst-1.0.99.2
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/recordproto-1.14.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=00275afadff442df020ef97752b02a40
+_md5_=5eb98dc5824535637aa7651f14bdf861
diff --git a/metadata/md5-cache/x11-proto/renderproto-0.11.1 b/metadata/md5-cache/x11-proto/renderproto-0.11.1
index bc3fdb7..1c7012f 100644
--- a/metadata/md5-cache/x11-proto/renderproto-0.11.1
+++ b/metadata/md5-cache/x11-proto/renderproto-0.11.1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Render protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/renderproto-0.11.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=e556be848788b2813a4863bf26269779
+_md5_=bdbd78021c1732aa0cbf84256fb53508
diff --git a/metadata/md5-cache/x11-proto/resourceproto-1.2.0 b/metadata/md5-cache/x11-proto/resourceproto-1.2.0
index 7b0244e..71e8d2f 100644
--- a/metadata/md5-cache/x11-proto/resourceproto-1.2.0
+++ b/metadata/md5-cache/x11-proto/resourceproto-1.2.0
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Resource protocol headers
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/resourceproto-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=fdace175d199c7ea19c3018a8a1e944c
+_md5_=62f42f51197eb8092992b9a607cd3cbf
diff --git a/metadata/md5-cache/x11-proto/scrnsaverproto-1.2.1 b/metadata/md5-cache/x11-proto/scrnsaverproto-1.2.1
index 628dd30..b63d834 100644
--- a/metadata/md5-cache/x11-proto/scrnsaverproto-1.2.1
+++ b/metadata/md5-cache/x11-proto/scrnsaverproto-1.2.1
@@ -4,10 +4,10 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=!<x11-libs/libXScrnSaver-1.2
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/scrnsaverproto-1.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=db044703fd81f593889444b96084825b
+_md5_=6d52652be37bfdbbf34821e59a3d1ee6
diff --git a/metadata/md5-cache/x11-proto/trapproto-3.4.3 b/metadata/md5-cache/x11-proto/trapproto-3.4.3
index eab73d4..b68c30a 100644
--- a/metadata/md5-cache/x11-proto/trapproto-3.4.3
+++ b/metadata/md5-cache/x11-proto/trapproto-3.4.3
@@ -2,10 +2,10 @@
 DEPEND=|| ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool >=sys-devel/libtool-1.5 >=sys-devel/m4-1.4 virtual/pkgconfig >=x11-misc/util-macros-1.3.0
 DESCRIPTION=X.Org Trap protocol headers
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=!<=x11-base/xorg-x11-6.9
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/trapproto-3.4.3.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	x-modular	9f4ee0c44a3a3b7ecdf52cefc1e10280
-_md5_=c60ca7d3e1103662122c89c9e3b41b3c
+_md5_=56f5c8f5d290135eae4f2cba7a8f0a33
diff --git a/metadata/md5-cache/x11-proto/videoproto-2.3.1 b/metadata/md5-cache/x11-proto/videoproto-2.3.1
index 8e27feb..1543e63 100644
--- a/metadata/md5-cache/x11-proto/videoproto-2.3.1
+++ b/metadata/md5-cache/x11-proto/videoproto-2.3.1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org Video protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x86-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/videoproto-2.3.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=dc7b191ee12f2a6f0d4dbda2d266974a
+_md5_=30fce1ba84f3689096acdd69ae6e4f51
diff --git a/metadata/md5-cache/x11-proto/xcmiscproto-1.2.1 b/metadata/md5-cache/x11-proto/xcmiscproto-1.2.1
index 3d83ba5..e6c8714 100644
--- a/metadata/md5-cache/x11-proto/xcmiscproto-1.2.1
+++ b/metadata/md5-cache/x11-proto/xcmiscproto-1.2.1
@@ -4,9 +4,9 @@
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xcmiscproto-1.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=51ad10be1175fe29d63cc3d9522021be
+_md5_=4a78574585b8be0baa626bc5b3ec556b
diff --git a/metadata/md5-cache/x11-proto/xf86bigfontproto-1.2.0 b/metadata/md5-cache/x11-proto/xf86bigfontproto-1.2.0
index 35342d8..fbbb9f3 100644
--- a/metadata/md5-cache/x11-proto/xf86bigfontproto-1.2.0
+++ b/metadata/md5-cache/x11-proto/xf86bigfontproto-1.2.0
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org XF86BigFont protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-freebsd ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xf86bigfontproto-1.2.0.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=dbd4fdac66079a0bbec3024bab66d94b
+_md5_=d9f6e6369370865072dba7d49a275aff
diff --git a/metadata/md5-cache/x11-proto/xf86dgaproto-2.1 b/metadata/md5-cache/x11-proto/xf86dgaproto-2.1
index a3ebbfc..9525bfc 100644
--- a/metadata/md5-cache/x11-proto/xf86dgaproto-2.1
+++ b/metadata/md5-cache/x11-proto/xf86dgaproto-2.1
@@ -2,10 +2,10 @@
 DEPEND=!<x11-libs/libXxf86dga-1.0.99.1 || ( >=sys-devel/automake-1.11.1 >=sys-devel/automake-1.12 ) >=sys-devel/autoconf-2.68 sys-devel/libtool >=sys-devel/libtool-1.5 >=sys-devel/m4-1.4 virtual/pkgconfig >=x11-misc/util-macros-1.3.0
 DESCRIPTION=X.Org XF86DGA protocol headers
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris
 LICENSE=MIT
 RDEPEND=!<x11-libs/libXxf86dga-1.0.99.1 !<=x11-base/xorg-x11-6.9
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xf86dgaproto-2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	x-modular	9f4ee0c44a3a3b7ecdf52cefc1e10280
-_md5_=49fb75181e14b15802e97ce324729624
+_md5_=8cacb8acfcb62b6118ccce41cb625ca5
diff --git a/metadata/md5-cache/x11-proto/xf86driproto-2.1.1 b/metadata/md5-cache/x11-proto/xf86driproto-2.1.1
index d132585..9c08ecd 100644
--- a/metadata/md5-cache/x11-proto/xf86driproto-2.1.1
+++ b/metadata/md5-cache/x11-proto/xf86driproto-2.1.1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org XF86DRI protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x64-freebsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xf86driproto-2.1.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=2372ff4daa3cce73e1a3107d4147c40c
+_md5_=878e9cdf8c7ac6ccb7a79090493c6efb
diff --git a/metadata/md5-cache/x11-proto/xf86rushproto-1.1.2-r1 b/metadata/md5-cache/x11-proto/xf86rushproto-1.1.2-r1
index 16e484c..efaa546 100644
--- a/metadata/md5-cache/x11-proto/xf86rushproto-1.1.2-r1
+++ b/metadata/md5-cache/x11-proto/xf86rushproto-1.1.2-r1
@@ -3,9 +3,9 @@
 DESCRIPTION=X.Org XF86Rush protocol headers
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=~alpha amd64 arm hppa ~ia64 ~mips ppc ppc64 ~s390 ~sh ~sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~amd64-fbsd ~x86-fbsd ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xf86rushproto-1.1.2.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=4b2de9be72926639bc1d946b57877419
+_md5_=f527d2209ac104bf6f6c1d0262076833
diff --git a/metadata/md5-cache/x11-proto/xf86vidmodeproto-2.3.1 b/metadata/md5-cache/x11-proto/xf86vidmodeproto-2.3.1
index 4a5a2c2..3b91313 100644
--- a/metadata/md5-cache/x11-proto/xf86vidmodeproto-2.3.1
+++ b/metadata/md5-cache/x11-proto/xf86vidmodeproto-2.3.1
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org XF86VidMode protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~x86-fbsd ~x64-freebsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris ~x86-winnt
 LICENSE=MIT
 RDEPEND=!<x11-libs/libXxf86vm-1.0.99.1
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xf86vidmodeproto-2.3.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=8b7ed3d1afb86e03bc9dba97d1f469a0
+_md5_=d4b62b388a59c891433f43631a464a49
diff --git a/metadata/md5-cache/x11-proto/xineramaproto-1.2.1 b/metadata/md5-cache/x11-proto/xineramaproto-1.2.1
index 5907061..be1b758 100644
--- a/metadata/md5-cache/x11-proto/xineramaproto-1.2.1
+++ b/metadata/md5-cache/x11-proto/xineramaproto-1.2.1
@@ -3,10 +3,10 @@
 DESCRIPTION=X.Org Xinerama protocol headers
 EAPI=3
 HOMEPAGE=http://xorg.freedesktop.org/
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~x86-fbsd ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x86-macos ~sparc-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 RDEPEND=!<x11-libs/libXinerama-1.0.99.1
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xineramaproto-1.2.1.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=5215d9e4e59190e66ebe0622addc4b1c
+_md5_=d2defb2f5321bcd0a27ea5957049e22a
diff --git a/metadata/md5-cache/x11-proto/xproto-7.0.23-r1 b/metadata/md5-cache/x11-proto/xproto-7.0.23-r1
index 656f429..87ad8a2 100644
--- a/metadata/md5-cache/x11-proto/xproto-7.0.23-r1
+++ b/metadata/md5-cache/x11-proto/xproto-7.0.23-r1
@@ -4,9 +4,9 @@
 EAPI=4
 HOMEPAGE=http://xorg.freedesktop.org/
 IUSE=doc
-KEYWORDS=alpha amd64 arm hppa ia64 ~mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
+KEYWORDS=alpha amd64 arm hppa ia64 mips ppc ppc64 s390 sh sparc x86 ~ppc-aix ~amd64-fbsd ~x86-fbsd ~x64-freebsd ~x86-freebsd ~hppa-hpux ~ia64-hpux ~x86-interix ~amd64-linux ~x86-linux ~ppc-macos ~x64-macos ~x86-macos ~sparc-solaris ~sparc64-solaris ~x64-solaris ~x86-solaris
 LICENSE=MIT
 SLOT=0
 SRC_URI=http://xorg.freedesktop.org/releases/individual/proto/xproto-7.0.23.tar.bz2
 _eclasses_=autotools	1b0fa473be98091220edff9f51d06153	autotools-utils	966fed1f979132a778b0b48c74a16adb	base	fc89786f3f7e7bcf03334359bd5b639b	eutils	d40dc948067bd3db1c8ebf7d51897313	flag-o-matic	c3131dc67d3bd39f044e92b8280505e4	libtool	0fd90d183673bf1107465ec45849d1ea	multilib	ded93e450747134a079e647d888aa80b	multiprocessing	1512bdfe7004902b8cd2c466fc3df772	toolchain-funcs	3e30ef439a720915f8f4fd4fe75f704c	user	9e552f935106ff0bc92af16da64b4b29	xorg-2	b83efc910bb3ac2c64f89e2623f181f5
-_md5_=6222ffe41cead1d48b29eacb3a3c2887
+_md5_=1c1fc8d3f07b0ac2428ff430d93d9112
