<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Eclipse Foundation Contributor&rsquo;s Certificate of Origin</title>

</head>

<body lang="EN-US">
	<div id="text1">
		<h1>Eclipse Foundation Contributor License Agreement</h1>
		<p>Version 1.0.0&nbsp;&nbsp;&nbsp;June 17, 2013</p>

		<p id="reference"><strong>This is a reference copy of the terms of the Eclipse Foundation Contributor
			License Agreement. To actually complete and submit a CLA, please go to the 
			CLA form.
		</strong></p>

			<p>Thank
			you for your interest in one or more projects managed by the Eclipse
			Foundation, Inc. &#40;&quot;Eclipse Foundation&quot;&#41;. In order for You
			&#40;as defined below&#41; to make intellectual property Contributions &#40;as
			defined below&#41; now or in the future to Eclipse Foundation projects,
			You must agree to this Contributor License Agreement &#40;&quot;CLA&quot;&#41;.
			If You have any questions about this agreement, licensing, or
			anything related to intellectual property at the Eclipse Foundation,
			please send an email to <a href="mailto:license@eclipse.org">license@eclipse.org</a>.
			</p>
			<p>Please
			read this CLA carefully before accepting its terms. By accepting the
			CLA, You are agreeing to be bound by its terms.&nbsp; If You want to
			accept this CLA, complete the form completely, print a copy for Your
			records, and when ready, press the &ldquo;<b>Accept&rdquo;</b> button
			at the end of this form.&nbsp; 
			</p>
			<p>As
			used in this CLA: &#40;i&#41; &ldquo;You&quot; &#40;or &quot;Your&quot;&#41; shall
			mean the entity that is making this Agreement with the Eclipse
			Foundation; &#40;ii&#41;&quot;Contribution&quot; shall mean any original work
			of authorship, including any modifications or additions to an
			existing work, that is submitted by You to the Eclipse Foundation for
			inclusion in, or documentation of, any of the Eclipse Foundation
			projects; and &#40;iii&#41;&nbsp; &ldquo;Submit&rdquo; &#40;or &ldquo;Submitted&rdquo;&#41;&nbsp;&nbsp;
			means any form of communication sent to the Eclipse Foundation &#40;e.g.
			the content You post on electronic mailing lists, forums, content
			management systems, source code control systems, code review systems,
			issue tracking systems, etc. that are used by the Eclipse
			Foundation&#41;.</p>
			<p>This
			agreement applies to all Contributions You Submit.&nbsp; 
			</p>
			<p>This
			CLA, and the license&#40;s&#41; associated with the particular Eclipse
			Foundation projects You are contributing to, provides a license to
			Your Contributions to the Eclipse Foundation and downstream
			consumers, but You still own Your Contributions, and except for the
			licenses provided for in this CLA, You reserve all right, title and
			interest in Your Contributions. 
			</p>
			<p>The
			Eclipse Foundation requires that each Contribution You Submit now or
			in the future to comply with the following four commitments. To
			confirm that You have read and agreed to each, please click on the
			box beside each one.</p>
		</div>
		<ul>
			<li id="question1">You
			will only Submit Contributions where You have authored 100% of the
			content.</li>
			<li id="question2">You
			will only Submit Contributions to which You have the necessary
			rights. This means that if You are employed You have received the
			necessary permissions from Your employer to make the Contributions.</li>
			<li id="question3">Whatever
			content You Contribute will be provided under the license&#40;s&#41;
			associated with the particular Eclipse Foundation project You are
			contributing to. You can see the license&#40;s&#41;, or find links to the
			license&#40;s&#41; in the notices and file headers for the project. 
			</li>
			<li id="question4">You understand and agree that Eclipse projects and Your contributions are public, 
			and that a record of the contribution &#40;including all personal information You submit with it, 
			including Your sign-off&#41; is maintained indefinitely and may be 
			redistributed consistent with the license&#40;s&#41; involved.</li>
		</ul>
		<div id="text2">
			<p>You
			will promptly notify the Eclipse Foundation if You become aware of
			any facts or circumstances that would make these commitments
			inaccurate in any way. To do so, please send an email to
			<a href="mailto:license@eclipse.org">license@eclipse.org</a>.</p>
			<p>If
			You think an Eclipse Foundation project could make use of content
			which You did not author, please talk to a
			committer on that Eclipse Foundation project. If they like Your idea, they
			will know the process to get it included. 
			</p>
			<p>The
			Eclipse Foundation takes intellectual property very seriously, so we
			are going to ask You to re-confirm this CLA every three	years.</p>
		</div>
		<div id="text3">
		<p>You represent that the information provided below is accurate.</p>
		</div>
</body>

</html>