<?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]
      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>
