<html xmlns:v="urn:schemas-microsoft-com:vml"
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:p="urn:schemas-microsoft-com:office:powerpoint"
xmlns:oa="urn:schemas-microsoft-com:office:activation"
xmlns="http://www.w3.org/TR/REC-html40">

<head>
<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
<meta name=ProgId content=PowerPoint.Slide>
<meta name=Generator content="Microsoft PowerPoint 10">
<link rel=File-List href="EclipseCon2004_PosterSession_files/filelist.xml">
<link rel=Preview href="EclipseCon2004_PosterSession_files/preview.wmf">
<link rel=Edit-Time-Data href="EclipseCon2004_PosterSession_files/editdata.mso">
<title>Eclipse UML2 Project</title>
<!--[if gte mso 9]><xml>
 <o:DocumentProperties>
  <o:Subject>Poster Session</o:Subject>
  <o:Author>Kenn Hussey</o:Author>
  <o:LastAuthor>khussey</o:LastAuthor>
  <o:Revision>340</o:Revision>
  <o:TotalTime>4327</o:TotalTime>
  <o:Created>2002-08-23T15:26:08Z</o:Created>
  <o:LastSaved>2004-02-10T19:49:20Z</o:LastSaved>
  <o:Words>403</o:Words>
  <o:PresentationFormat>On-screen Show</o:PresentationFormat>
  <o:Manager>Daniel Leroux</o:Manager>
  <o:Company>Rational Software, IBM Software Group</o:Company>
  <o:Bytes>109131</o:Bytes>
  <o:Paragraphs>96</o:Paragraphs>
  <o:Slides>12</o:Slides>
  <o:Notes>1</o:Notes>
  <o:Version>10.4219</o:Version>
 </o:DocumentProperties>
 <o:OfficeDocumentSettings>
  <o:ShowReviewingToolbar/>
  <o:PixelsPerInch>80</o:PixelsPerInch>
 </o:OfficeDocumentSettings>
</xml><![endif]-->
<link rel=Presentation-XML href="EclipseCon2004_PosterSession_files/pres.xml">
<meta name=Description content="2/10/2004: Eclipse UML2 Project">
<meta http-equiv=expires content=0>
<![if !ppt]><script>
<!--
	var ver = 0, appVer = navigator.appVersion, msie = appVer.indexOf( "MSIE " )
	var msieWin31 = (appVer.indexOf( "Windows 3.1" ) >= 0), isMac = (appVer.indexOf("Macintosh") >= 0)
	if( msie >= 0 )
		ver = parseFloat( appVer.substring( msie+5, appVer.indexOf ( ";", msie ) ) )
	else
		ver = parseInt( appVer )
	browserSupported=0
	if( !isMac && ver >= 4 && msie >= 0 ) {
		browserSupported=1
		window.location.replace( 'EclipseCon2004_PosterSession_files/frame.htm'+document.location.hash )
	}
//-->
</script>
<![endif]>
</head>

<body>
<script><!--

if( browserSupported )
	document.writeln('<div style="visibility:hidden">');

//--></script><font face=Arial size=2><b>

<p>This presentation contains content that your browser may not be able to show
properly. This presentation was optimized for more recent versions of Microsoft
Internet Explorer.</p>

<p>If you would like to proceed anyway, click <a
href="EclipseCon2004_PosterSession_files/frame.htm">here</a>.</p>

</b></font><script><!--

if( browserSupported )
	document.writeln('</div>');

//--></script>
</body>

</html>
