<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta http-equiv="CONTENT-TYPE" content="text/html; charset=utf-8">
<TITLE>OpenOffice.org Community Innovation Program</TITLE>
<meta name="GENERATOR" content="OpenOffice.org 2.4  (Unix)">
<style type="text/css">
  <!--
    @page { size: 8.5in 11in; margin-left: 1.25in; margin-right: 1.25in; margin-top: 0.5in; margin-bottom: 0.5in }
    P { margin-top: 0.08in; margin-bottom: 0.08in; }
    -->
  </style>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.4  (Unix)">
</head>
<body>
<h1 align=center>OpenOffice.org Community Innovation Program</h1>
<p align=center><strong>OFFICIAL RULES<br>
  NO PURCHASE NECESSARY</strong></p>
<h3>Update 2008-10-06</h3>
<p><strong>Awardees <a href="awardees-2008.html">announced</a>!</strong></p>
<p></p>
<h2>Introduction</h2>
<p>On 7 December 2007, Sun Microsystems Inc. <a href="http://www.sun.com/software/opensource/awards/index.jsp">announced</a> a new million-dollar program to foster innovation in six of the open-source projects it sponsors and contributes to. We are pleased to report that OpenOffice.org was included.</p>
<p>The “$1 Million Open Source Community Innovation Awards Program,” is generous in many ways. Although Sun will be handing out the actual cash and is ultimately the arbiter of who is eligible to be granted those cash awards, each community has been given the freedom, within limits, to devise its own focus and administer the program. </p>
<p>OpenOffice.org's interest lies in encouraging the development of technology and endeavours that advance the community and its products, and our Community is international. Accordingly, we have established “The OpenOffice.org Community Innovation Program,” which takes the form of a world-wide contest, with contestants competing for Gold, Silver, or Bronze prizes. Cash Prizes will be given to the winners in accordance with these Official Rules, as well as to those who have earned &quot;Honourable Mention,&quot; except where international legal considerations prohibit payments of this nature. In that case, OpenOffice.org will give the winners public honour and attention for their work.</p>
<p>A PDF version of these rules and other ancillary information can be found at <a href="community_innovation_program.pdf">http://development.openoffice.org/community_innovation_program.pdf</a>.
<br>
For examples see the
<a href="http://wiki.services.openoffice.org/wiki/Community_Innovation_Program/proposals">proposals for possible entries</a>.
These should be seen as suggestions, but should in no way limit the creativity of Entrants.
<br>
If you have questions, send a message to <a href="mailto:community-program@council.openoffice.org">community-program@council.openoffice.org.</a></p>
<center>
  ________________
</center>
<h2>Rules: Basics</h2>
<ul>
  <li value=1>
    <p> <strong>Goal and</strong> <strong>description of Program. </strong>The goal of OpenOffice.org Community Innovation Program (“Program”) is to foster Community development and innovation in the OpenOffice.org Community (“the Sponsor”). Prize winners will be selected by a panel of judges based on the criteria set forth in these Official Rules. All work must be able to be subsequently developed by the Community and all work must abide by OpenOffice.org’s license scheme. Entrants are encouraged to submit Entries that encourage Community participation.</p>
</ul>
<h3>Eligibility</h3>
<ul>
  <li value=1>
    <p><strong>Who is eligible:</strong> This Program is open only to individuals who are OpenOffice.org members and who have reached the legal age of majority in their country, province or state of legal residence. However, only legal residents of certain jurisdictions and countries are eligible to win a cash prize. These &quot;Prize Eligible Territories&quot; include: Argentina, Australia, Belgium, Brazil, Bulgaria, Canada (excluding the Province of Quebec), Chile, China, the Czech Republic, Denmark, Finland, France, Germany, Hungary, India, Indonesia, Israel, Italy, Japan, South Korea, Malaysia, Mexico, Netherlands, Norway, Peru, Poland, Russia, South Africa, Spain, Sweden, Switzerland, Taiwan, Thailand, Turkey, the United Kingdom, Vietnam, and the fifty United States and the District of Columbia. Sponsor reserves the right in its sole discretion to add to the list of Prize Eligible Territories at any time during the Program Period.</p>
    <ul>
      <li>
        <p> <strong>Important note.</strong>Entrants who otherwise meet the Sponsor's eligibility requirements above and legally reside in a territory that is not included on the list of Prize Eligible Territories may only participate in the Program to receive public recognition by the OpenOffice.org Program Committee for their work in the form of a public declaration that the Entry is deserving of an award under the Judging Criteria, but are <i>not</i> eligible to be awarded a cash prize.</p>
    </ul>
  <li>
    <p><strong>Who is not eligible</strong>. Employees of the Sponsor (OpenOffice.org) and Sun Microsystems Inc. and each of its parent companies, affiliates and subsidiaries, participating advertising and promotion agencies (and members of their immediate family, defined as parents, children, siblings and spouse, regardless of where they reside, and/or those living in the same household) are not eligible. Elected and appointed members of the OpenOffice.org Community Council and Community Awards Committee are ineligible. Entrants must also have access to the Internet and a valid email address in order to enter. The Program is void in Cuba, Iran, Syria, North Korea, Sudan, and Burma (Myanmar), and where prohibited by law: these are the &quot;Void Territories.&quot; Residents of the Void Territories are not eligible to participate in the or to win a cash Prize. </p>
  <li>
    <p><strong>Individuals and teams.</strong> Entrants may submit work on their own behalf or on behalf of a team. &quot;Entrant&quot; can mean individual or team. Individual entrants must certify that they meet the eligibility criteria set above. In the event that an Entry is submitted by a team, all individual members of the team must meet the eligibility requirements set forth herein, and must be members of the OpenOffice.org Community as defined in the Community Guidelines (<a href="http://www.openoffice.org/dev_docs/guidelines.html">http://www.openoffice.org/dev_docs/guidelines.html)</a> both at the time the Entry is submitted and at the time the prizes are awarded. In the event that any individual member of a team does not meet the eligibility requirements set forth herein, the Entry from that team will be disqualified. In the event that any individual member of a team is not a legal resident of a Prize Eligible Territory, the entire team will be ineligible to be awarded a cash prize. All individual members of a team must be identified as a member of the team at the time of registration and on the Entry submission. Only those individuals who have been identified at the time of Entry as a member of the team will be deemed to be members of the team and eligible to win a prize. All Entrants must certify at the time of entry whether they are eligible for a cash prize in accordance with these Official Rules.</p>
  <li>
    <p><strong>Team limits</strong>. A team may not be larger than ten (10) persons. Members of the relevant project or projects are not eligible for the award unless they have been identified as part of the Entrant's team at the time the Entry was submitted. Only eligible members may be included in the identified team; however, the Entrants (if any) may freely work with any project member or members who is not a team member or participating in this contest or able to, as long as the Entry submitted complies with these Official Rules.</p>
</ul>
<p>IMPORTANT NOTICE TO ENTRANTS: ENTRANTS ARE RESPONSIBLE FOR DETERMINING THE CORRESPONDING TIME ZONE WHERE THEY RESIDE.</p>
<h2>How to submit an Entry </strong> </h2>
<ul>
  <li value=1>All Entries must be submitted as an attachment emailed to: <a href="mailto:community-program@council.openoffice.org">community-program@council.openoffice.org</a>.
  <li>
    <p><strong>Note</strong>. Each individual or team who submits an Entry in accordance with these Official Rules will be deemed an “Entrant.” If an Entry is submitted by a team, the team must designate one individual member of the team as the Team Leader for contact purposes only. The team leader shall be responsible for submitting the Entry on behalf of the team and shall designate all members of the team associated with the Entry submission. Persons who are not named as a team member upon submission will not be deemed to be a member of the team and will not be eligible for prizes. Entrants may submit multiple Entries, but may win only one prize. </p>
</ul>
<p>Entries must clearly identify, in a presentation or text document not longer than 2000 words:</strong></p>
<ul>
  <li>
    <p>Name, contact details, and country of residence of the Entrant</p>
  <li>
    <p>For team entries, names, contact details, and countries of residence of all team members</p>
  <li>
    <p>Whether the Entrant(s) meet the Eligibility Criteria for cash awards</p>
  <li>
    <p>Which one of the six Categories of Interest the Entry is addressing</p>
  <li>
    <p>The problem addressed and why it is interesting</p>
  <li>
    <p>The methods used</p>
  <li>
    <p>The resources used</p>
  <li>
    <p>For development work, source code and full documentation, supporting test cases, etc.</p>
  <li>
    <p>Any other information that will help the Program Committee evaluate the merits of the Entry</p>
</ul>
<p>All personal information provided by the Entrant for this contest will be held in accordance with the Sponsor's privacy policy, which, for the purposes of this Program, corresponds to that of Sun Microsystems (see <a href="http://www.sun.com/privacy/">http://www.sun.com/privacy/</a>).</p>
<p> <strong>Dates</strong>. All Entries must be received between <strong>30 January 2008 0800 UTC and 23 June 2008 23:59 UTC </strong>(“Program Period”). The Sponsor’s clock is the official time clock of the Program. Proof of submission does not constitute proof of receipt. </p>
<p>Important notes</strong></p>
<p> Each Entry is subject to and must also comply with the following guidelines: </p>
<ul>
  <li value=1>
    <p> Entries may not contain any content or material that is lewd, obscene, sexually explicit, pornographic, disparaging, defamatory, libelous, obscene, inappropriate or objectionable, as determined by the Sponsor and/or Program Committee in their sole and absolute discretion. </p>
  </li>
  <li>
    <p> The Entry must be the Entrant’s original work, created solely by the Entrant, and must not infringe the copyright, trademark, privacy, publicity, or other intellectual rights of any person or entity.</p>
  </li>
  <li>
    <p> The Entry must not contain any personally identifiable information of any person other than the Entrant. If any persons appear in the Entry, the Entrant is responsible for obtaining, prior to sending the Entry, any and all releases and consents necessary to permit the exhibition and use of the Entry by Sponsor as set forth in these Official Rules. If any person appearing in any Entry is under the age of majority in their state, country or province of residence, the signature of a parent or legal guardian is required on each release.</p>
  <li>
    <p> Should the Entrant include personally identifiable information about him/herself in his/her Entry, other than contact information accompanied with the Entry, Entrant acknowledges and agrees that such information will be disclosed publicly and Entrant is solely responsible for any consequences thereof. </p>
  </li>
  <li>
    <p> All Entries submitted must abide by the OpenOffice.org license policy, available at <a href="http://www.openoffice.org/license.html">http://www.openoffice.org/license.html</a></p>
  </li>
  <li>
    <p> All Entries must be in English. Those in any other language will be returned to the entrant for resubmission in English. </p>
  </li>
  <li>
    <p>The Entry must not contain any commercial content or logos.</p>
</ul>
<h3>Categories of Interest</h3>
<p>Entries must be submitted in one of the following six categories. Entrants must specify the Category of Interest and can submit each Entry under one category only. If you are unsure about which Category to use, use “Special.”</p>
<ul>
  <ul>
    <li>
      <p> <strong>Technical</strong>: core code, extensions, ports</p>
    <li>
      <p> <strong>Community</strong>: new methods of community cooperation, new marketing efforts, artwork, and other efforts that significantly further OpenOffice.org use and development, or the efficiency and effectiveness of the Community</p>
    <li>
      <p> <strong>Tools</strong>: those that help the community build, distribute, work on OpenOffice.org, including infrastructure development, localization tools, as well as a working environment, management system, and other developer support</p>
    <li>
      <p> <strong>OpenDocument Format (ODF)</strong>: work that advances ODF development, OpenOffice.org's implementation, or makes the ODF more accessible through the ODF Toolkit project </p>
    <li>
      <p> <strong>Documentation</strong>: both enduser and developer documentation and/or training materials; articles on OpenOffice.org for developers or endusers</p>
    <li>
      <p> <strong>Special: </strong>a catch-all category to submit innovative Entries that significantly further OpenOffice.org, its applications and projects, and furthers the Community as a whole</p>
  </ul>
</ul>
<p> <strong>Note</strong>. All Entrants are urged to work with the Community using the accepted community tools, such as mail lists, forums, IRC channels, wikis, and so on. Entrants, whether individuals or teams, should work under the supervision of their OpenOffice.org project lead or leads (“Project Leads”). The judges will take into consideration community participation and consider the advice of the relevant Project Leads when judging. Entries submitted without the input of an OpenOffice.org Project Lead will be at a disadvantage in the judging.</p>
<h2>Judging</h2>
<p>All Entries, regardless of Category, will be judged by a committee comprised of members of the OpenOffice.org Community Council. This Community Innovation Program Committee (the “Program Committee”) will judge Entries on the following equally weighted criteria to decide, in its sole discretion if the Entry should be selected for one of the Four Award Levels outlined in the “Prizes” Section: </p>
<ul>
  <li>
    <p>Originality, which includes the nature of the problem addressed and the innovative nature of the Entry;</p>
  <li>
    <p>The difficulty of the Entry, which includes the nature of the problem addressed and the difficulty in fashioning a solution;</p>
  <li>The current relevance of the Entry to the OpenOffice.org Community, and its completeness;
  <li>
    <p>The extent to which the Entry provides utility to the Community either by providing code that the Community uses and values or by fostering the Community's growth and development or; and</p>
  <li>
    <p>Community participation by the Entrant in developing the Entry. </p>
</ul>
<p> The Program Committee will consider the advice of the Project Leads in judging the entries in accordance with the criteria set forth above. An Entry that is submitted without having been worked on in the relevant project or projects and which is outside the supervision of any OpenOffice.org Project Lead (including Co-Lead) is at a disadvantage. Entrants are strongly encouraged to work within the community structure and with the Project Leads and other project members.</p>
<p>Note. </strong>The Program Committee reserves the right not to award any or all prizes in any Category or Award Level if, in their sole and absolute discretion, they do not receive a sufficient number of eligible or qualified Entries. In the event that more than one Entry is received with the same or nearly identical submission, only the first submitted Entry will be eligible. Winners will be notified by email on or around 21 July 2008, although the judging period may be extended without notice in the sole discretion of the Sponsor. Decisions of the Program Committee are final and binding in all respects.</p>
<h3>Prizes</h3>
<ul>
  <li value=1>
    <p> A maximum total of $175,000 USD may be awarded, provided that there are a sufficient number of meritorious Entries from eligible Entrants that meet the criteria set forth below.</p>
  <li>
    <p>Prizes are awarded for merit, meaning that it is entirely possible that there may be no winners in one Category of Interest or Award Level and several in another. </p>
  <li>
    <p>There are four Award Levels: Gold, Silver, Bronze, and Honourable Mention. </p>
</ul>
<ul>
  <ul>
    <li value=1>
      <p> Gold Awards will recognize outstanding achievement in advancing the OpenOffice.org Community or product. Silver Awards will recognize a significant achievement, and Bronze Awards a substantial contribution. In its sole discretion, the Program Committee may recognize Entries that although they do not qualify for a Gold, Silver or Bronze Award, nevertheless satisfy each of the four criteria set forth above by being original, non- trivial, useful to the community, and produced through Community participation. </p>
  </ul>
</ul>
<ul>
  <li value=1>
    <p> The total $175,000 USD cash prize fund will be divided among the Award Levels as follows: </p>
</ul>
<ul>
  <ul>
    <li value=1>
      <p> Gold - $75,000 USD;</p>
    <li>
      <p> Silver - $50,000 USD;</p>
    <li>
      <p> Bronze - $25,000 USD;</p>
    <li>
      <p> Honourable Mention - $25,000 USD. </p>
  </ul>
</ul>
<ul>
  <li>
    <p>The Gold, Silver, and Bronze Award Level cash prize pools will be divided equally among the Prize Eligible Territory Entrants selected by the Program Committee for that Award Level. The Honourable Mention Award Level cash prize pool will also be divided equally among the Prize Eligible Territory Entrants selected by the Program Committee for that Award Level; however, $5,000 USD is the maximum cash award that can be made to eligible Entrants selected for this prize pool. Any funds remaining in the Honourable Mention prize pool after the cash prizes have been made will be added to the Gold, Silver and Bronze prize pools in a 3:2:1 ratio.</p>
  <li>
    <p>If the Program Committee does not select any Prize Eligible Territory Entrants in one or more of the four Award Levels, the Sponsor reserves the right in its sole and absolute discretion to either (1) not award that prize money or (2) allocate that prize money in equal amounts to the remaining Award Level prize pools.</p>
</ul>
<ul>
  <li value=1>
    <p> If the Program Committee selects an Entry for an Award Level, but the Entrant is not a legal resident of a Prize Eligible Territory, and therefore not eligible for a cash prize under this Program, the Entrant will receive a public declaration acknowledging that the Entry was selected for the particular Award Level.</p>
</ul>
<ul>
  <li>
    <p>If a team should win any Award and be eligible to receive the associated cash prize, the cash prize amount will be apportioned equally among the team members as identified at the time the Entry was submitted.</p>
</ul>
<ul>
  <li>
    <p>All amounts will be awarded in U.S. dollars and all costs associated with currency exchange are the sole responsibility of the winners.</p>
</ul>
<p>Other expenses and costs. </strong>All other expenses not specified herein are the responsibility of the winner. All costs associated with currency exchange are the sole responsibility of the winner. ALL TAXES AND ANY APPLICABLE WITHHOLDING AND REPORTING REQUIREMENTS ARE THE SOLE RESPONSIBILITY OF THE CASH WINNER. </p>
<h2>Conditions of Participation</h2>
<p>Submission of an Entry into this Program constitutes Entrant’s agreement to be bound by the terms of these Official Rules and by the decisions of the Program Committee and Sponsor, which are final and binding on all matters pertaining to this Program. Return of any prize/prize notification may result in disqualification and selection of an alternate winner. Any potential winner who cannot be contacted within 15 days of first attempted notification will be disqualified and forfeit any prize to which s/he may be entitled. Potential prize winners may be required to sign and return an Affidavit of Eligibility/Liability &amp; where legally permissible, a Publicity Release, within 30 days following the date of first attempted notification. Failure to comply within this time period may result in disqualification and selection of an alternate winner. In the event a prize is won by a team, all individual members of the team must sign and return the required documentation within the time period specified or the entire team may be disqualified and an alternate winner may be selected. The designated team leader shall be responsible for obtaining the required documentation from all members of the team. The intellectual and industrial property rights to the Entry, if any, will remain with the Entrants, except that these terms do not supersede any other assignment or grant of rights according to any other separate agreements between Entrants and other parties. As a condition of entry, Entrants must abide by the OpenOffice.org license policy and agree that Sponsor and Sun shall have the right to use, copy, modify and make available the Entry in connection with the operation, conduct, administration, and advertising and promotion of the Program via communication to the public, including but not limited to the right to make screenshots, animations and video clips available to the public for promotional and publicity purposes. Notwithstanding the foregoing, ownership of and all intellectual and industrial property rights in and to the application and code shall remain with the Entrant, and as specified in Sponsor’s license scheme which can be found at <a href="http://www.openoffice.org/license.html">http://www.openoffice.org/license.html</a>. </p>
<h3>Acceptance of prizes</h3>
<p>Acceptance of the prize constitutes permission for, and winner’s consent to, Sponsor and Sun and its agencies to use the winner’s name, likeness and/or entry for advertising and promotional purposes without additional compensation, unless prohibited by law. To the extent permitted by law, Entrants agree to hold Sponsor, Sun Microsystems, Inc., and each of their parents, subsidiaries, agents, directors, officers, employees, representatives, and assigns harmless from any injury or damage caused or claimed to be caused by participation in the Program and/or use or acceptance of any prize won, except to the extent that any death or personal injury is caused by the negligence of the Sponsor. Sponsor and Sun Microsystems, Inc. are not responsible for any typographical or other error in the printing of the offer, administration of the Program or in the announcement of the prize. An Entrant may be prohibited from participating in this Program if, in the Sponsor’s sole discretion, it reasonably believes that the Entrant has attempted to undermine the legitimate operation of this Program by cheating, deception, or other unfair playing practices or annoys, abuses, threatens or harasses any other Entrants, the Sponsor or associated agencies. If an individual member of a team is disqualified the entire team will be disqualified.</p>
<h3>No recourse to judicial or other procedures:</h3>
<p> To the extent permitted by law, the rights to litigate, to seek injunctive relief or to make any other recourse to judicial or any other procedure in case of disputes or claims resulting from or in connection with this Program are hereby excluded, and any Entrant expressly waives any and all such rights. In the event that a court of competent jurisdiction finds the foregoing waiver unenforceable, Entrants hereby consent to the jurisdiction and venue residing exclusively within the federal or state courts in the state of California, United States and and agrees that any and all disputes, claims, and causes of action arising out of or connected with this Program or any prize awarded shall be resolved individually, without resort to any form of class action.. Entrants agree that these Official Rules are governed by the laws of California, United States.</p>
<h3>Data privacy</h3>
<p>Entrants agree that personal data, especially name and address, may be processed, stored and otherwise used for the purposes and within the context of the Program and any other purposes outlined in these Official Rules. The data may also be used by the Sponsor in order to check Entrants’ identity, their postal address and telephone number, or to otherwise verify their eligibility to participate in the Program. Entrants have a right to access, review, rectify or cancel any personal data held by the Sponsor by emailing Sponsor at <a href="mailto:community-program@council.openoffice.org">community-program@council.openoffice.org</a>. If Entrant’s data is not provided or is canceled, Entrant’s Entry will be ineligible. By participating in the Program, Entrants hereby agree to all personal information uses and disclaimers as explained in Sun Microsystems' Privacy Policy (see <a href="http://www.sun.com/privacy/">http://www.sun.com/privacy/</a>). Participation in the Program further constitutes Entrant’s full and unconditional agreement to and acceptance of these Official Rules and Sponsor’s Privacy Policy and willingness to be contacted by email. If Entrant is a French resident, by entering the Program such Entrant gives consent to the transfer of his or her personal data outside the European Union in connection with the above purposes, and that such data will be transferred to the United States.</p>
<h3>Warranty and indemnity</h3>
<p>Entrants certify that their Entry is original and Entrant can legally grant the rights set out in the Sun Contributor Agreement. Each Entrant agrees not to submit any Entry that (1) infringes any 3rd party proprietary, intellectual property, industrial property, personal rights or other rights, including without limitation, copyright, trademark, patent, trade secret or confidentiality obligation; or (2) otherwise violates applicable law in any countries in the world. To the maximum extent permitted by law, each Entrant indemnifies and agrees to keep indemnified the Sponsor and Sun Microsystems, Inc. at all times from and against any liability, claims, demands, losses, damages, costs and expenses resulting from any act, default or omission of the Entrant and/or a breach of any warranty set forth herein. To the maximum extent permitted by law, each Entrant indemnifies and agrees to keep indemnified the Sponsor and Sun Microsystems, Inc. at all times from and against any liability, actions, claims, demands, losses, damages, costs and expenses for or in respect of which the Sponsor or Sun Microsystems, Inc. will or may become liable by reason of or related or incidental to any act, default or omission by an Entrant under these Official Rules including without limitation resulting from or in relation to any breach, non-observance, act or omission whether negligent or otherwise, pursuant to these official rules by an Entrant.</p>
<h3>Elimination</h3>
<p>Any false information provided within the context of the Program by any Entrant concerning identity, postal address, telephone number, ownership of right or noncompliance with these rules or the like may result in the immediate elimination of the Entrant from the Program Sponsor further reserves the right to disqualify any Entry that it believes in its sole and unfettered discretion infringes upon or violates the rights of any third party or otherwise does not comply with these official rules. In the event that an Entry is submitted by a team, elimination or disqualification of a team member will result in disqualification of the entire team's Entry.</p>
<h3>Internet</h3>
<p>Sponsor is not responsible for electronic transmission errors resulting in omission, interruption, deletion, defect, delay in operations or transmission. Sponsor is not responsible for theft or destruction or unauthorized access to or alterations of Entry materials, or for technical, network, telephone equipment, electronic, computer, hardware or software malfunctions or limitations of any kind. Sponsor is not responsible for inaccurate transmissions of or failure to receive Entry information by Sponsor on account of technical problems or traffic congestion on the Internet or at any Web site or any combination thereof, except to the extent that any death or personal injury is caused by the negligence of the Sponsor. If for any reason the Internet portion of the program is not capable of running as planned, including infection by computer virus, bugs, tampering, unauthorized intervention, fraud, technical failures, disruption or termination of the Program site for any reason or any other causes which corrupt or affect the administration, security, fairness, integrity, or proper conduct of this Program. Sponsor reserves the right, at its sole discretion, to immediately cancel, terminate, modify or suspend the Program. Sponsor reserves the right to select winners from eligible entries received as of the termination date. Sponsor further reserves the right to disqualify any individual who tampers with the Entry process. Caution: Any attempt by an Entrant to deliberately damage any Web site or undermine the legitimate operation of the Program is a violation of criminal and civil laws and should such an attempt be made, Sponsor reserves the right to seek damages from any such Entrant to the fullest extent of the law. Due to the unique nature and scope of this Program, Sponsor reserves the right to alter or modify these Official Rules at any time.</p>
<h3>Severability</h3>
<p>If any provision(s) of these Official Rules are held to be invalid or unenforceable, all remaining provisions hereof will remain in full force and effect.</p>
<h3>Winners' List</h3>
<p>Winners will be notified by the Program Committee and their names posted to the Internet. For winner’s name, go to <a href="http://development.openoffice.org/community_innovation_program_winners.html">http://development.openoffice.org/community_innovation_program_winners.html</a> on or about 15 August 2008; the list will be available for a period of up to 60 days.</p>
<h3>Sponsor</h3>
<p>The Sponsor of this Program is the OpenOffice.org Community, at <a href="http://www.openoffice.org/">www.openoffice.org</a>. Sun Microsystems, Inc. is funding all of the prize awards; however, Sun Microsystems shall have no liability or responsibility in connection with the Program other than to fund the prize awards specified herein. OpenOffice.org may be reached via email for questions pertaining to this Program at <a href="mailto:community-program@council.openoffice.org">community-program@council.openoffice.org</a>.</p>
<h3>Questions</h3>
<p>Please see the <a href="cip_faq.html">FAQ</a>. If you have any other questions about the procedure or process send them to <a href="mailto:community-program@council.openoffce.org">community-program@council.openoffce.org</a>. For questions relating to your work, confer with your project colleagues. </p>
<br>
</body>
</html>
