diff --git a/_asus/rogphone2.markdown b/_asus/rogphone2.markdown
index 355e03f..7e46641 100644
--- a/_asus/rogphone2.markdown
+++ b/_asus/rogphone2.markdown
@@ -1,16 +1,17 @@
 ---
 layout: device
-title: "ASUS Rog Phone 2"
+title: "ASUS ROG Phone II"
 codename: I001D
 oem: Asus
 downloadfolder: I001D
 supportstatus: Current
 maintainer: mauronofrio, Captain_Throwback
 devicetree: https://github.com/TeamWin/android_device_asus_I001D
-xdathread: "https://forum.xda-developers.com/rog-phone-2/development/recovery-unofficial-twrp-recovery-asus-t4026801"
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ROG.20Phone.20II">Support topic on Zulip</a></p>
+xdathread: https://forum.xda-developers.com/rog-phone-2/development/recovery-unofficial-twrp-recovery-asus-t4026801
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ROG.20Phone.20II
 ---
 
+
 {% include disclaimer.html %}
 
 
@@ -23,25 +24,5 @@
 {% include download.html %}
 
 
-<div class='page-heading'>Installation:</div>
-Please unlock your bootloader according to instructions documented <a href="https://www.xda-developers.com/asus-rog-phone-ii-bootloader-unlock-tool-kernel-source-code/">here</a>.
+{% include fastbootabinstall.html %}
 
-WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
-
-<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
-
-Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
-
-Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
-
-Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
-
-<code>adb reboot bootloader</code>
-
-Temporary boot the downloaded image using the following command:
-
-<code>fastboot boot twrp.img</code>
-
-Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
-
-After this is done, you have successfully installed TWRP on your device.
diff --git a/_asus/rogphone3.markdown b/_asus/rogphone3.markdown
index 81df9b6..cc85155 100644
--- a/_asus/rogphone3.markdown
+++ b/_asus/rogphone3.markdown
@@ -7,8 +7,8 @@
 supportstatus: Current
 maintainer: Captain_Throwback
 devicetree: https://github.com/TeamWin/android_device_asus_I003D
-xdathread: "https://forum.xda-developers.com/asus-rog-phone-3/development/recovery-twrp-asus-rog-phone-3-t4158949"
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ROG.20Phone.203">Support topic on Zulip</a></p>
+xdathread: https://forum.xda-developers.com/asus-rog-phone-3/development/recovery-twrp-asus-rog-phone-3-t4158949
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ROG.20Phone.203
 ---
 
 
@@ -54,3 +54,4 @@
 <p class="code">dd if=/sdcard/twrp.img of=/dev/block/by-name/recovery\_a</p>
 <p class="code">dd if=/sdcard/twrp.img of=/dev/block/by-name/recovery\_b</p>
 </html>
+
diff --git a/_asus/rogphone5_s.markdown b/_asus/rogphone5_s.markdown
index 2fb0789..e33ce4e 100644
--- a/_asus/rogphone5_s.markdown
+++ b/_asus/rogphone5_s.markdown
@@ -7,8 +7,8 @@
 supportstatus: Current
 maintainer: mikalovtch, Captain_Throwback
 devicetree: https://github.com/TeamWin/android_device_asus_I005D
-xdathread: "https://forum.xda-developers.com/t/recovery-unofficial-twrp-for-asus-rog-phone-5-rog-phone-5s.4333661/"
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ROG.20Phone.205.2F5S">Support topic on Zulip</a></p>
+xdathread: https://forum.xda-developers.com/t/recovery-unofficial-twrp-for-asus-rog-phone-5-rog-phone-5s.4333661/
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ROG.20Phone.205.2F5S
 ---
 
 
@@ -45,23 +45,5 @@
 </ul>
 
 
-<div class='page-heading'>Installation:</div>
-WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
+{% include fastbootabinstall.html %}
 
-<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
-
-Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
-
-Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
-
-Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
-
-<code>adb reboot bootloader</code>
-
-Temporary boot the downloaded image using the following command:
-
-<code>fastboot boot twrp.img</code>
-
-Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
-
-After this is done, you have successfully installed TWRP on your device.
diff --git a/_asus/zenfone7.markdown b/_asus/zenfone7.markdown
index beebe28..537c00e 100644
--- a/_asus/zenfone7.markdown
+++ b/_asus/zenfone7.markdown
@@ -7,8 +7,8 @@
 supportstatus: Current
 maintainer: Captain_Throwback
 devicetree: https://github.com/TeamWin/android_device_asus_I002D
-xdathread: "https://forum.xda-developers.com/asus-zenfone-7/development/recovery-twrp-asus-zenfone-7-series-t4161719"
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ZenFone.207">Support topic on Zulip</a></p>
+xdathread: https://forum.xda-developers.com/asus-zenfone-7/development/recovery-twrp-asus-zenfone-7-series-t4161719
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ZenFone.207
 ---
 
 
@@ -54,3 +54,4 @@
 <p class="code">dd if=/sdcard/twrp.img of=/dev/block/by-name/recovery\_a</p>
 <p class="code">dd if=/sdcard/twrp.img of=/dev/block/by-name/recovery\_b</p>
 </html>
+
diff --git a/_asus/zenfone8.markdown b/_asus/zenfone8.markdown
index db15938..22c10d8 100644
--- a/_asus/zenfone8.markdown
+++ b/_asus/zenfone8.markdown
@@ -7,8 +7,8 @@
 supportstatus: Current
 maintainer: Captain_Throwback
 devicetree: https://github.com/TeamWin/android_device_asus_I006D
-xdathread: "https://forum.xda-developers.com/t/recovery-twrp-for-zenfone-8.4329139"
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ZenFone.208">Support topic on Zulip</a></p>
+xdathread: https://forum.xda-developers.com/t/recovery-twrp-for-zenfone-8.4329139
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/ASUS.20ZenFone.208
 ---
 
 
@@ -24,23 +24,5 @@
 {% include download.html %}
 
 
-<div class='page-heading'>Installation:</div>
-WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
+{% include fastbootabinstall.html %}
 
-<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
-
-Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
-
-Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
-
-Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
-
-<code>adb reboot bootloader</code>
-
-Temporary boot the downloaded image using the following command:
-
-<code>fastboot boot twrp.img</code>
-
-Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
-
-After this is done, you have successfully installed TWRP on your device.
diff --git a/_google/googlepixel3a.markdown b/_google/googlepixel3a.markdown
index 7177b33..22efbce 100644
--- a/_google/googlepixel3a.markdown
+++ b/_google/googlepixel3a.markdown
@@ -7,34 +7,21 @@
 maintainer: Captain_Throwback
 oem: Google
 devicetree: https://github.com/TeamWin/android_device_google_bonito
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/Pixel.203a.20.28sargo.29.2FPixel.203a.20XL.20.28bonito.29">Support topic on Zulip</a></p>
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/Pixel.203a.20.28sargo.29.2FPixel.203a.20XL.20.28bonito.29
 ---
 
+
 {% include disclaimer.html %}
 
+
 {% include supportstatus.html %}
 
+
 {% include download.html %}
 
+
 {% include dynamicpartitions.html %}
 
-<div class='page-heading'>Installation:</div>
-WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
 
-<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
+{% include fastbootabinstall.html %}
 
-Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
-
-Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
-
-Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
-
-<code>adb reboot bootloader</code>
-
-Temporary boot the downloaded image using the following command:
-
-<code>fastboot boot twrp.img</code>
-
-Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
-
-After this is done, you have successfully installed TWRP on your device.
\ No newline at end of file
diff --git a/_google/googlepixel3axl.markdown b/_google/googlepixel3axl.markdown
index 3789697..caaefdf 100644
--- a/_google/googlepixel3axl.markdown
+++ b/_google/googlepixel3axl.markdown
@@ -7,34 +7,21 @@
 maintainer: Captain_Throwback
 oem: Google
 devicetree: https://github.com/TeamWin/android_device_google_bonito
-<p class="text"><a href="https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/Pixel.203a.20.28sargo.29.2FPixel.203a.20XL.20.28bonito.29">Support topic on Zulip</a></p>
+zuliptopic: https://twrp.zulipchat.com/#narrow/stream/290973-support-device/topic/Pixel.203a.20.28sargo.29.2FPixel.203a.20XL.20.28bonito.29
 ---
 
+
 {% include disclaimer.html %}
 
+
 {% include supportstatus.html %}
 
+
 {% include download.html %}
 
+
 {% include dynamicpartitions.html %}
 
-<div class='page-heading'>Installation:</div>
-WARNING: If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
 
-<p class="text"><a href="https://developer.android.com/studio/releases/platform-tools">You will need the platform-tools from the Android SDK on your computer.</a> Download the platform-tools as per your operating system.</p>
+{% include fastbootabinstall.html %}
 
-Windows users will need proper drivers installed on their computer. You can try the <a href="https://forum.xda-developers.com/android/software-hacking/live-iso-adb-fastboot-driver-issues-t3526755" target=_blank>simple FWUL adb/fastboot ISO</a> or the <a href="http://www.xda-developers.com/universal-naked-driver-solves-your-adb-driver-problems-on-windows/">Naked ADB drivers</a> or the <a href="https://adb.clockworkmod.com/">Universal ADB drivers</a> if you don't already have a working driver installed
-
-Download the correct image file and copy the file into the same folder as your platform-tools as well as device's storage. Rename the image to twrp.img.
-
-Now reboot to fastboot/download/bootloader mode by using adb or manual key combos (Use Google to find that if you are not sure). To use adb to reboot, use the following command:
-
-<code>adb reboot bootloader</code>
-
-Temporary boot the downloaded image using the following command:
-
-<code>fastboot boot twrp.img</code>
-
-Once booted, navigate to the Advanced > Flash Current TWRP option. This will install the TWRP image you just booted permanently to the device.
-
-After this is done, you have successfully installed TWRP on your device.
\ No newline at end of file
