<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>About</title>
</head>
<body lang="EN-US">
	<h2>About This Content</h2>

	<p>November 30, 2017</p>
	<h3>License</h3>

	<p>
		The Eclipse Foundation makes available all content in this plug-in
		(&quot;Content&quot;). Unless otherwise indicated below, the Content
		is provided to you under the terms and conditions of the Eclipse
		Public License Version 2.0 (&quot;EPL&quot;). A copy of the EPL is
		available at <a href="http://www.eclipse.org/legal/epl-2.0">http://www.eclipse.org/legal/epl-2.0</a>.
		For purposes of the EPL, &quot;Program&quot; will mean the Content.
	</p>

	<p>
		If you did not receive this Content directly from the Eclipse
		Foundation, the Content is being redistributed by another party
		(&quot;Redistributor&quot;) and different terms and conditions may
		apply to your use of any object code in the Content. Check the
		Redistributor's license that was provided with the Content. If no such
		license exists, contact the Redistributor. Unless otherwise indicated
		below, the terms and conditions of the EPL still apply to any source
		code in the Content and such source code may be obtained at <a
			href="http://www.eclipse.org/">http://www.eclipse.org</a>.
	</p>

	
<h3>Disassembler</h3>
<p>This plug-in contains a bytecode disassembler (&quot;Disassembler&quot;) that can produce a listing of the Java assembler mnemonics (&quot;Assembler Mnemonics&quot;) for a Java method.  If you 
use the Disassembler to view the Assembler Mnemonics for a method, you should ensure that doing so will not violate the terms of any licenses that apply to your use of that method, as
such licenses may not permit you to reverse engineer, decompile, or disassemble method bytecodes.</p>

<h4>Version</h4>
This version of the JDT has been modified for the Object Teams Development Tooling.

</body>
</html>