Subject: 20007 updated with 4 Homes For Sale. Prices listed at $195K to $1.5M.
From: "Homesnap" <[email-masked]>
To: "Rob Hunt" <[email-masked]>
Date: Thu, 16 Aug 2018 08:30:56 +0000 (UTC)

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:s="http://schemas.datacontract.org/1734/07/Sawbuck.Data">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width" />
    <title>Homesnap Weekend Report</title>
    <style type="text/css">
          #outlook a {padding:0;}
          body {width:100% !important; -webkit-text-size-adjust:100%; -ms-text-size-adjust:100%; margin:0; padding:0;}
          .ExternalClass {width:100%;}
          .ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {line-height: 100%;}
          table td {border-collapse: collapse;}
        </style>
<!--[if !mso & IE]><style>.propertyPreview { height: auto; width: auto; display: block; height: 177px; max-width: 265px; max-height: 199px;</style><![endif]-->
</head>
  <body bgcolor="#f3f3f3" style="margin: 0; padding: 0;">
    <div style="display:none;font-size:1px;color:#333333;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">
    </div>
    <div style="font-family: &quot;Trebuchet MS&quot;, Arial, Helvetica, Sans-Serif;">
      <table cellpadding="0" cellspacing="10" bgcolor="#FFFFFF" border="0" width="600" align="center">
        <tr>
          <td valign="middle" align="center">
            <div style="font-family: &quot;Trebuchet MS&quot;, Arial, Helvetica, Sans-Serif; font-size: 14px; color: #999999">Check out these real estate photos based on your recent Homesnap activity</div>
            <div style="font-family: &quot;Trebuchet MS&quot;, Arial, Helvetica, Sans-Serif; font-size: 14px; color: #999999">To unsubscribe from Weekly Update emails <a target="_blank" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N32IF5E49zjOlvJHyWSNW-2BbYRMw6ha0iTtd7-2B0c99Qqc50t0ogMUXSV-2FNlFK9Z4aKTi3RZEctiW4nFSVHpPpbCh2306EX416-2Fe7dqr-2B1gwmS9LRbvmkY5dgAUxQXzkVSOpUlz6qtm5OUwBcUhv5FRS3pVe7Gr3jSIw135gESHtDi6uzh1VKI20vqtIcE-2FpXk4uBiihjOdBqlqlfm6TomefcxPJRsLr0dCR2Y31yPFx0AJiCKXChXXAGqsZuffkHD-2FO8-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUekjuvbJOFSZu951Q4zLCiN-2BytUAPJauN8PIVQfd8u1nCy2zWmn-2Fg1TKloICj-2BZFbs-2BO1yYSSlcjb4q6lKQ49CZSUHjHshqVma1aEfjohjJUfBjPk8y-2FML-2BHu6wu-2F3z-2B1eBxlYhfV3lp7iJypoUJyFzaptSzvQqP03qFoVAvF90ChdVv5FN4zc-2BoHRZYPZQVGWUXpytjZkH3x6Kw5VgEKuzVMGTZmMCoy-2BKHmRiiW6t3nI2z4gR0szFqI6t1T8eBsZoCaldhMI9P9ID0AM8bFY1Y-3D" style="color: #999999; text-decoration: underline;">click here</a>
            </div>
          </td>
        </tr>
        <tr>
          <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td valign="top">
            <table width="600" cellpadding="0" cellspacing="0" border="0" height="84" xmlns="">
              <tr valign="top">
                <td align="right" width="295" height="84"><a style="display:block;" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzl0jRu3t8KYOhz3u3jMsqjc-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUes1BrtmHPqrneUkpZg8spMu625wrO-2FT35tHJ3BRzWnOs0n9hUWomEQy9HWWwhVxply-2BKIPe6Yd6XLxtS0fSH9ijy81PHM57oSrmHsXWLyb-2BZAYRpWo55VNkiVQldo91JBA8fNFiGs2knvZjZm2rkngw7qWTCRn4pqBV3aLELkUQw1tRzblas013RnzlAXWsqES08Puww6m4-2FFBZsVcQgINW9jCDO35C020W792FlWyrH34zrK7eMRw1qsNiQn2a3UZLBbqwHALaX9Txet7OcFTw-3D"><img border="0" alt="http://www.homesnap.com" width="295" height="84" src="http://www.homesnap.com/images/email/alerts_header.jpg?v=20140527"></a></td>
                <td width="305" height="84"><img border="0" alt="Weekly Report" width="305" height="84" src="http://www.homesnap.com/images/email/alerts_weekly_update.jpg?v=20140527"></td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td><table width="600" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td width="600">
      <table cellpadding="10" cellspacing="0" border="0" width="580">
        <tr>
          <td width="420" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 24px; color: #3b86c7; margin: 0">
				Real Estate Update for 20007</td>
          <td width="160" style="text-align: right;"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="177" align="center" valign="top" bgcolor="#24803E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      F<br>O<br>R<br><br>S<br>A<br>L<br>E
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://img2.sbck.us/listings/no_image/1_0_listing.png" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2710-35th-Place-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEctefRNFib46KJbnoqeCB4H9VT58jyRtBuO96Dpv-2Bi2c5_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeqPxeZNWQFwFSmKKuAWfKbxOLmqsWj4B7U0KFhhdISdazLjfoz-2BqPjaQ-2FzXue-2FFd8FifnWS1gceI8fC8mkIM9WzVJvK5cdOdlP4hJ-2Fd64oTaJCw-2Fk601IFZgK0XylkGrEbMaN-2BuLo4VfZScU3gJoKvbO4-2BwQs0-2FbXUBizwc6dTI-2BLAz-2F93WeNyYL-2FlkBS87XMw2oue75QWxU7Bnl6YYc9kMXf1hiQv4hJaOnnVYmPFTD0qEYkHkp9jPnsfVZxQ5nJ6DrkRi20UbialFsiHkvdao-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://img2.sbck.us/listings/no_image/1_0_listing.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/39654766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4482-Salem-Lane-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEciGf3DSYdV2u6qT9TBi569kngbk44gwqsyCFZ62YnBz1_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeqk-2FuVjRxMgS5PkZXhEfucFOOLYIHZht5dehjIl1Vl23UWMov7pyJhPu6eGgSbRFe2fA8uFRREtAq3yoqfIwH1vedcoKy6deiuwO2vHVz30uLMpbCf7gyr-2FHla1nMmuntkgSbqLm65YJWYbQ67HWGwwSnwAD3RfblrJdvrmNYEh-2Fjg07zEE5g9rBhHr-2FVWyAkYeBGnxnT7q6RwTB4gUPPa1MmAIq6E9XVP60tnz-2BslkZw146cGndeoK-2F-2BnreQEvgRT0nTY6YNmehi2HCfM8j-2FBA-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/39654766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="30" height="10" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="177" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/13152866-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4570-Macarthur-Boulevard-NW%2fproperty%2f400012099632">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsD2tcbFOQ1cWh3IsA5vbEoTXrOxXR3ChZZpPYkd1Vri3umBI1jaOohDgc9-2FvSkhGJAn3aE1OKWiQtfT7H1BpYw-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUenkgcKBvn-2FSs8yV7Bmv3NtDu-2FxTMuH2DdQbg4Ere2hwjxHS2NymP-2Fvm-2FbAbU2xLeOme-2BFwQVLsoB9kYZY6wMNiOOEu9EGscXv-2ByRKNd3yvOuI1BGBfkD2dJYR53Lm2u9tT0eHCS1y9F68WzHmIODT5aB7fN019nmmsRrrkNWuOV2blcqm6tfyf875q9AAsIE7uD6jzQap6WqnBribtO5q30qkOd9S53GO84RGDU-2FYdpuZhFqHfb7IXyKa1o1cMrgiWrcvvlwlrbtB7lA4PvUweM-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/13152866-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/11661866-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4607-Kenmore-Drive-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcvoXz7ERbVcURq0DWslcmI8roI9Qw9TWR-2Fm6s6Bg7jzx_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUehYDLYdkXhcqIH7DEAGwJFyX9Qg6mzW0xTl-2BsBA7q-2BqFc3m-2FHrMRn3kNclm0l7tFIKeBsJfrC9OQW6lRST2oFHyuJWAVkL99BjoioeF9Q1imjBr9SLtazRmZbyRm4fhL1wi3kKz7xUiO9ReL9JVBYo73093EGY11q5k6OSsBPuvOWPk-2BvVcd3zjlWi-2B4PzCW-2Fmj9q9vmG23HYw-2B26ysb8j-2Br-2FKsIRV8EFwt1sUoyJsPE-2F1HFbTugbYKsef2gyyaIT4cfytTmd0A9Lrh20xE4ea8-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/11661866-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/77375766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2027-37th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcvh9hwS50-2FjVM8BoGZmaULDdBgQAiNTO0M25Ka5YIsBM_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUegScN2bYEwJqc8fQZvjmRBoj7vWkmNHGLGzbpeQaKe1vzaFMWpLwM6dKvwSRxn8E7z-2B9l0Ed0-2FVOz2uoYI5VrGHRUc7i2P-2FyRTsd65ndjLTkh-2BCNFTvdi-2BEgrlxIWeLWpR43L8FTb-2FaiQQLi1GR4wl2p89rp5siL30vLf14j3182UttE5Gb8oD7cIdXxPppd-2F9ySduxWxb5Ht05YpOc2SgnC0YqyXu5uGXGzlP2tf-2FqdpgKUrjSlqoVnTor-2BLCy9otLnMe8e0YeEqdyo23YFpS8-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/77375766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      C<br>O<br>N<br>T<br>R<br>A<br>C<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/24586556-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2801-New-Mexico-Avenue-NW%2fproperty%2f400012024542">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpuqqyV39BPqToi6GXU7kOX-2FPNyO5Rw9y-2FrM5eza8tnG9-2BD9itNCLnAHnwG6xSA7s0flIjKETe2sQ4x20V3r2L4-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUelyYOtvldMtqyMpHI-2BYhtWRiVcO0pE7dP3n-2FSqbuBqHuaDL4jvuFAylK6UeSvXKOQw9Wpv8QIg-2BCnjeyitTFMpOJAvIxvwvboEWToY-2BnRT1CN7A5OllVVR-2FGTxdi9nAdE-2FR1vmw9SkFiy3jCQDcsu-2B-2F2LuO84R1eB5acHoDzRvi1ufLDmXotdYiVk8E14FVrNqieqV-2FiM-2BHOXFq98zvDGDH6FaDB-2FW2YXdLKsy6yOiYg38K-2B887G2jkiqSrJzVOWe-2Bx3mePlThHFEN6RwMm5v9s-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/24586556-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/57952366-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2828-Wisconsin-Avenue-NW%2fproperty%2f400012026976">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsQRQkXQNv9xyLfhivKKeb81y-2FbjpMvzseGnxs5O-2F3jfpJVlO6YzbhXPGiXoZ3TqbKwHUkVB-2FudLb4phhbGijH4-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeppIJLybJbCLYY9dSiZaXoMeQ68KyDDFZ1NLIVgHS-2B866b3NRSmxNTAxGCuqTnndNWzhFStW48suS0jNrouvv4BnOSJ1p6TY00Gt82vXjvsY6hZsGvIaaJtK35sczUOlgqdYbxCB1ddF8lFDMxBF0ttiPJJ98EXrQxzd6tUTlCogD11ilbBh8lujXLjfvCvkymZCidISfKm7H2UMr0kSsH-2Fgy-2Fwrth0XMrHjwu8lMaEAceXHFg7JmihZykXIIhF3ZlyY1Y5TelguHTZKWk7jIOw-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/57952366-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/10685046-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3641-Fulton-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcuxxWKJTCImiRhUz6ftBvgcGyuco2mx0IRPdooYcHZCR_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeppOOVVTsTTEHCVQklTEXWpZ-2F135oHqt9nzlx2tw9LW7oYzIOGVVUQDUeVl6aZojGWkMGUOItlV3-2BzWMQ9k-2FrFRejHRMLeEimbWmtc4bjSdU71yM-2FITdIBCsBxH5Fj7qbaVT0E-2FUG8OMsD7wONxMKfeN-2FsD3VEmyOBp7ovEQ0nxomxBK-2FArEjnxwCCMzMBeiSF12IIp4qRWgNtwK-2FI0x0dSvedmpkNcdhhUwkggXIKUH6LKb9ih81q7HpR5iQGXMVe5LFCER0Zt6qUeo3aXLN7s-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/10685046-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/74116695-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1045-31st-Street-NW%2flisting%2f59661147">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpNQ2CeWGJQx8i1f7NLgEUfrkPZYqCTXJFORs8Y1ubtx4-2FE8ZQh6sAg4YR4k9yk7HQ-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUepTQbaoy-2B2Vc3GxgQX1Pa7JxcTJ35K8pGmpZkrY4ukaOZ3dhZfoxBVQhSLWKMGo4-2FfSCimlExdCfKVC7ECyF7WSiWD9pplQTXPlrBzjPncaJtNN6otgwPC1WVnqcEi4tN3SKTZun68pngypbZNDyINNUbc-2F23y-2FhTjjTkAjP16DLb-2Bnrx6flAWMbo0uwFVyi4qEO8BIdHtg808U40NBE-2BETKt5BZDPcI1cKnO93PpAwqLh1opxtlQnxpxlyMw4ikl3EbOXH-2Fu4r1Xgu5y8cwdUPVF16XVS-2FRC8d4onaaLwjk" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/74116695-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/90287446-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2325-42nd-Street-NW%2fproperty%2f400012023301">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcshDSIuIk0lq-2F-2Fsx14n-2BJmrrKrnDCksjFz-2F-2FXW0OSL2Fve8VcLQV2mvVFDmpD7Nfbw-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUep8UdH-2BC-2ByuoH1cuWvPBOqfpF2SDqGEpItRMKJ4nTt82PFiXMzX5bSXMNbAPBPVCaNkc0djcqkhNWv4bJuWHumFUql-2F7nlsdAIleEmYwA58Z6vxjB0N4bg-2BzGsWka0YexVeri5P3mONN0Y-2FYROhE6iTht00WnjWkmIahBMO8-2BXClWK3RoFerLu9PLjCywWtQi7M-2BVHNvcA4wZDKeHsEopq4oBiQwe1KQcUljCvV43UyMYFsiJuX5uobDbHHqP-2BQMOMu5cnS6Fr0RWHFZCCerhYsWOiOqK0Jir-2F75Z4Hbgn86" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/90287446-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#EE3223">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      J<br>U<br>S<br>T<br><br>S<br>O<br>L<br>D
                    </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/22871366-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2814-R-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcvUjooNW45XDdubKDt4eAwo1gE5y8Wj6deBPadS7iIh-2F_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUepLMn2DJ6g70ZD1oPEwrHM1X-2Bt1gPmT0opc7WTwbdRgqEBZ1s3iWHC6g-2BvlL-2FRGdImpG9QyrvGnWsULT5mmsezME9Rl3-2FGz3Lv5ArAEZHmiSKv0TIxJIiOrLILuZlgp4SwNVrvqRkX0C8LBSRWOhT69zVQBnVy7WUIH9EtOL1URiguZgSVVRKeuEIKkdD3B1Kab-2Byku8TippcmdNnXyCmr1ZADFn91jrGgeQCNvwykk6vISPbbHY4YxxlpaAY9bLEmqDb1IDMVd7hRVskmcViWDh46DOVTtMPtyiEUK0Fvyb" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/22871366-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/48780156-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1695-34th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsl4HwAw-2FpQAB4JUT4CIlDNi6JJq5ImdhBt-2BCVW6-2FrqI_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUesFP0zmkBnVsapM950RaOAdUr7-2BnAKgylZB7xzz-2B3jI-2F8qShDfIe-2BxlfcNWEi607b3unLEVw8UKcv15hh7D9in1aUOpr0wlcCbC34EMb54PqMC9Lvdshzw5KBvJHLrZ6bWGas3WHYlpr9hTM9cRMzRBeYvDLJ-2FAQS7WQ9L9RVWR6VYStmpVI7wc7RYS-2FCKIVLO4QcX-2BLsRvhMg9eTYdrnz-2FhAvbDf25wwSJnRqB-2FLxWr9Px9sZQ55omsh8bvvZYGsITUzpvKvHlEjPC1007sMjsKkZzEbAYN5o-2BAVEUTiCf6" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/48780156-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="356" align="center" valign="top" bgcolor="#e4edfc" rowspan="3">
            <table width="30" height="356" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" width="30" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td width="30" height="351" align="center" valign="top" style="height: 351px; color: #000000; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 14px;">
                      M<br>A<br>R<br>K<br>E<br>T<br><br>S<br>T<br>A<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUen3Xa1xrr5qx2fhVdu2g8gIVQ-2FKSROZm8X3irR-2BvrgXZSgTkQmepAEQmy9nlqNz4ZEFvDKqRw2lDRCLn7UlMNrUWJLB8DmggkNupYbRr5uoHWTM-2FgoMqcqxtBl9Y-2FwkC-2FEE4lxd6afjWH4Gzb55l10FHIeryO4Jr6FlB5aDF-2FnEnw5HvUGXM5qwKx6DOAZX265sTkze9B7r3zwAqEF63hNF0ghDqT0v5TbdyayF5MbHH6sq1tCQWBwcwQqSCgVl5CE8GO7MXW72bmMIVp6tEERNzO-2BQ-2Fbr1YSnXrVhnd3Z92"><img width="215" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=215x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,j1kJfWeEmtq3q3o8oosJsJtGserMploTmti3hReZdbdHeEcybMaOZ6ajZmfCg8i3h6goooo8o8oTnqpRsyp6sJsyuEuYrgqjqOsysJooo8&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|0|40|80|120|160|200&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020007%20Listings"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUelbHl7ZisVnVGNcw7e0L7e2njoLSNRX1XOKwvhMOOL0dxvOSDsxCMBunj0bE8WFOwnGo3UK78B4NjGETAwk0lHdQTEG-2F-2FXQD54axnkjJM6Ridtm96Z7snoPGcRil0B1UStvHj3BVD3hx4w4lPr6l9AK89t9KT0MrCH1uN2r6WPNY1FmoZD19csG3BMUAib4-2BacbO5cuoZkbujvpatqpVxnrS8lw9LvwCF0NlwBNhwUpkcyLQq-2FBRLo50sSLvU8RU3IL6eXx9zejvm51hXCQ4YlBUov4QTB4nt6LHOE3QhAS-2B"><img width="245" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=245x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,rxrnrwwarxrxsnrnrnrxsMyAwywyx7rxrxx11tvHweygzA3U3D8i.J3Z4U3k5F1Nzx1N1NzW0rvHyavHtdtdsnq6rxtbrxrxqDn9nIoPkm&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|$0|$300,000|$600,000|$900,000|$1,200,000|$1,500,000|$1,800,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,646,1293,1939,2586,3232,3879&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.157753357753358|r,E4EDFC,0,0.315750915750916,0.473504273504273|r,E4EDFC,0,0.631501831501831,0.789255189255189&amp;chxtc=0,5|1,5&amp;chtt=Median%20List%20Price"></a></td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUej4nPqLdNgven9SWrghN3LlEWeTmPVI4CaE7J2a8OeipreKHPhtpweaHDHb4GGWZ-2BMUkXGTSL-2FSod7cKigAEJtHcqF2PnzjZ9Ap53I-2BoDGz097BAPFNbPxorsePcKzUeG3buscwytpRsk1lgiR0r-2Fdrskvuk-2FIIGKiXwd0vYgpAEnYC0S1hNowbFh7mZk824oxNGgyUSi29jxZAhNe-2Bu0ncQMuvASffLZlVdRDIP-2F3nk9QQUOjC0T6R3uNID-2FrLVk1aM2BN669BMHkLkzbQonXE6kmoivYF-2FEtP0RQl5-2F1K1"><img width="215" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=215x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,q9r4q9mZnTg6g6f.g6g6h0qDoOnTr4eKjpsyoOxXqDdQXxSSTMYrXxXxVBXxbbdQfFfFivjpivnTjpsy5l0G4rttoOpIsyoOnTq9wc1BzM&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|0|10|20|30|40|50|60|70&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,585,1170,1755,2340,2925,3510,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.142857142857143|r,E4EDFC,0,0.285714285714286,0.428571428571429|r,E4EDFC,0,0.571428571428571,0.714285714285714|r,E4EDFC,0,0.857142857142857,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020007%20Sales"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUenxnVYneIi38L-2BPBafIED5R4-2FLAgGfqw5XAEfebhR0H0HgX-2B0xRqP-2BYF47EytxatO4n1A6wnt6jd67rTstMJzEQCio9nf5Nczm2lLL6vvhyaN3VOam5Ivj9gabp0kqUXKcV-2BB3zjVrsVSWw5gAQpFOBRbdR1MCM1eT6Tfr5OeO4kNmPuE7p3o7W3JLdMVAtz8xWHjQ6rx05nM8DlCVuATrvLvvnkIOkHAGDzt9CK-2Fm-2BbQxMD3lFNA117eL9XckodjrQWSqvLpO0y57WAsp9Xc-2F538krb-2BmxyGcWzRu1ToJ1B"><img width="245" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=245x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,pXpXo.lIo.niqDpbuItDtOxorvtOq2qIqRp1qYsbpHrwn3r4tBquyRpiu2wVsce2e2sNza89102K0Vvw0VwcxLv.uuyRu2x0vTu2xUwpqQ&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000|$1,200,000|$1,400,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,585,1170,1755,2340,2925,3510,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.142857142857143|r,E4EDFC,0,0.285714285714286,0.428571428571429|r,E4EDFC,0,0.571428571428571,0.714285714285714|r,E4EDFC,0,0.857142857142857,1&amp;chxtc=0,5|1,5&amp;chtt=Median%20Sales%20Price"></a></td>
        </tr>
      </table>
    </td>
  </tr>
</table><br xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data"><table width="600" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td width="600">
      <table cellpadding="10" cellspacing="0" border="0" width="580">
        <tr>
          <td width="420" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 24px; color: #3b86c7; margin: 0">
				Real Estate Update for 20011</td>
          <td width="160" style="text-align: right;"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="177" align="center" valign="top" bgcolor="#24803E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      F<br>O<br>R<br><br>S<br>A<br>L<br>E
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/63499666-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f522-Buchanan-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcnJTXPdTmgwVMGR-2FPgh84DM-2FJK3x7dRyQBt6UQOsQtDL_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUevQGEvcXfiu1iIzTRv2EE4Ch3c-2FVBfEA00xdDO4xxWWt5U9aoG2XjRO66kVzTxrO8Tk1vSV8W1zGpSWrpJQi6uVmMdd6lzuD5ODpEQa5HI5N1baapcG-2BfHDuhN63ZjTpnObavgm15aD8zjpQMSXly2FgVMRxLgWdWAi7RTdinCHGOHlKIswDRtWtx322QI39l2pYXJY0AnjmvV3RuKb9r7q-2BgTkTlba6cd2an2qdCa-2BXylItC0LLFBKLnItuER8dg9yA45a6s7FoS-2BMKdMlrNpiTCZYrgRX-2BOaLP3XvjSAbR" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/63499666-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/37334866-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5117-3rd-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcuKrUd4g0D6isMCm5hL4JF-2Bm5U0F549IgGHS3c7vuedF_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeioCrOUXXkwKsn6MUif1b0GuSULDWM4VmI0yIqg64DQ2ZgP1MPgId6eOn77yNmpEkega9xRP1N8ZtV2slhXI3H4TJYyt-2B-2FIdpS-2FCD7bJDcQHLrWJy0e6PWEQWCf2MsHgjTyETF3pHXGQ0lI-2BqQ02s0sOG0puDEdtJoy-2FnIotFTeqg7V94dqRNmrxhi-2BQHiEDteTT28CHRURiDH1qEvoTsZQgEiEx9ufiwOiCYwOP2kAXgcNc6rU5RwGG-2Fa2leLM9KRWs4fB0ylm5z5d7mfzOazlOs2LcSWRJJWraA6BJBtlt" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/37334866-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="30" height="10" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="177" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/13452566-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5908-17th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcgZG3h1zJR3OkOvO-2F5kYx8sfUDuqKpFYfe54oP6lY2fr_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUelU-2Bbwq51-2BXIgQKUY54dnlcsw4dG5zzNQoczEkQdIVRfgMqfRfs-2B-2Bq18mdLyWC5w-2FvFB4v5dU-2FMGyvBS7hCmu06WPg0mhq2NuHo9HrrdDTmVCvzA36qDA0JYXGORcnbXWwv8qhNXDZ-2FaizJmsmvIPipr-2FFfRt7s8HWxKMF-2FnUCgm6XzvDPZ7-2FTmO4QnRupQ727yPmzD1nSC7EZPo6QXT4pNsbIGPTJzRHIh2Oa0hzlHy-2BVDyLksB2L-2FsVkxwmTiSSnvsCyL8pAXcgC5RAymgyy2iX-2BhM6-2Fgc-2FV5JeYgZYws3" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/13452566-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/63635866-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f501-Longfellow-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcnZ5m8FTcFZWMhlBudXgyjIg40SY9swecS0iUV6Y3OhH_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUepk6nf18xPF2vq0s2RLA0N5M-2Btyw6cDOCUfHxsAcsN-2BQo-2B6sIDxrLdv9MY3FlVxJ8IkOImJM-2F743BhfEUhLu85-2FU5O5EjeL0-2Fs6h-2BP0jgh-2F7dj1rYEDazAOzERJ-2F-2FAB9W5pQwZ9sCHkGD-2BgpPKoCxUrRbU0AwziNhbTYFXDHN71WGPDVkGoWdJ9u4F1IZ0Bjf8r9gnpMGsf4Wl-2Bz4minP0Ex6l1sxI-2FPPxZ-2FA8Qc5XZUUkXyAF5aSpXzgWZjLxVn5cY7f36TNVRfofcdxd5KCGzPUg15UV7sYg-2FCbU8ZlzDV" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/63635866-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/07807456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f729-Roxboro-Place-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcrCBn9MNfM5RNbtxjlfFgGMv90xkmm5wtH5BOoAkjgwP_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUehVhH4MU7OVVXVwTmjA-2BTB0r3l8AFOi8bwle-2BYEFCGMmSvVjbCpi3aqVOj0ljMZg-2BWDh4idB9EvzF-2BrNRFtkjpPEthwOt6fHFyF7oUsVI-2BWDbl-2F1zvv3CxrBPpG0A-2FTQL-2FKvl8gGkHvVJBU8c7LKeJ6NE7IspPMkPo0RNXlo2NOTMXz8rAMs5o7Qkznce2StgkYGsVgszWejT8mrPXp2OIKFTjiSrgWUMlXdkO4j-2Fuex7YrpNz1NGr07rodT-2FsjMvXWD5omhDAGsXj4Dux-2BeU5B8fpwhksZ1hoP6jcL2znEC" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/07807456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      C<br>O<br>N<br>T<br>R<br>A<br>C<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/08607766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4620-4th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsjad9xteO3zfMLlsO7n3yomeDzMo-2BgvE4Qjtc1mr2ER_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeo8VEL95n9jCH0jH73aJFKLUYaSOS4Jqcxv0PAj7N4e-2BUhoF3jnnhf9-2F3D91OWMSFB06Az-2FK6N6f6Qm6HX21yW8Ys7NdcSfpjCOTn9NcEIpvRFq9ON9PhXo6N8I2kgaY1da-2BpvrVOqPOj216nOMaOwP3fo5pNliph9B7pA8sQfpts4s8Lu-2FGYpHI-2BOmOCRA9ML2A6WFmyRgR5xErAJ4D8icryWo7VHVSfMlauQt-2FCPDrhFTwaMHcgdm9Q-2FlpEot6gDC68onY72EwZ6dlTVCZyyrOH5aQOcRB3vhD3UxefjqM" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/08607766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/52583766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4106-5th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEciNXBk1osfgJIsoF-2BFcy91Fm-2FiwvvGo33uMg1IlHfd-2Fo_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUetsQ-2By3Y38C59nZ9OtQmOE6nKp0vZRmMEWXQ6oxFMnItTwqLVEg8ee3dzKpiWPA8K7XWRzD2d7C1XuQP1S3qjUKO-2FnKesu-2BS33zlGaCxPqTVnjwkkyGmX1HFtLUtsCeOOSYBh6ciT-2Bgnyaiu11l0d98ymWGNAGoqfyrOTfURZ3IvKlYxiTMCIyiE-2BtIF9J8PQZWaDFZsRkb3c6B6fDL93DIexhF-2BhlhskidgLPKnUV3Kf8OB78yTUmXxRdN-2F7N6bnPuGebgKeKoBdUI5vGMOpwdFauZpcIG6eRaCSoZvS0RB" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/52583766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/08702946-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5200-New-Hampshire-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcppdx8nCA0s-2Fvc1Ve5-2Bqyd7ER18vcUpapETcbrDeknRY_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUerqJrPfnPL6Ptv4PJ-2F4mx2EZDfrL5ORS4op0mBCaP4rX1dU2pVV-2F7x6YI5wJl-2BGTOaA5mUHviXPOE1dhXkVNjrGf7uoY-2BwpRbt9s7Nc2bBSiYPt-2BBV7BcX-2BRPTIAcNKa19X0yZCw-2FCZFEVweEyLqhUJqPkgDiqMvFufaXPzupy1NTVPpRsSG34yisXvebscNFQQ63MiH5CIhkzRvBC2cTVpCllZrWX-2FkRlHjk3iB2Exec-2Fp50-2F69RqMu9-2BEs2USV56gNIvWV5FU6iWzAVLQVq4-2BJQWIniPqOqTKAa18mFCha" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/08702946-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/63855346-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5421-13th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEctmHTcW7h0AhG7w4ez17Vkh29tXalwyDkYmU-2Bu4CKRHD_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUepmlh3PtNMlsSkQFECiNmxw7wUYfHVtl-2Fb4ZVvZbk2kQyZyijB8-2FzHQMDpnmZYtQhUhMnvY4m8AuZej6DNBIM-2Flo0UWhmE5sZvNceCeKeRJxugVs9jI8mep6jNrKa-2BiBP1rMGqkofkm2z9BGFajWTLinKQvwDsggG9NksBTrPTWfMyEryp-2F8lUUzGZqgFmH6aWglcunoIHTcfzyaxF65YKoz3eHPheufdrttYkjbEOuD6JRv1frqWqvygCClsUNgWQkJNfUSjVWXuSrdrp0AL50YbocEoJZxXUD4zs8mYzuk" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/63855346-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/41161066-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f124-Webster-Street-NE">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEctPrIjiTU3y-2BsNsRLo-2Bxi-2F3VCX6MjqGH2QVrDKQFKpLv_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeorIvUgA-2F3W8SMMYzLWWecqh4o3WL5MhVCc-2FjNyGBhGtLiwFGRTI12x9X9y8Y-2Baa9kguYE-2B9suc75CoF2uBV53kfKZRKl-2FrCrMdWGY8M9-2FRhX52-2Bp8OG1KEs1tZ2vxMe41q5lZojkG82nbW2Vf11O-2BLRFW1gVQzP-2FDokW-2FKFWL6WN0qvJEf1AfLCyHYHrWPqR30GF6WRCyLewxGqB9W6zmfg-2Ff2ao1904EbtbGQkTNaEY1xZ0GfvNN9G2EJTZ91isJdO660emGaYeaJEF4prHhXQ6ANeU28JNmxBlgaS3cjR" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/41161066-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#EE3223">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      J<br>U<br>S<br>T<br><br>S<br>O<br>L<br>D
                    </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/87393066-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f807-Varnum-Street-NW%2fproperty%2f1576689">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcviQTm98kmg-2BshKzK9NxoPItXodTbvOk2SnVnbaxywh0MVQISZtOeDkkhJKVj249KQ-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUerizkOezceTKwZUnGEiNJ-2B97pWNQ1amgnZh3jd7opSW-2BMD9-2FcxN4EYQ9JvHD8mYdQk7kpWTLrAxSJk7zUspxAaQd4fApW3E3Minv3lhPI9kirDaUapLy7C2bAAgh-2BAVcYBV9-2FdmYQ0RyE-2BcNRFinPlb8E9yAWneZUE28DrTGGJnWyc5-2BoAPLH-2BDfRPn2AMmT6T-2FRRSqN2-2FqJwiwzjigtRvrj4pJQC1PsV-2FWYEUbyBJdoxb5JbYJJwIqhQv0Md529f4NghbX5lw0hXIaGxDaNGkg8ZJr2FIzrPdc24RGhB5fe" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/87393066-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/95663756-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1707-Allison-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcs0wtpt3aYqNCQemioCMR1h4ZJ0zmDF0GLm72xyMhDqb_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUenRfHAUdoWVx2tRpCLR4bD69OXxm4UxaIpR37CkzRQvxIKgKXgv0sbf6OOsXsw0FhkiZosuTIXV7gqPLzFXiJlK3Y9z9A7diiGvvV7XChN7j1UCVhXjWLqw-2Bq1jirvRx6uJLlxSOYOCnKucf8fxElOhppvIrAy1ClKGSaziHKC7O7iO8ooVgoEWq-2BnvCE3-2FNGRWtoTLt6QRiYr89bGKBUVHxGrIWQdc6345xfLh0XfO-2BDsrT7Uzql-2Fj7919XbIS2Q0tzud-2F-2FOrg0JIkdHT6tHqTlZZzLfb1eIrQZlZ1CWhwQ" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/95663756-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="356" align="center" valign="top" bgcolor="#e4edfc" rowspan="3">
            <table width="30" height="356" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" width="30" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td width="30" height="351" align="center" valign="top" style="height: 351px; color: #000000; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 14px;">
                      M<br>A<br>R<br>K<br>E<br>T<br><br>S<br>T<br>A<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUevUcdgQd37H-2FKDDcICUABDzAQgTt-2FZBc0Sz1GDvvIUF6LgrvAy0twtbm3SGEPHQZNlRbYx3B3xm7I2OjiwQZeKVj1kKZpGVjsekgbpIt9OF9U10gREtdLiF357Alkv3ukvIu07HhRcsdyzzeW6TZ-2BX8J9aBNBCfUDwd3o2-2F3ePTn0PjcwmyILpt2-2FHfhpWGcrHbvOlXRDZ3cXtKejBlmUqwASzgG16XL1rU6tg6sLNwcmrT-2FFd-2B7GpRahqYCvOP0wULcmot-2FfuMk0Bu9OJBaL2BNNIxgRl43P6yHsV1Xcerb"><img width="215" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=215x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,o8oomtmZvqwTw8v.xl1vz0zgz0w8xluYrgnBlbijjMgTeEg8bMdwaOa3Z6cebMeEi3g8kJmtmEnWo8n.o8kyrgo8sJr1qOoTp6tvrMo8rM&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|0|40|80|120|160|200&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020011%20Listings"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeq3VARYZvs3E5UxiMrNoR3RvOXkWLtNdYM9cyYMTeYcdSOFspkAVCdcxN6NoQsFb9M4l83A5JrPEp29HVjJlnEfpBTLJ3oFlQofrV-2Fen2oaZqhQlI5-2BckgcdMosQ2-2BCk07oJQcTbnub7MN5uoinXQQbpXFdeqMbdW8eApuS7U3nBmDNvySipQkmVGKegSuexadfoXh8kxEhWA7ZhJ6CGHzCwtWl1W4LZAUGxiUmK144apmhswBAtMWfPiLDlOyZMYwkVDYu-2BvOtfZYty0q5HJ2wEscCOtTTVF0HUUC3addz5"><img width="245" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=245x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,zizGzlzqyyyYyy0.1g1W1W0y1v0Yz.z.z.z.zlz.yMxgwYxMyYxlv8uvv6v6v6x-x-z.1kz.0x0x1y3L384x4Y4Y3-5g5K38362T3G2T1.&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,1023,2047,3071,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.24981684981685|r,E4EDFC,0,0.4998778998779,0.74993894993895&amp;chxtc=0,5|1,5&amp;chtt=Median%20List%20Price"></a></td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUelKi4XwDnwmVo0Xxb1lgT929DzBatlTJt8L1oBF40m69hKMmQM4xZSaIB9pBayl28ita7E6QVAyVZ8nNA3IjbDN994q8MUCntkxS8SL8hX1eRkosrTQzkbNNfcVexvVnjrRpuaubaO-2FFWKezV33WA5RWaMkxgGB-2F-2FKcNuym6c8r5xL6iVGGtQvyW2lLW2DyXdGPBC85B5JH7-2FMaSv8eFLQOz7QijnKbkpHLKPOrrJsJfjewq9PHCn1Gb-2FgCEVdC30sznvd0HramxwDJZz1-2BkfMVmP8BDiEdInZNVVex6Vzq8"><img width="215" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=215x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,o8tbsJ3q3B3B0dplrgnqnqplqOnqq3nqqOx64T8J8J1GqOlwh6jMlHlwj1jMhRlwkeoTsyplwotbutx6z0z02Y6O48637gzMxRv.o8xRwo&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|0|20|40|60|80|100&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020011%20Sales"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeobEGER2sOPyubcp7mnQ7QsqL3c03ORApzbga3cXV4H670d07BjFZza7gJqm4z2qO74h3tHEqW2s1awVflF8WMyXhQ0gLldj3DZXi4CyC75yYIZhd2Ed-2BUpPolJzfbFx3lqRLQqDsSWN03kt7e8E7WO1p0B85dBC2SLCfchKLPErwMgdodgro50HKammoREPLURlYJjPZvVqIDMAnTkGPSNKyGexxLv-2Ftiu5PTM3GyV2qzZSoSmBO8A8MJneATRCQofvgzaxA2-2BMADVT5OizHDJud2l-2BjHx7qsH347ZmW6GH"><img width="245" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=245x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,rEp1nYplqOp.slu8uQuytltltWs8q.q4qltGxYxKt4xJvqxvy8wYuywYuyz.wMv.udtEshuYrKsYuYuLx.yEz.0y0y0.3l0l1L0y0y0yyD&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,1023,2047,3071,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.24981684981685|r,E4EDFC,0,0.4998778998779,0.74993894993895&amp;chxtc=0,5|1,5&amp;chtt=Median%20Sales%20Price"></a></td>
        </tr>
      </table>
    </td>
  </tr>
</table><br xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data"><table width="600" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td width="600">
      <table cellpadding="10" cellspacing="0" border="0" width="580">
        <tr>
          <td width="420" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 24px; color: #3b86c7; margin: 0">
				Real Estate Update for 20016</td>
          <td width="160" style="text-align: right;"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="177" align="center" valign="top" bgcolor="#24803E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      F<br>O<br>R<br><br>S<br>A<br>L<br>E
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/26864766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3823-Fessenden-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcid88RMQ8W11fUTRIjrcFiSToTa0TwN-2BGAmHSIRwVYPi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUehylaqy7XjOdzNbd2DLQ5GEoif0pDmQjVbNlrMcRP7sf5lR6W8pSGOA9pLdrC0m06BdrQiqjMWWDxZyjQ2yfvJ-2BcSBDS-2BvLukW-2FNm95VkUWB-2FTn-2BBRYakn7p0d4eVFUAtVVM7Abgz7i8QNSbBOVJPnWn-2BM5A6zMwgiiJ9fPcA4uy24zdD5noYLjoA8j8TrI9g2RNeg4hiC16wI3bItQbzorjlS8AT1PWI8CMXwSHyluGUsT1-2BwsoCU88S9-2Beb3tzObspcFb5irGpqu6KQirTUCY0aBxidxu3OUDfhV0dt7fT" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/26864766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/02466766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3909-48th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcgT36bX2eK9KB0eYGfgpBlzzdHMhFuWxsjVZh4ejLmCI_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeoli6pwPCbZe2v9-2FoQFcqntRv3Il6dxqZqdg7ijugtBC2Y5xGDonilpLlv37LSrc20VPciAJlkK8HFr-2FdKYhWWet39ZaNCYZF8wpZ5Zo-2BPsyh0cU7LfCbj8y1SR1kklE9VYOrmpmjTCGQRSv0-2BRBqjMBIp2E-2BiHpdP-2BtlrRQfO-2BuakryZmjIJ7ab-2FVLNl6O14kUfHdsmAkT4qBDXVH93e9YRRUwFzlZOUZjpyzLo-2FtlgLzR805V4Mi2pMCPlEqDa-2BqW-2FWdRlmzoKr6-2FO1t7AcputkznbbQBpNTEUD0s2-2FBja" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/02466766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="30" height="10" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="177" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/28582866-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4201-Cathedral-Avenue-NW%2fproperty%2f400012120227">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchOyjeE-2BpdridFzf2jGKqLq4u5-2Fg-2FFNpJtzppWH5vMJzSwXVep-2BiahG82cYPMNpVXhJVQDFVXZWTuAFMsMVFGPY-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUer2NeSUR-2BjaTJkxy9tZiKn7P5lze4mKbjJ87fxexq3D0jDajxZizfS947hw9eU-2Be3dNo76u-2BBnNAMTNQXXG84eQaZmUXteBMANjxZHknZr8PMIuVNnUPzH-2BCrDAlKMtSOlNYe2h4toaz1Ydde5-2FzDWZKln5MsgChFww1iAVbdoDHB7nATRwcS-2BUV6q6StIZait7gSQy4kX2tleLXB6neyD-2FeMq0g8T9EkvixmxKhgW-2BtqJ3RkTraiqv07NDab-2BHEYF212GFDdbKncSPA0bT63RDQm1bFANEQTLMbFZ3Z2aqW" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/28582866-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/87062866-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2804-Battery-Place-NW%2fproperty%2f9323685">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcjKWLF1N2LFeA84Y24-2FtdlSM390ASUQthk0079-2FuCq7idgX0sE1DVXCOY4Gmyejiog-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeoiOxUoN7n0irl40dAT36Tr7N6YZnBjczEKKh9ITcYwZNtgfihe7-2FiAV4yL-2Bz8aOIlQkpuulud3iTXw1R2hgrjfvA5g83YxBxGsKAZv7ziBwb-2Bb-2B9eFIWlJgOOIjZerv9b8hK7YJMA7ZWa9QpyVkdLRNDCMegSdocmXbOPF-2Fvzn3-2BOIFCfQh3GHRLpP084OYllRSSnd48g38jVhze8sFmDj4-2B7ITLnJnNrKoBpg2eR5fOUqNKGzaRimnoOJU0AVSwxni79yzjRNkak6jqqMXG883zX1pBwXXF6qyuwk6CesS" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/87062866-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/71325366-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3820-39th-Street-NW%2fproperty%2f400012024246">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcijcVc8kZyHs4VCiSo3nPUbPUqKUa1AB28UKGEHDs-2BOQMPtIsJ5seXEwIiFy3Nbt6A-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUekPf-2F1LbkYYdgml5Ca9YpWuBvvJkerHekPHzBDbIFM8kefxd4ZVGqaQeaHkNx5cw8UsxLUqNJ6InwWg-2Bf8R5-2Fvza-2F8-2B21jvKSA19JjDsu0rC6pVvpIwA1e0fuZ-2BcAAIg4m-2FbpFWqCJFKbY1JYEDCLP2f64mIMCz0QOsONp-2F92StaxBkDS8bRmKtXGWuHIYYBF8A5xbadp0Crq4S9-2Bfj6HPPo40uNCkK8ouTV1-2B7nLI9aBIn7hMEEpA9-2FzvL-2Fv4tzuw1ly1QLTmRFkL-2B4BCUKqUG985IhkZdYQI0Kn-2FttCfFS" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/71325366-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      C<br>O<br>N<br>T<br>R<br>A<br>C<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/83368766-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3237-Sutton-Place-NW%2fproperty%2f381439">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcrc8hgZ4aY6MxjxFUWQPzGHaUmmhFZBzMkQgCzs2R8TA-2FQF4NjUZnyJyqolDo-2FweAw-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUescTDWjlavvrzPhBiJe1tSAcGAKVQ-2BfTmPU6jLfkQA2xeO8fTIKvOVOKF4mwYx0w5qxq2ys9lFJ1ZBkBpVq9EKkfvDUo0Rb6ResrAR7xa257eqxcdReTRDZdDOZa78n7P4I-2F5PcRv6JpdpsREs99Xqw95iOYDs5ZNyGkh5EThLkRgDGBdK2LbJVBwUroh7sNxDvsv970uKuBBt9oerhnozktKshS6-2Fl5mWc951RHW05C1wBzWAFNuArv-2FudGT24zEwnhULLQZL-2BXRiUMxxilVPGFQO6KkIyvIJTz2rL2OWVu" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/83368766-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/26640066-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3856-Porter-Street-NW%2fproperty%2f400012101766">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcnsN79xNKOrNFh7Zo3-2BnFmVJ6fPuGQ1bThuYefw2FdtbXYbgHQnHAxTn6HTajzmvjJUArXCo5rTTvYe-2BjKkxBQs-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeje5ulGhCYLUfh0sPJYXiIUn18EFOkOdKBzPS-2F6L-2FrHxOFMXT8SniZvxKt3v1F26TeiUVQQV6aA-2Bp-2FpzqPJcUKCContX4PE4wkTCZc57k5CWsoiqaIK-2BO-2F8FZuEQMj00Ai40fPDxJ-2FRXH2KVW0fGSs1JD28iauAk-2BS3g5CmOX0DrUEcf8TWcVb-2FHCBG4oXhR5tpya8Il8nqq1yWqc-2BJeV-2BTPfhG0PZ-2FoE21zsh8mlYzSpTy9Wnd2APjFwwvT4L-2FxiBinMjUTFkkc1txYTRk6AOxGOy51MMevoiaZbGo-2BOwyC" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/26640066-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/43450366-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5123-Cathedral-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcp3gm-2FXb2eE7DtJ-2BpIN8IUahJsE1KAv2Azgkk9w99wDC_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUesvIvqcwrFZoKB2Ni8-2FRhVcUvGLgkaOo3ROvSzWBeNVQa-2BqERHda3hUUPX-2BVTrS-2BZdLUtzor63hdG0y3qBEzTGr4gGBLqtb5R1t4trGVxFQxBopr9k90YCR49X-2FaAeNpdkf3qYvO2IGQMhL9lpaH4CEj-2BVt6wJvwiNajTNUIugwoBjT731j3fU9gqQJMHJ1VnECkn4sggEA029GhVtf2pz4G9fqn-2FdQScf2FpmdG6M26JBL7eeQJIVtm5592ygY-2Bg3toywuGhopj5nMbMthe6oTTJKvkF-2FbwuKUe-2Fi9QP5IT" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/43450366-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/67605756-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4408-39th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchkwqINw0koKU2r4E1fqsrLEC2tvAu4tRS8tbbKRyVlY_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUegC-2BeOnUWlXanbba-2FJ-2FGOvOXalvnb6gEv2bXOxPoBklb4yPVYkLgnoo0VgeFFGM6tJyT4rqOvfNoxY-2F-2FFnQvvohEmX2Lm6jZz64PIDICvoR7cTxblS1x4TxMJHt34IxtSr8-2BU3MKZzUuXGN9dBYAhHweechh4hT6YBQzjJI1TWrUHYsZRVMki7d7EbGOLV2-2B-2B0E9y7yA67PfdkYp2RdaBp4nZD-2FApfVLiLIiPgsT0RjMrqJM-2BeN7u-2FnWxIx-2BFU1f2Fq4oF-2FVjDea0usThm5HGp7qo3vPnXnwD-2BCAm8xKSRrs" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/67605756-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/15634726-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3831-Cathedral-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsSpIQsp69a0XvwrTmW1c6GMMX8l1Z8bZd8LDNjYr8wL_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUejIesudXKxJatHwGccUuiG73qnNBtTajgM-2B0GnKxkK7MlkdpgnKPsxCzBSEp2acfdnSDuqO-2F4JfXNlRCT0xTn-2FEsJTMjTrNyV2j-2Fk8GgrHyE9qEmr7KPULkojsRn63n5o48YiDPvTvHDTdCr0hv8PkCVxYvGGHT3cuZSFIN0F26e8k1y7kcvobGr5At-2BbW5uU7oWSJ69ZuXIi7TTo6zTrEqRYqVSi9dh5-2FRGmi7uDCcwcmNeu90JH4UgkwAv7FmpNGi3pfQVIGYCys93lyzf2tqRprbb4DGvZZAN-2B3EQp7QX" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/15634726-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#EE3223">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      J<br>U<br>S<br>T<br><br>S<br>O<br>L<br>D
                    </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/18122346-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5114-Manning-Place-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpmxsktE3pQySrJ1NnEJQrkWOoNCpRc5UAOAR4bhTnHJ_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUenWdBoZ6D9xOJQHhlj0Q0GMIx3lojGYOtU4J0YcjSR-2BzjF-2FYHk-2FaK6ki9i8ZiLuixFEk0GeKGir7RqMmLuJrobjwLUrRTFfyQUjN-2FmeXsTqash0JHmf5ILqwtcCdhxKnEhTH5AF53UYKdQ3elGfn8Z7vdw27a8Ig1nxSgEVGB9xrbcrwWbb3eNCMT8kGUb6B65SC7NiwWjDVgYmNTtPneJYKkQGxl1grLV8SHrzBbPA3KoB2SLMc8w1NkVkQwHP5rGppOdLdP8e0UBcx8Op-2Bm-2FivkYr1hE9LBDg1kYIGQrFT" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/18122346-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/45391066-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3217-Wisconsin-Avenue-NW%2fproperty%2f400012118198">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcnZOC1JlAB2OBWr3pNeRTrxUzo8baA8z6sZIxQkiMpnwiNjNs6u9Llzgk3HiiKwxGAJGGfZglUosi4GkqEAYano-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUep7nRPgycCPOOrBK1tm-2FCqvBQ2JxD63-2Bw1loTOdj1KFOvauTUoxKMzLOkd-2FvoEYBoj-2FcQuJjGnLb-2B7F-2Bt4qieLKy-2FTzUfE8ly1B0pqjOJhwS4eaonv-2FXo8PCheCleObrdnFvnpT9BMbCOju57hsop96rqdNdXOS4ckLIu-2Fu0mpThuf9Ar0fiRJuw9e5bzSAAUXUHFI30a0Go-2FCJPFrW0S3dOAwZIHF1KdkxqLNNWVawWtUSU4OvHY-2BIEEA0CjxfHj1-2FEKH5SSGtFjEULxhbMB1Zklcq3aFzxWeWVtKl9Oo-2FE" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/45391066-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="356" align="center" valign="top" bgcolor="#e4edfc" rowspan="3">
            <table width="30" height="356" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" width="30" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td width="30" height="351" align="center" valign="top" style="height: 351px; color: #000000; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 14px;">
                      M<br>A<br>R<br>K<br>E<br>T<br><br>S<br>T<br>A<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUetQKr1txPohMSFd5oDe4kqaZ5IwHiatisbnY19wEIdh8flKpeexY-2FRW3mMQ8TSm6sbaI-2F8gh5sH4sjebtdm3-2Bil3QD5lb-2BohYSYZY3-2Fe10BRRaOiZI8Bpc4HKQZ3C1e4v1oEx6-2BrICGaGpZMnfGmZOUmiFif3zW5MZYsX8iBG6rVX8y0yov-2F0nsb-2FAkVb2MEGPXwB8vbRsaZ4XHyY5SXnhvnByUM14GcyOankSGoRqnXmpPPFhEsVpAh-2BWeDkSpjkwnunKMCz-2BIP8Fo8Hyyngt5L0Ummpz1aQ7rpj56Pgri3"><img width="215" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=215x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,jgjggTf.nqqOvBuEvBzMwTtvr1ploTkJjggodHbMX.YUYoXCZRZRYoZ6a3dbgTh6keg8jgkejglHn.o8nqoor1oopRpRnBoTq3rMq3n.nB&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|0|40|80|120|160|200&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020016%20Listings"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUepeDGYIXb0A5Kku-2BwZCX2ND5jo7KejEbsGwwTG2-2FyWpLLsRS2pYaUualn7YNQgNudsAwU46lIghuHBRyVuAb85wSGEgyrLTdypmQmO2wRyt2HBob2UOZWElFIpTe8kRtDNiVuxhHoYR3gjS9JlJmXg2MpeiQqfgk9n9HWb1jBsxTHI7-2B6w-2B2zKuZXJga7ngkuxRzv3SNX7vyTA1JFU3ZCvj-2BYsy-2B90OYbyuqpGVQETIWWhc9DBvydH6qWOh39qaVPrZqt7BzQ1ZfERMQvveDIdeXd0jt5a1rkQNQXtwk1sZz"><img width="245" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=245x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,2Y2Y0J8yzq.qyi8W8x4H773-zHytyMx2uYsyuAo4mUjqlDl6kylDoPtvswqhujstngmYrMvjuKtP8u3B4T2E5R3.445h5R1byMyCvqphng&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=Median%20List%20Price"></a></td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUekCTxOBxiD2KLly1Al-2B1vkPqcoDjP9ka0MzHXGuXGs0Rx-2FKiatIdch8uNny-2F6ECW3gV3D1ovxktjW-2FZxjap6K-2BrE51It3C-2B-2FPRzrCX4F-2BuK5tBt2Ct64bKwGbyrMTLMScwHKJRA7TyRYlH-2Ba3oS-2BSUp1suyULttXWYG0UqhjP2SHBPeHQbBFo8DfKfVG958bWu8FTRjsKumiWud09cKzxHcw3WT-2BOazw7Ov0lHAcNlht5TGoAqKOispMsm1kHsh2Sl-2FZecBMWVyFc-2FazR5uotsI8s55OsUzBypYfKoj7YbCw"><img width="215" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=215x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,mZjMplrMrMoyfMYydlgynMn.sylloyn.plwywyz.rMiZfMbMX.dlX.X.aZb.gyj.kygyeZbMaZeZmZuYxlz.zMvMtlplvMvMz.4yvMvMpl&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|0|20|40|60|80&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,1023,2047,3071,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.24981684981685|r,E4EDFC,0,0.4998778998779,0.74993894993895&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020016%20Sales"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeliuppqcPHLoPuyau0PC3MzCdxeuq9Wxz00yUkD5s-2B-2BCK4G558iamAv9etRPAQ6rHGiNNYH1Ihu5JPqg9SuxsoWmmFiVyfGU0mTG1zqyqvAYCIoL3i6wAzsIvc-2F4AuMMOBvFcVQziZa0tSXLmkDrMPrK-2F7m-2FxnHkyUtJsdVnUhnwxRo3rKSLPRgLdqSLSggBFvXpQHKyDIiwKEp-2B-2BXN4DmjPf-2Boo7jTgX9P0Clqy34CZ57jg5hzUfmaewY-2FWJ3u3XTfR1sRKmcV6AVUaTv0Vf-2F8hFO8Z33vIPRTtMpTIoUEN"><img width="245" height="180" border="0" alt="" src="http://chart.apis.google.com/chart?cht=lxy&amp;chs=245x180&amp;chd=e:AABOCdDsE7GJHYInJ2LEMTNiOxP.ROSdTsU6WJXYYnZ1bEcTdiewf.hOidjrk6mJnYomp1rEsTthuwv.xOyczr062J3X4m517E8S9h-w..,4by6n.repvlzsCoRgvoRoRhckQmze1njn9ymzt3Q6m1g1gvQrrrVppokotkWl8pljshcskoZ1z3jrorotFp4qZu8xf1q6v1O7C3Q6K9Ez6&amp;chxt=x,y&amp;chxl=0:|8/14/17|8/13/18|10/17|12/17|2/18|4/18|6/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,744,1489,2233,2978,3722&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.181684981684982|r,E4EDFC,0,0.363614163614164,0.545299145299145|r,E4EDFC,0,0.727228327228327,0.908913308913309&amp;chxtc=0,5|1,5&amp;chtt=Median%20Sales%20Price"></a></td>
        </tr>
      </table>
    </td>
  </tr>
</table><br xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data"></td>
        </tr>
        <tr>
          <td valign="top"><span style="padding: 40px 10px 20px 10px; display: block" xmlns=""><div style="font-size: 12px; color: #999999">
        Please do not respond to this email. This email was sent to <span style="color: #24799B !important;">rhbdc@icloud.com</span>.
		To unsubscribe from Weekly Update emails <a target="_blank" style="color: #999999; text-decoration: underline;" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N32IF5E49zjOlvJHyWSNW-2BbYRMw6ha0iTtd7-2B0c99Qqc50t0ogMUXSV-2FNlFK9Z4aKTi3RZEctiW4nFSVHpPpbCh2306EX416-2Fe7dqr-2B1gwmS9LRbvmkY5dgAUxQXzkVSOpUlz6qtm5OUwBcUhv5FRS3pVe7Gr3jSIw135gESHtDi6uzh1VKI20vqtIcE-2FpXk4uBiihjOdBqlqlfm6TomefcxPJRsLr0dCR2Y31yPFx0AJiCKXChXXAGqsZuffkHD-2FO8-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeuicSizZgOYjYLqfwuCsm3vdv676LyEH-2BA6ZAQKOu-2FO7YDKlcc-2Fh2-2F12AP-2F80C5upNg3GU1KfGxGsy6w4OLJNbktjmXFeC-2FoX-2FMi-2BPO5JY3-2BaRtKEgpWOf1ssliRIT-2BnudsMImP5vCfu3XaWwXAYDTlzFrfBcmj0dRHGIs-2BhhKaSWyAWvu3kj2Zqy8cMW9U4RK226aVooT68OZUUTfKFg2fLa1oSEzWvDNamPrNqIE8fnGDZWlrz-2BEg-2Fv8eCws-2BUV35wm1rDAU4vXWzXnIXe0gxqJxNT6wJCGvnZliR1fl-2FI">click here
        </a>
        | Homesnap.com | 7200 Wisconsin Avenue Suite 200 Bethesda, MD 20814
      </div></span></td>
        </tr>
        <tr valign="top">
          <td align="left">
            <br />
            <br />
            <br />
            <a style="text-decoration: none;">
              <img border="0" width="600" height="315" alt="" src="http://www.homesnap.com/images/email/HomeSnap_Footer_Note_Large.jpg?v=20140626" />
            </a>
          </td>
        </tr>
      </table>
    </div>
  
<img src="http://email.homesnap.com/wf/open?upn=WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZxR0uxlFht1pVcXLd0-2Fx39rZGmIWMuhFHtTTLSrRPyZ-2FYH0OjUhUseJ8x9ivrXE9Du34cNgRNChwX6rI6eLgUeuiYqKyaHdAVSn5EHHfwnd-2B-2FbjhtGppQlTZT0LTqrkvU6T5inIABoXOsWEWTNnN4AfkumnhlH03ucCMKS8tGmdS3wEez6tSbFlB96NrcXQBa4ywPDpOMyJJD-2FOsUgUsT9rvblQQrl0dEuzVjsuii2cB4tOwjOSYL9smvttnyk6ZhlcK8i-2FdnaGwWzTC5ls2TGNXONdCCN3fZuTIBWpVpn283Q-2FweGMV7JILtVVxRh-2BM2u3I1HyLMXuXC9NrxvtTAYSAw1ac8WN9naoBO3h1a4A3wVQEJwI-2FeCTZaOhqUM1s0" alt="" width="1" height="1" border="0" style="height:1px !important;width:1px !important;border-width:0 !important;margin-top:0 !important;margin-bottom:0 !important;margin-right:0 !important;margin-left:0 !important;padding-top:0 !important;padding-bottom:0 !important;padding-right:0 !important;padding-left:0 !important;"/>
</body>
</html>
 color 000000 conversation-id 7051 date-last-viewed 0 date-received 1534408264 flags 8590195841 remote-id 8739