<!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-2011 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),</li>
<li>the NeoMAD Tools by Neomades,</li>
<li>the Javaground Tools, 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>
