<!DOCTYPE html PUBLIC "-//IETF//DTD HTML 2.0//EN">
<HTML>
<HEAD>
<TITLE>Special Exception to the GNU General Public License</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#1F00FF" ALINK="#FF0000" VLINK="#9900DD">
<H1>Special Exception to the GNU General Public License</H1>

<P>
Copyright &copy; 2002-2014 Eric Lafortune
</P>

<P>
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
</P>

<P>
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
</P>

<P>
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307 USA
</P>

<P>
In addition, as a special exception, Eric Lafortune gives permission to link
the code of this program with the following stand-alone applications:
<ul>
<li>Apache Ant,</li>
<li>Apache Maven,</li>
<li>the Google Android SDK,</li>
<li>the Eclipse ProGuardDT GUI,</li>
<li>the EclipseME JME IDE,</li>
<li>the Oracle NetBeans Java IDE,</li>
<li>the Oracle JME Wireless Toolkit,</li>
<li>the Simple Build Tool for Scala (and its scripts), and</li>
<li>the Sanaware Tools.</li>
</ul>
and distribute linked combinations including the two. You must obey the GNU
General Public License in all respects for all of the code used other than
these programs. If you modify this file, you may extend this exception to your
version of the file, but you are not obligated to do so. If you do not wish to
do so, delete this exception statement from your version.
</P>

</BODY>
</HTML>
