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


  
    <title>Apache Felix - Apache Felix iPOJO</title>
    <link rel="stylesheet" href="apache-felix-ipojo_files/site.css" type="text/css" media="all">
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head><body>
    <div class="title"><div class="logo"><a href="http://felix.apache.org/site/index.html"><img alt="Apache Felix" src="apache-felix-ipojo_files/logo.png" border="0"></a></div><div class="header"><a href="http://www.apache.org/"><img alt="Apache" src="apache-felix-ipojo_files/apache.png" border="0"></a></div></div>
    <div class="menu">
<ul>
	<li><a href="http://felix.apache.org/site/news.html" title="news">news</a></li>
	<li><a href="http://felix.apache.org/site/license.html" title="license">license</a></li>
	<li><a href="http://felix.apache.org/site/downloads.cgi" rel="nofollow">downloads</a></li>
	<li><a href="http://felix.apache.org/site/documentation.html" title="documentation">documentation</a></li>
	<li><a href="http://felix.apache.org/site/mailinglists.html" title="mailinglists">mailing lists</a></li>
	<li><a href="http://felix.apache.org/site/contributing.html" title="Contributing">contributing</a></li>
	<li><a href="http://www.apache.org/" rel="nofollow">asf</a></li>
	<li><a href="http://www.apache.org/foundation/sponsorship.html" rel="nofollow">sponsorship</a></li>
	<li><a href="http://www.apache.org/foundation/thanks.html" rel="nofollow">sponsors</a>
<!-- ApacheCon Ad -->
<iframe src="apache-felix-ipojo_files/button.html" style="border-width: 0pt; float: left;" scrolling="no" frameborder="0" height="135" width="135"></iframe>
<p style="height: 100px;">
<!-- ApacheCon Ad -->
</p></li></ul> </div>
    <div class="main">
<style type="text/css">
 @import url(http://people.apache.org/~clement/ipojo/site/superfish.css); 
</style>

<style type="text/css">
 @import url(http://people.apache.org/~clement/ipojo/site/style.css); 
</style>

<p>
<script class="javascript" src="apache-felix-ipojo_files/shCore.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushCSharp.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushPhp.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushJScript.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushVb.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushSql.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushXml.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushShell.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushDelphi.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushPython.js"></script>
<script class="javascript" src="apache-felix-ipojo_files/shBrushJava.js"></script>

<script type="text/javascript" src="apache-felix-ipojo_files/jquery-1.js"></script>
<script type="text/javascript" src="apache-felix-ipojo_files/hoverIntent.js"></script> 
<script type="text/javascript" src="apache-felix-ipojo_files/superfish.js"></script> 
<script type="text/javascript" src="apache-felix-ipojo_files/supersubs.js"></script> 

<script type="text/javascript"> 
 
    $(document).ready(function(){ 
        $("ul.sf-menu").supersubs({ 
            minWidth:    14,   // minimum width of sub-menus in em units 
            maxWidth:    30,   // maximum width of sub-menus in em units 
            extraWidth:  1     // extra width can ensure lines don't sometimes turn over 
                               // due to slight rounding differences and font-family 
        }).superfish();  // call supersubs first, then superfish, so that subs are 
                         // not display:none when measuring. Call before initialising 
                         // containing tabs for same reason. 
    }); 
 
</script>
</p><div class="main">
<div class="page-header">
<img src="apache-felix-ipojo_files/header.png" class="header">
<a href="http://ipojo.org/"><img src="apache-felix-ipojo_files/ipojo.png" class="header-logo" width="225"></a>
<ul class="sf-menu sf-js-enabled sf-shadow" id="ipojo-menu">
<li class="current">
<!-- Menu Overview -->
<a href="" class="sf-with-ul">Overview<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
<ul style="float: none; width: 14em; display: none; visibility: hidden;">
	<li style="white-space: normal; float: left; width: 100%;">
	<a style="float: none; width: auto;" href="" title="Apache Felix iPOJO">Home</a>							
	</li>
	<li style="white-space: normal; float: left; width: 100%;">
	<a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-why-choose-ipojo.html" title="apache-felix-ipojo-why-choose-ipojo">Why choose iPOJO</a>
	</li>
	<li style="white-space: normal; float: left; width: 100%;">
	<a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-successstories.html" title="apache-felix-ipojo-successstories">Success stories</a>
	</li>
	<li style="white-space: normal; float: left; width: 100%;">
	<a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-feature-overview.html" title="Apache Felix iPOJO Feature Overview">Features</a>
	</li>
</ul>
</li>	

<li class="">			
<!-- Menu download -->
</li><li>
<a href="http://felix.apache.org/site/download.html" title="Download">Download </a>
</li>

<li class="">					
<!-- Menu Documentation -->
<a href="" class="sf-with-ul">Documentation<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
<ul style="float: none; width: 14em; display: none; visibility: hidden;">
    <!-- sub- menu : getting started -->
    <li style="white-space: normal; float: left; width: 100%;" class="">
    <a style="float: none; width: auto;" href="" class="sf-with-ul">Getting Started<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
    <ul style="left: 14em; float: none; width: 14em; display: none; visibility: hidden;">
     <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-in-10-minutes.html" title="iPOJO in 10 minutes">iPOJO in 10 minutes</a></li>
     <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/how-to-use-ipojo-annotations.html" title="How to use iPOJO Annotations">Using Annotations</a></li>
     <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-hello-word-maven-based-tutorial.html" title="iPOJO Hello Word (Maven-Based) tutorial">Maven tutorial</a></li>
     <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-advanced-tutorial.html" title="iPOJO Advanced Tutorial">Advanced tutorial</a></li>
     <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-dosgi.html" title="apache-felix-ipojo-dosgi">Using Distributed OSGi</a></li>
     <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-composition-tutorial.html" title="iPOJO Composition Tutorial">Application Composition</a></li>
    </ul>
    </li> <!-- end of getting started -->
    <!-- sub menu : Describing Components -->
     <li style="white-space: normal; float: left; width: 100%;" class="">
        <a style="float: none; width: auto;" href="http://felix.apache.org/site/describing-components.html" class="sf-with-ul">Describing components<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
        <ul style="left: 14em; float: none; width: 14em; display: none; visibility: hidden;">
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/service-requirement-handler.html" title="Service Requirement Handler">Requiring a service</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/providing-osgi-services.html" title="Providing OSGi services">Providing a service</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/lifecycle-callback-handler.html" title="Lifecycle Callback Handler">Lifecycle management</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/configuration-handler.html" title="Configuration Handler">Configuration</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/architecture-handler.html" title="Architecture Handler">Introspection</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/controller-lifecycle-handler.html" title="Controller Lifecycle Handler">Impacting the lifecycle</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/event-admin-handlers.html" title="Event Admin Handlers">Asynchronous communication</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-jmx-handler.html" title="iPOJO JMX Handler">JMX management</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/extender-pattern-handler.html" title="Extender Pattern Handler">Extender pattern</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/white-board-pattern-handler.html" title="White Board Pattern Handler">Whiteboard pattern</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/temporal-service-dependency.html" title="Temporal Service Dependency">Temporal dependencies</a></li>
        </ul>
     </li> <!-- End of describing components -->
    <!-- sub- menu : User Guide -->
    <li style="white-space: normal; float: left; width: 100%;" class="">
    <a style="float: none; width: auto;" href="" class="sf-with-ul">User Guide<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
        <ul style="left: 14em; float: none; width: 14em; display: none; visibility: hidden;">
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/using-xml-schemas.html" title="Using XML Schemas">XML Schemas</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-api.html" title="apache-felix-ipojo-api">API</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-testing-components.html" title="apache-felix-ipojo-testing-components">Testing components</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-eclipse-integration.html" title="apache-felix-ipojo-eclipse-integration">Eclipse Integration</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-faq.html" title="iPOJO FAQ">FAQ</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-reference-card.html" title="iPOJO-Reference-Card">Reference Card</a></li>
        </ul>
    </li> <!-- end of user guide -->
    <!-- sub- menu : Dev Guide -->
    <li class="" style="white-space: normal; float: left; width: 100%;"> 
    <a style="float: none; width: auto;" href="" class="sf-with-ul">Advanced Topics<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
       <ul style="left: 14em; float: none; width: 14em; display: none; visibility: hidden;">
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/ipojo/api/1.2.0" rel="nofollow">Javadoc</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/how-to-write-your-own-handler.html" title="How to write your own handler">Handler development</a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/how-to-use-ipojo-manipulation-metadata.html" title="How to use iPOJO Manipulation Metadata">Manipulation Metadata </a></li>
        <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/dive-into-the-ipojo-manipulation-depths.html" title="Dive into the iPOJO Manipulation depths">Dive into the iPOJO Manipulation depths</a></li>
       </ul>
    </li> <!-- End of Dev guide -->
</ul> 
</li> <!-- End of doc -->
<!-- Menu 4 : Tools -->
<li class="">
<a href="" class="sf-with-ul">Tools<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
<ul style="float: none; width: 14em; display: none; visibility: hidden;">
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-ant-task.html" title="iPOJO Ant Task">Ant Task</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-eclipse-plug-in.html" title="iPOJO Eclipse Plug-in">Eclipse Plugin</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-maven-plug-in.html" title="iPOJO Maven Plug-in">Maven Plugin</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-arch-command.html" title="iPOJO-Arch-Command"><tt>arch</tt> shell command</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-online-manipulator.html" title="apache-felix-ipojo-online-manipulator">Online Manipulator</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/ipojo-webconsole-plugin.html" title="iPOJO Webconsole Plugin">Webconsole plugin</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-junit4osgi.html" title="apache-felix-ipojo-junit4osgi">Junit4OSGi</a></li>
</ul>   
</li><!-- End of tools -->					
<!-- Menu 5 : Misc -->
<li class="">
<a href="" class="sf-with-ul">Misc<span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span><span class="sf-sub-indicator"> »</span></a>
<ul style="float: none; width: 14em; display: none; visibility: hidden;">
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-issuestracker.html" title="apache-felix-ipojo-issuestracker">Issues Tracker</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-supportedvms.html" title="apache-felix-ipojo-supportedVMs">Supported JVMs</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/apache-felix-ipojo-supportedosgi.html" title="apache-felix-ipojo-supportedOSGi">Supported OSGi Implementations</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://ipojo-dark-side.blogspot.com/" rel="nofollow">iPOJO's Dark Side Blog</a></li>
   <li style="white-space: normal; float: left; width: 100%;"><a style="float: none; width: auto;" href="http://felix.apache.org/site/article-presentations.html" title="Article &amp; Presentations">Article &amp; Presentations</a></li>
</ul>
</li><!-- End of misc -->
</ul> <!-- End of the menu -->
</div> <!-- Page header -->


<div class="content">

<p><b>iPOJO</b> is a service component runtime aiming to simplify OSGi
application development. It natively supports ALL the dynamism of OSGi.
Based on the concept of POJO, application logic is developed easily.
Non functional properties are just <em>injected</em> in the component at runtime.
<br clear="all">
<br clear="all">
iPOJO strength points are :</p>
<ul>
	<li>components are developed as POJO, nothing else is required !</li>
	<li>the component model is extensible, so feel free to adapt it to your needs</li>
	<li>the standard component model manages service providing and service dependencies, and so can require any other OSGi services</li>
	<li>iPOJO manages the component instance lifecycle and the environment dynamics as it has never been possible</li>
	<li>iPOJO provides a powerful composition system to create highly dynamic applications</li>
</ul>


<p><br clear="all"></p>

<p>
</p><div class="smallboxes" style="margin-left: auto; margin-right: auto; width: 824px;">
<table>
<tbody><tr>
<td>
<div class="smallbox" style="margin-left: 10px; margin-right: 10px;">
	<div class="smallbox-title">
		<img src="apache-felix-ipojo_files/status_online.png"> <b>Why choose iPOJO ?</b>
	</div>
	<div class="smallbox-content">
	<ul> 
	<li><a href="http://felix.apache.org/site/apache-felix-ipojo-successstories.html#apache-felix-ipojo-successstories-schneider">iPOJO at Schneider Electric</a></li>
	<li><a href="http://felix.apache.org/site/apache-felix-ipojo-successstories.html#apache-felix-ipojo-successstories-ugasp">iPOJO at Ubidreams</a> </li>
	<li><a href="http://felix.apache.org/site/apache-felix-ipojo-successstories.html" title="apache-felix-ipojo-successstories">others success stories</a></li>
	<li><a href="http://felix.apache.org/site/apache-felix-ipojo-keypoints.html" title="apache-felix-ipojo-keypoints">iPOJO Key points</a></li> 
	<li><a href="http://felix.apache.org/site/apache-felix-ipojo-why-choose-ipojo.html" title="apache-felix-ipojo-why-choose-ipojo">Why choose iPOJO </a></li>
	</ul>
	</div>
</div>
</td>
<td>
<div class="smallbox" style="margin-left: 10px; margin-right: 10px;">
	<div class="smallbox-title">
		<img src="apache-felix-ipojo_files/cog.png"> <b>Getting started</b>
	</div>
	<div class="smallbox-content">
	<ul>
        <li><a href="http://felix.apache.org/site/download.html" title="Download">Downloads</a></li>
	<li><a href="http://felix.apache.org/site/ipojo-in-10-minutes.html" title="iPOJO in 10 minutes">iPOJO in 10 minutes</a></li>
        <li><a href="http://felix.apache.org/site/how-to-use-ipojo-annotations.html" title="How to use iPOJO Annotations">Using Annotations</a></li>
        <li><a href="http://felix.apache.org/site/ipojo-hello-word-maven-based-tutorial.html" title="iPOJO Hello Word (Maven-Based) tutorial">Maven tutorial</a></li>
        <li><a href="http://felix.apache.org/site/ipojo-advanced-tutorial.html" title="iPOJO Advanced Tutorial">Advanced tutorial</a></li>
	</ul>
	</div>
</div>
</td>
<td>
<div class="smallbox" style="margin-left: 10px; margin-right: 10px;">
	<div class="smallbox-title">
		<img src="apache-felix-ipojo_files/user_edit.png"> <b>The developer corner</b>
	</div>
	<div class="smallbox-content">
	<ul>
	<li><a href="http://felix.apache.org/site/describing-components.html" title="Describing components">Describing components</a></li>
	<li><a href="http://felix.apache.org/site/ipojo-reference-card.html" title="iPOJO-Reference-Card">iPOJO Reference Card</a></li>
	<li><a href="http://felix.apache.org/site/apache-felix-ipojo-eclipse-integration.html" title="apache-felix-ipojo-eclipse-integration">Eclipse Integration</a></li>
        <li><a href="http://felix.apache.org/site/apache-felix-ipojo-online-manipulator.html" title="apache-felix-ipojo-online-manipulator">Online Manipulator</a></li>
        <li><a href="http://felix.apache.org/site/ipojo-faq.html" title="iPOJO FAQ">FAQ</a></li>
	</ul>
	</div>
</div>
</td>
</tr>
</tbody></table>
</div>



<p>The easiest way to get involved in iPOJO is to try it out. See the
Quick Start Guide for how to get up and running with the iPOJO
framework and the downloads page for more information on acquiring
iPOJO &amp; related tools.</p>

<p>You can also have a look to <a href="http://felix.apache.org/site/presentations.data/ipojo-berlin-20080611.pdf" rel="nofollow">this</a> presentation describing iPOJO main features.
<br clear="all"></p>

<h2><a name="ApacheFelixiPOJO-What'snews"></a>What's news</h2>

<ul>
	<li><b>New web site... and some issues</b> : the iPOJO web site
has changed. Enjoy! However, we're still setting everything correctly,
it should be done shortly. (2009-07-08)</li>
	<li><b>iPOJO And Distributed Services</b> : New tutorial about Distributed OSGi and iPOJO available. (2009-07-05)</li>
	<li><b>iPOJO web console plugin is now available</b> : Manages your iPOJO system with the Apache Felix Web Console. More info <a href="http://felix.apache.org/site/ipojo-webconsole-plugin.html" title="iPOJO Webconsole Plugin">here</a> (2009-06-30)</li>
	<li><b>iPOJO online manipulator is now available</b> : It allows to avoid offline manipulation! More info <a href="http://felix.apache.org/site/apache-felix-ipojo-online-manipulator.html" title="apache-felix-ipojo-online-manipulator">here</a> (2009-04-22)</li>
	<li><b>iPOJO API is now in the iPOJO Trunk</b> : The iPOJO API is now available from the iPOJO Trunk (2009-02-09)</li>
	<li><b>Integrating iPOJO inside Eclipse</b> : <a href="http://felix.apache.org/site/apache-felix-ipojo-eclipse-integration.html" title="apache-felix-ipojo-eclipse-integration">How to don't break your compile &amp; run cycle</a> (2009-02-05)</li>
	<li><b>Towards iPOJO 1.2.0</b> : The release process has began (2009-01-15)</li>
	<li><b>Release of the Apache Felix iPOJO 1.0.0</b> : iPOJO 1.0.0 is available in the <a href="http://felix.apache.org/site/download.html" title="Download">download section</a> (2008-10-22)</li>
</ul>

<ul>
	<li><a href="http://felix.apache.org/site/ipojo-news.html" title="iPOJO-news">all news...</a></li>
</ul>




 </div>
        <img src="apache-felix-ipojo_files/footer.png" class="footer">
</div>

<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script><script src="apache-felix-ipojo_files/ga.js" type="text/javascript"></script>
<script type="text/javascript">
try{
var pageTracker = _gat._getTracker("UA-1518442-4");
pageTracker._trackPageview();
} catch(err) {}
</script>

    </div>
  </body></html>