diff --git a/www/api/cache-view.html b/www/api/cache-view.html
index c56610c..692c47d 100644
--- a/www/api/cache-view.html
+++ b/www/api/cache-view.html
@@ -49,12 +49,19 @@
 
 <body id="www-imagemagick-org">
 <div class="titlebar">
-<a href="../../index.html">
-  <img src="../../images/script.png" alt="[ImageMagick]"
-  style="width: 350px; height: 60px; margin: 28px auto; float: left;" /></a>
-<a href="http://www.networkredux.com">
-  <img src="../../images/networkredux.png" alt="[sponsor]"
-  style="margin-top: 42px; border: 0px; float: left;" /></a>
+<div style="margin: 17px auto; float: left;">
+  <script type="text/javascript">
+  <!--
+    google_ad_client = "pub-3129977114552745";
+    google_ad_slot = "5439289906";
+    google_ad_width = 728;
+    google_ad_height = 90;
+  //-->
+  </script>
+  <script type="text/javascript"
+    src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
+  </script>
+</div>
 <a href="http://www.imagemagick.org/discourse-server/">
   <img src="../../images/logo.jpg"
   alt="ImageMagick Logo"
@@ -148,6 +155,9 @@
 <div  class="menu">
   <a title="Sponsors" href="../../www/sponsors.html">Sponsors:</a>
 
+<a href="http://www.networkredux.com">
+  <img src="../../images/networkredux.png" alt="[sponsor]"
+  style="margin-top: 4px; margin-left: 4px; border: 0px; float: left;" /></a>
 <div class="sponsbox">
 <div  class="sponsor">
   <a title="Sponsor: Druckerei" href="http://www.allesdruck.de">Druckerei</a><!-- 201303011500 r.leo -->
@@ -174,24 +184,14 @@
   <a title="Sponsor: Druckerei" href="http://print24.com/de/">Druckerei</a><!-- 201110010720 -->
 </div>
 <div  class="sponsor">
-   <a title="Sponsor: Fernsehdienst Berlin" href="http://www.atlas-multimedia.de">Fernsehdienst Berlin</a><!-- 2011060100025 atlas.multimedia-->
+   <a title="Sponsor: Custom T-Shirts" href="http://www.ooshirts.com">Custom T-Shirts</a><!-- 2011050100030 ooshirts.com-->
 </div>
 </div>
 </div>
 </div>
 
 <div class="eastbar">
-  <script type="text/javascript">
-  <!--
-    google_ad_client = "pub-3129977114552745";
-    google_ad_slot = "0574824969";
-    google_ad_width = 160;
-    google_ad_height = 600;
-  //-->
-  </script>
-  <script type="text/javascript"
-    src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
-  </script>
+
 </div>
 
 <div class="main">
