Subject: New in District of Columbia starting at just $324K
From: "Homesnap" <[email-masked]>
To: "Rob Hunt" <[email-masked]>
Date: Thu, 08 Mar 2018 21:24:18 +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 turn off your Homesnap Weekly Update, please <a target="_blank" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N31Dt-2F87aadY3ANDpzrL7kh808Ne17xIVlQJWUZfRbclHe8YWbosVi8zoeStWddO6Bu3XLPeBasdoUiufffUvwgq8DOqcKrNthB7lN7MZqOOSw-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLsWHO2gYFfsSh-2FYUkvru32HpJ4U0ctwjCCrCr835sdzb-2BsoQG3v4wO-2BXOiN4ESQ5p4frKA0bNclp1jrs33sckAHkdldMkuLrucgXzA-2BrQ9Ox6YvzszMQ6daG7ru7yaWUYDREkQe2qggwdC8zD6B19eM-2F3wuK2QMbemMfPL47Snf-2B99I3kpDK6JgRdZ4ltS2M9WjVSqzre5B-2Fko4L84G-2Bxisk8PbM9gEjKARn-2FnGY3rdp-2FxXYR6b5iJ48Xg8kr2REFjsjtiHk16EwT4CayYTGiJI-3D" style="color: #999999; text-decoration: underline;">unsubscribe</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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLjvTKGkDUnjXmwNmYKgiiJI2c-2Fhdd52sl9k7mWrhAjyRIUrnmGX0E3JfZRANztzVZKLHoAMWQuo-2F8VVhBCix9oo9dvwXu3pJkD-2FTJy7bX4CBiouCIYrXN0CBvlG8piB0bPfcO-2Bo5ok5UkmnKlBoWp-2BlRNJZIitmZS7NBzKzEQ8HOU2a9u9UhOnmxK8KlXsAdK3DwgMWrux5lQItoPxi-2BdHPH87x9VUFkZFTiGY58dYGU-2Bcp2VHTc5OLS8q-2Ft9cB5PMe8ySgYTXwoNnx-2FAVCr6X0-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&#xA;              "></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&#xA;            "></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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3901-Tunlaw-Road-NW%2fproperty%2f400012088670" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://img2.sbck.us/listings/no_image/4_1_listing.png" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcqvwZvpLetu6WOLlqk1NoPPT7FjTLCvvR-2Fu-2FhkQQx0MGZAsj-2BPaZGCla1iBkiFkKvA-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLnu1eOzFo0XO5fpfPlrq9XMHY0BLEgNnNt7BHBFvn-2Be00faxiUn8acswIKzYIejthQSS-2B0UKQP14AYAB9tbvl2hhbmciQoJvIWsiEsPNgK0u0KlBalvvwaBVKR3r9o5O56xESt6MByiXXktgfvw2mSZkMKgt6QtLNuvtnLCB44UwKcjN6U0dMhofRwg8IHKY49Cn49srRyQajXnryZgNGS8Vx7oGuibnp1P2TItI4ajqi9TcmdEj3LKDDqW7FIwPJQXgi6t-2FNsXRcs4yn09NlGY-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://img2.sbck.us/listings/no_image/4_1_listing.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f1685-32nd-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/46747206-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcgrE9fk5M4WENSu6D3MIZnADhi10uQctMgpOiAR5qATy_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLgbtYkWAW4qJftx635oq2CNMEqsra37z-2FwBG9po6dr-2BwR7NFlFzDjL4MaVwJyq12mhG-2BbV4QiShyPzmuWdWOCQ-2BZMGA36nndpV-2BjFTBL9vgQFY5nprd0y9DUdROdNELUFywjDR1DQgBSfcibP6TxFUKUTeOQ9xuj4qJ3o9nAuBAZPjuK6aLAq4QAIk8Ja9darvKwP67gRTXla5vaVoIOH1QEaNuub4U5vMBJwzhN-2FVvDG7WWy2jTs68NtigVLmAsiyEoQMxQkqAoScCXTnf2dmo-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/46747206-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3402-Dent-Place-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/83331306-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsbpo3JuPqhR-2Bi9h3NTyx7c6rONw2o4StDPISgrZkuPh_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLrkkAiV-2FJCaRKPPSSfvYeX9Xn3v9lGWkpyfaKLeAZaRXR0jcpRREOZvya-2FqedTwEAHmWIF7D8oJcf6mPQ5NfOlK68plEOQwp9xJOI-2B0Isb1NpgSnIjtfK5RosA9EY0lQEh6OAD2WdmkGmAmPQoLq4F5dndhBIE0xqthg7kFeIsdce8B8BuC4rV-2BeeIAGlz1JHsEUhdtRsnYp-2FxQxmh0X5yuLIiV9FJLEz721hPolJ98vLe2gI8-2Fzqlpa9w3kTT1iql7pm-2BZ4BzSoKBiitUOgZxc-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/83331306-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3032-Dent-Place-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/67898106-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcoB2SvMZN3uuJYajyIBGYMAmqEc6cJ-2BOEnAkFQ8iHmh-2B_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLqm-2Fa2r2wGhdYb4tFI7B-2BqdoRe5iMor8-2BwjzbWFBBspBKpbr0PFnTuBaZlaH53K2WtZlb-2B3-2FOfh08cAz6-2Bgjx-2BF1hqeirbuC4Vd8QsK3JSH-2FsxHAXhPB5UX5iPEB7-2FVnFm-2BMy5tUNooXGiLOrfP3z8GIVPQQvMtqnp6L1JdNKEfJE9nIWjFakP1AWkE7GVrTP-2BdYw9AuvVqDS25olkijFWCuiZYWsska9wGig8W0t8smoi8DCRSfBspoZt8IFUK4wZ6F-2BnQdFAsVYPgW3p7L3kk-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/67898106-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f2703-P-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/41091306-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsd4htfQoh1uxTVc3ctEGFHS1-2Fcf2Q-2Bo8fahRdgJobnU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLpYpuNhRCJULMIVWjShA4cr3FS9jh3X0Iu8dSzQtzrOLwTRtoMAccwSa-2FocRNoqMvE4ABD9IQdTFEI8ysx6ePsY6DXD5CvzFHZX2R07OICHoDSKqZSVqUQ1jGqlq7X6vwgBoCLjFCfGYjFBrZUisPg6Ins2l2rDObW9T6GNfrno0TS0P8QdF49Q55ZgQIZWZo75lUFUWhAMPcUOqf1HKds-2FXgT759wdrdyx-2BTp38CUqrhUr3cU1cP57V8RO4K2EqHPQB1uQVIUIs1OBFWoQqLdw-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/41091306-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2fproperty%2f400012015894" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/76550795-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpNQ2CeWGJQx8i1f7NLgEUcfafuPUtEON0-2BM79Qv5-2BWr3nACkQtvoMoAFXCPcYF57g-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLlI0sThZ2IFdA5Jxg881VbrL27LmdsX12RGxQDIQKVPEPQdyr9xo4Q4xkE8c7Wu2JYMlbvP-2FtdhHl56b79yHyPU9-2F8ChBHtEVKFylMJJIo-2BILEMlXwlXLesPpXTaC0HsCkz-2FwKIqPo24nv6WzicOlKpGBO4FmdjpcNgKvoFMZz-2FmrlXLxBsyg61jxcWb-2FhB7JROQ-2FR883LsqlTNwSJhkWQ2mCYTxP-2FdFA-2BM3X28q7V9wn3LjjCx97CR7YU0BUIg8NWJNZ4YnquYGIkYNHoSwk-2Fs-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/76550795-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3608-Whitehaven-Parkway-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/16796006-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEctags7or3cqjcgsmQgzCF5ONYlllApf3ZQZkRbiHSyYN_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLnEjlEdipHDXT002fxTZW1b-2FoNJ-2B-2BaDF22W-2BovpMTN-2FeTHSZn7HlQGV2sADXKz9dUMBYjWwLtvpAvTNqxQwTuCN835-2BwCfmIFEGY23RMHbQwBrMLWa7rFUq-2FrWvIk3gnzVNAxKUlIwAVveFO6208s0wZkqA58um-2F3-2BamtW-2B4Im7aO2x1JQYRISRwPwnaNdiixSnUxSAuRtRK4N-2F9QsYm7az-2BU7-2FKMRIgmI-2FMDKZ0EuqlSzBE3f-2BSJRP-2BlgCwjS0vNUT-2B6aG0Ns7kc58r6uZ7tfo-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/16796006-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f1639-35th-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/66920106-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpjol0b7smw80nhTf1ExHGQ-2BQjxKzOFCehi-2F5Bj67QRC_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLpmbbkLpMuEEF0tnN8hXxewIFbcpTYJj98EjDUO5hRxjK4m8DqDiyXPzcAr-2FaDOU1V4QdkFraf2R2SuZSkG-2FbH6dVJi8WCd4kHG6KhnUDTNQu0r-2BOzJ3dKVKW8UvjZ9ffTTCLPzZuiEjTe2eoCdYRpaJ9pmXxANWVaYz8IDbOd-2BsryT-2FV7NKlktMoT8XKU-2F-2FkMFwZXvN4a18zoXxAaAgJY796OXQ8zbIytyjpmV0yyUIkmQKw8ihh8L7iXU9q4-2BYoRLuaydf2hN04nY9eQzRHac-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/66920106-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f2704-Dumbarton-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/90576595-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcgumuXI-2F5EZcpKnyXKKzKFDdcIoc4UfNGARhZsJ-2B1AhI_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLiqOvQfk5M2I6XUCHvaJP5ygARzjDooofswSOUcZTqV0-2Br-2Fa4N5iMkEzxVj7bBqeILtLBx9eE6IqCV2WetnOtyUdj1vCYcYS5PAp-2BjZEZp0ROGeDa9rTANPbiwabWhhQSPQOFQFEfcL8tJLgWDsFu86lN-2FdOU8k8TAexPGHhqwSc6h9EsacyCpwNizErPoHyhXNaATJDUDuMWJsqqPYq0NQzl5q7hHEPWGBWxHVqkhtXtnjN8uSYQ2R6pBUTYmtodvU-2FmRrXN4LJu4SqqD2P90o-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/90576595-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f1803-37th-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/04514495-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchWnlzWf3LVd85UaW5Ee4p43IBS3SxNfmmdaL0xSchlf_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLm4SQuyIT7YkUAYTWF0OFL5eEXHP8gkDpFYDzoZqvn5yxZCk307HW5boqv3S-2FUE7TAYjDBfNKcmUXlA-2FY1t2GFi-2BSI0M-2B22I5SllvqCZFhKiL4MRYl6i4p6PbjCASLBi9JkzKDTJrz-2F7DJ3ken-2FP-2FCNdRugFwHwyb9ZeAPGw3gKb4B7WV5ZCfMBmgRQPBznMHIT9iOjzb8lsIoNTnsD5GgYY1k-2F8h1cGRKQaezQekTrFyxVHTmdxEDRu4qj-2B2WMcy3LhK3sQ6wyaKzsJMNuIxOQ-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/04514495-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f2141-Wisconsin-Avenue-NW%2fproperty%2f400012017664" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/75319885-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcli3VaGcG0RSbIFg3jrEw54qEeqFB06p9BMP1d1Awjg6oxRwtziuV3eNb5wmMEMYEh-2Fl2BsC7oIvKb17h7YnGRk-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLn5v-2FTFT825c3c1d9-2FJy5D61oV0jG-2F89kXmlKSdUkM68xFAIbBjxv2q2oK7w0Xel3vQNU254gb0ip0x8-2B3LEsHtqSDObELRbGW6ptvOuZM97FqU-2B31vfKFV0Oc02TGVQ2dHHTACdipAv9i6LZ88lB1vc-2F3isrOEdItp9njzdQi3T-2FE-2FYz1Fm1ri-2BKkRrkoTYiut90j6E9B2nTZcIYJcAzRXEdZoagtfLHPRG0mPQFIEIJgjLuPnUIeYuJj9DYhwGUAC1ub3VXKxCUrxpI5D9dWg-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/75319885-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f2725-39th-Street-NW%2fproperty%2f400012018036" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/31248295-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcrDXDuO9mYFDaT2djw8dCM-2F9huwlB-2F-2FceyD1jC0SFmVB67iLXo2J2ROlfLTze1H6EA-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLhapcolh58ryWpXO4TL1QCViC5lx3gNjqZZuWlrD2O1YN9-2FUBdIp84pkm8eenIedqST7O4zm-2BcBmaME7l0C3AA2gTnfvdEZl0MXoHjXAKkKPJsbeJw-2FIq5aymcjD917S61M2E9-2FOAtOSWwbPl8C0RnKhrnyqGx-2F4jj8zZVqJp72GjaF-2FH2mF0vxi-2FtgPgMR1Z3rShR52sxBbdA0R9RR4IzF6BtheteOzrMmCnkzLtQyPTOFiXTteevN45xM-2BrfQNIvX6Z5hDZPmhLMeRCyVDUzU-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/31248295-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLrArO77qTlfiMSiKDbiAKMYQTzjqaE-2FeSOf-2FpaDnZT0p4rPygkKIKQcOd5N6-2Fj1Igt9Q7ZZBvB4KOc-2FGjmgEwqcu26FcqAl2Ng7BVw3pLDOSqYWaeCQIqrdQSohTjfuiBoRLKfhlnJNpDtoTDwHCy3TDXmTlaZoLAH2eJW3w1SO8L0aDPw4WWsvuh-2BNlKCpMYNHknILa4AYg9lAEzX-2Bq6fAOKdZfeGzw6XZmk0QjMMVVWNGMXNogu-2F0qUqr8uyEU8ZxyP3xLMbfn2jNDdzgeSlw-3D"><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..,jgkejgi3jgmZijmZoTp6p6tGrMrgvquYsypRplqjq3ookJkJkefreZnBrMrMpRo8sesetbserMploTmti3hReEdHcydwcea3Z6ZmaOZRet&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 of 20007 Listings"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLvGxz-2FoRixsQbaHSZ2-2BGdHM05kpxjYol-2FEXDzq3LEXKecoPWPblc8TbH7xQ-2FVNQPFb5I6Oy1yTXP9DOof3TrCrGvsqKc7luRyn9BKTBWVV-2FOHqH8ZqwYd9spy39hBh3krpfHFxs0meeTHyVeb4bL-2BUKj-2FJ3YShBd8u3E4cy21QRmWkXlzRzJ8aGfDx9gCELxc7ehbjCYje9kew-2Bn1s-2FDelYUDmysmhhmVyiHuL41-2BO-2BK-2BdMS133gj9HhFzJcqJ2werKFW-2Bd-2Fv-2FkEqBu7d6NTf2E-3D"><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..,5F4U5F5FwHwZxQxQyF0ByWxrzWyew1yW0L141z1tyWw1u-rxrrrxyWsmrxtdrnrnrxsnyLwywyx7rxrxx11tuSvHyLx13D258c943O3k3k&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 List Price"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLhbjWgbrj9LIQgs8KyxaKjd-2BTrPSMYfM1Xb5HFrAdEHoPrFDU85-2BXoPjeOXLzgVnOkoe6EkHXziqAPT1RNJtfH-2By-2BN-2F-2B-2Bm9WmHotFDJ2-2FL6bG4QhlztNkIldR7bsxrhNMqYsCUEhjbczcrEZmDRb6w7TSpFAWo-2FMwETT9PN4kTijrnzQYkWqPdL9q9af8KB0pq5YZehXLJFb45ga-2Fts-2Fxw8jDLQKR-2FOPBwqY8g40lRdwe8A3rQ3eWcA7TXkO7wKZtrRki0p2PsKiSY-2BKCF33wMg-3D"><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..,lUiIsyzMsyruohiIf.ohruzM2Yv.ndndru2Y1UzMyHpl0QyHzMyHsyt2mZmZlUmZmZndxDu7t2zMjMpl0Qu75lxDiIbuVVWZbuaqaqXdZm&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/18||||||||1:|0|10|20|30|40|50|60&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,682,1365,2047,2730,3412,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.166544566544567|r,E4EDFC,0,0.333333333333333,0.4998778998779|r,E4EDFC,0,0.666666666666667,0.833211233211233&amp;chxtc=0,5|1,5&amp;chtt=%23 of 20007 Sales"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLma1oIoiuY79USvaOW7dQbY2-2F68EBD8ztU0vGCdArEpwLQnN8aqo0sxoBlv4DQoWGa8AcGdP-2Fw-2FQ05PwLXaVQuagdz4ctGlS565qP-2BJvIvQz-2FlnwUKdMc6hsJjTHsC8UPKRxAnzsKRfEA3Rsg7NrXrc3kCyW-2Bdfq9a53hvIT9AJQ3PKj2I2xbYIvJjkJ5Tl5gl8NbUQupn7v-2Bsyw49vFl7O-2BYZrCpoqSZC6BRbuTSRWMUy4AcBERF68iaKsqAw0blmPU0O3Ph1uIjs-2FxSe5WSTU-3D"><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..,w-yJyJzE2JugxGz9z93T0OqjpWtxrz2F6U6U7rwevvsiutsisisJn.sJqktSsnxrwhws1dvGwsuJtYthtDtpv1sRvIq7vQwesivQsMv30D&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000|$1,200,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,630,1260,1890,2520,3150,3780&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.153846153846154|r,E4EDFC,0,0.307692307692308,0.461538461538462|r,E4EDFC,0,0.615384615384615,0.769230769230769&amp;chxtc=0,5|1,5&amp;chtt=Median Sales Price"></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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f5112-8th-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/70046106-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcqUwRU9aAMtei3QGEicydCStLe6EQwVY0Cn-2Fo7XFPJHB_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLvy8dXMoja3PbRl5kHhM9TDFlLh0oMnE9xluMBIAvIdn1t5wqQrsH9i87G1qhgDNt-2Fpw7Y-2B2r4qv8upgoCGoKrHqMRzsSlfETHxDhkXeD7bGbswxbTURs-2BeCGxoHuQlNUNtDrLGn3Memkm5z-2BY1Yvu1gPA2g12aTo6WPcqpaXXlQJLFheId49s9r-2ByRvwkY7dHEFFMOzZQq87qhaQzvuGo34TPouzCscauXOMcKBayiFycdEmDxvHBXBRhI6ibROSwtlU-2F05hTudTq0lnlpNhao-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/70046106-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f622-Randolph-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/54255206-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcp2mutVLTrIm3L6VvFW1-2BK20yzQGhuPQXY2Lt4Ad5paB_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLpk01A2pdvyLSKn1cSzZBCzR5OnMf0X1WZtTEFukw1VShvGqSCkP-2FA6Fr4rdRE1FNNRJ3ZgWD2OzPno44lvrwj9ezI9XITW7ODVmhcs-2B-2BqyjeyyF5CmgTE8b9aSVvJdMufQY1Bc5cG19P-2Bvwx8HcC7Y9nrykqofNQh-2BF0pZMxxg0hth-2FeIUgkhVJs88MFbHUvVGlLUTfnd8Vd7DeDQgYozO94yWRuNMiDfog0Biq1mmtDFAR2ekImWLsls-2BB4ZhqE0F-2FNJXUdkvWpbOukTBOj-2BM-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/54255206-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f1320-Buchanan-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/10161106-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEckD3Ti-2B9aLZuBilVrFH9LpGfPi0rOFdwAYVmj79vPi9n_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLmNawWxu613CtrexcaF4AB0I2i3vRLJgFrNDKtPINkir8exLw9acdRIz00HdilSdPUuFD-2FbmPtfFq53QpAl84B4lRUWY9gauWgnmf7RRpQiAQNDDfFDBZOMBw3YFBFTAqw57GjvSPKjSCaE6DirRX4qMUmEhefTcJ-2F3G1K8QpdpnsUAQm1Gmuqj1bYNWG-2B404Ioq1cOCCOVJ5w0MVFML8-2BuYjvTlD9MgGfGY6wVZtPBft5ipgnAJ0UWXo0d1QmCB9RB9xgWz4h3S1AB1BMfHPqk-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/10161106-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f5714-Colorado-Avenue-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/43628695-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchysrQs2R1eoChYp5gqvZBpmq77LLAonZ50gOQfMvCy-2B_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLtuw9SgRUEqEijBNKC2VVB-2BDyA8ilIbOekNFbtbohGw-2F58Wbg5jzUF6wvG1M8K78enzQH3-2F5-2BSUNekjeSRCK5fu-2F1cPrlpPcQ67IDQT3-2BqO20pbRELtjS7nhyes7UmsdQ0afYFHK9jyxtsm4LVEeKdmOZUFBoY8LXVp0ptv7qYHtlUWhe74W0To4gT3nbwu9rUwR08O2XYa468zWxH8OD2ZkF5TSFzRcu-2FI9iirZGkoaatvG2A4R8BOEvQjOCoyISX1YeSa1r3W21TrVjI1awxA-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/43628695-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f437-Hamilton-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/53126006-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcvJflU1qwzwWHo9UCHIIwc7RcGAEwWcEg6dMsue7-2FJ3-2B_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLp1UCq3Lcb8auUyHSWV-2Fftgnz4aRne8l34M6Y01BCrAOv8DEuaa7YY1mBKttaTKw0ONVWhIN6CT86dgnyPI7nITfGuWY-2FC8mJ8Qe-2Fcc-2FgFDggsuqo7JKAhle2Zw1ReFeq2SfXBqGEXzMV1dqLQZ-2Bf1oCWueaVc7JRGpTw0TurklRefq9vBsB3OG4MbQcpa9R5aFfZJPZgukr92QICD3eZNN3lNLClqWIhJtBpLoKIh9hNoEbwFZ9zkl5gRavJiCt3AI4qPIby-2FosL7Nlsins8I8-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/53126006-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f505-Nicholson-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/03933995-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcj8gjgNoqT5kqOmebKrziiPr-2BW3ASUVd885Ejbkjtel-2F_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLteRE1jQw0UqEMgAPk9dt9fySJlw7VDN9PLtMxFngEDtQpQIn2WoP8vg-2BbpLWZHSLNFewxLecemRrERZSMKyYfTvH28uFOp8IdwTmXUUWTvmkhvtasZHFqtz9QEAU9SX8N2CJt7YUSPhNxp3Q6d3AsUBDtUSVlG6iH5mbXfcTmrCfAOL72o6SaaOGRMs9DawYtnkhNOCjvznrBj3YXhONK-2Bx6Yku4832qu5-2FPzSLdlictQm4gy4WYJs6as-2FVjke3MDGamvj1xHkRO-2FdD93iBO3w-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/03933995-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f5006-Arkansas-Avenue-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/33252775-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEctqHekzfXnzcG3Yap2EcS-2FLQYEjSjkcFQMEsOIf11KQB_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLkTSl8IhrLKQB-2FXY2LL6XwnxLO91DpdVoeeM8vndaS-2FAvCd07a7OiwpdUwq2iLBzclUwFLWGS-2BIpjJLIptJGzDmiWKzsWZT5FJ5aJpPeFgwE4x1MdvVwejtcEGrqKM8sA3sS6dNk7eq3t-2BAk4DdjXzrPO4JIX3wT4sFEwUCSQeX-2BPJkLtWJx8289Z1i2tUKWcRujQqH24OFMAFN-2FeTfXIMjpnm5ZkRY2bqlBanUfu9DQC-2FKMooMf5xk-2FF-2BXGv-2FB4oZBzcY855yEiFar-2Fsw69vos-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/33252775-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f216-Madison-Street-NW%2flisting%2f58408757" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/75780485-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcup9UuPVCXjvF6vr24bHt4l2RmY9FTWfRbsnzDS4bi9nwVThtq9g5c8KENMAbC-2B41g-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLsvDcfSzY7iCqMh5ViS0P1pAUA2m1ydu2Tbp2KcxvsmHUTc-2Fj2d-2FOQWD-2BCRYh-2FeJfDvtbtYcDPV69WeKQS3UBhhl3qZMsqQ3UR5xSizi6nUjsL6G3iLF-2FUtdzlwvFZP38axBN4HNCz3Hdr18-2BtZBIOfqWqKIDN2D8XnVnJ-2BywwWhgq6rg5r8FPJ9fc8UaUQ7JMbDeeuAUMMgVI8QpV90gQn6Dzrb2sgqifVg95YDvg83u2kQdWWIAN3HjYFDBDN0Qjs8Qrbg4yMGDSZSadmH-2FhQ-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/75780485-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f250-Gallatin-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/78762395-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcmrZGI9otAgWb03iOYbMbIoux1agflJWbiWSmrPdEziL_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLoVC8QCLuo8iI-2Brkj06hlAXa2Z-2BWYotwI-2Bs3oRGd4iUp4elNHv-2FWb5AiQauB6dgwAZdygF6tcnH7vxu4fAm49NsbIdbl9fK5dQ-2Bmz3VXwl9-2FbO5ky9akxdjRwcjmWnRuewKu6Thx7Jrz76Q-2FfbD70NXM9bYBOhE7bIJS4cIpLYhNgVi8b3HULAN6iE6-2B6EpkTQCblauJ0uG2tDagHkjX40FIPidox78NsYWRUONCf09KfMwHyxlTNlZ6dcOshqChYBrW2KtQ9hPOpohgZMUZzBs-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/78762395-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2fget" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="https://www.homesnap.com/images/email/web_ad1.png" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IdKxl5-2Fqqj8pYIeDIn-2F2Yig-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLotAMn3lm0P1GUuBKchhu9FiP36uTAsQOeI4MqYQQbOAbTZKKc0WNKQM0ea-2Bh3sXKpvDHJQhjpFfUiHMU-2BiEoeAuX9u0H1TA-2BtPIKbikJ8Rep4-2FUvoqwXF0HrlzwYAnj1xOmgyeJdBZcMIootVDnaNTat6EiU-2BLwWjwMgtqG601672pshTcsxvbW5SNkOiF8XA9ReYnWrDOL8m-2F9EsTMKvXj1EY7p8rLk5G-2Br0YhckAznL11kvmGy7x5pyQOV3F52q8l-2FITe-2BeoB6U2u3EP-2BpXs-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="https://www.homesnap.com/images/email/web_ad1.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLnX9t-2FrAaX-2Fgn4kkRC28b8m2Vanq88J9AyVXav2I-2B1ESvQCG5M-2BsoNpxk0TkYd2uAXo27iONRiikcRtnR6TtY9bxYWUBNorxuzITdaXb7QcwPzc1GK9I4Ntga2-2F65bfVDVJfh2678NaU00D-2BVkg1BwfUZjVfTN1N4lr7ppgZbf5KgLEgNOMBpNH2hP1keuF5bUcEyERJPfiYId1j46eTTYGZeggOgIH5tSbZQCKnyfq7FgTedNCvo3tmmnamz9v11k4JNsBK-2FpQjSE2uB2AC4bg-3D"><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..,lbmtjgkJi3mEmZj1lHhRmZn.n.qOp6q3rgp6plnqnBplmEo8oomtmZvqwTw8v.xl1vz0zgz0w8xluYrgnBlbijjMgTeEg8bMdwaOa3Z6cy&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 of 20011 Listings"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLoWwn-2BXVOMAtfCer2ivDEpa01Vzxc0nv7t1BButXgyj0AfaR1z7mm8zB8HFoXhovps4RIz2DSM4zUokU6hY3NAP2iKlEdUFgxTJ4d8Wh9RVWxAKvH4x3ev6lhckYVEsxSdLLoVb4AWdC4GckUzQabDzoIp3hJM1-2BF9ZFoF-2FxC32RThKGwBgeJBjI7BAOAScOPfVqh8NzQOAwHs-2BJs-2BTfvHHtXc6Ei040wGsEl-2FYDULxd2ITSOfoHYFJX-2BDgcMCyCf2gmYBRcb6GOPrbBzL7X4yQ-3D"><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..,vlvlv6v81gz-0v2W2J1J2W1.162y2Y1.1.1.0xz8z-z-zQzizGzlzqyyyYyy0.1g1W1W0y1v0Yz.z.z.z.zlz.yMxgwYxMyYxlv8uvv6v6&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 List Price"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLjwnmSm6bpgtY12BljgUX4YfohudhGB39lB0UXw3Oen3asjp0CVVtZZmkLMik3Ez5Kax9ADEGOr63QmtmpcuLEia2yr0yryVyglP1jpVky6YhI2a2cqLuin9pvZj14ICnJiLIArQI81QqvICWw-2BKpfRZtRRF90wsS0V5wKyDPQeNGL-2Bf4T4A5NLwb7wbOJoCCgYGERV-2BgAVScS4Ik5HnnyjiROMofQ8QbbTVo7uD66cUaUT8L9-2BkdJY-2FXKSjp0qEH1bLzikW1ZRh5xOtxioUN2Q-3D"><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..,j1nBqOoTxRyjx6xRnqnBqOutxRvWtbqOnBx6woxRwoplo8o8tbsJ3q3B3B0dplrgnqnqplqOnqq3nqqOx64T8J8J1GqOlwh6jMlHlHjMh6&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 of 20011 Sales"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLnwJxVm-2FiBeBSBMJz0-2BdZB4x0zk32r51RpaF3kwV4b6UE0tiG32cIM1rUpp-2BTbELKs-2Ffnku2cR1e7f5NR4d84v-2Bv0QqemuyAqr5KUrf1-2BDZEOcF0iRhSqZcP9UxsOuiy9xCAhgDkzICSaa58rSPy2BUiMqqTk-2BQD9d3onnoTJafPpiXL3tHYNDMYRRX1PxM3t7Rg2KbG3gRtiv-2FS94LVUx-2F3l2f3tlBGmnZUWTV5AVrknBat3Tjrafkj-2Br7QkMdgriaqW-2B8Crs3jyIHdBkZZ5SE-3D"><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..,wr6g7w8G3T0G0g0Fyc1Aw3wc3ZzM2R222R1s3T3wyu5I1BxOvztBviwQv.y91p031e0G0Gz0zXxIxBwrzj4c4M0c4K2e426O3T1d3T2273&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/18||||||||1:|$0|$100,000|$200,000|$300,000|$400,000|$500,000|$600,000|$700,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 Sales Price"></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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3816-Cathedral-Avenue-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://img2.sbck.us/listings/no_image/1_0_listing.png" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcn0RKzAyG4myz5wqqJ9fOobMYFb57RFBVzQgg9XP4z-2FP_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLoxWEkNk02TsPB0sMiD6fXEfqSCe3GR8jvvRVzi2mGqpD6Y9j6o-2B3nrP2v165VR7St9liLxJPtrScPBZOQRBkRhxMSZVEEB7FL4tWVuMT7MiTzVNgHIj3a5yslO3zbn7-2FaBJg2gWUhevDCWADi6uWLgon63Q9Z-2FH-2FSrS4-2BK58XYkAk3lDuSNp2PLXxLpXdZ7JSkkWBsWwofin8q2nzc8LnI-2Bqxr43YAr12DEqNczgrlBlQl566EuuR2DDxSBoaa3NYjqZ-2FJIgNpjAlVS-2B-2BZVUtE-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><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:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f4711-Albemarle-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://img2.sbck.us/listings/no_image/1_2_listing.png" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEclSIblHwmC9Zd-2FWRwDaQwKp65CErELdOk05lDibmOC54_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLonf4i85ujHveV8xCD0PTOyoI44-2FqzqnUCmFp-2FT-2Fa5gpDAy0VurZhXhbrNX15KdB539EPlBdT-2BA1mzHTgIj3dJsZaUeDLRrGafGZD-2BmXAPsfRA-2Ba0ftY93Y91nKRDuwO0r6fi2pZjQ5343GryY75TukOTZQORmS-2BMk-2BzGF5oYx-2Bj-2BqB2i9AAM8LgTqDMtD8jjoeVtgx0aPuSDgK6c6YqcYMl-2F5ga9mu8tWfXzBS3bwjnb7IRbQViF0dyzUtih3sbcbaUTXo7QFdVe10vp4VnW3M-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://img2.sbck.us/listings/no_image/1_2_listing.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f5153-Tilden-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/15520306-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchAiqV1-2BQDkbb7LkcISZUJOIXXeUsPBGoJLxVGZQtUaC_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLhWImvYDOCmYnCdZ-2BdopeC6JxinYK7VFL9mKnmVGsAEiuHb-2BS9beM3TQBbWDMM-2FRJmJ35HSMfbJm6GhrZs8kGhJ6NAlIrrgKdQBBQbUAyf892tw2-2Fks1-2Fd2Q9nbhvY1hZClfBUEUtG-2BCZHwGro80SFQ3PvHoeccTOy8XGbkOUkPNzB1FL-2BdyGEx62IZPrV5i-2BCjCN9C-2B6Xtp8zAV36R2OOaGdA3SG8oS9Hm-2Ffn8UAXHVxobCcqfZ4IKAqvLaWpxCqpFgavctOcfWEHQaRinyufE-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/15520306-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3033-New-Mexico-Avenue-NW%2fproperty%2f400012101036" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/10859106-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcj3T5d5GQBjpxH3A8yqUVji2Ad3VudbriJcEWMqunHRbciSE61XgpZzVZu2vY-2BLh9qqsosrcQXx0gF-2BbSfq4Zt8-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLohBVOQgfxanKUylcgIA1CKAaH08CU910fK4kUEk9sGsOHq0o5KbgA1H6ej-2FNk-2BGK2wmFP8ZAAMfhe-2B00vDoTK3Byrsbp2WxNMTbK48LRdyyIRfQtiWTmQ1sn2ewUax0ROEw39GNt1TRhi4EaOIC0HKHE0THxPTyZEm1Pys3pb-2FatJhv7UOIjj2lAL8d4g0DDtW-2B5gIJ-2FSAsciKXiWoc-2FkDDkyTltUEnmVXv5wJo5vRtpr2zhAF4L7A8pGImkNc8gAqMnYtgbpMa8K94EZOdr-2Bo-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/10859106-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f4713-Asbury-Place-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/39053595-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcixfRCp8GgwIgaMkDTWY4DZL5zLGO3LCc3dLwz8hqgY1_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLrg-2BQyW0ccTepVEpQOKRC7OVQpucjYenDCSPtbjGCeOstjtPaECPIX8lNE-2BF28l5ipAxlB72iFjVk-2BRUWt3dNY1byqSN-2BT9Gar5L2fQoTLo1bOy82ghMTDbS3aCmD8DVYrDoGQayueb7KGQYtiXeH-2F0OdC8ukMYIN19PiBTh3cUtc4SouUnFseCEdRpgeV-2BmqZv8-2FTAGbBWT8dAFEIfLK7RmqkcAL2hJJvRU2JH-2F5gKILlRrtgtPAV-2FbdBresc2T-2FuPLKhZraP0GpSXvNvfQpAU-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/39053595-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3101-New-Mexico-Avenue-NW%2fproperty%2f400012022424" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/62782895-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcoYaFz8YvitZXggKkP3Jrr5yPGBoaxvLhpsGvz2CSNDEBPsvoHp5GR6KZrYf3t2o8Evzv6I1ML56yOY5WO4y67s-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLlxRYSMnmKdBqlNgUtA7Boa0dNM5Xl6VYQtS4io0ruSzbRe2-2FwgAIU2h9Y2xosGz-2FGrHVW2YbXgCLRL-2BYDHcGIdst1IGKoYafk4Dw1eFzGM0gmPnRtegiDQhMj6o5riKSLvgPB2b2hPLxSoK6HxDGKsh-2B0Ri1FwriLNJpSh5tbRySrqDIosSJygXirtBDUND5GpXzbDTINR3XZpQFYP-2Bb-2BHBGn6fwNu-2Fnepd4lGKy2FKM8XvDR5Vlos9LCkQI2rzQUMRHf91EGKNNZMxh0c2nS0-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/62782895-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3844-Woodley-Road-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/67771895-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEckXHzF6ruRNig57rBxD-2FCuuqctaSwYha0-2FM70xMw-2FoAu_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLvCzK7Axhk4Cik584llZaTUTjVepLvs453yXiSzhfkHEFmMghqZIgqk4bIuvHYAUg3ANL3ch2wUzi2Blx5ipwydh2Neuttnuzw-2BqeMC71fzJ6BL8ez1nxJCtLsZecQzXAzVsnKWxeXZd6QvBViXX1P5cEvuAMc-2FDi2yGKykmNDGsnF-2BD2p5yT3TwMq13MusY-2Fhwn3cWofrGhFh9Fph5Ot5O-2BY9Qu3nUfisgI0eMQOBr1KUB-2FePyBAxKIlAo-2B7ucyoAfSTQPF1z1hsNKN32SyMQ8-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/67771895-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f4346-Alton-Place-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/22886006-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEciz-2BYFpDrxX1wErCqNgGoPh11zlr2yq4q0vM7ohPGURA_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLtfkmbm-2F3h1gcdAj2MgDazFHrzxRJMoJqMC-2F138hkpcqYUhhh8RLhdR6Su01Xn9Sd47TTjCmcw6F0Tj3esxQXJ70j7eXjPvFk5Zg4bu78EE1Zst9awhZJU4-2BwOmPCETA1x-2B9wK7rDPdppOfSzPGjHePdjg4hszhsVgZBd-2F9WscXfl-2Bb6yyN6rFoSVdahO5Y9y-2Bmx2GtSuKiwvO6hjUfAW5paKb3prbGXxBVEiJ1IWytP7k9NsEVJh05-2B-2BtPhV-2FpT2A6-2BGsW9PQ5ucKKKtFJV6lI-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/22886006-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f3527-Quebec-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://img2.sbck.us/listings/no_image/2_1_listing.png" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcmuR91UpaCwS4aoVNqTWNlzpjpOHrkTKyFYi9y9cFD-2F-2F_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLkHpXTrr8EXSxI00ubZdzsTgtrlHsUxgqTkbIleF2twByu7RwJF8ouCCIHZPjQ59vOXhfOZCYR2qyiFONBlddw4U-2FtK8915Tux7IHmyhYhirhZHB6VGfOPScLjmjba-2BhiCbglRQNpaVJg3N4-2FM4aXDJ-2BRMVmOUndeQHVyD6jJmsN-2F2wWR2wzjj7vteqEqQN6JlKRUTyuhpXjFYCcabEfjJHCv3SB2PaOPaxqIGs6QUGbovVfO5pLtq8db-2F48IhwNwx0qX9BhIudG8ygEjNdGWWg-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://img2.sbck.us/listings/no_image/2_1_listing.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;" 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%2f4435-Chesapeake-Street-NW" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:fill type="frame" src="http://s3.amazonaws.com/homesnap.listings/98606195-listing.jpg" size="265px, 199px" aspect="atmost" />
            </v:rect>
            <v:rect fill="false" stroke="false" style="height: 0; width: 0; visibility: hidden; margin: 0; padding: 0; line-height: 0; font-size: 0; position: absolute; top: -10px" userhidden="true" allowoverlap="true" xmlns:v="urn:schemas-microsoft-com:vml"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEck3thVc06zOifDf6WFWpOSBACttn7VmU-2B-2B3znaPQBLlp_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLha8x7eIRot2vopo31x6I53QX31DwmihtQTk39REYgOazMHHGq1-2FwXcp7bIb7-2FQvKMtYE9NURtekcPCpdqYyJvelewgA2cyd2k0NYuBE5J8P44s8BvungJgzFHjsVMhvzf5zLksHh0671ceNHwuCufGpImR2Pi3z4ORgbwTEWnXwh4gqAhJrU2HYyWF18jdu-2BqxDx8pmdPVefEZBK3HAN9y4wmwTeSijJyOM6-2BZb-2FqEOJ3lAT5KRhs6efHms6UN8xsc5Hixvojx15itARZBf7s4-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block"><img src="http://s3.amazonaws.com/homesnap.listings/98606195-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:rect><![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>
      </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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLs-2BysgI1MOBmv-2ByNyl-2BXyLN25T5-2Bp04-2BlgEa28jGhQu1omnRxS3pOcPKPfjjDD6rawNlvyfQGNZaO5eBmHCkO6xiKbACwowQBNeHjJgB-2BMKPABsE84CgQEv6N5jz-2FJU5Z4Zc1kxXoT02IEOzrxi2oAlUATwYWwhR3eRkKiWAcz3ucyrd3xISfNcFJrSUACctlRKFTSSVTTQRwNgtWuDtsQ5SFPDPXNu2PILADdL4hcTXNyxGcXXDFyh0meG7qnAS13T7o69lD0CkEeOXPkcuSa0-3D"><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..,mtpRlHj1n.lwjMpln.sJq3tvnBqjrgtGqjq3qjrgoooTkejgjggTf.nqqOvBuEvBzMwTtvr1ploTkJjggodHbMX.YUYoXCZRZRYoZ6a3db&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 of 20016 Listings"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLlYi-2FE5yj6uXKvh48t03izJ4nc7DL5wavl8J3sCtRyVZ-2BcqgbIe0ZI0pnmiQJJIFoK0jgijq3Vc85wAF3XWwxCjBXq-2BFq1IVIEzI6zl4xjQAsCZO3bImzSIaKfyuYA05ypg32wig44vN6W-2B5fIwhzooCoh7Vz5u5-2B9e4jml35dtyychgevty42T1UOW83MKcHKltt5N-2FtOqy4SNr8DuNOenRR-2B3UClYbxkMrvufO9355gxJdJzPAP9-2BA9sErO35zy8tYYl3iej3SKo5bLVH-2BO3w-3D"><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..,susFx4x2zLzHw4zH295h2932zL1C8o5l1CzJzHzL5h1l2Y2Y2Y0J8yzq.qyi8W8x4H773-zHytyMx2uYsyuAo4mUjqlDl6kylDoPtvswqh&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 List Price"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLu5bjEUQUq4dZzXDiOUd8SbU-2BfIkJDGqtgtDp-2FefA7o0A2Uq35-2FYmo3ZXfRNhzvah-2FONweWPp-2BsZ3PPwzNfl-2BNUoBimKfe4N-2F-2Fo7vlr-2BMwT6IFJoIymthnpYYJmtNuG-2Bp87btk3Kugf9gAfXyqJRG5Ys1x0305arkG1vno2rodADx0owNfNVP4TzsS6aGwXvuweqoB8mBvRRkjPc7QKJ5PrHjaY9J-2FC9QvjddYdLKYU1EFHiWbmSelaGgnqxqdjjteV6j62ebHIpQvT-2FBZq6Sgg-3D"><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..,T6YLYLd3ekccdJaTdJmZuNzM9J6Txx4KwW0nzMwWwWkQp8iIfSk-mZmZkQbuWCaTdJi1jjn0hakQjjk-rXrXuNmZekbuYLUnZmUnUnWwY4&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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,910,1820,2730,3640&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.222222222222222|r,E4EDFC,0,0.444444444444444,0.666666666666667&amp;chxtc=0,5|1,5&amp;chtt=%23 of 20016 Sales"></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-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLvBYuywDPAes3Vpf2LA5VxLPo1mPx6vsnaAEwcD85xC8outHC4iGF7HIOaLlUlOnRR538ICDa0uIDxqjkRuaCG-2FrTkEQ4IAArJKMQNSIlBUJehKMaykwKWm0UCA9MoCdSo1DRZJjn1pdpdXzbHYlKoRWjxagS7DwxBiucNGFO-2Bj1EVV8H-2BbuM-2F26-2FuKyGKfNw0OQfraJc5Q2FzcCIhAIdpmyl9i9IhqZRch7zBMpQshUly4NA6EkrDk66RV4cw71IR4vklDBWzjeOB2f9iVOZmU-3D"><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..,hljMpAs7qKv1gIgIcNcyothvqUt8pvzezm1T3O4C9t6D6D4by6n.repvlzsCoRgvoRoRhckQmze1njn9ymzt3Q6m1g1gvQs5sHqdototkW&amp;chxt=x,y&amp;chxl=0:|3/6/17|3/5/18|5/17|7/17|9/17|11/17|1/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 Sales Price"></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 this email
        <a target="_blank" style="color: #999999; text-decoration: underline;" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N31Dt-2F87aadY3ANDpzrL7kh808Ne17xIVlQJWUZfRbclHe8YWbosVi8zoeStWddO6Bu3XLPeBasdoUiufffUvwgq8DOqcKrNthB7lN7MZqOOSw-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLmrdApRECP0QIlPZSqdRN8BdHBb58oKyi6TJHZ1ZbtazYrmdKwNagmyEpUR1S8G-2Bpp5tDbhoaUU0HSisK1Ao3OhmrFNzAC7pu5nPldSVxeoX-2BQUb8j-2FYFezWbDfFtJfqVVoi8AXhNfOYFSYAOn3ZtZ6Fsx6woYxGIcebJvhT2srk71LoVmVui8Hu6cbYMv1umlQTa8hRDGh-2BmocdlWfU-2BbJotBZJCR530cilBBKXp36sOU9XRrseEvPUbuhASMyajpAdMKnKfzo33xBDK0wNJK8-3D">click here
        </a>
				| Homesnap.com | 5640 Nicholson Lane Suite 300 Rockville, MD 20852
			</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&#xA;                    " />
            </a>
          </td>
        </tr>
      </table>
    </div>
  
<img src="http://email.homesnap.com/wf/open?upn=WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZNHk-2BmraDvqdkcv3Z1qukivWdemiPsY7U6Iu3m0VS-2Fn9-2Fo-2BIDtlEcjOT1UbxeUbnYOhYIAagtQIbtRxG2XXkRLmkDVOJUWSjbRwJxbbd4tk51BLMlld2FOtTMidWthru1mRFKTulqIgKqIYGpH24cqWV8Kt-2Fp7SMs9u9cTCY5G0Xi-2FtrMjPlyfHJYY8NjSEFDEn1r4ba260b6kjUbkr09OLbsLSLD2jmEOprKbuvh2mtRk0bfg1kDivcbaDOIynfIzeONchvD44KdFrk8LgubpiGjH16aFlJxNEZr3qQlXvEVz6O8Uc9CM-2FUVIFNsL-2BrSq59u89WF28cbN-2FIFWOdhNzxLiYkMVIZbdbaQOfi5I3GWI2W5-2BDO5SbefvYMCYhpn" 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 9655 date-last-viewed 0 date-received 1520544263 flags 8590195841 remote-id 5948