<!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" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" lang="en"><head>
    <title>Eclipse Foundation Member Newsletter - June 2021</title>
    <meta property="og:title" content="Eclipse Foundation Member Newsletter - June 2021">
    <meta name="twitter:title" content="Eclipse Foundation Member Newsletter - June 2021">
    
    
    
<meta name="x-apple-disable-message-reformatting">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta name="viewport" content="width=device-width, initial-scale=1.0">


    <!--[if gte mso 9]>
  <xml>
      <o:OfficeDocumentSettings>
      <o:AllowPNG/>
      <o:PixelsPerInch>96</o:PixelsPerInch>
      </o:OfficeDocumentSettings>
  </xml>
  
  <style>
    ul > li {
      text-indent: -1em;
    }
  </style>
<![endif]-->
<!--[if mso]>
<style type="text/css">
 body, td {font-family: Arial, Helvetica, sans-serif;}
</style>
<![endif]-->


    






      









    


  <meta name="generator" content="HubSpot"><meta property="og:url" content="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-june-2021"><meta name="robots" content="noindex,follow"><!--[if !((mso)|(IE))]><!-- --><style type="text/css">.moz-text-html .hse-column-container{max-width:600px !important;width:600px !important}
.moz-text-html .hse-column{display:table-cell;vertical-align:top}.moz-text-html .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
.moz-text-html .hse-section .hse-size-12{max-width:600px !important;width:600px !important}
[owa] .hse-column-container{max-width:600px !important;width:600px !important}[owa] .hse-column{display:table-cell;vertical-align:top}
[owa] .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
[owa] .hse-section .hse-size-12{max-width:600px !important;width:600px !important}
@media only screen and (min-width:640px){.hse-column-container{max-width:600px !important;width:600px !important}
.hse-column{display:table-cell;vertical-align:top}.hse-section .hse-size-6{max-width:300px !important;width:300px !important}
.hse-section .hse-size-12{max-width:600px !important;width:600px !important}}@media only screen and (max-width:639px){img.stretch-on-mobile,.hs_rss_email_entries_table img{height:auto !important;width:100% !important}
.display_block_on_small_screens{display:block}.hs_padded{padding-left:20px !important;padding-right:20px !important}
ul,blockquote{margin:0;padding:1em 40px}}</style><!--<![endif]--><style type="text/css">body[data-outlook-cycle] img.stretch-on-mobile,body[data-outlook-cycle] .hs_rss_email_entries_table img{height:auto !important;width:100% !important}
body[data-outlook-cycle] .hs_padded{padding-left:20px !important;padding-right:20px !important}
a[x-apple-data-detectors]{color:inherit !important;text-decoration:none !important;font-size:inherit !important;font-family:inherit !important;font-weight:inherit !important;line-height:inherit !important}
#outlook a{padding:0}.yshortcuts a{border-bottom:none !important}a{text-decoration:underline}
.ExternalClass{width:100%}.ExternalClass,.ExternalClass p,.ExternalClass td,.ExternalClass div,.ExternalClass span,.ExternalClass font{line-height:100%}
p{margin:0}body{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;-webkit-font-smoothing:antialiased;moz-osx-font-smoothing:grayscale}</style></head>
  <body bgcolor="#f2f2f2" style="margin:0 !important; padding:0 !important; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
    


<div id="preview_text" style="display:none!important;font-size:1px;color:#f2f2f2;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">We want to keep you informed! Here's a list of our new members and a breakdown of all the recent activity at the Eclipse Foundation.  </div>


    
<!--[if gte mso 9]>
<v:background xmlns:v="urn:schemas-microsoft-com:vml" fill="t">
  
    <v:fill type="tile" size="100%,100%" color="#f2f2f2"/>
  
</v:background>
<![endif]-->


    <div class="hse-body-background" style="background-color:#f2f2f2" bgcolor="#f2f2f2">
      <table role="presentation" class="hse-body-wrapper-table" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; margin:0; padding:0; width:100% !important; min-width:320px !important; height:100% !important" width="100%" height="100%">
        <tbody><tr>
          <td class="hse-body-wrapper-td" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding-top:20px">
            <div id="hs_cos_wrapper_main" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_dnd_area" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="dnd_area">  <div id="section_1624555219345" class="hse-section hse-section-first" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;" cellpadding="0" cellspacing="0" role="presentation">
      <tr>
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1624555219345_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_162455521934044" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<div style="overflow:hidden">
<table role="presentation" class="hse-pre-header hse-secondary" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; text-align:right; font-family:Arial, sans-serif; font-size:12px; line-height:135%; color:#23496d; margin-bottom:0; padding:0" align="right">
    <tbody>
        <tr>
            <td align="right" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; color:#444444; word-break:break-word; text-align:right; font-family:Arial, sans-serif; font-size:12px; padding:10px 0; margin-bottom:0; line-height:135%">
                <a href="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-june-2021?ecid=&amp;utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#F79422; font-weight:normal; text-decoration:none; font-style:normal" data-hs-link-id="0" target="_blank">View in browser</a>
            </td>
        </tr>
    </tbody>
</table>
</div>
</div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_0" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border hse-border-top" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; border-top:1px solid #cccccc; background-color:#f79422" bgcolor="#f79422">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc;border-top:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border hse-border-top" width="600" bgcolor="#f79422">
      <tr style="background-color:#f79422;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_0_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_1519314331610150" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">




	


<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
    <tbody>
        <tr>
            <td align="left" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:left; padding:10px 20px; font-size:0px">
                
                <img alt="Member_Newsletter_Header_Template_(4)" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20June%202020/Member_Newsletter_Header_Template_(4).png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member_Newsletter_Header_Template_(4).png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20June%202020/Member_Newsletter_Header_Template_(4).png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member_Newsletter_Header_Template_(4).png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20June%202020/Member_Newsletter_Header_Template_(4).png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Member_Newsletter_Header_Template_(4).png 1116w" sizes="(max-width: 558px) 100vw, 558px">
                
            </td>
        </tr>
    </tbody>
</table>
</div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_2" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_2_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586291145041102" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586291145041102_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Executive Director's Report</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">OSPO.Zone: A Resource for Open Source Program Offices</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Participate in the IDE Working Group</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline"><span style="color: #444444;">IoT &amp; Edge Commercial Adoption Survey Report</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Eclipse Foundation Marketing Services</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">EclipseCon Program Coming Soon</span></li>
</ul></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_3" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
      <tr style="background-color:#FFFFFF;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_3_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1519385550660107" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="left" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16062366968383" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16062366968383_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">Executive Director's Report</h1></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15193855506601072" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15193855506601072_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">I’m pleased to report our membership remains strong. Our current corporate members now total 339, and our number of committers has grown to 1,739. Both stats are as of the end of May.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">As we look back on the<span style="color: #3d3935;"> first half of the year, I am excited by the many great things happening across the Eclipse Foundation ecosystem. As has been noted in this newsletter, as well as on our various channels, we have seen major milestones achieved with a significant number of our projects, such as the recent release of Eclipse ioFog 2.0 and the Eclipse IDE 2021-0</span>6.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">Also, I’m pleased to see so many of our working groups now producing artifacts that highlight the value and impact of the projects in their respective areas, such as the recent <a href="https://outreach.eclipse.foundation/edge-computing-edgeops-white-paper?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">white paper</a> from the Edge Native Working Group, which provides a comprehensive overview of the edge computing landscape, including several Eclipse Foundation projects. Similarly, the Open VSX Registry <a href="https://outreach.eclipse.foundation/openvsx?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">white paper</a> authored by the Eclipse Cloud DevTools Working Group outlines the benefits of a fully open source approach to a marketplace for VS Code extensions based on the Eclipse Open VSX project.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">To me, these community-contributed content assets represent great collaboration among our member organizations, and highlight the value of working groups in driving the visibility and awareness of our projects.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left; font-weight:bold" align="left"><span style="color: #444444;">Budget Approved</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">Our finances for the year remain strong and on target. In April, the Board approved the Foundation’s 2020 audited statements, and in June approved the Foundation’s 2021 forecast. A summary of both is provided in the table below.</p>
</div></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16245462340337" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><style type="text/css">
.tg  {border-collapse:collapse;border-spacing:0;}
.tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;
  overflow:hidden;padding:10px 10px;word-break:normal;}
.tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;
  font-weight:normal;overflow:hidden;padding:10px 10px;word-break:normal;}
.tg .tg-urqt{color:#444444;text-align:center;vertical-align:top}
.tg .tg-h8va{color:#444444;font-weight:bold;text-align:center;vertical-align:top}
.tg .tg-no8k{color:#444444;font-weight:bold;text-align:left;vertical-align:top}
.tg .tg-9hbx{color:#444444;text-align:left;vertical-align:top}
</style>
<table class="tg" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
<thead>
  <tr>
    <th class="tg-9hbx"></th>
    <th class="tg-h8va">2019 Actual</th>
    <th class="tg-h8va">2020 Actual</th>
    <th class="tg-h8va">2021 Forecast</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td class="tg-no8k" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">Revenue</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">5.7</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">6.7</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">7.3</td>
  </tr>
  <tr>
    <td class="tg-no8k" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">Expenses</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">6.2</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">6.6</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">7.7</td>
  </tr>
  <tr>
    <td class="tg-no8k" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">Net Income</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">(0.5)</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">0.1</td>
    <td class="tg-urqt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">(0.4)</td>
  </tr>
</tbody>
</table></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16245465754308" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16245465754308_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; font-weight:bold; text-align:left" align="left"><span style="color: #444444;">Moving Forward</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left; font-weight:normal" align="left"><span style="font-size: 15px; color: #3d3935;">The remainder of 2021 looks even more exciting, with a number of projects scheduling releases, and a number of major initiatives underway.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left; font-weight:normal" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left"><span style="font-size: 15px;"><span style="color: #3d3935;">At the Foundation, our team is continuing to find new ways to bring value to our members and our ecosystem. Of note, we continue to expand our engagement with members and other organizations in defining new programs, including new research and working group initiatives, collaboration in a European-based open source program office (OSPO) initiative, and extending our third-party partnerships. And </span><a href="https://www.eclipsecon.org/2021?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">EclipseCon 2021</a><span style="color: #3d3935;"> is shaping up to be another great event for us with submissions just closing and the program to be announced in the next few weeks. I encourage all members to participate actively in both the main program as well as the community day.</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left"><span style="color: #3d3935;">Finally, I would like to draw attention to our current initiatives around our code of conduct. We are proud of the fact that literally thousands of individuals collaborate together across our vast channels, and the manner in which those collaborations happen is so professional and welcoming. I find it very personally satisfying that, while our code of conduct has existed for years, the number of complaints received over that time is extremely low. Nonetheless, with the goal of constantly improving and evolving, over the coming months we will be providing additional guidance related to the code of conduct to better clarify how the code of conduct applies in the various aspects of “life at Eclipse,” as well as updating the processes in support of the code of conduct to better suit our evolving community.</span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_4" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
      <tr style="background-color:#FFFFFF;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_4_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1519385551532115" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184984773151" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184984773151_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center"><span style="font-size: 24px; color: #444444;">OSPO.Zone: A Resource for Open Source Program Offices</span></h1></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_162454794602911" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">




	


	

<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
    <tbody>
        <tr>
            <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
                
                    <a href="https://newsroom.eclipse.org/news/announcements/leading-european-open-source-non-profit-organizations-announce-ospo-alliance?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/OSPO.Zone.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=OSPO.Zone.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/OSPO.Zone.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=OSPO.Zone.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/OSPO.Zone.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=OSPO.Zone.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
                
                    </a>
                
            </td>
        </tr>
    </tbody>
</table>
</div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15193855515321152" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15193855515321152_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #444444;">In partnership with OW2, OpenForum Europe, and the Foundation for Public Code, the Eclipse Foundation has announced the <span style="color: #f88d2b;"><a href="https://newsroom.eclipse.org/news/announcements/leading-european-open-source-non-profit-organizations-announce-ospo-alliance?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="1" target="_blank">launch of the OSPO Alliance</a></span>. The mission of this open alliance is to grow awareness for open source in Europe and promote structured and professional management of open source by companies and administrations. The OSPO Alliance is a global initiative started in Europe.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">The alliance aims to help companies and public institutions discover and understand open source, start benefiting from it across their activities, and grow to host an Open Source Program Office (OSPO) through a new resource hub <span style="color: #f88d2b;"><a href="https://ospo.zone/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">OSPO.Zone</a></span>. It will be focused on the role of OSPOs as an aspect of organizational governance essentially in non-technology sectors, including education and public administration. We highly encourage all members and committers of the Eclipse Foundation to <a href="https://ospo.zone/contribute/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">get involved</a>&nbsp;and for members to sign the <a href="https://ospo.zone/docs/statement_of_support.pdf?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">statement of support</a>.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">Check out the resources at <span style="color: #f88d2b;"><a href="https://ospo.zone/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="1" target="_blank">OSPO.Zone</a></span>.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">&nbsp;</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_6" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
      <tr style="background-color:#FFFFFF;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_6_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1594734810783259" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184948533082" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184948533082_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">&nbsp;Participate in the IDE Working Group</h1></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15947348107832592" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15947348107832592_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">The <span style="color: #f88d2b;"><a href="http://ide-wg.eclipse.org/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">Eclipse IDE Working Group</a></span> has been created to ensure the continued evolution, adoption, and sustainability of the Eclipse IDE suite of products, related technologies, and ecosystem. In particular, the new working group will provide governance, guidance, and funding for the communities that support the delivery and maintenance of Eclipse IDE products.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">The goals of the Eclipse IDE Working Group are to ensure the continued success, vibrancy, quality and sustainability of the Eclipse Platform, desktop IDE, and underlying technologies, including related planning and delivery processes as well as related delivery technology. </span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%"><span style="color: #444444;">&nbsp;</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">The working group enables member organizations to provide direct support and funding for the great work that continues to be done by our committers and contributors. Any member organization that relies on the Eclipse IDE and has a vested interest in its continued success is encouraged to participate and/or sponsor the working group.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%"><span style="color: #444444;">&nbsp;</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%"><span style="color: #444444;">Learn more about the <span style="color: #f88d2b;"><a href="http://ide-wg.eclipse.org/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="1" target="_blank">Eclipse IDE Working Group</a></span>.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">As a reminder, the 2021-06 release of the Eclipse IDE is available today and can be downloaded via <span style="color: #f88d2b;"><a href="https://www.eclipse.org/eclipseide/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">eclipse.org/eclipseide</a></span>.</span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_7" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
      <tr style="background-color:#FFFFFF;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_7_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1598385152620211" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16245474306589" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">




	


	

<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
    <tbody>
        <tr>
            <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
                
                    <a href="https://outreach.eclipse.foundation/iot-edge-commercial-survey?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/IoT_survey.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=IoT_survey.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/IoT_survey.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=IoT_survey.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/IoT_survey.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=IoT_survey.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
                
                    </a>
                
            </td>
        </tr>
    </tbody>
</table>
</div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15983851526202113" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15983851526202113_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #444444;">The results of the <span style="color: #f88d2b;"><a href="https://outreach.eclipse.foundation/iot-edge-commercial-survey?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="1" target="_blank">2021 IoT &amp; Edge Commercial Adoption Survey</a></span> have been released. This year’s edition not only focuses on how today’s organizations are perceiving IoT and edge adoption on a macro level, but also provides valuable insights on the overall IoT and edge ecosystem challenges and concerns.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%"><span style="color: #444444;">Key findings, analysis, and recommendations for various ecosystem players have been revealed in this report. <span style="color: #f88d2b;"><a href="https://outreach.eclipse.foundation/iot-edge-commercial-survey?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b; text-decoration:underline" data-hs-link-id="2" target="_blank">Download your copy now!</a></span></span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16158290929903" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184952078023" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184952078023_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center"><span style="font-size: 24px;">Eclipse Foundation Marketing Services</span></h1>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">The marketing team at the Eclipse Foundation is focused on developer and community outreach, ecosystem building, and driving project awareness and industry adoption. We recently posted an outline of our <span style="color: #f88d2b;"><a href="https://www.eclipse.org/org/services/marketing?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">marketing services</a></span><span style="color: black;">, <span style="color: #444444;">which summarizes some basic marketing programs the Eclipse Foundation team supports, including:</span></span></p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #444444;">Project and working group press releases and announcements</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline; line-height:175%"><span style="color: #444444;">Community news and updates</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline; line-height:175%"><span style="color: #444444;">Event coordination and promotion</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline; line-height:175%"><span style="color: #444444;">Branding and creative services</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline; line-height:175%"><span style="color: #444444;">Content creation</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline; line-height:175%"><span style="color: #444444;">Member case studies</span></li>
<li style="mso-line-height-rule:exactly; color:black; vertical-align:baseline; line-height:175%"><span style="color: #444444;">Market intelligence and surveys</span></li>
</ul>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #444444;">These services are all about sharing relevant information, insights, and best practices within our ecosystem and industry at large. Our goal is to increase awareness, adoption, and contributions towards the open source projects and working groups that matter to you.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">Reach out to us at <span style="color: #f88d2b;"><a href="mailto:marketing@eclipse.org" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">marketing@eclipse.org</a></span><span style="color: #3d3935;"> and we would be happy to work with you.</span></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16214296398744" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16214296487495" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16214296487495_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; font-family:Arial, sans-serif; text-align:center; font-size:24px; line-height:263%" align="center">EclipseCon Program Coming Soon</h1>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: black;"><span style="color: #444444;">All submissions fo</span>r </span><span style="color: #f88d2b;"><a href="https://www.eclipsecon.org/2021?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="1" target="_blank">EclipseCon 2021</a></span> are now in! Thank you to the community for the <span style="color: #f88d2b;"><a href="https://www.eclipsecon.org/2021/sessions/proposed?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">excellent proposals</a></span>, both in quality and quantity. Stay tuned for the program announcement in early July (follow <a href="https://twitter.com/eclipsecon?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">@eclipsecon</a> for the latest news).</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">Plans for Community Day at EclipseCon are underway. If your community would like to organize a session, <span style="color: #f88d2b;"><a href="mailto:info@eclipsecon.org" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">contact us</a></span> soon because space is limited.</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">ElipseCon is a unique opportunity for member companies to connect with and support the Eclipse community. To learn more, see the <a href="https://www.eclipsecon.org/2021/prospectus?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" target="_blank" rel="noopener" data-saferedirecturl="https://www.google.com/url?q=https://www.eclipsecon.org/2021/prospectus&amp;source=gmail&amp;ust=1624649151916000&amp;usg=AFQjCNH3LzY-z4Tmw5G5lsNtSbFAXUtRjw" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0">online prospectus</a> or contact us at <a href="mailto:sponsors@eclipsecon.org" target="_blank" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0">sponsors@eclipsecon.org</a>.</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">EclipseCon 2021, October 25-28, is online and free to attend. We hope to see you there.</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_162142991364814" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_8" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#f79422" bgcolor="#f79422">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#f79422">
      <tr style="background-color:#f79422;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_8_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586443203069146" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586443203069146_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="color:#ffffff;font-size:24px;"><strong>Upcoming Virtual Events</strong></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_9" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_9_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586443203069148" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586443203069148_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px"><a href="https://www.crowdcast.io/e/virtualiotandedgeday2021?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"></a><a href="https://www.crowdcast.io/e/cloudtooltime_jun29_21?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="background-color: white;">Web-based tools - built with Eclipse (only) | Cloud Tool Time</span></a><span style="background-color: white;"> | June 29</span></p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px"><a href="https://www.crowdcast.io/e/jakartatechtalksjune29?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="background-color: white;">Jakarta EE 9/9.1 with Open Liberty | Jakarta Tech Talks</span></a><span style="background-color: white;"> | June 29</span></p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px"><a href="https://gotc.oschina.net/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic#schedule" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="background-color: white;">The Global Open Source Technology Summit</span></a><span style="background-color: white;"> | July 8-10</span></p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px"><a href="https://www.crowdcast.io/e/vecm_ros2?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="background-color: white;">Using zero-copy data transfer in ROS 2 | Virtual Eclipse Community Meetups</span></a><span style="background-color: white;"> | July 20</span></p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:150%; font-size:15px"><a href="https://www.crowdcast.io/e/jakarta_tech_talk_aug11_2?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="background-color: white;">Jakarta Concurrency: What's Next | Jakarta Tech Talks</span></a><span style="background-color: white;"> | August 11</span></p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_10" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#f79422" bgcolor="#f79422">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#f79422">
      <tr style="background-color:#f79422;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_10_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573062770099374" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573062770099374_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="font-size:24px;"><strong><span style="color: #ffffff;">New Members &amp; Working Group Participants</span></strong></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1608144436883" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1608144436884_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16081444414732" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16081444414732_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">For the month of May 2021</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16245439528584" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16245439528584_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center"><span style="font-size: 18px;"><strong>Contributing Members</strong></span></div>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">&nbsp;</div>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center"><a href="https://www.bessystem.com/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" rel="noopener" data-hs-link-id="0" target="_blank">Beijing Baolande Software Corporation</a></div>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; font-size:18px; line-height:239%"><strong>Associate Members</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.imec.be/nl?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Interuniversitair Micro-Electronica Centrum vzm (IMEC)</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #f88d2b;"><a href="https://www.apache.org/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f88d2b" rel="noopener" data-hs-link-id="0" target="_blank">The Apache Software Foundation</a></span></p>
<p style="mso-line-height-rule:exactly; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; font-size:18px; line-height:146%"><strong>Working Group Participants</strong></p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_11" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:299px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="299" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:299px">
<![endif]-->
<div id="column_11_0" class="hse-column hse-size-6">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573062147161181" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573062147161181_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; text-align:center; font-weight:bold; font-size:15px; line-height:239%" align="center">Jakarta EE Working Group</p>
<p style="mso-line-height-rule:exactly; text-align:center; line-height:175%" align="center"><a href="https://www.bessystem.com/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Beijing Baolande Software Corporation</a></p>
<p style="mso-line-height-rule:exactly; text-align:center; line-height:175%" align="center"><a href="https://www.apache.org/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">The Apache Software Foundation</a></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center">&nbsp;</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->

<!--[if (mso)|(IE)]>
  <td valign="top" style="width:299px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="299" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:299px">
<![endif]-->
<div id="column_11_1" class="hse-column hse-size-6">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16185095480621" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16185095480621_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center"><span style="font-size: 15px;"><strong>OSGi Working Group&nbsp;</strong></span></div>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">&nbsp;</div>
<div style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:175%; display:inline !important"><a href="https://www.imec.be/nl?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Interuniversitair Micro-Electronica Centrum vzm (IMEC)</a><a href="https://www.yatta.de/en/start/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"></a></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center">&nbsp;</p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_12" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_12_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573063318466527" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573063318466527_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; font-size:15px; line-height:239%; text-align:center" align="center"><strong>Adoptium Working Group</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><a href="https://www.huawei.com/en/?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Huawei</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><a href="https://www.microsoft.com/en-ca?utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Microsoft</a></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_161849677878512" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
    
    
  </tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_13" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_13_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1591621523496211" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">

<table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module" width="auto">
  <tbody>
    <tr align="center">
      
      <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="http://www.facebook.com/share.php?u=&amp;utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/facebook_square_color.png" alt="Facebook" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
          </tr>
        </tbody>
      </table>
  		</td>
      
      <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="http://www.linkedin.com/shareArticle?mini=true&amp;url=&amp;utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/linkedin_square_color.png" alt="LinkedIn" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
          </tr>
        </tbody>
      </table>
  		</td>
      
      <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="https://twitter.com/intent/tweet?original_referer=&amp;url=&amp;source=tweetbutton&amp;text=&amp;utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/twitter_square_color.png" alt="Twitter" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
          </tr>
        </tbody>
      </table>
  		</td>
      
      <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="http://pinterest.com/pin/create/button/?url=&amp;media=&amp;utm_campaign=June%202021&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--4H3S0rOM3Z5zPlwXlPqAG9Y6RlkV6RnB_52RhO1b80Ga098RTOWvebvW3K8kkJ7_Ss1ic" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/pinterest_square_color.png" alt="Pinterest" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
          </tr>
        </tbody>
      </table>
  		</td>
      
      <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="mailto:?subject=Check%20out%20%20&amp;body=Check%20out" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/mail_square_color.png" alt="Email" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
          </tr>
        </tbody>
      </table>
  		</td>
      
    </tr>
  </tbody>
</table>
</div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_14" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border-bottom hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; border-bottom:1px solid #cccccc; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-bottom:1px solid #cccccc;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border-bottom hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_14_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1519309286486146" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1519309286486146_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h4 style="font-size:15px; margin:0; mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="color: #646c7a;">Copyright © 2021 Eclipse Foundation. All rights reserved.</span></h4></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_15" class="hse-section hse-section-last" style="padding-left:10px; padding-right:10px; padding-bottom:20px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; padding-bottom:10px; padding-top:10px">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;" cellpadding="0" cellspacing="0" role="presentation">
      <tr>
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;padding-bottom:10px; padding-top:10px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_15_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_1477051461677107532" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">








  



  
  
  
  
  
  


















<table role="presentation" class="hse-footer hse-secondary" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; font-family:Arial, sans-serif; font-size:12px; line-height:135%; color:#23496d; margin-bottom:0; padding:0">
    <tbody>
        <tr>
            <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; text-align:center; margin-bottom:0; line-height:135%; padding:10px 20px">
                <p style="mso-line-height-rule:exactly; font-family:arial, helvetica, sans-serif; font-size:12px; font-weight:normal; text-decoration:none; font-style:normal; color:#23496d; direction:lrt" dir="lrt">
                  Eclipse Foundation, Suite 202, 2934 Baseline Rd, Ottawa, ON K2H 1B2, Canada
                </p>
                <p style="mso-line-height-rule:exactly">
                  
                  <a data-unsubscribe="true" href="#" style="mso-line-height-rule:exactly; font-family:helvetica; font-size:12px; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">Unsubscribe</a>
                  
                  <a data-unsubscribe="true" href="#" style="mso-line-height-rule:exactly; font-family:helvetica; font-size:12px; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">Manage preferences</a>
                  
                </p>
            </td>
        </tr>
    </tbody>
</table>
</div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>
</div>
          </td>
        </tr>
      </tbody></table>
    </div>
  
</body></html>