<html>
<head>
<!--

    Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.

    This program and the accompanying materials are made available under the
    terms of the Eclipse Public License v. 2.0, which is available at
    http://www.eclipse.org/legal/epl-2.0.

    This Source Code may also be made available under the following Secondary
    Licenses when the conditions for such availability set forth in the
    Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
    version 2 with the GNU Classpath Exception, which is available at
    https://www.gnu.org/software/classpath/license.html.

    SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0

-->

<title>Eclipse Foundation Specification License - v1.0</title>
</head>
<body>
<h1>Eclipse Foundation Specification License - v1.0</h1>
<p>By using and/or copying this document, or the Eclipse Foundation
  document from which this statement is linked, you (the licensee) agree
  that you have read, understood, and will comply with the following
  terms and conditions:</p>

<p>Permission to copy, and distribute the contents of this document, or
  the Eclipse Foundation document from which this statement is linked, in
  any medium for any purpose and without fee or royalty is hereby
  granted, provided that you include the following on ALL copies of the
  document, or portions thereof, that you use:</p>

<ul>
  <li> link or URL to the original Eclipse Foundation document.</li>
  <li>All existing copyright notices, or if one does not exist, a notice
      (hypertext is preferred, but a textual representation is permitted)
      of the form: &quot;Copyright &copy; [$date-of-document]
      &ldquo;Eclipse Foundation, Inc. &lt;&lt;url to this license&gt;&gt;
      &quot;
  </li>
</ul>

<p>Inclusion of the full text of this NOTICE must be provided. We
  request that authorship attribution be provided in any software,
  documents, or other items or products that you create pursuant to the
  implementation of the contents of this document, or any portion
  thereof.</p>

<p>No right to create modifications or derivatives of Eclipse Foundation
  documents is granted pursuant to this license, except anyone may
  prepare and distribute derivative works and portions of this document
  in software that implements the specification, in supporting materials
  accompanying such software, and in documentation of such software,
  PROVIDED that all such works include the notice below. HOWEVER, the
  publication of derivative works of this document for use as a technical
  specification is expressly prohibited.</p>

<p>The notice is:</p>

<p>&quot;Copyright &copy; 2018 Eclipse Foundation. This software or
  document includes material copied from or derived from [title and URI
  of the Eclipse Foundation specification document].&quot;</p>

<h2>Disclaimers</h2>

<p>THIS DOCUMENT IS PROVIDED &quot;AS IS,&quot; AND THE COPYRIGHT
  HOLDERS AND THE ECLIPSE FOUNDATION MAKE NO REPRESENTATIONS OR
  WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
  WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
  NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE
  SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS
  WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR
  OTHER RIGHTS.</p>

<p>THE COPYRIGHT HOLDERS AND THE ECLIPSE FOUNDATION WILL NOT BE LIABLE
  FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT
  OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE
  CONTENTS THEREOF.</p>

<p>The name and trademarks of the copyright holders or the Eclipse
  Foundation may NOT be used in advertising or publicity pertaining to
  this document or its contents without specific, written prior
  permission. Title to copyright in this document will at all times
  remain with copyright holders.</p>

</body>
</html>
