####################################################################
# $Id$
#
# When you add an entry to the top of this file, add your name, the date, and
# an explanation of why something is getting masked. Please be extremely
# careful not to commit atoms that are not valid, as it can cause large-scale
# breakage, especially if it ends up in the daily snapshot.
#
## Example:
##
## # Dev E. Loper <developer@gentoo.org> (28 Jun 2012)
## # Masking  these versions until we can get the
## # v4l stuff to work properly again
## =media-video/mplayer-0.90_pre5
## =media-video/mplayer-0.90_pre5-r1
#
# - Best last rites (removal) practices -
# Include the following info:
# a) reason for masking
# b) bug # for the removal (and yes you should have one)
# c) date of removal (either the date or "in x days")
#
## Example:
##
## # Dev E. Loper <developer@gentoo.org> (23 May 2015)
## # Masked for removal in 30 days.  Doesn't work
## # with new libfoo. Upstream dead, gtk-1, smells
## # funny. (bug #987654)
## app-misc/some-package

#--- END OF EXAMPLES ---

# David Seifert <soap@gentoo.org> (01 Oct 2016)
# Masked for failing to build with C++11, ancient codebase,
# dead upstream, no updates in 5 years. No revdeps.
# Mask for removal in 30 days. Bug #595754
net-libs/socket++

# Pacho Ramos <pacho@gentoo.org> (29 Sep 2016)
# Makes gst-transcoder to fail on building, bug #594172
=dev-util/meson-0.34.0

# Michael Palimaka <kensington@gentoo.org> (26 Sep 2016)
# No longer maintained by upstream. Unused.
# Masked for removal in 30 days.
kde-apps/kdeartwork-emoticons

# Fabian Groffen <grobian@gentoo.org> (25 Sep 2016)
# Mask Exim RCs
=mail-mta/exim-4.88_rc1

# Christoph Junghans <ottxor@gentoo.org> (20 Sep 2016)
# Switch to a non-stable scheme  following google-chrome
# please unmask latest version yourself
=www-plugins/google-talkplugin-5.4.2.0

# Gnome Team <gnome@gentoo.org> (19 sep 2016)
# Gnome 3.22 mask
>=dev-util/gdbus-codegen-2.50.0
>=dev-libs/glib-2.50.0

# David Seifert <soap@gentoo.org> (18 Sep 2016)
# Masked for failing to build with GCC 6, still using ancient
# distutils.eclass, tightly coupled to dev-libs/xqilla-2.2*.
# Purged by Debian and Fedora more than 5 years ago.
# Mask for removal in 30 days.
# Bug #594236
dev-libs/dbxml

# Michael Palimaka <kensington@gentoo.org> (15 Sep 2016)
# KDE PIM 5 masked for wider testing.
~kde-apps/akonadi-16.08.1
~kde-apps/akonadi-calendar-16.08.1
~kde-apps/akonadi-contacts-16.08.1
~kde-apps/akonadi-import-wizard-16.08.1
~kde-apps/akonadi-mime-16.08.1
~kde-apps/akonadi-notes-16.08.1
~kde-apps/akonadi-search-16.08.1
~kde-apps/akonadiconsole-16.08.1
~kde-apps/akregator-16.08.1
~kde-apps/blogilo-16.08.1
~kde-apps/calendarjanitor-16.08.1
~kde-apps/calendarsupport-16.08.1
~kde-apps/eventviews-16.08.1
~kde-apps/grantlee-editor-16.08.1
~kde-apps/grantleetheme-16.08.1
~kde-apps/incidenceeditor-16.08.1
~kde-apps/kaddressbook-16.08.1
~kde-apps/kalarm-16.08.1
~kde-apps/kalarmcal-16.08.1
~kde-apps/kblog-16.08.1
~kde-apps/kcalutils-16.08.1
~kde-apps/kdepim-addons-16.08.1
~kde-apps/kdepim-apps-libs-16.08.1
~kde-apps/kdepim-meta-16.08.1
~kde-apps/kdepim-runtime-16.08.1
~kde-apps/kidentitymanagement-16.08.1
~kde-apps/kimap-16.08.1
~kde-apps/kldap-16.08.1
~kde-apps/kmail-16.08.1
~kde-apps/kmail-account-wizard-16.08.1
~kde-apps/kmailtransport-16.08.1
~kde-apps/kmbox-16.08.1
~kde-apps/knotes-16.08.1
~kde-apps/konsolekalendar-16.08.1
~kde-apps/kontact-16.08.1
~kde-apps/kontactinterface-16.08.1
~kde-apps/korganizer-16.08.1
~kde-apps/ktnef-16.08.1
~kde-apps/libgravatar-16.08.1
~kde-apps/libkdepim-16.08.1
~kde-apps/libksieve-16.08.1
~kde-apps/libktnef-16.08.1
~kde-apps/mailcommon-16.08.1
~kde-apps/mailimporter-16.08.1
~kde-apps/mbox-importer-16.08.1
~kde-apps/messagelib-16.08.1
~kde-apps/pim-data-exporter-16.08.1
~kde-apps/pim-sieve-editor-16.08.1
~kde-apps/pim-storage-service-manager-16.08.1
~kde-apps/pimcommon-16.08.1
~kde-apps/syndication-16.08.1

# Denis Dupeyron <calchan@gentoo.org> (12 Sep 2016)
# Masked for testing, see bug #588894.
=x11-misc/light-locker-1.7.0-r1

# James Le Cuirot <chewi@gentoo.org> (12 Sep 2016)
# Now only available on Steam. Binaries were removed by the publisher
# and Humble Bundle over 2 years ago. Removal in 60 days. Bug #588110.
games-action/awesomenauts

# Sergei Trofimovich <slyfox@gentoo.org> (11 Sep 2016)
# Mask for removal in 30 days. Uses deprecated conduit-1.0*
# Upstream suggests using dev-haskell/conduit-combinators
# instead.
dev-haskell/base64-conduit

# Sergei Trofimovich <slyfox@gentoo.org> (11 Sep 2016)
# Mask for removal in 30 days. >=sci-mathematics/agda-2.4
# now provides 'agda' binary.
sci-mathematics/agda-executable

# Patrice Clement <monsieurp@gentoo.org> (10 Sep 2016)
# Upstream dead. This package tries very hard to outsmart autotools and
# reinvent the wheel by coming up with its own configure script. A complete
# disaster resulting in a gigantic wave of QA errors.
# Masked for removal in 30 days.
dev-libs/vrb

# Pawel Hajdan jr <phajdan.jr@gentoo.org> (10 Sep 2016)
# Dev channel releases are only for people who are developers or want more
# experimental features and accept a more unstable release.
>=www-client/chromium-55

# Martin Gysel <me@bearsh.org> via g-p-m (09 Sep 2016)
# Versions currently in Portage are old and block removal of other
# packages. Current versions require building against modified versions
# of dev-libs/libdivecomputer and kde-apps/marble which must be fetched
# from Git, and which are not versioned (upstream uses branch tags).
# Finally, upstream considers distribution-maintained packages deprecated.
# Removal in 30 days.
app-misc/subsurface

# Lars Wendler <polynomial-c@gentoo.org> (06 Sep 2016)
# Breaks samba's nmbd process (bug #592502)
=sys-libs/tevent-0.9.30

# Lars Wendler <polynomial-c@gentoo.org> (06 Sep 2016)
# Dead upstream since 2013. Superseded by eject from
# sys-apps/util-linux.
# Slated for removal in 30 days.
sys-block/eject

# Mike Gilbert <floppym@gentoo.org> (03 Sep 2016)
# Python 3.3 will be removed from Gentoo in 30 days.
# dev-lang/python:3.3 will be available in the python overlay.
dev-lang/python:3.3

# Mike Gilbert <floppym@gentoo.org> (03 Sep 2016)
# No reverse deps, only supports python3.3.
# Removal in 30 days.
dev-python/simpletal

# Ian Stakenvicius <axs@gentoo.org> (31 Aug 2016)
# Mask old versions of thunderbird as they are no longer supported,
# but we keep them in the repo for now in case there is a need
# for them for upgrading old user profiles, etc.
~mail-client/thunderbird-24.8.0
~mail-client/thunderbird-31.8.0
~mail-client/thunderbird-38.8.0

# Michał Górny <mgorny@gentoo.org> (28 Aug 2016)
# Masked for testing, and porting revdeps. Please do not unmask before
# media-libs/mesa release supports it.
~sys-devel/clang-3.9.0
~sys-devel/clang-runtime-3.9.0
~sys-devel/llvm-3.9.0
~sys-libs/libcxx-3.9.0
~sys-libs/libcxxabi-3.9.0
~sys-libs/llvm-libunwind-3.9.0

# Lars Wendler <polynomial-c@gentoo.org> (26 Aug 2016)
# Masked while being tested and reverse deps aren't fully compatible
=dev-libs/openssl-1.1*

# Christian Tietz <christian.tietz@mailbox.org> (23 Aug 2016)
# Depends on masked xfce-base/exo-0.11.1
=xfce-extra/xfce4-whiskermenu-plugin-2.0.1

# Brian Evans <grknight@gentoo.org> (22 Aug 2016)
# PHP 5.5 has reached end of life and will no longer receive security updates.
# Also include associated packages which do not work on newer versions
# Removal in 90 days
virtual/httpd-php:5.5
dev-lang/php:5.5
dev-php/pecl-http:0
=dev-php/pecl-mailparse-2.1.6-r1

# Pacho Ramos <pacho@gentoo.org> (21 Aug 2016)
# Needs fixing (#515944), nothing needs this in the tree. Removal in a
# month.
dev-lang/regina-rexx

# Pacho Ramos <pacho@gentoo.org> (21 Aug 2016)
# Security issues (#562898)
=app-admin/lsyncd-2.1.5

# Pacho Ramos <pacho@gentoo.org> (21 Aug 2016)
# Packages added without a maintainer:
#591110
dev-vcs/git-deps

# Brian Evans <grknight@gentoo.org> (18 Aug 2016)
# Mask new MariaDB alphas for testing
>=dev-db/mariadb-10.2.0

# Hans de Graaff <graaff@gentoo.org> (13 Aug 2016)

# Unfixed security problems, bug 576068. No longer supported by
# upstream. Use Rails 4.2 instead. Masked for removal in 30 days.
dev-ruby/rails:4.0
dev-ruby/railties:4.0
dev-ruby/activerecord:4.0
dev-ruby/actionmailer:4.0
dev-ruby/actionpack:4.0
dev-ruby/activemodel:4.0
dev-ruby/activesupport:4.0
dev-ruby/metasploit-concern:1.0
dev-ruby/metasploit-credential:1.0
dev-ruby/metasploit-credential:1.0.1
dev-ruby/metasploit_data_models:1.2.9
dev-ruby/metasploit_data_models:1.2.10
dev-ruby/metasploit-model:1.0

# Michael Palimaka <kensington@gentoo.org> (12 Aug 2016)
# Requires revdeps to build with at least C++11. Bug 589412.
# Masked for wider testing.
~dev-qt/assistant-5.7.0
~dev-qt/designer-5.7.0
~dev-qt/linguist-5.7.0
~dev-qt/linguist-tools-5.7.0
~dev-qt/pixeltool-5.7.0
~dev-qt/qdbus-5.7.0
~dev-qt/qdbusviewer-5.7.0
~dev-qt/qdoc-5.7.0
~dev-qt/qt3d-5.7.0
~dev-qt/qtbluetooth-5.7.0
~dev-qt/qtcharts-5.7.0
~dev-qt/qtconcurrent-5.7.0
~dev-qt/qtcore-5.7.0
~dev-qt/qtdatavis3d-5.7.0
~dev-qt/qtdbus-5.7.0
~dev-qt/qtdeclarative-5.7.0
~dev-qt/qtdiag-5.7.0
~dev-qt/qtgraphicaleffects-5.7.0
~dev-qt/qtgui-5.7.0
~dev-qt/qthelp-5.7.0
~dev-qt/qtimageformats-5.7.0
~dev-qt/qtlocation-5.7.0
~dev-qt/qtmultimedia-5.7.0
~dev-qt/qtnetwork-5.7.0
~dev-qt/qtopengl-5.7.0
~dev-qt/qtpaths-5.7.0
~dev-qt/qtplugininfo-5.7.0
~dev-qt/qtpositioning-5.7.0
~dev-qt/qtprintsupport-5.7.0
~dev-qt/qtquickcontrols2-5.7.0
~dev-qt/qtquickcontrols-5.7.0
~dev-qt/qtscript-5.7.0
~dev-qt/qtscxml-5.7.0
~dev-qt/qtsensors-5.7.0
~dev-qt/qtserialport-5.7.0
~dev-qt/qtsql-5.7.0
~dev-qt/qtsvg-5.7.0
~dev-qt/qttest-5.7.0
~dev-qt/qttranslations-5.7.0
~dev-qt/qtwayland-5.7.0
~dev-qt/qtwebchannel-5.7.0
~dev-qt/qtwebengine-5.7.0
~dev-qt/qtwebkit-5.7.0
~dev-qt/qtwebsockets-5.7.0
~dev-qt/qtwidgets-5.7.0
~dev-qt/qtx11extras-5.7.0
~dev-qt/qtxml-5.7.0
~dev-qt/qtxmlpatterns-5.7.0
=dev-qt/qt-docs-5.7*
>=kde-apps/minuet-16.08.0
>=media-sound/drumstick-1.1.0

# Mike Gilbert <floppym@gentoo.org> (07 Aug 2016)
# Fails to switch cpufreq governor.
# https://bugs.gentoo.org/590780
~sys-power/cpupower-4.7.0

# Michał Górny <mgorny@gentoo.org> (7 Aug 2016)
# Issue with thunar detailed view
# Masked for more restrictive testing.
=xfce-base/exo-0.11.1

# Alexis Ballier <aballier@gentoo.org> <2 Aug 2016>
# Doesn't install .so, causing all its revdeps to fail to build.
# Doesn't honour USE=static-libs.
# Bugs #590272, #590270, #590268, #590266 etc.
=sci-libs/fftw-3.3.5

# Michał Górny <mgorny@gentoo.org> (18 Jul 2016)
# Pre-release of a complete rewrite, provided for early testing. Not all
# functionality is provided yet. Use --pretend to make sure correct
# files will be removed.
>=app-admin/eclean-kernel-1.99

# Kent Fredric <kentnl@gentoo.org> (16 Jul 2016)
# Radically changed upstream and is critical to all Perl modules.
# Masked for extended testing.
# Will likely not be unmasked till equivalent versions ship in Perl itself.
>=perl-core/Test-Simple-1.301.0
>=virtual/perl-Test-Simple-1.301.0

# Mike Pagano <mpagano@gentoo.org> (15 Jul 2016)
# These two kernels have a serious OOM regression
# Fix in 4.1.28-r1 and 3.18.37-r1
=sys-kernel/gentoo-sources-3.18.37
=sys-kernel/gentoo-sources-4.1.28-r1
=sys-kernel/gentoo-sources-4.1.28

# Anthony G. Basile <blueness@gentoo.org> (11 Jul 2016)
# Upstream is in bad shape, bug #585726
net-dns/namecoind
net-dns/namecoin-qt

# Andrew Savchenko <bircoph@gentoo.org> (09 Jul 2016)
# Vulnerable due to wrong suid binary permissions (#345337)
<app-cdr/xcdroast-0.98_alpha16-r2

# Aaron Bauman <bman@gentoo.org> (30 Jun 2016)
# Unpatched security vulnerability per bug #509920
www-apps/egroupware

# Anthony G. Basile <blueness@gentoo.org> (29 Jun 2016)
# Masked for bug #585726
net-dns/namecoind
net-dns/namecoin-qt

# Michał Górny <mgorny@gentoo.org> (27 Jun 2016)
# (on behalf of QA & proxy-maint)
# Major QA violations, bug #587342 (#585722 in particular).
games-emulation/ppsspp

# Aaron Bauman <bman@gentoo.org> (26 Jun 2016)
# Unpatched security vulnerability per bug #475120
media-video/motion

# Chris Reffett <creffett@gentoo.org> (25 May 2016)
# The webkit-gtk:4 backend for Xiphos has known text display issues.
# Use at your own risk.
=app-text/xiphos-4.0.4-r1

# Luca Barbato <lu_zero@gentoo.org> (23 May 2016)
# Masked for testing, vlc-2.2 configure rejects it.
=media-video/libav-12*

# Kent Fredric <kentfredric@gmail.com> (15 May 2016)
# Andreas K. Hüttel <dilfridge@gentoo.org> (21 May 2016)
# Has been broken since app-arch/rar-5.0.0 due to List()
# format changing. Will require upstream revision bump
# or some helpful person to supply a parser patch.
# Bug #483888
<=dev-perl/Archive-Rar-2.20.0-r1

# Alon Bar-Lev <alonbl@gentoo.org> (13 May 2016)
# Force gnutls-3.4 testing so we can stabilize it.
>=net-libs/gnutls-3.5.0

# Lars Wendler <polynomial-c@gentoo.org> (2 May 2016)
# Broken reverse deps. At least one header file has been moved around.
>=media-gfx/imagemagick-7.0.1.0

# Andreas K. Hüttel <dilfridge@gentoo.org> (16 Apr 2016)
# Masked because of security bug 580210
=www-misc/monitorix-3.6.0
=www-misc/monitorix-3.8.1

# Richard Freeman <rich0@gentoo.org> (16 Apr 2016)
# Masked for extended testing, and porting of openrc scripts
# if necessary.
>=media-tv/mythtv-0.28
>=media-plugins/mythplugins-0.28
>=www-apps/mythweb-0.28

# Patrick Lauer <patrick@gentoo.org> (05 Apr 2016)
# --configtest is broken, mask until 2.3.1 release
=app-admin/logstash-bin-2.3.0*

# James Le Cuirot <chewi@gentoo.org> (03 Apr 2016)
# Masking Spring Framework for the time being as 3.2.4 is old, has
# multiple vulnerabilities, and we're not likely to update it
# soon. Hopefully we can revisit it when the Maven stuff works out.
dev-java/spring-aop
dev-java/spring-beans
dev-java/spring-core
dev-java/spring-expression
dev-java/spring-instrument

# Andreas K. Hüttel <dilfridge@gentoo.org> (03 Apr 2016)
# Can exhaust all available memory depending on task
# but is made available for experts who heed this warning
# as newer versions produce different output. Contact
# the proxied maintainer Matthew Brewer <tomboy64@sina.cn>
# for questions.
<=media-gfx/slic3r-1.1.9999

# Patrick Lauer (30 Mar 2015)
# Segfaults when creating directories #578582
=sys-apps/sandbox-2.11*

# José María Alonso <nimiux@gentoo.org> (24 Mar 2016)
# Fails to build dev-lisp/sbcl-1.3.3 #563812
=dev-lisp/asdf-3.1.7
=dev-lisp/uiop-3.1.7

# Aaron Bauman <bman@gentoo.org> (19 Mar 2016)
# Unpatched security vulnerability per bug #512356.
=app-forensics/chkrootkit-0.49

# Patrick Lauer <patrick@gentoo.org> (22 Feb 2016)
# Inactive upstream, build failures, obsoleted by rakudo/perl6
dev-lang/niecza
dev-lang/niecza-bin

# Eray Aslan <eras@gentoo.org> (22 Feb 2016)
# Mask experimental software
=mail-mta/postfix-3.2*

# Sergey Popov <pinkbyte@gentoo.org> (15 Feb 2016)
# Security mask, wrt bug #519730
<app-emulation/ganeti-2.11.6-r2

# Alexis Ballier <aballier@gentoo.org> (15 Feb 2016)
# Breaks some of its reverse dependencies.
# Bug 574788
>=media-video/ffmpeg-3.0
>=media-video/mplayer-1.3.0

# James Le Cuirot <chewi@gentoo.org> (07 Feb 2016)
# Masked until 2.0 final arrives, which hopefully won't depend on
# commons-dbcp:0 as that requires Java 6. Note that the 2.0 in the
# tree should have actually been 2.0_beta1. There are no revdeps.
dev-java/jcs

# Mike Frysinger <vapier@gentoo.org> (18 Jan 2016)
# Force people to migrate to the new combined libraries:
# media-libs/elementary & dev-libs/efl. #571796
app-benchmarks/expedite
dev-games/etrophy
dev-libs/ecore
dev-libs/edbus
dev-libs/eet
dev-libs/eeze
dev-libs/efreet
dev-libs/eina
dev-libs/eio
dev-libs/embryo
dev-libs/eobj
dev-libs/ephysics
media-libs/edje
media-libs/emotion
media-libs/ethumb
media-libs/evas
x11-plugins/echievements

# Andreas K. Hüttel <dilfridge@gentoo.org> (9 Jan 2016)
# Errorneously added. Is already in perl-core. Please uninstall.
dev-perl/ExtUtils-Constant

# Pacho Ramos <pacho@gentoo.org> (06 Jan 2016)
# Unbuildable for a long time, bug #522916. Removal in a month.
net-im/silc-server

# Andrey Grozin <grozin@gentoo.org> (04 Jan 2016)
# Needs a bump and substantial ebuild rewrite
=sci-mathematics/reduce-20110414-r1

# Victor Ostorga <vostorga@gentoo.org> (30 Dec 2015)
# Mask this liferea version because upstream released it broken
=net-news/liferea-1.10.17

# Michał Górny <mgorny@gentoo.org> (30 Oct 2015)
# Uses unsafe ioctls that could result in data corruption. Upstream
# is working on replacing them in the wip/dedup-syscall branch.
# Keep it masked until they are done. sys-fs/duperemove is
# the suggested replacement for the meantime.
sys-fs/bedup

# Ian Delaney <idella4@gentoo.org> (27 Oct 2015)
# fails to build dev-lisp/sbcl-1.2.16 #563812
# mgorny: dev-lisp/uiop as version-bound revdep
=dev-lisp/asdf-3.1.6
=dev-lisp/uiop-3.1.6

# Justin Lecher <jlec@gentoo.org> (23 Oct 2015)
# Breaking changes #563540
=app-text/ghostscript-gpl-9.18

# Mike Pagano <mpagano@gentoo.org> (2 Oct 2015)
# A regression in kernel 4.1.9 could lead to a system
# lockup.  This has been fixed in gentoo-sources-4.1.9-r1
# and the hope is that this patch will make it to 4.1.10
# Expires (2 Oct 2017)
=sys-kernel/vanilla-sources-4.1.9
=sys-kernel/gentoo-sources-4.1.9

# Andreas K. Huettel <dilfridge@gentoo.org> (19 Sep 2015)
# Masked for security reasons, bugs 516044, 552644
# Keeping it in the tree for now for users who cannot upgrade
# (commercial product, separate licenses for major versions)
=app-emulation/vmware-workstation-9*
=app-emulation/vmware-modules-271*

# Lars Wendler <polynomial-c@gentoo.org> (09 Sep 2015)
# Masked for testing
>=net-fs/samba-4.3.0

# Lars Wendler <polynomial-c@gentoo.org> (20 Aug 2015)
# Releases are not from original upstream but from a fork.
# Masked as requested by vapier.
~net-misc/iputils-20160308

# Sebastian Pipping <sping@gentoo.org> (8 Aug 2015)
# Upcoming, too young to go into testing unmasked
dev-libs/iniparser:4

# Davide Pesavento <pesa@gentoo.org> (23 Jul 2015)
# Standalone version of qtwebkit from the 2.3 upstream branch.
# Needs revdep testing. Bug #388207.
=dev-qt/qtwebkit-4.10*

# Ian Delaney <idella4@gentoo.org> (21 Jul 2015)
# The revbump has versions of lua which are also masked.
# Masked until those slotted versions are unmasked
=sys-apps/roccat-tools-3.5.0-r1

# Ben de Groot <yngwin@gentoo.org> (20 Jul 2015)
# Version bump is a WIP, see bug #524242
# It works (except USE=vamp) but is not up to Gentoo standards yet
>=media-sound/audacity-2.1.1

# Patrick Lauer <patrick@gentoo.org> (1 Jul 2015)
# Wrong version #553670
=sys-kernel/gentoo-sources-4.1.1

# Patrick Lauer <patrick@gentoo.org> (14 Jun 2015)
# Has race condition / failure modes that make systems unusable
# See #551724 and duplicates
=sys-fs/udev-init-scripts-29

# Justin Lecher <jlec@gentoo.org> (28 Feb 2015)
# Unfixed security problems
# No upstream support anymore
# CVE-2015-{0219,0220,0221,0222,5145}
# #536586
# #554864
=dev-python/django-1.4*
=dev-python/django-1.5*
=dev-python/django-1.6*
# Not supported by any django version upstream supports
dev-python/south

# Tony Vroon <chainsaw@gentoo.org> (5 Jan 2015)
# Asterisk 13 is an LTS release but has not seen
# sufficient releases to be considered ready for
# production usage. You are welcome to have a go
# but please be careful.
=net-misc/asterisk-13*

# Jeroen Roovers <jer@gentoo.org> (12 Dec 2014)
# The 96 and 173 branches are no longer supported and remain vulnerable to
# CVE-2014-8298 (bug #532342). You may be able to mitigate the vulnerability by
# disabling GLX indirect rendering protocol support on the X server.
<x11-drivers/nvidia-drivers-304

# Sergey Popov <pinkbyte@gentoo.org> (28 Aug 2014)
# Security mask, wrt bug #519650
# If your application is broken due to this mask,
# please file a separate bug report
<net-dialup/ppp-2.4.7

# Samuli Suominen <ssuominen@gentoo.org> (23 Aug 2014)
# Some compile problems with media-libs/openexr >= 2.2.0
# See https://bugs.gentoo.org/520240 for more information
>=media-libs/ilmbase-2.2.0
>=media-libs/openexr-2.2.0
>=media-gfx/openexr_viewers-2.2.0

# Robin H. Johnson <robbat2@gentoo.org> (04 Aug 2014)
# Masked for testing, presently fails upstream testsuite:
# FAIL:07:02:35 (00:00:00) db_dump/db_load(./TESTDIR.3/recd001.db:child killed: kill signal): expected 0, got 1
# FAIL:07:02:35 (00:00:00) Dump/load of ./TESTDIR.3/recd001.db failed.
# FAIL:07:02:35 (00:00:00) db_verify_preop: expected 0, got 1
=sys-libs/db-6.1*
=sys-libs/db-6.2*

# Ulrich Müller <ulm@gentoo.org> (15 Jul 2014)
# Permanently mask sys-libs/lib-compat and its reverse dependencies,
# pending multiple security vulnerabilities and QA issues.
# See bugs #515926 and #510960.
sys-libs/lib-compat
sys-libs/lib-compat-loki
games-action/mutantstorm-demo
games-action/phobiaii
games-fps/rtcw
games-fps/unreal
games-strategy/heroes3
games-strategy/heroes3-demo
games-strategy/smac
sys-block/afacli

# Mikle Kolyada <zlogene@gentoo.org> (27 Jun 2014)
# Masked for proper testing. (Major updates in the code).
~dev-perl/PortageXS-0.02.12
~dev-perl/PortageXS-0.2.12

# Robin H. Johnson <robbat2@gentoo.org> (21 Jun 2014)
# Needs work, but infra needs it for new VM boxes
app-emulation/openstack-guest-agents-unix
app-emulation/xe-guest-utilities

# Hans de Graaff <graaff@gentoo.org> (1 Jun 2014)
# Mask new rubinius version for testing. This needs more work
# to fully integrate it in our Gentoo ruby handling. Volunteers
# welcome.
=dev-lang/rubinius-3*

# Tom Wijsman <TomWij@gentoo.org> (03 May 2014)
# Needs to be further tested and revised by both Java and Ruby herds.
>=dev-java/jruby-1.7.12
dev-ruby/bitescript
dev-ruby/duby
dev-ruby/weakling

# Matti Bickel <mabi@gentoo.org> (22 Apr 2014)
# Masked slotted lua for testing
# William Hubbs <williamh@gentoo.org> (07 Aug 2016)
# Taking this mask since Mabi is retired
app-eselect/eselect-lua
=dev-lang/lua-5.1.5-r2
=dev-lang/lua-5.1.5-r100
=dev-lang/lua-5.2.3
=dev-lang/lua-5.2.3-r1

# Chí-Thanh Christopher Nguyễn <chithanh@gentoo.org> (26 Mar 2014)
# Affected by multiple vulnerabilities, #445916, #471098 and #472280
<media-libs/mesa-9.1.4

# Sergey Popov <pinkbyte@gentoo.org> (20 Mar 2014)
# Security mask of vulnerable versions, wrt bug #424167
<net-nds/openldap-2.4.35

# Mike Gilbert <floppym@gentoo.org> (04 Mar 2014)
# Dev channel releases are only for people who are developers or want more
# experimental features and accept a more unstable release.
www-plugins/chrome-binary-plugins:unstable

# Justin Lecher <jlec@gentoo.org> (14 Oct 2013)
# Seems to break all deps - API change?
>=sci-libs/metis-5

# Sergey Popov <pinkbyte@gentoo.org> (18 Sep 2013)
# Mask development releases of botan:
# - causes many API breakages
# - do not compile in some USE-flag combinations
# - requires at least gcc 4.7(and possibly even 4.8 for some features)
>=dev-libs/botan-1.11.0

# Julian Ospald <hasufell@gentoo.org> (21 Jul 2013)
# Mask all unfetchable versions and those with tons of random
# bugs and segfaults (all). Don't ask for a version bump unless
# there is a working release.
sci-geosciences/googleearth

# Michael Weber <xmw@gentoo.org> (17 Jul 2013)
# Upstream next versions
>=sys-boot/raspberrypi-firmware-1_pre

# Julian Ospald <hasufell@gentoo.org> (26 Jun 2013)
# Depends on masked dev-lang/lua-5.2
=games-emulation/sdlmame-0.149
=games-emulation/sdlmess-0.149

# Chí-Thanh Christopher Nguyễn <chithanh@gentoo.org> (25 Jun 2013)
# Mask new ptlib/opal for breakage, tracked in bug #474742
# Lars Wendler <polynomial-c@gentoo.org> (29 Apr 2014)
# Adjusted mask so newer versions get covered as well.
>=net-libs/ptlib-2.12.0
>=net-libs/opal-3.12.0

# Pacho Ramos <pacho@gentoo.org> (15 Jun 2013)
# Upstream stalled, improper rendering (#470818),
# use app-editors/efte instead.
=app-editors/fte-20110708

# Michael Weber <xmw@gentoo.org> (18 Apr 2013)
# Masked due test failures
=app-arch/advancecomp-1.17

# Richard Freeman <rich0@gentoo.org> (24 Mar 2013)
# Contains known buffer overflows.  Package generally works
# but should not be fed untrusted input (eg from strangers).
# Masked to ensure users are aware before they install.
app-text/cuneiform

# Samuli Suominen <ssuominen@gentoo.org> (06 Mar 2012)
# Masked for testing since this is known to break nearly
# every reverse dependency wrt bug 407091
>=dev-lang/lua-5.2.0

# Samuli Suominen <ssuominen@gentoo.org> (30 Oct 2011)
# Masked for security bug #294253, use only at your own risk!
=media-libs/fmod-3*

# Mike Frysinger <vapier@gentoo.org> (07 Mar 2010)
# Very old packages that people should have upgraded away from
# long ago.  Courtesy mask ... time to upgrade.
# Added <sys-fs/e2fsprogs as well (halcy0n)
<sys-libs/e2fsprogs-libs-1.41.8
<sys-fs/e2fsprogs-1.41.9

# Diego E. Pettenò <flameeyes@gentoo.org> (03 Jan 2009)
# These packages are not supposed to be merged directly, instead
# please use sys-devel/crossdev to install them.
dev-libs/cygwin
dev-util/mingw-runtime
dev-util/mingw64-runtime
dev-util/w32api
sys-libs/newlib
dev-embedded/msp430-binutils
dev-embedded/msp430-gcc
dev-embedded/msp430-gdb
dev-embedded/msp430-libc
dev-embedded/msp430mcu
dev-embedded/avr-libc

# Chris Gianelloni <wolf31o2@gentoo.org> (03 Mar 2008)
# Masking due to security bug #194607 and security bug #204067
games-fps/doom3
games-fps/doom3-cdoom
games-fps/doom3-chextrek
games-fps/doom3-data
games-fps/doom3-demo
games-fps/doom3-ducttape
games-fps/doom3-eventhorizon
games-fps/doom3-hellcampaign
games-fps/doom3-inhell
games-fps/doom3-lms
games-fps/doom3-mitm
games-fps/doom3-phantasm
games-fps/doom3-roe
games-fps/quake4-bin
games-fps/quake4-data
games-fps/quake4-demo

# <klieber@gentoo.org> (01 Apr 2004)
# The following packages contain a remotely-exploitable
# security vulnerability and have been hard masked accordingly.
#
# Please see https://bugs.gentoo.org/show_bug.cgi?id=44351 for more info
#
games-fps/unreal-tournament-goty
games-fps/unreal-tournament-strikeforce
games-fps/unreal-tournament-bonuspacks
games-fps/aaut
