diff --git a/docs/html/distribute/googleplay/cast.jd b/docs/html/distribute/googleplay/cast.jd
index 339142e..937ab58 100644
--- a/docs/html/distribute/googleplay/cast.jd
+++ b/docs/html/distribute/googleplay/cast.jd
@@ -4,10 +4,15 @@
 @jd:body
 
 <p>
-  With Google Cast
-  you make it easy for users to include your content as part of their viewing
-  on TV and listening on audio systems. All they need is an Android TV, a TV with a Chromecast plugged in,
-  or a Cast for audio device connected to their audio system.
+With Google Cast you make it easy for users to include your content as part of
+their viewing on TV and listening on audio systems. All they need is a TV with a
+Chromecast plugged in, an Android TV or a Cast for audio device connected to their
+audio system.</p>
+
+<p>Cast Remote Display lets you cast a second display directly to the TV while running
+a primary display on the sender. Native games can provide real-time interaction on
+the TV and user control on the hand-held device. Graphics-intensive apps can now
+take full advantage of multiscreen experiences via Cast.
 </p>
 
 <div>
diff --git a/docs/html/google/index.jd b/docs/html/google/index.jd
index 8538161..923d48d 100644
--- a/docs/html/google/index.jd
+++ b/docs/html/google/index.jd
@@ -11,7 +11,7 @@
   <div class="wrap">
     <div class="cols dac-hero-content">
       <div class="col-1of2 col-push-1of2 dac-hero-figure">
-        <img class="dac-hero-image" src="/images/google/hero-play-services_2x.png">
+        <img class="dac-hero-image" src="/images/google/hero-play-services_2x.png" style="padding-bottom:1em">
       </div>
       <div class="col-1of2 col-pull-1of2">
         <h1 class="dac-hero-title">Build better apps with Google</h1>
@@ -105,88 +105,4 @@
       Licensing library
     </a></li>
   </ul>
-</div></section>
-
-<!--
-
-<section class="dac-section dac-light"><div class="wrap">
-  <h1 class="dac-section-title">More</h1>
-  <div class="dac-section-subtitle">
-    Design around Android's capabilities and conventions to give users the best experience.
-  </div>
-  <div class="resource-widget resource-flow-layout col-16"
-       data-query="collection:google/landing/more"
-       data-cardSizes="6x6"
-       data-maxResults="6"></div>
-</div></section>
-
-
-
-
-Google Play services
-video video
-
-
-Google Play Publishing Tools
-
-
-
-Distribute your app on Google Play to all devices running Android 2.3
-  or higher, and some services support even more devices.</p>
-
-
-Google Maps
-
-Include the power of Google Maps in your app
-    with an embeddable map view. You can customize the map with
-    markers and overlays, control the user's perspective, draw lines
-    and shapes, and much more.
-
-Google+</a></h4>
-
-Allow users to sign in with their Google account,
-    customize the user experience with Google+ info,
-    pull people into your app with interactive posts,
-    and add +1 buttons so users can recommend your content.</p>
-
-
-Google Cloud Platform
-
-Build and host the backend for your Android app at Google-scale. With an infrastructure
-    that is managed automatically, you can focus on your app. Then, scale to support
-    millions of users.
-
-
-
-
-
-More
-
-Google Play In-App Billing
-
-Build an app with a steady revenue stream that keeps users engaged
-    by offering new content or virtual goods directly in your app. All transactions are handled
-    by Google Play Store for a simple user experience.
-
-
-Android Pay
-
-Provide fast and easy checkout in your app when selling physical goods and services.
-    Increase conversions by streamlining your purchase flow and reducing the amount of
-    information your customers need to enter.
-
-Google Analytics
-
-Measure your success and gain insights into how users engage with your app content
-by integrating Google Analytics. You can track in-app purchases, the number of active users,
-interaction patterns, and much more.
-
-
-Google Mobile Ads
-
-Display ads from Google Mobile Ads offer you an alternative revenue opportunity that leverages
-    multiple ad networks with targeted ads and several display formats.
-
-
-
--->
\ No newline at end of file
+</div></section>
\ No newline at end of file
diff --git a/docs/html/google/play/billing/billing_reference.jd b/docs/html/google/play/billing/billing_reference.jd
index 7884929..b06d874 100644
--- a/docs/html/google/play/billing/billing_reference.jd
+++ b/docs/html/google/play/billing/billing_reference.jd
@@ -208,7 +208,7 @@
   <tr>
     <td>{@code orderId}</td>
     <td>A unique order identifier for the transaction. This identifier
-      corresponds to the Google Wallet Order ID.</td>
+      corresponds to the Google payments order ID.</td>
   </tr>
   <tr>
     <td>{@code packageName}</td>
diff --git a/docs/html/preview/images/m-preview-timeline.png b/docs/html/preview/images/m-preview-timeline.png
index 2a45333..e9a339e 100644
--- a/docs/html/preview/images/m-preview-timeline.png
+++ b/docs/html/preview/images/m-preview-timeline.png
Binary files differ
diff --git a/docs/html/preview/index.jd b/docs/html/preview/index.jd
index b1f14ac..d9af7e0 100644
--- a/docs/html/preview/index.jd
+++ b/docs/html/preview/index.jd
@@ -66,7 +66,7 @@
 <section class="dac-section dac-gray dac-small dac-invert" id="latest"><div class="wrap">
   <h2 class="norule">Latest</h2>
   <div class="resource-widget resource-flow-layout col-16"
-       data-query="type:blog+tag:featured"
+       data-query="type:blog+tag:androidm,type:youtube+tag:androidm"
        data-cardSizes="6x6"
        data-maxResults="6"
        data-initial-results="3"</div>
diff --git a/docs/html/preview/overview.jd b/docs/html/preview/overview.jd
index 633fd25..e235d68 100644
--- a/docs/html/preview/overview.jd
+++ b/docs/html/preview/overview.jd
@@ -16,7 +16,7 @@
 <img src="{@docRoot}preview/images/m-preview-timeline.png"
   alt="Preview program timeline" id="figure1" style="margin-top: 15px;">
 <p class="img-caption">
-  <b>Figure 1.</b> Timeline for the M Developer Preview program.
+  Timeline for the M Developer Preview program.
 </p>
 
 <p>
diff --git a/docs/html/preview/samples.jd b/docs/html/preview/samples.jd
index b3836f8..45c9293 100644
--- a/docs/html/preview/samples.jd
+++ b/docs/html/preview/samples.jd
@@ -1,5 +1,5 @@
 page.title=Samples
-
+page.image=images/cards/card-samples_2x.png
 @jd:body
 
 <p>
diff --git a/docs/html/training/in-app-billing/preparing-iab-app.jd b/docs/html/training/in-app-billing/preparing-iab-app.jd
index 344693a..17cd0d51 100644
--- a/docs/html/training/in-app-billing/preparing-iab-app.jd
+++ b/docs/html/training/in-app-billing/preparing-iab-app.jd
@@ -47,7 +47,7 @@
 <p>The Google Play Developer Console is where you publish your In-app Billing application and  manage the various digital goods that are available for purchase from your application. When you create a new application entry in the Developer Console, it automatically generates a public license key for your application. You will need this key to establish a trusted connection from your application to the Google Play servers. You only need to generate this key once per application, and don’t need to repeat these steps when you update the APK file for your application.</p>
 <p>To add your application to the Developer Console:</p>
 <ol>
-<li>Go to the <a href="http://play.google.com/apps/publish">Google Play Developer Console</a> site and log in. You will need to register for a new developer account, if you have not registered previously. To sell in-app items, you also need to have a <a href="http://www.google.com/wallet/merchants.html">Google Wallet</a> merchant account.</li>
+<li>Go to the <a href="http://play.google.com/apps/publish">Google Play Developer Console</a> site and log in. You will need to register for a new developer account, if you have not registered previously. To sell in-app items, you also need to have a <a href="http://www.google.com/wallet/merchants.html">Google payments</a> merchant account.</li>
 <li>Click on <strong>Try the new design</strong> to access the preview version of the Developer Console, if you are not already logged on to that version. </li>
 <li>In the <strong>All Applications</strong> tab, add a new application entry.
 <ol type="a">
