diff --git a/src/compatibility/5.1/android-5.1-cdd.html b/src/compatibility/5.1/android-5.1-cdd.html
index 0e59cec..efe2adc 100644
--- a/src/compatibility/5.1/android-5.1-cdd.html
+++ b/src/compatibility/5.1/android-5.1-cdd.html
@@ -161,8 +161,7 @@
 
 </div>
 
-<div style="clear: both; page-break-after:always; height:15px"></div>
-
+<div style="clear: both; page-break-after:always; height:1px"></div>
 
 <div id="toc_left_2">
 
@@ -1284,8 +1283,13 @@
 hardware, the corresponding APIs MUST be implemented as no-ops. This behavior
 is further detailed in <a href="#7_hardware_compatibility">section 7</a>.</p>
 
-<p>Additionally, the implementation MUST correctly render all resources (icons,
-sound files, etc.) provided for in the APIs [<a href="https://developer.android.com/guide/topics/resources/available-resources.html">Resources, 23</a>], or in the Status/System Bar icon style guide [<a href="http://developer.android.com/design/style/iconography.html">Resources, 24</a>]. Device implementers MAY provide an alternative user experience for
+<p>Additionally, the implementation MUST correctly render all resources (icons, animation files
+etc.) provided for in the APIs
+[<a href="https://developer.android.com/guide/topics/resources/available-resources.html">Resources, 23</a>],
+or in the Status/System Bar icon style guide
+[<a href="http://developer.android.com/design/style/iconography.html">Resources, 24</a>],
+which in the case of an Android Television device includes the possibility to not display the
+notifications. Device implementers MAY provide an alternative user experience for
 notifications than that provided by the reference Android Open Source
 implementation; however, such alternative notification systems MUST support
 existing notification resources, as above. </p>
@@ -1298,8 +1302,10 @@
   <li><strong>Lockscreen notifications</strong>. Notifications shown over a lock screen with granular control on visibility.</li>
 </ul>
 
-<p>Device implementations MUST properly display and execute these notifications,
-including the title/name, icon, text as documented in the Android APIs <a href="http://developer.android.com/design/patterns/notifications.html">[Resources, 25]</a>.</p>
+<p>Android device implementations, when such notifications are made visible, MUST properly execute
+Rich and Heads-up notifications and include the title/name, icon, text as documented in the Android
+APIs <a href="https://developer.android.com/design/patterns/notifications.html">[Resources, 25]</a>.
+</p>
 
 <p>Android includes Notification Listener Service APIs that allow apps (once
 explicitly enabled by the user) to receive a copy of all notifications as they
@@ -1434,8 +1440,10 @@
 
 <p>The Remote Control Client API is deprecated from Android 5.0 in favor of the
 Media Notification Template that allows media applications to integrate with
-playback controls that are displayed on the lock screen [<a href="http://developer.android.com/reference/android/app/Notification.MediaStyle.html">Resources, 35</a>]. Device implementations that support a lock screen in the device MUST support
-the Media Notification Template along with other notifications.</p>
+playback controls that are displayed on the lock screen [<a href="http://developer.android.com/reference/android/app/Notification.MediaStyle.html">Resources, 35</a>].
+Device implementations that support a lock screen, unless an Android Automotive or Watch
+implementation, MUST display the Lockscreen Notifications including the Media Notification
+Template.</p>
 
 <h3 id="3_8_11_dreams">3.8.11. Dreams</h3>
 
@@ -1581,7 +1589,13 @@
 <p>Device implementations MUST support the core media formats specified in the
 Android SDK documentation [<a href="http://developer.android.com/guide/appendix/media-formats.html">Resources, 50</a>] except where explicitly permitted in this document. Specifically, device
 implementations MUST support the media formats, encoders, decoders, file types,
-and container formats defined in the tables below. All of these codecs are
+and container formats defined in the tables below and reported via MediaCodecList
+[<a href="http://developer.android.com/reference/android/media/MediaCodecList.html">Resources,112</a>].
+Device implementations MUST also be able to decode all profiles reported in its CamcorderProfile
+[<a href="http://developer.android.com/reference/android/media/CamcorderProfile.html">Resources,
+113</a>].
+
+All of these codecs are
 provided as software implementations in the preferred Android implementation
 from the Android Open Source Project.</p>
 
@@ -1780,7 +1794,6 @@
 
 <div class="div">
 <p>Video codecs are optional for Android Watch device implementations.</p>
-</div>
 
 <table>
  <tr>
@@ -1788,7 +1801,7 @@
     <th>Encoder</th>
     <th>Decoder</th>
     <th>Details</th>
-    <th>Supported File Types/Container Formats</th>
+    <th>Supported File Types/<br>Container Formats</th>
  </tr>
  <tr>
     <td>H.263</td>
@@ -1812,7 +1825,7 @@
  <tr>
     <td>H.265 HEVC</td>
     <td></td>
-    <td>REQUIRED<sup>2</sup></td>
+    <td>REQUIRED<sup>5</sup></td>
     <td>See <a href="#5_3_video_decoding">section 5.3</a> for details</td>
     <td>MPEG-4 (.mp4)</td>
  </tr>
@@ -1859,6 +1872,8 @@
 
 <p class="table_footnote">4 Device implementations SHOULD support writing Matroska WebM files.</p>
 
+<p class="table_footnote">5 Strongly recommended for Android Automotive, optional for Android Watch, and required for all other device types.</p>
+
 <h2 id="5_2_video_encoding">5.2. Video Encoding</h2>
 
 <div class="note">
@@ -3989,17 +4004,17 @@
 <h2 id="8_2_file_i_o_access_performance">8.2. File I/O Access Performance</h2>
 
 
-<p>Device implementations MUST ensure file access performance consistency for read
+<p>Device implementations MUST ensure internal storage file access performance consistency for read
 and write operations. </p>
 
 <ul>
-  <li><strong>Sequential write</strong>. Device implementations MUST ensure a sequential write performance of 10MB/s
+  <li><strong>Sequential write</strong>. Device implementations MUST ensure a sequential write performance of at least 5MB/s
 for a 256MB file using 10MB write buffer.</li>
-  <li><strong>Random write</strong>. Device implementations MUST ensure a random write performance of 0.5MB/s for a
+  <li><strong>Random write</strong>. Device implementations MUST ensure a random write performance of at least 0.5MB/s for a
 256MB file using 4KB write buffer.</li>
-  <li><strong>Sequential read</strong>. Device implementations MUST ensure a sequential read performance of 15MB/s for
+  <li><strong>Sequential read</strong>. Device implementations MUST ensure a sequential read performance of at least 15MB/s for
 a 256MB file using 10MB write buffer.</li>
-  <li><strong>Random read</strong>. Device implementations MUST ensure a random read performance of 3.5MB/s for a
+  <li><strong>Random read</strong>. Device implementations MUST ensure a random read performance of at least 3.5MB/s for a
 256MB file using 4KB write buffer.</li>
 </ul>
 
@@ -4235,13 +4250,26 @@
 
 <h2 id="9_10_verified_boot">9.10. Verified Boot</h2>
 
+<p>
+Verified boot is a feature that guarantees the integrity of the device software.
+If a device implementation supports the feature, it MUST:</p>
+<ul>
+<li>Declare the platform feature flag android.software.verified_boot</li>
+<li>Perform verification on every boot sequence</li>
+<li>Start verification from a hardware key that is the root of trust, and go
+all the way up to the system partition</li>
+<li>Implement each stage of verification to check the integrity and authenticity
+of all the bytes in the next stage before executing the code in the next stage</li>
+<li>Use verification algorithms as strong as current recommendations
+from NIST for hashing algorithms (SHA-256) and public key sizes (RSA-2048)</li>
+</ul>
 
-<p>Device implementations SHOULD support verified boot for device integrity, and
-if the feature is supported it MUST declare the platform feature flag
-android.software.verified_boot. While this requirement is stated as SHOULD for
-this version of the Android platform, it is <strong>very strongly RECOMMENDED</strong> as we expect this to change to MUST in the future versions of Android. The
-upstream Android Open Source Project provides a preferred implementation of
-this feature based on the linux kernel feature dm-verity.</p>
+<p>Device implementations SHOULD support verified boot for device integrity.
+While this requirement is SHOULD for this version of the Android platform,
+it is <strong>strongly RECOMMENDED</strong> as we expect this to change to MUST
+in future versions of Android. The upstream Android Open Source Project provides
+a preferred implementation of this feature based on the linux kernel feature dm-verity.
+</p>
 
 <h1 id="10_software_compatibility_testing">10. Software Compatibility Testing</h1>
 
@@ -4352,93 +4380,50 @@
  </tr>
  <tr>
     <td>2. Device Types</td>
-    <td>Included definitions for device types for handheld, television, and watch
-devices.</td>
+    <td>Added definition for Android automotive implementation.</td>
  </tr>
  <tr>
-    <td>2.1 Device Configuration</td>
-    <td>Added non-exhaustive list to illustrate hardware configuration deviation across
-devices.</td>
+    <td>2.1 Device Configurations</td>
+    <td>Added column for Android automotive implementation.</td>
  </tr>
  <tr>
-    <td>3.1. Managed API Compatibility</td>
-    <td>MUST also provide complete implementations of APIs with &ldquo;@SystemApi&rdquo; marker in
-the upstream Android source code.</td>
- </tr>
- <tr>
-    <td>3.2.2. Build Parameters</td>
-    <td>Included SUPPORTED_ABIS, SUPPORTED_32_BIT_ABIS, and SUPPORTED_64_BIT_ABIS
-parameters in list, updated PRODUCT to require unique Product SKUs, and updated
-TAGS.</td>
- </tr>
- <tr>
-    <td>3.2.3.1. Core Application Intents</td>
-    <td>Clarified language that the compatibility requirement is for mainly the intents
-pattern </td>
- </tr>
- <tr>
-    <td>3.2.3.5. Default App Settings</td>
-    <td>Included new requirements for home screen, NFC, and default SMS applications.</td>
- </tr>
- <tr>
-    <td>3.3.1 Application Binary Interfaces</td>
-    <td>Added requirements to support equivalent 32-bit ABI if any 64-bit ABI is
-supported. Updated parameters to reflect this change.</td>
+    <td>3.3.2. 32-bit ARM Native Code Compatibility</td>
+    <td>New section added.</td>
  </tr>
  <tr>
     <td>3.4.1. WebView Compatibility</td>
-    <td>Webview compatibility required for all devices except Android Watch devices.
-Removed Locale string requirement.</td>
+    <td>Updated webview user agent string requirement to accomodate upstream
+        implementation change.</td>
  </tr>
  <tr>
     <td>3.4.2. Browser compatibility</td>
-    <td>Android Television, Watch, and Android Automotive implementations MAY
-    omit a browser application, but all other types of device implementations
-    MUST include one.</td>
+    <td>Added Android automotive implementations as another case that MAY omit a
+        browser application.</td>
  </tr>
  <tr>
-    <td>3.7. Runtime compatibility</td>
-    <td>Updated Minimum application memory requirements</td>
- </tr>
- <tr>
-    <td>3.8.2. Widgets</td>
-    <td>Widget support is optional for all device types, but recommended for Handheld
-Devices.</td>
+    <td>3.7. Runtime Compatibility</td>
+    <td>Updated required runtime heap size for smaller screens and added requirement
+        for the new dpi bucket (280dpi).</td>
  </tr>
  <tr>
     <td>3.8.3. Notifications</td>
-    <td>Expanded definitions for types of supported notifications. </td>
+    <td>Clarified notification requirement for Android Watch, Television and
+        Automotive implementations.</td>
  </tr>
  <tr>
-    <td>3.8.4. Search</td>
-    <td>Android Television devices MUST include global search. All other device types
-SHOULD.</td>
- </tr>
- <tr>
-    <td>3.8.6. Themes</td>
-    <td>Devices MUST support material theme.</td>
- </tr>
- <tr>
-    <td>3.8.7. Live Wallpapers</td>
-    <td>Devices that include live wallpaper MUST report the platform feature flag
-android.software.live_wallpaper.</td>
- </tr>
- <tr>
-    <td>3.8.8. Activity Switching</td>
-    <td>Advised requirement to support new Recents User Interface</td>
- </tr>
- <tr>
-    <td>3.8.10. Lock Screen Media Remote Control</td>
-    <td> Remote Control Client API deprecated in favor of the Media Notification
-Template</td>
- </tr>
- <tr>
-    <td>3.8.11. Dreams</td>
-    <td>Optional for Android Watch devices. Required for all other device types.</td>
+    <td>3.8.10. Lock Screen Media Control</td>
+    <td>Clarified requirement for Android Watch and Automotive implementations.</td>
  </tr>
  <tr>
     <td>3.8.13. Unicode and font</td>
-    <td>MUST support Roboto 2 in addition to existing requirements. Added Android automotive requirements.</td>
+    <td>Relaxed Emoji character input method requirement.</td>
+ </tr>
+ <tr>
+    <td>3.9. Device Administration</td>
+    <td>Clarified condition when the full range of device administration policies
+        has to be supported.</td>
+
+
  </tr>
  <tr>
     <td>3.10. Accessibility</td>
@@ -4449,239 +4434,89 @@
     <td>Added Android automotive requirements.</td>
  </tr>
  <tr>
-    <td>3.12. TV Input Framework</td>
-    <td>Android Television device implementations MUST support Television Input
-Framework.</td>
- </tr>
- <tr>
     <td>5.1. Media Codecs</td>
-    <td>Added 3 sections for Audio, Image, and Video codecs.</td>
+    <td>Mandated decoding support for codecs reported by CamcorderProfile.</td>
+ </tr>
+   <tr>
+    <td>5.1.3 Video Codecs</td>
+    <td>Added Android automotive requirements.</td>
  </tr>
  <tr>
-    <td>5.4 Audio Recording</td>
-    <td>Broken into subsections</td>
- </tr>
- <tr>
-    <td>5.4.1. Raw audio capture</td>
-    <td>Defined characteristics for raw audio capture on devices that declare
-android.hardware.microphone</td>
- </tr>
- <tr>
-    <td>5.5. Audio Playback</td>
-    <td>Added section 5.5. Audio Playback with 2 subsections: 5.5.1 Audio Effects and
-5.5.2. Audio Output Volume</td>
- </tr>
- <tr>
-    <td>5.6 Audio Latency</td>
-    <td>Added definitions and requirements for cold output jitter, cold input jitter,
-and continuous round-trip latency.</td>
- </tr>
- <tr>
-    <td>5.8 Secure Media</td>
-    <td>Included secure media requirements from 7.1.8. External Displays and added
-requirements for Android Television.</td>
- </tr>
- <tr>
-    <td>6.1. Developer Tools</td>
-    <td>Updated resources.</td>
- </tr>
- <tr>
-    <td>6.2.1. Experimental</td>
-    <td>Removed section</td>
- </tr>
- <tr>
-    <td>7. Hardware Compatibility</td>
-    <td>Updated to reflect that device implementations MUST consistently report
-accurate hardware configuration for the same build fingerprint.</td>
- </tr>
- <tr>
-    <td>7.1.1.1. Screen Size</td>
-    <td>Updated to reflect Android Watch devices screen size and that the value can&rsquo;t
-change</td>
- </tr>
- <tr>
-    <td>7.1.1.2. Screen Aspect Ratio</td>
-    <td>Updated to reflect Android Watch devices screen aspect ratio (1:1).</td>
- </tr>
- <tr>
-    <td>7.1.3. Screen Orientation</td>
-    <td>Updated to reflect that devices with a fixed orientation landscape screen
-SHOULD only report that orientation. </td>
- </tr>
- <tr>
-    <td>7.1.4. 2D and 3D Graphics Acceleration</td>
-    <td>Added that Android devices MAY support the Android extension pack. </td>
+    <td>7.1.1.3. Screen Density</td>
+    <td>Added a new screen dpi (280dpi).</td>
  </tr>
  <tr>
     <td>7.1.5. Legacy Application Compatibility Mode</td>
     <td>Added Android automotive requirements.</td>
  </tr>
  <tr>
-    <td>(old) 7.1.6. Screen Types</td>
-    <td>Section Removed </td>
- </tr>
- <tr>
     <td>7.1.6. Screen Technology</td>
     <td>Updated pixel aspect ratio (PAR) to be between 0.9 and 1.15. (~15% tolerance)</td>
  </tr>
  <tr>
     <td>7.1.7. External Displays</td>
     <td>Moved part of section to section 5.8. Secure Media.</td>
+    <td>7.2 Input Devices</td>
+    <td>Added general introduction statement.</td>
  </tr>
  <tr>
     <td>7.2.1. Keyboard</td>
     <td>Added Android Automotive requirements.</td>
  </tr>
-  <tr>
-    <td>7.2 Input Devices</td>
-    <td>Added general intro statement.</td>
- </tr>
- <tr>
-    <td>7.2.2. Non-touch Navigation</td>
-    <td>Android Television devices MUST support D-pad. </td>
- </tr>
+
  <tr>
     <td>7.2.3. Navigation Keys</td>
-    <td>Included language for support across different device types. Added
-    Android Automotive requirements.</td>
- </tr>
- <tr>
-    <td>7.2.4. Touchscreen Input</td>
-    <td>Android Watch devices MUST support touchscreen input. </td>
- </tr>
- <tr>
-    <td>7.2.6. Game Controller Support</td>
-    <td>Added section with Android Television requirements.</td>
- </tr>
- <tr>
-    <td>7.2.7. Remote Control </td>
-    <td>Added section with Android Television requirements.</td>
- </tr>
- <tr>
-    <td>7.3. Sensors</td>
-    <td>Redefined synthetic sensors as composite sensors and streaming sensors as
-continuous sensors. Sensors should report event time in nanoseconds.</td>
+    <td>Added Android Automotive requirements.</td>
  </tr>
  <tr>
     <td>7.3.1. Accelerometer</td>
-    <td>Clarified required sensor types and revised requirement thresholds. </td>
- </tr>
- <tr>
-    <td>7.3.2. Magnetometer</td>
-    <td>Clarified required sensor types and revised requirement thresholds.</td>
+    <td>Relaxed requirement for reporting frequency on Android Watch.</td>
  </tr>
  <tr>
     <td>7.3.4. Gyroscope</td>
-    <td>Clarified required sensor types and revised requirement thresholds.</td>
- </tr>
- <tr>
-    <td>7.3.5. Barometer</td>
-    <td>Changed from MAY to SHOULD implement barometer. MUST implement and report
-TYPE_PRESSURE sensor.</td>
- </tr>
- <tr>
-    <td>7.3.6. Thermometer</td>
-    <td>Devices MAY include ambient thermometer. MAY but SHOULD NOT include CPU
-thermometer.</td>
- </tr>
- <tr>
-    <td>7.3.8. Proximity Sensor</td>
-    <td>Devices that can make a voice call and indicate any value other than
-PHONE_TYPE_NONE in getPhoneType SHOULD include a proximity sensor.</td>
- </tr>
- <tr>
-    <td>7.4.2. IEEE 802.11 (Wi-Fi)</td>
-    <td>Android Television devices MUST include Wi-Fi support. Devices that DO support
-wifi must report android.hardware.wifi. </td>
- </tr>
- <tr>
-    <td>7.4.2.1. Wi-Fi Direct</td>
-    <td>MUST report the hardware feature android.hardware.wifi.direct.</td>
- </tr>
- <tr>
-    <td>7.4.2.2. Wi-Fi Tunneled Direct Link Setup</td>
-    <td>Android Television devices MUST include support for Wi-Fi TDLS.</td>
+    <td>Relaxed requirement for reporting frequency on Android Watch.</td>
  </tr>
  <tr>
     <td>7.4.3 Bluetooth</td>
     <td>Added Android Automotive requirements.</td>
  </tr>
  <tr>
-    <td>7.5. Cameras</td>
-    <td>If a device implementation includes at least one camera, it SHOULD be possible
-for an application to simultaneously allocate 3 bitmaps equal to the size of
-the images produced by the largest-resolution camera sensor on the device.</td>
- </tr>
- <tr>
-    <td>7.5.3. External Cameras</td>
-    <td>Added requirements that device implementations with USB host mode MAY include
-support for an external camera.</td>
- </tr>
- <tr>
-    <td>7.5.5. Camera System Features</td>
-    <td>Added list of camera features and when they should be defined. </td>
+    <td>7.4.4. Near-Field Communications</td>
+    <td>Clarified condition for when Host Card Emulation is a requirement.</td>
  </tr>
  <tr>
     <td>7.6.1. Minimum Memory and Storage</td>
-    <td>Updated requirements for 32- and 64-bit devices. SVELTE memory requirement
-removed. Devices MUST have at least 1.5GB of non-volatile storage</td>
+    <td>Updated minimum memory requirements for lower resulution screen devices
+        and added hard-limit requirement isLowRamDevice().</td>
  </tr>
  <tr>
     <td>7.6.2. Application Shared Storage</td>
-    <td>Updated requirements for user-accessible removable storage</td>
- </tr>
- <tr>
-    <td>7.7. USB</td>
-    <td>Removed requirements for non-charging ports being on the same edge as the
-micro-USB port. Updated requirements for Host and Peripheral mode. </td>
- </tr>
- <tr>
-    <td>7.8. Audio</td>
-    <td>Moved microphone section here. Added requirements for Audio Output and Audio
-Analog ports.</td>
+    <td>Updated requirements when support for host machine access is mandatory.</td>
  </tr>
  <tr>
     <td>7.8.1. Microphone</td>
     <td>Added Android Automotive requirements.</td>
  </tr>
  <tr>
-    <td>8. Performance Compatibility</td>
-    <td>Added requirements for user interface consistency.</td>
+    <td>8.2. File I/O Access Performance</td>
+    <td>Clarified requirements.</td>
  </tr>
  <tr>
-    <td>9.5. Multi-User Support</td>
-    <td>Multi-user support feature is optional for all device types. Detailed
-requirements by device type in section.</td>
- </tr>
- <tr>
-    <td>9.7. Kernel Security Features</td>
-    <td>MAY have a visible user interface when an unblocked security violation occurs
-resulting in a successful exploit. No permissive mode domains allowed.</td>
+    <td>9.8. Privacy</td>
+    <td>Added privacy requirement for preloaded VPNs.</td>
  </tr>
  <tr>
     <td>9.9. Full-Disk Encryption</td>
-    <td>Devices with a lock screen MUST support full-disk encryption. For new devices,
-full-disk encryption must be enabled out of box. </td>
+    <td>Clarified condition when Full-Disk encryption support is mandatory.</td>
  </tr>
  <tr>
-    <td>9.10 Verified boot</td>
-    <td>Added section to recommend that Device implementations support verified boot
-for device integrity.</td>
- </tr>
- <tr>
-    <td>10.3. Reference Applications</td>
-    <td>Removed section from CDD.</td>
+    <td>9.10. Verified Boot</td>
+    <td>Clarified definition of verified boot.</td>
  </tr>
  <tr>
     <td>11. Updatable Software</td>
-    <td>If a device supports 802.11 or Bluetooth PAN (Personal Area Network) profile,
-then it MUST support over-the-air (OTA) download with offline update via reboot. Clarified
-the OTA download requirement is allowed but not mandatory for Android Automotive
-implementations.</td>
- </tr>
- <tr>
-    <td>14. Resources</td>
-    <td>Resources moved from section 2 to section 14</td>
+    <td>Clarified the OTA download requirement is allowed but not mandatory for
+        Android Automotive implementations.</td>
  </tr>
 </table>
 
@@ -4928,7 +4763,11 @@
 
 <p>110. WebM project: <a href="http://www.webmproject.org/">http://www.webmproject.org/</a>  </p>
 
-<p>111. Android Auto feature: <a href="http://developer.android.com/reference/android/content/res/Configuration.html#UI_MODE_TYPE_CAR">http://developer.android.com/reference/android/content/res/Configuration.html#UI_MODE_TYPE_CAR</a></p>
+<p>111. Android UI_MODE_TYPE_CAR API: <a href="http://developer.android.com/reference/android/content/res/Configuration.html#UI_MODE_TYPE_CAR">http://developer.android.com/reference/android/content/res/Configuration.html#UI_MODE_TYPE_CAR</a></p>
+
+<p>112. Android MediaCodecList API: <a href="http://developer.android.com/reference/android/media/MediaCodecList.html">http://developer.android.com/reference/android/media/MediaCodecList.html</a></p>
+
+<p>113. Android CamcorderProfile API: <a href="http://developer.android.com/reference/android/media/CamcorderProfile.html">http://developer.android.com/reference/android/media/CamcorderProfile.html</a></p>
 
 <p>Many of these resources are derived directly or indirectly from the Android
 SDK, and will be functionally identical to the information in that SDK&rsquo;s
diff --git a/src/compatibility/5.1/android-cdd-cover.css b/src/compatibility/5.1/android-cdd-cover.css
index dcbcc2f..04133d6 100644
--- a/src/compatibility/5.1/android-cdd-cover.css
+++ b/src/compatibility/5.1/android-cdd-cover.css
@@ -58,7 +58,7 @@
 }
 
 .padding-bottom {
-    padding: 40px 20px 200px 60px;
+    padding: 40px 20px 194px 60px;
 }
 
 .cover-text {
@@ -83,4 +83,4 @@
 p {
     margin: 0px;
     padding: 0px;
-}
\ No newline at end of file
+}
diff --git a/src/compatibility/5.1/android-cdd-cover_5_1.html b/src/compatibility/5.1/android-cdd-cover_5_1.html
index a59caf9..8ffdd31 100644
--- a/src/compatibility/5.1/android-cdd-cover_5_1.html
+++ b/src/compatibility/5.1/android-cdd-cover_5_1.html
@@ -17,14 +17,14 @@
 
 <tr>
 <td>
-<img src="../images/android-lollipop.jpg" alt="Lollipop logo" style="border-top: 5px solid orange; border-bottom: 5px solid orange"/>
+<img src="../images/android-lollipop-mr1.jpg" alt="Lollipop logo" style="border-top: 5px solid orange; border-bottom: 5px solid orange"/>
 </td>
 </tr>
 
 <tr>
 <td>
 <p class="subtitle">Android 5.1</p>
-<p class="cover-text">Last updated: April 1, 2015</p>
+<p class="cover-text">Last updated: June 9th, 2015</p>
 <p class="cover-text">Copyright &copy; 2015, Google Inc. All rights reserved.</p>
 <p class="cover-text"><a href="mailto:compatibility@android.com">compatibility@android.com</a></p>
 </td>
@@ -39,4 +39,4 @@
 </table>
 
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/src/compatibility/android-5.1-cdd.pdf b/src/compatibility/android-5.1-cdd.pdf
new file mode 100644
index 0000000..78a9857
--- /dev/null
+++ b/src/compatibility/android-5.1-cdd.pdf
Binary files differ
diff --git a/src/compatibility/android-cdd.pdf b/src/compatibility/android-cdd.pdf
index f29d081..78a9857 100644
--- a/src/compatibility/android-cdd.pdf
+++ b/src/compatibility/android-cdd.pdf
Binary files differ
diff --git a/src/compatibility/images/android-lollipop-mr1.jpg b/src/compatibility/images/android-lollipop-mr1.jpg
new file mode 100644
index 0000000..c9b757d
--- /dev/null
+++ b/src/compatibility/images/android-lollipop-mr1.jpg
Binary files differ
