<?php
/**
 * Copyright (c) 2018 Eclipse Foundation and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * Contributors:
 * Eric Poirier (Eclipse Foundation) - Initial implementation
 *
 * SPDX-License-Identifier: EPL-2.0
 */
?>

<h1><?php print $pageTitle; ?></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>
