<!-- Footer -->


    </td>
    </tr>
    </table>

<hr />


    <table width="100%">
	<tr>
	    <td width="60%">
		<font face="arial, helvetica, sans-serif" size="-1">
		    <a href="/copyright.txt">Copyright &copy; 1999-2005 Erik Andersen</a>
		    <br>
		    Mail all comments, insults, suggestions and bribes to
		    <br>
		    Denys Vlasenko <a href="mailto:vda.linux@googlemail.com">vda.linux@googlemail.com</a><br>
		</font>
	    </td>

	    <td>
		<a href="http://www.vim.org/"><img border=0 width=88 height=31
		src="images/written.in.vi.png"
		alt="This site created with the vi editor"></a>
	    </td>

	    <td>
		<a href="http://osuosl.org/"><img border=0 width=114 height=63
		src="images/osuosl.png"
		alt="This site is kindly hosted by OSL"></a>
	    </td>
<!--
	    <td>
		<a href="http://validator.w3.org/check?uri=referer"><img
		border="0" height="31" width="88"
		src="images/valid-html401.png"
		alt="Valid HTML"></a>
	    </td>
-->
	</TR>
    </table>

  </body>
</html>

