Subject: 20007 updated with 4 Homes For Sale. Prices listed at $954K to $2.2M.
From: "Homesnap" <[email-masked]>
To: "Rob Hunt" <[email-masked]>
Date: Thu, 21 Jun 2018 11:48:12 +0000 (UTC)

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:s="http://schemas.datacontract.org/1734/07/Sawbuck.Data">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width" />
    <title>Homesnap Weekend Report</title>
    <style type="text/css">
          #outlook a {padding:0;}
          body {width:100% !important; -webkit-text-size-adjust:100%; -ms-text-size-adjust:100%; margin:0; padding:0;}
          .ExternalClass {width:100%;}
          .ExternalClass, .ExternalClass p, .ExternalClass span, .ExternalClass font, .ExternalClass td, .ExternalClass div {line-height: 100%;}
          table td {border-collapse: collapse;}
        </style>
<!--[if !mso & IE]><style>.propertyPreview { height: auto; width: auto; display: block; height: 177px; max-width: 265px; max-height: 199px;</style><![endif]-->
</head>
  <body bgcolor="#f3f3f3" style="margin: 0; padding: 0;">
    <div style="display:none;font-size:1px;color:#333333;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">
    </div>
    <div style="font-family: &quot;Trebuchet MS&quot;, Arial, Helvetica, Sans-Serif;">
      <table cellpadding="0" cellspacing="10" bgcolor="#FFFFFF" border="0" width="600" align="center">
        <tr>
          <td valign="middle" align="center">
            <div style="font-family: &quot;Trebuchet MS&quot;, Arial, Helvetica, Sans-Serif; font-size: 14px; color: #999999">Check out these real estate photos based on your recent Homesnap activity</div>
            <div style="font-family: &quot;Trebuchet MS&quot;, Arial, Helvetica, Sans-Serif; font-size: 14px; color: #999999">To unsubscribe from Weekly Update emails <a target="_blank" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N32IF5E49zjOlvJHyWSNW-2BbYRMw6ha0iTtd7-2B0c99Qqc50t0ogMUXSV-2FNlFK9Z4aKTi3RZEctiW4nFSVHpPpbCh2306EX416-2Fe7dqr-2B1gwmS9Pci2Kf3ODtW7owClIPrYGixK-2BPDNth4ss9RdVn2wGObJ-2BjiXEiQb50P3470l5wuee7ZDZeyqJsqxOgLZr5UUNa0F8gLKMBmeS6QtkNMxswtOQX-2BOqoS1zqH3V05k562krP2Bb1ISqsabn9v8KP2l0Y-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrCQI33EIKAA1MBk2QLSqd9GSZ2yrYPHthIxfTE5UlMDJtzGnoL5XD6hkPi2k6a6zA0uNVZwDyQa7ikHSxtepA2aFi20GN67KrYo3g1hZQh6zJh2jcmUT03nofLNOlB9qyVK6-2F382zOQQQGdEHV9F1CUW4spWggJfpUab0fSra63TUh5xaI22yT-2Fd3esKOQiP3RjS4UYkJz7eSywicmzzFUidZDVCvPYawc4dUrMLIo0i5cz217fuZRShRmEAj17TFNtXtuSvaTYOAetw8-2FJQiaU-3D" style="color: #999999; text-decoration: underline;">click here</a>
            </div>
          </td>
        </tr>
        <tr>
          <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td valign="top">
            <table width="600" cellpadding="0" cellspacing="0" border="0" height="84" xmlns="">
              <tr valign="top">
                <td align="right" width="295" height="84"><a style="display:block;" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzl0jRu3t8KYOhz3u3jMsqjc-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrEhB1ctNIml8af42XKa2Jpc8FXFE-2FhzL-2Bc3qLNxXLeKNQtRNWfpUnto3rRWc2J2apunQWsffHSS0Wm-2FvckGZsgb2Km6rZXHNsh8vLWB1-2BGwUQEEOiplGot50zZ4fuSi8hS8josq3dEC5MMKt52kmupMd6YyWycbWzhnKxTMTJRGDImFZ8MoNXEl-2Br45M7iMiqwgMb8AtREx-2Fh4i7xEXczxXQCPwaTfsIMdJ5l7PcR51B7WQO-2BNHSMeJgf2nuLZl2jr2akDCXxa4U6dVd2EXkLDA-3D"><img border="0" alt="http://www.homesnap.com" width="295" height="84" src="http://www.homesnap.com/images/email/alerts_header.jpg?v=20140527"></a></td>
                <td width="305" height="84"><img border="0" alt="Weekly Report" width="305" height="84" src="http://www.homesnap.com/images/email/alerts_weekly_update.jpg?v=20140527"></td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td><table width="600" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td width="600">
      <table cellpadding="10" cellspacing="0" border="0" width="580">
        <tr>
          <td width="420" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 24px; color: #3b86c7; margin: 0">
				Real Estate Update for 20007</td>
          <td width="160" style="text-align: right;"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="177" align="center" valign="top" bgcolor="#24803E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      F<br>O<br>R<br><br>S<br>A<br>L<br>E
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/48804456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3731-W-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcqZGQnpTDXKrYzXbMfejObug2AWsbIYUeJnxJp39OL-2Fs_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrNnFvS-2FU44T8b6lG8nBnhGbqsQZWHEaYYKdhawVn6oVze1iJEJ0IStpwzLqVKgO9qFJCCtT29LJ6LAixshMjcY03nwC-2FSiBk9Ow0cX-2FAVGawD-2FuxxnlYHdIEZM4j1OJeE6tEK-2Fv-2FyNNsgaoMIapQVUAMiUfjkkS87bO6m4C-2Bbc13e1abO3ngBiTtbiZoNU1jYAIrUYaH9pyPgqEy1Ltxkyo0RnaXbTMSAYB7dVhjTSBdVp5BgQ1GZw1Kfw1ZsITxqxBNw7-2BHPAbsaSa-2B9fW4YdY-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/48804456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/54640556-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2801-New-Mexico-Avenue-NW%2fproperty%2f400012100316">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpuqqyV39BPqToi6GXU7kOX-2FPNyO5Rw9y-2FrM5eza8tnGsO03fTwQuwYrX6Wv-2BoPo7efR1U4OvZfi5tZeUsKYwAA-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrPcP13CAUnVqJrhSJoicdBISMze-2BM2UTctZavVfFxbe-2FALZ77UD4U4RrcU5dI2ajJsN5JhbxL02KYK8h0QehKdgV2bi6bCNeaYk9IwjnLDf2P788YjSmJUmXy7dUTErodszo9-2FsigT0MVakIq34AnLyC0-2F5s2v8RXKybhg6vnDVCLdR-2F6C15dmZshe4bxwsfyKukPqFjACQ7pENlMfgIkEFA1HUGZle-2FxCZKSeWmbtXEFHQv9cJjWvT-2FeWO-2BI7uR-2BmWr3e348VKTdAd1hqcegGg-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/54640556-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="30" height="10" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="177" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/98285456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2828-Wisconsin-Avenue-NW%2fproperty%2f400012114008">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcsQRQkXQNv9xyLfhivKKeb81y-2FbjpMvzseGnxs5O-2F3jfOkmrFSYBXutP1jCcAOsejXeiabWTBK2emeNsbEDnrD0-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrHVEVZScqTWqVzoEOZRbhHgmWoM-2FLvgIucMMNrNUYG-2BXiqj6vELUJQYlPZt617tewCXD1zAJ-2BnBxp68u5GTIna92l3pY50X7w0mOOwoZKUZz5ydP-2BHR4U78I0JQVlr0SsFvRzToi8qq0erz1s1-2FETp511Z-2Fpe9POrllqjt26JzzG8WJQ8-2Fey-2F9wDvmd7Vn4lgHPThiUzkM3MEam-2FrBOQ615bwsW349hET0YMMnoSPL4B4ScfKLVfbkvxlNPfYQXNKgc1m4Brxpb1zuL8Dsc0Wnw-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/98285456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/56586456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3313-N-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEch94Du26Sb3-2FZvsOVLnEL5mr1yyvFhtCrCSk6-2FRb4KDi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrGJFJXEyS7yBowfQMqDWthC0vXzmgF7jvynh-2FEEX06yfSyijz2lseFBqUgKjjRaFFPNUzholdiPx7cp44kKR2gfz3iBjl-2FTOnukGs-2F-2Bm-2FH3XMpz-2Ft-2F-2F5AAkAHVYwQv1vGFD5duhVywKDj0H6Mir0W58uiPlftxZzyblqKf83Z3ctpwM9NpinhkDo28Q7nFY2WehfkhhY-2BoW-2F26f3ZHMAUuDMgyygbza39krVJJssbTW47rOFpbHKsMhTPULcrrmRzP4iqivAxgT9u1f2yhRWQFY-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/56586456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/71602346-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2238-39th-Place-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcuUzUp0eCDuD5oZ4ur0ik04Yb0pi37v3Z6B3BeKKEGkM_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrLSG5gq47BsW6MLbICtR5dgL78A3R-2Br8LI-2BZh7ZGDCr-2B5hRgcJHYJ3-2FrlpaV7GnnfkoKK-2FNOiDDUjc3U5f7o1T0ErD1Lnb9ev3obpBNF-2BhWfKIQrHK-2FTlFjftLEG6BNfNwMt-2FgFbcmP-2F44btk3Hd2MB0mfVUFcO1amMf-2FM6R71klbsJU55pnqv-2F074ExVfJROMmICmcC0oQ-2B8W1egtje2eDD-2BzUVPhm-2BTM4TT1n5edEsY9ENzoWG1fDNiakfjN9gJZJ-2BevTEXZ6JaNwh8-2BE4mYo-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/71602346-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      C<br>O<br>N<br>T<br>R<br>A<br>C<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/72516046-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1535-44th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcjcUtvlKKxNS0iiW1BdKh2nJpdXHblN1UznqBasBP9z-2F_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrKCVyTZNe4JOe4fiIjEDJ7k2n4tVkoYHsBRm4dt0bHK0sD0TZuzQ8gmaraxCAZP-2FI9BGqXEtBQia3tuveVvEOpPwTP-2BNT6h1eTbFr2yAA-2F5eI7l21gnCC673GKcNPpY2j3l-2FTRSilDlaj9ustvG8LMs6BZen7IZtPRKD7q-2B97Fm8vgmLxy6FQkKJWlT46rPvxuTkV32K8nHhk9DXyI5KFcJbDBfVItXcQvTEUu63M2bPeiem2ErtOcdG-2Bv9R4ZPr1u6o-2FGEO9uFdoty9u8hhR4Q-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/72516046-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/11271256-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3825-Benton-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcqqzjUaIphXmh-2FvRUvafG3eydbwsCSbCt7lZ9Z1PD-2FGS_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrDry76LONft-2BeYuGF2OTmFrPXGzRoMNQR3m5HtDPyRpziVzK-2BwmM3OBKHyRv4ZDxYzrzSW-2FaAehKtGmN3HHzTGd9u2VPlPGLYv9r25ncDnYBreHnl-2BrCXMSDVf29GAJBcdzZ5MX57vPQ4GNh-2BpouZCFqr4G7V3qGIF8UGeQ6261xV4gDuYnYqERxE-2BXmPeJa-2Fwdbj37RLv3qnLwMyLHhR9c1rq5zIT8-2F0Qa2CxZzjn0-2BEoWaowADisRMNsxuQhtCj8UTpB2oWD7Sm0hFOI8N6dY-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/11271256-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/31073356-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4711-Reservoir-Road-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcqcpMjEK6SuIdvowkt1RtFBF6kUfObVsbL1JHZ-2FH5q2H_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrDUlVhpj-2Bl-2FhyoMFXZKAk8uQJYCZfq-2Bb84gUWRdA78-2B3v-2FUNf5-2BVbacoegHp3NvnsDYoUmMg0xyLsxMauUQn8uJ4avzIX6a-2F2qtVQRDEVZvtqoHn5EXtJXu6SDSipr2hB0Ronokx6ke9JdQutvwRDaTDdROJClNo9wJZsu6ZuaGlN1-2FhYKcBNfQbyfhjAQqIibkHfKle55gyuVj41D9qFte9ehbzCb1vQHZH6xq9EDQRx6HULnrT6N9Rwo9LegOrMXXpCWZoz-2BQbq8uVD8ednkw-3D" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/31073356-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/19522816-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2231-Hall-Place-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEch9B2H2HOMaCit-2BVHw6plDqdvKwbfLTYPuwhq4jtoNZv_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrCyQO9PBnxOyry7Zey0FwZf-2BKWn7P9APCoM0fpYKtoG2EnYMec-2BeasOuWPCTRlhrLKk3paOkPNBUkbnp5Qt030X6n4gn2wqHlIkN9cSCbW09rnB21yHNcrcrXb7T9n-2FJhEAILPhdCbmSr-2BallH4m5pEzcT6hPzKFLFHuHymu4mpKC5H8H296DtkcmZNlbTqsTf3dzek-2BBKX5D-2Bij2n3rD-2F9jwBko2PXhX0vP2p47y2w92aMT4PoS8zB8sFQCA85pIU9vFH191naz4yzHGXkgG-2F2-2BEQzF49PVZjcQr6elPrqE" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/19522816-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/60144126-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4614-Foxhall-Crescent-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpU-2Fr3eecNGnSXtgB3dzGTT2Firu3z55YTfjez5uxXCJ_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrO4k1qM65p7ilaHSpaSs5zB7zA4rw4ebGyRZq-2B2dmBZk50lDz3qOcX3BvvJ1x4MrpVKmm2atQAiggdpZmGh9bkXsqZUZHC6fbykVqwVbcc7eyUAKudtdVWOQF8z-2FzukQHFpMKS9IqCjK7Zpah2nqg6ACtVMsHNxKAp-2F9O0OvDyLizL67Xz2iuzqUpxbGP8EHUh0DhD-2F2K-2B-2B-2BtmXsbeywbEjTBEPWdvuJuZ-2BKditKzgcSCbJvqcfwafCNetMfaxpRobGjBj-2B-2BJv-2BfFls48L1dt4K9SOtuygDwZ-2BzHoNiSTnDV" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/60144126-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#EE3223">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      J<br>U<br>S<br>T<br><br>S<br>O<br>L<br>D
                    </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/96234936-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f2500-Q-Street-NW%2fproperty%2f400012115007">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcmJ5hfRiWedUppxfZSAPr6zbNG-2B3WkJ25q79Ik2czMvKH05DJB65yDm16wQp92UQFA-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrHDTIMrJqKJRDgsF6yJX3PLjnIJOa3PGJ0snKX8-2FmBHQhGayxi8PKLB97ngzjnM1IQU-2BeFaNQBQGoFLYfeLwz-2FpL9p8kj4waikbLfO9FkhhGhYvCUZtJ0ouPxVvtv8myqtKDBBUzZ-2BDVl9nzoH-2FT1KcvboDPZ8C6TJDvxQHq83LoDAE2c0PkmaNNMwdV-2Fm8CcWo7hNQGyRvQu2ai-2Bz16qhxTzJKcS89YaknVCrBTn2SpT0GgknNrsiN3903x16zZK1vTtFs5JQqE4Sskmb-2FwEKew9pgB9mQQilZ3SVXd2YZ1" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/96234936-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/58496436-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3812-Calvert-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcj1w4DSZgVtJvWh3h9S78OTLf8MWmr8sx9Qvj75o0gdn_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrO8glGrgmGIJntcGD9ZwqEV2tqHuU0FVVraNwpU5awZjoznHDwFLkCG6xLHOW7puC5VQ4ckgUtiyq1GsgESzI4ZLWUNjTx-2BMvRpHraXxOwl5CkgF2-2FMfcyYOon2l-2Bn-2FS2l63Xms-2FkYH-2F9ZDOopu9P77RSHXzGbP6H93xBE0Voi-2BRuZcYj4ppB01cc843kiMwX6x2cF4Y9LdS0CTKPOD3Xaaz7oNZme5jnUbilVHS78gINsGJxjp0wHfwJHU09Wt8j-2FnOkoSo2gSV-2F0LdJlRFPkxcpeAmkbkqTdG8h1o9e0wV" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/58496436-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="356" align="center" valign="top" bgcolor="#e4edfc" rowspan="3">
            <table width="30" height="356" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" width="30" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td width="30" height="351" align="center" valign="top" style="height: 351px; color: #000000; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 14px;">
                      M<br>A<br>R<br>K<br>E<br>T<br><br>S<br>T<br>A<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrFB7qtmcIk9h6hBej8xnfQxeMBt2VnhlPsxm25b8UcCUu72cVo1Lv-2FZq3sVB25v6DJMxx3xAEAxU6c9BlhU9IWNT1lsbME-2FV-2FmhWjDzCeq7V-2FZX69vVofsjkjPumqoVBguIF372h2N2oqKaN4He5RgfBoLTRFbwl3WXY-2F5pP69tYD5Pl9F9trZALdMty5EZb8Oe2UFFjkpjHbn-2BDe6utLbT35b5OCbPvlSPRfPWHBgwiKym2WvqoSutL-2FEkZNMsgHv9QBNwMWnF-2FubwXjcyjp7WIKCui0CG206jqsAYZze7W"><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..,uEseo8pRqOqjoTj1j1kJfWeEmtq3q3o8oosJsJtGserMploTmti3hReZdbdHeEcybMaOZ6ajZmfCg8i3h6goooo8o8oTnqpRsyp6sJsyuE&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|0|40|80|120|160|200&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020007%20Listings"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrH3ZugwW4dnkx744Xr-2FYfAaF3-2Be53gG535SXlXi1u5Fxl-2FyxKinPyC7OCmUjHQVSLR0HoknoO-2FeZAIRnKqRX8KLRY0FJw-2FjRoPocSoPbOvYC6wc0oKzutJ0O75Gf0hPdVzOllzlRWuqqUq2KaqBLjYtMaLpIrLM7VAorRT6-2BcH2UbyaRPnNWXWkoauhNcgJ9CNRw5lr-2Fmh93T4Y5tjuvV6j944iF2riLjeLpGh2PxuVX04mcDucK42IGtsdxEShNsAFf9gLltmfaN0bn6-2F9tIO6j9F0mYkqiphQFPnCaATtf"><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..,xlye0L1t0GyWw1u-rxrnrwwarxrxsnrnrnrxsMyAwywyx7rxrxx11tvHweygzA3U3D8i.J3Z4U3k5F1Nzx1N1NzW0rvHyavHtdtdsnq6rx&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|$0|$300,000|$600,000|$900,000|$1,200,000|$1,500,000|$1,800,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,646,1293,1939,2586,3232,3879&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.157753357753358|r,E4EDFC,0,0.315750915750916,0.473504273504273|r,E4EDFC,0,0.631501831501831,0.789255189255189&amp;chxtc=0,5|1,5&amp;chtt=Median%20List%20Price"></a></td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrHYKQfZsn1KfILLGuVy03TZ5-2FOI4kYfckhHiy6wU4lWKyohu4YOZEVKuTFyVbq2oMt6iKY6fFJw985bxIACUZgoed96e2IeOVxkG5suri8RPxfqE73Xz6p9T9BLOBdLfFD-2FSb7x-2Bqs09U5Ouh0ubq2jKImMZ-2FexrBfhrfTtuVO4gl7UrwVHWJL2T6D91Vd0UvtGSOpbmLxoXp9wUXJVeTstl8umUf0y7uYDLp-2BFkpNZ4dk5xOejXSN5Mwfbl8q-2FkHuL-2BewvBu82sf2L7aKn1hLVIrOky-2Bio0rkLMqblBvoFj"><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..,h0leunttr4q9jpsyq9r4q9mZnTg6g6f.g6g6h0qDoOnTr4eKjpsyoOxXqDdQXxSSTMYrXxXxVBW2agcVeKfFivjpivnTjpsy5l0G4rttmZ&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|0|10|20|30|40|50|60|70&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,585,1170,1755,2340,2925,3510,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.142857142857143|r,E4EDFC,0,0.285714285714286,0.428571428571429|r,E4EDFC,0,0.571428571428571,0.714285714285714|r,E4EDFC,0,0.857142857142857,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020007%20Sales"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPq3kumehToLBwxJMED0-2FcQU_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrPhzbIe6M3oGqbgLILmSiUxdCDxJnBxNH-2BtpShegTPlR7JwOGRfrN5Cjwj0ZWeMvmriHDXjuo3bifForVkefiLkMBVT5QLqdfYigWUTgLVTzsxV82XAWmrQRKpteiV9NWXkdZx-2B3LIveEkrsBR4Y6X1ILMl-2BdDmW8nCn1j5yzKIqclexZdYLGMFQKWfSWAfKFH3i-2F-2FLg2LYSQz3VTB5oKGjalyLodn7wO2HG6LjUQ6ITVB8JNeKOzxbkYYPbvB96UoG-2BqwlS8KiPoAaCVaSD5H-2FQu3lkIjFRweZM0Tfv8WGw"><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..,yO2K2K3atBsVpXrXpXpXo.lIo.niqDpbuItDtOxorvtOq2qIqRp1qYsbpHrwn3r4tBquyRpiu2u2qDckcksNza89102K0Vvw0VwcxLv.uu&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000|$1,200,000|$1,400,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,585,1170,1755,2340,2925,3510,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.142857142857143|r,E4EDFC,0,0.285714285714286,0.428571428571429|r,E4EDFC,0,0.571428571428571,0.714285714285714|r,E4EDFC,0,0.857142857142857,1&amp;chxtc=0,5|1,5&amp;chtt=Median%20Sales%20Price"></a></td>
        </tr>
      </table>
    </td>
  </tr>
</table><br xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data"><table width="600" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td width="600">
      <table cellpadding="10" cellspacing="0" border="0" width="580">
        <tr>
          <td width="420" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 24px; color: #3b86c7; margin: 0">
				Real Estate Update for 20011</td>
          <td width="160" style="text-align: right;"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="177" align="center" valign="top" bgcolor="#24803E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      F<br>O<br>R<br><br>S<br>A<br>L<br>E
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://img2.sbck.us/listings/no_image/2_0_listing.png" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f421-Missouri-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEckczNLGktALoVTAJLPj3R41-2B0P5bSLlJCSiXn48t-2FFVE_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrFOMjfETLrujaT7JWAli2LRxXlvQ8AO8YlmiN4ZjOpAMsMdTBkVF8MKNRUh-2FBf4xrKfbvYwROigxEeUnRGJZomPUgRwxX1DUUxtEl-2B7QgTFK7wPPsOSzBcGsKsMenYJmGhzrIsBiH3aigkxi9tPR8aHvvGUxbXdS4OHq0FF3pPKgqPdKJ2D3fexocCGGqf888RzsFJwqyt8igbXpZuu4KyqdelTogZF4FW5j6Sv-2FaWCRUOqjRjthnbQa2aRUYZX-2Bh7wVwyxU94-2F-2Bfusc5OXopxFLb4VdP-2FofAXQpecDlTMig" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://img2.sbck.us/listings/no_image/2_0_listing.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://img2.sbck.us/listings/no_image/2_0_listing.png" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f918-Hamilton-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcgZuJf8q4eaXEi-2FC777Kwzea3NfUhYjXgR-2BLWYo3aJGY_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrHNUovns1CXbqDyIrTVWyNNMDKUjctfRLvNcklgG9dzzr4VH1sILTGlLRbVBjrPnEG0Z7zx6FrBm0zpC8vOSzgTtVC4JJm2CwEggUBjMKLdNjjlNi9hTZotyawcwg1rpD4XNgkfz7XnKLsPRMk97P9b0e2LcSbIJf60wnmOZ64N-2FkLaJ08zdEjVbZ4UXPGAZZ3Ka5oavplMSyXC56wnt4rBuqaIfbJwOVrpopwDFV7mMwU-2BMh9Bvg1bVsOgzu2-2Feqkn86L6zg24pTSEPJbviatpIE27CQOhkHcnJrACrWASK" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://img2.sbck.us/listings/no_image/2_0_listing.png" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="30" height="10" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="177" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/98399456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4100-4th-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchTEa5A6kVW-2BSdfXyQT0ayJ1O2gmg7EcKDFVcOQ2cnwp_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrDK6KOtZPoG11l9QmClxhfEAWq-2FEfvcmlsSpM9WBTDuJ-2Bw3g8-2BZamUdLxq2Mls2hIYLR-2BiGFN0tl-2FRyXr8gRadyRiELipc8e26trj644teCDi3Eym75VUYo0qQhEpog882XTXy8SLvq3kXuVRE-2BGnVSHWd-2BwJiEUhk-2FBHsCZEwGq-2BNL95dNKaWLtZMIB471uMEHHqhS9DO-2FZLEtbEE1RSbov3uCMy9j-2F8wWG7e2fWLVdn5Q6SfkGD-2Fvd5zSdE5vRgmnY4IFtn2odq4uAtjXCU85w26eVrdQpa0LlxVG4SAPs" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/98399456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/07807456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f729-Roxboro-Place-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcrCBn9MNfM5RNbtxjlfFgGMv90xkmm5wtH5BOoAkjgwP_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrBTa7jcEV9rTXkUyNhheHdMRRmVnT5KGotIEkFJ-2BN-2Fg6tg9BbZdE3DL2AKiUeQ1tLruY1rKCt0tgZrgTMNzFQyZamrp29Evm-2FgR4f12BOtkW2Ck1ktmFD3HsGSgAHyCbjvvIVw04G23G3D1NZLACMb-2Bu0DTqmIsIijGDIjY4c51c7vyY8xFsm6a1mBXrQBBZNE5DugTN8fmPy1FQSvzo-2F0L4A0joAbdBAnbZunUUePgjC-2FO41myH1vKfb7aLV1ilc8rjGLIoD9cvn4k6jiFe85gK7xV4zYuvt5-2BB-2BXFTQFrS" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/07807456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/25368836-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1224-Missouri-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchru60Gzv5BWvXzoCMRlHbLgcma27W-2BCfyjVuKLC1T1v_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrCcG3iM-2BRV8aWuZSZGy72Tv-2FcyMW5CIFQejKpL6QF5JF5EZ-2BRWejtOJ3jOX9t5Zu8yCr4YoplIqiN8sno8NWE8WJuew4GayCiqmnR0FAC9TSMVv6iNFHg4Gdab-2B41RtkSAPPx7mxi8XBMFLG1TqbJ7HmzjZSQar1pMp3Ln3yfttsmMDIjqqaQqenl0VQSwkIBiAJAXzQpgQKun8SieYgMMHmeapqJnbfVLKmYKdpnyIpbuCzTHOjiVKDbNSRzkc1F2ZSc5-2F0AZEWaDlmTaPlhNBiCzEnU9fGGGX5oO-2BynzJ2" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/25368836-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      C<br>O<br>N<br>T<br>R<br>A<br>C<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/89952256-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1306-Shepherd-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcn3nskttA-2FV-2FNjAChRUyQwIUo6pFFgdCr6tBnpUI4nLi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrN6FrIBKkntJEC6kG0Zwz2I19ZbnD3nY4Jfi7uVyzA9mrz-2BjsIEjOtEd2eTdcRpGzB8iULO0PUL5s6zvRCVvIqxdU8M3NVLQ9XMMxN6TZCjoG-2BWId34T2W3j-2FghzhxD4sJsFPBKiP1qFr6Hx0Wn8Ua1x-2Bedr4XtbQ2cU2WsfTNlaU21-2FG2f10ZId-2BMfJeYvnCvTCrH-2BsiGBRqv2JvPzbc9Mud7Ho1BdwgXkgaDjB7mQD9lf8AohpNWGjiIkZZeKLHlBJ1vCFoT-2Bml4KMxgRHsRhYd91Obxd-2FdsocKdygKRZm" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/89952256-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/79049256-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1322-Missouri-Avenue-NW%2fproperty%2f9202683">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcitDnhlr5twJ9vRjEGW3q8T73Hh7m9GwNoFz4BtOBiK8Nik3jfxiUZfJ32UAwT53Eg-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrAjk7EYYwhUgrHkxiQNHrQeQHlKJC7Ya-2FOvOlDtlfsMZI8P4Ieg47xB2zM99bnmDwDj3M7vLj4XgeMDwxrRQJRDLTjG4vfazqdmVmNq86Su0jg1eduRjAPyAKYdR9cn5c7-2BZU8D2Wh-2BK1MvRM7n6xNIBSj6qeJ3JnMhDW4GMSm0hZ6CA-2BIpIUxuncan9gvoyukypSeZ5z1-2FSXX41-2By9-2Fcry648xvhirenHCCoL7Ed0n04q-2Fgold-2B-2FhNzXjDC3cTtkLUXqClOgek7DxRGZIpQ7J8P3T5J8wEFZLmK3EKl2GiD" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/79049256-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/10951446-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1209-Gallatin-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcs8VMU-2FcyK-2Fi92jZ6ZpPKb87EPxUj8dwhnPfSZyjfy9k_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrPldZ040RwxirtVg3WIg9WsV1xjqaCtNSav9j2pVV5gcXVlYZf0b15c3lVipnMmmoViVh3bk-2BNqm3GgM3KNDarDuRHSQiA-2BjULQWzbjd01YmAHYCuPfHfvlDPJCyKBl-2BJQA6CcaOTefyzRN6cdcGJs-2FlyjDa0JFC2W5U2wtPIh0Q9IyxeeRQWiNxJ6LTM5GI5R2HDAt8GSgpZmHpk4xyMq-2FSY75CJXyS8Ahjq-2BtpsOOv5CKLSrinZtT2WYIKOVdqInBBbFRm-2FYv-2Be75PEcOSP3ZEyE-2F760HAOnTfzJGE-2FGLk" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/10951446-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/35521316-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4869-Colorado-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpm6lIs-2Bh6EBY9NB2maE0EGNu-2F8ACuRQHGrwvUSPoa-2Ff_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrJCjf0913h6Qp1wRFfYuFHsNLaQ-2BjFk5NUrE8Yc2Z4-2Fzrxl1KEK9akcOtYMYxA1QHJuAgCHylxuLKOxQDEVtCJ76mgZ-2BNEHmX-2FL2C1HCVxA-2BgThkB3mp-2Ff5A8QIaIV-2BIunXx-2FmS1UMfLtVzYL4UR0akg0I9dhU6sOJRx7HIp0KNydrQIhBJz2vwb2XulxbKYaSBZTZa22UbVJxhoOCJfL4IzMZCnsFWKr5GuG6-2Bascgcn2-2BlEipQHpLiIFjc1I2uaUup2sSBDUC0CNGPUK-2BbSns3LIhvF7Q6h-2BWEtXqBsOz1" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/35521316-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/21208436-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f1612-Buchanan-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEctpQGSUTW9N8RImBCok2R7n8j8ZfWt3pVzAGI-2BTg0iqh_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrOuv8KAfRpUXItzWM045SXEzbxaqlyKyFritaBCg-2FHF9wf0BTOZmpVAQXRr8ZF3EMQmLV4UFgYxHuqzph6AiIgXplwFLsEE8UEnBQmcfEUZKTVeA5UMPujlQR9USDqpWm7MOOw16RADj6c-2FRpL4GDeDtu50ThZlHoZHQEnHus-2BfmfKs5cwZ27bPXw-2BkF-2FyOLcPoLzHCcCg8JTsV6lAX-2BUs4u-2FYeUgqD2lGb3CnzdNSN4mZnxARRUns1Op3Zie3IMXED0eQtTFFp4FrVEgJum7-2BfOqrv7eqLs6v8HkqPPDTKA" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/21208436-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#EE3223">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      J<br>U<br>S<br>T<br><br>S<br>O<br>L<br>D
                    </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/70731075-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f22-Gallatin-Street-NE%2fproperty%2f4262462">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEci9eI7dl-2Faf3ym3IRCNtoOkIS2yCBlvs8JADEENZ9BwYJsMv6EyceXbBvlXsrnuCTg-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrPHSnzSJmOOK4lgk7Anv8iSWqmQTNFJkfL1BRNdtRXMsQHzwZ-2BhuaJEt2o1aBxYKzqzfkoWLze93ZSoNDAiS35Wq6lfHXungJs1ZFechdcRq8PADrE-2BNj3uiRx3c0B3TDp1o-2FVFRRRsNszNJsyCbfuqh1y7fIpHy5L5NM5heIy2WQvIUq4n3UkEzJLJuuJcuNiDyjpxXwxDCkivRpw3eEAx-2B0-2BFE5C1B3QXe-2BbYHhnlkjI-2B6YL9ISp2QeA6mqL1035aSWcN-2BQD4Z2wF-2BYG8ZVxsAaqqFoPt01CLk9LXI9WRJ" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/70731075-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/51192916-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f422-Longfellow-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcuucLWHe6kWQUBLs-2BjcN6pEKzO3Mqyb1kOBT3l428BEz_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrLpj0EA-2BlhLIsie4uBTA2HJfUEzaONimgwpO1jXnjceNe2iLdZQSGZ25Chd-2F0ZrumkPUM7-2BzfQG0bvHrh-2BJM-2F6XkhRJC0bpVbtWtvIer0Wz-2FEzRnqsuJKfctAuaI7jFXYB2QdchdcNsq2Gji0hY37iEPZrsUjOhEJ8y4rs8e3Od5gsSLr0m6-2BzzMBnNSYgMojSYJnlCUT2Ew3tTKVKDdKyeb8ueiQUpm-2BxgMEHdCeRzMY-2FKmhTuOEFZ9z2whSTL-2F96Q5AVD-2FdsFYIi2E6g37uyEUhgegmZ-2FICFQr1BhLPau5" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/51192916-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="356" align="center" valign="top" bgcolor="#e4edfc" rowspan="3">
            <table width="30" height="356" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" width="30" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td width="30" height="351" align="center" valign="top" style="height: 351px; color: #000000; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 14px;">
                      M<br>A<br>R<br>K<br>E<br>T<br><br>S<br>T<br>A<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrDHI0DDJuNmQPgeyIvPRMWDZ6CORa70Tk6oXVw5MbzXsnPQUauAoj19wyNg940WkbPEAkpsUfG-2FDBZwFbs-2FMdqL0iYNWbHG8wHoY51GX7SbfpSbg9RSOUuQGAUlB8p-2FkO-2BbCDff0g4Ln1StCXDHxQiEp-2B8M9p21XKVWxcORvXPYdDXerh-2BEPWHS6foCO4p3dkO2OSoeZR28bOc3FrMBrasQ4BzIpvLJnvgxnaiEz3Dhn7YO6zXKcCmRKwe2n4SXx-2FNoYlWMKoRb6gP6w5O3DNOiDNC6sIJ-2FLKx2HZxN4bGpe"><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..,q3rgp6plnqnBplmEo8oomtmZvqwTw8v.xl1vz0zgz0w8xluYrgnBlbijjMgTeEg8bMdwaOa3Z6cebMeEi3g8kJmtmEnWo8n.o8lHr1pRsy&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|0|40|80|120|160|200&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020011%20Listings"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrGFEXaGRcQq22IchfGPx0cAapn6xR7wSJaETdyYU4gk-2FfcZI-2FKlkt-2BvMOz26kFP91rTjgdU3NNf-2BJ1WOV-2BlvivGKx-2FgFP6x-2BiSLGSXXC-2BMaVnpDNXCTu1IMki4-2Fxuy73LaBS3iTYsLwz-2FCwwnUoBQG-2FkyNnaP-2BzjYhLWeaNDFJ8lDpA-2BW0GmtCQ9nHoGDck4QqrmAYvQm7GuZ9dG-2B7zIdUvQ8itOTG7kYKbSj8xXPeyCLjEmboecKh7IttgnFBPxMuIl6-2BHwGrC8W8gfISZmrElz8N-2F0PWOlKE6dRaAz0gJp"><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..,1.1.1.0xz8z-z-zQzizGzlzqyyyYyy0.1g1W1W0y1v0Yz.z.z.z.zlz.yMxgwYxMyYxlv8uvv6v6v6x-x-z.1kz.0x0x1y3L384Y3.3.38&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,1023,2047,3071,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.24981684981685|r,E4EDFC,0,0.4998778998779,0.74993894993895&amp;chxtc=0,5|1,5&amp;chtt=Median%20List%20Price"></a></td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrOU0qSLCzn-2FigObcu5o8CDuhYzF6FWDAMIm3SFeOQnWHOCMs-2FNcivma-2F4UObZelNDAk-2Fh5WVOX3y5Twhmr4jy9uFZp2aJn7U59jaUWN9NJmfAL2iJF6IQTg-2Br2vmOf23AMJNHv8P5SQkF9cQPpx4iVCU6XNdLhjAq17CtkboiMP-2FAo9mOqsDZHjLlUcvid7YmpMf8FmLIeR1fyoqlrPInSfcMqdlP85kOzshVD-2BhQVirTChwhO8CI42aouCxBD3xfC1AnJ8MEP7obG85wdVL8u1fG8fOmV8a1xBiXsW0I32k"><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..,qOnByjxRx6xRplo8o8tbsJ3q3B3B0dplrgnqnqplqOnqq3nqqOx64T8J8J1GqOlwh6jMlHlwj1jMhRlwkeoTsyplwotbutx6z0z02Y5l1v&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|0|20|40|60|80|100&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020011%20Sales"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPpeG35pEWd-2B-2BmSnMO1He5Wi_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrEkzjON-2FvKKXkAqyyUc45exvZxnZh82uki-2F24jqPHmGE8p-2BPJpejvnzdUjmVXmtBpdVBXfKtHblEgcSvOIEk4PAHh8WgIj-2F11OtzMVMQNj0YtPpqGCb7gT9W3iyWMny4HbZMPZ2kecD2dKGnxAfuG70PFMskhwvigw-2FAiSSEGJkC3HZ7mtjbK6VnqYoD9llf4kvjG7imeWYJamCSDu2J1sAzULbOU5hQsd7PdL8CMeZRH-2FvCel2iVlrCivuW3yLgKUEzn0yoAf0-2Bo53z3jv8Mg42uk-2F150u17c85zYbnXEZi"><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..,222R163w3wyu5I1BxOvztBviwQv.y91p031e0G0Gz0zXxIxBwrzj4c4M0c4K2e426O3T1d3T1d7a3E221Gzgy41AxVyu1A0y5I5O7a8S8J&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/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%20Sales%20Price"></a></td>
        </tr>
      </table>
    </td>
  </tr>
</table><br xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data"><table width="600" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td width="600">
      <table cellpadding="10" cellspacing="0" border="0" width="580">
        <tr>
          <td width="420" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 24px; color: #3b86c7; margin: 0">
				Real Estate Update for 20016</td>
          <td width="160" style="text-align: right;"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="177" align="center" valign="top" bgcolor="#24803E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      F<br>O<br>R<br><br>S<br>A<br>L<br>E
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/87463556-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f4405-Sedgwick-Street-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcr1QkODLc2ZQpU7r4n-2F8ROEyYVt02J1if1X2DJNmwmz0_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrNG6SMTRYLeQ6KsWlzboPfrc-2BzB-2FWzQ4DZUlaM-2B8QH4wc-2Br6fFt-2BUBL3i-2BcnIcrkauY8yNZxZ2M6pVPYGFOjh4YviTV0rxv-2Bz3SQ3DGKreddlQ2tBSYHK2lwZmg3MP-2BIkCO4sZPguENT5-2BEHVNnSOas-2BZnhwaNrY1O36f1K1BsrPviV9LDF1y-2BR0eliQ13yFctTxedW96WUGsZons4TdBkQ4tYyNQL-2FExEv9mogXhFp1GCpewvJsuZrEALLhZqS6tHKY5QLt7WADLVsfc6TgZh-2BZ6ns6tSqCQ9kJNJmAOAHT" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/87463556-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/26511556-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3028-Wisconsin-Avenue-NW%2fproperty%2f333815">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcusqb0wsvQcZnwwRNZfZJtUiEXcFZxKwQs7DGJC5MjCY0DhJVvyWmnEmT93DwJeydQ-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrNydftJyZK3-2F0gH74NWbP6jkcnAGZHnRlalLmXjcikbP4Wz-2BeN-2Bg5qVerPf-2BKpkYLRwlFKQOqOLANBVJLd7x1S2yOISqYeuG6CST69LmI1N6M8Y37N04w30c59ikTfpZo-2FIdXGoQ0GxCgkVrxS9k1swkZCwEoTSoOuEgHJ-2FyMwmc8r5YI-2Bf0Scr6vvzMnA5g2oGfYsatJPehDHSmAQ1xY3KsaQ7Jczn-2B3v2GdIY0Jeyy0oagfECOYJqc3CsRPfPiiHchfn8EobZ25J9teAAq0uH-2BRQi8frVFlAQpJwrNycmH" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/26511556-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="30" height="10" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="177" bgcolor="#24803E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/70259456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3410-38th-Street-NW%2fproperty%2f400012025111">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcpmC6iEMFX4wAUuhjduDgCTUlpp436yWmgJaneWAPtRU3Tkfb5ooUwf93nFfPeyN4g-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrHSf0Xf1rgfD2E3pBwedHUC2upXdXtBf7MRiEvgJck1OMNPbGCnwTqAQROrQCyZ2XI96D6GRqXSBpxoL-2FqgWceW1NukG1kSHtxRaKoDV9UFQxhBlvnzNIMn05T6-2B6AaBSMousx5AVD7CVm-2BkoPdnz6iYeqZxNJTABlg7plMAnPcEoz4BXUCOSQQpdZl-2FPT2IOicSyqIaIVgbuIJRrNYJ6AGu5Mq1wFQWVehuftJRUpRtmN-2FgY0pOBHo5NfdkBiAYbDEErcEv4qzsHcdxGOXNIbbuPARFUodRLhB7v0RBuDhx" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/70259456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/71291456-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3235-Sutton-Place-NW%2fproperty%2f9222627">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcrqouMblNhkDUjaexH8YJeY20-2BxNmr8i7Wf-2Bu-2BF6g91-2FH2AkOjBHeS3GDjaabB4BPA-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrAat12vnXN-2BUBG0COCOfD9JGhOIRQyOWmHhytxQPnS5GbuckBbv6Rj-2B0wD-2BiCcYyfMyRHN-2F43Z8mHtztZKvYNyE-2BYJD7LRVcrr9KY2zUxuzKv58irC7yU2ST4HBxoIniocNg5-2BL-2BfcFmJ9wdFsgQ0h-2B-2BSCL-2B5N0MtHYiHOWZoRgPp-2FLXqk8KfPN0mmK07rNvNUs4uyfCqRBDI-2FBd9Jj45QsdmUORjbgeihWY-2F5eivrVm-2FS7Zm4kaHyK1ASgsNPyBLxd5dsxxqwOujP32YLZ-2B4NKvuIqfUtT27NRpIs4usLia" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/71291456-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/63177056-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f5023-Eskridge-Terrace-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcgbS4Ed1-2BNf5PPZOpscSfZ4hmxOyoiHW7ullYHAwjjZ2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrIPQF3BdtlOrvQ4ZHwWYTszYXUzMvD6ajPoLDb8v-2FdAQ9M8yzFMxNqmx9rY9ZdmOiC15IsUL6ZTv44B3EXjODH-2BdiZE8WMu2O9ivF1VX4LCzOLDy8OwS9jmNPK6DODj3dyMPW1HKT5uoQA8PbgR7DiQ5MfiMir3aTxBwSd61YF2ecVeFBVX6hwKK5fEQ7KE6JaYbDaMHoB1SiaL1hUTMwLdLHuIlZQHgePU0AOMUcy1KKtSXkIEDn6tqypKr0PD8ytPsa-2FNvnDVdG3aWZb-2BDtyJ62-2BT9LgsHZRF9pA24bgHU" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/63177056-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      C<br>O<br>N<br>T<br>R<br>A<br>C<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/57222356-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3660-38th-Street-NW%2fproperty%2f400012025608">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEchS8tcID4G38twW5WNxZxsPjGNmA84vDghuBWaTS4fug4XKZbuDlb7EewCh4eRHwPg-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrFWnGqURUdkj9wcKtLTbAWEQLMFvq6AcJn3Y3OUgjmUqA8uhq8-2BJZHlfTgxCeLgaM4kVEN3bVNbZwYPasGneR9A9SK8-2FLiGgW3DggT6N7xGu-2BnZo2BX2h7Oos2exPiskyylLd4HGm7b8kHaA0rqDDQTi0-2FTywj0IYNRPoukwqx1FQ-2B9o5DsHeQ1yVxAcxAnwfgHLKZNnStSnGdH-2BX7jutfeXFpHd-2BYtZm5abO04tOFPCLbSyQAihpDlhw-2Bvq1UI35MW1zvR5tHZ5SAwx4C3vPoX61C4GV7Q5Jrww1tMAx74l" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/57222356-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
        <tr>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="275" height="10" colspan="2" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/31373846-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3900-Cathedral-Avenue-NW%2fproperty%2f9150794">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEct87hQuNaGobUyQtoRhDHgzqH2Uq0ZKvPkO4xHAkBLfMRir0-2FxJZ9UwYHI3KTd60hA-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrI4JD0gPYdc4q-2FvLRAKzxGDvmR3iJHm-2FnCqdYh0kf6dU9ZhrzDlEDo9Q4ryrP-2FpHXdvfTH8Qfy3Jz8tdxlBaIvqKaI4bdCTHGBIGpQ5XqF08xI-2FSV2lyPS3Y0zAl-2Fhdy7vWJEXtM0-2Fgjt4htUHc-2BIxC0adWzje2b-2F2BJwRk9k2tZrkg-2FCxfCrKKbk6R0JhCrD-2B7VTAwZUg9sAKWRJQ96oDC3Uhfkx8hHoWtytaxqAGEotQQYG7wGqnXYufdu2-2Bru-2FUUlgKpiAwRCF5WQGu886-2FIm7OgKJWj2agtz3qkTvweq" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/31373846-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#F68D1E" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/49216446-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3721-39th-Street-NW%2fproperty%2f400012025570">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcn6UnNgrX4CNL8TuoWu5GYms4gc-2F7oONU1Uk3AbcTPj7Pra3Pb8pMU1mnfEsUdzq5g-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrIUJDExjdnavBcs-2F9m2zaPJaN1sgIH85XP9IBjs-2BCOCjlWl-2F9Hvy9J-2FZ3COkWTz3WVpyxAbEnq-2BNxKlR1lHdwr0ysNH4254tsxPBP2AT0rFR-2B7EnhH6PRBGtRgjaIP92p-2F1dT5FdhsM0KwiHfSnNV6EP0LIoIbIgZn6lJzCGEnAu57P-2Feup9VIgvU6VWMh86IvtxyNGdnzn-2BD-2BLm3YagKvH0SAtNgKzBECdSQNG8i0udSF1OdFsENpaFoBUZpudvxoRicx1yGw2PycMWqzNF5-2Fw84aV273rrRUTCFa56yb-2FB" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/49216446-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0">
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/88708536-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3832-Porter-Street-NW%2fproperty%2f400012025229">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcscpxk9q-2BrU3V9XUOXLdpqhhWIHhWYwC-2FxKw5Ogu9C4UcXC86vEuGgl0feEJSaRiuRjVSy9EW1HV2vjX4gElByQ-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrBtMYkLD2VGZ0VThe7t145oZkTsL7IuyULF8PN1vW6aWiU0-2BHWb1BmLI-2Fb9EH-2FTTqqNFIitzdaR2eCuYLkdL4-2FvYpRIIjjdbSGQyjwigHr-2F-2BQ9b-2B6REKGZ0UaYHasCHnWs49IcoKuJV3G6BpTVgOe0pFSJ6irYiGw9GMtlJBOXtxEfWFkeU8Uo-2Bj1TDl4XOFPZHWEYsFP5EmEKN1Of6tzBetiDKP5YmesUx8jrbjvU8t9-2Fu25a-2Fw-2F68KDqtahBAaAPjQiEiq0VPqhmKaCuSzUpbugS7cH4itA79r4vU3Guar" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/88708536-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/27045306-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3816-Cathedral-Avenue-NW">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcn0RKzAyG4myz5wqqJ9fOobMYFb57RFBVzQgg9XP4z-2FP_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrD4Z3RIbejdizcjDJYSyFGfstIz2G-2BCVMKCWtykEOLzHWS-2FvIpd-2FmyAKNn1xQl-2F5sIP03UZX5sEt2h7biCXXC13vYhNj717C0U-2FLjsT1bkY3ej07VglGDx25YVGW-2BVPC-2BE2MR-2FWSygPfxbQbKEiM5wq4-2BmbvjTgN2kwxHSxZso-2FHf2BtGqd3XD3VikSrh3wG3-2BGhDHoTCsZ1gSg0CncLMcne4VAI4mJ48yIxZP1VkRedh-2FFtz-2BOLIB3TRrTj-2FNGZfPB-2FznqieiNKCYaC-2Fipqt0t1q7DXbgteUuNUebCKK2AM" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/27045306-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="177" align="center" valign="top" bgcolor="#EE3223">
            <table width="30" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td align="center" valign="middle" style="color: #ffffff; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 15px;">
                      J<br>U<br>S<br>T<br><br>S<br>O<br>L<br>D
                    </td>
              </tr>
            </table>
          </td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="30" height="10" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
        <tr>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/06093226-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3400-39th-Street-NW%2fproperty%2f393612">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEcnxyabWE6-2F5zSu2ewPvo0s5iCwVtkPjHwyGCp1PAraqVdoRaxI-2FsZVcqlB1V24FzbQ-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrDJDdq6paBafU6xtXkQlUHBLgxQhrTs8GFYFpaG5YKk0yg5ueClywJyG6VOWdxDsJQqgayA1RD8Kc8zAXd4z2ZefuXmnzVvFlShaMbwpghCPwsMRdq-2BY-2B4CpRv5M1YQ5pho4EUTrdyd8PP6f1jBTyc7J5NbP1a8bm-2FHGeOUEya41zSfvjLMhsqBheEHvWoWT3QUtnojENWjdLktL1s4qdD0pHkpeQzLtlxS6OEXv-2F5JWekZkNmlHOp-2BeCwSWraEVf6GW8ec0HiD7gg5TmOMrSASdlRvXZ2IK2sd8AhG9aKCT" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/06093226-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="177" align="center" valign="middle" bgcolor="#e0e0e0" style="background-color: #e0e0e0;">
<!--[if (gte mso 9)]><v:image fill="true" stroke="false" style=" border: 0;display: inline-block; width: 265px; height: 199px; border: none;" src="http://s3.amazonaws.com/homesnap.listings/50623006-listing.jpg" xmlns:v="urn:schemas-microsoft-com:vml">
              <v:rect fill="true" stroke="false" style="width: 265px; height: 199px; border: none;display: inline-block;position: absolute;" href="https://www.homesnap.com/action?a=1&amp;ty=2&amp;id=312937421&amp;hash=08f6e5c9b13ba32ec2f215abe17307265b3fe0c3&amp;url=https%3a%2f%2fwww.homesnap.com%2fDC%2fWashington%2f3401-38th-Street-NW%2fproperty%2f7009193">
                <v:fill opacity="0%">
                  <v:textbox inset="0,0,0,0"><![endif]-->
<a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39ISGo462bRjledexJUvNYEclJ2iCwBZv1IibQ4OKBfJ21CdwxAi7OHJ6A-2FCF974RgGeE0545WYc8EIm2Z0jeMGXw-3D-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrHReNqkXK8-2BTDlTWORhRirMVWt-2FF7F3tHjjyyXa5-2BG70ZtiG5Gdz4ECKGjJJSvLolcdpWJctU9fNklj10ufFIdgRH12EIsYG05v-2FWp1gLU4-2BYPX7BBJHl37shK1wCCWieQwIau5xK4FtuNlnIMzCoqgavki-2FLFU1UmYNCO-2FsGjr4YChvduFIOkcEHZKndPd2avLCMlfCdaC12-2FuTocv8z06gRYr0kqTSXjt8GYmPa-2F4S1KC5FD698kW-2BYYF91GCjg3JHyFpn46F2Eew9sUa6bYAx1E1i3HqhXxeqtuBuOO72" target="_blank" style="text-decoration: none; border: none; max-width: 265px; max-height: 199px; display: block;mso-hide:all;"><img src="http://s3.amazonaws.com/homesnap.listings/50623006-listing.jpg" alt="" border="0" style="max-width: 265px; max-height: 199px;" class="propertyPreview"></a>
<!--[if (gte mso 9)]></v:textbox>
                </v:fill>
              </v:rect>
            </v:image><![endif]-->
</td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="10" height="177" bgcolor="#EE3223" style="font-size: 1px; line-height: 1px;"> </td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table width="600" border="0" cellpadding="0" cellspacing="0" xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data">
  <tr>
    <td align="center" valign="middle" height="10" style="height: 10px; font-size: 1px; line-height: 1px;"> </td>
  </tr>
  <tr>
    <td align="center" valign="middle">
      <table width="580" border="0" cellpadding="0" cellspacing="0" style="font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 16px;">
        <tr>
          <td width="30" height="356" align="center" valign="top" bgcolor="#e4edfc" rowspan="3">
            <table width="30" height="356" border="0" cellpadding="0" cellspacing="0">
              <tr>
                <td align="center" valign="middle" width="30" height="5" style="height: 5px; font-size: 1px; line-height: 1px;"> </td>
              </tr>
              <tr>
                <td width="30" height="351" align="center" valign="top" style="height: 351px; color: #000000; font-family: 'Trebuchet MS', Arial, Helvetica, Sans-Serif; font-size: 14px;">
                      M<br>A<br>R<br>K<br>E<br>T<br><br>S<br>T<br>A<br>T<br>S
                    </td>
              </tr>
            </table>
          </td>
          <td width="10" height="177" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrMLwXUflhCecKsImd-2FUX8KM4M4OK3jrvNGYICEa3m364-2FsWSnwThK-2F0eCRRLh61FlPZCKMq1kgDLJTklCD2DOr17l1sWzdiikHPXNN20AjaoRSE1SE7zThKKGT7wT5ppef5KP7GW2sJJtVrPEj9EoNE3KegP0E73q2hxMSzWEWnsEHBwl9Z6J-2Fepk7jwPABd-2BAyUsIw4HM6TB1VWN0Sfyfu654bCutxinCfO9rZTi8BqzFnBg94LgPqQ8fpFZ-2FqCe0m7DwNY9f1zNBaApcJjTifN5O0I93cY9k-2FNaH-2BqQTri"><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..,tGqjq3qjrgoooTkejgjggTf.nqqOvBuEvBzMwTtvr1ploTkJjggodHbMX.YUYoXCZRZRYoZ6a3dbgTh6keg8jgkejglHn.o8nqoor1pRp6&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|0|40|80|120|160|200&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020016%20Listings"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrH7Pq42YuWEHj7gHoKx24M-2F95ov5DKrUq3DLFsDl1qO-2B5ifuzoh-2FICZyO62Q7xgde4DilLThP-2BjlromwXYAv9dhdYlwNta5sX20ynETxsEWgPcSBOdo-2FShqtoiIfT9m-2BSYacEbT3e-2BVg9qeF431iR7SGv7LHIxiAmPAuO4EjxnzCNAd7Er6hUxIJmqwzDwp0XypouN-2BCeH6SyiW4V-2F09HVHAuxoFN6asL83QRyv4GMy5BueGtxZvwk3dUXPWeeUgILoDn-2FbFoQuJpgj6oQrBJeYED0fAjovZs4nwbgxvV4CM"><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..,5l1CzJzHzL5h1l2Y2Y2Y0J8yzq.qyi8W8x4H773-zHytyMx2uYsyuAo4mUjqlDl6kylDoPtvswqhujstngmYrMvjuKtP8u3B4T2E5R5R5R&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,819,1638,2457,3276,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.2|r,E4EDFC,0,0.4,0.6|r,E4EDFC,0,0.8,1&amp;chxtc=0,5|1,5&amp;chtt=Median%20List%20Price"></a></td>
        </tr>
        <tr>
          <td width="550" height="10" colspan="4"></td>
        </tr>
        <tr>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrMM47f0-2BbdFtc1BtJ-2BP79NpPUYA9jhtyeVcKCG4MF4J70G78P8QcMgGBRiRFkCr8MQuD2rAuOtKmvoI-2B3NGNqNsH7SyhU-2FAHO21OH2xVvGhEsJ-2FCL52QYoB5COv-2FL8ev-2FMJtlFwh-2BKNe2dHTR9uV7TLopsbjn5wJ80rLynJJWVLUjoFnX60ZmcK84zT7Oc9ynRXzvrYGyAdOSat08YRVczLIrxicwoU1ThVe5NVvyP0h8YuWUaQEAc9Rcx28NxiHQSQ5rLF-2BJlZpdgiI8zm4nHuVxjKpSAgH8TR-2FFvl-2FYzCm"><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..,.L2Y7L5l2Y2YoyvMmZjMplrMrMoyfMYydlgynMn.sylloyn.plwywyz.rMiZfMbMX.dlX.X.aZb.gyj.kygyeZbMaZeZmZuYxlz.zMuYr.&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|0|20|40|60|80&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,1023,2047,3071,4095&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.24981684981685|r,E4EDFC,0,0.4998778998779,0.74993894993895&amp;chxtc=0,5|1,5&amp;chtt=%23%20of%2020016%20Sales"></a></td>
          <td width="10" height="200" style="font-size: 1px; line-height: 1px;"> </td>
          <td width="265" height="200" align="center" valign="middle" style="border-top-color: #e4edfc; border-top-width: 1px; border-top-style: solid; border-bottom-color: #e4edfc; border-bottom-width: 1px; border-bottom-style: solid; border-left-color: #e4edfc; border-left-width: 1px; border-left-style: solid; border-right-color: #e4edfc; border-right-width: 1px; border-right-style: solid;"><a href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N33h9Om4wkmH8VjFI6Xa-2FQ29yPuDoegWA-2B6h8t9ptKni94TP5r3Szo5a1d5O6NAiCNqnmdg5D4NL0aVVIlAVnaFpobhsqavJ7Us-2F7hnzo58oLoYjitsC-2BUePokMowwPIDvW5ZF-2BMdee-2BiFOzBa0gf39IUTmCynYMwq75PGOoqFrZB9qXlzKHw5BbWpotsdQtTPqMVIGBwvo-2BUBHPKYR1PA-2B2_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrFQepRJuc1fMUE44ZEgFUKhO7gyE0zfPZOp-2FA82hQC2erKahhMrLkICC2r-2FDafaGE2ZJorkNzo0BlknrJ94y-2Bt-2B8cBScYS8uKtcFH5jUuu1pxKmFLA78ApJMh9tkRLUPlCslx67fyS7-2B2gZ0j-2B2rdg4nyQyAgcwvc-2FE6VYF2Jaq5OYsrCxwB-2Fb-2FFZsKCdB-2F8I7-2BerfO-2BBlQyPrysTzElQgOPLu-2FWSGFEfGD9A99Cun2QuGaFG3Kq68MjhFU-2FR2JqYbvI0HMVvhpejSMVaNfB7l9PSf3Ko-2Bjayo6NCy-2BmySWy"><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..,zezm1T3O4C9t6D6D4by6n.repvlzsCoRgvoRoRhckQmze1njn9ymzt3Q6m1g1gvQrrrVppokotkWl8pljshcskoZ1z3jrorotFp4qZuAu8&amp;chxt=x,y&amp;chxl=0:|6/19/17|6/18/18|8/17|10/17|12/17|2/18|4/18||||||||1:|$0|$200,000|$400,000|$600,000|$800,000|$1,000,000&amp;chxp=0,0,52,8.833333,17.66667,26.5,35.33333,44.16667,0,8.833333,17.66667,26.5,35.33333,44.16667,52|1,0,744,1489,2233,2978,3722&amp;chxr=0,0,52|1,0,4095&amp;chxs=2,0000DD,13,-1,t,FF0000&amp;chm=r,E4EDFC,0,0,0.181684981684982|r,E4EDFC,0,0.363614163614164,0.545299145299145|r,E4EDFC,0,0.727228327228327,0.908913308913309&amp;chxtc=0,5|1,5&amp;chtt=Median%20Sales%20Price"></a></td>
        </tr>
      </table>
    </td>
  </tr>
</table><br xmlns:s="http://schemas.datacontract.org/1774/07/Sawbuck.Data"></td>
        </tr>
        <tr>
          <td valign="top"><span style="padding: 40px 10px 20px 10px; display: block" xmlns=""><div style="font-size: 12px; color: #999999">
        Please do not respond to this email. This email was sent to <span style="color: #24799B !important;">rhbdc@icloud.com</span>.
		To unsubscribe from Weekly Update emails <a target="_blank" style="color: #999999; text-decoration: underline;" href="http://email.homesnap.com/wf/click?upn=Xr3wy-2FwtmMOh4N1KpQGGzlmkO4-2BGRPne8-2FmwAlY0N32IF5E49zjOlvJHyWSNW-2BbYRMw6ha0iTtd7-2B0c99Qqc50t0ogMUXSV-2FNlFK9Z4aKTi3RZEctiW4nFSVHpPpbCh2306EX416-2Fe7dqr-2B1gwmS9Pci2Kf3ODtW7owClIPrYGixK-2BPDNth4ss9RdVn2wGObJ-2BjiXEiQb50P3470l5wuee7ZDZeyqJsqxOgLZr5UUNa0F8gLKMBmeS6QtkNMxswtOQX-2BOqoS1zqH3V05k562krP2Bb1ISqsabn9v8KP2l0Y-3D_WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrEmNHgJO3uc-2F5-2FVrCHY3sDRAKqtXuLmr-2BWEUHMBMPEctsdrDDpu7KZaevMnuEGEXXiPFIASinKCLTS7-2Bo4g96tTUJzkTUM90iUf1bbef-2F-2FH3rYLcKpo7-2FKWmiKkSoRntz-2FNLXiTv2-2BRK6IbrpziuBfazQonOKobSkJsu0aBDM-2BdfWFmsAmg-2BFpMLXfxNtqY1JIUh1CuFcLTfcl6JFK4rE4efG0p-2FdapMyA20J7uQKgkUM2SMRT-2FZxxMLeFw2ibaR73pShT7cGrNhuR9UNBzBUthEZznH7F3d1M-2BOUrsSzLRg">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" />
            </a>
          </td>
        </tr>
      </table>
    </div>
  
<img src="http://email.homesnap.com/wf/open?upn=WSe0z-2F5OLgOaZUJhZVR6d3a2lDFT3UOv-2B9ZkB-2BR-2BGitREdCwTWl-2BBJIyVWC6znPZywpsHMCcqPnqkepXrmYHoFctyfp-2BCmyL-2Fv11-2Fu4ncS4sRyI6EqWE9-2BlSAP83ftW2pKnIkwhHKFxD7Nha2a7zrFSr-2FFaXg8L5JAdqxJtSZWcgYWtxg45lYbX1S9oLHOnB3vnCEzldBcde2U7WgPzt7kwCaHsTC03p2R3e-2FGNapJ8dIdkQdlm5iO88TzO4Vt1xa07oqcMfxR6qTrmOz7o7PbanmdcA1dPl-2F0KWG7IMspfnlGjCV-2BXeR0zma1h-2B8O3oftDI2sMNRDFhvAyxa9euoazg5-2BO5bzttfJL-2FaPlHjF4MaRH-2BRlI8-2BYaskq-2FAt1k6jWa5r9oRjn-2Bz4KJCtsv77DPIG4ZFGUeQcQqtf41-2BfRjnmLqL2QHxMfnR72KEoyZf" 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 8029 date-last-viewed 0 date-received 1529581699 flags 8590195841 remote-id 7716