diff --git a/quickstep/res/drawable/ic_save_app_pair_left_right.xml b/quickstep/res/drawable/ic_save_app_pair_left_right.xml
index b104f44..509bc98 100644
--- a/quickstep/res/drawable/ic_save_app_pair_left_right.xml
+++ b/quickstep/res/drawable/ic_save_app_pair_left_right.xml
@@ -1,28 +1,25 @@
-<?xml version="1.0" encoding="utf-8"?>
-
 <!--
-     Copyright (C) 2024 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.
--->
-
+  ~ Copyright (C) 2025 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"
-    android:viewportHeight="24">
-  <path
-      android:pathData="M8.5,4.5H3.5C2.4,4.5 1.5,5.4 1.5,6.5V18.5C1.5,19.6 2.4,20.5 3.5,20.5H8.5C9.6,20.5 10.5,19.6 10.5,18.5V6.5C10.5,5.4 9.6,4.5 8.5,4.5ZM8.5,18.5H3.5V6.5H8.5V18.5ZM14.5,6.5H19.5V13.5H21.5V6.5C21.5,5.4 20.6,4.5 19.5,4.5H14.5C13.4,4.5 12.5,5.4 12.5,6.5V18.5C12.5,19.6 13.4,20.5 14.5,20.5H15.5V18.5H14.5V6.5ZM20.5,14.5V16.5H22.5V18.5H20.5V20.5H18.5V18.5H16.5V16.5H18.5V14.5H20.5Z"
-      android:fillColor="#48473A"
-      android:fillType="evenOdd"/>
+    android:width="20dp"
+    android:height="20dp"
+    android:tint="?attr/colorControlNormal"
+    android:viewportHeight="960"
+    android:viewportWidth="960">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M744,816L720,816Q704.7,816 694.35,805.71Q684,795.42 684,780.21Q684,765 694.35,754.5Q704.7,744 720,744L744,744L744,720Q744,704.7 754.29,694.35Q764.58,684 779.79,684Q795,684 805.5,694.35Q816,704.7 816,720L816,744L840,744Q855.3,744 865.65,754.29Q876,764.58 876,779.79Q876,795 865.65,805.5Q855.3,816 840,816L816,816L816,840Q816,855.3 805.71,865.65Q795.42,876 780.21,876Q765,876 754.5,865.65Q744,855.3 744,840L744,816ZM215.74,816Q186,816 165,794.85Q144,773.7 144,744L144,216Q144,186.3 165.18,165.15Q186.35,144 216.09,144L360.26,144Q390,144 411,165.15Q432,186.3 432,216L432,744Q432,773.7 410.82,794.85Q389.65,816 359.91,816L215.74,816ZM616,816Q581,816 554.5,796Q528,776 528,743.95L528,216Q528,186.3 549.18,165.15Q570.35,144 600.09,144L744.26,144Q774,144 795,165.15Q816,186.3 816,216L816,616Q807,614 798,613Q789,612 780,612Q709.79,612 660.9,661Q612,710 612,780Q612,789 613,798Q614,807 616,816Z" />
 </vector>
diff --git a/quickstep/res/drawable/ic_save_app_pair_up_down.xml b/quickstep/res/drawable/ic_save_app_pair_up_down.xml
index 86f110c..282751c 100644
--- a/quickstep/res/drawable/ic_save_app_pair_up_down.xml
+++ b/quickstep/res/drawable/ic_save_app_pair_up_down.xml
@@ -1,28 +1,25 @@
-<?xml version="1.0" encoding="utf-8"?>
-
 <!--
-     Copyright (C) 2024 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.
--->
-
+  ~ Copyright (C) 2025 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"
-    android:viewportHeight="24">
-  <path
-      android:pathData="M18,2L6,2C4.9,2 4,2.9 4,4L4,9C4,10.1 4.9,11 6,11L18,11C19.1,11 20,10.1 20,9L20,4C20,2.9 19.1,2 18,2ZM18,9L6,9L6,4L18,4L18,9ZM18,13L6,13C4.9,13 4,13.9 4,15L4,20C4,21.1 4.9,22 6,22L13,22L13,20L6,20L6,15L18,15L18,16L20,16L20,15C20,13.9 19.1,13 18,13ZM16,17L18,17L18,19L20,19L20,21L18,21L18,23L16,23L16,21L14,21L14,19L16,19L16,17Z"
-      android:fillColor="#48473A"
-      android:fillType="evenOdd"/>
-</vector>
+    android:width="20dp"
+    android:height="20dp"
+    android:tint="?attr/colorControlNormal"
+    android:viewportHeight="960"
+    android:viewportWidth="960">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M744,816L720,816Q704.7,816 694.35,805.71Q684,795.42 684,780.21Q684,765 694.35,754.5Q704.7,744 720,744L744,744L744,720Q744,704.7 754.29,694.35Q764.58,684 779.79,684Q795,684 805.5,694.35Q816,704.7 816,720L816,744L840,744Q855.3,744 865.65,754.29Q876,764.58 876,779.79Q876,795 865.65,805.5Q855.3,816 840,816L816,816L816,840Q816,855.3 805.71,865.65Q795.42,876 780.21,876Q765,876 754.5,865.65Q744,855.3 744,840L744,816ZM216,432Q183,432 163.5,412.5Q144,393 144,360L144,216Q144,183 163.5,163.5Q183,144 216,144L744,144Q777,144 796.5,163.5Q816,183 816,216L816,360Q816,393 796.5,412.5Q777,432 744,432L216,432ZM215.62,816Q183,816 163.5,796.5Q144,777 144,744L144,600Q144,567 163.5,547.5Q183,528 216,528L744,528Q777,528 796.5,547.5Q816,567 816,600L816,616Q808,614 798.06,613Q788.13,612 780,612Q709.44,612 660.72,661.5Q612,711 612,780Q612,789.94 612.5,798.97Q613,808 615,816L215.62,816Z" />
+</vector>
\ No newline at end of file
diff --git a/res/drawable/ic_split_horizontal.xml b/res/drawable/ic_split_horizontal.xml
index 2efd2b9..26efedc 100644
--- a/res/drawable/ic_split_horizontal.xml
+++ b/res/drawable/ic_split_horizontal.xml
@@ -1,9 +1,25 @@
+<!--
+  ~ Copyright (C) 2025 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"
-    android:viewportHeight="24">
-  <path
-      android:pathData="M4,6L9,6L9,18L4,18L4,6ZM2,6L2,18C2,19.1 2.9,20 4,20L9,20C10.1,20 11,19.1 11,18L11,6C11,4.9 10.1,4 9,4L4,4C2.9,4 2,4.9 2,6ZM15,6L20,6L20,18L15,18L15,6ZM13,6L13,18C13,19.1 13.9,20 15,20L20,20C21.1,20 22,19.1 22,18L22,6C22,4.9 21.1,4 20,4L15,4C13.9,4 13,4.9 13,6Z"
-      android:fillColor="#000000"/>
+    android:width="20dp"
+    android:height="20dp"
+    android:tint="?attr/colorControlNormal"
+    android:viewportHeight="960"
+    android:viewportWidth="960">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M552,624L684,624Q699.3,624 709.65,613.66Q720,603.32 720,588.04L720,372.28Q720,357 709.65,346.5Q699.3,336 684,336L552,336Q536.7,336 526.35,346.34Q516,356.68 516,371.96L516,587.72Q516,603 526.35,613.5Q536.7,624 552,624ZM276,624L408,624Q423.3,624 433.65,613.66Q444,603.32 444,588.04L444,372.28Q444,357 433.65,346.5Q423.3,336 408,336L276,336Q260.7,336 250.35,346.34Q240,356.68 240,371.96L240,587.72Q240,603 250.35,613.5Q260.7,624 276,624ZM168,768Q138.3,768 117.15,746.84Q96,725.68 96,695.96L96,263.72Q96,234 117.15,213Q138.3,192 168,192L792,192Q821.7,192 842.85,213.16Q864,234.32 864,264.04L864,696.28Q864,726 842.85,747Q821.7,768 792,768L168,768ZM792,264L168,264Q168,264 168,264Q168,264 168,264L168,696Q168,696 168,696Q168,696 168,696L792,696Q792,696 792,696Q792,696 792,696L792,264Q792,264 792,264Q792,264 792,264ZM168,264Q168,264 168,264Q168,264 168,264L168,696Q168,696 168,696Q168,696 168,696L168,696Q168,696 168,696Q168,696 168,696L168,264Q168,264 168,264Q168,264 168,264Z" />
 </vector>
diff --git a/res/drawable/ic_split_vertical.xml b/res/drawable/ic_split_vertical.xml
index 9bc9785..787953a 100644
--- a/res/drawable/ic_split_vertical.xml
+++ b/res/drawable/ic_split_vertical.xml
@@ -1,9 +1,25 @@
+<!--
+  ~ Copyright (C) 2025 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"
-    android:viewportHeight="24">
-  <path
-      android:pathData="M18,4V9H6V4H18ZM18,2H6C4.9,2 4,2.9 4,4V9C4,10.1 4.9,11 6,11H18C19.1,11 20,10.1 20,9V4C20,2.9 19.1,2 18,2ZM18,15V20H6V15H18ZM18,13H6C4.9,13 4,13.9 4,15V20C4,21.1 4.9,22 6,22H18C19.1,22 20,21.1 20,20V15C20,13.9 19.1,13 18,13Z"
-      android:fillColor="#000000"/>
+    android:width="20dp"
+    android:height="20dp"
+    android:tint="?attr/colorControlNormal"
+    android:viewportHeight="960"
+    android:viewportWidth="960">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M371.96,720L587.72,720Q603,720 613.5,709.65Q624,699.3 624,684L624,552Q624,536.7 613.66,526.35Q603.32,516 588.04,516L372.28,516Q357,516 346.5,526.35Q336,536.7 336,552L336,684Q336,699.3 346.34,709.65Q356.68,720 371.96,720ZM371.96,444L587.72,444Q603,444 613.5,433.65Q624,423.3 624,408L624,276Q624,260.7 613.66,250.35Q603.32,240 588.04,240L372.28,240Q357,240 346.5,250.35Q336,260.7 336,276L336,408Q336,423.3 346.34,433.65Q356.68,444 371.96,444ZM768,792Q768,821.7 746.84,842.85Q725.68,864 695.96,864L263.72,864Q234,864 213,842.85Q192,821.7 192,792L192,168Q192,138.3 213.16,117.15Q234.32,96 264.04,96L696.28,96Q726,96 747,117.15Q768,138.3 768,168L768,792ZM696,792L696,168Q696,168 696,168Q696,168 696,168L264,168Q264,168 264,168Q264,168 264,168L264,792Q264,792 264,792Q264,792 264,792L696,792Q696,792 696,792Q696,792 696,792ZM696,168Q696,168 696,168Q696,168 696,168L264,168Q264,168 264,168Q264,168 264,168L264,168Q264,168 264,168Q264,168 264,168L696,168Q696,168 696,168Q696,168 696,168Z" />
 </vector>
