diff --git a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 70d3011..0000000
--- a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_white_color_120.png b/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_white_color_120.png
deleted file mode 100644
index 4068d5a..0000000
--- a/assets/product/res/drawable-hdpi/product_logo_avatar_anonymous_white_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-mdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-mdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 60d3c3a..0000000
--- a/assets/product/res/drawable-mdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-xhdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-xhdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index ec99ca6..0000000
--- a/assets/product/res/drawable-xhdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-xxhdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-xxhdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 2b009a3..0000000
--- a/assets/product/res/drawable-xxhdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/product/res/drawable-xxxhdpi/product_logo_avatar_anonymous_color_120.png b/assets/product/res/drawable-xxxhdpi/product_logo_avatar_anonymous_color_120.png
deleted file mode 100644
index 4b111b1..0000000
--- a/assets/product/res/drawable-xxxhdpi/product_logo_avatar_anonymous_color_120.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index cd19726..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index ec2349c..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 485c826..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-hdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-hdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index bbfbc96..0000000
--- a/assets/quantum/res/drawable-hdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-hdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-hdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index f517557..0000000
--- a/assets/quantum/res/drawable-ldrtl-hdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-mdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-mdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 22a1140..0000000
--- a/assets/quantum/res/drawable-ldrtl-mdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-xhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-xhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index d858f18..0000000
--- a/assets/quantum/res/drawable-ldrtl-xhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-xxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-xxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 614ad49..0000000
--- a/assets/quantum/res/drawable-ldrtl-xxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-ldrtl-xxxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-ldrtl-xxxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index d409b54..0000000
--- a/assets/quantum/res/drawable-ldrtl-xxxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 4ef72ee..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index de635e0..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index d67647c..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-mdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-mdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index faefc59..0000000
--- a/assets/quantum/res/drawable-mdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 832f5a3..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index eea1bbf..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 3e73b49..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xhdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-xhdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index bfc3e39..0000000
--- a/assets/quantum/res/drawable-xhdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index 32a6d91..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index 99f57c1..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 1358a12..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxhdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-xxhdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index abbb989..0000000
--- a/assets/quantum/res/drawable-xxhdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_arrow_back_white_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_arrow_back_white_24.png
deleted file mode 100644
index e27034d..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_arrow_back_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_bluetooth_audio_grey600_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
deleted file mode 100644
index 1595be1..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_bluetooth_audio_grey600_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_history_white_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_history_white_24.png
deleted file mode 100644
index 5b99ef6..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_history_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_search_white_24.png b/assets/quantum/res/drawable-xxxhdpi/quantum_ic_search_white_24.png
deleted file mode 100644
index dd5adfc..0000000
--- a/assets/quantum/res/drawable-xxxhdpi/quantum_ic_search_white_24.png
+++ /dev/null
Binary files differ
diff --git a/assets/quantum/res/drawable/quantum_ic_clear_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_clear_vd_theme_24.xml
deleted file mode 100644
index f55a394..0000000
--- a/assets/quantum/res/drawable/quantum_ic_clear_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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:fillColor="@android:color/white"
-      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"/>
-</vector>
\ No newline at end of file
diff --git a/assets/quantum/res/drawable/quantum_ic_error_outline_vd_theme_36.xml b/assets/quantum/res/drawable/quantum_ic_error_outline_vd_theme_36.xml
deleted file mode 100644
index df4dc32..0000000
--- a/assets/quantum/res/drawable/quantum_ic_error_outline_vd_theme_36.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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="36dp"
-    android:height="36dp"
-    android:viewportWidth="36.0"
-    android:viewportHeight="36.0"
-    android:tint="?attr/colorControlNormal">
-  <group
-      android:pivotX="12"
-      android:pivotY="12"
-      android:scaleX="1.5"
-      android:scaleY="1.5"
-      android:translateX="6"
-      android:translateY="6">
-    <path
-        android:fillColor="@android:color/white"
-        android:pathData="M11,15h2v2h-2zM11,7h2v6h-2zM11.99,2C6.47,2 2,6.48 2,12s4.47,10 9.99,10C17.52,22 22,17.52 22,12S17.52,2 11.99,2zM12,20c-4.42,0 -8,-3.58 -8,-8s3.58,-8 8,-8 8,3.58 8,8 -3.58,8 -8,8z"/>
-  </group>
-</vector>
\ No newline at end of file
diff --git a/assets/quantum/res/drawable/quantum_ic_fiber_manual_record_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_fiber_manual_record_vd_theme_24.xml
deleted file mode 100644
index 21993c3..0000000
--- a/assets/quantum/res/drawable/quantum_ic_fiber_manual_record_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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,12m-8,0a8,8 0,1 1,16 0a8,8 0,1 1,-16 0"
-        android:fillColor="@android:color/white"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_fullscreen_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_fullscreen_vd_theme_24.xml
deleted file mode 100644
index baa88f4..0000000
--- a/assets/quantum/res/drawable/quantum_ic_fullscreen_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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:fillColor="@android:color/white"
-        android:pathData="M7,14L5,14v5h5v-2L7,17v-3zM5,10h2L7,7h3L10,5L5,5v5zM17,17h-3v2h5v-5h-2v3zM14,5v2h3v3h2L19,5h-5z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_my_location_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_my_location_vd_theme_24.xml
deleted file mode 100644
index b13816e..0000000
--- a/assets/quantum/res/drawable/quantum_ic_my_location_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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:fillColor="@android:color/white"
-        android:pathData="M12,8c-2.21,0 -4,1.79 -4,4s1.79,4 4,4 4,-1.79 4,-4 -1.79,-4 -4,-4zM20.94,11c-0.46,-4.17 -3.77,-7.48 -7.94,-7.94L13,1h-2v2.06C6.83,3.52 3.52,6.83 3.06,11L1,11v2h2.06c0.46,4.17 3.77,7.48 7.94,7.94L11,23h2v-2.06c4.17,-0.46 7.48,-3.77 7.94,-7.94L23,13v-2h-2.06zM12,19c-3.87,0 -7,-3.13 -7,-7s3.13,-7 7,-7 7,3.13 7,7 -3.13,7 -7,7z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_perm_phone_msg_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_perm_phone_msg_vd_theme_24.xml
deleted file mode 100644
index 68735dd..0000000
--- a/assets/quantum/res/drawable/quantum_ic_perm_phone_msg_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2017 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:fillColor="@android:color/white"
-        android:pathData="M20,15.5c-1.25,0 -2.45,-0.2 -3.57,-0.57 -0.35,-0.11 -0.74,-0.03 -1.02,0.24l-2.2,2.2c-2.83,-1.44 -5.15,-3.75 -6.59,-6.58l2.2,-2.21c0.28,-0.27 0.36,-0.66 0.25,-1.01C8.7,6.45 8.5,5.25 8.5,4c0,-0.55 -0.45,-1 -1,-1H4c-0.55,0 -1,0.45 -1,1 0,9.39 7.61,17 17,17 0.55,0 1,-0.45 1,-1v-3.5c0,-0.55 -0.45,-1 -1,-1zM12,3v10l3,-3h6V3h-9z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_schedule_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_schedule_vd_theme_24.xml
deleted file mode 100644
index 54fd545..0000000
--- a/assets/quantum/res/drawable/quantum_ic_schedule_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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:fillColor="@android:color/white"
-        android:pathData="M11.99,2C6.47,2 2,6.48 2,12s4.47,10 9.99,10C17.52,22 22,17.52 22,12S17.52,2 11.99,2zM12,20c-4.42,0 -8,-3.58 -8,-8s3.58,-8 8,-8 8,3.58 8,8 -3.58,8 -8,8zM12.5,7L11,7v6l5.25,3.15 0.75,-1.23 -4.5,-2.67z"/>
-</vector>
diff --git a/assets/quantum/res/drawable/quantum_ic_security_vd_theme_24.xml b/assets/quantum/res/drawable/quantum_ic_security_vd_theme_24.xml
deleted file mode 100644
index 36ea6eb..0000000
--- a/assets/quantum/res/drawable/quantum_ic_security_vd_theme_24.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright (C) 2018 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:fillColor="@android:color/white"
-      android:pathData="M12,1L3,5v6c0,5.55 3.84,10.74 9,12 5.16,-1.26 9,-6.45 9,-12L21,5l-9,-4zM12,11.99h7c-0.53,4.12 -3.28,7.79 -7,8.94L12,12L5,12L5,6.3l7,-3.11v8.8z"/>
-</vector>
diff --git a/java/com/android/dialer/app/res/drawable-hdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-hdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 393a0c8..0000000
--- a/java/com/android/dialer/app/res/drawable-hdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-mdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-mdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index d7d5c58..0000000
--- a/java/com/android/dialer/app/res/drawable-mdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 3e6ec07..0000000
--- a/java/com/android/dialer/app/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 7c256b5..0000000
--- a/java/com/android/dialer/app/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/app/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png b/java/com/android/dialer/app/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png
deleted file mode 100644
index 6591ed4..0000000
--- a/java/com/android/dialer/app/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-mdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-mdpi/ic_scroll_handle.png
deleted file mode 100644
index 0724e2a..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-mdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-xhdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-xhdpi/ic_scroll_handle.png
deleted file mode 100644
index e0adfbb..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-xhdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-xxhdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-xxhdpi/ic_scroll_handle.png
deleted file mode 100644
index 37e041c..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-xxhdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable-xxxhdpi/ic_scroll_handle.png b/java/com/android/dialer/contacts/resources/res/drawable-xxxhdpi/ic_scroll_handle.png
deleted file mode 100644
index d725ce1..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable-xxxhdpi/ic_scroll_handle.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/contacts/resources/res/drawable/fastscroll_thumb.xml b/java/com/android/dialer/contacts/resources/res/drawable/fastscroll_thumb.xml
deleted file mode 100644
index 67645ff..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable/fastscroll_thumb.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?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.
--->
-<selector xmlns:android="http://schemas.android.com/apk/res/android">
-  <item android:drawable="@drawable/ic_scroll_handle_pressed" android:state_pressed="true"/>
-  <item android:drawable="@drawable/ic_scroll_handle_default"/>
-</selector>
\ No newline at end of file
diff --git a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_default.xml b/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_default.xml
deleted file mode 100644
index 9164ab1..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_default.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?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.
--->
-
-<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
-  android:src="@drawable/ic_scroll_handle"
-  android:tint="?colorIcon"/>
diff --git a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_pressed.xml b/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_pressed.xml
deleted file mode 100644
index c9b93d9..0000000
--- a/java/com/android/dialer/contacts/resources/res/drawable/ic_scroll_handle_pressed.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?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.
--->
-
-<bitmap xmlns:android="http://schemas.android.com/apk/res/android"
-  android:src="@drawable/ic_scroll_handle"
-  android:tint="?android:attr/colorPrimary"/>
\ No newline at end of file
diff --git a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_arrow_back_grey600_48dp.png b/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_arrow_back_grey600_48dp.png
deleted file mode 100644
index 0a379b4..0000000
--- a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_arrow_back_grey600_48dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_stop_circle_filled_blue_24dp.png b/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_stop_circle_filled_blue_24dp.png
deleted file mode 100644
index 520f860..0000000
--- a/java/com/android/dialer/voicemail/settings/res/drawable-xhdpi/ic_stop_circle_filled_blue_24dp.png
+++ /dev/null
Binary files differ
diff --git a/java/com/android/incallui/calllocation/impl/res/drawable/bg_location_card.xml b/java/com/android/incallui/calllocation/impl/res/drawable/bg_location_card.xml
deleted file mode 100644
index 0bcba95..0000000
--- a/java/com/android/incallui/calllocation/impl/res/drawable/bg_location_card.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2017 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
-  -->
-
-<ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    android:color="@color/ripple_material_light">
-  <item android:drawable="@android:color/white"/>
-</ripple>
diff --git a/java/com/android/incallui/rtt/impl/res/drawable/incallui_message_bubble.xml b/java/com/android/incallui/rtt/impl/res/drawable/incallui_message_bubble.xml
deleted file mode 100644
index 31044b6..0000000
--- a/java/com/android/incallui/rtt/impl/res/drawable/incallui_message_bubble.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (C) 2018 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
-  -->
-<shape xmlns:android="http://schemas.android.com/apk/res/android"
-    android:shape="rectangle">
-  <solid android:color="?android:attr/colorBackgroundFloating"/>
-  <corners android:radius="20dp"/>
-</shape>
\ No newline at end of file
