diff --git a/current/android.jar b/current/android.jar
index a62d7f8..0988b47 100644
--- a/current/android.jar
+++ b/current/android.jar
Binary files differ
diff --git a/current/framework.aidl b/current/framework.aidl
index e152395..af683f5 100644
--- a/current/framework.aidl
+++ b/current/framework.aidl
@@ -39,6 +39,7 @@
 parcelable android.graphics.PointF;
 parcelable android.graphics.RectF;
 parcelable android.graphics.Rect;
+parcelable android.graphics.drawable.Icon;
 parcelable android.accounts.AuthenticatorDescription;
 parcelable android.accounts.Account;
 parcelable android.app.admin.SystemUpdatePolicy;
diff --git a/current/support/annotations/android-support-annotations.jar b/current/support/annotations/android-support-annotations.jar
index 0c25107..42a2a60 100644
--- a/current/support/annotations/android-support-annotations.jar
+++ b/current/support/annotations/android-support-annotations.jar
Binary files differ
diff --git a/current/support/customtabs/libs/android-support-customtabs.jar b/current/support/customtabs/libs/android-support-customtabs.jar
index 97ed488..7c88235 100644
--- a/current/support/customtabs/libs/android-support-customtabs.jar
+++ b/current/support/customtabs/libs/android-support-customtabs.jar
Binary files differ
diff --git a/current/support/design/libs/android-support-design.jar b/current/support/design/libs/android-support-design.jar
index 27efb76..297ea55 100644
--- a/current/support/design/libs/android-support-design.jar
+++ b/current/support/design/libs/android-support-design.jar
Binary files differ
diff --git a/current/support/design/res/anim-v21/design_bottom_sheet_slide_in.xml b/current/support/design/res/anim-v21/design_bottom_sheet_slide_in.xml
new file mode 100644
index 0000000..b5960a3
--- /dev/null
+++ b/current/support/design/res/anim-v21/design_bottom_sheet_slide_in.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+     android:duration="@integer/bottom_sheet_slide_duration"
+     android:interpolator="@android:interpolator/fast_out_linear_in">
+
+    <translate
+            android:fromYDelta="20%p"
+            android:toYDelta="0"/>
+
+    <alpha
+            android:fromAlpha="0.0"
+            android:toAlpha="1.0"/>
+
+</set>
diff --git a/current/support/design/res/anim-v21/design_bottom_sheet_slide_out.xml b/current/support/design/res/anim-v21/design_bottom_sheet_slide_out.xml
new file mode 100644
index 0000000..d680abe
--- /dev/null
+++ b/current/support/design/res/anim-v21/design_bottom_sheet_slide_out.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+     android:duration="@integer/bottom_sheet_slide_duration"
+     android:interpolator="@android:interpolator/fast_out_slow_in">
+
+    <translate
+            android:fromYDelta="0"
+            android:toYDelta="20%p"/>
+
+    <alpha
+            android:fromAlpha="1.0"
+            android:toAlpha="0.0"/>
+
+</set>
diff --git a/current/support/design/res/anim/design_bottom_sheet_slide_in.xml b/current/support/design/res/anim/design_bottom_sheet_slide_in.xml
new file mode 100644
index 0000000..7cbae08
--- /dev/null
+++ b/current/support/design/res/anim/design_bottom_sheet_slide_in.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+     android:duration="@integer/bottom_sheet_slide_duration"
+     android:interpolator="@android:anim/accelerate_decelerate_interpolator">
+
+    <translate
+            android:fromYDelta="20%p"
+            android:toYDelta="0"/>
+
+    <alpha
+            android:fromAlpha="0.0"
+            android:toAlpha="1.0"/>
+
+</set>
diff --git a/current/support/design/res/anim/design_bottom_sheet_slide_out.xml b/current/support/design/res/anim/design_bottom_sheet_slide_out.xml
new file mode 100644
index 0000000..2e30963
--- /dev/null
+++ b/current/support/design/res/anim/design_bottom_sheet_slide_out.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<set xmlns:android="http://schemas.android.com/apk/res/android"
+     android:duration="@integer/bottom_sheet_slide_duration"
+     android:interpolator="@android:anim/accelerate_interpolator">
+
+    <translate
+            android:fromYDelta="0"
+            android:toYDelta="20%p"/>
+
+    <alpha
+            android:fromAlpha="1.0"
+            android:toAlpha="0.0"/>
+
+</set>
diff --git a/current/support/design/res/anim/design_snackbar_out.xml b/current/support/design/res/anim/design_snackbar_out.xml
index eb55cc0..b535c04 100644
--- a/current/support/design/res/anim/design_snackbar_out.xml
+++ b/current/support/design/res/anim/design_snackbar_out.xml
@@ -17,4 +17,4 @@
 
 <translate xmlns:android="http://schemas.android.com/apk/res/android"
            android:fromYDelta="0"
-           android:toYDelta="100%"/>
\ No newline at end of file
+           android:toYDelta="100%"/>
diff --git a/current/support/design/res/drawable/design_fab_background.xml b/current/support/design/res/drawable/design_fab_background.xml
index 43afd5c..03d82f1 100644
--- a/current/support/design/res/drawable/design_fab_background.xml
+++ b/current/support/design/res/drawable/design_fab_background.xml
@@ -18,4 +18,4 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
         android:shape="oval">
     <solid android:color="@android:color/white" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/design/res/drawable/design_snackbar_background.xml b/current/support/design/res/drawable/design_snackbar_background.xml
index e82441c..6d9a519 100644
--- a/current/support/design/res/drawable/design_snackbar_background.xml
+++ b/current/support/design/res/drawable/design_snackbar_background.xml
@@ -19,4 +19,4 @@
        android:shape="rectangle">
     <corners android:radius="@dimen/design_snackbar_background_corner_radius"/>
     <solid android:color="@color/design_snackbar_background_color"/>
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/design/res/layout-sw600dp/design_layout_snackbar.xml b/current/support/design/res/layout-sw600dp/design_layout_snackbar.xml
index b68395a..6638275 100644
--- a/current/support/design/res/layout-sw600dp/design_layout_snackbar.xml
+++ b/current/support/design/res/layout-sw600dp/design_layout_snackbar.xml
@@ -20,4 +20,4 @@
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:layout_gravity="bottom|center_horizontal"
-      style="@style/Widget.Design.Snackbar" />
\ No newline at end of file
+      style="@style/Widget.Design.Snackbar" />
diff --git a/current/support/design/res/layout/design_bottom_sheet_dialog.xml b/current/support/design/res/layout/design_bottom_sheet_dialog.xml
new file mode 100644
index 0000000..cd5fb18
--- /dev/null
+++ b/current/support/design/res/layout/design_bottom_sheet_dialog.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<android.support.design.widget.CoordinatorLayout
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:app="http://schemas.android.com/apk/res-auto"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:soundEffectsEnabled="false">
+
+    <FrameLayout
+            android:id="@+id/design_bottom_sheet"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center_horizontal"
+            app:layout_behavior="@string/bottom_sheet_behavior"
+            style="?attr/bottomSheetStyle"/>
+
+</android.support.design.widget.CoordinatorLayout>
diff --git a/current/support/design/res/layout/design_layout_snackbar.xml b/current/support/design/res/layout/design_layout_snackbar.xml
index 604aafc..2054caf 100644
--- a/current/support/design/res/layout/design_layout_snackbar.xml
+++ b/current/support/design/res/layout/design_layout_snackbar.xml
@@ -20,4 +20,4 @@
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:layout_gravity="bottom"
-      style="@style/Widget.Design.Snackbar" />
\ No newline at end of file
+      style="@style/Widget.Design.Snackbar" />
diff --git a/current/support/design/res/layout/design_layout_snackbar_include.xml b/current/support/design/res/layout/design_layout_snackbar_include.xml
index 1aab24b..69459c5 100644
--- a/current/support/design/res/layout/design_layout_snackbar_include.xml
+++ b/current/support/design/res/layout/design_layout_snackbar_include.xml
@@ -47,4 +47,4 @@
             android:textColor="?attr/colorAccent"
             style="?attr/borderlessButtonStyle"/>
 
-</merge>
\ No newline at end of file
+</merge>
diff --git a/current/support/design/res/layout/design_layout_tab_icon.xml b/current/support/design/res/layout/design_layout_tab_icon.xml
index 5dcfa11..5aa13fb 100644
--- a/current/support/design/res/layout/design_layout_tab_icon.xml
+++ b/current/support/design/res/layout/design_layout_tab_icon.xml
@@ -18,4 +18,4 @@
 <ImageView xmlns:android="http://schemas.android.com/apk/res/android"
            android:layout_width="24dp"
            android:layout_height="24dp"
-           android:scaleType="centerInside"/>
\ No newline at end of file
+           android:scaleType="centerInside"/>
diff --git a/current/support/design/res/layout/design_layout_tab_text.xml b/current/support/design/res/layout/design_layout_tab_text.xml
index a83bb3d..9ff9609 100644
--- a/current/support/design/res/layout/design_layout_tab_text.xml
+++ b/current/support/design/res/layout/design_layout_tab_text.xml
@@ -20,4 +20,4 @@
           android:layout_height="wrap_content"
           android:ellipsize="end"
           android:gravity="center"
-          android:maxLines="2"/>
\ No newline at end of file
+          android:maxLines="2"/>
diff --git a/current/support/design/res/values-sw600dp/config.xml b/current/support/design/res/values-sw600dp/config.xml
index 58b6207..a5d7692 100644
--- a/current/support/design/res/values-sw600dp/config.xml
+++ b/current/support/design/res/values-sw600dp/config.xml
@@ -19,4 +19,4 @@
 
     <integer name="design_snackbar_text_max_lines">1</integer>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/design/res/values-sw600dp/dimens.xml b/current/support/design/res/values-sw600dp/dimens.xml
index 8dada20..f63dc9a 100644
--- a/current/support/design/res/values-sw600dp/dimens.xml
+++ b/current/support/design/res/values-sw600dp/dimens.xml
@@ -26,4 +26,7 @@
     <dimen name="design_snackbar_background_corner_radius">2dp</dimen>
     <dimen name="design_snackbar_action_inline_max_width">0dp</dimen>
 
-</resources>
\ No newline at end of file
+    <!-- 5 * standard increment (64dp on tablets) -->
+    <dimen name="design_navigation_max_width">320dp</dimen>
+
+</resources>
diff --git a/current/support/design/res/values/attrs.xml b/current/support/design/res/values/attrs.xml
index 9212e46..3ca6174 100644
--- a/current/support/design/res/values/attrs.xml
+++ b/current/support/design/res/values/attrs.xml
@@ -264,7 +264,8 @@
              Lollipop with the correct setup. -->
         <attr name="statusBarScrim" format="color" />
         <!-- The id of the primary Toolbar child that you wish to use for the purpose of collapsing.
-             If you do not set this then the first Toolbar child found will be used. -->
+             This Toolbar descendant view does not need to be a direct child of the layout.
+             If you do not set this, the first direct Toolbar child found will be used. -->
         <attr name="toolbarId" format="reference"/>
 
         <!-- Specifies how the title should be positioned when collapsed. -->
@@ -343,5 +344,12 @@
         <attr name="behavior_hideable" format="boolean"/>
     </declare-styleable>
 
+    <declare-styleable name="DesignTheme">
+        <!-- Theme to use for modal bottom sheet dialogs spawned from this theme. -->
+        <attr name="bottomSheetDialogTheme" format="reference" />
+        <!-- Style to use for modal bottom sheets in this theme. -->
+        <attr name="bottomSheetStyle" format="reference" />
+    </declare-styleable>
+
 </resources>
 
diff --git a/current/support/design/res/values/colors.xml b/current/support/design/res/values/colors.xml
index a958156..8cdf337 100644
--- a/current/support/design/res/values/colors.xml
+++ b/current/support/design/res/values/colors.xml
@@ -37,4 +37,4 @@
 
     <color name="design_snackbar_background_color">#323232</color>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/design/res/values/config.xml b/current/support/design/res/values/config.xml
index 67635a8..8b028ec 100644
--- a/current/support/design/res/values/config.xml
+++ b/current/support/design/res/values/config.xml
@@ -19,4 +19,4 @@
 
     <integer name="design_snackbar_text_max_lines">2</integer>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/design/res/values/dimens.xml b/current/support/design/res/values/dimens.xml
index 011ef63..604ac52 100644
--- a/current/support/design/res/values/dimens.xml
+++ b/current/support/design/res/values/dimens.xml
@@ -23,7 +23,8 @@
     <dimen name="design_fab_size_mini">40dp</dimen>
     <dimen name="design_fab_border_width">0.5dp</dimen>
 
-    <dimen name="design_navigation_max_width">320dp</dimen>
+    <!-- 5 * standard increment (56dp) -->
+    <dimen name="design_navigation_max_width">280dp</dimen>
     <dimen name="design_navigation_elevation">16dp</dimen>
     <dimen name="design_navigation_icon_padding">32dp</dimen>
     <dimen name="design_navigation_icon_size">24dp</dimen>
@@ -54,4 +55,7 @@
 
     <dimen name="design_appbar_elevation">4dp</dimen>
 
+    <dimen name="design_bottom_sheet_modal_elevation">16dp</dimen>
+    <dimen name="design_bottom_sheet_modal_peek_height">256dp</dimen>
+
 </resources>
diff --git a/current/support/design/res/values/integers.xml b/current/support/design/res/values/integers.xml
new file mode 100644
index 0000000..de20303
--- /dev/null
+++ b/current/support/design/res/values/integers.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<resources>
+    <integer name="bottom_sheet_slide_duration">150</integer>
+</resources>
diff --git a/current/support/design/res/values/strings.xml b/current/support/design/res/values/strings.xml
index 416d289..35ee706 100644
--- a/current/support/design/res/values/strings.xml
+++ b/current/support/design/res/values/strings.xml
@@ -17,6 +17,8 @@
 <resources>
     <!-- The class name to the ScrollingChildBehavior required for AppBarLayout -->
     <string name="appbar_scrolling_view_behavior" translatable="false">android.support.design.widget.AppBarLayout$ScrollingViewBehavior</string>
+    <!-- The class name to the BottomSheetBehavior -->
+    <string name="bottom_sheet_behavior" translatable="false">android.support.design.widget.BottomSheetBehavior</string>
     <!-- The text pattern for the character counter -->
     <string name="character_counter_pattern" translatable="false">%1$d / %2$d</string>
 </resources>
diff --git a/current/support/design/res/values/styles.xml b/current/support/design/res/values/styles.xml
index 24a9aa9..f69975c 100644
--- a/current/support/design/res/values/styles.xml
+++ b/current/support/design/res/values/styles.xml
@@ -114,5 +114,18 @@
         <item name="android:textColor">?android:attr/textColorPrimary</item>
     </style>
 
+    <style name="Animation.Design.BottomSheetDialog" parent="Animation.AppCompat.Dialog">
+        <item name="android:windowEnterAnimation">@anim/design_bottom_sheet_slide_in</item>
+        <item name="android:windowExitAnimation">@anim/design_bottom_sheet_slide_out</item>
+    </style>
+
+    <style name="Widget.Design.BottomSheet.Modal" parent="android:Widget">
+        <item name="android:minWidth">384dp</item>
+        <item name="android:background">?android:attr/colorBackground</item>
+        <item name="android:elevation">@dimen/design_bottom_sheet_modal_elevation</item>
+        <item name="behavior_peekHeight">@dimen/design_bottom_sheet_modal_peek_height</item>
+        <item name="behavior_hideable">true</item>
+    </style>
+
 </resources>
 
diff --git a/current/support/design/res/values/themes.xml b/current/support/design/res/values/themes.xml
new file mode 100644
index 0000000..0e3b1b1
--- /dev/null
+++ b/current/support/design/res/values/themes.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+<resources>
+
+    <style name="Theme.Design.BottomSheetDialog" parent="Theme.AppCompat.Dialog">
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowAnimationStyle">@style/Animation.Design.BottomSheetDialog</item>
+        <item name="bottomSheetStyle">@style/Widget.Design.BottomSheet.Modal</item>
+    </style>
+
+    <style name="Theme.Design.Light.BottomSheetDialog" parent="Theme.AppCompat.Light.Dialog">
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowAnimationStyle">@style/Animation.Design.BottomSheetDialog</item>
+        <item name="bottomSheetStyle">@style/Widget.Design.BottomSheet.Modal</item>
+    </style>
+
+</resources>
diff --git a/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar b/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar
index 1e2d428..00569c7 100644
--- a/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar
+++ b/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar
Binary files differ
diff --git a/current/support/multidex/library/libs/android-support-multidex.jar b/current/support/multidex/library/libs/android-support-multidex.jar
index 55861f5..6c54fec 100644
--- a/current/support/multidex/library/libs/android-support-multidex.jar
+++ b/current/support/multidex/library/libs/android-support-multidex.jar
Binary files differ
diff --git a/current/support/percent/libs/android-support-percent.jar b/current/support/percent/libs/android-support-percent.jar
index 20eb196..b101369 100644
--- a/current/support/percent/libs/android-support-percent.jar
+++ b/current/support/percent/libs/android-support-percent.jar
Binary files differ
diff --git a/current/support/recommendation/libs/android-support-recommendation.jar b/current/support/recommendation/libs/android-support-recommendation.jar
index 65ab56b..1a3f97d 100644
--- a/current/support/recommendation/libs/android-support-recommendation.jar
+++ b/current/support/recommendation/libs/android-support-recommendation.jar
Binary files differ
diff --git a/current/support/v13/android-support-v13.jar b/current/support/v13/android-support-v13.jar
index 0fda1ad..7c6a4ca 100644
--- a/current/support/v13/android-support-v13.jar
+++ b/current/support/v13/android-support-v13.jar
Binary files differ
diff --git a/current/support/v14/preference/libs/android-support-v14-preference.jar b/current/support/v14/preference/libs/android-support-v14-preference.jar
index c98338e..da9cc5b 100644
--- a/current/support/v14/preference/libs/android-support-v14-preference.jar
+++ b/current/support/v14/preference/libs/android-support-v14-preference.jar
Binary files differ
diff --git a/current/support/v14/preference/res/layout/preference_dropdown_material.xml b/current/support/v14/preference/res/layout/preference_dropdown_material.xml
new file mode 100644
index 0000000..d1ca64e
--- /dev/null
+++ b/current/support/v14/preference/res/layout/preference_dropdown_material.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <Spinner
+        android:id="@+id/spinner"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:visibility="invisible" />
+
+    <include layout="@layout/preference_material" />
+
+</FrameLayout>
diff --git a/current/support/v14/preference/res/values/styles.xml b/current/support/v14/preference/res/values/styles.xml
index c197121..a83417a 100644
--- a/current/support/v14/preference/res/values/styles.xml
+++ b/current/support/v14/preference/res/values/styles.xml
@@ -60,6 +60,10 @@
         <item name="android:layout">@layout/preference_material</item>
     </style>
 
+    <style name="Preference.DropDown.Material">
+        <item name="android:layout">@layout/preference_dropdown_material</item>
+    </style>
+
     <style name="Preference_TextAppearanceMaterialBody2">
         <item name="android:textSize">14sp</item>
         <item name="android:fontFamily">sans-serif</item>
diff --git a/current/support/v14/preference/res/values/themes.xml b/current/support/v14/preference/res/values/themes.xml
index 64bc91e..026d2d8 100644
--- a/current/support/v14/preference/res/values/themes.xml
+++ b/current/support/v14/preference/res/values/themes.xml
@@ -33,6 +33,7 @@
         <item name="switchPreferenceStyle">@style/Preference.SwitchPreference.Material</item>
         <item name="dialogPreferenceStyle">@style/Preference.DialogPreference.Material</item>
         <item name="editTextPreferenceStyle">@style/Preference.DialogPreference.EditTextPreference.Material</item>
+        <item name="dropdownPreferenceStyle">@style/Preference.DropDown.Material</item>
         <item name="preferenceFragmentListStyle">@style/PreferenceFragmentList.Material</item>
     </style>
 </resources>
diff --git a/current/support/v17/leanback/libs/android-support-v17-leanback.jar b/current/support/v17/leanback/libs/android-support-v17-leanback.jar
index b881033..94b2432 100644
--- a/current/support/v17/leanback/libs/android-support-v17-leanback.jar
+++ b/current/support/v17/leanback/libs/android-support-v17-leanback.jar
Binary files differ
diff --git a/current/support/v17/leanback/res/animator-v21/lb_guidedstep_slide_in_from_end.xml b/current/support/v17/leanback/res/animator-v21/lb_guidedstep_slide_in_from_end.xml
index df3aca2..1fe7109 100644
--- a/current/support/v17/leanback/res/animator-v21/lb_guidedstep_slide_in_from_end.xml
+++ b/current/support/v17/leanback/res/animator-v21/lb_guidedstep_slide_in_from_end.xml
@@ -33,4 +33,4 @@
         android:valueTo="1.0"
         android:valueType="floatType" />
 
-</set>
\ No newline at end of file
+</set>
diff --git a/current/support/v17/leanback/res/drawable-v21/lb_card_foreground.xml b/current/support/v17/leanback/res/drawable-v21/lb_card_foreground.xml
index 3cd9699..75ce912 100644
--- a/current/support/v17/leanback/res/drawable-v21/lb_card_foreground.xml
+++ b/current/support/v17/leanback/res/drawable-v21/lb_card_foreground.xml
@@ -17,4 +17,4 @@
 
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
     android:color="?android:attr/colorControlHighlight" >
-</ripple>
\ No newline at end of file
+</ripple>
diff --git a/current/support/v17/leanback/res/drawable-v21/lb_control_button_primary.xml b/current/support/v17/leanback/res/drawable-v21/lb_control_button_primary.xml
index a006889..4f91ff0 100644
--- a/current/support/v17/leanback/res/drawable-v21/lb_control_button_primary.xml
+++ b/current/support/v17/leanback/res/drawable-v21/lb_control_button_primary.xml
@@ -34,4 +34,4 @@
         </selector>
     </item>
 
-</ripple>
\ No newline at end of file
+</ripple>
diff --git a/current/support/v17/leanback/res/drawable-v21/lb_control_button_secondary.xml b/current/support/v17/leanback/res/drawable-v21/lb_control_button_secondary.xml
index 6623f6e..3beab65 100644
--- a/current/support/v17/leanback/res/drawable-v21/lb_control_button_secondary.xml
+++ b/current/support/v17/leanback/res/drawable-v21/lb_control_button_secondary.xml
@@ -34,4 +34,4 @@
         </selector>
     </item>
 
-</ripple>
\ No newline at end of file
+</ripple>
diff --git a/current/support/v17/leanback/res/layout/lb_control_button_primary.xml b/current/support/v17/leanback/res/layout/lb_control_button_primary.xml
index af94487..5da24e4 100644
--- a/current/support/v17/leanback/res/layout/lb_control_button_primary.xml
+++ b/current/support/v17/leanback/res/layout/lb_control_button_primary.xml
@@ -40,4 +40,4 @@
         android:layout_gravity="center"
         style="?attr/playbackControlButtonLabelStyle" />
 
-</FrameLayout>
\ No newline at end of file
+</FrameLayout>
diff --git a/current/support/v17/leanback/res/layout/lb_control_button_secondary.xml b/current/support/v17/leanback/res/layout/lb_control_button_secondary.xml
index 4d0cafd..39d5654 100644
--- a/current/support/v17/leanback/res/layout/lb_control_button_secondary.xml
+++ b/current/support/v17/leanback/res/layout/lb_control_button_secondary.xml
@@ -33,4 +33,4 @@
         android:layout_height="@dimen/lb_control_icon_height"
         android:layout_gravity="center" />
 
-</FrameLayout>
\ No newline at end of file
+</FrameLayout>
diff --git a/current/support/v17/leanback/res/layout/lb_guidedstep_fragment.xml b/current/support/v17/leanback/res/layout/lb_guidedstep_fragment.xml
index a41d47d..4ba182d 100644
--- a/current/support/v17/leanback/res/layout/lb_guidedstep_fragment.xml
+++ b/current/support/v17/leanback/res/layout/lb_guidedstep_fragment.xml
@@ -15,7 +15,8 @@
      limitations under the License.
 -->
 <!-- Layout for the frame of a 2 pane actions fragment. -->
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<android.support.v17.leanback.app.GuidedStepRootLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/guidedstep_root"
     android:orientation="horizontal"
     android:layout_width="match_parent"
@@ -68,4 +69,4 @@
         </android.support.v17.leanback.widget.NonOverlappingFrameLayout>
 
     </LinearLayout>
-</FrameLayout>
\ No newline at end of file
+</android.support.v17.leanback.app.GuidedStepRootLayout>
diff --git a/current/support/v17/leanback/res/layout/lb_image_card_view.xml b/current/support/v17/leanback/res/layout/lb_image_card_view.xml
index 1bc23f8..bd079a9 100644
--- a/current/support/v17/leanback/res/layout/lb_image_card_view.xml
+++ b/current/support/v17/leanback/res/layout/lb_image_card_view.xml
@@ -20,11 +20,11 @@
 
     <ImageView
         android:id="@+id/main_image"
-        style="?attr/lbImageCardViewImageStyle" />
+        style="?attr/imageCardViewImageStyle" />
 
     <android.support.v17.leanback.widget.NonOverlappingRelativeLayout
         android:id="@+id/info_field"
-        style="?attr/lbImageCardViewInfoAreaStyle">
+        style="?attr/imageCardViewInfoAreaStyle">
     </android.support.v17.leanback.widget.NonOverlappingRelativeLayout>
 
-</merge>
\ No newline at end of file
+</merge>
diff --git a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_left.xml b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_left.xml
index 35d2da6..6d40c07 100644
--- a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_left.xml
+++ b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_left.xml
@@ -20,4 +20,4 @@
     android:layout_alignBottom="@+id/content_text"
     android:layout_alignParentStart="true"
     android:layout_marginEnd="@dimen/lb_basic_card_info_badge_margin"
-    style="?attr/lbImageCardViewBadgeStyle" />
\ No newline at end of file
+    style="?attr/imageCardViewBadgeStyle" />
diff --git a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_right.xml b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_right.xml
index 02dd917..5672025 100644
--- a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_right.xml
+++ b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_badge_right.xml
@@ -20,4 +20,4 @@
     android:layout_alignBottom="@+id/content_text"
     android:layout_alignParentEnd="true"
     android:layout_marginStart="@dimen/lb_basic_card_info_badge_margin"
-    style="?attr/lbImageCardViewBadgeStyle" />
\ No newline at end of file
+    style="?attr/imageCardViewBadgeStyle" />
diff --git a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_content.xml b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_content.xml
index 5592371..08332f4 100644
--- a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_content.xml
+++ b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_content.xml
@@ -17,4 +17,4 @@
 
 <TextView xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/content_text"
-    style="?attr/lbImageCardViewContentStyle" />
+    style="?attr/imageCardViewContentStyle" />
diff --git a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_title.xml b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_title.xml
index 67e2493..8f2ca82 100644
--- a/current/support/v17/leanback/res/layout/lb_image_card_view_themed_title.xml
+++ b/current/support/v17/leanback/res/layout/lb_image_card_view_themed_title.xml
@@ -17,4 +17,4 @@
 
 <TextView xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/title_text"
-    style="?attr/lbImageCardViewTitleStyle" />
+    style="?attr/imageCardViewTitleStyle" />
diff --git a/current/support/v17/leanback/res/layout/lb_list_row_hovercard.xml b/current/support/v17/leanback/res/layout/lb_list_row_hovercard.xml
index a001dc9..73e3f5b 100644
--- a/current/support/v17/leanback/res/layout/lb_list_row_hovercard.xml
+++ b/current/support/v17/leanback/res/layout/lb_list_row_hovercard.xml
@@ -29,4 +29,4 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         style="?attr/rowHoverCardDescriptionStyle" />
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/current/support/v17/leanback/res/layout/lb_picker.xml b/current/support/v17/leanback/res/layout/lb_picker.xml
index 848434f..b11c051 100644
--- a/current/support/v17/leanback/res/layout/lb_picker.xml
+++ b/current/support/v17/leanback/res/layout/lb_picker.xml
@@ -14,20 +14,11 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/picker_frame"
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/picker"
     android:layout_width="fill_parent"
     android:layout_height="fill_parent"
-    android:gravity="center" >
-
-    <view
-        class="android.support.v17.leanback.widget.picker.Picker$ChildFocusAwareLinearLayout"
-        android:id="@+id/picker"
-        android:layout_width="fill_parent"
-        android:layout_height="fill_parent"
-        android:layout_gravity="center"
-        android:focusable="false"
-        android:gravity="center_vertical"
-        android:orientation="horizontal" />
-
-</RelativeLayout>
\ No newline at end of file
+    android:layout_gravity="center"
+    android:gravity="center_vertical"
+    android:orientation="horizontal" />
diff --git a/current/support/v17/leanback/res/layout/lb_picker_column.xml b/current/support/v17/leanback/res/layout/lb_picker_column.xml
index c2d3123..14b5af2 100644
--- a/current/support/v17/leanback/res/layout/lb_picker_column.xml
+++ b/current/support/v17/leanback/res/layout/lb_picker_column.xml
@@ -18,12 +18,8 @@
     xmlns:lb="http://schemas.android.com/apk/res-auto"
     android:id="@+id/column"
     android:layout_width="wrap_content"
-    android:layout_height="@dimen/picker_column_height"
+    android:layout_height="@dimen/picker_item_height"
     lb:columnWidth="wrap_content"
     android:clipToPadding="false"
-    android:enabled="true"
-    android:focusable="true"
     android:paddingStart="@dimen/picker_column_horizontal_padding"
-    android:paddingEnd="@dimen/picker_column_horizontal_padding"
-    lb:focusOutFront="false"
-    lb:focusOutEnd="false" />
+    android:paddingEnd="@dimen/picker_column_horizontal_padding" />
diff --git a/current/support/v17/leanback/res/layout/lb_picker_item.xml b/current/support/v17/leanback/res/layout/lb_picker_item.xml
index 3b8bcf7..55fd5df 100644
--- a/current/support/v17/leanback/res/layout/lb_picker_item.xml
+++ b/current/support/v17/leanback/res/layout/lb_picker_item.xml
@@ -19,5 +19,4 @@
     android:layout_width="wrap_content"
     android:layout_height="@dimen/picker_item_height"
     android:layout_centerHorizontal="true"
-    android:focusable="true"
     android:gravity="center" />
diff --git a/current/support/v17/leanback/res/layout/lb_playback_controls.xml b/current/support/v17/leanback/res/layout/lb_playback_controls.xml
index dda7e06..8ab938c 100644
--- a/current/support/v17/leanback/res/layout/lb_playback_controls.xml
+++ b/current/support/v17/leanback/res/layout/lb_playback_controls.xml
@@ -81,4 +81,4 @@
         </FrameLayout>
     </android.support.v17.leanback.widget.PersistentFocusWrapper>
 
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/current/support/v17/leanback/res/layout/lb_playback_controls_row.xml b/current/support/v17/leanback/res/layout/lb_playback_controls_row.xml
index a58840d..55ae539 100644
--- a/current/support/v17/leanback/res/layout/lb_playback_controls_row.xml
+++ b/current/support/v17/leanback/res/layout/lb_playback_controls_row.xml
@@ -88,4 +88,4 @@
         android:layout_width="match_parent"
         android:layout_height="@dimen/lb_playback_controls_margin_bottom" />
 
-</android.support.v17.leanback.widget.PlaybackControlsRowView>
\ No newline at end of file
+</android.support.v17.leanback.widget.PlaybackControlsRowView>
diff --git a/current/support/v17/leanback/res/layout/lb_row_container.xml b/current/support/v17/leanback/res/layout/lb_row_container.xml
index 31b0f58..450e7a8 100644
--- a/current/support/v17/leanback/res/layout/lb_row_container.xml
+++ b/current/support/v17/leanback/res/layout/lb_row_container.xml
@@ -23,4 +23,4 @@
     style="?attr/rowHeaderDockStyle"
     android:clipToPadding="false">
 </android.support.v17.leanback.widget.NonOverlappingLinearLayout>
-</merge>
\ No newline at end of file
+</merge>
diff --git a/current/support/v17/leanback/res/layout/lb_rows_fragment.xml b/current/support/v17/leanback/res/layout/lb_rows_fragment.xml
index 0a5112d..49ef79e 100644
--- a/current/support/v17/leanback/res/layout/lb_rows_fragment.xml
+++ b/current/support/v17/leanback/res/layout/lb_rows_fragment.xml
@@ -27,4 +27,4 @@
         android:clipToPadding="false"
         style="?attr/rowsVerticalGridStyle" />
 
-</android.support.v17.leanback.widget.ScaleFrameLayout>
\ No newline at end of file
+</android.support.v17.leanback.widget.ScaleFrameLayout>
diff --git a/current/support/v17/leanback/res/layout/lb_shadow.xml b/current/support/v17/leanback/res/layout/lb_shadow.xml
index af4e4aa..41a80d6 100644
--- a/current/support/v17/leanback/res/layout/lb_shadow.xml
+++ b/current/support/v17/leanback/res/layout/lb_shadow.xml
@@ -27,4 +27,4 @@
         android:background="@drawable/lb_card_shadow_focused"
         android:alpha="0" />
 
-</merge>
\ No newline at end of file
+</merge>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_browse_enter_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_browse_enter_transition.xml
index 4ad9888..f8de5ff 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_browse_enter_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_browse_enter_transition.xml
@@ -19,4 +19,4 @@
   <fade
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:duration="150"/>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_browse_entrance_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_browse_entrance_transition.xml
index 9dd440b..1457d65 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_browse_entrance_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_browse_entrance_transition.xml
@@ -25,4 +25,4 @@
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:slideEdge="@integer/slideEdgeEnd">
   </slide>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_browse_return_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_browse_return_transition.xml
index 6d341b5..4de8902 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_browse_return_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_browse_return_transition.xml
@@ -40,4 +40,4 @@
           <target android:excludeId="@+id/browse_headers_root" />
       </targets>
   </fade>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_details_enter_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_details_enter_transition.xml
index a9ebb3d..0497cf1 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_details_enter_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_details_enter_transition.xml
@@ -30,4 +30,4 @@
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:duration="350">
   </fade>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_details_return_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_details_return_transition.xml
index f31ebcb..134d0a3 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_details_return_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_details_return_transition.xml
@@ -29,4 +29,4 @@
       android:interpolator="@android:interpolator/fast_out_linear_in"
       android:duration="350">
   </fade>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_enter_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_enter_transition.xml
index 1572934..69ef9db 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_enter_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_enter_transition.xml
@@ -20,4 +20,4 @@
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:startDelay="175"
       android:duration="400"/>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_guidedstep_activity_enter.xml b/current/support/v17/leanback/res/transition-v21/lb_guidedstep_activity_enter.xml
index d92890d..b554e81 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_guidedstep_activity_enter.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_guidedstep_activity_enter.xml
@@ -49,4 +49,4 @@
             <target android:targetId="@id/guidedactions_list2" />
         </targets>
   </slide>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_shared_element_enter_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_shared_element_enter_transition.xml
index a671954..f442497 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_shared_element_enter_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_shared_element_enter_transition.xml
@@ -28,4 +28,4 @@
   <changeImageTransform
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:duration="500"/>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_shared_element_return_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_shared_element_return_transition.xml
index ee008e0..90ef1ad 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_shared_element_return_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_shared_element_return_transition.xml
@@ -29,4 +29,4 @@
   <changeImageTransform
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:duration="325"/>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_enter_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_enter_transition.xml
index 00466cb..fa2c493 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_enter_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_enter_transition.xml
@@ -19,4 +19,4 @@
   <fade
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:duration="150"/>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_entrance_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_entrance_transition.xml
index ee06953..81b480c 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_entrance_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_entrance_transition.xml
@@ -21,4 +21,4 @@
       android:interpolator="@android:interpolator/linear_out_slow_in"
       android:slideEdge="bottom">
   </slide>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_return_transition.xml b/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_return_transition.xml
index edb3816..463e701 100644
--- a/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_return_transition.xml
+++ b/current/support/v17/leanback/res/transition-v21/lb_vertical_grid_return_transition.xml
@@ -29,4 +29,4 @@
       android:interpolator="@android:interpolator/fast_out_linear_in"
       android:duration="350">
   </fade>
-</transitionSet>
\ No newline at end of file
+</transitionSet>
diff --git a/current/support/v17/leanback/res/values-af/strings.xml b/current/support/v17/leanback/res/values-af/strings.xml
index 0310403..aa12a88 100644
--- a/current/support/v17/leanback/res/values-af/strings.xml
+++ b/current/support/v17/leanback/res/values-af/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Deaktiveer onderskrifte"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Voltooi"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Gaan voort"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-am/strings.xml b/current/support/v17/leanback/res/values-am/strings.xml
index 77d2993..806c515 100644
--- a/current/support/v17/leanback/res/values-am/strings.xml
+++ b/current/support/v17/leanback/res/values-am/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ዝግ የምስል ስር ጽሑፍ አጻጻፍን አሰናክል"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ጨርስ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ቀጥል"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"፦"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ar/strings.xml b/current/support/v17/leanback/res/values-ar/strings.xml
index c52be7f..ee2b477 100644
--- a/current/support/v17/leanback/res/values-ar/strings.xml
+++ b/current/support/v17/leanback/res/values-ar/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"تعطيل الترجمة المصاحبة"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"إنهاء"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"متابعة"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-az-rAZ/strings.xml b/current/support/v17/leanback/res/values-az-rAZ/strings.xml
index cb558a0..fb4a7ad 100644
--- a/current/support/v17/leanback/res/values-az-rAZ/strings.xml
+++ b/current/support/v17/leanback/res/values-az-rAZ/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Qapalı çəkilişi deaktiv edin"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Bitir"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Davam edin"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-b+sr+Latn/strings.xml b/current/support/v17/leanback/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..d31310b
--- /dev/null
+++ b/current/support/v17/leanback/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+Copyright (C) 2014 The Android Open Source Project
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="orb_search_action" msgid="5651268540267663887">"Radnja pretrage"</string>
+    <string name="lb_search_bar_hint" msgid="8325490927970116252">"Pretražite"</string>
+    <string name="lb_search_bar_hint_speech" msgid="5511270823320183816">"Govorite da biste pretraživali"</string>
+    <string name="lb_search_bar_hint_with_title" msgid="1627103380996590035">"Pretražite <xliff:g id="SEARCH_CONTEXT">%1$s</xliff:g>"</string>
+    <string name="lb_search_bar_hint_with_title_speech" msgid="2712734639766312034">"Izgovorite da biste pretražili <xliff:g id="SEARCH_CONTEXT">%1$s</xliff:g>"</string>
+    <string name="lb_control_display_fast_forward_multiplier" msgid="4541442045214207774">"%1$dX"</string>
+    <string name="lb_control_display_rewind_multiplier" msgid="3097220783222910245">"%1$dX"</string>
+    <string name="lb_playback_controls_play" msgid="731953341987346903">"Pusti"</string>
+    <string name="lb_playback_controls_pause" msgid="6189521112079849518">"Pauziraj"</string>
+    <string name="lb_playback_controls_fast_forward" msgid="8569951318244687220">"Premotaj unapred"</string>
+    <string name="lb_playback_controls_fast_forward_multiplier" msgid="1058753672110224526">"Premotaj unapred %1$dX"</string>
+    <string name="lb_playback_controls_rewind" msgid="2227196334132350684">"Premotaj unazad"</string>
+    <string name="lb_playback_controls_rewind_multiplier" msgid="1640629531440849942">"Premotaj unazad %1$dX"</string>
+    <string name="lb_playback_controls_skip_next" msgid="2946499493161095772">"Preskoči sledeću"</string>
+    <string name="lb_playback_controls_skip_previous" msgid="2326801832933178348">"Preskoči prethodnu"</string>
+    <string name="lb_playback_controls_more_actions" msgid="2330770008796987655">"Još radnji"</string>
+    <string name="lb_playback_controls_thumb_up" msgid="6530420347129222601">"Opozovi izbor palca nagore"</string>
+    <string name="lb_playback_controls_thumb_up_outline" msgid="1577637924003500946">"Izaberi palac nagore"</string>
+    <string name="lb_playback_controls_thumb_down" msgid="4498041193172964797">"Opozovi izbor palca nadole"</string>
+    <string name="lb_playback_controls_thumb_down_outline" msgid="2936020280629424365">"Izaberi palac nadole"</string>
+    <string name="lb_playback_controls_repeat_none" msgid="87476947476529036">"Ne ponavljaj nijednu"</string>
+    <string name="lb_playback_controls_repeat_all" msgid="6730354406289599000">"Ponovi sve"</string>
+    <string name="lb_playback_controls_repeat_one" msgid="3285202316452203619">"Ponovi jednu"</string>
+    <string name="lb_playback_controls_shuffle_enable" msgid="1099874107835264529">"Omogući nasumičnu reprodukciju"</string>
+    <string name="lb_playback_controls_shuffle_disable" msgid="8388150597335115226">"Onemogući nasumičnu reprodukciju"</string>
+    <string name="lb_playback_controls_high_quality_enable" msgid="202415780019335254">"Omogući visok kvalitet"</string>
+    <string name="lb_playback_controls_high_quality_disable" msgid="8637371582779057866">"Onemogući visok kvalitet"</string>
+    <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Omogući titlove"</string>
+    <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Onemogući titlove"</string>
+    <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Dovrši"</string>
+    <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Nastavi"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
+</resources>
diff --git a/current/support/v17/leanback/res/values-bg/strings.xml b/current/support/v17/leanback/res/values-bg/strings.xml
index 6b16775..d3f29e7 100644
--- a/current/support/v17/leanback/res/values-bg/strings.xml
+++ b/current/support/v17/leanback/res/values-bg/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Деактивиране на субтитрите"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Край"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Напред"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-bn-rBD/strings.xml b/current/support/v17/leanback/res/values-bn-rBD/strings.xml
index 04669bd..a0c5d80 100644
--- a/current/support/v17/leanback/res/values-bn-rBD/strings.xml
+++ b/current/support/v17/leanback/res/values-bn-rBD/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"সাবটাইটেল অক্ষম করুন"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"শেষ করুন"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"চালিয়ে যান"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ca/strings.xml b/current/support/v17/leanback/res/values-ca/strings.xml
index 6578f3b..d211dd3 100644
--- a/current/support/v17/leanback/res/values-ca/strings.xml
+++ b/current/support/v17/leanback/res/values-ca/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Desactiva els subtítols tancats"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finalitza"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continua"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-cs/strings.xml b/current/support/v17/leanback/res/values-cs/strings.xml
index 8ffb4f3..496f4b5 100644
--- a/current/support/v17/leanback/res/values-cs/strings.xml
+++ b/current/support/v17/leanback/res/values-cs/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Vypnout titulky"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Dokončit"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Pokračovat"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-da/strings.xml b/current/support/v17/leanback/res/values-da/strings.xml
index 87c507b..d2a8402 100644
--- a/current/support/v17/leanback/res/values-da/strings.xml
+++ b/current/support/v17/leanback/res/values-da/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Deaktiver undertekster"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Afslut"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Fortsæt"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-de/strings.xml b/current/support/v17/leanback/res/values-de/strings.xml
index 9d018c6..3467150 100644
--- a/current/support/v17/leanback/res/values-de/strings.xml
+++ b/current/support/v17/leanback/res/values-de/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Untertitel deaktivieren"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Fertigstellen"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Weiter"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-el/strings.xml b/current/support/v17/leanback/res/values-el/strings.xml
index 310b6a9..8cbbc2d 100644
--- a/current/support/v17/leanback/res/values-el/strings.xml
+++ b/current/support/v17/leanback/res/values-el/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Απενεργοποίηση υποτίτλων"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Τέλος"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Συνέχεια"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-en-rAU/strings.xml b/current/support/v17/leanback/res/values-en-rAU/strings.xml
index 0097135..7be00fa 100644
--- a/current/support/v17/leanback/res/values-en-rAU/strings.xml
+++ b/current/support/v17/leanback/res/values-en-rAU/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Disable Closed Captioning"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finish"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continue"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-en-rGB/strings.xml b/current/support/v17/leanback/res/values-en-rGB/strings.xml
index 0097135..7be00fa 100644
--- a/current/support/v17/leanback/res/values-en-rGB/strings.xml
+++ b/current/support/v17/leanback/res/values-en-rGB/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Disable Closed Captioning"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finish"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continue"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-en-rIN/strings.xml b/current/support/v17/leanback/res/values-en-rIN/strings.xml
index 0097135..7be00fa 100644
--- a/current/support/v17/leanback/res/values-en-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-en-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Disable Closed Captioning"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finish"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continue"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-es-rUS/strings.xml b/current/support/v17/leanback/res/values-es-rUS/strings.xml
index 8341a4d..a7bfac5 100644
--- a/current/support/v17/leanback/res/values-es-rUS/strings.xml
+++ b/current/support/v17/leanback/res/values-es-rUS/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Inhabilitar subtítulos"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finalizar"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuar"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-es/strings.xml b/current/support/v17/leanback/res/values-es/strings.xml
index 9f308c0..91e6b1f 100644
--- a/current/support/v17/leanback/res/values-es/strings.xml
+++ b/current/support/v17/leanback/res/values-es/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Inhabilitar subtítulos"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finalizar"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuar"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-et-rEE/strings.xml b/current/support/v17/leanback/res/values-et-rEE/strings.xml
index a97c385..fc62de1 100644
--- a/current/support/v17/leanback/res/values-et-rEE/strings.xml
+++ b/current/support/v17/leanback/res/values-et-rEE/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Keela subtiitrid"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Lõpeta"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Jätka"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-eu-rES/strings.xml b/current/support/v17/leanback/res/values-eu-rES/strings.xml
index c22f172..40819ab 100644
--- a/current/support/v17/leanback/res/values-eu-rES/strings.xml
+++ b/current/support/v17/leanback/res/values-eu-rES/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Desgaitu azpitituluak"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Amaitu"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Jarraitu"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-fa/strings.xml b/current/support/v17/leanback/res/values-fa/strings.xml
index 58e823f..ee4a3cb 100644
--- a/current/support/v17/leanback/res/values-fa/strings.xml
+++ b/current/support/v17/leanback/res/values-fa/strings.xml
@@ -25,7 +25,7 @@
     <string name="lb_control_display_fast_forward_multiplier" msgid="4541442045214207774">"%1$dX"</string>
     <string name="lb_control_display_rewind_multiplier" msgid="3097220783222910245">"%1$dX"</string>
     <string name="lb_playback_controls_play" msgid="731953341987346903">"پخش"</string>
-    <string name="lb_playback_controls_pause" msgid="6189521112079849518">"توقف موقت"</string>
+    <string name="lb_playback_controls_pause" msgid="6189521112079849518">"مکث"</string>
     <string name="lb_playback_controls_fast_forward" msgid="8569951318244687220">"جلو بردن سریع"</string>
     <string name="lb_playback_controls_fast_forward_multiplier" msgid="1058753672110224526">"‏بازارسال سریع %1$dX"</string>
     <string name="lb_playback_controls_rewind" msgid="2227196334132350684">"عقب بردن"</string>
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"غیرفعال کردن زیرنویس"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"پایان"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ادامه"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-fi/strings.xml b/current/support/v17/leanback/res/values-fi/strings.xml
index 0c55e6f..2e182f3 100644
--- a/current/support/v17/leanback/res/values-fi/strings.xml
+++ b/current/support/v17/leanback/res/values-fi/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Poista tekstitys käytöstä"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Valmis"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Jatka"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"."</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-fr-rCA/strings.xml b/current/support/v17/leanback/res/values-fr-rCA/strings.xml
index b28beae..073601b 100644
--- a/current/support/v17/leanback/res/values-fr-rCA/strings.xml
+++ b/current/support/v17/leanback/res/values-fr-rCA/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Désactiver le sous-titrage"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Terminer"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuer"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-fr/strings.xml b/current/support/v17/leanback/res/values-fr/strings.xml
index 914bf08..9d4d9f7 100644
--- a/current/support/v17/leanback/res/values-fr/strings.xml
+++ b/current/support/v17/leanback/res/values-fr/strings.xml
@@ -33,10 +33,10 @@
     <string name="lb_playback_controls_skip_next" msgid="2946499493161095772">"Ignorer l\'élément suivant"</string>
     <string name="lb_playback_controls_skip_previous" msgid="2326801832933178348">"Ignorer l\'élément précédent"</string>
     <string name="lb_playback_controls_more_actions" msgid="2330770008796987655">"Autres actions"</string>
-    <string name="lb_playback_controls_thumb_up" msgid="6530420347129222601">"Désélectionner \"J\'aime\""</string>
-    <string name="lb_playback_controls_thumb_up_outline" msgid="1577637924003500946">"Sélectionner \"J\'aime\""</string>
-    <string name="lb_playback_controls_thumb_down" msgid="4498041193172964797">"Désélectionner \"Je n\'aime pas\""</string>
-    <string name="lb_playback_controls_thumb_down_outline" msgid="2936020280629424365">"Sélectionner \"Je n\'aime pas\""</string>
+    <string name="lb_playback_controls_thumb_up" msgid="6530420347129222601">"Annuler +1"</string>
+    <string name="lb_playback_controls_thumb_up_outline" msgid="1577637924003500946">"Sélectionner +1"</string>
+    <string name="lb_playback_controls_thumb_down" msgid="4498041193172964797">"Annuler -1"</string>
+    <string name="lb_playback_controls_thumb_down_outline" msgid="2936020280629424365">"Sélectionner -1"</string>
     <string name="lb_playback_controls_repeat_none" msgid="87476947476529036">"Ne rien lire en boucle"</string>
     <string name="lb_playback_controls_repeat_all" msgid="6730354406289599000">"Tout lire en boucle"</string>
     <string name="lb_playback_controls_repeat_one" msgid="3285202316452203619">"Lire en boucle un élément"</string>
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Désactiver les sous-titres"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Terminer"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuer"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-gl-rES/strings.xml b/current/support/v17/leanback/res/values-gl-rES/strings.xml
index 62b3a2b..d8d9656 100644
--- a/current/support/v17/leanback/res/values-gl-rES/strings.xml
+++ b/current/support/v17/leanback/res/values-gl-rES/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Desactivar subtítulos"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finalizar"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuar"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-gu-rIN/strings.xml b/current/support/v17/leanback/res/values-gu-rIN/strings.xml
index afec9da..d295a2f 100644
--- a/current/support/v17/leanback/res/values-gu-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-gu-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"વિગતવાર ઉપશીર્ષકોને અક્ષમ કરો"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"સમાપ્ત કરો"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ચાલુ રાખો"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-hi/strings.xml b/current/support/v17/leanback/res/values-hi/strings.xml
index c243c17..f4764e8 100644
--- a/current/support/v17/leanback/res/values-hi/strings.xml
+++ b/current/support/v17/leanback/res/values-hi/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"उपशीर्षक अक्षम करें"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"समाप्त करें"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"जारी रखें"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-hr/strings.xml b/current/support/v17/leanback/res/values-hr/strings.xml
index bb6ebcc..17799e3 100644
--- a/current/support/v17/leanback/res/values-hr/strings.xml
+++ b/current/support/v17/leanback/res/values-hr/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Onemogući titlove"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Završi"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Nastavi"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"."</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-hu/strings.xml b/current/support/v17/leanback/res/values-hu/strings.xml
index cfeb2ad..c8efddb 100644
--- a/current/support/v17/leanback/res/values-hu/strings.xml
+++ b/current/support/v17/leanback/res/values-hu/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Feliratok letiltása"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Befejezés"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Folytatás"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-hy-rAM/strings.xml b/current/support/v17/leanback/res/values-hy-rAM/strings.xml
index 1ac5dd8..8b9e552 100644
--- a/current/support/v17/leanback/res/values-hy-rAM/strings.xml
+++ b/current/support/v17/leanback/res/values-hy-rAM/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Անջատել խորագրերը"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Վերջ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Շարունակել"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-in/strings.xml b/current/support/v17/leanback/res/values-in/strings.xml
index 6569825..75e8aba 100644
--- a/current/support/v17/leanback/res/values-in/strings.xml
+++ b/current/support/v17/leanback/res/values-in/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Nonaktifkan Pembuatan Teks"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Selesai"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Lanjutkan"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"."</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-is-rIS/strings.xml b/current/support/v17/leanback/res/values-is-rIS/strings.xml
index 830b11e..25245f4 100644
--- a/current/support/v17/leanback/res/values-is-rIS/strings.xml
+++ b/current/support/v17/leanback/res/values-is-rIS/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Slökkva á skjátextum"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Ljúka"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Halda áfram"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-it/strings.xml b/current/support/v17/leanback/res/values-it/strings.xml
index 2f0ca47..219ca30 100644
--- a/current/support/v17/leanback/res/values-it/strings.xml
+++ b/current/support/v17/leanback/res/values-it/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Disattiva sottotitoli"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Fine"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continua"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-iw/strings.xml b/current/support/v17/leanback/res/values-iw/strings.xml
index f2bda58..53b3ec9 100644
--- a/current/support/v17/leanback/res/values-iw/strings.xml
+++ b/current/support/v17/leanback/res/values-iw/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"השבת כתוביות"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"סיום"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"המשך"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ja/strings.xml b/current/support/v17/leanback/res/values-ja/strings.xml
index 09faa8b..911f27e 100644
--- a/current/support/v17/leanback/res/values-ja/strings.xml
+++ b/current/support/v17/leanback/res/values-ja/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"字幕を無効にする"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完了"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"続行"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ka-rGE/strings.xml b/current/support/v17/leanback/res/values-ka-rGE/strings.xml
index ac9f4cd..ca921a9 100644
--- a/current/support/v17/leanback/res/values-ka-rGE/strings.xml
+++ b/current/support/v17/leanback/res/values-ka-rGE/strings.xml
@@ -52,4 +52,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"დახურული წარწერების გაუქმება"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"დასრულება"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"გაგრძელება"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-kk-rKZ/strings.xml b/current/support/v17/leanback/res/values-kk-rKZ/strings.xml
index 380695b..f3f3d14 100644
--- a/current/support/v17/leanback/res/values-kk-rKZ/strings.xml
+++ b/current/support/v17/leanback/res/values-kk-rKZ/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Жасырын титрлерді өшіру"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Аяқтау"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Жалғастыру"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-km-rKH/strings.xml b/current/support/v17/leanback/res/values-km-rKH/strings.xml
index 60f90e5..f6bfb42 100644
--- a/current/support/v17/leanback/res/values-km-rKH/strings.xml
+++ b/current/support/v17/leanback/res/values-km-rKH/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"បិទ​ការ​ដាក់​ចំណង​ដែល​បាន​បិទ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"បញ្ចប់"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"បន្ត"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"៖"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-kn-rIN/strings.xml b/current/support/v17/leanback/res/values-kn-rIN/strings.xml
index 18206ed..0de7c79 100644
--- a/current/support/v17/leanback/res/values-kn-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-kn-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ಮುಚ್ಚಿದ ಶೀರ್ಷಿಕೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ಪೂರ್ಣಗೊಳಿಸು"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ಮುಂದುವರಿಸು"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ko/strings.xml b/current/support/v17/leanback/res/values-ko/strings.xml
index e262b1c..2d09881 100644
--- a/current/support/v17/leanback/res/values-ko/strings.xml
+++ b/current/support/v17/leanback/res/values-ko/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"자막 사용 중지"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"완료"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"계속"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ky-rKG/strings.xml b/current/support/v17/leanback/res/values-ky-rKG/strings.xml
index 74cc841..59329cc 100644
--- a/current/support/v17/leanback/res/values-ky-rKG/strings.xml
+++ b/current/support/v17/leanback/res/values-ky-rKG/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Жабык субтитрлерди өчүрүү"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Бүтүрүү"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Улантуу"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ldrtl/integers.xml b/current/support/v17/leanback/res/values-ldrtl/integers.xml
index 250523d..a052a9c 100644
--- a/current/support/v17/leanback/res/values-ldrtl/integers.xml
+++ b/current/support/v17/leanback/res/values-ldrtl/integers.xml
@@ -21,4 +21,4 @@
     <!-- Gravity.LEFT -->
     <integer name="slideEdgeEnd">3</integer>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v17/leanback/res/values-lo-rLA/strings.xml b/current/support/v17/leanback/res/values-lo-rLA/strings.xml
index d919e93..84af3e2 100644
--- a/current/support/v17/leanback/res/values-lo-rLA/strings.xml
+++ b/current/support/v17/leanback/res/values-lo-rLA/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"​ປິດ​ນຳ​ໃຊ້​ຄຳ​ບັນ​ຍາຍ​ແບບ​ປິດ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ສໍາເລັດ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"​ສືບ​ຕໍ່"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-lt/strings.xml b/current/support/v17/leanback/res/values-lt/strings.xml
index 415fc25..3b0bd19 100644
--- a/current/support/v17/leanback/res/values-lt/strings.xml
+++ b/current/support/v17/leanback/res/values-lt/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Išjungti subtitrus"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Baigti"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Tęsti"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-lv/strings.xml b/current/support/v17/leanback/res/values-lv/strings.xml
index 3979e43..eb157de 100644
--- a/current/support/v17/leanback/res/values-lv/strings.xml
+++ b/current/support/v17/leanback/res/values-lv/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Atspējot slēgtos parakstus"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Pabeigt"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Turpināt"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-mk-rMK/strings.xml b/current/support/v17/leanback/res/values-mk-rMK/strings.xml
index ccf6d62..41aca2b 100644
--- a/current/support/v17/leanback/res/values-mk-rMK/strings.xml
+++ b/current/support/v17/leanback/res/values-mk-rMK/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Оневозможи затворено објаснување"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Заврши"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Продолжи"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ml-rIN/strings.xml b/current/support/v17/leanback/res/values-ml-rIN/strings.xml
index 356b0e9..d24a3d2 100644
--- a/current/support/v17/leanback/res/values-ml-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-ml-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"അടച്ച അടിക്കുറിപ്പ് നൽകൽ പ്രവർത്തനരഹിതമാക്കുക"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"പൂര്‍ത്തിയാക്കുക"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"തുടരുക"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-mn-rMN/strings.xml b/current/support/v17/leanback/res/values-mn-rMN/strings.xml
index a7a640f..9f0e1bf 100644
--- a/current/support/v17/leanback/res/values-mn-rMN/strings.xml
+++ b/current/support/v17/leanback/res/values-mn-rMN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Текст тайлбарыг идэвхгүйжүүлэх"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Дуусгах"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Үргэлжлүүлэх"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-mr-rIN/strings.xml b/current/support/v17/leanback/res/values-mr-rIN/strings.xml
index b9b568a..83b583a 100644
--- a/current/support/v17/leanback/res/values-mr-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-mr-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"उपशीर्षके अक्षम करा"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"समाप्त"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"सुरू ठेवा"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ms-rMY/strings.xml b/current/support/v17/leanback/res/values-ms-rMY/strings.xml
index 0a5f8bd..1c12999 100644
--- a/current/support/v17/leanback/res/values-ms-rMY/strings.xml
+++ b/current/support/v17/leanback/res/values-ms-rMY/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Lumpuhkan Kapsyen Tertutup"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Selesai"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Teruskan"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-my-rMM/strings.xml b/current/support/v17/leanback/res/values-my-rMM/strings.xml
index 1b3cdee..6e0e577 100644
--- a/current/support/v17/leanback/res/values-my-rMM/strings.xml
+++ b/current/support/v17/leanback/res/values-my-rMM/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"စာတမ်းထိုးအား ပိတ်ထားရန်"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ပြီးပြီ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ဆက်လုပ်ရန်"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"−"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-nb/strings.xml b/current/support/v17/leanback/res/values-nb/strings.xml
index c58544d..f561f0e 100644
--- a/current/support/v17/leanback/res/values-nb/strings.xml
+++ b/current/support/v17/leanback/res/values-nb/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Deaktiver teksting"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Fullfør"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Fortsett"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">"."</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ne-rNP/strings.xml b/current/support/v17/leanback/res/values-ne-rNP/strings.xml
index 54c9285..4e7a473 100644
--- a/current/support/v17/leanback/res/values-ne-rNP/strings.xml
+++ b/current/support/v17/leanback/res/values-ne-rNP/strings.xml
@@ -50,4 +50,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"बन्द क्याप्सनहरु असक्षम"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"समाप्त गर्नुहोस्"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"जारी राख्नुहोस्"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-nl/strings.xml b/current/support/v17/leanback/res/values-nl/strings.xml
index 941aa79..a4bc09b 100644
--- a/current/support/v17/leanback/res/values-nl/strings.xml
+++ b/current/support/v17/leanback/res/values-nl/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Ondertiteling uitschakelen"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Voltooien"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Doorgaan"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"-"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-pa-rIN/strings.xml b/current/support/v17/leanback/res/values-pa-rIN/strings.xml
index f197657..17d02cd 100644
--- a/current/support/v17/leanback/res/values-pa-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-pa-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ਬੰਦ ਕੈਪਸ਼ਨਿੰਗ ਅਸਮਰੱਥ ਬਣਾਓ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ਖ਼ਤਮ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ਜਾਰੀ ਰੱਖੋ"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-pl/strings.xml b/current/support/v17/leanback/res/values-pl/strings.xml
index 7598c73..bd05ef4 100644
--- a/current/support/v17/leanback/res/values-pl/strings.xml
+++ b/current/support/v17/leanback/res/values-pl/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Wyłącz napisy"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Zakończ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Dalej"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-pt-rBR/strings.xml b/current/support/v17/leanback/res/values-pt-rBR/strings.xml
index 12c9533..6ff65c1 100644
--- a/current/support/v17/leanback/res/values-pt-rBR/strings.xml
+++ b/current/support/v17/leanback/res/values-pt-rBR/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Desativar closed captioning"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Concluir"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuar"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-pt-rPT/strings.xml b/current/support/v17/leanback/res/values-pt-rPT/strings.xml
index 7b12f5e..8a21baa 100644
--- a/current/support/v17/leanback/res/values-pt-rPT/strings.xml
+++ b/current/support/v17/leanback/res/values-pt-rPT/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Desativar legendas"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Concluir"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuar"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-pt/strings.xml b/current/support/v17/leanback/res/values-pt/strings.xml
index 12c9533..6ff65c1 100644
--- a/current/support/v17/leanback/res/values-pt/strings.xml
+++ b/current/support/v17/leanback/res/values-pt/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Desativar closed captioning"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Concluir"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuar"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ro/strings.xml b/current/support/v17/leanback/res/values-ro/strings.xml
index b4f9ee3..f19b587 100644
--- a/current/support/v17/leanback/res/values-ro/strings.xml
+++ b/current/support/v17/leanback/res/values-ro/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Dezactivează subtitrările"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Finalizați"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Continuați"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ru/strings.xml b/current/support/v17/leanback/res/values-ru/strings.xml
index 864054a..adbe8a1 100644
--- a/current/support/v17/leanback/res/values-ru/strings.xml
+++ b/current/support/v17/leanback/res/values-ru/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Отключить субтитры."</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Готово"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Далее"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-si-rLK/strings.xml b/current/support/v17/leanback/res/values-si-rLK/strings.xml
index 3db1293..41ccb31 100644
--- a/current/support/v17/leanback/res/values-si-rLK/strings.xml
+++ b/current/support/v17/leanback/res/values-si-rLK/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"වැසුණු ශිර්ෂ කිරීම අබල කරන ලදි"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"අවසානය"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"දිගටම කර ගෙන යන්න"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-sk/strings.xml b/current/support/v17/leanback/res/values-sk/strings.xml
index a317d18..fb4e24b 100644
--- a/current/support/v17/leanback/res/values-sk/strings.xml
+++ b/current/support/v17/leanback/res/values-sk/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Vypnúť skryté titulky"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Dokončiť"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Pokračovať"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-sl/strings.xml b/current/support/v17/leanback/res/values-sl/strings.xml
index 7b16952..9b216f2 100644
--- a/current/support/v17/leanback/res/values-sl/strings.xml
+++ b/current/support/v17/leanback/res/values-sl/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Onemogoči podnapise"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Dokončaj"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Naprej"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-sq-rAL/strings.xml b/current/support/v17/leanback/res/values-sq-rAL/strings.xml
index 723b90c..bc981f3 100644
--- a/current/support/v17/leanback/res/values-sq-rAL/strings.xml
+++ b/current/support/v17/leanback/res/values-sq-rAL/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Çaktivizo titrat me sekuencë kohore"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Përfundo"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Vazhdo"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-sr/strings.xml b/current/support/v17/leanback/res/values-sr/strings.xml
index df6c6b1..3423efe 100644
--- a/current/support/v17/leanback/res/values-sr/strings.xml
+++ b/current/support/v17/leanback/res/values-sr/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Онемогући титлове"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Доврши"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Настави"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-sv/strings.xml b/current/support/v17/leanback/res/values-sv/strings.xml
index 9b874ca..3bcd4ae 100644
--- a/current/support/v17/leanback/res/values-sv/strings.xml
+++ b/current/support/v17/leanback/res/values-sv/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Inaktivera textning"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Slutför"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Fortsätt"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-sw/strings.xml b/current/support/v17/leanback/res/values-sw/strings.xml
index 53ef95a..b984d94 100644
--- a/current/support/v17/leanback/res/values-sw/strings.xml
+++ b/current/support/v17/leanback/res/values-sw/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Zima manukuu"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Kamilisha"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Endelea"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ta-rIN/strings.xml b/current/support/v17/leanback/res/values-ta-rIN/strings.xml
index 1cc2eea..5402062 100644
--- a/current/support/v17/leanback/res/values-ta-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-ta-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"விரிவான வசனங்களை முடக்கு"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"முடி"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"தொடர்க"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-te-rIN/strings.xml b/current/support/v17/leanback/res/values-te-rIN/strings.xml
index 32d311d..064d3cf 100644
--- a/current/support/v17/leanback/res/values-te-rIN/strings.xml
+++ b/current/support/v17/leanback/res/values-te-rIN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"సంవృత శీర్షికలను నిలిపివేయి"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ముగించు"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"కొనసాగించు"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-th/strings.xml b/current/support/v17/leanback/res/values-th/strings.xml
index d3eb2a3..c85d870 100644
--- a/current/support/v17/leanback/res/values-th/strings.xml
+++ b/current/support/v17/leanback/res/values-th/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ปิดใช้คำบรรยาย"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"เสร็จสิ้น"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ต่อไป"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-tl/strings.xml b/current/support/v17/leanback/res/values-tl/strings.xml
index f50b4d1..fb8610e 100644
--- a/current/support/v17/leanback/res/values-tl/strings.xml
+++ b/current/support/v17/leanback/res/values-tl/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"I-disable ang Paglalagay ng Subtitle"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Tapusin"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Magpatuloy"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-tr/strings.xml b/current/support/v17/leanback/res/values-tr/strings.xml
index 814cb29..fb639bc 100644
--- a/current/support/v17/leanback/res/values-tr/strings.xml
+++ b/current/support/v17/leanback/res/values-tr/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Altyazıları Devre Dışı Bırak"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Son"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Devam"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-uk/strings.xml b/current/support/v17/leanback/res/values-uk/strings.xml
index a38db30..20a4127 100644
--- a/current/support/v17/leanback/res/values-uk/strings.xml
+++ b/current/support/v17/leanback/res/values-uk/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Вимкнути субтитри"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Закінчити"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Продовжити"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-ur-rPK/strings.xml b/current/support/v17/leanback/res/values-ur-rPK/strings.xml
index 666cf71..cad5f93 100644
--- a/current/support/v17/leanback/res/values-ur-rPK/strings.xml
+++ b/current/support/v17/leanback/res/values-ur-rPK/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"سب ٹائٹلز کو غیر فعال کریں"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"مکمل کریں"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"جاری رکھیں"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-uz-rUZ/strings.xml b/current/support/v17/leanback/res/values-uz-rUZ/strings.xml
index d81d8de..c280461 100644
--- a/current/support/v17/leanback/res/values-uz-rUZ/strings.xml
+++ b/current/support/v17/leanback/res/values-uz-rUZ/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Taglavhalarni o‘chirib qo‘yish"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Tugatish"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Davom etish"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-v21/styles.xml b/current/support/v17/leanback/res/values-v21/styles.xml
index 89029c4..85ead74 100644
--- a/current/support/v17/leanback/res/values-v21/styles.xml
+++ b/current/support/v17/leanback/res/values-v21/styles.xml
@@ -25,4 +25,4 @@
         <item name="android:background">@drawable/lb_action_bg</item>
     </style>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v17/leanback/res/values-v22/integers.xml b/current/support/v17/leanback/res/values-v22/integers.xml
index fdd7792..b8bbe89 100644
--- a/current/support/v17/leanback/res/values-v22/integers.xml
+++ b/current/support/v17/leanback/res/values-v22/integers.xml
@@ -21,4 +21,4 @@
     <!-- Gravity.END -->
     <integer name="slideEdgeEnd">0x800005</integer>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v17/leanback/res/values-vi/strings.xml b/current/support/v17/leanback/res/values-vi/strings.xml
index 881734b..c84965e 100644
--- a/current/support/v17/leanback/res/values-vi/strings.xml
+++ b/current/support/v17/leanback/res/values-vi/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Tắt phụ đề"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Hoàn tất"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Tiếp tục"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-zh-rCN/strings.xml b/current/support/v17/leanback/res/values-zh-rCN/strings.xml
index fc3fa10..d2bc960 100644
--- a/current/support/v17/leanback/res/values-zh-rCN/strings.xml
+++ b/current/support/v17/leanback/res/values-zh-rCN/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"关闭字幕"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完成"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"继续"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-zh-rHK/strings.xml b/current/support/v17/leanback/res/values-zh-rHK/strings.xml
index 7cba4b5..953064f 100644
--- a/current/support/v17/leanback/res/values-zh-rHK/strings.xml
+++ b/current/support/v17/leanback/res/values-zh-rHK/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"停用字幕"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完成"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"繼續"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-zh-rTW/strings.xml b/current/support/v17/leanback/res/values-zh-rTW/strings.xml
index dcca2db..9d1e00b 100644
--- a/current/support/v17/leanback/res/values-zh-rTW/strings.xml
+++ b/current/support/v17/leanback/res/values-zh-rTW/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"停用字幕"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完成"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"繼續"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values-zu/strings.xml b/current/support/v17/leanback/res/values-zu/strings.xml
index f4c589d..b12035d 100644
--- a/current/support/v17/leanback/res/values-zu/strings.xml
+++ b/current/support/v17/leanback/res/values-zu/strings.xml
@@ -48,4 +48,6 @@
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Khubaza imihbalo engezansi"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Qeda"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Qhubeka"</string>
+    <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
+    <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
 </resources>
diff --git a/current/support/v17/leanback/res/values/attrs.xml b/current/support/v17/leanback/res/values/attrs.xml
index b2f846d..142ba16 100644
--- a/current/support/v17/leanback/res/values/attrs.xml
+++ b/current/support/v17/leanback/res/values/attrs.xml
@@ -126,14 +126,8 @@
     </declare-styleable>
 
     <declare-styleable name="lbImageCardView">
-        <!-- Deprecated. Use 'lbImageCardViewInfoAreaStyle' instead. -->
+        <!-- Deprecated. Use 'imageCardViewInfoAreaStyle' instead. -->
         <attr name="infoAreaBackground" format="reference|color"/>
-        <!-- Use these attributes to override a ImageCardView's component style. -->
-        <attr name="lbImageCardViewImageStyle" format="reference" />
-        <attr name="lbImageCardViewTitleStyle" format="reference" />
-        <attr name="lbImageCardViewContentStyle" format="reference" />
-        <attr name="lbImageCardViewBadgeStyle" format="reference" />
-        <attr name="lbImageCardViewInfoAreaStyle" format="reference" />
         <!-- Defines what components the ImageCardView will use. -->
         <attr name="lbImageCardViewType">
             <flag name="Title" value="1" />
@@ -260,6 +254,11 @@
         <!-- CardView styles -->
         <attr name="baseCardViewStyle" format="reference" />
         <attr name="imageCardViewStyle" format="reference" />
+        <attr name="imageCardViewImageStyle" format="reference" />
+        <attr name="imageCardViewTitleStyle" format="reference" />
+        <attr name="imageCardViewContentStyle" format="reference" />
+        <attr name="imageCardViewBadgeStyle" format="reference" />
+        <attr name="imageCardViewInfoAreaStyle" format="reference" />
 
         <!-- for details overviews -->
         <attr name="detailsDescriptionTitleStyle" format="reference" />
@@ -486,4 +485,4 @@
         <attr name="datePickerFormat" format="string"/>
     </declare-styleable>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v17/leanback/res/values/dimens.xml b/current/support/v17/leanback/res/values/dimens.xml
index 0c6ec35..87b3549 100644
--- a/current/support/v17/leanback/res/values/dimens.xml
+++ b/current/support/v17/leanback/res/values/dimens.xml
@@ -269,8 +269,6 @@
 
     <!-- height for picker item. -->
     <dimen name="picker_item_height">64dp</dimen>
-    <!-- height for picker column. Should be a multiple of @dimen/picker_item_height -->
-    <dimen name="picker_column_height">192dp</dimen>
     <!-- picker column horizontal padding-->
     <dimen name="picker_column_horizontal_padding">8dp</dimen>
     <!-- picker separator horizontal padding -->
diff --git a/current/support/v17/leanback/res/values/styles.xml b/current/support/v17/leanback/res/values/styles.xml
index fb8c0b1..1f7f3dd 100644
--- a/current/support/v17/leanback/res/values/styles.xml
+++ b/current/support/v17/leanback/res/values/styles.xml
@@ -103,15 +103,13 @@
         <item name="infoVisibility">activated</item>
         <!-- In order to keep backward compatibility we have to create an icon on right. -->
         <item name="lbImageCardViewType">Title|Content|IconOnRight</item>
-        <item name="lbImageCardViewImageStyle">@style/Widget.Leanback.ImageCardView.ImageStyle</item>
-        <item name="lbImageCardViewTitleStyle">@style/Widget.Leanback.ImageCardView.TitleStyle</item>
-        <item name="lbImageCardViewContentStyle">@style/Widget.Leanback.ImageCardView.ContentStyle</item>
-        <item name="lbImageCardViewBadgeStyle">@style/Widget.Leanback.ImageCardView.BadgeStyle</item>
-        <item name="lbImageCardViewInfoAreaStyle">@style/Widget.Leanback.ImageCardView.InfoAreaStyle</item>
         <!-- Deprecated. Use 'Widget.Leanback.ImageCardView.InfoAreaStyle' instead. -->
         <item name="infoAreaBackground">@null</item>
     </style>
 
+    <style name="TextAppearance.Leanback.ImageCardView">
+    </style>
+
     <style name="Widget.Leanback.ImageCardView" />
 
     <style name="Widget.Leanback.ImageCardView.ImageStyle">
@@ -134,18 +132,26 @@
         <item name="android:paddingTop">@dimen/lb_basic_card_info_padding_top</item>
         <item name="android:background">@color/lb_basic_card_info_bg_color</item>
     </style>
-	
+
+    <style name="TextAppearance.Leanback.ImageCardView.Title">
+        <item name="android:textColor">@color/lb_basic_card_title_text_color</item>
+        <item name="android:textSize">@dimen/lb_basic_card_title_text_size</item>
+    </style>
+
     <style name="Widget.Leanback.ImageCardView.TitleStyle">
         <item name="android:id">@id/title_text</item>
         <item name="android:layout_width">match_parent</item>
         <item name="android:layout_height">wrap_content</item>
         <item name="android:maxLines">1</item>
         <item name="android:layout_marginBottom">@dimen/lb_basic_card_info_text_margin</item>
-        <item name="android:fontFamily">sans-serif-condensed</item>
-        <item name="android:textColor">@color/lb_basic_card_title_text_color</item>
-        <item name="android:textSize">@dimen/lb_basic_card_title_text_size</item>
         <item name="android:textAlignment">viewStart</item>
         <item name="android:ellipsize">end</item>
+        <item name="android:textAppearance">@style/TextAppearance.Leanback.ImageCardView.Title</item>
+    </style>
+
+    <style name="TextAppearance.Leanback.ImageCardView.Content">
+        <item name="android:textColor">@color/lb_basic_card_content_text_color</item>
+        <item name="android:textSize">@dimen/lb_basic_card_content_text_size</item>
     </style>
 
     <style name="Widget.Leanback.ImageCardView.ContentStyle">
@@ -156,11 +162,9 @@
         <item name="android:layout_below">@+id/title_text</item>
         <item name="android:layout_toStartOf">@+id/extra_badge</item>
         <item name="android:maxLines">1</item>
-        <item name="android:fontFamily">sans-serif-condensed</item>
-        <item name="android:textColor">@color/lb_basic_card_content_text_color</item>
-        <item name="android:textSize">@dimen/lb_basic_card_content_text_size</item>
         <item name="android:textAlignment">viewStart</item>
         <item name="android:ellipsize">none</item>
+        <item name="android:textAppearance">@style/TextAppearance.Leanback.ImageCardView.Content</item>
     </style>
 
     <style name="Widget.Leanback.ImageCardView.BadgeStyle">
@@ -444,18 +448,14 @@
     <style name="Widget.Leanback.GuidedActionsListStyle">
         <item name="android:layout_width">match_parent</item>
         <item name="android:layout_height">match_parent</item>
-        <item name="android:focusable">true</item>
-        <item name="android:focusableInTouchMode">true</item>
-        <item name="focusOutEnd">true</item>
+        <item name="focusOutEnd">false</item>
         <item name="focusOutFront">false</item>
-        <item name="focusOutSideStart">false</item>
-        <item name="focusOutSideEnd">true</item>
     </style>
 
     <!-- Style for the vertical grid of sub actions in a GuidedActionsStylist's default layout. -->
     <style name="Widget.Leanback.GuidedSubActionsListStyle" parent="Widget.Leanback.GuidedActionsListStyle">
         <item name="focusOutEnd">false</item>
-        <item name="focusOutFront">true</item>
+        <item name="focusOutFront">false</item>
         <item name="focusOutSideStart">false</item>
         <item name="focusOutSideEnd">false</item>
         <item name="android:layout_marginBottom">@dimen/lb_guidedactions_sublist_bottom_margin</item>
@@ -463,8 +463,6 @@
 
     <!-- Style for the vertical grid of button actions in a GuidedActionsStylist's default layout. -->
     <style name="Widget.Leanback.GuidedButtonActionsListStyle" parent="Widget.Leanback.GuidedActionsListStyle">
-        <item name="focusOutSideStart">true</item>
-        <item name="focusOutSideEnd">false</item>
     </style>
 
     <!-- Style for an action's container in a GuidedActionsStylist's default item layout. -->
diff --git a/current/support/v17/leanback/res/values/themes.xml b/current/support/v17/leanback/res/values/themes.xml
index 50835a3..42b49bc 100644
--- a/current/support/v17/leanback/res/values/themes.xml
+++ b/current/support/v17/leanback/res/values/themes.xml
@@ -32,6 +32,11 @@
 
         <item name="baseCardViewStyle">@style/Widget.Leanback.BaseCardViewStyle</item>
         <item name="imageCardViewStyle">@style/Widget.Leanback.ImageCardViewStyle</item>
+        <item name="imageCardViewImageStyle">@style/Widget.Leanback.ImageCardView.ImageStyle</item>
+        <item name="imageCardViewTitleStyle">@style/Widget.Leanback.ImageCardView.TitleStyle</item>
+        <item name="imageCardViewContentStyle">@style/Widget.Leanback.ImageCardView.ContentStyle</item>
+        <item name="imageCardViewBadgeStyle">@style/Widget.Leanback.ImageCardView.BadgeStyle</item>
+        <item name="imageCardViewInfoAreaStyle">@style/Widget.Leanback.ImageCardView.InfoAreaStyle</item>
 
         <item name="browsePaddingStart">@dimen/lb_browse_padding_start</item>
         <item name="browsePaddingEnd">@dimen/lb_browse_padding_end</item>
diff --git a/current/support/v17/preference-leanback/libs/android-support-v17-preference-leanback.jar b/current/support/v17/preference-leanback/libs/android-support-v17-preference-leanback.jar
index 789ba87..4fc388d 100644
--- a/current/support/v17/preference-leanback/libs/android-support-v17-preference-leanback.jar
+++ b/current/support/v17/preference-leanback/libs/android-support-v17-preference-leanback.jar
Binary files differ
diff --git a/current/support/v17/preference-leanback/res/layout/leanback_preference_fragment.xml b/current/support/v17/preference-leanback/res/layout/leanback_preference_fragment.xml
index 199e0f7..8c0c055 100644
--- a/current/support/v17/preference-leanback/res/layout/leanback_preference_fragment.xml
+++ b/current/support/v17/preference-leanback/res/layout/leanback_preference_fragment.xml
@@ -20,7 +20,6 @@
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:background="@color/lb_preference_decor_list_background"
-    android:elevation="@dimen/lb_preference_decor_elevation"
     android:orientation="vertical"
     android:transitionGroup="false"
     >
diff --git a/current/support/v17/preference-leanback/res/layout/leanback_settings_fragment.xml b/current/support/v17/preference-leanback/res/layout/leanback_settings_fragment.xml
index e9c421e..010f8e9 100644
--- a/current/support/v17/preference-leanback/res/layout/leanback_settings_fragment.xml
+++ b/current/support/v17/preference-leanback/res/layout/leanback_settings_fragment.xml
@@ -22,5 +22,7 @@
         android:id="@+id/settings_preference_fragment_container"
         android:layout_width="@dimen/lb_settings_pane_width"
         android:layout_height="match_parent"
-        android:layout_gravity="end"/>
+        android:layout_gravity="end"
+        android:elevation="@dimen/lb_preference_decor_elevation"
+        android:outlineProvider="bounds" />
 </android.support.v17.preference.LeanbackSettingsRootView>
diff --git a/current/support/v4/android-support-v4.jar b/current/support/v4/android-support-v4.jar
index cd3451c..cf1d7b8 100644
--- a/current/support/v4/android-support-v4.jar
+++ b/current/support/v4/android-support-v4.jar
Binary files differ
diff --git a/current/support/v4/src/api/current.txt b/current/support/v4/src/api/current.txt
index b234efd..ec81f1a 100644
--- a/current/support/v4/src/api/current.txt
+++ b/current/support/v4/src/api/current.txt
@@ -632,6 +632,7 @@
     method public android.support.v4.app.NotificationCompat.Builder setSubText(java.lang.CharSequence);
     method public android.support.v4.app.NotificationCompat.Builder setTicker(java.lang.CharSequence);
     method public android.support.v4.app.NotificationCompat.Builder setTicker(java.lang.CharSequence, android.widget.RemoteViews);
+    method public android.support.v4.app.NotificationCompat.Builder setTopic(android.support.v4.app.NotificationCompat.Topic);
     method public android.support.v4.app.NotificationCompat.Builder setUsesChronometer(boolean);
     method public android.support.v4.app.NotificationCompat.Builder setVibrate(long[]);
     method public android.support.v4.app.NotificationCompat.Builder setVisibility(int);
@@ -688,6 +689,12 @@
     method public void setBuilder(android.support.v4.app.NotificationCompat.Builder);
   }
 
+  public static class NotificationCompat.Topic {
+    ctor public NotificationCompat.Topic(java.lang.String, java.lang.CharSequence);
+    method public java.lang.String getId();
+    method public java.lang.CharSequence getLabel();
+  }
+
   public static final class NotificationCompat.WearableExtender implements android.support.v4.app.NotificationCompat.Extender {
     ctor public NotificationCompat.WearableExtender();
     ctor public NotificationCompat.WearableExtender(android.app.Notification);
@@ -1045,7 +1052,7 @@
   public final class SharedPreferencesCompat {
   }
 
-  public static class SharedPreferencesCompat.EditorCompat {
+  public static final class SharedPreferencesCompat.EditorCompat {
     method public void apply(android.content.SharedPreferences.Editor);
     method public static android.support.v4.content.SharedPreferencesCompat.EditorCompat getInstance();
   }
@@ -1060,7 +1067,7 @@
 
 package android.support.v4.content.pm {
 
-  public class ActivityInfoCompat {
+  public final class ActivityInfoCompat {
     field public static final int CONFIG_UI_MODE = 512; // 0x200
   }
 
@@ -1068,8 +1075,7 @@
 
 package android.support.v4.content.res {
 
-  public class ResourcesCompat {
-    ctor public ResourcesCompat();
+  public final class ResourcesCompat {
     method public static int getColor(android.content.res.Resources, int, android.content.res.Resources.Theme) throws android.content.res.Resources.NotFoundException;
     method public static android.content.res.ColorStateList getColorStateList(android.content.res.Resources, int, android.content.res.Resources.Theme) throws android.content.res.Resources.NotFoundException;
     method public static android.graphics.drawable.Drawable getDrawable(android.content.res.Resources, int, android.content.res.Resources.Theme) throws android.content.res.Resources.NotFoundException;
@@ -1097,12 +1103,24 @@
 
   public final class ColorUtils {
     method public static int HSLToColor(float[]);
+    method public static int LABToColor(double, double, double);
+    method public static void LABToXYZ(double, double, double, double[]);
     method public static void RGBToHSL(int, int, int, float[]);
+    method public static void RGBToLAB(int, int, int, double[]);
+    method public static void RGBToXYZ(int, int, int, double[]);
+    method public static int XYZToColor(double, double, double);
+    method public static void XYZToLAB(double, double, double, double[]);
+    method public static int blendARGB(int, int, float);
+    method public static void blendHSL(float[], float[], float[], float);
+    method public static void blendLAB(double[], double[], double[], double);
     method public static double calculateContrast(int, int);
     method public static double calculateLuminance(int);
     method public static int calculateMinimumAlpha(int, int, float);
     method public static void colorToHSL(int, float[]);
+    method public static void colorToLAB(int, double[]);
+    method public static void colorToXYZ(int, double[]);
     method public static int compositeColors(int, int);
+    method public static double distanceEuclidean(double[], double[]);
     method public static int setAlphaComponent(int, int);
   }
 
@@ -1739,11 +1757,14 @@
 
 package android.support.v4.os {
 
-  public class AsyncTaskCompat {
-    ctor public AsyncTaskCompat();
+  public final class AsyncTaskCompat {
     method public static android.os.AsyncTask<Params, Progress, Result> executeParallel(android.os.AsyncTask<Params, Progress, Result>, Params...);
   }
 
+  public class BuildCompat {
+    method public static boolean isAtLeastN();
+  }
+
   public final class CancellationSignal {
     ctor public CancellationSignal();
     method public void cancel();
@@ -1783,8 +1804,7 @@
 
   public class UserManagerCompat {
     ctor public UserManagerCompat();
-    method public static boolean isUserRunningAndLocked(android.content.Context);
-    method public static boolean isUserRunningAndUnlocked(android.content.Context);
+    method public static boolean isUserUnlocked(android.content.Context);
   }
 
 }
@@ -1870,8 +1890,7 @@
     method public android.support.v4.text.BidiFormatter.Builder stereoReset(boolean);
   }
 
-  public class ICUCompat {
-    ctor public ICUCompat();
+  public final class ICUCompat {
     method public static java.lang.String maximizeAndGetScript(java.util.Locale);
   }
 
@@ -2153,8 +2172,7 @@
     field public static final int SOURCE_UNKNOWN = 0; // 0x0
   }
 
-  public class KeyEventCompat {
-    ctor public KeyEventCompat();
+  public final class KeyEventCompat {
     method public static boolean dispatch(android.view.KeyEvent, android.view.KeyEvent.Callback, java.lang.Object, java.lang.Object);
     method public static java.lang.Object getKeyDispatcherState(android.view.View);
     method public static boolean hasModifiers(android.view.KeyEvent, int);
@@ -2167,6 +2185,7 @@
   }
 
   public final class LayoutInflaterCompat {
+    method public static android.support.v4.view.LayoutInflaterFactory getFactory(android.view.LayoutInflater);
     method public static void setFactory(android.view.LayoutInflater, android.support.v4.view.LayoutInflaterFactory);
   }
 
@@ -2399,8 +2418,7 @@
     method public static float getYVelocity(android.view.VelocityTracker, int);
   }
 
-  public class ViewCompat {
-    ctor public ViewCompat();
+  public final class ViewCompat {
     method public static android.support.v4.view.ViewPropertyAnimatorCompat animate(android.view.View);
     method public static boolean canScrollHorizontally(android.view.View, int);
     method public static boolean canScrollVertically(android.view.View, int);
@@ -2723,7 +2741,7 @@
 
 package android.support.v4.view.accessibility {
 
-  public class AccessibilityEventCompat {
+  public final class AccessibilityEventCompat {
     method public static void appendRecord(android.view.accessibility.AccessibilityEvent, android.support.v4.view.accessibility.AccessibilityRecordCompat);
     method public static android.support.v4.view.accessibility.AccessibilityRecordCompat asRecord(android.view.accessibility.AccessibilityEvent);
     method public static int getContentChangeTypes(android.view.accessibility.AccessibilityEvent);
@@ -2752,8 +2770,7 @@
     field public static final int TYPE_WINDOW_CONTENT_CHANGED = 2048; // 0x800
   }
 
-  public class AccessibilityManagerCompat {
-    ctor public AccessibilityManagerCompat();
+  public final class AccessibilityManagerCompat {
     method public static boolean addAccessibilityStateChangeListener(android.view.accessibility.AccessibilityManager, android.support.v4.view.accessibility.AccessibilityManagerCompat.AccessibilityStateChangeListenerCompat);
     method public static java.util.List<android.accessibilityservice.AccessibilityServiceInfo> getEnabledAccessibilityServiceList(android.view.accessibility.AccessibilityManager, int);
     method public static java.util.List<android.accessibilityservice.AccessibilityServiceInfo> getInstalledAccessibilityServiceList(android.view.accessibility.AccessibilityManager);
@@ -3077,7 +3094,7 @@
     method public float getInterpolation(float);
   }
 
-  public class PathInterpolatorCompat {
+  public final class PathInterpolatorCompat {
     method public static android.view.animation.Interpolator create(android.graphics.Path);
     method public static android.view.animation.Interpolator create(float, float);
     method public static android.view.animation.Interpolator create(float, float, float, float);
diff --git a/current/support/v4/src/api/removed.txt b/current/support/v4/src/api/removed.txt
index e69de29..217aba3 100644
--- a/current/support/v4/src/api/removed.txt
+++ b/current/support/v4/src/api/removed.txt
@@ -0,0 +1,9 @@
+package android.support.v4.os {
+
+  public class UserManagerCompat {
+    method public static deprecated boolean isUserRunningAndLocked(android.content.Context);
+    method public static deprecated boolean isUserRunningAndUnlocked(android.content.Context);
+  }
+
+}
+
diff --git a/current/support/v4/src/tests/res/drawable/test_drawable_blue.xml b/current/support/v4/src/tests/res/drawable/test_drawable_blue.xml
index 5d05ef2..eae0ecb 100644
--- a/current/support/v4/src/tests/res/drawable/test_drawable_blue.xml
+++ b/current/support/v4/src/tests/res/drawable/test_drawable_blue.xml
@@ -22,4 +22,4 @@
         android:height="@dimen/drawable_small_size" />
     <solid
         android:color="@color/test_blue" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v4/src/tests/res/drawable/test_drawable_green.xml b/current/support/v4/src/tests/res/drawable/test_drawable_green.xml
index 9f33104..0de8213 100644
--- a/current/support/v4/src/tests/res/drawable/test_drawable_green.xml
+++ b/current/support/v4/src/tests/res/drawable/test_drawable_green.xml
@@ -22,4 +22,4 @@
         android:height="@dimen/drawable_large_size" />
     <solid
         android:color="@color/test_green" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v4/src/tests/res/drawable/test_drawable_red.xml b/current/support/v4/src/tests/res/drawable/test_drawable_red.xml
index cd1af56..e630659 100644
--- a/current/support/v4/src/tests/res/drawable/test_drawable_red.xml
+++ b/current/support/v4/src/tests/res/drawable/test_drawable_red.xml
@@ -22,4 +22,4 @@
         android:height="@dimen/drawable_medium_size" />
     <solid
         android:color="@color/test_red" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v4/src/tests/res/drawable/themed_drawable.xml b/current/support/v4/src/tests/res/drawable/themed_drawable.xml
index 08d89c7..a460465 100644
--- a/current/support/v4/src/tests/res/drawable/themed_drawable.xml
+++ b/current/support/v4/src/tests/res/drawable/themed_drawable.xml
@@ -22,4 +22,4 @@
         android:height="@dimen/drawable_small_size" />
     <solid
         android:color="?attr/theme_color_default" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v4/src/tests/res/layout/fragment_a.xml b/current/support/v4/src/tests/res/layout/fragment_a.xml
new file mode 100644
index 0000000..38e0423
--- /dev/null
+++ b/current/support/v4/src/tests/res/layout/fragment_a.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical">
+    <TextView android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:id="@+id/textA"
+              android:text="@string/hello"/>
+</LinearLayout>
diff --git a/current/support/v4/src/tests/res/layout/fragment_b.xml b/current/support/v4/src/tests/res/layout/fragment_b.xml
new file mode 100644
index 0000000..d8ed961
--- /dev/null
+++ b/current/support/v4/src/tests/res/layout/fragment_b.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical">
+    <TextView android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:id="@+id/textB"
+              android:text="@string/hello"/>
+</LinearLayout>
diff --git a/current/support/v4/src/tests/res/layout/fragment_c.xml b/current/support/v4/src/tests/res/layout/fragment_c.xml
new file mode 100644
index 0000000..ed3c753
--- /dev/null
+++ b/current/support/v4/src/tests/res/layout/fragment_c.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical">
+    <TextView android:layout_width="wrap_content"
+              android:layout_height="wrap_content"
+              android:id="@+id/textC"
+              android:text="@string/hello"/>
+</LinearLayout>
diff --git a/current/support/v4/src/tests/res/values-hdpi/dimens.xml b/current/support/v4/src/tests/res/values-hdpi/dimens.xml
index eb1ff54..3e7770a 100644
--- a/current/support/v4/src/tests/res/values-hdpi/dimens.xml
+++ b/current/support/v4/src/tests/res/values-hdpi/dimens.xml
@@ -15,4 +15,4 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <dimen name="density_aware_size">14dip</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values-mdpi/dimens.xml b/current/support/v4/src/tests/res/values-mdpi/dimens.xml
index 5766379..5b5a669 100644
--- a/current/support/v4/src/tests/res/values-mdpi/dimens.xml
+++ b/current/support/v4/src/tests/res/values-mdpi/dimens.xml
@@ -15,4 +15,4 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <dimen name="density_aware_size">12dip</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values-xhdpi/dimens.xml b/current/support/v4/src/tests/res/values-xhdpi/dimens.xml
index a25d23d..43a623e 100644
--- a/current/support/v4/src/tests/res/values-xhdpi/dimens.xml
+++ b/current/support/v4/src/tests/res/values-xhdpi/dimens.xml
@@ -15,4 +15,4 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <dimen name="density_aware_size">16dip</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values-xxhdpi/dimens.xml b/current/support/v4/src/tests/res/values-xxhdpi/dimens.xml
index 399cde1..77c5bbb 100644
--- a/current/support/v4/src/tests/res/values-xxhdpi/dimens.xml
+++ b/current/support/v4/src/tests/res/values-xxhdpi/dimens.xml
@@ -15,4 +15,4 @@
 -->
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <dimen name="density_aware_size">18dip</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values/attrs.xml b/current/support/v4/src/tests/res/values/attrs.xml
index 36d1e9e..3d68176 100644
--- a/current/support/v4/src/tests/res/values/attrs.xml
+++ b/current/support/v4/src/tests/res/values/attrs.xml
@@ -18,4 +18,4 @@
     <attr name="theme_color_focused" format="reference" />
     <attr name="theme_color_pressed" format="reference" />
     <attr name="theme_color_selected" format="reference" />
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values/dimens.xml b/current/support/v4/src/tests/res/values/dimens.xml
index 5c82462..5d0592a 100644
--- a/current/support/v4/src/tests/res/values/dimens.xml
+++ b/current/support/v4/src/tests/res/values/dimens.xml
@@ -19,4 +19,4 @@
     <dimen name="drawable_small_size">12dip</dimen>
     <dimen name="drawable_medium_size">16dip</dimen>
     <dimen name="drawable_large_size">20dip</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values/ids.xml b/current/support/v4/src/tests/res/values/ids.xml
index e5fcf63..2147fef 100644
--- a/current/support/v4/src/tests/res/values/ids.xml
+++ b/current/support/v4/src/tests/res/values/ids.xml
@@ -24,4 +24,4 @@
     <item name="page_7" type="id"/>
     <item name="page_8" type="id"/>
     <item name="page_9" type="id"/>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values/strings.xml b/current/support/v4/src/tests/res/values/strings.xml
index b804faf..1f543d0 100644
--- a/current/support/v4/src/tests/res/values/strings.xml
+++ b/current/support/v4/src/tests/res/values/strings.xml
@@ -21,4 +21,4 @@
     <!-- Long text for testing. -->
     <string name="test_text_long">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam dui neque, suscipit quis rhoncus vitae, rhoncus hendrerit neque. Proin ac mauris cursus nulla aliquam viverra. Vivamus pharetra luctus magna, lacinia imperdiet leo mollis eget. Fusce a diam ipsum. Etiam sit amet nisl et velit aliquam dignissim eget nec nisi. Duis bibendum euismod tortor non pulvinar. Nunc quis neque ultricies nulla luctus aliquet. Sed consectetur, orci ac vehicula consectetur, metus sem pellentesque turpis, sed venenatis nisi lorem vitae ante.</string>
     <string name="hello">Hello World</string>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v4/src/tests/res/values/styles.xml b/current/support/v4/src/tests/res/values/styles.xml
index c0855d8..f6004d3 100644
--- a/current/support/v4/src/tests/res/values/styles.xml
+++ b/current/support/v4/src/tests/res/values/styles.xml
@@ -31,4 +31,4 @@
         <item name="theme_color_focused">@color/theme_color_lilac_focused</item>
         <item name="theme_color_pressed">@color/theme_color_lilac_pressed</item>
     </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar b/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar
index bd6419c..2c3a829 100644
--- a/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar
+++ b/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar
Binary files differ
diff --git a/current/support/v7/appcompat/res/anim/abc_fade_in.xml b/current/support/v7/appcompat/res/anim/abc_fade_in.xml
index da7ee29..ea3e602 100644
--- a/current/support/v7/appcompat/res/anim/abc_fade_in.xml
+++ b/current/support/v7/appcompat/res/anim/abc_fade_in.xml
@@ -17,4 +17,4 @@
 <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        android:interpolator="@android:anim/decelerate_interpolator"
        android:fromAlpha="0.0" android:toAlpha="1.0"
-       android:duration="@android:integer/config_mediumAnimTime" />
\ No newline at end of file
+       android:duration="@android:integer/config_mediumAnimTime" />
diff --git a/current/support/v7/appcompat/res/anim/abc_fade_out.xml b/current/support/v7/appcompat/res/anim/abc_fade_out.xml
index c81b39a..40d2d37 100644
--- a/current/support/v7/appcompat/res/anim/abc_fade_out.xml
+++ b/current/support/v7/appcompat/res/anim/abc_fade_out.xml
@@ -17,4 +17,4 @@
 <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        android:interpolator="@android:anim/decelerate_interpolator"
        android:fromAlpha="1.0" android:toAlpha="0.0"
-       android:duration="@android:integer/config_mediumAnimTime" />
\ No newline at end of file
+       android:duration="@android:integer/config_mediumAnimTime" />
diff --git a/current/support/v7/appcompat/res/anim/abc_grow_fade_in_from_bottom.xml b/current/support/v7/appcompat/res/anim/abc_grow_fade_in_from_bottom.xml
index 79d02d4..f38b039 100644
--- a/current/support/v7/appcompat/res/anim/abc_grow_fade_in_from_bottom.xml
+++ b/current/support/v7/appcompat/res/anim/abc_grow_fade_in_from_bottom.xml
@@ -27,4 +27,4 @@
     <alpha 	android:interpolator="@android:anim/decelerate_interpolator"
               android:fromAlpha="0.0" android:toAlpha="1.0"
               android:duration="@integer/abc_config_activityShortDur" />
-</set>
\ No newline at end of file
+</set>
diff --git a/current/support/v7/appcompat/res/anim/abc_popup_enter.xml b/current/support/v7/appcompat/res/anim/abc_popup_enter.xml
index 91664da..2036eec 100644
--- a/current/support/v7/appcompat/res/anim/abc_popup_enter.xml
+++ b/current/support/v7/appcompat/res/anim/abc_popup_enter.xml
@@ -18,4 +18,4 @@
     <alpha android:fromAlpha="0.0" android:toAlpha="1.0"
            android:interpolator="@android:anim/decelerate_interpolator"
            android:duration="@integer/abc_config_activityShortDur" />
-</set>
\ No newline at end of file
+</set>
diff --git a/current/support/v7/appcompat/res/anim/abc_popup_exit.xml b/current/support/v7/appcompat/res/anim/abc_popup_exit.xml
index db7e807..9f6a54d 100644
--- a/current/support/v7/appcompat/res/anim/abc_popup_exit.xml
+++ b/current/support/v7/appcompat/res/anim/abc_popup_exit.xml
@@ -18,4 +18,4 @@
     <alpha android:fromAlpha="1.0" android:toAlpha="0.0"
            android:interpolator="@android:anim/decelerate_interpolator"
            android:duration="@integer/abc_config_activityShortDur" />
-</set>
\ No newline at end of file
+</set>
diff --git a/current/support/v7/appcompat/res/anim/abc_shrink_fade_out_from_bottom.xml b/current/support/v7/appcompat/res/anim/abc_shrink_fade_out_from_bottom.xml
index 9a23cd2..09d9769 100644
--- a/current/support/v7/appcompat/res/anim/abc_shrink_fade_out_from_bottom.xml
+++ b/current/support/v7/appcompat/res/anim/abc_shrink_fade_out_from_bottom.xml
@@ -24,4 +24,4 @@
     <alpha 	android:interpolator="@android:anim/decelerate_interpolator"
               android:fromAlpha="1.0" android:toAlpha="0.0"
               android:duration="@integer/abc_config_activityShortDur" />
-</set>
\ No newline at end of file
+</set>
diff --git a/current/support/v7/appcompat/res/anim/abc_slide_in_top.xml b/current/support/v7/appcompat/res/anim/abc_slide_in_top.xml
index ab824f2..e6bd8bb 100644
--- a/current/support/v7/appcompat/res/anim/abc_slide_in_top.xml
+++ b/current/support/v7/appcompat/res/anim/abc_slide_in_top.xml
@@ -16,4 +16,4 @@
 <translate xmlns:android="http://schemas.android.com/apk/res/android"
            android:interpolator="@android:anim/decelerate_interpolator"
            android:fromYDelta="-50%p" android:toYDelta="0"
-           android:duration="@android:integer/config_mediumAnimTime"/>
\ No newline at end of file
+           android:duration="@android:integer/config_mediumAnimTime"/>
diff --git a/current/support/v7/appcompat/res/anim/abc_slide_out_bottom.xml b/current/support/v7/appcompat/res/anim/abc_slide_out_bottom.xml
index b309fe8..9b13d3b 100644
--- a/current/support/v7/appcompat/res/anim/abc_slide_out_bottom.xml
+++ b/current/support/v7/appcompat/res/anim/abc_slide_out_bottom.xml
@@ -16,4 +16,4 @@
 <translate xmlns:android="http://schemas.android.com/apk/res/android"
            android:interpolator="@android:anim/accelerate_interpolator"
            android:fromYDelta="0" android:toYDelta="50%p"
-           android:duration="@android:integer/config_mediumAnimTime"/>
\ No newline at end of file
+           android:duration="@android:integer/config_mediumAnimTime"/>
diff --git a/current/support/v7/appcompat/res/anim/abc_slide_out_top.xml b/current/support/v7/appcompat/res/anim/abc_slide_out_top.xml
index e84d1c7..980f826 100644
--- a/current/support/v7/appcompat/res/anim/abc_slide_out_top.xml
+++ b/current/support/v7/appcompat/res/anim/abc_slide_out_top.xml
@@ -16,4 +16,4 @@
 <translate xmlns:android="http://schemas.android.com/apk/res/android"
            android:interpolator="@android:anim/accelerate_interpolator"
            android:fromYDelta="0" android:toYDelta="-50%p"
-           android:duration="@android:integer/config_mediumAnimTime"/>
\ No newline at end of file
+           android:duration="@android:integer/config_mediumAnimTime"/>
diff --git a/current/support/v7/appcompat/res/color-v23/abc_color_highlight_material.xml b/current/support/v7/appcompat/res/color-v23/abc_color_highlight_material.xml
index 8d53611..a79aa44 100644
--- a/current/support/v7/appcompat/res/color-v23/abc_color_highlight_material.xml
+++ b/current/support/v7/appcompat/res/color-v23/abc_color_highlight_material.xml
@@ -20,4 +20,4 @@
           android:alpha="@dimen/highlight_alpha_material_colored"
           android:color="?android:attr/colorControlActivated" />
     <item android:color="?android:attr/colorControlHighlight" />
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_search_url_text.xml b/current/support/v7/appcompat/res/color/abc_search_url_text.xml
index 0631d5d..26a973c 100644
--- a/current/support/v7/appcompat/res/color/abc_search_url_text.xml
+++ b/current/support/v7/appcompat/res/color/abc_search_url_text.xml
@@ -18,4 +18,4 @@
     <item android:state_pressed="true" android:color="@color/abc_search_url_text_pressed"/>
     <item android:state_selected="true" android:color="@color/abc_search_url_text_selected"/>
     <item android:color="@color/abc_search_url_text_normal"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_btn_checkable.xml b/current/support/v7/appcompat/res/color/abc_tint_btn_checkable.xml
index 0c663f6..6095c06 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_btn_checkable.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_btn_checkable.xml
@@ -19,4 +19,4 @@
     <item android:state_enabled="false" android:color="?attr/colorControlNormal" app:alpha="?android:disabledAlpha"/>
     <item android:state_checked="true" android:color="?attr/colorControlActivated"/>
     <item android:color="?attr/colorControlNormal"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_default.xml b/current/support/v7/appcompat/res/color/abc_tint_default.xml
index 8d7c391..0d73016 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_default.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_default.xml
@@ -23,4 +23,4 @@
     <item android:state_selected="true" android:color="?attr/colorControlActivated"/>
     <item android:state_checked="true" android:color="?attr/colorControlActivated"/>
     <item android:color="?attr/colorControlNormal"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_edittext.xml b/current/support/v7/appcompat/res/color/abc_tint_edittext.xml
index 536d77f..0f27a0b 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_edittext.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_edittext.xml
@@ -21,4 +21,4 @@
     <item android:state_pressed="false" android:state_focused="false"
           android:color="?attr/colorControlNormal"/>
     <item android:color="?attr/colorControlActivated"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_seek_thumb.xml b/current/support/v7/appcompat/res/color/abc_tint_seek_thumb.xml
index cb53788..7617e3f 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_seek_thumb.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_seek_thumb.xml
@@ -18,4 +18,4 @@
           xmlns:app="http://schemas.android.com/apk/res-auto">
     <item android:state_enabled="false" android:color="?attr/colorControlActivated" app:alpha="?android:attr/disabledAlpha"/>
     <item android:color="?attr/colorControlActivated"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_spinner.xml b/current/support/v7/appcompat/res/color/abc_tint_spinner.xml
index 44333dd..1f4693d 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_spinner.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_spinner.xml
@@ -19,4 +19,4 @@
     <item android:state_enabled="false" android:color="?attr/colorControlNormal" app:alpha="?android:disabledAlpha"/>
     <item android:state_pressed="false" android:state_focused="false" android:color="?attr/colorControlNormal"/>
     <item android:color="?attr/colorControlActivated"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_switch_thumb.xml b/current/support/v7/appcompat/res/color/abc_tint_switch_thumb.xml
index fc8bd24..a3d42df 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_switch_thumb.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_switch_thumb.xml
@@ -19,4 +19,4 @@
     <item android:state_enabled="false" android:color="?attr/colorSwitchThumbNormal" app:alpha="?android:attr/disabledAlpha"/>
     <item android:state_checked="true" android:color="?attr/colorControlActivated"/>
     <item android:color="?attr/colorSwitchThumbNormal"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/abc_tint_switch_track.xml b/current/support/v7/appcompat/res/color/abc_tint_switch_track.xml
index 22322f8..ee4cb1c 100644
--- a/current/support/v7/appcompat/res/color/abc_tint_switch_track.xml
+++ b/current/support/v7/appcompat/res/color/abc_tint_switch_track.xml
@@ -19,4 +19,4 @@
     <item android:state_enabled="false" android:color="?android:attr/colorForeground" app:alpha="0.1"/>
     <item android:state_checked="true" android:color="?attr/colorControlActivated" app:alpha="0.3"/>
     <item android:color="?android:attr/colorForeground" app:alpha="0.3"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/switch_thumb_material_dark.xml b/current/support/v7/appcompat/res/color/switch_thumb_material_dark.xml
index 6153382..8fede70 100644
--- a/current/support/v7/appcompat/res/color/switch_thumb_material_dark.xml
+++ b/current/support/v7/appcompat/res/color/switch_thumb_material_dark.xml
@@ -17,4 +17,4 @@
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
     <item android:state_enabled="false" android:color="@color/switch_thumb_disabled_material_dark"/>
     <item android:color="@color/switch_thumb_normal_material_dark"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/color/switch_thumb_material_light.xml b/current/support/v7/appcompat/res/color/switch_thumb_material_light.xml
index 94d7114..1a34b74 100644
--- a/current/support/v7/appcompat/res/color/switch_thumb_material_light.xml
+++ b/current/support/v7/appcompat/res/color/switch_thumb_material_light.xml
@@ -17,4 +17,4 @@
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
     <item android:state_enabled="false" android:color="@color/switch_thumb_disabled_material_light"/>
     <item android:color="@color/switch_thumb_normal_material_light"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_check_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_check_to_on_mtrl_000.png
deleted file mode 100644
index 9911008..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_check_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_check_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_check_to_on_mtrl_015.png
deleted file mode 100644
index 69ff9dd..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_check_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_radio_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_radio_to_on_mtrl_000.png
deleted file mode 100644
index 9218981..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_radio_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_radio_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_radio_to_on_mtrl_015.png
deleted file mode 100644
index a588576..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_btn_radio_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index 46ccacc..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_clear_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_clear_mtrl_alpha.png
deleted file mode 100644
index ce64334..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_clear_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_go_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_go_search_api_mtrl_alpha.png
deleted file mode 100644
index f39c153..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_go_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 706fc1f..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index e78bcaf..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
deleted file mode 100644
index 00e189b..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_paste_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_paste_mtrl_am_alpha.png
deleted file mode 100644
index 8610c50..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_paste_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_selectall_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_selectall_mtrl_alpha.png
deleted file mode 100644
index e631df7..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_selectall_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_share_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_share_mtrl_alpha.png
deleted file mode 100644
index cd1f57c..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_menu_share_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_voice_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_voice_search_api_mtrl_alpha.png
deleted file mode 100644
index a6dbc2a..0000000
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_ic_voice_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-hdpi/abc_textfield_default_mtrl_alpha.9.png b/current/support/v7/appcompat/res/drawable-hdpi/abc_textfield_default_mtrl_alpha.9.png
index 0078bf6..5440b1a 100644
--- a/current/support/v7/appcompat/res/drawable-hdpi/abc_textfield_default_mtrl_alpha.9.png
+++ b/current/support/v7/appcompat/res/drawable-hdpi/abc_textfield_default_mtrl_alpha.9.png
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index 57211b5..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index a262b0c..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index d8eaf07..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-hdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index b872414..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 254f806..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index efe4446..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-mdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index ffa1654..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 88e34c4..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index 87bf8d3..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xhdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index 33b4f0f..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index fb54215..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index 3cdb6cf..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xxhdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index a91425a..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index fb91811..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index 90fe333..0000000
--- a/current/support/v7/appcompat/res/drawable-ldrtl-xxxhdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_check_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_check_to_on_mtrl_000.png
deleted file mode 100644
index 7a9fcbc..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_check_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_check_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_check_to_on_mtrl_015.png
deleted file mode 100644
index 3b052e5..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_check_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_radio_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_radio_to_on_mtrl_000.png
deleted file mode 100644
index 96a8693..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_radio_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_radio_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_radio_to_on_mtrl_015.png
deleted file mode 100644
index 6e18d40..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_btn_radio_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index 90fbc56..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_clear_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_clear_mtrl_alpha.png
deleted file mode 100644
index dde307e..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_clear_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_go_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_go_search_api_mtrl_alpha.png
deleted file mode 100644
index 0084c12..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_go_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 559b835..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index 44a3768..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
deleted file mode 100644
index f95f7f7..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_paste_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_paste_mtrl_am_alpha.png
deleted file mode 100644
index 1492ab6..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_paste_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_selectall_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_selectall_mtrl_alpha.png
deleted file mode 100644
index 7c011af..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_selectall_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_share_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_share_mtrl_alpha.png
deleted file mode 100644
index 36f664c..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_menu_share_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_voice_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_voice_search_api_mtrl_alpha.png
deleted file mode 100644
index a216da1..0000000
--- a/current/support/v7/appcompat/res/drawable-mdpi/abc_ic_voice_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-v21/abc_action_bar_item_background_material.xml b/current/support/v7/appcompat/res/drawable-v21/abc_action_bar_item_background_material.xml
index 595c56c..025e8df 100644
--- a/current/support/v7/appcompat/res/drawable-v21/abc_action_bar_item_background_material.xml
+++ b/current/support/v7/appcompat/res/drawable-v21/abc_action_bar_item_background_material.xml
@@ -15,4 +15,4 @@
 -->
 
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
-        android:color="?android:attr/colorControlHighlight"/>
\ No newline at end of file
+        android:color="?android:attr/colorControlHighlight"/>
diff --git a/current/support/v7/appcompat/res/drawable-v21/abc_btn_colored_material.xml b/current/support/v7/appcompat/res/drawable-v21/abc_btn_colored_material.xml
index 10251aa..0f87c09 100644
--- a/current/support/v7/appcompat/res/drawable-v21/abc_btn_colored_material.xml
+++ b/current/support/v7/appcompat/res/drawable-v21/abc_btn_colored_material.xml
@@ -47,4 +47,4 @@
             </selector>
         </item>
     </ripple>
-</inset>
\ No newline at end of file
+</inset>
diff --git a/current/support/v7/appcompat/res/drawable-v21/abc_edit_text_material.xml b/current/support/v7/appcompat/res/drawable-v21/abc_edit_text_material.xml
new file mode 100644
index 0000000..9861e378b
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable-v21/abc_edit_text_material.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<inset xmlns:android="http://schemas.android.com/apk/res/android"
+       android:insetLeft="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetRight="@dimen/abc_edit_text_inset_horizontal_material"
+       android:insetTop="@dimen/abc_edit_text_inset_top_material"
+       android:insetBottom="@dimen/abc_edit_text_inset_bottom_material">
+    <selector>
+        <item android:state_enabled="false">
+            <nine-patch android:src="@drawable/abc_textfield_default_mtrl_alpha"
+                        android:tint="?attr/colorControlNormal"
+                        android:alpha="?android:attr/disabledAlpha"/>
+        </item>
+        <item android:state_pressed="false" android:state_focused="false">
+            <nine-patch android:src="@drawable/abc_textfield_default_mtrl_alpha"
+                        android:tint="?attr/colorControlNormal"/>
+        </item>
+        <item>
+            <nine-patch android:src="@drawable/abc_textfield_activated_mtrl_alpha"
+                        android:tint="?attr/colorControlActivated"/>
+        </item>
+    </selector>
+</inset>
diff --git a/current/support/v7/appcompat/res/drawable-v23/abc_control_background_material.xml b/current/support/v7/appcompat/res/drawable-v23/abc_control_background_material.xml
index 0b54039..a837ac6 100644
--- a/current/support/v7/appcompat/res/drawable-v23/abc_control_background_material.xml
+++ b/current/support/v7/appcompat/res/drawable-v23/abc_control_background_material.xml
@@ -16,4 +16,4 @@
 
 <ripple xmlns:android="http://schemas.android.com/apk/res/android"
         android:color="@color/abc_color_highlight_material"
-        android:radius="20dp" />
\ No newline at end of file
+        android:radius="20dp" />
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_check_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_check_to_on_mtrl_000.png
deleted file mode 100644
index 4902520..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_check_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_check_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_check_to_on_mtrl_015.png
deleted file mode 100644
index 59a683a..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_check_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_radio_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_radio_to_on_mtrl_000.png
deleted file mode 100644
index 03bf49c..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_radio_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_radio_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_radio_to_on_mtrl_015.png
deleted file mode 100644
index 342323b..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_btn_radio_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index 154babd..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_clear_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_clear_mtrl_alpha.png
deleted file mode 100644
index 6d90d0c..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_clear_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_go_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_go_search_api_mtrl_alpha.png
deleted file mode 100644
index 19e000a..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_go_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 6448549..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index cd38901..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
deleted file mode 100644
index e76c83e..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_paste_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_paste_mtrl_am_alpha.png
deleted file mode 100644
index 9aabc43..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_paste_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_selectall_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_selectall_mtrl_alpha.png
deleted file mode 100644
index 6a7161f..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_selectall_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_share_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_share_mtrl_alpha.png
deleted file mode 100644
index 6be7e09..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_menu_share_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_search_api_mtrl_alpha.png
deleted file mode 100644
index 209898d..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_voice_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_voice_search_api_mtrl_alpha.png
deleted file mode 100644
index 7329c15..0000000
--- a/current/support/v7/appcompat/res/drawable-xhdpi/abc_ic_voice_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_check_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_check_to_on_mtrl_000.png
deleted file mode 100644
index accf80e..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_check_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_check_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_check_to_on_mtrl_015.png
deleted file mode 100644
index 8c82ec3..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_check_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_radio_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_radio_to_on_mtrl_000.png
deleted file mode 100644
index 8fc0a9b..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_radio_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_radio_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_radio_to_on_mtrl_015.png
deleted file mode 100644
index 3038d70..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_btn_radio_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index f99802f..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_clear_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_clear_mtrl_alpha.png
deleted file mode 100644
index b85e87f..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_clear_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_go_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_go_search_api_mtrl_alpha.png
deleted file mode 100644
index d041623..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_go_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 90d6ba3..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index 63e541f..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
deleted file mode 100644
index c382aa6..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_paste_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_paste_mtrl_am_alpha.png
deleted file mode 100644
index f71485c..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_paste_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_selectall_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_selectall_mtrl_alpha.png
deleted file mode 100644
index 162ab98..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_selectall_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_share_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_share_mtrl_alpha.png
deleted file mode 100644
index d95a377..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_menu_share_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_voice_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_voice_search_api_mtrl_alpha.png
deleted file mode 100644
index dacf407..0000000
--- a/current/support/v7/appcompat/res/drawable-xxhdpi/abc_ic_voice_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_check_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_check_to_on_mtrl_000.png
deleted file mode 100644
index d44bbae..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_check_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_check_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_check_to_on_mtrl_015.png
deleted file mode 100644
index 4e18de2..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_check_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_radio_to_on_mtrl_000.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_radio_to_on_mtrl_000.png
deleted file mode 100644
index 5fa3266..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_radio_to_on_mtrl_000.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_radio_to_on_mtrl_015.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_radio_to_on_mtrl_015.png
deleted file mode 100644
index c11cb2e..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_btn_radio_to_on_mtrl_015.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_ab_back_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
deleted file mode 100644
index 41d6d6b..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_ab_back_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_clear_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_clear_mtrl_alpha.png
deleted file mode 100644
index da2b577..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_clear_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
deleted file mode 100644
index 715db8a..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_copy_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_cut_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_cut_mtrl_alpha.png
deleted file mode 100644
index 397fd91..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_cut_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
deleted file mode 100644
index 16e9e14..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_moreoverflow_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_paste_mtrl_am_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_paste_mtrl_am_alpha.png
deleted file mode 100644
index 1891b3d..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_paste_mtrl_am_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_selectall_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_selectall_mtrl_alpha.png
deleted file mode 100644
index 591a1c9..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_selectall_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_share_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_share_mtrl_alpha.png
deleted file mode 100644
index ba16aac..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_menu_share_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_voice_search_api_mtrl_alpha.png b/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_voice_search_api_mtrl_alpha.png
deleted file mode 100644
index d191642..0000000
--- a/current/support/v7/appcompat/res/drawable-xxxhdpi/abc_ic_voice_search_api_mtrl_alpha.png
+++ /dev/null
Binary files differ
diff --git a/current/support/v7/appcompat/res/drawable/abc_btn_check_material.xml b/current/support/v7/appcompat/res/drawable/abc_btn_check_material.xml
index 4934a92..ac3ae35 100644
--- a/current/support/v7/appcompat/res/drawable/abc_btn_check_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_btn_check_material.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2014 The Android Open Source Project
+<!-- Copyright (C) 2015 The Android Open Source Project
 
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
@@ -15,6 +15,6 @@
 -->
 
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
-    <item android:state_checked="true" android:drawable="@drawable/abc_btn_check_to_on_mtrl_015" />
-    <item android:drawable="@drawable/abc_btn_check_to_on_mtrl_000" />
-</selector>
\ No newline at end of file
+    <item android:state_checked="true" android:drawable="@drawable/abc_btn_checkbox_checked_mtrl" />
+    <item android:drawable="@drawable/abc_btn_checkbox_unchecked_mtrl" />
+</selector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_btn_checkbox_checked_mtrl.xml b/current/support/v7/appcompat/res/drawable/abc_btn_checkbox_checked_mtrl.xml
new file mode 100644
index 0000000..2a14c2a
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_btn_checkbox_checked_mtrl.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:name="abc_btn_checkbox_checked"
+        android:width="32dp"
+        android:viewportWidth="48"
+        android:height="32dp"
+        android:viewportHeight="48">
+    <group
+            android:name="icon_null"
+            android:translateX="24"
+            android:translateY="24"
+            android:scaleX="0.2"
+            android:scaleY="0.2">
+        <group
+                android:name="check"
+                android:scaleX="7.5"
+                android:scaleY="7.5">
+            <path
+                    android:name="check_path_merged"
+                    android:pathData="M 7.0,-9.0 c 0.0,0.0 -14.0,0.0 -14.0,0.0 c -1.1044921875,0.0 -2.0,0.8955078125 -2.0,2.0 c 0.0,0.0 0.0,14.0 0.0,14.0 c 0.0,1.1044921875 0.8955078125,2.0 2.0,2.0 c 0.0,0.0 14.0,0.0 14.0,0.0 c 1.1044921875,0.0 2.0,-0.8955078125 2.0,-2.0 c 0.0,0.0 0.0,-14.0 0.0,-14.0 c 0.0,-1.1044921875 -0.8955078125,-2.0 -2.0,-2.0 c 0.0,0.0 0.0,0.0 0.0,0.0 Z M -2.0,5.00001525879 c 0.0,0.0 -5.0,-5.00001525879 -5.0,-5.00001525879 c 0.0,0.0 1.41409301758,-1.41409301758 1.41409301758,-1.41409301758 c 0.0,0.0 3.58590698242,3.58601379395 3.58590698242,3.58601379395 c 0.0,0.0 7.58590698242,-7.58601379395 7.58590698242,-7.58601379395 c 0.0,0.0 1.41409301758,1.41409301758 1.41409301758,1.41409301758 c 0.0,0.0 -9.0,9.00001525879 -9.0,9.00001525879 Z"
+                    android:fillColor="#FF000000"/>
+        </group>
+        <group
+                android:name="box_dilate"
+                android:scaleX="7.5"
+                android:scaleY="7.5">
+            <path
+                    android:name="box_inner_merged"
+                    android:pathData="M 0.0,-1.0 l 0.0,0.0 c 0.5522847498,0.0 1.0,0.4477152502 1.0,1.0 l 0.0,0.0 c 0.0,0.5522847498 -0.4477152502,1.0 -1.0,1.0 l 0.0,0.0 c -0.5522847498,0.0 -1.0,-0.4477152502 -1.0,-1.0 l 0.0,0.0 c 0.0,-0.5522847498 0.4477152502,-1.0 1.0,-1.0 Z M 7.0,-9.0 c 0.0,0.0 -14.0,0.0 -14.0,0.0 c -1.1044921875,0.0 -2.0,0.8955078125 -2.0,2.0 c 0.0,0.0 0.0,14.0 0.0,14.0 c 0.0,1.1044921875 0.8955078125,2.0 2.0,2.0 c 0.0,0.0 14.0,0.0 14.0,0.0 c 1.1044921875,0.0 2.0,-0.8955078125 2.0,-2.0 c 0.0,0.0 0.0,-14.0 0.0,-14.0 c 0.0,-1.1044921875 -0.8955078125,-2.0 -2.0,-2.0 c 0.0,0.0 0.0,0.0 0.0,0.0 Z"
+                    android:fillColor="#FF000000"
+                    android:fillAlpha="0"/>
+        </group>
+    </group>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_btn_checkbox_unchecked_mtrl.xml b/current/support/v7/appcompat/res/drawable/abc_btn_checkbox_unchecked_mtrl.xml
new file mode 100644
index 0000000..d61a379
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_btn_checkbox_unchecked_mtrl.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:name="abc_btn_checkbox_unchecked"
+        android:width="32dp"
+        android:viewportWidth="48"
+        android:height="32dp"
+        android:viewportHeight="48">
+    <group
+            android:name="icon_null"
+            android:translateX="24"
+            android:translateY="24"
+            android:scaleX="0.2"
+            android:scaleY="0.2">
+        <group
+                android:name="check"
+                android:scaleX="7.5"
+                android:scaleY="7.5">
+            <path
+                    android:name="box_outer_merged"
+                    android:pathData="M 7.0,-9.0 c 0.0,0.0 -14.0,0.0 -14.0,0.0 c -1.1044921875,0.0 -2.0,0.8955078125 -2.0,2.0 c 0.0,0.0 0.0,14.0 0.0,14.0 c 0.0,1.1044921875 0.8955078125,2.0 2.0,2.0 c 0.0,0.0 14.0,0.0 14.0,0.0 c 1.1044921875,0.0 2.0,-0.8955078125 2.0,-2.0 c 0.0,0.0 0.0,-14.0 0.0,-14.0 c 0.0,-1.1044921875 -0.8955078125,-2.0 -2.0,-2.0 c 0.0,0.0 0.0,0.0 0.0,0.0 Z M -2.0,5.00001525879 c 0.0,0.0 -1.4234161377,-1.40159606934 -1.4234161377,-1.40159606934 c 0.0,0.0 1.41409301758,-1.41409301758 1.41409301758,-1.41409301758 c 0.0,0.0 0.00932312011719,-0.0124053955078 0.00932312011719,-0.0124053955078 c 0.0,0.0 0.0234069824219,-0.0235137939453 0.0234069824219,-0.0235137939453 c 0.0,0.0 1.41409301758,1.41409301758 1.41409301758,1.41409301758 c 0.0,0.0 -1.4375,1.43751525879 -1.4375,1.43751525879 Z"
+                    android:fillColor="#FF000000"
+                    android:fillAlpha="0"/>
+        </group>
+        <group
+                android:name="box_dilate"
+                android:scaleX="7.5"
+                android:scaleY="7.5">
+            <path
+                    android:name="box_inner_merged"
+                    android:pathData="M -7.0,-7.0 l 14.0,0.0 c 0.0,0.0 0.0,0.0 0.0,0.0 l 0.0,14.0 c 0.0,0.0 0.0,0.0 0.0,0.0 l -14.0,0.0 c 0.0,0.0 0.0,0.0 0.0,0.0 l 0.0,-14.0 c 0.0,0.0 0.0,0.0 0.0,0.0 Z M 7.0,-9.0 c 0.0,0.0 -14.0,0.0 -14.0,0.0 c -1.1044921875,0.0 -2.0,0.8955078125 -2.0,2.0 c 0.0,0.0 0.0,14.0 0.0,14.0 c 0.0,1.1044921875 0.8955078125,2.0 2.0,2.0 c 0.0,0.0 14.0,0.0 14.0,0.0 c 1.1044921875,0.0 2.0,-0.8955078125 2.0,-2.0 c 0.0,0.0 0.0,-14.0 0.0,-14.0 c 0.0,-1.1044921875 -0.8955078125,-2.0 -2.0,-2.0 c 0.0,0.0 0.0,0.0 0.0,0.0 Z"
+                    android:fillColor="#FF000000"/>
+        </group>
+    </group>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_btn_radio_material.xml b/current/support/v7/appcompat/res/drawable/abc_btn_radio_material.xml
index 6e9f9cf..4699fb4 100644
--- a/current/support/v7/appcompat/res/drawable/abc_btn_radio_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_btn_radio_material.xml
@@ -15,6 +15,6 @@
 -->
 
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
-    <item android:state_checked="true" android:drawable="@drawable/abc_btn_radio_to_on_mtrl_015" />
-    <item android:drawable="@drawable/abc_btn_radio_to_on_mtrl_000" />
-</selector>
\ No newline at end of file
+    <item android:state_checked="true" android:drawable="@drawable/abc_btn_radio_on_mtrl" />
+    <item android:drawable="@drawable/abc_btn_radio_off_mtrl" />
+</selector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_btn_radio_off_mtrl.xml b/current/support/v7/appcompat/res/drawable/abc_btn_radio_off_mtrl.xml
new file mode 100644
index 0000000..fc66a09
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_btn_radio_off_mtrl.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<vector
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        android:name="btn_radio_to_on_mtrl"
+        android:width="32dp"
+        android:viewportWidth="32"
+        android:height="32dp"
+        android:viewportHeight="32">
+    <group
+            android:name="btn_radio_to_on_mtrl_0"
+            android:translateX="16"
+            android:translateY="16" >
+        <group
+                android:name="ring_outer" >
+            <path
+                    android:name="ring_outer_path"
+                    android:strokeColor="#FF000000"
+                    android:strokeWidth="2"
+                    android:pathData="M 0.0,-9.0 c 4.9705627482,0.0 9.0,4.0294372518 9.0,9.0 c 0.0,4.9705627482 -4.0294372518,9.0 -9.0,9.0 c -4.9705627482,0.0 -9.0,-4.0294372518 -9.0,-9.0 c 0.0,-4.9705627482 4.0294372518,-9.0 9.0,-9.0 Z" />
+        </group>
+        <group
+                android:name="dot_group"
+                android:scaleX="0"
+                android:scaleY="0" >
+            <path
+                    android:name="dot_path"
+                    android:pathData="M 0.0,-5.0 c -2.7619934082,0.0 -5.0,2.2380065918 -5.0,5.0 c 0.0,2.7619934082 2.2380065918,5.0 5.0,5.0 c 2.7619934082,0.0 5.0,-2.2380065918 5.0,-5.0 c 0.0,-2.7619934082 -2.2380065918,-5.0 -5.0,-5.0 Z"
+                    android:fillColor="#FF000000" />
+        </group>
+    </group>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_btn_radio_on_mtrl.xml b/current/support/v7/appcompat/res/drawable/abc_btn_radio_on_mtrl.xml
new file mode 100644
index 0000000..448e2eb
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_btn_radio_on_mtrl.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<vector
+        xmlns:android="http://schemas.android.com/apk/res/android"
+        android:name="btn_radio_to_off_mtrl"
+        android:width="32dp"
+        android:viewportWidth="32"
+        android:height="32dp"
+        android:viewportHeight="32">
+    <group
+            android:name="btn_radio_to_off_mtrl_0"
+            android:translateX="16"
+            android:translateY="16" >
+        <group
+                android:name="ring_outer" >
+            <path
+                    android:name="ring_outer_path"
+                    android:strokeColor="#FF000000"
+                    android:strokeWidth="2"
+                    android:pathData="M 0.0,-9.0 c 4.9705627482,0.0 9.0,4.0294372518 9.0,9.0 c 0.0,4.9705627482 -4.0294372518,9.0 -9.0,9.0 c -4.9705627482,0.0 -9.0,-4.0294372518 -9.0,-9.0 c 0.0,-4.9705627482 4.0294372518,-9.0 9.0,-9.0 Z" />
+        </group>
+        <group
+                android:name="dot_group" >
+            <path
+                    android:name="dot_path"
+                    android:pathData="M 0.0,-5.0 c -2.7619934082,0.0 -5.0,2.2380065918 -5.0,5.0 c 0.0,2.7619934082 2.2380065918,5.0 5.0,5.0 c 2.7619934082,0.0 5.0,-2.2380065918 5.0,-5.0 c 0.0,-2.7619934082 -2.2380065918,-5.0 -5.0,-5.0 Z"
+                    android:fillColor="#FF000000" />
+        </group>
+    </group>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_cab_background_internal_bg.xml b/current/support/v7/appcompat/res/drawable/abc_cab_background_internal_bg.xml
index 9faf60a..45c4d9f 100644
--- a/current/support/v7/appcompat/res/drawable/abc_cab_background_internal_bg.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_cab_background_internal_bg.xml
@@ -20,4 +20,4 @@
 <shape xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">
     <solid android:color="@android:color/white" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_dark.xml b/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_dark.xml
index 41c4a6f..1bb10f2 100644
--- a/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_dark.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_dark.xml
@@ -23,4 +23,4 @@
         <corners android:radius="2dp" />
         <solid android:color="@color/background_floating_material_dark" />
     </shape>
-</inset>
\ No newline at end of file
+</inset>
diff --git a/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_light.xml b/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_light.xml
index 248b13a..a70d37c 100644
--- a/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_light.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_dialog_material_background_light.xml
@@ -23,4 +23,4 @@
         <corners android:radius="2dp" />
         <solid android:color="@color/background_floating_material_light" />
     </shape>
-</inset>
\ No newline at end of file
+</inset>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_ab_back_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_ab_back_material.xml
new file mode 100644
index 0000000..026ac9e
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_ab_back_material.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Copyright (C) 2015 The Android Open Source Project
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:autoMirrored="true"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M20,11L7.8,11l5.6,-5.6L12,4l-8,8l8,8l1.4,-1.4L7.8,13L20,13L20,11z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_clear_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_clear_material.xml
new file mode 100644
index 0000000..e6d106b
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_clear_material.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M19,6.41L17.59,5,12,10.59,6.41,5,5,6.41,10.59,12,5,17.59,6.41,19,12,13.41,17.59,19,19,17.59,13.41,12z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_go_search_api_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_go_search_api_material.xml
new file mode 100644
index 0000000..0c88119
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_go_search_api_material.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2015 The Android Open Source Project
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?attr/colorControlNormal">
+    <path
+        android:pathData="M10,6l-1.4,1.4 4.599999,4.6 -4.599999,4.6 1.4,1.4 6,-6z"
+        android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_menu_copy_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_menu_copy_material.xml
new file mode 100644
index 0000000..6af0e0c
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_menu_copy_material.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:autoMirrored="true"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M16,1L4,1C2.9,1 2,1.9 2,3l0,14l2,0L4,3l12,0L16,1zM19,5L8,5C6.9,5 6,5.9 6,7l0,14c0,1.1 0.9,2 2,2l11,0c1.1,0 2,-0.9 2,-2L21,7C21,5.9 20.1,5 19,5zM19,21L8,21L8,7l11,0L19,21z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_menu_cut_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_menu_cut_material.xml
new file mode 100644
index 0000000..22cb81d
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_menu_cut_material.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:autoMirrored="true"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M10,6c0,-2.2 -1.8,-4 -4,-4S2,3.8 2,6c0,2.2 1.8,4 4,4c0.6,0 1.1,-0.1 1.6,-0.4L10,12l-2.4,2.4C7.1,14.1 6.6,14 6,14c-2.2,0 -4,1.8 -4,4c0,2.2 1.8,4 4,4s4,-1.8 4,-4c0,-0.6 -0.1,-1.1 -0.4,-1.6L12,14l7,7l4,0L9.6,7.6C9.9,7.1 10,6.6 10,6zM6,8C4.9,8 4,7.1 4,6s0.9,-2 2,-2c1.1,0 2,0.9 2,2S7.1,8 6,8zM6,20c-1.1,0 -2,-0.9 -2,-2s0.9,-2 2,-2c1.1,0 2,0.9 2,2S7.1,20 6,20zM12,11.5c0.3,0 0.5,0.2 0.5,0.5c0,0.3 -0.2,0.5 -0.5,0.5c-0.3,0 -0.5,-0.2 -0.5,-0.5C11.5,11.7 11.7,11.5 12,11.5zM23,3l-4,0l-6,6l2,2L23,3z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_menu_overflow_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_menu_overflow_material.xml
new file mode 100644
index 0000000..34e8215
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_menu_overflow_material.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M12,8c1.1,0 2,-0.9 2,-2s-0.9,-2 -2,-2c-1.1,0 -2,0.9 -2,2S10.9,8 12,8zM12,10c-1.1,0 -2,0.9 -2,2s0.9,2 2,2c1.1,0 2,-0.9 2,-2S13.1,10 12,10zM12,16c-1.1,0 -2,0.9 -2,2s0.9,2 2,2c1.1,0 2,-0.9 2,-2S13.1,16 12,16z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_menu_paste_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_menu_paste_material.xml
new file mode 100644
index 0000000..b642aae
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_menu_paste_material.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:autoMirrored="true"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M19,2l-4.2,0c-0.4,-1.2 -1.5,-2 -2.8,-2c-1.3,0 -2.4,0.8 -2.8,2L5,2C3.9,2 3,2.9 3,4l0,16c0,1.1 0.9,2 2,2l14,0c1.1,0 2,-0.9 2,-2L21,4C21,2.9 20.1,2 19,2zM12,2c0.6,0 1,0.4 1,1s-0.4,1 -1,1c-0.6,0 -1,-0.4 -1,-1S11.4,2 12,2zM19,20L5,20L5,4l2,0l0,3l10,0L17,4l2,0L19,20z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_menu_selectall_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_menu_selectall_material.xml
new file mode 100644
index 0000000..cd0bbd5
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_menu_selectall_material.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:autoMirrored="true"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M3,5l2,0L5,3C3.9,3 3,3.9 3,5zM3,13l2,0l0,-2L3,11L3,13zM7,21l2,0l0,-2L7,19L7,21zM3,9l2,0L5,7L3,7L3,9zM13,3l-2,0l0,2l2,0L13,3zM19,3l0,2l2,0C21,3.9 20.1,3 19,3zM5,21l0,-2L3,19C3,20.1 3.9,21 5,21zM3,17l2,0l0,-2L3,15L3,17zM9,3L7,3l0,2l2,0L9,3zM11,21l2,0l0,-2l-2,0L11,21zM19,13l2,0l0,-2l-2,0L19,13zM19,21c1.1,0 2,-0.9 2,-2l-2,0L19,21zM19,9l2,0L21,7l-2,0L19,9zM19,17l2,0l0,-2l-2,0L19,17zM15,21l2,0l0,-2l-2,0L15,21zM15,5l2,0L17,3l-2,0L15,5zM7,17l10,0L17,7L7,7L7,17zM9,9l6,0l0,6L9,15L9,9z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_menu_share_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_menu_share_material.xml
new file mode 100644
index 0000000..ce5ceff
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_menu_share_material.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?attr/colorControlNormal">
+    <path
+            android:pathData="M18,16.1c-0.8,0 -1.5,0.3 -2,0.8l-7.1,-4.2C9,12.5 9,12.2 9,12s0,-0.5 -0.1,-0.7L16,7.2C16.5,7.7 17.200001,8 18,8c1.7,0 3,-1.3 3,-3s-1.3,-3 -3,-3s-3,1.3 -3,3c0,0.2 0,0.5 0.1,0.7L8,9.8C7.5,9.3 6.8,9 6,9c-1.7,0 -2.9,1.2 -2.9,2.9s1.3,3 3,3c0.8,0 1.5,-0.3 2,-0.8l7.1,4.2c-0.1,0.3 -0.1,0.5 -0.1,0.7c0,1.6 1.3,2.9 2.9,2.9s2.9,-1.3 2.9,-2.9S19.6,16.1 18,16.1z"
+            android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_ic_voice_search_api_material.xml b/current/support/v7/appcompat/res/drawable/abc_ic_voice_search_api_material.xml
new file mode 100644
index 0000000..143db55
--- /dev/null
+++ b/current/support/v7/appcompat/res/drawable/abc_ic_voice_search_api_material.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+        android:width="24dp"
+        android:height="24dp"
+        android:viewportWidth="24.0"
+        android:viewportHeight="24.0"
+        android:tint="?attr/colorControlNormal">
+    <path
+        android:pathData="M12,14c1.7,0 3,-1.3 3,-3l0,-6c0,-1.7 -1.3,-3 -3,-3c-1.7,0 -3,1.3 -3,3l0,6C9,12.7 10.3,14 12,14zM17.299999,11c0,3 -2.5,5.1 -5.3,5.1c-2.8,0 -5.3,-2.1 -5.3,-5.1L5,11c0,3.4 2.7,6.2 6,6.7L11,21l2,0l0,-3.3c3.3,-0.5 6,-3.3 6,-6.7L17.299999,11.000001z"
+        android:fillColor="@android:color/white"/>
+</vector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_seekbar_thumb_material.xml b/current/support/v7/appcompat/res/drawable/abc_seekbar_thumb_material.xml
index 7fea83b..091d1e5 100644
--- a/current/support/v7/appcompat/res/drawable/abc_seekbar_thumb_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_seekbar_thumb_material.xml
@@ -32,4 +32,4 @@
         <bitmap android:src="@drawable/abc_scrubber_control_to_pressed_mtrl_000"
                 android:gravity="center"/>
     </item>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_seekbar_track_material.xml b/current/support/v7/appcompat/res/drawable/abc_seekbar_track_material.xml
index e68ac03..d9030d5 100644
--- a/current/support/v7/appcompat/res/drawable/abc_seekbar_track_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_seekbar_track_material.xml
@@ -37,4 +37,4 @@
             </selector>
         </scale>
     </item>
-</layer-list>
\ No newline at end of file
+</layer-list>
diff --git a/current/support/v7/appcompat/res/drawable/abc_spinner_textfield_background_material.xml b/current/support/v7/appcompat/res/drawable/abc_spinner_textfield_background_material.xml
index d0f46a8..e5de811 100644
--- a/current/support/v7/appcompat/res/drawable/abc_spinner_textfield_background_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_spinner_textfield_background_material.xml
@@ -33,4 +33,4 @@
             </layer-list>
         </item>
     </selector>
-</inset>
\ No newline at end of file
+</inset>
diff --git a/current/support/v7/appcompat/res/drawable/abc_switch_thumb_material.xml b/current/support/v7/appcompat/res/drawable/abc_switch_thumb_material.xml
index ee96ec2..71ff2e5 100644
--- a/current/support/v7/appcompat/res/drawable/abc_switch_thumb_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_switch_thumb_material.xml
@@ -17,4 +17,4 @@
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
     <item android:state_checked="true" android:drawable="@drawable/abc_btn_switch_to_on_mtrl_00012" />
     <item android:drawable="@drawable/abc_btn_switch_to_on_mtrl_00001" />
-</selector>
\ No newline at end of file
+</selector>
diff --git a/current/support/v7/appcompat/res/drawable/abc_text_cursor_material.xml b/current/support/v7/appcompat/res/drawable/abc_text_cursor_material.xml
index 885670c..c4f9936 100644
--- a/current/support/v7/appcompat/res/drawable/abc_text_cursor_material.xml
+++ b/current/support/v7/appcompat/res/drawable/abc_text_cursor_material.xml
@@ -20,4 +20,4 @@
     <size android:height="2dp"
           android:width="2dp"/>
     <solid android:color="@android:color/white"/>
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v7/appcompat/res/layout/abc_action_bar_view_list_nav_layout.xml b/current/support/v7/appcompat/res/layout/abc_action_bar_view_list_nav_layout.xml
index 5c105ab..72baf04 100644
--- a/current/support/v7/appcompat/res/layout/abc_action_bar_view_list_nav_layout.xml
+++ b/current/support/v7/appcompat/res/layout/abc_action_bar_view_list_nav_layout.xml
@@ -20,4 +20,4 @@
               android:layout_width="fill_parent"
               android:layout_height="fill_parent"
               style="?attr/actionBarTabBarStyle">
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/current/support/v7/appcompat/res/layout/abc_action_mode_close_item_material.xml b/current/support/v7/appcompat/res/layout/abc_action_mode_close_item_material.xml
index 2944d98..fa5733d 100644
--- a/current/support/v7/appcompat/res/layout/abc_action_mode_close_item_material.xml
+++ b/current/support/v7/appcompat/res/layout/abc_action_mode_close_item_material.xml
@@ -16,11 +16,12 @@
 
 <ImageView
         xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:app="http://schemas.android.com/apk/res-auto"
         android:id="@+id/action_mode_close_button"
         android:contentDescription="@string/abc_action_mode_done"
         android:focusable="true"
         android:clickable="true"
-        android:src="?attr/actionModeCloseDrawable"
+        app:srcCompat="?attr/actionModeCloseDrawable"
         style="?attr/actionModeCloseButtonStyle"
         android:layout_width="wrap_content"
-        android:layout_height="match_parent"/>
\ No newline at end of file
+        android:layout_height="match_parent"/>
diff --git a/current/support/v7/appcompat/res/layout/abc_activity_chooser_view.xml b/current/support/v7/appcompat/res/layout/abc_activity_chooser_view.xml
index 2522f1a..0100c23 100644
--- a/current/support/v7/appcompat/res/layout/abc_activity_chooser_view.xml
+++ b/current/support/v7/appcompat/res/layout/abc_activity_chooser_view.xml
@@ -31,16 +31,16 @@
         android:layout_gravity="center"
         android:focusable="true"
         android:addStatesFromChildren="true"
-        android:background="?attr/actionBarItemBackground">
+        android:background="?attr/actionBarItemBackground"
+        android:paddingTop="2dip"
+        android:paddingBottom="2dip"
+        android:paddingLeft="12dip"
+        android:paddingRight="12dip">
 
         <ImageView android:id="@+id/image"
             android:layout_width="32dip"
             android:layout_height="32dip"
             android:layout_gravity="center"
-            android:layout_marginTop="2dip"
-            android:layout_marginBottom="2dip"
-            android:layout_marginLeft="12dip"
-            android:layout_marginRight="12dip"
             android:scaleType="fitCenter"
             android:adjustViewBounds="true" />
 
@@ -53,16 +53,16 @@
         android:layout_gravity="center"
         android:focusable="true"
         android:addStatesFromChildren="true"
-        android:background="?attr/actionBarItemBackground">
+        android:background="?attr/actionBarItemBackground"
+        android:paddingTop="2dip"
+        android:paddingBottom="2dip"
+        android:paddingLeft="12dip"
+        android:paddingRight="12dip">
 
         <ImageView android:id="@+id/image"
             android:layout_width="32dip"
             android:layout_height="32dip"
             android:layout_gravity="center"
-            android:layout_marginTop="2dip"
-            android:layout_marginBottom="2dip"
-            android:layout_marginLeft="12dip"
-            android:layout_marginRight="12dip"
             android:scaleType="fitCenter"
             android:adjustViewBounds="true" />
 
diff --git a/current/support/v7/appcompat/res/layout/abc_activity_chooser_view_list_item.xml b/current/support/v7/appcompat/res/layout/abc_activity_chooser_view_list_item.xml
index 887427d..a239a42 100644
--- a/current/support/v7/appcompat/res/layout/abc_activity_chooser_view_list_item.xml
+++ b/current/support/v7/appcompat/res/layout/abc_activity_chooser_view_list_item.xml
@@ -49,4 +49,4 @@
 
     </LinearLayout>
 
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/current/support/v7/appcompat/res/layout/abc_alert_dialog_material.xml b/current/support/v7/appcompat/res/layout/abc_alert_dialog_material.xml
index 3237533..4d94072 100644
--- a/current/support/v7/appcompat/res/layout/abc_alert_dialog_material.xml
+++ b/current/support/v7/appcompat/res/layout/abc_alert_dialog_material.xml
@@ -124,4 +124,4 @@
 
     <include layout="@layout/abc_alert_dialog_button_bar_material" />
 
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/current/support/v7/appcompat/res/layout/abc_dialog_title_material.xml b/current/support/v7/appcompat/res/layout/abc_dialog_title_material.xml
index 1ea20c5..3136332 100644
--- a/current/support/v7/appcompat/res/layout/abc_dialog_title_material.xml
+++ b/current/support/v7/appcompat/res/layout/abc_dialog_title_material.xml
@@ -44,4 +44,4 @@
             android:layout_height="wrap_content"
             android:layout_weight="1"/>
 
-</android.support.v7.widget.FitWindowsLinearLayout>
\ No newline at end of file
+</android.support.v7.widget.FitWindowsLinearLayout>
diff --git a/current/support/v7/appcompat/res/layout/abc_screen_simple_overlay_action_mode.xml b/current/support/v7/appcompat/res/layout/abc_screen_simple_overlay_action_mode.xml
index c02c2aa..1f58d1e 100644
--- a/current/support/v7/appcompat/res/layout/abc_screen_simple_overlay_action_mode.xml
+++ b/current/support/v7/appcompat/res/layout/abc_screen_simple_overlay_action_mode.xml
@@ -36,4 +36,4 @@
             android:layout_width="match_parent"
             android:layout_height="wrap_content" />
 
-</android.support.v7.widget.FitWindowsFrameLayout>
\ No newline at end of file
+</android.support.v7.widget.FitWindowsFrameLayout>
diff --git a/current/support/v7/appcompat/res/layout/abc_select_dialog_material.xml b/current/support/v7/appcompat/res/layout/abc_select_dialog_material.xml
index 12bcbf1..bf46215 100644
--- a/current/support/v7/appcompat/res/layout/abc_select_dialog_material.xml
+++ b/current/support/v7/appcompat/res/layout/abc_select_dialog_material.xml
@@ -32,4 +32,4 @@
       android:paddingTop="@dimen/abc_dialog_list_padding_vertical_material"
       android:paddingBottom="@dimen/abc_dialog_list_padding_vertical_material"
       android:clipToPadding="false"
-      style="@style/Widget.AppCompat.ListView" />
\ No newline at end of file
+      style="@style/Widget.AppCompat.ListView" />
diff --git a/current/support/v7/appcompat/res/layout/notification_media_action.xml b/current/support/v7/appcompat/res/layout/notification_media_action.xml
index d546792..448a64c 100644
--- a/current/support/v7/appcompat/res/layout/notification_media_action.xml
+++ b/current/support/v7/appcompat/res/layout/notification_media_action.xml
@@ -22,4 +22,4 @@
     android:layout_marginLeft="2dp"
     android:layout_marginRight="2dp"
     android:layout_weight="1"
-    android:gravity="center"/>
\ No newline at end of file
+    android:gravity="center"/>
diff --git a/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml b/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml
index e31d891..c22a730 100644
--- a/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml
+++ b/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml
@@ -16,6 +16,7 @@
   -->
 
 <ImageButton xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
     style="?android:attr/borderlessButtonStyle"
     android:id="@+id/cancel_action"
     android:layout_width="48dp"
@@ -23,6 +24,6 @@
     android:layout_marginLeft="2dp"
     android:layout_marginRight="2dp"
     android:layout_weight="1"
-    android:src="@drawable/abc_ic_clear_mtrl_alpha"
+    app:srcCompat="@drawable/abc_ic_clear_material"
     android:gravity="center"
-    android:visibility="gone"/>
\ No newline at end of file
+    android:visibility="gone"/>
diff --git a/current/support/v7/appcompat/res/layout/notification_template_lines.xml b/current/support/v7/appcompat/res/layout/notification_template_lines.xml
index 42ba776..0d0aadd 100644
--- a/current/support/v7/appcompat/res/layout/notification_template_lines.xml
+++ b/current/support/v7/appcompat/res/layout/notification_template_lines.xml
@@ -105,4 +105,4 @@
             android:paddingStart="8dp"
             />
     </LinearLayout>
-</LinearLayout>
\ No newline at end of file
+</LinearLayout>
diff --git a/current/support/v7/appcompat/res/layout/support_simple_spinner_dropdown_item.xml b/current/support/v7/appcompat/res/layout/support_simple_spinner_dropdown_item.xml
index d2f177a..52b22f0 100644
--- a/current/support/v7/appcompat/res/layout/support_simple_spinner_dropdown_item.xml
+++ b/current/support/v7/appcompat/res/layout/support_simple_spinner_dropdown_item.xml
@@ -22,4 +22,4 @@
           android:singleLine="true"
           android:layout_width="match_parent"
           android:layout_height="?attr/dropdownListPreferredItemHeight"
-          android:ellipsize="marquee"/>
\ No newline at end of file
+          android:ellipsize="marquee"/>
diff --git a/current/support/v7/appcompat/res/values-b+sr+Latn/strings.xml b/current/support/v7/appcompat/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..fc92231
--- /dev/null
+++ b/current/support/v7/appcompat/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2012 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="abc_action_mode_done" msgid="4076576682505996667">"Gotovo"</string>
+    <string name="abc_action_bar_home_description" msgid="4600421777120114993">"Odlazak na Početnu"</string>
+    <string name="abc_action_bar_up_description" msgid="1594238315039666878">"Kretanje nagore"</string>
+    <string name="abc_action_menu_overflow_description" msgid="3588849162933574182">"Još opcija"</string>
+    <string name="abc_toolbar_collapse_description" msgid="1603543279005712093">"Skupi"</string>
+    <string name="abc_action_bar_home_description_format" msgid="1397052879051804371">"%1$s, %2$s"</string>
+    <string name="abc_action_bar_home_subtitle_description_format" msgid="6623331958280229229">"%1$s, %2$s, %3$s"</string>
+    <string name="abc_searchview_description_search" msgid="8264924765203268293">"Pretraga"</string>
+    <string name="abc_search_hint" msgid="7723749260725869598">"Pretražite..."</string>
+    <string name="abc_searchview_description_query" msgid="2550479030709304392">"Upit za pretragu"</string>
+    <string name="abc_searchview_description_clear" msgid="3691816814315814921">"Brisanje upita"</string>
+    <string name="abc_searchview_description_submit" msgid="8928215447528550784">"Slanje upita"</string>
+    <string name="abc_searchview_description_voice" msgid="893419373245838918">"Glasovna pretraga"</string>
+    <string name="abc_activitychooserview_choose_application" msgid="2031811694353399454">"Izbor aplikacije"</string>
+    <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Prikaži sve"</string>
+    <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Deli sa aplikacijom %s"</string>
+    <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Deli sa"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
+    <string name="abc_capital_on" msgid="3405795526292276155">"UKLJUČI"</string>
+    <string name="abc_capital_off" msgid="121134116657445385">"ISKLJUČI"</string>
+</resources>
diff --git a/current/support/v7/appcompat/res/values-hdpi/styles_base.xml b/current/support/v7/appcompat/res/values-hdpi/styles_base.xml
index fd55289..bfe60b6 100644
--- a/current/support/v7/appcompat/res/values-hdpi/styles_base.xml
+++ b/current/support/v7/appcompat/res/values-hdpi/styles_base.xml
@@ -20,4 +20,4 @@
           <item name="gapBetweenBars">3.33dp</item>
           <item name="drawableSize">24dp</item>
      </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-land/dimens.xml b/current/support/v7/appcompat/res/values-land/dimens.xml
index f0b6892..25bf75d 100644
--- a/current/support/v7/appcompat/res/values-land/dimens.xml
+++ b/current/support/v7/appcompat/res/values-land/dimens.xml
@@ -18,4 +18,4 @@
     <!-- Size of the indeterminate Progress Bar -->
     <dimen name="abc_action_bar_progress_bar_size">32dp</dimen>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-land/dimens_material.xml b/current/support/v7/appcompat/res/values-land/dimens_material.xml
index 80b7463..f1cb18a 100644
--- a/current/support/v7/appcompat/res/values-land/dimens_material.xml
+++ b/current/support/v7/appcompat/res/values-land/dimens_material.xml
@@ -22,4 +22,4 @@
     <!-- Default text size for action bar subtitle.-->
     <dimen name="abc_text_size_subtitle_material_toolbar">12dp</dimen>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-night/themes_daynight.xml b/current/support/v7/appcompat/res/values-night/themes_daynight.xml
index 965d355..8736722 100644
--- a/current/support/v7/appcompat/res/values-night/themes_daynight.xml
+++ b/current/support/v7/appcompat/res/values-night/themes_daynight.xml
@@ -16,7 +16,7 @@
 
 <resources>
 
-    <!-- Material theme (day/night vesion) for activities. -->
+    <!-- AppCompat theme (day/night vesion) for activities. -->
     <style name="Theme.AppCompat.DayNight" parent="Theme.AppCompat" />
 
     <!-- Variant of AppCompat.DayNight that has a solid (opaque) action bar
@@ -27,7 +27,7 @@
     <!-- Variant of AppCompat.DayNight with no action bar.  -->
     <style name="Theme.AppCompat.DayNight.NoActionBar" parent="Theme.AppCompat.NoActionBar" />
 
-    <!-- Material theme (day/night vesion) for dialog windows and activities,
+    <!-- AppCompat theme (day/night vesion) for dialog windows and activities,
          which is used by the {@code android.support.v7.app.Dialog} class. This changes
          the window to be floating (not fill the entire screen), and puts a
          frame around its contents. You can set this theme on an activity if
@@ -43,8 +43,8 @@
          (large, xlarge). -->
     <style name="Theme.AppCompat.DayNight.DialogWhenLarge" parent="Theme.AppCompat.DialogWhenLarge" />
 
-    <!-- Material user theme for alert dialog windows, which is used by the
+    <!-- AppCompat user theme for alert dialog windows, which is used by the
          {@code android.support.v7.app.AlertDialog} class. -->
     <style name="Theme.AppCompat.DayNight.Dialog.Alert" parent="Theme.AppCompat.Dialog.Alert" />
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-sw600dp/config.xml b/current/support/v7/appcompat/res/values-sw600dp/config.xml
index fba21e1..732dba5 100644
--- a/current/support/v7/appcompat/res/values-sw600dp/config.xml
+++ b/current/support/v7/appcompat/res/values-sw600dp/config.xml
@@ -22,4 +22,4 @@
 <resources>
     <!-- see comment in values/config.xml -->
     <dimen name="abc_config_prefDialogWidth">580dp</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-sw600dp/dimens.xml b/current/support/v7/appcompat/res/values-sw600dp/dimens.xml
index a83abb1..9958c75 100644
--- a/current/support/v7/appcompat/res/values-sw600dp/dimens.xml
+++ b/current/support/v7/appcompat/res/values-sw600dp/dimens.xml
@@ -28,4 +28,4 @@
     <!-- Default end padding of an action bar. -->
     <dimen name="abc_action_bar_default_padding_end_material">8dp</dimen>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-v11/styles_base.xml b/current/support/v7/appcompat/res/values-v11/styles_base.xml
index f651320..083e56e 100644
--- a/current/support/v7/appcompat/res/values-v11/styles_base.xml
+++ b/current/support/v7/appcompat/res/values-v11/styles_base.xml
@@ -33,4 +33,4 @@
            parent="android:Widget.Holo.ProgressBar">
     </style>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-v11/styles_base_text.xml b/current/support/v7/appcompat/res/values-v11/styles_base_text.xml
index 4227794..a2ce395 100644
--- a/current/support/v7/appcompat/res/values-v11/styles_base_text.xml
+++ b/current/support/v7/appcompat/res/values-v11/styles_base_text.xml
@@ -61,4 +61,4 @@
         <item name="android:textColorLink">?android:attr/textColorLinkInverse</item>
     </style>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-v13/bools.xml b/current/support/v7/appcompat/res/values-v13/bools.xml
new file mode 100644
index 0000000..d0c646a
--- /dev/null
+++ b/current/support/v7/appcompat/res/values-v13/bools.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<resources>
+    <!-- Whether to allow vertically stacked button bars. This is disabled for
+         configurations with a small (e.g. less than 320dp) screen height. -->
+    <bool name="abc_allow_stacked_button_bar">false</bool>
+</resources>
diff --git a/current/support/v7/appcompat/res/values-v14/styles.xml b/current/support/v7/appcompat/res/values-v14/styles.xml
index f54796d..8a920bf 100644
--- a/current/support/v7/appcompat/res/values-v14/styles.xml
+++ b/current/support/v7/appcompat/res/values-v14/styles.xml
@@ -30,4 +30,4 @@
     <style name="TextAppearance.StatusBar.EventContent.Info"/>
     <style name="TextAppearance.StatusBar.EventContent.Time"/>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-v14/styles_base_text.xml b/current/support/v7/appcompat/res/values-v14/styles_base_text.xml
index 54c8de2..188618d 100644
--- a/current/support/v7/appcompat/res/values-v14/styles_base_text.xml
+++ b/current/support/v7/appcompat/res/values-v14/styles_base_text.xml
@@ -23,4 +23,4 @@
         <item name="android:textColor">?android:textColorPrimary</item>
     </style>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values-v21/themes_base.xml b/current/support/v7/appcompat/res/values-v21/themes_base.xml
index 6c2aa26..b517723 100644
--- a/current/support/v7/appcompat/res/values-v21/themes_base.xml
+++ b/current/support/v7/appcompat/res/values-v21/themes_base.xml
@@ -27,6 +27,9 @@
         <item name="android:windowNoTitle">true</item>
         <item name="android:windowActionBar">false</item>
 
+        <item name="android:textColorLink">?android:attr/colorAccent</item>
+        <item name="android:textColorLinkInverse">?android:attr/colorAccent</item>
+
         <item name="android:buttonBarStyle">?attr/buttonBarStyle</item>
         <item name="android:buttonBarButtonStyle">?attr/buttonBarButtonStyle</item>
     </style>
@@ -35,6 +38,9 @@
         <item name="android:windowNoTitle">true</item>
         <item name="android:windowActionBar">false</item>
 
+        <item name="android:textColorLink">?android:attr/colorAccent</item>
+        <item name="android:textColorLinkInverse">?android:attr/colorAccent</item>
+
         <item name="android:buttonBarStyle">?attr/buttonBarStyle</item>
         <item name="android:buttonBarButtonStyle">?attr/buttonBarButtonStyle</item>
     </style>
@@ -64,7 +70,7 @@
         <item name="borderlessButtonStyle">?android:borderlessButtonStyle</item>
         <item name="dividerHorizontal">?android:attr/dividerHorizontal</item>
         <item name="dividerVertical">?android:attr/dividerVertical</item>
-        <item name="editTextBackground">?android:attr/editTextBackground</item>
+        <item name="editTextBackground">@drawable/abc_edit_text_material</item>
         <item name="editTextColor">?android:attr/editTextColor</item>
         <item name="listChoiceBackgroundIndicator">?android:attr/listChoiceBackgroundIndicator</item>
 
@@ -109,7 +115,7 @@
         <item name="borderlessButtonStyle">?android:borderlessButtonStyle</item>
         <item name="dividerHorizontal">?android:attr/dividerHorizontal</item>
         <item name="dividerVertical">?android:attr/dividerVertical</item>
-        <item name="editTextBackground">?android:attr/editTextBackground</item>
+        <item name="editTextBackground">@drawable/abc_edit_text_material</item>
         <item name="editTextColor">?android:attr/editTextColor</item>
         <item name="listChoiceBackgroundIndicator">?android:attr/listChoiceBackgroundIndicator</item>
 
diff --git a/current/support/v7/appcompat/res/values-v22/themes_base.xml b/current/support/v7/appcompat/res/values-v22/themes_base.xml
index 8a38724..8c39fac 100644
--- a/current/support/v7/appcompat/res/values-v22/themes_base.xml
+++ b/current/support/v7/appcompat/res/values-v22/themes_base.xml
@@ -22,10 +22,14 @@
 
     <style name="Base.V22.Theme.AppCompat" parent="Base.V21.Theme.AppCompat">
         <item name="actionModeShareDrawable">?android:attr/actionModeShareDrawable</item>
+        <!-- We use the framework provided edit text background on 22+ -->
+        <item name="editTextBackground">?android:attr/editTextBackground</item>
     </style>
 
     <style name="Base.V22.Theme.AppCompat.Light" parent="Base.V21.Theme.AppCompat.Light">
         <item name="actionModeShareDrawable">?android:attr/actionModeShareDrawable</item>
+        <!-- We use the framework provided edit text background on 22+ -->
+        <item name="editTextBackground">?android:attr/editTextBackground</item>
     </style>
 
 </resources>
diff --git a/current/support/v7/appcompat/res/values-v23/styles_base_text.xml b/current/support/v7/appcompat/res/values-v23/styles_base_text.xml
index 3fbae02..9e73338 100644
--- a/current/support/v7/appcompat/res/values-v23/styles_base_text.xml
+++ b/current/support/v7/appcompat/res/values-v23/styles_base_text.xml
@@ -18,4 +18,4 @@
 
     <style name="Base.TextAppearance.AppCompat.Widget.Button.Inverse" parent="android:TextAppearance.Material.Widget.Button.Inverse" />
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values/attrs.xml b/current/support/v7/appcompat/res/values/attrs.xml
index b64ef6a..a2360aa 100644
--- a/current/support/v7/appcompat/res/values/attrs.xml
+++ b/current/support/v7/appcompat/res/values/attrs.xml
@@ -993,4 +993,10 @@
         <attr name="android:alpha"/>
     </declare-styleable>
 
+    <declare-styleable name="AppCompatImageView">
+        <attr name="android:src"/>
+        <!-- TODO -->
+        <attr name="srcCompat" format="reference" />
+    </declare-styleable>
+
 </resources>
diff --git a/current/support/v7/appcompat/res/values/bools.xml b/current/support/v7/appcompat/res/values/bools.xml
index 6e1089f..825ece0 100644
--- a/current/support/v7/appcompat/res/values/bools.xml
+++ b/current/support/v7/appcompat/res/values/bools.xml
@@ -19,4 +19,8 @@
     <bool name="abc_action_bar_embed_tabs">true</bool>
 
     <bool name="abc_config_showMenuShortcutsWhenKeyboardPresent">false</bool>
+
+    <!-- Whether to allow vertically stacked button bars. This is enabled for
+         all < v13 devices. -->
+    <bool name="abc_allow_stacked_button_bar">true</bool>
 </resources>
diff --git a/current/support/v7/appcompat/res/values/colors.xml b/current/support/v7/appcompat/res/values/colors.xml
index 0ce01d2..3f9fe99 100644
--- a/current/support/v7/appcompat/res/values/colors.xml
+++ b/current/support/v7/appcompat/res/values/colors.xml
@@ -21,4 +21,4 @@
     <color name="abc_input_method_navigation_guard">@android:color/black</color>
 
     <drawable name="notification_template_icon_bg">#3333B5E5</drawable>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values/strings.xml b/current/support/v7/appcompat/res/values/strings.xml
index 6e2a622..c2bb43c 100644
--- a/current/support/v7/appcompat/res/values/strings.xml
+++ b/current/support/v7/appcompat/res/values/strings.xml
@@ -73,4 +73,4 @@
     <string name="abc_capital_on">ON</string>
     <!-- Default text for a button that can be toggled on and off. -->
     <string name="abc_capital_off">OFF</string>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values/styles_base.xml b/current/support/v7/appcompat/res/values/styles_base.xml
index a0e24ed..0b1086d 100644
--- a/current/support/v7/appcompat/res/values/styles_base.xml
+++ b/current/support/v7/appcompat/res/values/styles_base.xml
@@ -75,7 +75,7 @@
     </style>
 
     <style name="Base.Widget.AppCompat.ActionButton.Overflow" parent="RtlUnderlay.Widget.AppCompat.ActionButton.Overflow">
-        <item name="android:src">@drawable/abc_ic_menu_moreoverflow_mtrl_alpha</item>
+        <item name="srcCompat">@drawable/abc_ic_menu_overflow_material</item>
         <item name="android:background">?attr/actionBarItemBackground</item>
         <item name="android:contentDescription">@string/abc_action_menu_overflow_description</item>
         <item name="android:minWidth">@dimen/abc_action_button_min_width_overflow_material</item>
@@ -301,7 +301,7 @@
         <item name="subtitleTextAppearance">@style/TextAppearance.Widget.AppCompat.Toolbar.Subtitle</item>
         <item name="android:minHeight">?attr/actionBarSize</item>
         <item name="titleMargin">4dp</item>
-        <item name="maxButtonHeight">56dp</item>
+        <item name="maxButtonHeight">@dimen/abc_action_bar_default_height_material</item>
         <item name="buttonGravity">top</item>
         <item name="collapseIcon">?attr/homeAsUpIndicator</item>
         <item name="collapseContentDescription">@string/abc_toolbar_collapse_description</item>
@@ -328,11 +328,11 @@
         <item name="layout">@layout/abc_search_view</item>
         <item name="queryBackground">@drawable/abc_textfield_search_material</item>
         <item name="submitBackground">@drawable/abc_textfield_search_material</item>
-        <item name="closeIcon">@drawable/abc_ic_clear_mtrl_alpha</item>
+        <item name="closeIcon">@drawable/abc_ic_clear_material</item>
         <item name="searchIcon">@drawable/abc_ic_search_api_mtrl_alpha</item>
         <item name="searchHintIcon">@drawable/abc_ic_search_api_mtrl_alpha</item>
-        <item name="goIcon">@drawable/abc_ic_go_search_api_mtrl_alpha</item>
-        <item name="voiceIcon">@drawable/abc_ic_voice_search_api_mtrl_alpha</item>
+        <item name="goIcon">@drawable/abc_ic_go_search_api_material</item>
+        <item name="voiceIcon">@drawable/abc_ic_voice_search_api_material</item>
         <item name="commitIcon">@drawable/abc_ic_commit_search_api_mtrl_alpha</item>
         <item name="suggestionRowLayout">@layout/abc_search_dropdown_item_icons_2line</item>
     </style>
diff --git a/current/support/v7/appcompat/res/values/styles_base_text.xml b/current/support/v7/appcompat/res/values/styles_base_text.xml
index 8597179..a230a73 100644
--- a/current/support/v7/appcompat/res/values/styles_base_text.xml
+++ b/current/support/v7/appcompat/res/values/styles_base_text.xml
@@ -139,4 +139,4 @@
         <item name="android:textColorHint">?android:attr/textColorHintInverse</item>
     </style>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/appcompat/res/values/themes_base.xml b/current/support/v7/appcompat/res/values/themes_base.xml
index 38757df..4aaaed1 100644
--- a/current/support/v7/appcompat/res/values/themes_base.xml
+++ b/current/support/v7/appcompat/res/values/themes_base.xml
@@ -123,7 +123,7 @@
         <item name="selectableItemBackground">@drawable/abc_item_background_holo_dark</item>
         <item name="selectableItemBackgroundBorderless">?attr/selectableItemBackground</item>
         <item name="borderlessButtonStyle">@style/Widget.AppCompat.Button.Borderless</item>
-        <item name="homeAsUpIndicator">@drawable/abc_ic_ab_back_mtrl_am_alpha</item>
+        <item name="homeAsUpIndicator">@drawable/abc_ic_ab_back_material</item>
 
         <item name="dividerVertical">@drawable/abc_list_divider_mtrl_alpha</item>
         <item name="dividerHorizontal">@drawable/abc_list_divider_mtrl_alpha</item>
@@ -152,14 +152,14 @@
         <item name="actionModeStyle">@style/Widget.AppCompat.ActionMode</item>
         <item name="actionModeBackground">@drawable/abc_cab_background_top_material</item>
         <item name="actionModeSplitBackground">?attr/colorPrimaryDark</item>
-        <item name="actionModeCloseDrawable">@drawable/abc_ic_ab_back_mtrl_am_alpha</item>
+        <item name="actionModeCloseDrawable">@drawable/abc_ic_ab_back_material</item>
         <item name="actionModeCloseButtonStyle">@style/Widget.AppCompat.ActionButton.CloseMode</item>
 
-        <item name="actionModeCutDrawable">@drawable/abc_ic_menu_cut_mtrl_alpha</item>
-        <item name="actionModeCopyDrawable">@drawable/abc_ic_menu_copy_mtrl_am_alpha</item>
-        <item name="actionModePasteDrawable">@drawable/abc_ic_menu_paste_mtrl_am_alpha</item>
-        <item name="actionModeSelectAllDrawable">@drawable/abc_ic_menu_selectall_mtrl_alpha</item>
-        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_mtrl_alpha</item>
+        <item name="actionModeCutDrawable">@drawable/abc_ic_menu_cut_material</item>
+        <item name="actionModeCopyDrawable">@drawable/abc_ic_menu_copy_material</item>
+        <item name="actionModePasteDrawable">@drawable/abc_ic_menu_paste_material</item>
+        <item name="actionModeSelectAllDrawable">@drawable/abc_ic_menu_selectall_material</item>
+        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_material</item>
 
         <!-- Panel attributes -->
         <item name="panelMenuListWidth">@dimen/abc_panel_menu_list_width</item>
@@ -280,7 +280,7 @@
         <item name="selectableItemBackground">@drawable/abc_item_background_holo_light</item>
         <item name="selectableItemBackgroundBorderless">?attr/selectableItemBackground</item>
         <item name="borderlessButtonStyle">@style/Widget.AppCompat.Button.Borderless</item>
-        <item name="homeAsUpIndicator">@drawable/abc_ic_ab_back_mtrl_am_alpha</item>
+        <item name="homeAsUpIndicator">@drawable/abc_ic_ab_back_material</item>
 
         <item name="dividerVertical">@drawable/abc_list_divider_mtrl_alpha</item>
         <item name="dividerHorizontal">@drawable/abc_list_divider_mtrl_alpha</item>
@@ -306,14 +306,14 @@
         <item name="actionModeStyle">@style/Widget.AppCompat.ActionMode</item>
         <item name="actionModeBackground">@drawable/abc_cab_background_top_material</item>
         <item name="actionModeSplitBackground">?attr/colorPrimaryDark</item>
-        <item name="actionModeCloseDrawable">@drawable/abc_ic_ab_back_mtrl_am_alpha</item>
+        <item name="actionModeCloseDrawable">@drawable/abc_ic_ab_back_material</item>
         <item name="actionModeCloseButtonStyle">@style/Widget.AppCompat.ActionButton.CloseMode</item>
 
-        <item name="actionModeCutDrawable">@drawable/abc_ic_menu_cut_mtrl_alpha</item>
-        <item name="actionModeCopyDrawable">@drawable/abc_ic_menu_copy_mtrl_am_alpha</item>
-        <item name="actionModePasteDrawable">@drawable/abc_ic_menu_paste_mtrl_am_alpha</item>
-        <item name="actionModeSelectAllDrawable">@drawable/abc_ic_menu_selectall_mtrl_alpha</item>
-        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_mtrl_alpha</item>
+        <item name="actionModeCutDrawable">@drawable/abc_ic_menu_cut_material</item>
+        <item name="actionModeCopyDrawable">@drawable/abc_ic_menu_copy_material</item>
+        <item name="actionModePasteDrawable">@drawable/abc_ic_menu_paste_material</item>
+        <item name="actionModeSelectAllDrawable">@drawable/abc_ic_menu_selectall_material</item>
+        <item name="actionModeShareDrawable">@drawable/abc_ic_menu_share_material</item>
 
         <!-- Dropdown Spinner Attributes -->
         <item name="actionDropDownStyle">@style/Widget.AppCompat.Light.Spinner.DropDown.ActionBar</item>
diff --git a/current/support/v7/appcompat/res/values/themes_daynight.xml b/current/support/v7/appcompat/res/values/themes_daynight.xml
index bc7001d..2dc7688 100644
--- a/current/support/v7/appcompat/res/values/themes_daynight.xml
+++ b/current/support/v7/appcompat/res/values/themes_daynight.xml
@@ -16,7 +16,7 @@
 
 <resources>
 
-    <!-- Material theme (day/night vesion) for activities. -->
+    <!-- AppCompat theme (day/night vesion) for activities. -->
     <style name="Theme.AppCompat.DayNight" parent="Theme.AppCompat.Light" />
 
     <!-- Variant of AppCompat.DayNight that has a solid (opaque) action bar
@@ -27,7 +27,7 @@
     <!-- Variant of AppCompat.DayNight with no action bar.  -->
     <style name="Theme.AppCompat.DayNight.NoActionBar" parent="Theme.AppCompat.Light.NoActionBar" />
 
-    <!-- Material theme (day/night vesion) for dialog windows and activities,
+    <!-- AppCompat theme (day/night vesion) for dialog windows and activities,
          which is used by the {@code android.support.v7.app.Dialog} class. This changes
          the window to be floating (not fill the entire screen), and puts a
          frame around its contents. You can set this theme on an activity if
@@ -43,8 +43,8 @@
          (large, xlarge). -->
     <style name="Theme.AppCompat.DayNight.DialogWhenLarge" parent="Theme.AppCompat.Light.DialogWhenLarge" />
 
-    <!-- Material user theme for alert dialog windows, which is used by the
+    <!-- AppCompat user theme for alert dialog windows, which is used by the
          {@code android.support.v7.app.AlertDialog} class. -->
     <style name="Theme.AppCompat.DayNight.Dialog.Alert" parent="Theme.AppCompat.Light.Dialog.Alert" />
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/cardview/libs/android-support-v7-cardview.jar b/current/support/v7/cardview/libs/android-support-v7-cardview.jar
index 39bcaf4..3b2eecc 100644
--- a/current/support/v7/cardview/libs/android-support-v7-cardview.jar
+++ b/current/support/v7/cardview/libs/android-support-v7-cardview.jar
Binary files differ
diff --git a/current/support/v7/cardview/res/values/attrs.xml b/current/support/v7/cardview/res/values/attrs.xml
index a0bd67d..efdd51b 100644
--- a/current/support/v7/cardview/res/values/attrs.xml
+++ b/current/support/v7/cardview/res/values/attrs.xml
@@ -38,5 +38,9 @@
         <attr name="contentPaddingTop" format="dimension" />
         <!-- Inner padding between the bottom edge of the Card and children of the CardView. -->
         <attr name="contentPaddingBottom" format="dimension" />
+        <!-- Workaround to read user defined minimum width -->
+        <attr name="android:minWidth"/>
+        <!-- Workaround to read user defined minimum height -->
+        <attr name="android:minHeight"/>
     </declare-styleable>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/cardview/res/values/colors.xml b/current/support/v7/cardview/res/values/colors.xml
index df202d1..30354ef 100644
--- a/current/support/v7/cardview/res/values/colors.xml
+++ b/current/support/v7/cardview/res/values/colors.xml
@@ -23,4 +23,4 @@
     <color name="cardview_shadow_start_color">#37000000</color>
     <!-- Shadow color for the furthest pixels around CardView. -->
     <color name="cardview_shadow_end_color">#03000000</color>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/cardview/res/values/dimens.xml b/current/support/v7/cardview/res/values/dimens.xml
index ebfbb3a..d72130d 100644
--- a/current/support/v7/cardview/res/values/dimens.xml
+++ b/current/support/v7/cardview/res/values/dimens.xml
@@ -22,4 +22,4 @@
     <!-- Inset shadow for RoundRectDrawableWithShadow. It is used to avoid gaps between the card
      and the shadow. -->
     <dimen name="cardview_compat_inset_shadow">1dp</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/cardview/res/values/styles.xml b/current/support/v7/cardview/res/values/styles.xml
index 99dfbc9..e4225ca 100644
--- a/current/support/v7/cardview/res/values/styles.xml
+++ b/current/support/v7/cardview/res/values/styles.xml
@@ -28,4 +28,4 @@
     <style name="CardView.Dark">
         <item name="cardBackgroundColor">@color/cardview_dark_background</item>
     </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar b/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar
index 87bb013..3bf4bb4 100644
--- a/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar
+++ b/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar
Binary files differ
diff --git a/current/support/v7/gridlayout/res/values/attrs.xml b/current/support/v7/gridlayout/res/values/attrs.xml
index 8eea3d9..10442b1 100644
--- a/current/support/v7/gridlayout/res/values/attrs.xml
+++ b/current/support/v7/gridlayout/res/values/attrs.xml
@@ -190,4 +190,4 @@
         </attr>
     </declare-styleable>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/gridlayout/res/values/dimens.xml b/current/support/v7/gridlayout/res/values/dimens.xml
index 189f409..28a55fd 100644
--- a/current/support/v7/gridlayout/res/values/dimens.xml
+++ b/current/support/v7/gridlayout/res/values/dimens.xml
@@ -4,4 +4,4 @@
     <!-- The default gap between components in a layout. -->
     <dimen name="default_gap">8dip</dimen>
 
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar b/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar
index ec7fdf5..9aa58d3 100644
--- a/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar
+++ b/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar
Binary files differ
diff --git a/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_dark.xml b/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_dark.xml
index 54f348c..9fca0a9 100644
--- a/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_dark.xml
+++ b/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_dark.xml
@@ -20,4 +20,4 @@
         android:shape="rectangle">
     <corners android:radius="2dp" />
     <solid android:color="@color/background_floating_material_dark" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_light.xml b/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_light.xml
index b5d82af..6b40a5d 100644
--- a/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_light.xml
+++ b/current/support/v7/mediarouter/res/drawable/mr_dialog_material_background_light.xml
@@ -20,4 +20,4 @@
         android:shape="rectangle">
     <corners android:radius="2dp" />
     <solid android:color="@color/background_floating_material_light" />
-</shape>
\ No newline at end of file
+</shape>
diff --git a/current/support/v7/mediarouter/res/values-b+sr+Latn/strings.xml b/current/support/v7/mediarouter/res/values-b+sr+Latn/strings.xml
new file mode 100644
index 0000000..c10c42d
--- /dev/null
+++ b/current/support/v7/mediarouter/res/values-b+sr+Latn/strings.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--  Copyright (C) 2013 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+ -->
+
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="mr_system_route_name" msgid="5441529851481176817">"Sistem"</string>
+    <string name="mr_user_route_category_name" msgid="7498112907524977311">"Uređaji"</string>
+    <string name="mr_button_content_description" msgid="3698378085901466129">"Dugme Prebaci"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"Prebacujte na"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"Pronalaženje uređaja"</string>
+    <string name="mr_controller_disconnect" msgid="1227264889412989580">"Prekini vezu"</string>
+    <string name="mr_controller_stop" msgid="4570331844078181931">"Zaustavi prebacivanje"</string>
+    <string name="mr_controller_close_description" msgid="7333862312480583260">"Zatvori"</string>
+    <string name="mr_controller_play" msgid="683634565969987458">"Pusti"</string>
+    <string name="mr_controller_pause" msgid="5451884435510905406">"Pauziraj"</string>
+    <string name="mr_controller_expand_group" msgid="8062427022744266907">"Proširi"</string>
+    <string name="mr_controller_collapse_group" msgid="7924809056904240926">"Skupi"</string>
+    <string name="mr_controller_no_media_selected" msgid="6547130360349182381">"Nema izabranih medija"</string>
+    <string name="mr_controller_no_info_available" msgid="5585418471741142924">"Nisu dostupne nikakve informacije"</string>
+    <string name="mr_controller_casting_screen" msgid="4868457957151124867">"Prebacuje se ekran"</string>
+</resources>
diff --git a/current/support/v7/mediarouter/res/values-fa/strings.xml b/current/support/v7/mediarouter/res/values-fa/strings.xml
index 87a81ba..2c812ae 100644
--- a/current/support/v7/mediarouter/res/values-fa/strings.xml
+++ b/current/support/v7/mediarouter/res/values-fa/strings.xml
@@ -25,7 +25,7 @@
     <string name="mr_controller_stop" msgid="4570331844078181931">"توقف ارسال محتوا"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"بستن"</string>
     <string name="mr_controller_play" msgid="683634565969987458">"پخش"</string>
-    <string name="mr_controller_pause" msgid="5451884435510905406">"توقف موقت"</string>
+    <string name="mr_controller_pause" msgid="5451884435510905406">"مکث"</string>
     <string name="mr_controller_expand_group" msgid="8062427022744266907">"بزرگ کردن"</string>
     <string name="mr_controller_collapse_group" msgid="7924809056904240926">"کوچک کردن"</string>
     <string name="mr_controller_no_media_selected" msgid="6547130360349182381">"رسانه انتخاب نشده است"</string>
diff --git a/current/support/v7/palette/libs/android-support-v7-palette.jar b/current/support/v7/palette/libs/android-support-v7-palette.jar
index c70cbf6..b03b30b 100644
--- a/current/support/v7/palette/libs/android-support-v7-palette.jar
+++ b/current/support/v7/palette/libs/android-support-v7-palette.jar
Binary files differ
diff --git a/current/support/v7/preference/libs/android-support-v7-preference.jar b/current/support/v7/preference/libs/android-support-v7-preference.jar
index a5bd306..6055117 100644
--- a/current/support/v7/preference/libs/android-support-v7-preference.jar
+++ b/current/support/v7/preference/libs/android-support-v7-preference.jar
Binary files differ
diff --git a/current/support/v7/preference/res/layout/preference_dropdown.xml b/current/support/v7/preference/res/layout/preference_dropdown.xml
new file mode 100644
index 0000000..09ea8fb
--- /dev/null
+++ b/current/support/v7/preference/res/layout/preference_dropdown.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <Spinner
+        android:id="@+id/spinner"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:visibility="invisible" />
+
+    <include layout="@layout/preference" />
+
+</FrameLayout>
diff --git a/current/support/v7/preference/res/values/attrs.xml b/current/support/v7/preference/res/values/attrs.xml
index 310a444..c0f255a 100644
--- a/current/support/v7/preference/res/values/attrs.xml
+++ b/current/support/v7/preference/res/values/attrs.xml
@@ -50,6 +50,8 @@
         <attr name="editTextPreferenceStyle" format="reference" />
         <!-- Default style for RingtonePreference. -->
         <attr name="ringtonePreferenceStyle" format="reference" />
+        <!-- Default style for DropDownPreference. -->
+        <attr name="dropdownPreferenceStyle" format="reference" />
         <!-- The preference layout that has the child/tabbed effect. -->
         <attr name="preferenceLayoutChild" format="reference" />
         <!-- Preference panel style -->
diff --git a/current/support/v7/preference/res/values/styles.xml b/current/support/v7/preference/res/values/styles.xml
index 774c0c9..06b24fa 100644
--- a/current/support/v7/preference/res/values/styles.xml
+++ b/current/support/v7/preference/res/values/styles.xml
@@ -65,4 +65,8 @@
         <item name="android:paddingLeft">16dp</item>
         <item name="android:paddingRight">16dp</item>
     </style>
+
+    <style name="Preference.DropDown">
+        <item name="android:layout">@layout/preference_dropdown</item>
+    </style>
 </resources>
diff --git a/current/support/v7/preference/res/values/themes.xml b/current/support/v7/preference/res/values/themes.xml
index 8a7eaa3..bb7f496 100644
--- a/current/support/v7/preference/res/values/themes.xml
+++ b/current/support/v7/preference/res/values/themes.xml
@@ -27,5 +27,6 @@
         <item name="dialogPreferenceStyle">@style/Preference.DialogPreference</item>
         <item name="editTextPreferenceStyle">@style/Preference.DialogPreference.EditTextPreference</item>
         <item name="preferenceFragmentListStyle">@style/PreferenceFragmentList</item>
+        <item name="dropdownPreferenceStyle">@style/Preference.DropDown</item>
     </style>
 </resources>
diff --git a/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar b/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar
index efe3c61..e3422e5 100644
--- a/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar
+++ b/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar
Binary files differ
diff --git a/current/support/v7/recyclerview/res/values/attrs.xml b/current/support/v7/recyclerview/res/values/attrs.xml
index ad93ce6..041e46a 100644
--- a/current/support/v7/recyclerview/res/values/attrs.xml
+++ b/current/support/v7/recyclerview/res/values/attrs.xml
@@ -37,4 +37,4 @@
         <attr name="reverseLayout" format="boolean" />
         <attr name="stackFromEnd" format="boolean" />
     </declare-styleable>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/support/v7/recyclerview/res/values/dimens.xml b/current/support/v7/recyclerview/res/values/dimens.xml
index 90c41b9..91a7e8d 100644
--- a/current/support/v7/recyclerview/res/values/dimens.xml
+++ b/current/support/v7/recyclerview/res/values/dimens.xml
@@ -21,4 +21,4 @@
     <dimen name="item_touch_helper_max_drag_scroll_per_frame">20dp</dimen>
     <dimen name="item_touch_helper_swipe_escape_velocity">120dp</dimen>
     <dimen name="item_touch_helper_swipe_escape_max_velocity">800dp</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/current/uiautomator.jar b/current/uiautomator.jar
index 2d90b52..ff43ba6 100644
--- a/current/uiautomator.jar
+++ b/current/uiautomator.jar
Binary files differ
diff --git a/system_current/android.jar b/system_current/android.jar
index b135454..d075bc7 100644
--- a/system_current/android.jar
+++ b/system_current/android.jar
Binary files differ
