

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head><title>

</title><link rel="stylesheet" href="/" type="text/css" media="all" /></head>
<body>
    <form name="form1" method="post" action="/blogrss.aspx?blog=42571" id="form1">
<div>
<input type="hidden" name="EktronClientManager" id="EktronClientManager" value="372029315" />
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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