diff --git a/org.aspectj.weaver/about.html b/org.aspectj.weaver/about.html
index ffc57b4..c4f9918 100644
--- a/org.aspectj.weaver/about.html
+++ b/org.aspectj.weaver/about.html
@@ -38,45 +38,6 @@
 		code for the modified version of BCEL is available at Eclipse.org in the AspectJ source tree. This code
 		is made available under the Apache Software License v1.1</p>
 		
-		<strong>ASM v2.2.1</strong> 
-		<p>AspectJ includes a binary version of ASM v2.2.1 (<a href="http://asm.objectweb.org/index.html">http://asm.objectweb.org/</a>)
-		The source code for ASM is available from the ObjectWeb download site at 
-		<a href="http://asm.objectweb.org/download/">http://asm.objectweb.org/download/</a>. 
-		<p>The ASM license is available at <a href="http://asm.objectweb.org/license.html">http://asm.objectweb.org/license.html</a>. 
-		The license is also reproduced here:
-		</p>
-
-<pre>Copyright (c) 2000-2005 INRIA, France Telecom
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holders nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGE.
-</pre>	
-
 		</em></p>
 
 
diff --git a/org.aspectj.weaver/aspectjweaver.jar b/org.aspectj.weaver/aspectjweaver.jar
index ad6d4bc..2cc68df 100644
--- a/org.aspectj.weaver/aspectjweaver.jar
+++ b/org.aspectj.weaver/aspectjweaver.jar
Binary files differ
diff --git a/org.aspectj.weaver/aspectjweaversrc.zip b/org.aspectj.weaver/aspectjweaversrc.zip
index 1fa59ce..e9b28f9 100644
--- a/org.aspectj.weaver/aspectjweaversrc.zip
+++ b/org.aspectj.weaver/aspectjweaversrc.zip
Binary files differ
