diff --git a/_devices/acericoniaa500.markdown b/_devices/acericoniaa500.markdown
index 473a8ac..78895ea 100644
--- a/_devices/acericoniaa500.markdown
+++ b/_devices/acericoniaa500.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Acer Iconia Tab A500"
-codename: picasso
-downloadfolder: picasso
-oldurl: http://teamw.in/project/twrp2/88
-supportstatus: No longer updated
-maintainer: None
-oem: Acer
-devicetree: https://github.com/TeamWin/device_acer_picasso
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1592677"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Acer Iconia Tab A500"
+codename: picasso
+downloadfolder: picasso
+oldurl: http://teamw.in/project/twrp2/88
+supportstatus: No longer updated
+maintainer: None
+oem: Acer
+devicetree: https://github.com/TeamWin/device_acer_picasso
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1592677"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/adt-1.markdown b/_devices/adt-1.markdown
index f8e7d4b..3cb1267 100644
--- a/_devices/adt-1.markdown
+++ b/_devices/adt-1.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "ADT-1 Android TV"
-codename: molly
-downloadfolder: molly
-supportstatus: Current
-maintainer: r3pwn
-oem: Google
-devicetree: https://github.com/teamwin/android_device_google_molly
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "ADT-1 Android TV"
+codename: molly
+downloadfolder: molly
+supportstatus: Current
+maintainer: r3pwn
+oem: Google
+devicetree: https://github.com/teamwin/android_device_google_molly
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/allviewx2soulxtreme.markdown b/_devices/allviewx2soulxtreme.markdown
index b9437ce..2279e52 100644
--- a/_devices/allviewx2soulxtreme.markdown
+++ b/_devices/allviewx2soulxtreme.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Allview X2 Soul Xtreme"
-codename: x2xtreme
-downloadfolder: x2xtreme
-supportstatus: Current
-maintainer: bemolxd
-oem: Allview
-devicetree: https://github.com/teamwin/android_device_allview_x2xtreme
-xdathread: "http://forum.xda-developers.com/pure-xl/development/twrp-3-0-0-unofficial-twrp-x2-xtreme-t3309540"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Allview X2 Soul Xtreme"
+codename: x2xtreme
+downloadfolder: x2xtreme
+supportstatus: Current
+maintainer: bemolxd
+oem: Allview
+devicetree: https://github.com/teamwin/android_device_allview_x2xtreme
+xdathread: "http://forum.xda-developers.com/pure-xl/development/twrp-3-0-0-unofficial-twrp-x2-xtreme-t3309540"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/amazonkindlefire.markdown b/_devices/amazonkindlefire.markdown
index 6a6e399..631bddf 100644
--- a/_devices/amazonkindlefire.markdown
+++ b/_devices/amazonkindlefire.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Amazon Kindle Fire (1st Gen)"
-codename: otter
-downloadfolder: blaze
-oldurl: http://teamw.in/project/twrp2/79
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Amazon
-devicetree: https://github.com/TeamWin/device_amazon_blaze
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Amazon Kindle Fire (1st Gen)"
+codename: otter
+downloadfolder: blaze
+oldurl: http://teamw.in/project/twrp2/79
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Amazon
+devicetree: https://github.com/TeamWin/device_amazon_blaze
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/amlogick200.markdown b/_devices/amlogick200.markdown
index 56683b1..f086cfd 100644
--- a/_devices/amlogick200.markdown
+++ b/_devices/amlogick200.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "AMLogic k200 based TV sticks"
-codename: k200
-downloadfolder: k200
-oldurl: http://teamw.in/project/twrp2/289
-supportstatus: Current
-maintainer: abdul_pt
-oem: AMLogic
----
-
-<p class='text'>This should work on Beelink S82/S82B/S82H+Ap6210/Ap6330 and MXIII(1G&2G DDR)+AP6181/AP6210/AP6330 and Tronsmart S89/S89H and maybe others.</p>
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-<div class='page-heading'>SD Card Install Method (No Root Required):</div>
-<hr />
-<p class='text'>Download the above file. Save it to the root of your removable SD card and rename it to recovery.img Power off the device then power it on while holding the reset button.</p>
-<p class='text'>If you wish to replace the stock recovery, boot the recovery image from your SD card as above. Go to Install -&gt; Images... then browse to your SD card and select the recovery.img, choose recovery and swipe to flash.</p>
+---
+layout: device
+title:  "AMLogic k200 based TV sticks"
+codename: k200
+downloadfolder: k200
+oldurl: http://teamw.in/project/twrp2/289
+supportstatus: Current
+maintainer: abdul_pt
+oem: AMLogic
+---
+
+<p class='text'>This should work on Beelink S82/S82B/S82H+Ap6210/Ap6330 and MXIII(1G&2G DDR)+AP6181/AP6210/AP6330 and Tronsmart S89/S89H and maybe others.</p>
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+<div class='page-heading'>SD Card Install Method (No Root Required):</div>
+<hr />
+<p class='text'>Download the above file. Save it to the root of your removable SD card and rename it to recovery.img Power off the device then power it on while holding the reset button.</p>
+<p class='text'>If you wish to replace the stock recovery, boot the recovery image from your SD card as above. Go to Install -&gt; Images... then browse to your SD card and select the recovery.img, choose recovery and swipe to flash.</p>
diff --git a/_devices/androidemulator.markdown b/_devices/androidemulator.markdown
index d6947af..bb9582d 100644
--- a/_devices/androidemulator.markdown
+++ b/_devices/androidemulator.markdown
@@ -1,43 +1,43 @@
----
-layout: device
-title:  "Android Emulator"
-codename: twrp
-downloadfolder: twrp
-oldurl: http://teamw.in/project/twrp2/169
-supportstatus: Current
-maintainer: Dees_Troy
-oem: TWRP
-devicetree: https://github.com/TeamWin/android_device_emulator_twrp
-xdathread: "http://forum.xda-developers.com/showthread.php?p=32965365"
----
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-<p class="text">TWRP can be booted in the Android emulator. To use this you will need to download both the goldfish_2.6_kernel and the appropriate .img file from one of our mirrors above.</p>
-<p>With the Android emulator make a new device based on a Galaxy Nexus. Allow it to have a hardware keyboard and a 1500MB sdcard. Give it a name like TWRP. Then from your android-sdk/tools folder run the following command:</p>
-<p><tt>./emulator -avd TWRP -ramdisk ~/cm_folder/out/target/product/twrp/ramdisk-recovery.img -kernel ~/cm_folder/device/emulator/twrp/goldfish_2.6_kernel</tt></p>
-<p>(Note that you will have to change the paths to match the locations of the files that you have downloaded.)</p>
-<p>After the first boot, wait for ADB to start up (usually ADB comes online about 15 seconds after TWRP boots), then:</p>
-<p><tt>adb shell /sbin/create_partitions.sh</tt></p>
-<p>
-<p>This script will partition the sdcard with a boot, recovery, system, cache, data, and removable sdcard partition. It's designed to work with a 1500MiB sdcard. If you want a different sdcard size then you will need to modify the script in the cm_folder/device/emulator/twrp/recovery/root/sbin/create_partitions.sh location to suit your needs. The script will also mount the old MTD system device to /system so that you can make a backup of the system image to restore to your new mmc-based system.</p>
-<p>If you want to make the emulator boot up using the emmc partitions, you will need to modify the ramdisk.img. Locate the ramdisk.img in your android-sdk/system-images/android##/armeabi-v7a/ folder. To unpack it:</p>
-<div><tt>mkdir ramdisk</tt></div>
-<div><tt>cd ramdisk</tt></div>
-<div><tt>gzip -dc ../ramdisk.img | cpio -i</tt></div>
-<p>Modify the init.rc to mount your mmc based partitions instead of the mtd ones by locating the line in init.rc that says &quot;on fs&quot; and modifying it to look like this:</p>
-<div><tt>on fs</tt></div>
-<div><tt># mount emmc partitions</tt></div>
-<div><tt>&nbsp; &nbsp; # Mount /system rw first to give the filesystem a chance to save a checkpoint</tt></div>
-<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@system /system</tt></div>
-<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@system /system ro remount</tt></div>
-<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@userdata /data nosuid nodev</tt></div>
-<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@cache /cache nosuid nodev</tt></div>
-<div><tt>&nbsp; &nbsp; mount ext4 /dev/block/mmcblk0p3 /system wait ro</tt></div>
-<div><tt>&nbsp; &nbsp; mount ext4 /dev/block/mmcblk0p5 /data wait noatime nosuid nodev</tt></div>
-<div><tt>&nbsp; &nbsp; mount ext4 /dev/block/mmcblk0p4 /cache wait noatime nosuid nodev</tt></div>
-<p>Save the changes and repack the ramdisk image as follows:</p>
-<p><tt>find . | cpio -o -H newc &gt; gzip &gt; ../newramdisk.img</tt></p>
-<p>Boot the emulator using -ramdisk path/to/newramdisk.img -kernel path/to/goldfish_2.6_kernel</p>
+---
+layout: device
+title:  "Android Emulator"
+codename: twrp
+downloadfolder: twrp
+oldurl: http://teamw.in/project/twrp2/169
+supportstatus: Current
+maintainer: Dees_Troy
+oem: TWRP
+devicetree: https://github.com/TeamWin/android_device_emulator_twrp
+xdathread: "http://forum.xda-developers.com/showthread.php?p=32965365"
+---
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+<p class="text">TWRP can be booted in the Android emulator. To use this you will need to download both the goldfish_2.6_kernel and the appropriate .img file from one of our mirrors above.</p>
+<p>With the Android emulator make a new device based on a Galaxy Nexus. Allow it to have a hardware keyboard and a 1500MB sdcard. Give it a name like TWRP. Then from your android-sdk/tools folder run the following command:</p>
+<p><tt>./emulator -avd TWRP -ramdisk ~/cm_folder/out/target/product/twrp/ramdisk-recovery.img -kernel ~/cm_folder/device/emulator/twrp/goldfish_2.6_kernel</tt></p>
+<p>(Note that you will have to change the paths to match the locations of the files that you have downloaded.)</p>
+<p>After the first boot, wait for ADB to start up (usually ADB comes online about 15 seconds after TWRP boots), then:</p>
+<p><tt>adb shell /sbin/create_partitions.sh</tt></p>
+<p>
+<p>This script will partition the sdcard with a boot, recovery, system, cache, data, and removable sdcard partition. It's designed to work with a 1500MiB sdcard. If you want a different sdcard size then you will need to modify the script in the cm_folder/device/emulator/twrp/recovery/root/sbin/create_partitions.sh location to suit your needs. The script will also mount the old MTD system device to /system so that you can make a backup of the system image to restore to your new mmc-based system.</p>
+<p>If you want to make the emulator boot up using the emmc partitions, you will need to modify the ramdisk.img. Locate the ramdisk.img in your android-sdk/system-images/android##/armeabi-v7a/ folder. To unpack it:</p>
+<div><tt>mkdir ramdisk</tt></div>
+<div><tt>cd ramdisk</tt></div>
+<div><tt>gzip -dc ../ramdisk.img | cpio -i</tt></div>
+<p>Modify the init.rc to mount your mmc based partitions instead of the mtd ones by locating the line in init.rc that says &quot;on fs&quot; and modifying it to look like this:</p>
+<div><tt>on fs</tt></div>
+<div><tt># mount emmc partitions</tt></div>
+<div><tt>&nbsp; &nbsp; # Mount /system rw first to give the filesystem a chance to save a checkpoint</tt></div>
+<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@system /system</tt></div>
+<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@system /system ro remount</tt></div>
+<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@userdata /data nosuid nodev</tt></div>
+<div><tt>&nbsp; &nbsp; # mount yaffs2 mtd@cache /cache nosuid nodev</tt></div>
+<div><tt>&nbsp; &nbsp; mount ext4 /dev/block/mmcblk0p3 /system wait ro</tt></div>
+<div><tt>&nbsp; &nbsp; mount ext4 /dev/block/mmcblk0p5 /data wait noatime nosuid nodev</tt></div>
+<div><tt>&nbsp; &nbsp; mount ext4 /dev/block/mmcblk0p4 /cache wait noatime nosuid nodev</tt></div>
+<p>Save the changes and repack the ramdisk image as follows:</p>
+<p><tt>find . | cpio -o -H newc &gt; gzip &gt; ../newramdisk.img</tt></p>
+<p>Boot the emulator using -ramdisk path/to/newramdisk.img -kernel path/to/goldfish_2.6_kernel</p>
diff --git a/_devices/archos50diamond.markdown b/_devices/archos50diamond.markdown
index 45bef96..5834ae4 100644
--- a/_devices/archos50diamond.markdown
+++ b/_devices/archos50diamond.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Archos 50 Diamond"
-codename: ac50da
-downloadfolder: ac50da
-supportstatus: Current
-maintainer: phh
-oem: Archos
-ddof: "/dev/block/bootdevice/by-name/recovery"
-devicetree: https://github.com/TeamWin/android_device_archos_ac50da
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Archos 50 Diamond"
+codename: ac50da
+downloadfolder: ac50da
+supportstatus: Current
+maintainer: phh
+oem: Archos
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_archos_ac50da
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/archos80cxenon.markdown b/_devices/archos80cxenon.markdown
index 177f58f..e3091a2 100644
--- a/_devices/archos80cxenon.markdown
+++ b/_devices/archos80cxenon.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Archos 80c Xenon"
-codename: ac80cxe
-downloadfolder: ac80cxe
-supportstatus: Current
-maintainer: phh
-oem: Archos
-ddof: "/dev/recovery"
-devicetree: https://github.com/TeamWin/android_device_archos_ac80cxe
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Archos 80c Xenon"
+codename: ac80cxe
+downloadfolder: ac80cxe
+supportstatus: Current
+maintainer: phh
+oem: Archos
+ddof: "/dev/recovery"
+devicetree: https://github.com/TeamWin/android_device_archos_ac80cxe
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/asusTF300T.markdown b/_devices/asusTF300T.markdown
index 53ab0d6..8935c8e 100644
--- a/_devices/asusTF300T.markdown
+++ b/_devices/asusTF300T.markdown
@@ -1,57 +1,57 @@
----
-layout: device
-title:  "Asus Transformer TF300T"
-codename: tf300t
-downloadfolder: tf300t
-oldurl: http://teamw.in/project/twrp2/97
-supportstatus: No Longer Updated
-maintainer: None
-oem: Asus
-devicetree: https://github.com/TeamWin/device_asus_tf300t
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1672108"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-<div class='page-heading'>Notes:</div>
-<hr />
-<p class="text">If you have updated to the JB OTA bootloader then you must use the -JB version of the recovery, flashing the non -JB version could potentially permanently brick your device (unless you have nvflash as noted above).</p>
-<p class="text">Date is off by 1 month in recovery - this is an Asus bug that can't be fixed easily. Just use the keyboard to name your backup</p>
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">TF300T:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}tf300t">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">TF300TG:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}tf300tg">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-<div class='page-heading'>Fastboot Install Method (No Root Required):</div>
-<hr />
-<p class="text"><a href="http://developer.android.com/sdk/index.html">You will need the platform-tools from the Android SDK on your computer.</a> Find the SDK Only section on the page linked and install the SDK and download only the platform-tools to get adb and fastboot binaries.</p>
-<p class="text">Windows users will need proper drivers installed on your computer. You can try 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="http://www.koushikdutta.com/post/universal-adb-driver">Universal ADB drivers</a> if you don't already have a working driver installed</p>
-<p class="text">On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:</p>
-<p class="text">adb reboot bootloader</p>
-<p class="text">You should now be in fastboot mode. Download the correct blob file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.blob and type:</p>
-<p class="text">fastboot -i 0x0b05 flash staging twrp.img<p></p>fastboot reboot</p>
-
-
+---
+layout: device
+title:  "Asus Transformer TF300T"
+codename: tf300t
+downloadfolder: tf300t
+oldurl: http://teamw.in/project/twrp2/97
+supportstatus: No Longer Updated
+maintainer: None
+oem: Asus
+devicetree: https://github.com/TeamWin/device_asus_tf300t
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1672108"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+<div class='page-heading'>Notes:</div>
+<hr />
+<p class="text">If you have updated to the JB OTA bootloader then you must use the -JB version of the recovery, flashing the non -JB version could potentially permanently brick your device (unless you have nvflash as noted above).</p>
+<p class="text">Date is off by 1 month in recovery - this is an Asus bug that can't be fixed easily. Just use the keyboard to name your backup</p>
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">TF300T:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}tf300t">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">TF300TG:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}tf300tg">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+<div class='page-heading'>Fastboot Install Method (No Root Required):</div>
+<hr />
+<p class="text"><a href="http://developer.android.com/sdk/index.html">You will need the platform-tools from the Android SDK on your computer.</a> Find the SDK Only section on the page linked and install the SDK and download only the platform-tools to get adb and fastboot binaries.</p>
+<p class="text">Windows users will need proper drivers installed on your computer. You can try 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="http://www.koushikdutta.com/post/universal-adb-driver">Universal ADB drivers</a> if you don't already have a working driver installed</p>
+<p class="text">On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:</p>
+<p class="text">adb reboot bootloader</p>
+<p class="text">You should now be in fastboot mode. Download the correct blob file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.blob and type:</p>
+<p class="text">fastboot -i 0x0b05 flash staging twrp.img<p></p>fastboot reboot</p>
+
+
diff --git a/_devices/asusnexus720123g.markdown b/_devices/asusnexus720123g.markdown
index 2772824..928c4ff 100644
--- a/_devices/asusnexus720123g.markdown
+++ b/_devices/asusnexus720123g.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Asus Nexus 7 2012 3G"
-codename: tilapia
-downloadfolder: tilapia
-oldurl: http://teamw.in/project/twrp2/150
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Asus
-devicetree: https://github.com/TeamWin/android_device_asus_tilapia
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1779092"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus Nexus 7 2012 3G"
+codename: tilapia
+downloadfolder: tilapia
+oldurl: http://teamw.in/project/twrp2/150
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Asus
+devicetree: https://github.com/TeamWin/android_device_asus_tilapia
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1779092"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asusnexus72012wifi.markdown b/_devices/asusnexus72012wifi.markdown
index 6b6358d..de73615 100644
--- a/_devices/asusnexus72012wifi.markdown
+++ b/_devices/asusnexus72012wifi.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Asus Nexus 7 2012 Wi-Fi"
-codename: grouper
-downloadfolder: grouper
-oldurl: http://teamw.in/project/twrp2/103
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Asus
-devicetree: https://github.com/omnirom/android_device_asus_grouper
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1779092"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus Nexus 7 2012 Wi-Fi"
+codename: grouper
+downloadfolder: grouper
+oldurl: http://teamw.in/project/twrp2/103
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Asus
+devicetree: https://github.com/omnirom/android_device_asus_grouper
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1779092"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asusnexus72013lte.markdown b/_devices/asusnexus72013lte.markdown
index 92cdf5b..472b844 100644
--- a/_devices/asusnexus72013lte.markdown
+++ b/_devices/asusnexus72013lte.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Asus Nexus 7 2013 LTE"
-codename: deb
-downloadfolder: deb
-oldurl: http://teamw.in/project/twrp2/194
-supportstatus: Current
-maintainer: None
-oem: Asus
-devicetree: https://github.com/omnirom/android_device_asus_deb
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2380100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus Nexus 7 2013 LTE"
+codename: deb
+downloadfolder: deb
+oldurl: http://teamw.in/project/twrp2/194
+supportstatus: Current
+maintainer: None
+oem: Asus
+devicetree: https://github.com/omnirom/android_device_asus_deb
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2380100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asusnexus72013wifi.markdown b/_devices/asusnexus72013wifi.markdown
index 76d6156..21ee799 100644
--- a/_devices/asusnexus72013wifi.markdown
+++ b/_devices/asusnexus72013wifi.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Asus Nexus 7 2013 Wi-Fi"
-codename: flo
-downloadfolder: flo
-oldurl: http://teamw.in/project/twrp2/193
-supportstatus: Current
-maintainer: None
-oem: Asus
-devicetree: https://github.com/omnirom/android_device_asus_flo
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2380100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus Nexus 7 2013 Wi-Fi"
+codename: flo
+downloadfolder: flo
+oldurl: http://teamw.in/project/twrp2/193
+supportstatus: Current
+maintainer: None
+oem: Asus
+devicetree: https://github.com/omnirom/android_device_asus_flo
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2380100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asusnexusplayer.markdown b/_devices/asusnexusplayer.markdown
index 5ea80ff..5d23291 100644
--- a/_devices/asusnexusplayer.markdown
+++ b/_devices/asusnexusplayer.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Asus Nexus Player"
-codename: fugu
-downloadfolder: fugu
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Asus
-devicetree: https://github.com/teamwin/android_device_asus_fugu
-xdathread: "http://forum.xda-developers.com/nexus-player/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3114717"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus Nexus Player"
+codename: fugu
+downloadfolder: fugu
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Asus
+devicetree: https://github.com/teamwin/android_device_asus_fugu
+xdathread: "http://forum.xda-developers.com/nexus-player/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3114717"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asuspadfone1.markdown b/_devices/asuspadfone1.markdown
index 9bf2d38..dc2cb03 100644
--- a/_devices/asuspadfone1.markdown
+++ b/_devices/asuspadfone1.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Asus PadFone 1"
-codename: A66
-downloadfolder: A66
-oldurl: http://teamw.in/project/twrp2/172
-supportstatus: No Longer Supported
-maintainer: None
-oem: Asus
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus PadFone 1"
+codename: A66
+downloadfolder: A66
+oldurl: http://teamw.in/project/twrp2/172
+supportstatus: No Longer Supported
+maintainer: None
+oem: Asus
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asuspadfone2.markdown b/_devices/asuspadfone2.markdown
index 4df8720..a7b505d 100644
--- a/_devices/asuspadfone2.markdown
+++ b/_devices/asuspadfone2.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Asus PadFone 2"
-codename: A68
-downloadfolder: A68
-oldurl: http://teamw.in/project/twrp2/157
-supportstatus: No Longer Supported
-maintainer: None
-oem: Asus
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus PadFone 2"
+codename: A68
+downloadfolder: A68
+oldurl: http://teamw.in/project/twrp2/157
+supportstatus: No Longer Supported
+maintainer: None
+oem: Asus
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asustransformerTF101.markdown b/_devices/asustransformerTF101.markdown
index 5b9f187..2dc97ef 100644
--- a/_devices/asustransformerTF101.markdown
+++ b/_devices/asustransformerTF101.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Asus Transformer TF101"
-codename: tf101
-downloadfolder: tf101
-oldurl: http://teamw.in/project/twrp2/109
-supportstatus: No Longer Updated
-maintainer: None
-oem: Asus
-devicetree: https://github.com/TeamWin/android_device_asus_tf101
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Asus Transformer TF101"
+codename: tf101
+downloadfolder: tf101
+oldurl: http://teamw.in/project/twrp2/109
+supportstatus: No Longer Updated
+maintainer: None
+oem: Asus
+devicetree: https://github.com/TeamWin/android_device_asus_tf101
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asustransformerinfinityTF700T.markdown b/_devices/asustransformerinfinityTF700T.markdown
index d38902c..ba1322b 100644
--- a/_devices/asustransformerinfinityTF700T.markdown
+++ b/_devices/asustransformerinfinityTF700T.markdown
@@ -1,31 +1,31 @@
----
-layout: device
-title:  "Asus Transformer Infinity TF700T"
-codename: tf700t
-downloadfolder: tf700t
-oldurl: http://teamw.in/project/twrp2/105
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Asus
-devicetree: https://github.com/TeamWin/device_asus_tf700t
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1797692"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-<div class='page-heading'>Fastboot Install Method (No Root Required):</div>
-<hr />
-<p class="text"><a href="http://developer.android.com/sdk/index.html">You will need the platform-tools from the Android SDK on your computer.</a> Find the SDK Only section on the page linked and install the SDK and download only the platform-tools to get adb and fastboot binaries.</p>
-<p class="text">Windows users will need proper drivers installed on your computer. You can try 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="http://www.koushikdutta.com/post/universal-adb-driver">Universal ADB drivers</a> if you don't already have a working driver installed</p>
-<p class="text">On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:</p>
-<p class="text">adb reboot bootloader</p>
-<p class="text">You should now be in fastboot mode. Download the correct blob file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.blob and type:</p>
-<p class="text">fastboot -i 0x0b05 flash staging twrp.img<p></p>fastboot reboot</p>
+---
+layout: device
+title:  "Asus Transformer Infinity TF700T"
+codename: tf700t
+downloadfolder: tf700t
+oldurl: http://teamw.in/project/twrp2/105
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Asus
+devicetree: https://github.com/TeamWin/device_asus_tf700t
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1797692"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+<div class='page-heading'>Fastboot Install Method (No Root Required):</div>
+<hr />
+<p class="text"><a href="http://developer.android.com/sdk/index.html">You will need the platform-tools from the Android SDK on your computer.</a> Find the SDK Only section on the page linked and install the SDK and download only the platform-tools to get adb and fastboot binaries.</p>
+<p class="text">Windows users will need proper drivers installed on your computer. You can try 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="http://www.koushikdutta.com/post/universal-adb-driver">Universal ADB drivers</a> if you don't already have a working driver installed</p>
+<p class="text">On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:</p>
+<p class="text">adb reboot bootloader</p>
+<p class="text">You should now be in fastboot mode. Download the correct blob file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.blob and type:</p>
+<p class="text">fastboot -i 0x0b05 flash staging twrp.img<p></p>fastboot reboot</p>
diff --git a/_devices/asustransformerprimeTF201.markdown b/_devices/asustransformerprimeTF201.markdown
index b155c16..d3e2b02 100644
--- a/_devices/asustransformerprimeTF201.markdown
+++ b/_devices/asustransformerprimeTF201.markdown
@@ -1,36 +1,36 @@
----
-layout: device
-title:  "Asus Transformer Prime TF201"
-codename: tf201
-downloadfolder: tf201
-oldurl: http://teamw.in/project/twrp2/93
-supportstatus: No Longer Updated
-maintainer: None
-oem: Asus
-devicetree: https://github.com/TeamWin/device_asus_tf201
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1615990"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-<div class='page-heading'>Notes:</div>
-<hr />
-<p class="text">If you have updated to the JB OTA bootloader then you must use the -JB version of the recovery, flashing the non -JB version could potentially permanently brick your device (unless you have nvflash as noted above).</p>
-<p class="text">Date is off by 1 month in recovery - this is an Asus bug that can't be fixed easily. Just use the keyboard to name your backup</p>
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-<div class='page-heading'>Fastboot Install Method (No Root Required):</div>
-<hr />
-<p class="text"><a href="http://developer.android.com/sdk/index.html">You will need the platform-tools from the Android SDK on your computer.</a> Find the SDK Only section on the page linked and install the SDK and download only the platform-tools to get adb and fastboot binaries.</p>
-<p class="text">Windows users will need proper drivers installed on your computer. You can try 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="http://www.koushikdutta.com/post/universal-adb-driver">Universal ADB drivers</a> if you don't already have a working driver installed</p>
-<p class="text">On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:</p>
-<p class="text">adb reboot bootloader</p>
-<p class="text">You should now be in fastboot mode. Download the correct blob file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.blob and type:</p>
-<p class="text">fastboot -i 0x0b05 flash staging twrp.img<p></p>fastboot reboot</p>
-
-
+---
+layout: device
+title:  "Asus Transformer Prime TF201"
+codename: tf201
+downloadfolder: tf201
+oldurl: http://teamw.in/project/twrp2/93
+supportstatus: No Longer Updated
+maintainer: None
+oem: Asus
+devicetree: https://github.com/TeamWin/device_asus_tf201
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1615990"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+<div class='page-heading'>Notes:</div>
+<hr />
+<p class="text">If you have updated to the JB OTA bootloader then you must use the -JB version of the recovery, flashing the non -JB version could potentially permanently brick your device (unless you have nvflash as noted above).</p>
+<p class="text">Date is off by 1 month in recovery - this is an Asus bug that can't be fixed easily. Just use the keyboard to name your backup</p>
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+<div class='page-heading'>Fastboot Install Method (No Root Required):</div>
+<hr />
+<p class="text"><a href="http://developer.android.com/sdk/index.html">You will need the platform-tools from the Android SDK on your computer.</a> Find the SDK Only section on the page linked and install the SDK and download only the platform-tools to get adb and fastboot binaries.</p>
+<p class="text">Windows users will need proper drivers installed on your computer. You can try 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="http://www.koushikdutta.com/post/universal-adb-driver">Universal ADB drivers</a> if you don't already have a working driver installed</p>
+<p class="text">On your device, go into Settings -> About and find the Build Number and tap on it 7 times to enable developer settings. Press back and go into Developer Options and enable USB debugging. From your computer, open a command prompt and type:</p>
+<p class="text">adb reboot bootloader</p>
+<p class="text">You should now be in fastboot mode. Download the correct blob file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.blob and type:</p>
+<p class="text">fastboot -i 0x0b05 flash staging twrp.img<p></p>fastboot reboot</p>
+
+
diff --git a/_devices/asuszenfone2.markdown b/_devices/asuszenfone2.markdown
index 4fe25a1..6346635 100644
--- a/_devices/asuszenfone2.markdown
+++ b/_devices/asuszenfone2.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Asus ZenFone 2 1080p"
-codename: Z00A
-downloadfolder: Z00A
-supportstatus: Current
-maintainer: Dees_Troy or bigbiff
-oem: Asus
-devicetree: https://github.com/teamwin/android_device_asus_zenfone2
-ddof: /dev/block/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Starting with TWRP 3.0.0, Z008 and Z00A TWRP builds are unified. The same image will work on both models.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Asus ZenFone 2 1080p"
+codename: Z00A
+downloadfolder: Z00A
+supportstatus: Current
+maintainer: Dees_Troy or bigbiff
+oem: Asus
+devicetree: https://github.com/teamwin/android_device_asus_zenfone2
+ddof: /dev/block/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Starting with TWRP 3.0.0, Z008 and Z00A TWRP builds are unified. The same image will work on both models.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/asuszenfone2720p.markdown b/_devices/asuszenfone2720p.markdown
index 950e8a8..4f33d97 100644
--- a/_devices/asuszenfone2720p.markdown
+++ b/_devices/asuszenfone2720p.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Asus ZenFone 2 720p"
-codename: Z008
-downloadfolder: Z008
-supportstatus: Current
-maintainer: jrior001
-oem: Asus
-devicetree: https://github.com/teamwin/android_device_asus_zenfone2
-ddof: /dev/block/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Starting with TWRP 3.0.0, Z008 and Z00A TWRP builds are unified. The same image will work on both models.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Asus ZenFone 2 720p"
+codename: Z008
+downloadfolder: Z008
+supportstatus: Current
+maintainer: jrior001
+oem: Asus
+devicetree: https://github.com/teamwin/android_device_asus_zenfone2
+ddof: /dev/block/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Starting with TWRP 3.0.0, Z008 and Z00A TWRP builds are unified. The same image will work on both models.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/asuszenfone2laser1080p.markdown b/_devices/asuszenfone2laser1080p.markdown
index 0cda713..973819b 100644
--- a/_devices/asuszenfone2laser1080p.markdown
+++ b/_devices/asuszenfone2laser1080p.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Asus ZenFone 2 Laser 1080p"
-codename: Z00T
-downloadfolder: Z00T
-supportstatus: Current
-maintainer: LuK1337
-oem: Asus
-devicetree: https://github.com/teamwin/android_device_asus_Z00T
-ddof: /dev/block/bootdevice/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Asus ZenFone 2 Laser 1080p"
+codename: Z00T
+downloadfolder: Z00T
+supportstatus: Current
+maintainer: LuK1337
+oem: Asus
+devicetree: https://github.com/teamwin/android_device_asus_Z00T
+ddof: /dev/block/bootdevice/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/asuszenfone2laser720p.markdown b/_devices/asuszenfone2laser720p.markdown
index 214a104..0ebf3a9 100644
--- a/_devices/asuszenfone2laser720p.markdown
+++ b/_devices/asuszenfone2laser720p.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Asus ZenFone 2 Laser 720p"
-codename: Z00L
-downloadfolder: Z00L
-supportstatus: Current
-maintainer: LuK1337
-oem: Asus
-devicetree: https://github.com/teamwin/android_device_asus_Z00L
-ddof: /dev/block/bootdevice/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Asus ZenFone 2 Laser 720p"
+codename: Z00L
+downloadfolder: Z00L
+supportstatus: Current
+maintainer: LuK1337
+oem: Asus
+devicetree: https://github.com/teamwin/android_device_asus_Z00L
+ddof: /dev/block/bootdevice/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/barnesnoblenookcolor.markdown b/_devices/barnesnoblenookcolor.markdown
index 742eb97..3ca217d 100644
--- a/_devices/barnesnoblenookcolor.markdown
+++ b/_devices/barnesnoblenookcolor.markdown
@@ -1,73 +1,73 @@
----
-layout: device
-title:  "Barnes & Noble Nook Color"
-codename: encore
-downloadfolder: encore
-oldurl: http://teamw.in/project/twrp2/43
-supportstatus: No Longer Updated
-maintainer: None
-oem: "Barnes & Noble"
-devicetree: https://github.com/TeamWin/android_device_bn_encore
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-<div class='page-heading'>Download - Install on EMMC:</div>
-<hr />
-<p class="text">twrp-encore-2.3.1.0.ub</p>
-<p class="text">twrp-encore-kernel-2.3.1.0</p>
-
-Download the above files.  Connect your Nook Color to the PC via the USB cable.  This assumes you have working ADB.
-
-Execute the following:
-
-adb shell busybox remount / -o rw,remount
-adb shell busybox mkdir /boot
-adb shell busybox mount /dev/block/mmcblk0p1 /boot
-adb push twrp-encore-2.3.1.0.ub /boot/uRecRam      <---  You can change uRecRam to uAltRam for alternate boot.
-adb push twrp-encore-kernel-2.3.1.0 /boot/uRecImg           <---  You can change uRecImg to uAltImg for alternate boot. 
-adb shell busybox umount /boot
-
-
-ALTERNATIVE EMMC INSTALL 1
-
-Download Nook Color UMS (credit: samuelhalff)
-
-Connect your Nook Color to the PC via the USB cable.  Open the app and select to mount boot and confirm. You should now see BOOT as a usb drive. Rename twrp-encore-2.3.1.0.ub to uRecRam (or uAltRam for altboot) and   twrp-encore-kernel-2.3.1.0 to uRecImg (or uAltImg) and copy them to /boot.
-
-Unmount /boot in the app and then reboot to recovery (or altboot).
-
-
-ALTERNATIVE EMMC INSTALL 2
-
-If you already have ClockworkMod recovery installed to EMMC, boot into it (holding n and power on boot). Use the menu option in mounts to mount /boot then:
-
-adb push twrp-encore-2.3.1.0.ub /boot/uRecRam      <---  You can change uRecRam to uAltRam for alternate boot.
-adb push twrp-encore-kernel-2.3.1.0 /boot/uRecImg           <---  You can change uRecImg to uAltImg for alternate boot. 
-
-Then unmount boot in cwm and reboot to recovery or altboot using the boot menu (holding n on boot).
-
-<div class='page-heading'>Bootable SD Card (No Root Required):</div>
-<hr />
-If you already have a working bootable recovery sdcard just download the above files, rename to uRamdisk and uImage and replace the files on the root of the sdcard. 
-
-<div class='page-heading'>Download - Flashable EMMC zip</div>
-
-<p class="text">Download openrecovery-twrp-2.3.1.0-encore-signed.zip from one of our mirrors and just flash this file from your current recovery</p>
-
-<div class='page-heading'>Download - SD Card Image</div>
-<hr />
-
-<p class="text">Download TWRP_2.3.0.2-encore-1gb-SD-IMAGE from one of the mirrors above.</p>
-
-The 1gb image can be used for installing roms and making backups. A 1gb image can be flashed on any size sdcard.
-
-Extract the TWRP2 .img (if you can't open the file use 7zip) and burn to sdcard using win32diskimager (free) or winimage (shareware). These apps will need to be "run as administrator.". ***Some internal laptop/desktop readers will not work to do this, you may need an external USB reader if you run into problems.***
-
-Once the card is done.  Copy any roms, or zips you want to flash over to the card.   Turn your Nook Color off, insert the card and boot the nook.  It should come up in TWRP2.
+---
+layout: device
+title:  "Barnes & Noble Nook Color"
+codename: encore
+downloadfolder: encore
+oldurl: http://teamw.in/project/twrp2/43
+supportstatus: No Longer Updated
+maintainer: None
+oem: "Barnes & Noble"
+devicetree: https://github.com/TeamWin/android_device_bn_encore
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+<div class='page-heading'>Download - Install on EMMC:</div>
+<hr />
+<p class="text">twrp-encore-2.3.1.0.ub</p>
+<p class="text">twrp-encore-kernel-2.3.1.0</p>
+
+Download the above files.  Connect your Nook Color to the PC via the USB cable.  This assumes you have working ADB.
+
+Execute the following:
+
+adb shell busybox remount / -o rw,remount
+adb shell busybox mkdir /boot
+adb shell busybox mount /dev/block/mmcblk0p1 /boot
+adb push twrp-encore-2.3.1.0.ub /boot/uRecRam      <---  You can change uRecRam to uAltRam for alternate boot.
+adb push twrp-encore-kernel-2.3.1.0 /boot/uRecImg           <---  You can change uRecImg to uAltImg for alternate boot. 
+adb shell busybox umount /boot
+
+
+ALTERNATIVE EMMC INSTALL 1
+
+Download Nook Color UMS (credit: samuelhalff)
+
+Connect your Nook Color to the PC via the USB cable.  Open the app and select to mount boot and confirm. You should now see BOOT as a usb drive. Rename twrp-encore-2.3.1.0.ub to uRecRam (or uAltRam for altboot) and   twrp-encore-kernel-2.3.1.0 to uRecImg (or uAltImg) and copy them to /boot.
+
+Unmount /boot in the app and then reboot to recovery (or altboot).
+
+
+ALTERNATIVE EMMC INSTALL 2
+
+If you already have ClockworkMod recovery installed to EMMC, boot into it (holding n and power on boot). Use the menu option in mounts to mount /boot then:
+
+adb push twrp-encore-2.3.1.0.ub /boot/uRecRam      <---  You can change uRecRam to uAltRam for alternate boot.
+adb push twrp-encore-kernel-2.3.1.0 /boot/uRecImg           <---  You can change uRecImg to uAltImg for alternate boot. 
+
+Then unmount boot in cwm and reboot to recovery or altboot using the boot menu (holding n on boot).
+
+<div class='page-heading'>Bootable SD Card (No Root Required):</div>
+<hr />
+If you already have a working bootable recovery sdcard just download the above files, rename to uRamdisk and uImage and replace the files on the root of the sdcard. 
+
+<div class='page-heading'>Download - Flashable EMMC zip</div>
+
+<p class="text">Download openrecovery-twrp-2.3.1.0-encore-signed.zip from one of our mirrors and just flash this file from your current recovery</p>
+
+<div class='page-heading'>Download - SD Card Image</div>
+<hr />
+
+<p class="text">Download TWRP_2.3.0.2-encore-1gb-SD-IMAGE from one of the mirrors above.</p>
+
+The 1gb image can be used for installing roms and making backups. A 1gb image can be flashed on any size sdcard.
+
+Extract the TWRP2 .img (if you can't open the file use 7zip) and burn to sdcard using win32diskimager (free) or winimage (shareware). These apps will need to be "run as administrator.". ***Some internal laptop/desktop readers will not work to do this, you may need an external USB reader if you run into problems.***
+
+Once the card is done.  Copy any roms, or zips you want to flash over to the card.   Turn your Nook Color off, insert the card and boot the nook.  It should come up in TWRP2.
diff --git a/_devices/barnesnoblenookhd.markdown b/_devices/barnesnoblenookhd.markdown
index b1ab48a..8fbc5f7 100644
--- a/_devices/barnesnoblenookhd.markdown
+++ b/_devices/barnesnoblenookhd.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Barnes & Noble Nook HD"
-codename: hummingbird
-downloadfolder: hummingbird
-supportstatus: Current
-maintainer: airend
-oem: "Barnes & Noble"
-devicetree: https://github.com/CyanogenMod/android_device_bn_hummingbird
-ddof: /dev/block/platform/omap/omap_hsmmc.1/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Barnes & Noble Nook HD"
+codename: hummingbird
+downloadfolder: hummingbird
+supportstatus: Current
+maintainer: airend
+oem: "Barnes & Noble"
+devicetree: https://github.com/CyanogenMod/android_device_bn_hummingbird
+ddof: /dev/block/platform/omap/omap_hsmmc.1/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/barnesnoblenookhdplus.markdown b/_devices/barnesnoblenookhdplus.markdown
index f8d7cdc..d2b2d21 100644
--- a/_devices/barnesnoblenookhdplus.markdown
+++ b/_devices/barnesnoblenookhdplus.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Barnes & Noble Nook HD+"
-codename: ovation
-downloadfolder: ovation
-supportstatus: Current
-maintainer: airend
-oem: "Barnes & Noble"
-devicetree: https://github.com/CyanogenMod/android_device_bn_ovation
-ddof: /dev/block/platform/omap/omap_hsmmc.1/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Barnes & Noble Nook HD+"
+codename: ovation
+downloadfolder: ovation
+supportstatus: Current
+maintainer: airend
+oem: "Barnes & Noble"
+devicetree: https://github.com/CyanogenMod/android_device_bn_ovation
+ddof: /dev/block/platform/omap/omap_hsmmc.1/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/barnesnoblenooktablet.markdown b/_devices/barnesnoblenooktablet.markdown
index a425e03..1bee0ad 100644
--- a/_devices/barnesnoblenooktablet.markdown
+++ b/_devices/barnesnoblenooktablet.markdown
@@ -1,29 +1,29 @@
----
-layout: device
-title:  "Barnes & Noble Nook Tablet"
-codename: acclaim
-downloadfolder: acclaim
-oldurl: http://teamw.in/project/twrp2/183
-supportstatus: Current
-maintainer: Dees_Troy
-oem: "Barnes & Noble"
-devicetree: https://github.com/CyanogenMod/android_device_bn_acclaim
-xdathread: "http://forum.xda-developers.com/nook-tablet/development/recovery-twrp-2-8-5-1-touch-recovery-t3034670"
-ddof: "/dev/block/mmcblk0p3"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-<div class='page-heading'>Bootable SD Card (No Root Required):</div>
-<hr />
-<p class="text">If you prefer not to modify any of the stock software, you can create a proper bootable sdcard for your device and copy the acclaim-sdcard file to the root of the sdcard and rename it to recovery.img and/or altboot.img and boot TWRP using the cyanoboot menu from your sdcard.</p>
+---
+layout: device
+title:  "Barnes & Noble Nook Tablet"
+codename: acclaim
+downloadfolder: acclaim
+oldurl: http://teamw.in/project/twrp2/183
+supportstatus: Current
+maintainer: Dees_Troy
+oem: "Barnes & Noble"
+devicetree: https://github.com/CyanogenMod/android_device_bn_acclaim
+xdathread: "http://forum.xda-developers.com/nook-tablet/development/recovery-twrp-2-8-5-1-touch-recovery-t3034670"
+ddof: "/dev/block/mmcblk0p3"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+<div class='page-heading'>Bootable SD Card (No Root Required):</div>
+<hr />
+<p class="text">If you prefer not to modify any of the stock software, you can create a proper bootable sdcard for your device and copy the acclaim-sdcard file to the root of the sdcard and rename it to recovery.img and/or altboot.img and boot TWRP using the cyanoboot menu from your sdcard.</p>
diff --git a/_devices/bqaquarisa45.markdown b/_devices/bqaquarisa45.markdown
index 61af1c3..38c061a 100644
--- a/_devices/bqaquarisa45.markdown
+++ b/_devices/bqaquarisa45.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris A4.5"
-codename: dendeone
-downloadfolder: dendeone
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_dendeone
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris A4.5"
+codename: dendeone
+downloadfolder: dendeone
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_dendeone
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarise10.markdown b/_devices/bqaquarise10.markdown
index b933722..e705de5 100644
--- a/_devices/bqaquarise10.markdown
+++ b/_devices/bqaquarise10.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris E10"
-codename: kaito_wifi
-downloadfolder: kaito_wifi 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_kaito_wifi
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E10"
+codename: kaito_wifi
+downloadfolder: kaito_wifi 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_kaito_wifi
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarise4.markdown b/_devices/bqaquarise4.markdown
index 84a6d50..64a5b99 100644
--- a/_devices/bqaquarise4.markdown
+++ b/_devices/bqaquarise4.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris E4"
-codename: puar
-downloadfolder: puar 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_puar
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E4"
+codename: puar
+downloadfolder: puar 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_puar
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarise45.markdown b/_devices/bqaquarise45.markdown
index 7b64873..fac6585 100644
--- a/_devices/bqaquarise45.markdown
+++ b/_devices/bqaquarise45.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris E4.5"
-codename: krillin
-downloadfolder: krillin
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_krillin
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E4.5"
+codename: krillin
+downloadfolder: krillin
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_krillin
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarise54g.markdown b/_devices/bqaquarise54g.markdown
index 3b86657..1a1c23c 100644
--- a/_devices/bqaquarise54g.markdown
+++ b/_devices/bqaquarise54g.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "BQ Aquaris E5 4G"
-codename: vegetalte
-downloadfolder: vegetalte
-oldurl: http://teamw.in/project/twrp2/274
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_vegetalte
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E5 4G"
+codename: vegetalte
+downloadfolder: vegetalte
+oldurl: http://teamw.in/project/twrp2/274
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_vegetalte
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/bqaquarise5fhd.markdown b/_devices/bqaquarise5fhd.markdown
index e5851b9..044bfcb 100644
--- a/_devices/bqaquarise5fhd.markdown
+++ b/_devices/bqaquarise5fhd.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris E5FHD"
-codename: vegetafhd
-downloadfolder: vegetafhd
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_vegetafhd
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E5FHD"
+codename: vegetafhd
+downloadfolder: vegetafhd
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_vegetafhd
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarise5hd.markdown b/_devices/bqaquarise5hd.markdown
index e43e610..ed2d6ef 100644
--- a/_devices/bqaquarise5hd.markdown
+++ b/_devices/bqaquarise5hd.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris E5HD"
-codename: vegetahd
-downloadfolder: vegetahd
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_vegetahd
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E5HD"
+codename: vegetahd
+downloadfolder: vegetahd
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_vegetahd
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarise6.markdown b/_devices/bqaquarise6.markdown
index 55195e4..2007e5c 100644
--- a/_devices/bqaquarise6.markdown
+++ b/_devices/bqaquarise6.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris E6"
-codename: bulma
-downloadfolder: bulma
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_bulma
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris E6"
+codename: bulma
+downloadfolder: bulma
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_bulma
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarism10.markdown b/_devices/bqaquarism10.markdown
index 3fa5bce..7c5604b 100644
--- a/_devices/bqaquarism10.markdown
+++ b/_devices/bqaquarism10.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "BQ Aquaris M10"
-codename: freezerhd
-downloadfolder: freezerhd 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_freezerhd
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris M10"
+codename: freezerhd
+downloadfolder: freezerhd 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_freezerhd
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/bqaquarism10fhd.markdown b/_devices/bqaquarism10fhd.markdown
index 82fe9c2..35a6779 100644
--- a/_devices/bqaquarism10fhd.markdown
+++ b/_devices/bqaquarism10fhd.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "BQ Aquaris M10 FHD"
-codename: freezerfhd
-downloadfolder: freezerfhd 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_freezerfhd
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris M10 FHD"
+codename: freezerfhd
+downloadfolder: freezerfhd 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_freezerfhd
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/bqaquarism45.markdown b/_devices/bqaquarism45.markdown
index 8a85fd7..2322d1c 100644
--- a/_devices/bqaquarism45.markdown
+++ b/_devices/bqaquarism45.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris M4.5"
-codename: dende
-downloadfolder: dende
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_dende
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include mtkinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris M4.5"
+codename: dende
+downloadfolder: dende
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_dende
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include mtkinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqaquarism5.markdown b/_devices/bqaquarism5.markdown
index 37e0934..24b51db 100644
--- a/_devices/bqaquarism5.markdown
+++ b/_devices/bqaquarism5.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris M5"
-codename: piccolo
-downloadfolder: piccolo
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_piccolo
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris M5"
+codename: piccolo
+downloadfolder: piccolo
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_piccolo
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/bqaquarism55.markdown b/_devices/bqaquarism55.markdown
index 37b7c34..1ed15e3 100644
--- a/_devices/bqaquarism55.markdown
+++ b/_devices/bqaquarism55.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris M5.5"
-codename: namek
-downloadfolder: namek
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_namek
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris M5.5"
+codename: namek
+downloadfolder: namek
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_namek
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/bqaquarisx5.markdown b/_devices/bqaquarisx5.markdown
index c3681d2..bf05d7c 100644
--- a/_devices/bqaquarisx5.markdown
+++ b/_devices/bqaquarisx5.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Aquaris X5 (piccolometal/paella)"
-codename: piccolometal
-downloadfolder: piccolometal
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_piccolometal
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "BQ Aquaris X5 (piccolometal/paella)"
+codename: piccolometal
+downloadfolder: piccolometal
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_piccolometal
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/bqcurie2qc.markdown b/_devices/bqcurie2qc.markdown
index 1f00166..e2a339e 100644
--- a/_devices/bqcurie2qc.markdown
+++ b/_devices/bqcurie2qc.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "BQ Curie 2 QC"
-codename: curie2qc
-downloadfolder: curie2qc 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_curie2qc
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include flashimageinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Curie 2 QC"
+codename: curie2qc
+downloadfolder: curie2qc 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_curie2qc
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include flashimageinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqedison2qc.markdown b/_devices/bqedison2qc.markdown
index 044039d..ccd8029 100644
--- a/_devices/bqedison2qc.markdown
+++ b/_devices/bqedison2qc.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "BQ Edison 2 QC"
-codename: edison2qc
-downloadfolder: edison2qc 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_edison2qc
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include flashimageinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Edison 2 QC"
+codename: edison2qc
+downloadfolder: edison2qc 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_edison2qc
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include flashimageinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqedison3mini.markdown b/_devices/bqedison3mini.markdown
index 396da34..d141466 100644
--- a/_devices/bqedison3mini.markdown
+++ b/_devices/bqedison3mini.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "BQ Edison 3 Mini"
-codename: edison3mini
-downloadfolder: edison3mini
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_edison3mini
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fastbootinstall.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Edison 3 Mini"
+codename: edison3mini
+downloadfolder: edison3mini
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_edison3mini
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fastbootinstall.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqmaxwell2.markdown b/_devices/bqmaxwell2.markdown
index 101cb67..edbb5d4 100644
--- a/_devices/bqmaxwell2.markdown
+++ b/_devices/bqmaxwell2.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "BQ Maxwell 2"
-codename: maxwell2
-downloadfolder: maxwell2 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_maxwell2
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include flashimageinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Maxwell 2"
+codename: maxwell2
+downloadfolder: maxwell2 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_maxwell2
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include flashimageinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqmaxwell2lite.markdown b/_devices/bqmaxwell2lite.markdown
index 23fbc1b..be9f6fd 100644
--- a/_devices/bqmaxwell2lite.markdown
+++ b/_devices/bqmaxwell2lite.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "BQ Maxwell 2 Lite"
-codename: maxwell2lite
-downloadfolder: maxwell2lite 
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_maxwell2lite
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include flashimageinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Maxwell 2 Lite"
+codename: maxwell2lite
+downloadfolder: maxwell2lite 
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_maxwell2lite
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include flashimageinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqmaxwell2plus.markdown b/_devices/bqmaxwell2plus.markdown
index ac1e7bd..383caad 100644
--- a/_devices/bqmaxwell2plus.markdown
+++ b/_devices/bqmaxwell2plus.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "BQ Maxwell 2 Plus"
-codename: maxwell2plus
-downloadfolder: maxwell2plus
-supportstatus: Current
-maintainer: Kra1o5
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_maxwell2plus
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include flashimageinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Maxwell 2 Plus"
+codename: maxwell2plus
+downloadfolder: maxwell2plus
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_maxwell2plus
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include flashimageinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/bqmaxwell2qc.markdown b/_devices/bqmaxwell2qc.markdown
index d584f75..bd7921b 100644
--- a/_devices/bqmaxwell2qc.markdown
+++ b/_devices/bqmaxwell2qc.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "BQ Maxwell 2 QC"
-codename: maxwell2qc
-downloadfolder: maxwell2qc 
-supportstatus: Current
-maintainer: fefifofum
-oem: BQ
-devicetree: https://github.com/TeamWin/android_device_bq_maxwell2qc
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include flashimageinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
+---
+layout: device
+title:  "BQ Maxwell 2 QC"
+codename: maxwell2qc
+downloadfolder: maxwell2qc 
+supportstatus: Current
+maintainer: fefifofum
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_maxwell2qc
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include flashimageinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
diff --git a/_devices/catb15q.markdown b/_devices/catb15q.markdown
index ed3e5c3..e762eee 100644
--- a/_devices/catb15q.markdown
+++ b/_devices/catb15q.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Cat B15q"
-codename: b15q
-downloadfolder: b15q
-supportstatus: Current
-maintainer: None
-oem: Cat
-devicetree: https://github.com/TeamWin/android_device_cat_b15q
-ddof: "/dev/recovery"
-mtkchipset: mt6582
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you should be able to root this device using kingo root app.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Cat B15q"
+codename: b15q
+downloadfolder: b15q
+supportstatus: Current
+maintainer: None
+oem: Cat
+devicetree: https://github.com/TeamWin/android_device_cat_b15q
+ddof: "/dev/recovery"
+mtkchipset: mt6582
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you should be able to root this device using kingo root app.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/dellstreak7.markdown b/_devices/dellstreak7.markdown
index 085163a..4e2ccc6 100644
--- a/_devices/dellstreak7.markdown
+++ b/_devices/dellstreak7.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Dell Streak 7"
-codename: streak7
-downloadfolder: streak7
-oldurl: http://teamw.in/project/twrp2/12
-supportstatus: No Longer Updated
-maintainer: None
-oem: Dell
-devicetree: https://github.com/TeamWin/android_device_dell_streak7
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Dell Streak 7"
+codename: streak7
+downloadfolder: streak7
+oldurl: http://teamw.in/project/twrp2/12
+supportstatus: No Longer Updated
+maintainer: None
+oem: Dell
+devicetree: https://github.com/TeamWin/android_device_dell_streak7
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/hptouchpad.markdown b/_devices/hptouchpad.markdown
index 724a604..20a849d 100644
--- a/_devices/hptouchpad.markdown
+++ b/_devices/hptouchpad.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "HP TouchPad"
-codename: tenderloin
-downloadfolder: tenderloin
-oldurl: http://teamw.in/project/twrp2/75
-supportstatus: No longer updated
-maintainer: None
-oem: HP
-devicetree: https://github.com/TeamWin/device_hp_tenderloin
-xdathread: http://forum.xda-developers.com/showthread.php?t=1400649
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-<div class='page-heading'>Manual Install:</div>
-<hr />
-<p class="text">You must already have Android installed on your TouchPad. Download the above file. Rename it to uImage.TWRP&nbsp; Boot to recovery and use the menu options to mount boot.&nbsp; Plug the TouchPad into your computer and run the following command:</p>
-<p class="text">adb push uImage.TWRP /boot</p>
-<p class="text">Reboot and select TWRP&nbsp;from the boot menu.</p>
+---
+layout: device
+title:  "HP TouchPad"
+codename: tenderloin
+downloadfolder: tenderloin
+oldurl: http://teamw.in/project/twrp2/75
+supportstatus: No longer updated
+maintainer: None
+oem: HP
+devicetree: https://github.com/TeamWin/device_hp_tenderloin
+xdathread: http://forum.xda-developers.com/showthread.php?t=1400649
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+<div class='page-heading'>Manual Install:</div>
+<hr />
+<p class="text">You must already have Android installed on your TouchPad. Download the above file. Rename it to uImage.TWRP&nbsp; Boot to recovery and use the menu options to mount boot.&nbsp; Plug the TouchPad into your computer and run the following command:</p>
+<p class="text">adb push uImage.TWRP /boot</p>
+<p class="text">Reboot and select TWRP&nbsp;from the boot menu.</p>
diff --git a/_devices/htc10.markdown b/_devices/htc10.markdown
index 7ec6d07..cf43da7 100644
--- a/_devices/htc10.markdown
+++ b/_devices/htc10.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC 10"
-codename: pme
-downloadfolder: pme
-supportstatus: Current
-maintainer: CaptainThrowback
-oem: HTC
-ddof: "/dev/block/bootdevice/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_htc_pme"
-xdathread: "http://forum.xda-developers.com/htc-10/development/recovery-twrp-touch-recovery-t3358139"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC 10"
+codename: pme
+downloadfolder: pme
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_htc_pme"
+xdathread: "http://forum.xda-developers.com/htc-10/development/recovery-twrp-touch-recovery-t3358139"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htca11ul.markdown b/_devices/htca11ul.markdown
index 6ed7473..d2e162c 100644
--- a/_devices/htca11ul.markdown
+++ b/_devices/htca11ul.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Desire 510 EU"
-codename: a11ul
-downloadfolder: a11ul
-supportstatus: current
-maintainer: PatrikKT
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_a11ul
-xdathread: ""
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire 510 EU"
+codename: a11ul
+downloadfolder: a11ul
+supportstatus: current
+maintainer: PatrikKT
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_a11ul
+xdathread: ""
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htca31ul.markdown b/_devices/htca31ul.markdown
index f674c07..8791101 100644
--- a/_devices/htca31ul.markdown
+++ b/_devices/htca31ul.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Desire 620" 
-codename: a31ul
-downloadfolder: a31ul
-supportstatus: current
-maintainer: PatrikKT
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_a31ul
-xdathread: ""
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire 620" 
+codename: a31ul
+downloadfolder: a31ul
+supportstatus: current
+maintainer: PatrikKT
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_a31ul
+xdathread: ""
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcamaze4g.markdown b/_devices/htcamaze4g.markdown
index 49ff1f7..99b33cf 100644
--- a/_devices/htcamaze4g.markdown
+++ b/_devices/htcamaze4g.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC Amaze 4G"
-codename: ruby
-downloadfolder: ruby
-oldurl: http://teamw.in/project/twrp2/86
-supportstatus: No longer updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/device_htc_ruby
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1416118"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Amaze 4G"
+codename: ruby
+downloadfolder: ruby
+oldurl: http://teamw.in/project/twrp2/86
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_ruby
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1416118"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcbutterfly2.markdown b/_devices/htcbutterfly2.markdown
index bc53fae..f84f86d 100644
--- a/_devices/htcbutterfly2.markdown
+++ b/_devices/htcbutterfly2.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Butterfly 2"
-codename: b2ul
-downloadfolder: b2ul
-oldurl: http://teamw.in/project/twrp2/285
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Butterfly 2"
+codename: b2ul
+downloadfolder: b2ul
+oldurl: http://teamw.in/project/twrp2/285
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcbutterflyx920d.markdown b/_devices/htcbutterflyx920d.markdown
index f39d844..b2110dc 100644
--- a/_devices/htcbutterflyx920d.markdown
+++ b/_devices/htcbutterflyx920d.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Butterfly X920d"
-codename: dlxu
-downloadfolder: dlxu
-oldurl: http://teamw.in/project/twrp2/142
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Butterfly X920d"
+codename: dlxu
+downloadfolder: dlxu
+oldurl: http://teamw.in/project/twrp2/142
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcbutterflyx920e.markdown b/_devices/htcbutterflyx920e.markdown
index 505eca4..ab76b23 100644
--- a/_devices/htcbutterflyx920e.markdown
+++ b/_devices/htcbutterflyx920e.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Butterfly X9202"
-codename: dlxub1
-downloadfolder: dlxub1
-oldurl: http://teamw.in/project/twrp2/141
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Butterfly X9202"
+codename: dlxub1
+downloadfolder: dlxub1
+oldurl: http://teamw.in/project/twrp2/141
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesire510usa32bit.markdown b/_devices/htcdesire510usa32bit.markdown
index 10c7c63..9995e6c 100644
--- a/_devices/htcdesire510usa32bit.markdown
+++ b/_devices/htcdesire510usa32bit.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Desire 510 USA 32bit"
-codename: a11
-downloadfolder: a11
-oldurl: http://teamw.in/project/twrp2/272
-supportstatus: Current
-maintainer: Dees_Troy
-oem: HTC
-xdathread: "http://forum.xda-developers.com/desire-510/orig-development/recovery-twrp-2-8-3-0-touch-recovery-t2980932"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire 510 USA 32bit"
+codename: a11
+downloadfolder: a11
+oldurl: http://teamw.in/project/twrp2/272
+supportstatus: Current
+maintainer: Dees_Troy
+oem: HTC
+xdathread: "http://forum.xda-developers.com/desire-510/orig-development/recovery-twrp-2-8-3-0-touch-recovery-t2980932"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesire601cdma.markdown b/_devices/htcdesire601cdma.markdown
index d58cdb5..2e657c2 100644
--- a/_devices/htcdesire601cdma.markdown
+++ b/_devices/htcdesire601cdma.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Desire 601 CDMA"
-codename: zaracl
-downloadfolder: zaracl
-oldurl: http://teamw.in/project/twrp2/217
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire 601 CDMA"
+codename: zaracl
+downloadfolder: zaracl
+oldurl: http://teamw.in/project/twrp2/217
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesire601gsm.markdown b/_devices/htcdesire601gsm.markdown
index a141ce7..b644553 100644
--- a/_devices/htcdesire601gsm.markdown
+++ b/_devices/htcdesire601gsm.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Desire 601 GSM"
-codename: zara
-downloadfolder: zara
-oldurl: http://teamw.in/project/twrp2/279
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire 601 GSM"
+codename: zara
+downloadfolder: zara
+oldurl: http://teamw.in/project/twrp2/279
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesire610usa.markdown b/_devices/htcdesire610usa.markdown
index 7f780a2..a21feb9 100644
--- a/_devices/htcdesire610usa.markdown
+++ b/_devices/htcdesire610usa.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC Desire 610"
-codename: a3ul
-downloadfolder: a3ul
-oldurl: http://teamw.in/project/twrp2/246
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p41"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC Desire 610"
+codename: a3ul
+downloadfolder: a3ul
+oldurl: http://teamw.in/project/twrp2/246
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p41"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htcdesire626s.markdown b/_devices/htcdesire626s.markdown
index 1250100..199c8fb 100644
--- a/_devices/htcdesire626s.markdown
+++ b/_devices/htcdesire626s.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC Desire 626s"
-codename: a32e
-downloadfolder: a32e
-supportstatus: Current
-maintainer: CaptainThrowback
-oem: HTC
-ddof: "/dev/block/bootdevice/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC Desire 626s"
+codename: a32e
+downloadfolder: a32e
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/bootdevice/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htcdesire816.markdown b/_devices/htcdesire816.markdown
index b3254e2..9967e7f 100644
--- a/_devices/htcdesire816.markdown
+++ b/_devices/htcdesire816.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC Desire 816"
-codename: a5
-downloadfolder: a5
-oldurl: http://teamw.in/project/twrp2/247
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p41"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC Desire 816"
+codename: a5
+downloadfolder: a5
+oldurl: http://teamw.in/project/twrp2/247
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p41"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htcdesirec.markdown b/_devices/htcdesirec.markdown
index b59e1d7..1cbedd1 100644
--- a/_devices/htcdesirec.markdown
+++ b/_devices/htcdesirec.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Desire C"
-codename: golfu
-downloadfolder: golfu
-oldurl: http://teamw.in/project/twrp2/160
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire C"
+codename: golfu
+downloadfolder: golfu
+oldurl: http://teamw.in/project/twrp2/160
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesirehd.markdown b/_devices/htcdesirehd.markdown
index 290d313..407c905 100644
--- a/_devices/htcdesirehd.markdown
+++ b/_devices/htcdesirehd.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Desire HD"
-codename: ace
-downloadfolder: ace
-oldurl: http://teamw.in/project/twrp2/6
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/device_htc_ace
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire HD"
+codename: ace
+downloadfolder: ace
+oldurl: http://teamw.in/project/twrp2/6
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_ace
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesires.markdown b/_devices/htcdesires.markdown
index d75f211..9a3cedc 100644
--- a/_devices/htcdesires.markdown
+++ b/_devices/htcdesires.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Desire S"
-codename: saga
-downloadfolder: saga
-oldurl: http://teamw.in/project/twrp2/68
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/device_htc_saga
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire S"
+codename: saga
+downloadfolder: saga
+oldurl: http://teamw.in/project/twrp2/68
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_saga
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdesirex.markdown b/_devices/htcdesirex.markdown
index c9e6d54..f2d9baa 100644
--- a/_devices/htcdesirex.markdown
+++ b/_devices/htcdesirex.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Desire X"
-codename: protou
-downloadfolder: protou
-oldurl: http://teamw.in/project/twrp2/140
-supportstatus: Current
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_protou
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Desire X"
+codename: protou
+downloadfolder: protou
+oldurl: http://teamw.in/project/twrp2/140
+supportstatus: Current
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_protou
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdroiddna.markdown b/_devices/htcdroiddna.markdown
index 3f1aef6..ca30104 100644
--- a/_devices/htcdroiddna.markdown
+++ b/_devices/htcdroiddna.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Droid DNA"
-codename: dlx
-downloadfolder: dlx
-oldurl: http://teamw.in/project/twrp2/127
-supportstatus: Current
-maintainer: invisiblek
-oem: HTC
-ddof: "/dev/block/mmcblk0p41"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Droid DNA"
+codename: dlx
+downloadfolder: dlx
+oldurl: http://teamw.in/project/twrp2/127
+supportstatus: Current
+maintainer: invisiblek
+oem: HTC
+ddof: "/dev/block/mmcblk0p41"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdroidincredible.markdown b/_devices/htcdroidincredible.markdown
index c24e743..26d376b 100644
--- a/_devices/htcdroidincredible.markdown
+++ b/_devices/htcdroidincredible.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Droid Incredible"
-codename: inc
-downloadfolder: inc
-oldurl: http://teamw.in/project/twrp2/4
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Droid Incredible"
+codename: inc
+downloadfolder: inc
+oldurl: http://teamw.in/project/twrp2/4
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdroidincredible2.markdown b/_devices/htcdroidincredible2.markdown
index 50215e9..c23f6c9 100644
--- a/_devices/htcdroidincredible2.markdown
+++ b/_devices/htcdroidincredible2.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Droid Incredible 2"
-codename: vivow
-downloadfolder: vivow
-oldurl: http://teamw.in/project/twrp2/71
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Droid Incredible 2"
+codename: vivow
+downloadfolder: vivow
+oldurl: http://teamw.in/project/twrp2/71
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcdroidincredible4g.markdown b/_devices/htcdroidincredible4g.markdown
index 7deb90d..cccdb91 100644
--- a/_devices/htcdroidincredible4g.markdown
+++ b/_devices/htcdroidincredible4g.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Droid Incredible 4G"
-codename: fireball
-downloadfolder: fireball
-oldurl: http://teamw.in/project/twrp2/139
-supportstatus: Current
-maintainer: mdmower
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Droid Incredible 4G"
+codename: fireball
+downloadfolder: fireball
+oldurl: http://teamw.in/project/twrp2/139
+supportstatus: Current
+maintainer: mdmower
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcevo3dcdma.markdown b/_devices/htcevo3dcdma.markdown
index 8c1da7c..663180d 100644
--- a/_devices/htcevo3dcdma.markdown
+++ b/_devices/htcevo3dcdma.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC EVO 3D CDMA 4G WiMAX"
-codename: shooter
-downloadfolder: shooter
-oldurl: http://teamw.in/project/twrp2/67
-supportstatus: Active
-maintainer: CaptainThrowback
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_shooter
-xdathread: "http://forum.xda-developers.com/htc-evo-3d/cdma-development/recovery-twrp-touch-recovery-selinux-t3063642"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC EVO 3D CDMA 4G WiMAX"
+codename: shooter
+downloadfolder: shooter
+oldurl: http://teamw.in/project/twrp2/67
+supportstatus: Active
+maintainer: CaptainThrowback
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_shooter
+xdathread: "http://forum.xda-developers.com/htc-evo-3d/cdma-development/recovery-twrp-touch-recovery-selinux-t3063642"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcevo3dgsm.markdown b/_devices/htcevo3dgsm.markdown
index 6bba3ee..72b0b99 100644
--- a/_devices/htcevo3dgsm.markdown
+++ b/_devices/htcevo3dgsm.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC EVO 3D GSM"
-codename: shooteru
-downloadfolder: shooteru
-oldurl: http://teamw.in/project/twrp2/87
-supportstatus: Current
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/device_htc_shooteru
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1509748"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC EVO 3D GSM"
+codename: shooteru
+downloadfolder: shooteru
+oldurl: http://teamw.in/project/twrp2/87
+supportstatus: Current
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_shooteru
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1509748"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcevo4g.markdown b/_devices/htcevo4g.markdown
index 7a47c1c..6265dc5 100644
--- a/_devices/htcevo4g.markdown
+++ b/_devices/htcevo4g.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC EVO 4G"
-codename: supersonic
-downloadfolder: supersonic
-oldurl: http://teamw.in/project/twrp2/3
-supportstatus: Active
-maintainer: CaptainThrowback
-oem: HTC
-devicetree: "https://github.com/TeamWin/android_device_htc_supersonic"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=3060199"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC EVO 4G"
+codename: supersonic
+downloadfolder: supersonic
+oldurl: http://teamw.in/project/twrp2/3
+supportstatus: Active
+maintainer: CaptainThrowback
+oem: HTC
+devicetree: "https://github.com/TeamWin/android_device_htc_supersonic"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=3060199"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcevo4glte.markdown b/_devices/htcevo4glte.markdown
index 9140225..5ec0ddd 100644
--- a/_devices/htcevo4glte.markdown
+++ b/_devices/htcevo4glte.markdown
@@ -1,28 +1,28 @@
----
-layout: device
-title:  "HTC EVO 4G LTE"
-codename: jewel
-downloadfolder: jewel
-oldurl: http://teamw.in/project/twrp2/98
-supportstatus: Current
-maintainer: Dees_Troy, CaptainThrowback
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_jewel/tree/android-5.0
-xdathread: "http://forum.xda-developers.com/evo-4g-lte-sprint/orig-development/recovery-twrp-touch-recovery-t3068193"
-ddof: "/dev/block/mmcblk0p22"
----
-
-{% include disclaimer.html %}
-NOTE: As of TWRP 2.8.6.0, both partition layouts for Jewel are supported by the official TWRP!
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC EVO 4G LTE"
+codename: jewel
+downloadfolder: jewel
+oldurl: http://teamw.in/project/twrp2/98
+supportstatus: Current
+maintainer: Dees_Troy, CaptainThrowback
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_jewel/tree/android-5.0
+xdathread: "http://forum.xda-developers.com/evo-4g-lte-sprint/orig-development/recovery-twrp-touch-recovery-t3068193"
+ddof: "/dev/block/mmcblk0p22"
+---
+
+{% include disclaimer.html %}
+NOTE: As of TWRP 2.8.6.0, both partition layouts for Jewel are supported by the official TWRP!
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htcevoshift.markdown b/_devices/htcevoshift.markdown
index 02cb40c..768fa36 100644
--- a/_devices/htcevoshift.markdown
+++ b/_devices/htcevoshift.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC EVO Shift 4G"
-codename: speedy
-downloadfolder: speedy
-oldurl: http://teamw.in/project/twrp2/5
-supportstatus: No longer updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_speedy
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1291643"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC EVO Shift 4G"
+codename: speedy
+downloadfolder: speedy
+oldurl: http://teamw.in/project/twrp2/5
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_speedy
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1291643"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcexplorer.markdown b/_devices/htcexplorer.markdown
index 77e9333..8112eb1 100644
--- a/_devices/htcexplorer.markdown
+++ b/_devices/htcexplorer.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Explorer"
-codename: pico
-downloadfolder: pico
-oldurl: http://teamw.in/project/twrp2/163
-supportstatus: Current
-maintainer: MSF-Jarvis
-oem: HTC
-xdathread: "http://forum.xda-developers.com/htc-explorer/orig-development/twrp-2-8-7-0-twrp-htc-explorer-t3282943"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Explorer"
+codename: pico
+downloadfolder: pico
+oldurl: http://teamw.in/project/twrp2/163
+supportstatus: Current
+maintainer: MSF-Jarvis
+oem: HTC
+xdathread: "http://forum.xda-developers.com/htc-explorer/orig-development/twrp-2-8-7-0-twrp-htc-explorer-t3282943"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcfirst.markdown b/_devices/htcfirst.markdown
index 4d00f86..0a4c2ed 100644
--- a/_devices/htcfirst.markdown
+++ b/_devices/htcfirst.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC First"
-codename: mystul
-downloadfolder: mystul
-oldurl: http://teamw.in/project/twrp2/236
-supportstatus: Current
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_mystul
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC First"
+codename: mystul
+downloadfolder: mystul
+oldurl: http://teamw.in/project/twrp2/236
+supportstatus: Current
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_mystul
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htchd2.markdown b/_devices/htchd2.markdown
index 7fa9cd8..02a0bd9 100644
--- a/_devices/htchd2.markdown
+++ b/_devices/htchd2.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC HD2"
-codename: leo
-downloadfolder: leo
-oldurl: http://teamw.in/project/twrp2/80
-supportstatus: No longer updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/device_htc_leo
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include flashimageinstall.html %}
+---
+layout: device
+title:  "HTC HD2"
+codename: leo
+downloadfolder: leo
+oldurl: http://teamw.in/project/twrp2/80
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_leo
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include flashimageinstall.html %}
diff --git a/_devices/htcherocdma.markdown b/_devices/htcherocdma.markdown
index 5cc3ca7..abb2959 100644
--- a/_devices/htcherocdma.markdown
+++ b/_devices/htcherocdma.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "HTC Hero CDMA"
-codename: heroc
-downloadfolder: heroc
-oldurl: http://teamw.in/project/twrp2/49
-supportstatus: No longer updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/device_htc_heroc
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1852183"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include flashimageinstall.html %}
+---
+layout: device
+title:  "HTC Hero CDMA"
+codename: heroc
+downloadfolder: heroc
+oldurl: http://teamw.in/project/twrp2/49
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_heroc
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1852183"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include flashimageinstall.html %}
diff --git a/_devices/htcincredibles.markdown b/_devices/htcincredibles.markdown
index bd18e96..1f8e341 100644
--- a/_devices/htcincredibles.markdown
+++ b/_devices/htcincredibles.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Incredible S"
-codename: vivo
-downloadfolder: vivo
-oldurl: http://teamw.in/project/twrp2/70
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Incredible S"
+codename: vivo
+downloadfolder: vivo
+oldurl: http://teamw.in/project/twrp2/70
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcmerge.markdown b/_devices/htcmerge.markdown
index 96c2bc0..bc74e4b 100644
--- a/_devices/htcmerge.markdown
+++ b/_devices/htcmerge.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Merge"
-codename: lexicon
-downloadfolder: lexicon
-oldurl: http://teamw.in/project/twrp2/84
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Merge"
+codename: lexicon
+downloadfolder: lexicon
+oldurl: http://teamw.in/project/twrp2/84
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcnexus9.markdown b/_devices/htcnexus9.markdown
index 24eecef..6073995 100644
--- a/_devices/htcnexus9.markdown
+++ b/_devices/htcnexus9.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC Nexus 9"
-codename: flounder
-downloadfolder: flounder
-oldurl: http://teamw.in/project/twrp2/269
-supportstatus: Current
-maintainer: Dees_Troy
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_flounder
-xdathread: "http://forum.xda-developers.com/nexus-9/orig-development/recovery-twrp-2-8-2-0-touch-recovery-t2944788"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Nexus 9"
+codename: flounder
+downloadfolder: flounder
+oldurl: http://teamw.in/project/twrp2/269
+supportstatus: Current
+maintainer: Dees_Troy
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_flounder
+xdathread: "http://forum.xda-developers.com/nexus-9/orig-development/recovery-twrp-2-8-2-0-touch-recovery-t2944788"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcnexusone.markdown b/_devices/htcnexusone.markdown
index 87c48de..8291d6f 100644
--- a/_devices/htcnexusone.markdown
+++ b/_devices/htcnexusone.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "HTC Nexus One"
-codename: passion
-downloadfolder: passion
-oldurl: http://teamw.in/project/twrp2/51
-supportstatus: No longer updated
-maintainer: None
-oem: HTC
-devicetree: https://github.com/TeamWin/android_device_htc_passion
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Nexus One"
+codename: passion
+downloadfolder: passion
+oldurl: http://teamw.in/project/twrp2/51
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/android_device_htc_passion
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconea9.markdown b/_devices/htconea9.markdown
index 8d94ef6..5d10f1c 100644
--- a/_devices/htconea9.markdown
+++ b/_devices/htconea9.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC One A9"
-codename: hiae
-downloadfolder: hiae
-supportstatus: Current
-maintainer: CaptainThrowback
-oem: HTC
-ddof: "/dev/block/bootdevice/by-name/recovery"
-devicetree: "https://github.com/teamwin/android_device_htc_hiae"
-xdathread: "http://forum.xda-developers.com/one-a9/orig-development/recovery-twrp-touch-recovery-t3257023"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One A9"
+codename: hiae
+downloadfolder: hiae
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: "https://github.com/teamwin/android_device_htc_hiae"
+xdathread: "http://forum.xda-developers.com/one-a9/orig-development/recovery-twrp-touch-recovery-t3257023"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconee8.markdown b/_devices/htconee8.markdown
index 15bee4c..e293b2a 100644
--- a/_devices/htconee8.markdown
+++ b/_devices/htconee8.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "HTC One E8"
-codename: e8
-downloadfolder: e8
-supportstatus: Current
-maintainer: CaptainThrowback
-oem: HTC
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_htc_e8"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=3060188"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One E8"
+codename: e8
+downloadfolder: e8
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_htc_e8"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=3060188"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconem7dualsim.markdown b/_devices/htconem7dualsim.markdown
index d0b69ed..2bd42ce 100644
--- a/_devices/htconem7dualsim.markdown
+++ b/_devices/htconem7dualsim.markdown
@@ -1,56 +1,56 @@
----
-layout: device
-title:  "HTC One m7 Dual SIM"
-codename: m7cd
-downloadfolder: m7cdtu
-oldurl: http://teamw.in/project/twrp2/278
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p37"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">m7cdtu:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}m7cdtu">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">m7cdug:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}m7cdug">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">m7cdwg:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}m7cdwg">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One m7 Dual SIM"
+codename: m7cd
+downloadfolder: m7cdtu
+oldurl: http://teamw.in/project/twrp2/278
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p37"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">m7cdtu:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}m7cdtu">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">m7cdug:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}m7cdug">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">m7cdwg:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}m7cdwg">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconem7gsm.markdown b/_devices/htconem7gsm.markdown
index ba686b4..b59a4e9 100644
--- a/_devices/htconem7gsm.markdown
+++ b/_devices/htconem7gsm.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One m7 GSM"
-codename: m7
-downloadfolder: m7
-oldurl: http://teamw.in/project/twrp2/164
-supportstatus: Current
-maintainer: mdmower
-oem: HTC
-ddof: "/dev/block/mmcblk0p34"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One m7 GSM"
+codename: m7
+downloadfolder: m7
+oldurl: http://teamw.in/project/twrp2/164
+supportstatus: Current
+maintainer: mdmower
+oem: HTC
+ddof: "/dev/block/mmcblk0p34"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconem7sprint.markdown b/_devices/htconem7sprint.markdown
index 2b72768..ada1a93 100644
--- a/_devices/htconem7sprint.markdown
+++ b/_devices/htconem7sprint.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One m7 Sprint"
-codename: m7wls
-downloadfolder: m7wls
-oldurl: http://teamw.in/project/twrp2/171
-supportstatus: Current
-maintainer: mdmower
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One m7 Sprint"
+codename: m7wls
+downloadfolder: m7wls
+oldurl: http://teamw.in/project/twrp2/171
+supportstatus: Current
+maintainer: mdmower
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconem7verizon.markdown b/_devices/htconem7verizon.markdown
index 83e9369..18d5bda 100644
--- a/_devices/htconem7verizon.markdown
+++ b/_devices/htconem7verizon.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One m7 Verizon"
-codename: m7wlv
-downloadfolder: m7vzw
-oldurl: http://teamw.in/project/twrp2/255
-supportstatus: Current
-maintainer: mdmower
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One m7 Verizon"
+codename: m7wlv
+downloadfolder: m7vzw
+oldurl: http://teamw.in/project/twrp2/255
+supportstatus: Current
+maintainer: mdmower
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconem8gsm.markdown b/_devices/htconem8gsm.markdown
index 855561a..0c704a1 100644
--- a/_devices/htconem8gsm.markdown
+++ b/_devices/htconem8gsm.markdown
@@ -1,30 +1,30 @@
----
-layout: device
-title:  "HTC One M8 All Variants"
-codename: m8
-downloadfolder: m8
-oldurl: http://teamw.in/project/twrp2/225
-supportstatus: Current
-maintainer: CaptainThrowback
-oem: HTC
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/teamwin/android_device_htc_m8"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2717932"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-[Sprint support thread on xda-developers](http://forum.xda-developers.com/showthread.php?t=2717924)
-
-[Verizon support thread on xda-developers](http://forum.xda-developers.com/showthread.php?t=2717928)
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One M8 All Variants"
+codename: m8
+downloadfolder: m8
+oldurl: http://teamw.in/project/twrp2/225
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/teamwin/android_device_htc_m8"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2717932"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+[Sprint support thread on xda-developers](http://forum.xda-developers.com/showthread.php?t=2717924)
+
+[Verizon support thread on xda-developers](http://forum.xda-developers.com/showthread.php?t=2717928)
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconem9.markdown b/_devices/htconem9.markdown
index d8bf142..b68f843 100644
--- a/_devices/htconem9.markdown
+++ b/_devices/htconem9.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "HTC One M9"
-codename: hima
-downloadfolder: hima
-supportstatus: Current
-maintainer: CaptainThrowback
-oem: HTC
-ddof: "/dev/block/bootdevice/by-name/recovery"
-devicetree: "https://github.com/teamwin/android_device_htc_hima"
-xdathread: "http://forum.xda-developers.com/one-m9/orig-development/recovery-twrp-touch-recovery-t3066720"
----
-
-{% include disclaimer.html %}
-NOTE: Installing TWRP can break your ability to receive updates from HTC.
-
-DISCLAIMER: Please make sure you read about the [Device-Specific Issues](http://forum.xda-developers.com/one-m9/orig-development/recovery-twrp-touch-recovery-t3066720/post59745198) in the XDA thread for this device PRIOR to downloading or flashing ANYTHING from this page!!
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One M9"
+codename: hima
+downloadfolder: hima
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: "https://github.com/teamwin/android_device_htc_hima"
+xdathread: "http://forum.xda-developers.com/one-m9/orig-development/recovery-twrp-touch-recovery-t3066720"
+---
+
+{% include disclaimer.html %}
+NOTE: Installing TWRP can break your ability to receive updates from HTC.
+
+DISCLAIMER: Please make sure you read about the [Device-Specific Issues](http://forum.xda-developers.com/one-m9/orig-development/recovery-twrp-touch-recovery-t3066720/post59745198) in the XDA thread for this device PRIOR to downloading or flashing ANYTHING from this page!!
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconemaxgsm.markdown b/_devices/htconemaxgsm.markdown
index 677aeb2..8ff82c3 100644
--- a/_devices/htconemaxgsm.markdown
+++ b/_devices/htconemaxgsm.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "HTC One Max GSM"
-codename: t6ul
-downloadfolder: t6ul
-supportstatus: Current
-maintainer: FlyHalf205
-oem: HTC
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One Max GSM"
+codename: t6ul
+downloadfolder: t6ul
+supportstatus: Current
+maintainer: FlyHalf205
+oem: HTC
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconemaxsprint.markdown b/_devices/htconemaxsprint.markdown
index 557c20d..1c83467 100644
--- a/_devices/htconemaxsprint.markdown
+++ b/_devices/htconemaxsprint.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One Max Sprint"
-codename: t6spr
-downloadfolder: t6spr
-oldurl: http://teamw.in/project/twrp2/211
-supportstatus: Current
-maintainer: FlyHalf205
-oem: HTC
-ddof: "/dev/block/mmcblk0p38"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One Max Sprint"
+codename: t6spr
+downloadfolder: t6spr
+oldurl: http://teamw.in/project/twrp2/211
+supportstatus: Current
+maintainer: FlyHalf205
+oem: HTC
+ddof: "/dev/block/mmcblk0p38"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconemaxverizon.markdown b/_devices/htconemaxverizon.markdown
index 8f24d24..b28041e 100644
--- a/_devices/htconemaxverizon.markdown
+++ b/_devices/htconemaxverizon.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One Max Verizon"
-codename: t6vzw
-downloadfolder: t6vzw
-oldurl: http://teamw.in/project/twrp2/210
-supportstatus: Current
-maintainer: FlyHalf205
-oem: HTC
-ddof: "/dev/block/mmcblk0p38"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One Max Verizon"
+codename: t6vzw
+downloadfolder: t6vzw
+oldurl: http://teamw.in/project/twrp2/210
+supportstatus: Current
+maintainer: FlyHalf205
+oem: HTC
+ddof: "/dev/block/mmcblk0p38"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconeminigsm.markdown b/_devices/htconeminigsm.markdown
index d00e540..ba31d6d 100644
--- a/_devices/htconeminigsm.markdown
+++ b/_devices/htconeminigsm.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One Mini"
-codename: m4ul
-downloadfolder: m4ul
-oldurl: http://teamw.in/project/twrp2/216
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One Mini"
+codename: m4ul
+downloadfolder: m4ul
+oldurl: http://teamw.in/project/twrp2/216
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconeremix.markdown b/_devices/htconeremix.markdown
index cb01bd8..26df608 100644
--- a/_devices/htconeremix.markdown
+++ b/_devices/htconeremix.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "HTC One Remix"
-codename: memwl
-downloadfolder: memwl
-supportstatus: No longer updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One Remix"
+codename: memwl
+downloadfolder: memwl
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconess3.markdown b/_devices/htconess3.markdown
index 8c037c0..6585393 100644
--- a/_devices/htconess3.markdown
+++ b/_devices/htconess3.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "HTC One S (S3 processor)"
-codename: villec
-downloadfolder: villec
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One S (S3 processor)"
+codename: villec
+downloadfolder: villec
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconess4.markdown b/_devices/htconess4.markdown
index 15b1799..0300fe2 100644
--- a/_devices/htconess4.markdown
+++ b/_devices/htconess4.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One S (S4 processor)"
-codename: ville
-downloadfolder: ville
-oldurl: http://teamw.in/project/twrp2/100
-supportstatus: Current
-maintainer: mdmower
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One S (S4 processor)"
+codename: ville
+downloadfolder: ville
+oldurl: http://teamw.in/project/twrp2/100
+supportstatus: Current
+maintainer: mdmower
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconess4specialedition.markdown b/_devices/htconess4specialedition.markdown
index ccb4605..529d868 100644
--- a/_devices/htconess4specialedition.markdown
+++ b/_devices/htconess4specialedition.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "HTC One S (S4 processor) Special Edition 64GB"
-codename: ville_u
-downloadfolder: ville_u
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One S (S4 processor) Special Edition 64GB"
+codename: ville_u
+downloadfolder: ville_u
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconesvboost.markdown b/_devices/htconesvboost.markdown
index 2d1c731..a9771c8 100644
--- a/_devices/htconesvboost.markdown
+++ b/_devices/htconesvboost.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One SV Boost USA"
-codename: k2_cl
-downloadfolder: k2_cl
-oldurl: http://teamw.in/project/twrp2/184
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One SV Boost USA"
+codename: k2_cl
+downloadfolder: k2_cl
+oldurl: http://teamw.in/project/twrp2/184
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconesvcricket.markdown b/_devices/htconesvcricket.markdown
index 92793e5..ad179da 100644
--- a/_devices/htconesvcricket.markdown
+++ b/_devices/htconesvcricket.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One SV Cricket USA"
-codename: k2_plc_cl
-downloadfolder: k2_plc_cl
-oldurl: http://teamw.in/project/twrp2/188
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One SV Cricket USA"
+codename: k2_plc_cl
+downloadfolder: k2_plc_cl
+oldurl: http://teamw.in/project/twrp2/188
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconesvgsm.markdown b/_devices/htconesvgsm.markdown
index 5304bcb..2efaa4b 100644
--- a/_devices/htconesvgsm.markdown
+++ b/_devices/htconesvgsm.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One SV GSM"
-codename: k2_u
-downloadfolder: k2_u
-oldurl: http://teamw.in/project/twrp2/189
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One SV GSM"
+codename: k2_u
+downloadfolder: k2_u
+oldurl: http://teamw.in/project/twrp2/189
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconesvlte.markdown b/_devices/htconesvlte.markdown
index 32c20a7..9c0c0b3 100644
--- a/_devices/htconesvlte.markdown
+++ b/_devices/htconesvlte.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "HTC One SV LTE"
-codename: k2_ul
-downloadfolder: k2_ul
-oldurl: http://teamw.in/project/twrp2/190
-supportstatus: Current
-maintainer: None
-oem: HTC
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "HTC One SV LTE"
+codename: k2_ul
+downloadfolder: k2_ul
+oldurl: http://teamw.in/project/twrp2/190
+supportstatus: Current
+maintainer: None
+oem: HTC
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/htconevgsm.markdown b/_devices/htconevgsm.markdown
index febf203..0b1dc92 100644
--- a/_devices/htconevgsm.markdown
+++ b/_devices/htconevgsm.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One V GSM"
-codename: primou
-downloadfolder: primou
-oldurl: http://teamw.in/project/twrp2/119
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One V GSM"
+codename: primou
+downloadfolder: primou
+oldurl: http://teamw.in/project/twrp2/119
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconevvirgin.markdown b/_devices/htconevvirgin.markdown
index c1f3ec3..3c18a5d 100644
--- a/_devices/htconevvirgin.markdown
+++ b/_devices/htconevvirgin.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One V Virgin Mobile"
-codename: primoc
-downloadfolder: primoc
-oldurl: http://teamw.in/project/twrp2/120
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One V Virgin Mobile"
+codename: primoc
+downloadfolder: primoc
+oldurl: http://teamw.in/project/twrp2/120
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconevx.markdown b/_devices/htconevx.markdown
index 963a5d5..98b4e32 100644
--- a/_devices/htconevx.markdown
+++ b/_devices/htconevx.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One VX"
-codename: totemc2
-downloadfolder: totemc2
-oldurl: http://teamw.in/project/twrp2/158
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One VX"
+codename: totemc2
+downloadfolder: totemc2
+oldurl: http://teamw.in/project/twrp2/158
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconexatt.markdown b/_devices/htconexatt.markdown
index 9611f35..32b86f7 100644
--- a/_devices/htconexatt.markdown
+++ b/_devices/htconexatt.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One X AT&T"
-codename: evita
-downloadfolder: evita
-oldurl: http://teamw.in/project/twrp2/99
-supportstatus: mdmower
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One X AT&T"
+codename: evita
+downloadfolder: evita
+oldurl: http://teamw.in/project/twrp2/99
+supportstatus: mdmower
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconexinternational.markdown b/_devices/htconexinternational.markdown
index 4a768cb..721d363 100644
--- a/_devices/htconexinternational.markdown
+++ b/_devices/htconexinternational.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One X International Tegra"
-codename: endeavoru
-downloadfolder: endeavoru
-oldurl: http://teamw.in/project/twrp2/95
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One X International Tegra"
+codename: endeavoru
+downloadfolder: endeavoru
+oldurl: http://teamw.in/project/twrp2/95
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconexplusatt.markdown b/_devices/htconexplusatt.markdown
index fff922d..464af9d 100644
--- a/_devices/htconexplusatt.markdown
+++ b/_devices/htconexplusatt.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One X+ AT&T"
-codename: evitareul
-downloadfolder: evitareul
-oldurl: http://teamw.in/project/twrp2/131
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One X+ AT&T"
+codename: evitareul
+downloadfolder: evitareul
+oldurl: http://teamw.in/project/twrp2/131
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htconexplusinternational.markdown b/_devices/htconexplusinternational.markdown
index b011dc1..70aaf60 100644
--- a/_devices/htconexplusinternational.markdown
+++ b/_devices/htconexplusinternational.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC One X+ International"
-codename: enrc2b
-downloadfolder: enrc2b
-oldurl: http://teamw.in/project/twrp2/130
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC One X+ International"
+codename: enrc2b
+downloadfolder: enrc2b
+oldurl: http://teamw.in/project/twrp2/130
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcsensation.markdown b/_devices/htcsensation.markdown
index 415d8f6..037d9e0 100644
--- a/_devices/htcsensation.markdown
+++ b/_devices/htcsensation.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Sensation"
-codename: pyramid
-downloadfolder: pyramid
-oldurl: http://teamw.in/project/twrp2/66
-supportstatus: Current
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Sensation"
+codename: pyramid
+downloadfolder: pyramid
+oldurl: http://teamw.in/project/twrp2/66
+supportstatus: Current
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcsensationxl.markdown b/_devices/htcsensationxl.markdown
index eb80ce4..050a29e 100644
--- a/_devices/htcsensationxl.markdown
+++ b/_devices/htcsensationxl.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Sensation XL"
-codename: runnymede
-downloadfolder: runnymede
-oldurl: http://teamw.in/project/twrp2/134
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Sensation XL"
+codename: runnymede
+downloadfolder: runnymede
+oldurl: http://teamw.in/project/twrp2/134
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcthunderbolt.markdown b/_devices/htcthunderbolt.markdown
index dd91950..e6da2ba 100644
--- a/_devices/htcthunderbolt.markdown
+++ b/_devices/htcthunderbolt.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Thunderbolt"
-codename: mecha
-downloadfolder: mecha
-oldurl: http://teamw.in/project/twrp2/10
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Thunderbolt"
+codename: mecha
+downloadfolder: mecha
+oldurl: http://teamw.in/project/twrp2/10
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcvivid.markdown b/_devices/htcvivid.markdown
index 2572c9a..2160364 100644
--- a/_devices/htcvivid.markdown
+++ b/_devices/htcvivid.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Vivid"
-codename: holiday
-downloadfolder: holiday
-oldurl: http://teamw.in/project/twrp2/76
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Vivid"
+codename: holiday
+downloadfolder: holiday
+oldurl: http://teamw.in/project/twrp2/76
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcwildfires.markdown b/_devices/htcwildfires.markdown
index dcfd836..ebd6420 100644
--- a/_devices/htcwildfires.markdown
+++ b/_devices/htcwildfires.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "HTC Wildfire S GSM"
-codename: marvel
-downloadfolder: marvel
-oldurl: http://teamw.in/project/twrp2/111
-supportstatus: No Longer Updated
-maintainer: None
-oem: HTC
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "HTC Wildfire S GSM"
+codename: marvel
+downloadfolder: marvel
+oldurl: http://teamw.in/project/twrp2/111
+supportstatus: No Longer Updated
+maintainer: None
+oem: HTC
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweiascendmate2.markdown b/_devices/huaweiascendmate2.markdown
index d1e0322..f9e671d 100644
--- a/_devices/huaweiascendmate2.markdown
+++ b/_devices/huaweiascendmate2.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Huawei Ascend Mate 2"
-codename: mt2l03
-downloadfolder: mt2l03
-oldurl: http://teamw.in/project/twrp2/265
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_mt2l03
-xdathread: "http://forum.xda-developers.com/ascend-mate2/orig-development/recovery-twrp-2-8-0-0-touch-recovery-t2913270"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei Ascend Mate 2"
+codename: mt2l03
+downloadfolder: mt2l03
+oldurl: http://teamw.in/project/twrp2/265
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_mt2l03
+xdathread: "http://forum.xda-developers.com/ascend-mate2/orig-development/recovery-twrp-2-8-0-0-touch-recovery-t2913270"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweig510.markdown b/_devices/huaweig510.markdown
index a7d33b6..e532920 100644
--- a/_devices/huaweig510.markdown
+++ b/_devices/huaweig510.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Huawei G510"
-codename: u8951
-downloadfolder: u8951
-oldurl: http://teamw.in/project/twrp2/170
-supportstatus: No Longer Updated
-maintainer: None
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_u8951
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei G510"
+codename: u8951
+downloadfolder: u8951
+oldurl: http://teamw.in/project/twrp2/170
+supportstatus: No Longer Updated
+maintainer: None
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_u8951
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweig8.markdown b/_devices/huaweig8.markdown
index 17bad72..c731334 100644
--- a/_devices/huaweig8.markdown
+++ b/_devices/huaweig8.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Huawei G8"
-codename: rio
-downloadfolder: rio
-supportstatus: Current
-maintainer: eloygomez
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_rio
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei G8"
+codename: rio
+downloadfolder: rio
+supportstatus: Current
+maintainer: eloygomez
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_rio
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweihonor5x.markdown b/_devices/huaweihonor5x.markdown
index 4ef6937..609393a 100644
--- a/_devices/huaweihonor5x.markdown
+++ b/_devices/huaweihonor5x.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Huawei Honor 5X"
-codename: kiwi
-downloadfolder: kiwi
-supportstatus: Current
-maintainer: deadman96385
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_kiwi
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei Honor 5X"
+codename: kiwi
+downloadfolder: kiwi
+supportstatus: Current
+maintainer: deadman96385
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_kiwi
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweihonor7.markdown b/_devices/huaweihonor7.markdown
index 92eb43a..5704b3a 100644
--- a/_devices/huaweihonor7.markdown
+++ b/_devices/huaweihonor7.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Huawei Honor 7"
-codename: plank
-downloadfolder: plank
-supportstatus: Current
-maintainer: paulobrien
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_plank
-xdathread: "http://forum.xda-developers.com/honor-7/development/recovery-twrp-recovery-plank-honor-7-t3366622"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei Honor 7"
+codename: plank
+downloadfolder: plank
+supportstatus: Current
+maintainer: paulobrien
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_plank
+xdathread: "http://forum.xda-developers.com/honor-7/development/recovery-twrp-recovery-plank-honor-7-t3366622"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweimates.markdown b/_devices/huaweimates.markdown
index 108ea03..b66ec68 100644
--- a/_devices/huaweimates.markdown
+++ b/_devices/huaweimates.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Huawei Mate S"
-codename: carrera
-downloadfolder: carrera
-supportstatus: Current
-maintainer: eloygomez
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_carrera
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei Mate S"
+codename: carrera
+downloadfolder: carrera
+supportstatus: Current
+maintainer: eloygomez
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_carrera
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweinexus6p.markdown b/_devices/huaweinexus6p.markdown
index f337b40..655b887 100644
--- a/_devices/huaweinexus6p.markdown
+++ b/_devices/huaweinexus6p.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Huawei Nexus 6P"
-codename: angler
-downloadfolder: angler
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_angler
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei Nexus 6P"
+codename: angler
+downloadfolder: angler
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_angler
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweip8.markdown b/_devices/huaweip8.markdown
index 8004b1e..30726cb 100644
--- a/_devices/huaweip8.markdown
+++ b/_devices/huaweip8.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Huawei P8"
-codename: p8
-downloadfolder: p8
-supportstatus: Current
-maintainer: reas0n
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_p8
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei P8"
+codename: p8
+downloadfolder: p8
+supportstatus: Current
+maintainer: reas0n
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_p8
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweiu8815.markdown b/_devices/huaweiu8815.markdown
index 04ba39a..2f67ac4 100644
--- a/_devices/huaweiu8815.markdown
+++ b/_devices/huaweiu8815.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Huawei U8815"
-codename: u8815
-downloadfolder: u8815
-oldurl: http://teamw.in/project/twrp2/136
-supportstatus: No Longer Updated
-maintainer: None
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_u8815
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei U8815"
+codename: u8815
+downloadfolder: u8815
+oldurl: http://teamw.in/project/twrp2/136
+supportstatus: No Longer Updated
+maintainer: None
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_u8815
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/huaweiy300.markdown b/_devices/huaweiy300.markdown
index 8dbfa75..9d92f9a 100644
--- a/_devices/huaweiy300.markdown
+++ b/_devices/huaweiy300.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Huawei Y300"
-codename: u8833
-downloadfolder: u8833
-oldurl: http://teamw.in/project/twrp2/166
-supportstatus: No Longer Updated
-maintainer: None
-oem: Huawei
-devicetree: https://github.com/TeamWin/android_device_huawei_u8833
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Huawei Y300"
+codename: u8833
+downloadfolder: u8833
+oldurl: http://teamw.in/project/twrp2/166
+supportstatus: No Longer Updated
+maintainer: None
+oem: Huawei
+devicetree: https://github.com/TeamWin/android_device_huawei_u8833
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/infinixhot2.markdown b/_devices/infinixhot2.markdown
index 1e2f95e..a2bb05a 100644
--- a/_devices/infinixhot2.markdown
+++ b/_devices/infinixhot2.markdown
@@ -1,30 +1,30 @@
----
-layout: device
-title: "Infinix Hot 2"
-codename: d5110
-downloadfolder: d5110
-supportstatus: Current
-maintainer: HostZero
-oem: Infinix
-ddof: "/dev/block/platform/mtk-msdc.0/by-name/recovery"
-fastbootunlock: true
-mtkchipset: mt6580
-devicetree: "https://github.com/TeamWin/android_device_infinix_d5110"
-xdathread: "http://forum.xda-developers.com/hot-2/orig-development/official-twrp-infinix-hot-2-t3394989"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include mtkinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Infinix Hot 2"
+codename: d5110
+downloadfolder: d5110
+supportstatus: Current
+maintainer: HostZero
+oem: Infinix
+ddof: "/dev/block/platform/mtk-msdc.0/by-name/recovery"
+fastbootunlock: true
+mtkchipset: mt6580
+devicetree: "https://github.com/TeamWin/android_device_infinix_d5110"
+xdathread: "http://forum.xda-developers.com/hot-2/orig-development/official-twrp-infinix-hot-2-t3394989"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include mtkinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/iuniu3.markdown b/_devices/iuniu3.markdown
index 5b61e47..3b0ca33 100644
--- a/_devices/iuniu3.markdown
+++ b/_devices/iuniu3.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "IUNI U3"
-codename: u3
-downloadfolder: u3
-supportstatus: Current
-maintainer: Abdess
-oem: IUNI
-devicetree: https://github.com/TeamWin/android_device_iuni_u3
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "IUNI U3"
+codename: u3
+downloadfolder: u3
+supportstatus: Current
+maintainer: Abdess
+oem: IUNI
+devicetree: https://github.com/TeamWin/android_device_iuni_u3
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/kazamthunderq45.markdown b/_devices/kazamthunderq45.markdown
index a4165f4..5c395ae 100644
--- a/_devices/kazamthunderq45.markdown
+++ b/_devices/kazamthunderq45.markdown
@@ -1,29 +1,29 @@
----
-layout: device
-title:  "Kazam Thunder Q4.5"
-codename: thunder_q45
-downloadfolder: thunder_q45
-oldurl: http://teamw.in/project/twrp2/287
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Kazam
-devicetree: https://github.com/TeamWin/android_device_kazam_thunder_q45
-xdathread: "http://forum.xda-developers.com/thunder-q45/general/recovery-twrp-2-8-5-0-touch-recovery-t3033364"
-ddof: "/dev/recovery"
-mtkchipset: mt6582
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you should be able to root this device using framaroot with the barahir method.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Kazam Thunder Q4.5"
+codename: thunder_q45
+downloadfolder: thunder_q45
+oldurl: http://teamw.in/project/twrp2/287
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Kazam
+devicetree: https://github.com/TeamWin/android_device_kazam_thunder_q45
+xdathread: "http://forum.xda-developers.com/thunder-q45/general/recovery-twrp-2-8-5-0-touch-recovery-t3033364"
+ddof: "/dev/recovery"
+mtkchipset: mt6582
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you should be able to root this device using framaroot with the barahir method.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/kazamtornado348.markdown b/_devices/kazamtornado348.markdown
index 72eec21..97e6b4c 100644
--- a/_devices/kazamtornado348.markdown
+++ b/_devices/kazamtornado348.markdown
@@ -1,29 +1,29 @@
----
-layout: device
-title:  "Kazam Tornado 348"
-codename: tornado_348
-downloadfolder: tornado_348
-oldurl: http://teamw.in/project/twrp2/290
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Kazam
-devicetree: https://github.com/TeamWin/android_device_kazam_tornado_348
-xdathread: "http://forum.xda-developers.com/tornado-348/orig-development/recovery-twrp-2-8-5-0-touch-recovery-t3042096"
-ddof: "/dev/recovery"
-mtkchipset: mt6592
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you should be able to root this device using kingo root app or [this towelroot port](http://forum.xda-developers.com/note-2-verizon/general/root-adb-ghettoroot-v0-1-towelroot-port-t2864125).
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Kazam Tornado 348"
+codename: tornado_348
+downloadfolder: tornado_348
+oldurl: http://teamw.in/project/twrp2/290
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Kazam
+devicetree: https://github.com/TeamWin/android_device_kazam_tornado_348
+xdathread: "http://forum.xda-developers.com/tornado-348/orig-development/recovery-twrp-2-8-5-0-touch-recovery-t3042096"
+ddof: "/dev/recovery"
+mtkchipset: mt6592
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you should be able to root this device using kingo root app or [this towelroot port](http://forum.xda-developers.com/note-2-verizon/general/root-adb-ghettoroot-v0-1-towelroot-port-t2864125).
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/lenovoyogahd10pluswifi.markdown b/_devices/lenovoyogahd10pluswifi.markdown
index dbf396a..179b6ba 100644
--- a/_devices/lenovoyogahd10pluswifi.markdown
+++ b/_devices/lenovoyogahd10pluswifi.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Lenovo Yoga HD 10+ Wi-Fi"
-codename: b8080f
-downloadfolder: b8080f
-supportstatus: Current
-maintainer: KHendrik
-oem: Lenovo
-devicetree: https://github.com/teamwin/android_device_lenovo_b8080f
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Lenovo Yoga HD 10+ Wi-Fi"
+codename: b8080f
+downloadfolder: b8080f
+supportstatus: Current
+maintainer: KHendrik
+oem: Lenovo
+devicetree: https://github.com/teamwin/android_device_lenovo_b8080f
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/letvle1pro.markdown b/_devices/letvle1pro.markdown
index 4ead523..a41f66b 100644
--- a/_devices/letvle1pro.markdown
+++ b/_devices/letvle1pro.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Letv Le 1 Pro"
-codename: x1
-downloadfolder: x1
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Letv
-ddof: "/dev/block/bootdevice/by-name/recovery"
-devicetree: https://github.com/TeamWin/android_device_letv_x1
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Letv Le 1 Pro"
+codename: x1
+downloadfolder: x1
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Letv
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_letv_x1
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg2.markdown b/_devices/lgg2.markdown
index 1d5c8e1..e1d9df0 100644
--- a/_devices/lgg2.markdown
+++ b/_devices/lgg2.markdown
@@ -1,93 +1,93 @@
----
-layout: device
-title:  "LG G2"
-codename: G2
-downloadfolder: G2
-oldurl: http://teamw.in/project/twrp2/197
-supportstatus: No longer updated
-maintainer: None
-oem: LG
-ddof: /dev/block/platform/msm_sdcc.1/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note: You must be rooted and vulnerable to loki to install TWRP on this device.
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">AT&amp;T&nbsp;USA:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2att">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Sprint USA:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2spr">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">T-Mobile USA:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2tmo">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Verizon USA:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2vzw">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea F320K:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2kor">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Bell Canada:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2bell">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Rogers Canada:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}g2rog">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G2"
+codename: G2
+downloadfolder: G2
+oldurl: http://teamw.in/project/twrp2/197
+supportstatus: No longer updated
+maintainer: None
+oem: LG
+ddof: /dev/block/platform/msm_sdcc.1/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note: You must be rooted and vulnerable to loki to install TWRP on this device.
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">AT&amp;T&nbsp;USA:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2att">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Sprint USA:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2spr">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">T-Mobile USA:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2tmo">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Verizon USA:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2vzw">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea F320K:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2kor">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Bell Canada:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2bell">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Rogers Canada:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}g2rog">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3att.markdown b/_devices/lgg3att.markdown
index 27f97b7..cf3707f 100644
--- a/_devices/lgg3att.markdown
+++ b/_devices/lgg3att.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 AT&T"
-codename: d850
-downloadfolder: d850
-oldurl: http://teamw.in/project/twrp2/256
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_d850
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 AT&T"
+codename: d850
+downloadfolder: d850
+oldurl: http://teamw.in/project/twrp2/256
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_d850
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3canadabellrogers.markdown b/_devices/lgg3canadabellrogers.markdown
index 8146278..cc8506d 100644
--- a/_devices/lgg3canadabellrogers.markdown
+++ b/_devices/lgg3canadabellrogers.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 Canada Bell Rogers"
-codename: d852
-downloadfolder: d852
-oldurl: http://teamw.in/project/twrp2/261
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_d852
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 Canada Bell Rogers"
+codename: d852
+downloadfolder: d852
+oldurl: http://teamw.in/project/twrp2/261
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_d852
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3canadawindvideotronsasktel.markdown b/_devices/lgg3canadawindvideotronsasktel.markdown
index 434488d..db952b2 100644
--- a/_devices/lgg3canadawindvideotronsasktel.markdown
+++ b/_devices/lgg3canadawindvideotronsasktel.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 Canada Wind, Videotron, Sasktel"
-codename: d852g
-downloadfolder: d852g
-oldurl: http://teamw.in/project/twrp2/260
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_d852g
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 Canada Wind, Videotron, Sasktel"
+codename: d852g
+downloadfolder: d852g
+oldurl: http://teamw.in/project/twrp2/260
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_d852g
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3europe.markdown b/_devices/lgg3europe.markdown
index 9eda797..816042d 100644
--- a/_devices/lgg3europe.markdown
+++ b/_devices/lgg3europe.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 Europe"
-codename: d855
-downloadfolder: d855
-oldurl: http://teamw.in/project/twrp2/262
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_d855
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 Europe"
+codename: d855
+downloadfolder: d855
+oldurl: http://teamw.in/project/twrp2/262
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_d855
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3korea.markdown b/_devices/lgg3korea.markdown
index 17a0579..458a957 100644
--- a/_devices/lgg3korea.markdown
+++ b/_devices/lgg3korea.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 Korea"
-codename: f400
-downloadfolder: f400
-oldurl: http://teamw.in/project/twrp2/259
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_f400
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 Korea"
+codename: f400
+downloadfolder: f400
+oldurl: http://teamw.in/project/twrp2/259
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_f400
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3sprint.markdown b/_devices/lgg3sprint.markdown
index 1c775ae..6e18fbc 100644
--- a/_devices/lgg3sprint.markdown
+++ b/_devices/lgg3sprint.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 Sprint"
-codename: ls990
-downloadfolder: ls990
-oldurl: http://teamw.in/project/twrp2/258
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_ls990
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 Sprint"
+codename: ls990
+downloadfolder: ls990
+oldurl: http://teamw.in/project/twrp2/258
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_ls990
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3tmo.markdown b/_devices/lgg3tmo.markdown
index 01c7ea6..b57b840 100644
--- a/_devices/lgg3tmo.markdown
+++ b/_devices/lgg3tmo.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 T-Mobile"
-codename: d851
-downloadfolder: d851
-oldurl: http://teamw.in/project/twrp2/249
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_d851
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 T-Mobile"
+codename: d851
+downloadfolder: d851
+oldurl: http://teamw.in/project/twrp2/249
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_d851
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3uscellular.markdown b/_devices/lgg3uscellular.markdown
index 2291b85..14873c7 100644
--- a/_devices/lgg3uscellular.markdown
+++ b/_devices/lgg3uscellular.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 US Cellular"
-codename: us990
-downloadfolder: us990
-oldurl: http://teamw.in/project/twrp2/276
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_us990
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 US Cellular"
+codename: us990
+downloadfolder: us990
+oldurl: http://teamw.in/project/twrp2/276
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_us990
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg3verizon.markdown b/_devices/lgg3verizon.markdown
index 4a6819b..75efce9 100644
--- a/_devices/lgg3verizon.markdown
+++ b/_devices/lgg3verizon.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G3 Verizon"
-codename: vs985
-downloadfolder: vs985
-oldurl: http://teamw.in/project/twrp2/257
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_vs985
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G3 Verizon"
+codename: vs985
+downloadfolder: vs985
+oldurl: http://teamw.in/project/twrp2/257
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_vs985
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg4h811.markdown b/_devices/lgg4h811.markdown
index 39f99fd..c75e695 100644
--- a/_devices/lgg4h811.markdown
+++ b/_devices/lgg4h811.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "LG G4 T-Mobile USA"
-codename: H811
-downloadfolder: h811
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_h811
-ddof: "/dev/block/bootdevice/by-name/recovery"
-xdathread: "http://forum.xda-developers.com/g4/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3125859"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G4 T-Mobile USA"
+codename: H811
+downloadfolder: h811
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_h811
+ddof: "/dev/block/bootdevice/by-name/recovery"
+xdathread: "http://forum.xda-developers.com/g4/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3125859"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg4h815.markdown b/_devices/lgg4h815.markdown
index 1a2265e..579758a 100644
--- a/_devices/lgg4h815.markdown
+++ b/_devices/lgg4h815.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G4 International"
-codename: H815
-downloadfolder: h815
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_h815
-ddof: "/dev/block/bootdevice/by-name/recovery"
-xdathread: "http://forum.xda-developers.com/g4/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3125859"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-NOTE: You must unlock the bootloader first before installing TWRP!
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G4 International"
+codename: H815
+downloadfolder: h815
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_h815
+ddof: "/dev/block/bootdevice/by-name/recovery"
+xdathread: "http://forum.xda-developers.com/g4/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3125859"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+NOTE: You must unlock the bootloader first before installing TWRP!
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg5h830.markdown b/_devices/lgg5h830.markdown
index dbb812a..960f1a0 100644
--- a/_devices/lgg5h830.markdown
+++ b/_devices/lgg5h830.markdown
@@ -1,28 +1,28 @@
----
-layout: device
-title: "LG G5 T-Mobile"
-codename: h830
-downloadfolder: h830
-supportstatus: Current
-maintainer: jcadduono
-oem: LG
-ddof: "/dev/block/platform/soc/624000.ufshc/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_lge_h830"
-xdathread: "http://forum.xda-developers.com/tmobile-lg-g5/development/recovery-team-win-recovery-project-lg-g5-t3349499"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-<p class="text">Note: h830 requires a 3rd party unlock tool to flash.</p>
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "LG G5 T-Mobile"
+codename: h830
+downloadfolder: h830
+supportstatus: Current
+maintainer: jcadduono
+oem: LG
+ddof: "/dev/block/platform/soc/624000.ufshc/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_lge_h830"
+xdathread: "http://forum.xda-developers.com/tmobile-lg-g5/development/recovery-team-win-recovery-project-lg-g5-t3349499"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+<p class="text">Note: h830 requires a 3rd party unlock tool to flash.</p>
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgg5h850.markdown b/_devices/lgg5h850.markdown
index ab8e6df..b296d28 100644
--- a/_devices/lgg5h850.markdown
+++ b/_devices/lgg5h850.markdown
@@ -1,28 +1,28 @@
----
-layout: device
-title: "LG G5 International"
-codename: h850
-downloadfolder: h850
-supportstatus: Current
-maintainer: jcadduono
-oem: LG
-ddof: "/dev/block/platform/soc/624000.ufshc/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_lge_h850"
-xdathread: "http://forum.xda-developers.com/lg-g5/development/recovery-team-win-recovery-project-lg-g5-t3363047"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include lgunlock.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "LG G5 International"
+codename: h850
+downloadfolder: h850
+supportstatus: Current
+maintainer: jcadduono
+oem: LG
+ddof: "/dev/block/platform/soc/624000.ufshc/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_lge_h850"
+xdathread: "http://forum.xda-developers.com/lg-g5/development/recovery-team-win-recovery-project-lg-g5-t3363047"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include lgunlock.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lggflexkorean.markdown b/_devices/lggflexkorean.markdown
index 710255b..0c25043 100644
--- a/_devices/lggflexkorean.markdown
+++ b/_devices/lggflexkorean.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "LG G Flex Korean"
-codename: f340k
-downloadfolder: f340k
-oldurl: http://teamw.in/project/twrp2/212
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_f340k
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to loki to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G Flex Korean"
+codename: f340k
+downloadfolder: f340k
+oldurl: http://teamw.in/project/twrp2/212
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_f340k
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to loki to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lggpad101.markdown b/_devices/lggpad101.markdown
index 2497939..1de6646 100644
--- a/_devices/lggpad101.markdown
+++ b/_devices/lggpad101.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "LG G Pad 10.1"
-codename: e9wifi
-downloadfolder: e9wifi
-supportstatus: Current
-maintainer: Dark_Nightmare
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_e9wifi
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG G Pad 10.1"
+codename: e9wifi
+downloadfolder: e9wifi
+supportstatus: Current
+maintainer: Dark_Nightmare
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_e9wifi
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note, you must be rooted and vulnerable to BUMP to use TWRP on this device.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lggpad83.markdown b/_devices/lggpad83.markdown
index eb6b31a..5062b68 100644
--- a/_devices/lggpad83.markdown
+++ b/_devices/lggpad83.markdown
@@ -1,47 +1,47 @@
----
-layout: device
-title:  "LG G Pad 8.3 (v500, v510, awifi, palman)"
-codename: v500
-downloadfolder: v500
-oldurl: http://teamw.in/project/twrp2/213
-supportstatus: Current
-maintainer: fefifofum
-oem: LG
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">Regular v500 / awifi:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}v500">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Google Edition v510 / palman:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}palman">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include appinstall.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include fastbootinstall.html %}
-Note: Fastboot install is for Google Edition only.
+---
+layout: device
+title:  "LG G Pad 8.3 (v500, v510, awifi, palman)"
+codename: v500
+downloadfolder: v500
+oldurl: http://teamw.in/project/twrp2/213
+supportstatus: Current
+maintainer: fefifofum
+oem: LG
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">Regular v500 / awifi:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}v500">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Google Edition v510 / palman:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}palman">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include appinstall.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include fastbootinstall.html %}
+Note: Fastboot install is for Google Edition only.
diff --git a/_devices/lggwatch.markdown b/_devices/lggwatch.markdown
index 774d281..793513d 100644
--- a/_devices/lggwatch.markdown
+++ b/_devices/lggwatch.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG G Watch"
-codename: dory
-downloadfolder: dory
-oldurl: http://teamw.in/project/twrp2/242
-supportstatus: Current
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG G Watch"
+codename: dory
+downloadfolder: dory
+oldurl: http://teamw.in/project/twrp2/242
+supportstatus: Current
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lggwatchr.markdown b/_devices/lggwatchr.markdown
index 12aca7d..6c274d2 100644
--- a/_devices/lggwatchr.markdown
+++ b/_devices/lggwatchr.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG G Watch"
-codename: lenok
-downloadfolder: lenok
-oldurl: http://teamw.in/project/twrp2/281
-supportstatus: Current
-maintainer: Tassadar
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG G Watch"
+codename: lenok
+downloadfolder: lenok
+oldurl: http://teamw.in/project/twrp2/281
+supportstatus: Current
+maintainer: Tassadar
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgl90.markdown b/_devices/lgl90.markdown
index 973ba61..06d4893 100644
--- a/_devices/lgl90.markdown
+++ b/_devices/lgl90.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "LG L90"
-codename: w7,w7ds,w7n
-downloadfolder: w7
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_w7
-ddof: "dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG L90"
+codename: w7,w7ds,w7n
+downloadfolder: w7
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_w7
+ddof: "dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgleonlte.markdown b/_devices/lgleonlte.markdown
index 95fc0ea..149399b 100644
--- a/_devices/lgleonlte.markdown
+++ b/_devices/lgleonlte.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "LG Leon LTE"
-codename: c50
-downloadfolder: c50
-supportstatus: Current
-maintainer: None
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_c50
-ddof: "/dev/block/bootdevice/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG Leon LTE"
+codename: c50
+downloadfolder: c50
+supportstatus: Current
+maintainer: None
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_c50
+ddof: "/dev/block/bootdevice/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgnexus4.markdown b/_devices/lgnexus4.markdown
index b290acc..cea1d4d 100644
--- a/_devices/lgnexus4.markdown
+++ b/_devices/lgnexus4.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "LG Nexus 4"
-codename: mako
-downloadfolder: mako
-oldurl: http://teamw.in/project/twrp2/129
-supportstatus: Current
-maintainer: Dees_Troy
-oem: LG
-devicetree: https://github.com/omnirom/android_device_lge_mako
-xdathread: "http://forum.xda-developers.com/nexus-4/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2002326"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Nexus 4"
+codename: mako
+downloadfolder: mako
+oldurl: http://teamw.in/project/twrp2/129
+supportstatus: Current
+maintainer: Dees_Troy
+oem: LG
+devicetree: https://github.com/omnirom/android_device_lge_mako
+xdathread: "http://forum.xda-developers.com/nexus-4/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2002326"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgnexus5.markdown b/_devices/lgnexus5.markdown
index 904fd50..4b870ca 100644
--- a/_devices/lgnexus5.markdown
+++ b/_devices/lgnexus5.markdown
@@ -1,45 +1,45 @@
----
-layout: device
-title:  "LG Nexus 5"
-codename: hammerhead
-downloadfolder: hammerhead
-oldurl: http://teamw.in/project/twrp2/205
-supportstatus: Current
-maintainer: Dees_Troy
-oem: LG
-devicetree: https://github.com/omnirom/android_device_lge_hammerhead
-xdathread: "http://forum.xda-developers.com/google-nexus-5/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2511507"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">Normal (recommended):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hammerhead">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">hammerheadcaf (use only if you know this is what you need):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hammerheadcaf">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Nexus 5"
+codename: hammerhead
+downloadfolder: hammerhead
+oldurl: http://teamw.in/project/twrp2/205
+supportstatus: Current
+maintainer: Dees_Troy
+oem: LG
+devicetree: https://github.com/omnirom/android_device_lge_hammerhead
+xdathread: "http://forum.xda-developers.com/google-nexus-5/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2511507"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">Normal (recommended):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hammerhead">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">hammerheadcaf (use only if you know this is what you need):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hammerheadcaf">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgnexus5x.markdown b/_devices/lgnexus5x.markdown
index 6f4b383..cfa5dc9 100644
--- a/_devices/lgnexus5x.markdown
+++ b/_devices/lgnexus5x.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "LG Nexus 5X"
-codename: bullhead
-downloadfolder: bullhead
-supportstatus: Current
-maintainer: Dees_Troy
-oem: LG
-devicetree: https://github.com/TeamWin/android_device_lge_bullhead
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-NOTE: Decrypting data does not work if you fastboot boot the recovery image. Decrypt works if you flash the recovery and boot it like normal. If you do not know what this means, you can ignore this note.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Nexus 5X"
+codename: bullhead
+downloadfolder: bullhead
+supportstatus: Current
+maintainer: Dees_Troy
+oem: LG
+devicetree: https://github.com/TeamWin/android_device_lge_bullhead
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+NOTE: Decrypting data does not work if you fastboot boot the recovery image. Decrypt works if you flash the recovery and boot it like normal. If you do not know what this means, you can ignore this note.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgnitrohd.markdown b/_devices/lgnitrohd.markdown
index 4eceabf..9517a85 100644
--- a/_devices/lgnitrohd.markdown
+++ b/_devices/lgnitrohd.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "LG Nitro HD"
-codename: p930
-downloadfolder: p930
-oldurl: http://teamw.in/project/twrp2/162
-supportstatus: Current
-maintainer: None
-oem: LG
-ddof: "/dev/block/mmcblk0p13"
-devicetree: "https://github.com/TeamWin/android_device_lge_p930"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG Nitro HD"
+codename: p930
+downloadfolder: p930
+oldurl: http://teamw.in/project/twrp2/162
+supportstatus: Current
+maintainer: None
+oem: LG
+ddof: "/dev/block/mmcblk0p13"
+devicetree: "https://github.com/TeamWin/android_device_lge_p930"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgoptimus2x.markdown b/_devices/lgoptimus2x.markdown
index 8fa8660..56e14ff 100644
--- a/_devices/lgoptimus2x.markdown
+++ b/_devices/lgoptimus2x.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "LG Optimus 2x"
-codename: p990
-downloadfolder: p990
-oldurl: http://teamw.in/project/twrp2/65
-supportstatus: Current
-maintainer: None
-oem: LG
-ddof: "/dev/block/mmcblk0p7"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG Optimus 2x"
+codename: p990
+downloadfolder: p990
+oldurl: http://teamw.in/project/twrp2/65
+supportstatus: Current
+maintainer: None
+oem: LG
+ddof: "/dev/block/mmcblk0p7"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgoptimus4xhd.markdown b/_devices/lgoptimus4xhd.markdown
index 06e0c53..0c25d16 100644
--- a/_devices/lgoptimus4xhd.markdown
+++ b/_devices/lgoptimus4xhd.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG Optimus 4x HD"
-codename: p880
-downloadfolder: p880
-oldurl: http://teamw.in/project/twrp2/240
-supportstatus: Current
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Optimus 4x HD"
+codename: p880
+downloadfolder: p880
+oldurl: http://teamw.in/project/twrp2/240
+supportstatus: Current
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgoptimusblack.markdown b/_devices/lgoptimusblack.markdown
index 646e7fa..dabc4a6 100644
--- a/_devices/lgoptimusblack.markdown
+++ b/_devices/lgoptimusblack.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "LG Optimus Black"
-codename: p970
-downloadfolder: p970
-oldurl: http://teamw.in/project/twrp2/116
-supportstatus: Current
-maintainer: None
-oem: LG
-ddof: /dev/block/mmcblk0p4
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG Optimus Black"
+codename: p970
+downloadfolder: p970
+oldurl: http://teamw.in/project/twrp2/116
+supportstatus: Current
+maintainer: None
+oem: LG
+ddof: /dev/block/mmcblk0p4
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgoptimusfuel.markdown b/_devices/lgoptimusfuel.markdown
index 9f8e986..5d04bdf 100644
--- a/_devices/lgoptimusfuel.markdown
+++ b/_devices/lgoptimusfuel.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "LG Optimus Fuel"
-codename: l34c
-downloadfolder: l34c
-oldurl: http://teamw.in/project/twrp2/277
-supportstatus: Current
-maintainer: Dees_Troy
-oem: LG
-ddof: /dev/block/platform/msm_sdcc.1/by-name/recovery
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note: You must be rooted and vulnerable to BUMP to install TWRP on this device.
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG Optimus Fuel"
+codename: l34c
+downloadfolder: l34c
+oldurl: http://teamw.in/project/twrp2/277
+supportstatus: Current
+maintainer: Dees_Troy
+oem: LG
+ddof: /dev/block/platform/msm_sdcc.1/by-name/recovery
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note: You must be rooted and vulnerable to BUMP to install TWRP on this device.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgoptimusgatt.markdown b/_devices/lgoptimusgatt.markdown
index 9345c4a..15f8a9e 100644
--- a/_devices/lgoptimusgatt.markdown
+++ b/_devices/lgoptimusgatt.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG Optimus G AT&T"
-codename: geeb
-downloadfolder: geeb
-oldurl: http://teamw.in/project/twrp2/154
-supportstatus: No Longer Updated
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Optimus G AT&T"
+codename: geeb
+downloadfolder: geeb
+oldurl: http://teamw.in/project/twrp2/154
+supportstatus: No Longer Updated
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgoptimusgpro.markdown b/_devices/lgoptimusgpro.markdown
index c26bf88..7935309 100644
--- a/_devices/lgoptimusgpro.markdown
+++ b/_devices/lgoptimusgpro.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "LG Optimus G Pro GSM"
-codename: e980
-downloadfolder: e980
-supportstatus: Current
-maintainer: nerdyblonde
-oem: LG
-ddof: /dev/block/platform/msm_sdcc.1/by-name/recovery
-devicetree: https://github.com/CyanogenMod/android_device_lge_e980
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "LG Optimus G Pro GSM"
+codename: e980
+downloadfolder: e980
+supportstatus: Current
+maintainer: nerdyblonde
+oem: LG
+ddof: /dev/block/platform/msm_sdcc.1/by-name/recovery
+devicetree: https://github.com/CyanogenMod/android_device_lge_e980
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/lgoptimusgsprint.markdown b/_devices/lgoptimusgsprint.markdown
index 113e4d2..e326086 100644
--- a/_devices/lgoptimusgsprint.markdown
+++ b/_devices/lgoptimusgsprint.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG Optimus G Sprint"
-codename: geehrc4g
-downloadfolder: geehrc4g
-oldurl: http://teamw.in/project/twrp2/155
-supportstatus: No Longer Updated
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Optimus G Sprint"
+codename: geehrc4g
+downloadfolder: geehrc4g
+oldurl: http://teamw.in/project/twrp2/155
+supportstatus: No Longer Updated
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgoptimuslte.markdown b/_devices/lgoptimuslte.markdown
index 65515b8..406d3d6 100644
--- a/_devices/lgoptimuslte.markdown
+++ b/_devices/lgoptimuslte.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG Optimus LTE"
-codename: su640
-downloadfolder: su640
-oldurl: http://teamw.in/project/twrp2/167
-supportstatus: Current
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Optimus LTE"
+codename: su640
+downloadfolder: su640
+oldurl: http://teamw.in/project/twrp2/167
+supportstatus: Current
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgoptimusone.markdown b/_devices/lgoptimusone.markdown
index 3d80a23..cbbcdce 100644
--- a/_devices/lgoptimusone.markdown
+++ b/_devices/lgoptimusone.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "LG Optimus One"
-codename: p500
-downloadfolder: p500
-oldurl: http://teamw.in/project/twrp2/73
-supportstatus: Current
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Optimus One"
+codename: p500
+downloadfolder: p500
+oldurl: http://teamw.in/project/twrp2/73
+supportstatus: Current
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgoptimusslider.markdown b/_devices/lgoptimusslider.markdown
index 0713e91..51f353e 100644
--- a/_devices/lgoptimusslider.markdown
+++ b/_devices/lgoptimusslider.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "LG Optimus Slider"
-codename: gelato
-downloadfolder: gelato
-oldurl: http://teamw.in/project/twrp2/168
-supportstatus: Current
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include flashimageinstall.html %}
+---
+layout: device
+title:  "LG Optimus Slider"
+codename: gelato
+downloadfolder: gelato
+oldurl: http://teamw.in/project/twrp2/168
+supportstatus: Current
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include flashimageinstall.html %}
diff --git a/_devices/lgtmobileg2x.markdown b/_devices/lgtmobileg2x.markdown
index ec7d7f9..bcac49d 100644
--- a/_devices/lgtmobileg2x.markdown
+++ b/_devices/lgtmobileg2x.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "LG T-Mobile G2x"
-codename: p999
-downloadfolder: p999
-oldurl: http://teamw.in/project/twrp2/63
-supportstatus: No Longer Updated
-maintainer: None
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-<p class="text">Download the above file and rename it to recovery.img. &nbsp;Make sure that you have the APX drivers installed (Windows). &nbsp;You can find some here:</p>
-<p class="text"><a href="http://forum.xda-developers.com/showthread.php?t=1514942">http://forum.xda-developers.com/showthread.php?t=1514942</a></p>
-<p class="text">You'll also need nvflash:</p>
-<p class="text"><a href="http://www.mediafire.com/?6tj0jttn68vtbtc">http://www.mediafire.com/?6tj0jttn68vtbtc</a></p>
-<p class="text">Once you have the required files, run this command on your computer:</p>
-<p class="text">nvflash.exe --bct E1108_Hynix_512MB_H8TBR00U0MLR-0DM_300MHz_final_emmc_x8.bct --bl fastboot.bin --download 5 recovery.img</p>
+---
+layout: device
+title:  "LG T-Mobile G2x"
+codename: p999
+downloadfolder: p999
+oldurl: http://teamw.in/project/twrp2/63
+supportstatus: No Longer Updated
+maintainer: None
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+<p class="text">Download the above file and rename it to recovery.img. &nbsp;Make sure that you have the APX drivers installed (Windows). &nbsp;You can find some here:</p>
+<p class="text"><a href="http://forum.xda-developers.com/showthread.php?t=1514942">http://forum.xda-developers.com/showthread.php?t=1514942</a></p>
+<p class="text">You'll also need nvflash:</p>
+<p class="text"><a href="http://www.mediafire.com/?6tj0jttn68vtbtc">http://www.mediafire.com/?6tj0jttn68vtbtc</a></p>
+<p class="text">Once you have the required files, run this command on your computer:</p>
+<p class="text">nvflash.exe --bct E1108_Hynix_512MB_H8TBR00U0MLR-0DM_300MHz_final_emmc_x8.bct --bl fastboot.bin --download 5 recovery.img</p>
diff --git a/_devices/lgwatchurbane.markdown b/_devices/lgwatchurbane.markdown
index d96fba8..ca72faa 100644
--- a/_devices/lgwatchurbane.markdown
+++ b/_devices/lgwatchurbane.markdown
@@ -1,19 +1,19 @@
----
-layout: device
-title:  "LG Watch Urbane"
-codename: bass
-downloadfolder: bass
-supportstatus: Current
-maintainer: Dees_Troy
-oem: LG
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "LG Watch Urbane"
+codename: bass
+downloadfolder: bass
+supportstatus: Current
+maintainer: Dees_Troy
+oem: LG
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/micromaxcanvasmagnus.markdown b/_devices/micromaxcanvasmagnus.markdown
index 9e6ce83..d2aeed2 100644
--- a/_devices/micromaxcanvasmagnus.markdown
+++ b/_devices/micromaxcanvasmagnus.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Micromax Canvas Magnus"
-codename: a117
-downloadfolder: a117
-oldurl: http://teamw.in/project/twrp2/271
-supportstatus: Current
-maintainer: None
-oem: Micromax
-ddof: "/dev/recovery"
-mtkchipset: mt6589
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Micromax Canvas Magnus"
+codename: a117
+downloadfolder: a117
+oldurl: http://teamw.in/project/twrp2/271
+supportstatus: Current
+maintainer: None
+oem: Micromax
+ddof: "/dev/recovery"
+mtkchipset: mt6589
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/micromaxpace.markdown b/_devices/micromaxpace.markdown
index 45a4c8c..5f2d245 100644
--- a/_devices/micromaxpace.markdown
+++ b/_devices/micromaxpace.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Micromax Canvas Pace 4G"
-codename: pace
-downloadfolder: pace
-supportstatus: Current
-maintainer: Vibhor Chaudhary (vibhu0009)
-oem: Micromax
-ddof: "/dev/block/bootdevice/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Micromax Canvas Pace 4G"
+codename: pace
+downloadfolder: pace
+supportstatus: Current
+maintainer: Vibhor Chaudhary (vibhu0009)
+oem: Micromax
+ddof: "/dev/block/bootdevice/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/minixneou1.markdown b/_devices/minixneou1.markdown
index dbbe308..c804ea0 100644
--- a/_devices/minixneou1.markdown
+++ b/_devices/minixneou1.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Minix NEO U1"
-codename: p200_2G
-downloadfolder: p200_2G
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Minix
-ddof: "/dev/block/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Minix NEO U1"
+codename: p200_2G
+downloadfolder: p200_2G
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Minix
+ddof: "/dev/block/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/minixz64a.markdown b/_devices/minixz64a.markdown
index a157cb8..5f06860 100644
--- a/_devices/minixz64a.markdown
+++ b/_devices/minixz64a.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Minix Z64 Android"
-codename: byt_t_crv2
-downloadfolder: byt_t_crv2
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Minix
-ddof: "/dev/block/platform/intel/by-label/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note: Graphics rendering on Intel-based devices is very slow. The framerate will be low, but TWRP should be usable. It is not recommended to use a custom theme on this device as a custom theme may perform worse.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Minix Z64 Android"
+codename: byt_t_crv2
+downloadfolder: byt_t_crv2
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Minix
+ddof: "/dev/block/platform/intel/by-label/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note: Graphics rendering on Intel-based devices is very slow. The framerate will be low, but TWRP should be usable. It is not recommended to use a custom theme on this device as a custom theme may perform worse.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/motorolaatrix4g.markdown b/_devices/motorolaatrix4g.markdown
index 9c76cdb..94488ac 100644
--- a/_devices/motorolaatrix4g.markdown
+++ b/_devices/motorolaatrix4g.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Motorola Atrix 4G"
-codename: olympus
-downloadfolder: olympus
-oldurl: http://teamw.in/project/twrp2/72
-supportstatus: No Longer Updated
-maintainer: None
-oem: Motorola
-devicetree: https://github.com/TeamWin/device_motorola_olympus
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Atrix 4G"
+codename: olympus
+downloadfolder: olympus
+oldurl: http://teamw.in/project/twrp2/72
+supportstatus: No Longer Updated
+maintainer: None
+oem: Motorola
+devicetree: https://github.com/TeamWin/device_motorola_olympus
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motoroladefy.markdown b/_devices/motoroladefy.markdown
index 473c3a1..af62328 100644
--- a/_devices/motoroladefy.markdown
+++ b/_devices/motoroladefy.markdown
@@ -1,20 +1,20 @@
----
-layout: device
-title:  "Motorola Defy"
-codename: jordan
-downloadfolder: jordan
-oldurl: http://teamw.in/project/twrp2/91
-supportstatus: No Longer Updated
-maintainer: None
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-<div class='page-heading'>Notes:</div>
-<hr />
-<p class="text">Download the zip and flash in recovery just like you would flash a ROM.</p>
+---
+layout: device
+title:  "Motorola Defy"
+codename: jordan
+downloadfolder: jordan
+oldurl: http://teamw.in/project/twrp2/91
+supportstatus: No Longer Updated
+maintainer: None
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+<div class='page-heading'>Notes:</div>
+<hr />
+<p class="text">Download the zip and flash in recovery just like you would flash a ROM.</p>
diff --git a/_devices/motorolamoto360.markdown b/_devices/motorolamoto360.markdown
index 3968020..80306b9 100644
--- a/_devices/motorolamoto360.markdown
+++ b/_devices/motorolamoto360.markdown
@@ -1,18 +1,18 @@
----
-layout: device
-title:  "Motorola Moto 360"
-codename: minnow
-downloadfolder: minnow
-oldurl: http://teamw.in/project/twrp2/280
-supportstatus: Current
-maintainer: None
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto 360"
+codename: minnow
+downloadfolder: minnow
+oldurl: http://teamw.in/project/twrp2/280
+supportstatus: Current
+maintainer: None
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotoe.markdown b/_devices/motorolamotoe.markdown
index 24fa1b0..5a26fc9 100644
--- a/_devices/motorolamotoe.markdown
+++ b/_devices/motorolamotoe.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Moto E"
-codename: condor
-downloadfolder: condor
-oldurl: http://teamw.in/project/twrp2/235
-supportstatus: Current
-maintainer: magdeoz
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto E"
+codename: condor
+downloadfolder: condor
+oldurl: http://teamw.in/project/twrp2/235
+supportstatus: Current
+maintainer: magdeoz
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotoelte.markdown b/_devices/motorolamotoelte.markdown
index 00fbdfc..e86b261 100644
--- a/_devices/motorolamotoelte.markdown
+++ b/_devices/motorolamotoelte.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Moto E LTE"
-codename: surnia
-downloadfolder: surnia
-supportstatus: Current
-maintainer: None
-oem: Motorola
-devicetree: https://github.com/TeamWin/android_device_motorola_surnia
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto E LTE"
+codename: surnia
+downloadfolder: surnia
+supportstatus: Current
+maintainer: None
+oem: Motorola
+devicetree: https://github.com/TeamWin/android_device_motorola_surnia
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotog2014.markdown b/_devices/motorolamotog2014.markdown
index ef04624..5b56a56 100644
--- a/_devices/motorolamotog2014.markdown
+++ b/_devices/motorolamotog2014.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Moto G 2014"
-codename: titan
-downloadfolder: titan
-oldurl: http://teamw.in/project/twrp2/275
-supportstatus: Current
-maintainer: luca020400
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto G 2014"
+codename: titan
+downloadfolder: titan
+oldurl: http://teamw.in/project/twrp2/275
+supportstatus: Current
+maintainer: luca020400
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotog2014lte.markdown b/_devices/motorolamotog2014lte.markdown
index f98609b..d93281c 100644
--- a/_devices/motorolamotog2014lte.markdown
+++ b/_devices/motorolamotog2014lte.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "Motorola Moto G 2014 LTE"
-codename: thea
-downloadfolder: thea
-supportstatus: Current
-maintainer: luca020400
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto G 2014 LTE"
+codename: thea
+downloadfolder: thea
+supportstatus: Current
+maintainer: luca020400
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotomaxx.markdown b/_devices/motorolamotomaxx.markdown
index 2354a3b..7edd6df 100644
--- a/_devices/motorolamotomaxx.markdown
+++ b/_devices/motorolamotomaxx.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "Motorola Moto MAXX"
-codename: quark
-downloadfolder: quark
-supportstatus: Current
-maintainer: BHB27
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto MAXX"
+codename: quark
+downloadfolder: quark
+supportstatus: Current
+maintainer: BHB27
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotox2013.markdown b/_devices/motorolamotox2013.markdown
index 00a991d..bdddd74 100644
--- a/_devices/motorolamotox2013.markdown
+++ b/_devices/motorolamotox2013.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Moto X 2013"
-codename: ghost
-downloadfolder: ghost
-oldurl: http://teamw.in/project/twrp2/234
-supportstatus: Current
-maintainer: None
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto X 2013"
+codename: ghost
+downloadfolder: ghost
+oldurl: http://teamw.in/project/twrp2/234
+supportstatus: Current
+maintainer: None
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotox2014.markdown b/_devices/motorolamotox2014.markdown
index 32284e2..7151b28 100644
--- a/_devices/motorolamotox2014.markdown
+++ b/_devices/motorolamotox2014.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Moto X 2014"
-codename: victara
-downloadfolder: victara
-oldurl: http://teamw.in/project/twrp2/264
-supportstatus: Current
-maintainer: None
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto X 2014"
+codename: victara
+downloadfolder: victara
+oldurl: http://teamw.in/project/twrp2/264
+supportstatus: Current
+maintainer: None
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolamotox2015pure.markdown b/_devices/motorolamotox2015pure.markdown
index 2402c91..26ca9fa 100644
--- a/_devices/motorolamotox2015pure.markdown
+++ b/_devices/motorolamotox2015pure.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "Motorola Moto X 2015 Pure"
-codename: clark
-downloadfolder: clark
-supportstatus: Current
-maintainer: Hashbang173
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Moto X 2015 Pure"
+codename: clark
+downloadfolder: clark
+supportstatus: Current
+maintainer: Hashbang173
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolanexus6.markdown b/_devices/motorolanexus6.markdown
index 53e52a0..bc86791 100644
--- a/_devices/motorolanexus6.markdown
+++ b/_devices/motorolanexus6.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Motorola Nexus 6"
-codename: shamu
-downloadfolder: shamu
-oldurl: http://teamw.in/project/twrp2/270
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Motorola
-devicetree: https://github.com/omnirom/android_device_moto_shamu
-xdathread: "http://forum.xda-developers.com/nexus-6/orig-development/recovery-twrp-2-8-2-0-touch-recovery-t2946534"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Nexus 6"
+codename: shamu
+downloadfolder: shamu
+oldurl: http://teamw.in/project/twrp2/270
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Motorola
+devicetree: https://github.com/omnirom/android_device_moto_shamu
+xdathread: "http://forum.xda-developers.com/nexus-6/orig-development/recovery-twrp-2-8-2-0-touch-recovery-t2946534"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolaphoton4g.markdown b/_devices/motorolaphoton4g.markdown
index dc7b42e..8ff64f7 100644
--- a/_devices/motorolaphoton4g.markdown
+++ b/_devices/motorolaphoton4g.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Motorola Photon 4G"
-codename: sunfire
-downloadfolder: sunfire
-oldurl: http://teamw.in/project/twrp2/82
-supportstatus: No Longer Updated
-maintainer: None
-oem: Motorola
-devicetree: https://github.com/TeamWin/device_motorola_sunfire
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Photon 4G"
+codename: sunfire
+downloadfolder: sunfire
+oldurl: http://teamw.in/project/twrp2/82
+supportstatus: No Longer Updated
+maintainer: None
+oem: Motorola
+devicetree: https://github.com/TeamWin/device_motorola_sunfire
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolaphotonq.markdown b/_devices/motorolaphotonq.markdown
index cf05534..fb22eda 100644
--- a/_devices/motorolaphotonq.markdown
+++ b/_devices/motorolaphotonq.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Photon Q"
-codename: asanti_c
-downloadfolder: asanti
-oldurl: http://teamw.in/project/twrp2/137
-supportstatus: Current
-maintainer: arrrghhh
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Photon Q"
+codename: asanti_c
+downloadfolder: asanti
+oldurl: http://teamw.in/project/twrp2/137
+supportstatus: Current
+maintainer: arrrghhh
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/motorolaxoom.markdown b/_devices/motorolaxoom.markdown
index 7bc5db4..7af2b38 100644
--- a/_devices/motorolaxoom.markdown
+++ b/_devices/motorolaxoom.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Motorola Xoom"
-codename: wingray
-downloadfolder: wingray
-oldurl: http://teamw.in/project/twrp2/61
-supportstatus: No Longer Updated
-maintainer: None
-oem: Motorola
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Motorola Xoom"
+codename: wingray
+downloadfolder: wingray
+oldurl: http://teamw.in/project/twrp2/61
+supportstatus: No Longer Updated
+maintainer: None
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/nextbitrobin.markdown b/_devices/nextbitrobin.markdown
index 06231f4..8457b66 100644
--- a/_devices/nextbitrobin.markdown
+++ b/_devices/nextbitrobin.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Nextbit Robin"
-codename: ether
-downloadfolder: ether
-supportstatus: Current
-maintainer: deadman96385, Dees_Troy
-oem: Nextbit
-devicetree: https://github.com/TeamWin/android_device_nextbit_ether
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-Note: Some fastboot binaries may not recognize the Nextbit's vendor ID. You may use fastboot -i 0x2c3f flash recovery twrp-3.0.0-0-ether.img or similar to make fastboot recognize the device.
+---
+layout: device
+title:  "Nextbit Robin"
+codename: ether
+downloadfolder: ether
+supportstatus: Current
+maintainer: deadman96385, Dees_Troy
+oem: Nextbit
+devicetree: https://github.com/TeamWin/android_device_nextbit_ether
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+Note: Some fastboot binaries may not recognize the Nextbit's vendor ID. You may use fastboot -i 0x2c3f flash recovery twrp-3.0.0-0-ether.img or similar to make fastboot recognize the device.
diff --git a/_devices/nvidiahshieldportable.markdown b/_devices/nvidiahshieldportable.markdown
index 68cd25d..2d80e38 100644
--- a/_devices/nvidiahshieldportable.markdown
+++ b/_devices/nvidiahshieldportable.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "NVidia Shield Portable"
-codename: roth
-downloadfolder: roth
-supportstatus: Current
-maintainer: webgeek1234
-oem: NVidia
-devicetree: https://github.com/TeamWin/android_device_nvidia_roth
-ddof: "/dev/block/platform/sdhci-tegra.3/by-name/SOS"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "NVidia Shield Portable"
+codename: roth
+downloadfolder: roth
+supportstatus: Current
+maintainer: webgeek1234
+oem: NVidia
+devicetree: https://github.com/TeamWin/android_device_nvidia_roth
+ddof: "/dev/block/platform/sdhci-tegra.3/by-name/SOS"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/nvidiahshieldtablet.markdown b/_devices/nvidiahshieldtablet.markdown
index e12b3cb..efff4c4 100644
--- a/_devices/nvidiahshieldtablet.markdown
+++ b/_devices/nvidiahshieldtablet.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "NVidia Shield Tablet"
-codename: shieldtablet
-downloadfolder: shieldtablet
-supportstatus: Current
-maintainer: webgeek1234
-oem: NVidia
-devicetree: https://github.com/TeamWin/android_device_nvidia_shieldtablet
-ddof: "/dev/block/platform/sdhci-tegra.3/by-name/SOS"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-<div class='page-heading'>Notes:</div>
-<hr />
-<p class="text">Releases 3.0.2-0 and before are for the 'L' bootloader only. Later versions work on all models and bootloaders.</p>
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "NVidia Shield Tablet"
+codename: shieldtablet
+downloadfolder: shieldtablet
+supportstatus: Current
+maintainer: webgeek1234
+oem: NVidia
+devicetree: https://github.com/TeamWin/android_device_nvidia_shieldtablet
+ddof: "/dev/block/platform/sdhci-tegra.3/by-name/SOS"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+<div class='page-heading'>Notes:</div>
+<hr />
+<p class="text">Releases 3.0.2-0 and before are for the 'L' bootloader only. Later versions work on all models and bootloaders.</p>
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/omatetruesmart.markdown b/_devices/omatetruesmart.markdown
index 8e41762..27d3135 100644
--- a/_devices/omatetruesmart.markdown
+++ b/_devices/omatetruesmart.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Omate TrueSmart"
-codename: x201
-downloadfolder: omatesmartwatch2
-oldurl: http://teamw.in/project/twrp2/214
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Omate
-ddof: "/dev/recovery"
-mtkchipset: mt6572
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Omate TrueSmart"
+codename: x201
+downloadfolder: omatesmartwatch2
+oldurl: http://teamw.in/project/twrp2/214
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Omate
+ddof: "/dev/recovery"
+mtkchipset: mt6572
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/oneplusone.markdown b/_devices/oneplusone.markdown
index 4cc3ac6..d3774bb 100644
--- a/_devices/oneplusone.markdown
+++ b/_devices/oneplusone.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "OnePlus One"
-codename: bacon
-downloadfolder: bacon
-oldurl: http://teamw.in/project/twrp2/231
-supportstatus: Current
-maintainer: Dees_Troy
-oem: OnePlus
-devicetree: https://github.com/TeamWin/android_device_oneplus_bacon
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2766186"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "OnePlus One"
+codename: bacon
+downloadfolder: bacon
+oldurl: http://teamw.in/project/twrp2/231
+supportstatus: Current
+maintainer: Dees_Troy
+oem: OnePlus
+devicetree: https://github.com/TeamWin/android_device_oneplus_bacon
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2766186"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oneplustwo.markdown b/_devices/oneplustwo.markdown
index 08a3e3b..bf13618 100644
--- a/_devices/oneplustwo.markdown
+++ b/_devices/oneplustwo.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "OnePlus Two"
-codename: oneplus2
-downloadfolder: oneplus2
-supportstatus: Current
-maintainer: None
-oem: OnePlus
-devicetree: https://github.com/TeamWin/android_device_oneplus_oneplus2
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "OnePlus Two"
+codename: oneplus2
+downloadfolder: oneplus2
+supportstatus: Current
+maintainer: None
+oem: OnePlus
+devicetree: https://github.com/TeamWin/android_device_oneplus_oneplus2
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oneplusx.markdown b/_devices/oneplusx.markdown
index d6ff6e8..ff952ca 100644
--- a/_devices/oneplusx.markdown
+++ b/_devices/oneplusx.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "OnePlus X"
-codename: onyx
-downloadfolder: onyx
-supportstatus: Current
-maintainer: Dees_Troy
-oem: OnePlus
-devicetree: https://github.com/TeamWin/android_device_oneplus_onyx
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "OnePlus X"
+codename: onyx
+downloadfolder: onyx
+supportstatus: Current
+maintainer: Dees_Troy
+oem: OnePlus
+devicetree: https://github.com/TeamWin/android_device_oneplus_onyx
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppofind5.markdown b/_devices/oppofind5.markdown
index 77f3014..b68f359 100644
--- a/_devices/oppofind5.markdown
+++ b/_devices/oppofind5.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Oppo Find 5"
-codename: find5
-downloadfolder: find5
-oldurl: http://teamw.in/project/twrp2/156
-supportstatus: Current
-maintainer: None
-oem: Oppo
-devicetree: https://github.com/TeamWin/android_device_oppo_find5
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo Find 5"
+codename: find5
+downloadfolder: find5
+oldurl: http://teamw.in/project/twrp2/156
+supportstatus: Current
+maintainer: None
+oem: Oppo
+devicetree: https://github.com/TeamWin/android_device_oppo_find5
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppofind7.markdown b/_devices/oppofind7.markdown
index 86fd342..b03d57d 100644
--- a/_devices/oppofind7.markdown
+++ b/_devices/oppofind7.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Oppo Find 7"
-codename: find7
-downloadfolder: find7
-oldurl: http://teamw.in/project/twrp2/245
-supportstatus: Current
-maintainer: bigbiff
-oem: Oppo
-devicetree: https://github.com/omnirom/android_device_oppo_find7
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-Note: The same TWRP image will work for both the 7a and 7s model now.
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo Find 7"
+codename: find7
+downloadfolder: find7
+oldurl: http://teamw.in/project/twrp2/245
+supportstatus: Current
+maintainer: bigbiff
+oem: Oppo
+devicetree: https://github.com/omnirom/android_device_oppo_find7
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+Note: The same TWRP image will work for both the 7a and 7s model now.
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppon1.markdown b/_devices/oppon1.markdown
index f6841cb..4699652 100644
--- a/_devices/oppon1.markdown
+++ b/_devices/oppon1.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Oppo N1"
-codename: N1
-downloadfolder: N1
-oldurl: http://teamw.in/project/twrp2/209
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Oppo
-devicetree: https://github.com/omnirom/android_device_oppo_n1
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo N1"
+codename: N1
+downloadfolder: N1
+oldurl: http://teamw.in/project/twrp2/209
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Oppo
+devicetree: https://github.com/omnirom/android_device_oppo_n1
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppon3.markdown b/_devices/oppon3.markdown
index 35011d2..7379679 100644
--- a/_devices/oppon3.markdown
+++ b/_devices/oppon3.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Oppo N3"
-codename: n3
-downloadfolder: n3
-oldurl: http://teamw.in/project/twrp2/209
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Oppo
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo N3"
+codename: n3
+downloadfolder: n3
+oldurl: http://teamw.in/project/twrp2/209
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Oppo
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppor5.markdown b/_devices/oppor5.markdown
index 44b29a5..892fb34 100644
--- a/_devices/oppor5.markdown
+++ b/_devices/oppor5.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Oppo R5"
-codename: r5
-downloadfolder: r5
-supportstatus: Current
-maintainer: maxwen
-oem: Oppo
-devicetree: https://github.com/omnirom/android_device_oppo_r5
-xdathread: "http://forum.xda-developers.com/oppo-r5/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3114720"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo R5"
+codename: r5
+downloadfolder: r5
+supportstatus: Current
+maintainer: maxwen
+oem: Oppo
+devicetree: https://github.com/omnirom/android_device_oppo_r5
+xdathread: "http://forum.xda-developers.com/oppo-r5/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3114720"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppor7f.markdown b/_devices/oppor7f.markdown
index b1c580b..65fb53d 100644
--- a/_devices/oppor7f.markdown
+++ b/_devices/oppor7f.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Oppo R7f"
-codename: r7f
-downloadfolder: r7f
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Oppo
-devicetree: https://github.com/TeamWin/android_device_oppo_r7f
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo R7f"
+codename: r7f
+downloadfolder: r7f
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Oppo
+devicetree: https://github.com/TeamWin/android_device_oppo_r7f
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppor7plusf.markdown b/_devices/oppor7plusf.markdown
index 929e7fb..79fc714 100644
--- a/_devices/oppor7plusf.markdown
+++ b/_devices/oppor7plusf.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Oppo R7 Plus f"
-codename: r7plusf
-downloadfolder: r7plusf
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Oppo
-devicetree: https://github.com/TeamWin/android_device_oppo_r7plusf
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo R7 Plus f"
+codename: r7plusf
+downloadfolder: r7plusf
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Oppo
+devicetree: https://github.com/TeamWin/android_device_oppo_r7plusf
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppor7sf.markdown b/_devices/oppor7sf.markdown
index a5f1405..7b97df2 100644
--- a/_devices/oppor7sf.markdown
+++ b/_devices/oppor7sf.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Oppo R7sf"
-codename: r7sf
-downloadfolder: r7sf
-supportstatus: Current
-maintainer: Celoxocis
-oem: Oppo
-devicetree: https://github.com/TeamWin/android_device_oppo_r7sf
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Oppo R7sf"
+codename: r7sf
+downloadfolder: r7sf
+supportstatus: Current
+maintainer: Celoxocis
+oem: Oppo
+devicetree: https://github.com/TeamWin/android_device_oppo_r7sf
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/oppor819.markdown b/_devices/oppor819.markdown
index 355bc8f..509a495 100644
--- a/_devices/oppor819.markdown
+++ b/_devices/oppor819.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Oppo R819"
-codename: R819
-downloadfolder: R819
-oldurl: http://teamw.in/project/twrp2/209
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Oppo
-ddof: "/dev/recovery"
-mtkchipset: MT6589
-devicetree: "https://github.com/TeamWin/android_device_oppo_R819"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2504665"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include mtkinstall.html %}
+---
+layout: device
+title:  "Oppo R819"
+codename: R819
+downloadfolder: R819
+oldurl: http://teamw.in/project/twrp2/209
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Oppo
+ddof: "/dev/recovery"
+mtkchipset: MT6589
+devicetree: "https://github.com/TeamWin/android_device_oppo_R819"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2504665"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_devices/samsungefascinate.markdown b/_devices/samsungefascinate.markdown
index f78a439..47dafb5 100644
--- a/_devices/samsungefascinate.markdown
+++ b/_devices/samsungefascinate.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Samsung Galaxy S Fascinate"
-codename: fascinatemtd
-downloadfolder: fascinatemtd
-oldurl: http://teamw.in/project/twrp2/40
-supportstatus: No Longer Updated
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/device_samsung_fascinatemtd
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-<div class='page-heading'>Notes:</div>
-<hr />
-<p class="text">This will only work with AOSP based ROMs. It will not work with stock-based Samsung ROMs.</p>
-<p class="text">Download the zip and flash in recovery just like you would flash a ROM.</p>
+---
+layout: device
+title:  "Samsung Galaxy S Fascinate"
+codename: fascinatemtd
+downloadfolder: fascinatemtd
+oldurl: http://teamw.in/project/twrp2/40
+supportstatus: No Longer Updated
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/device_samsung_fascinatemtd
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+<div class='page-heading'>Notes:</div>
+<hr />
+<p class="text">This will only work with AOSP based ROMs. It will not work with stock-based Samsung ROMs.</p>
+<p class="text">Download the zip and flash in recovery just like you would flash a ROM.</p>
diff --git a/_devices/samsungepic4g.markdown b/_devices/samsungepic4g.markdown
index c8b2814..77983a9 100644
--- a/_devices/samsungepic4g.markdown
+++ b/_devices/samsungepic4g.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Samsung Epic 4g"
-codename: epicmtd
-downloadfolder: epicmtd
-oldurl: http://teamw.in/project/twrp2/13
-supportstatus: No Longer Updated
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/device_samsung_epicmtd
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include download.html %}
-
-<div class='page-heading'>Notes:</div>
-<hr />
-<p class="text">This will only work with AOSP based ROMs. It will not work with stock-based Samsung ROMs.</p>
-<p class="text">Download the zip and flash in recovery just like you would flash a ROM.</p>
+---
+layout: device
+title:  "Samsung Epic 4g"
+codename: epicmtd
+downloadfolder: epicmtd
+oldurl: http://teamw.in/project/twrp2/13
+supportstatus: No Longer Updated
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/device_samsung_epicmtd
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+<div class='page-heading'>Notes:</div>
+<hr />
+<p class="text">This will only work with AOSP based ROMs. It will not work with stock-based Samsung ROMs.</p>
+<p class="text">Download the zip and flash in recovery just like you would flash a ROM.</p>
diff --git a/_devices/samsunggalaxyace3.markdown b/_devices/samsunggalaxyace3.markdown
index fbfac12..c2c1629 100644
--- a/_devices/samsunggalaxyace3.markdown
+++ b/_devices/samsunggalaxyace3.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Ace 3"
-codename: loganreltexx
-downloadfolder: loganreltexx
-supportstatus: Current
-maintainer: Kotzir
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Ace 3"
+codename: loganreltexx
+downloadfolder: loganreltexx
+supportstatus: Current
+maintainer: Kotzir
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyalpha.markdown b/_devices/samsunggalaxyalpha.markdown
index 8052971..3764c5b 100644
--- a/_devices/samsunggalaxyalpha.markdown
+++ b/_devices/samsunggalaxyalpha.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Alpha"
-codename: slte
-downloadfolder: slte
-oldurl: http://teamw.in/project/twrp2/267
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p10"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Alpha"
+codename: slte
+downloadfolder: slte
+oldurl: http://teamw.in/project/twrp2/267
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p10"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxycore2.markdown b/_devices/samsunggalaxycore2.markdown
index a7fcd20..f0076fc 100644
--- a/_devices/samsunggalaxycore2.markdown
+++ b/_devices/samsunggalaxycore2.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Core 2 SM-G355HN"
-codename: kanas3gnfc
-downloadfolder: kanas3gnfc
-supportstatus: Current
-maintainer: Y300-0100
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Core 2 SM-G355HN"
+codename: kanas3gnfc
+downloadfolder: kanas3gnfc
+supportstatus: Current
+maintainer: Y300-0100
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxycoreprime3g.markdown b/_devices/samsunggalaxycoreprime3g.markdown
index 4f05700..33a53f9 100644
--- a/_devices/samsunggalaxycoreprime3g.markdown
+++ b/_devices/samsunggalaxycoreprime3g.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Core Prime 3G SM-G360H"
-codename: core33g
-downloadfolder: core33g
-supportstatus: Current
-maintainer: DreamStar
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Core Prime 3G SM-G360H"
+codename: core33g
+downloadfolder: core33g
+supportstatus: Current
+maintainer: DreamStar
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxycoreprimequalcomm.markdown b/_devices/samsunggalaxycoreprimequalcomm.markdown
index 3f6fb2b..597d77f 100644
--- a/_devices/samsunggalaxycoreprimequalcomm.markdown
+++ b/_devices/samsunggalaxycoreprimequalcomm.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Core Prime Qualcomm"
-codename: coreprimelte
-downloadfolder: coreprimelte
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/soc.0/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Core Prime Qualcomm"
+codename: coreprimelte
+downloadfolder: coreprimelte
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/soc.0/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxycoreprimequalcommcdma.markdown b/_devices/samsunggalaxycoreprimequalcommcdma.markdown
index 8cc7753..dd7391e 100644
--- a/_devices/samsunggalaxycoreprimequalcommcdma.markdown
+++ b/_devices/samsunggalaxycoreprimequalcommcdma.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Core Prime Qualcomm CDMA"
-codename: cprimeltemtr
-downloadfolder: cprimeltemtr
-supportstatus: Current
-maintainer: DreamStar001
-oem: Samsung
-ddof: "/dev/block/mmcblk0p17"
-devicetree: https://github.com/TeamWin/android_device_samsung_cprimeltemtr
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Core Prime Qualcomm CDMA"
+codename: cprimeltemtr
+downloadfolder: cprimeltemtr
+supportstatus: Current
+maintainer: DreamStar001
+oem: Samsung
+ddof: "/dev/block/mmcblk0p17"
+devicetree: https://github.com/TeamWin/android_device_samsung_cprimeltemtr
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyexpress.markdown b/_devices/samsunggalaxyexpress.markdown
index 86aff3b..6febeae 100644
--- a/_devices/samsunggalaxyexpress.markdown
+++ b/_devices/samsunggalaxyexpress.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Express"
-codename: expressltexx
-downloadfolder: expressltexx
-supportstatus: Current
-maintainer: Kotzir
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Express"
+codename: expressltexx
+downloadfolder: expressltexx
+supportstatus: Current
+maintainer: Kotzir
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyexpress2.markdown b/_devices/samsunggalaxyexpress2.markdown
index 7ec1a5e..1b3352b 100644
--- a/_devices/samsunggalaxyexpress2.markdown
+++ b/_devices/samsunggalaxyexpress2.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Express 2"
-codename: wilcoxltexx
-downloadfolder: wilcoxltexx
-supportstatus: Current
-maintainer: Kotzir
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Express 2"
+codename: wilcoxltexx
+downloadfolder: wilcoxltexx
+supportstatus: Current
+maintainer: Kotzir
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxygrandduos.markdown b/_devices/samsunggalaxygrandduos.markdown
index 7720278..e6ee223 100644
--- a/_devices/samsunggalaxygrandduos.markdown
+++ b/_devices/samsunggalaxygrandduos.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Grand Duos"
-codename: i9082
-downloadfolder: i9082
-oldurl: http://teamw.in/project/twrp2/252
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Grand Duos"
+codename: i9082
+downloadfolder: i9082
+oldurl: http://teamw.in/project/twrp2/252
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxygrandprimeve.markdown b/_devices/samsunggalaxygrandprimeve.markdown
index 85d7d28..f61f463 100644
--- a/_devices/samsunggalaxygrandprimeve.markdown
+++ b/_devices/samsunggalaxygrandprimeve.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Grand Prime VE"
-codename: grandprimevelte
-downloadfolder: grandprimevelte
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/soc.2/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_grandprimevelte"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Grand Prime VE"
+codename: grandprimevelte
+downloadfolder: grandprimevelte
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/soc.2/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_grandprimevelte"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyj1ace.markdown b/_devices/samsunggalaxyj1ace.markdown
index 85b53f3..33d8396 100644
--- a/_devices/samsunggalaxyj1ace.markdown
+++ b/_devices/samsunggalaxyj1ace.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy J1 Ace (SM-J110)"
-codename: j1acelte
-downloadfolder: j1acelte
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-ddof: "/dev/block/platform/soc.2/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/device_samsung_j1acelte"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy J1 Ace (SM-J110)"
+codename: j1acelte
+downloadfolder: j1acelte
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+ddof: "/dev/block/platform/soc.2/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/device_samsung_j1acelte"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyj2.markdown b/_devices/samsunggalaxyj2.markdown
index 314e326..c50dd91 100644
--- a/_devices/samsunggalaxyj2.markdown
+++ b/_devices/samsunggalaxyj2.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy J2 (SM-J200)"
-codename: j2lte
-downloadfolder: j2lte
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-ddof: "/dev/block/platform/13540000.dwmmc0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/device_samsung_j2lte"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy J2 (SM-J200)"
+codename: j2lte
+downloadfolder: j2lte
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+ddof: "/dev/block/platform/13540000.dwmmc0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/device_samsung_j2lte"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyj7exynos.markdown b/_devices/samsunggalaxyj7exynos.markdown
index 15b676e..1ad1b37 100644
--- a/_devices/samsunggalaxyj7exynos.markdown
+++ b/_devices/samsunggalaxyj7exynos.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy J7 Exynos SM-J700"
-codename: j7elte
-downloadfolder: j7elte
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-ddof: "/dev/block/platform/13540000.dwmmc0/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy J7 Exynos SM-J700"
+codename: j7elte
+downloadfolder: j7elte
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+ddof: "/dev/block/platform/13540000.dwmmc0/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxymega58.markdown b/_devices/samsunggalaxymega58.markdown
index c31e7f9..1c59d5a 100644
--- a/_devices/samsunggalaxymega58.markdown
+++ b/_devices/samsunggalaxymega58.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Mega 5.8"
-codename: crater
-downloadfolder: crater
-oldurl: http://teamw.in/project/twrp2/196
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2460586"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Mega 5.8"
+codename: crater
+downloadfolder: crater
+oldurl: http://teamw.in/project/twrp2/196
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2460586"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxymega63.markdown b/_devices/samsunggalaxymega63.markdown
index 108b8bc..9b21512 100644
--- a/_devices/samsunggalaxymega63.markdown
+++ b/_devices/samsunggalaxymega63.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Mega 6.3"
-codename: melius
-downloadfolder: melius
-oldurl: http://teamw.in/project/twrp2/199
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2460586"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Mega 6.3"
+codename: melius
+downloadfolder: melius
+oldurl: http://teamw.in/project/twrp2/199
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2460586"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynexusgsm.markdown b/_devices/samsunggalaxynexusgsm.markdown
index 038de42..4775451 100644
--- a/_devices/samsunggalaxynexusgsm.markdown
+++ b/_devices/samsunggalaxynexusgsm.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Nexus (GSM)"
-codename: maguro
-downloadfolder: maguro
-oldurl: http://teamw.in/project/twrp2/90
-supportstatus: No longer updated
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/device_samsung_maguro
-xdathread: "http://forum.xda-developers.com/galaxy-nexus/development/recovery-twrp-2-7-1-0-touch-recovery-t1592689"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Nexus (GSM)"
+codename: maguro
+downloadfolder: maguro
+oldurl: http://teamw.in/project/twrp2/90
+supportstatus: No longer updated
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/device_samsung_maguro
+xdathread: "http://forum.xda-developers.com/galaxy-nexus/development/recovery-twrp-2-7-1-0-touch-recovery-t1592689"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/samsunggalaxynexussprint.markdown b/_devices/samsunggalaxynexussprint.markdown
index d7d08c7..42acec7 100644
--- a/_devices/samsunggalaxynexussprint.markdown
+++ b/_devices/samsunggalaxynexussprint.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Nexus (Sprint)"
-codename: toroplus
-downloadfolder: toroplus
-oldurl: http://teamw.in/project/twrp2/92
-supportstatus: No longer updated
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/device_samsung_toroplus
-xdathread: "http://forum.xda-developers.com/galaxy-nexus/sprint-develop/recovery-twrp-2-7-1-0-touch-recovery-t1592691"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Nexus (Sprint)"
+codename: toroplus
+downloadfolder: toroplus
+oldurl: http://teamw.in/project/twrp2/92
+supportstatus: No longer updated
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/device_samsung_toroplus
+xdathread: "http://forum.xda-developers.com/galaxy-nexus/sprint-develop/recovery-twrp-2-7-1-0-touch-recovery-t1592691"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/samsunggalaxynexusverizon.markdown b/_devices/samsunggalaxynexusverizon.markdown
index a333db0..36e985b 100644
--- a/_devices/samsunggalaxynexusverizon.markdown
+++ b/_devices/samsunggalaxynexusverizon.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Nexus (Verizon)"
-codename: toro
-downloadfolder: toro
-oldurl: http://teamw.in/project/twrp2/89
-supportstatus: No longer updated
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/device_samsung_toro
-xdathread: "http://forum.xda-developers.com/galaxy-nexus/verizon-develop/recovery-twrp-2-7-1-0-touch-recovery-t1615168"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Nexus (Verizon)"
+codename: toro
+downloadfolder: toro
+oldurl: http://teamw.in/project/twrp2/89
+supportstatus: No longer updated
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/device_samsung_toro
+xdathread: "http://forum.xda-developers.com/galaxy-nexus/verizon-develop/recovery-twrp-2-7-1-0-touch-recovery-t1615168"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/samsunggalaxynote101.markdown b/_devices/samsunggalaxynote101.markdown
index 2873a2c..bb1261d 100644
--- a/_devices/samsunggalaxynote101.markdown
+++ b/_devices/samsunggalaxynote101.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Note 10.1"
-codename: p4noterf
-downloadfolder: p4noterf
-oldurl: http://teamw.in/project/twrp2/110
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 10.1"
+codename: p4noterf
+downloadfolder: p4noterf
+oldurl: http://teamw.in/project/twrp2/110
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote1012014exynos.markdown b/_devices/samsunggalaxynote1012014exynos.markdown
index a9fe022..e346d5e 100644
--- a/_devices/samsunggalaxynote1012014exynos.markdown
+++ b/_devices/samsunggalaxynote1012014exynos.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 10.1 (2014) Exynos Wi-Fi"
-codename: lt03wifiue
-downloadfolder: lt03wifiue
-oldurl: http://teamw.in/project/twrp2/206
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/android_device_samsung_lt03wifiue
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2515656"
-ddof: "/dev/block/mmcblk0p10"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 10.1 (2014) Exynos Wi-Fi"
+codename: lt03wifiue
+downloadfolder: lt03wifiue
+oldurl: http://teamw.in/project/twrp2/206
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/android_device_samsung_lt03wifiue
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2515656"
+ddof: "/dev/block/mmcblk0p10"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote1012014qcom.markdown b/_devices/samsunggalaxynote1012014qcom.markdown
index f1ced0b..dcdbe43 100644
--- a/_devices/samsunggalaxynote1012014qcom.markdown
+++ b/_devices/samsunggalaxynote1012014qcom.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 10.1 (2014) Qualcomm LTE"
-codename: lt03ltexx
-downloadfolder: lt03ltexx
-oldurl: http://teamw.in/project/twrp2/207
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: https://github.com/TeamWin/android_device_samsung_lt03ltexx
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2515656"
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 10.1 (2014) Qualcomm LTE"
+codename: lt03ltexx
+downloadfolder: lt03ltexx
+oldurl: http://teamw.in/project/twrp2/207
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/android_device_samsung_lt03ltexx
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2515656"
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote1att.markdown b/_devices/samsunggalaxynote1att.markdown
index 4cc757b..5a710e8 100644
--- a/_devices/samsunggalaxynote1att.markdown
+++ b/_devices/samsunggalaxynote1att.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 1 AT&T"
-codename: quincyatt
-downloadfolder: quincyatt
-oldurl: http://teamw.in/project/twrp2/96
-supportstatus: Current
-maintainer: javelinanddart
-oem: Samsung
-ddof: "/dev/block/mmcblk0p22"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1647575"
-devicetree: "https://github.com/TeamWin/android_device_samsung_quincyatt"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 1 AT&T"
+codename: quincyatt
+downloadfolder: quincyatt
+oldurl: http://teamw.in/project/twrp2/96
+supportstatus: Current
+maintainer: javelinanddart
+oem: Samsung
+ddof: "/dev/block/mmcblk0p22"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1647575"
+devicetree: "https://github.com/TeamWin/android_device_samsung_quincyatt"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote1tmobile.markdown b/_devices/samsunggalaxynote1tmobile.markdown
index b4a607c..5894929 100644
--- a/_devices/samsunggalaxynote1tmobile.markdown
+++ b/_devices/samsunggalaxynote1tmobile.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 1 T-Mobile"
-codename: quincytmo
-downloadfolder: quincytmo
-oldurl: http://teamw.in/project/twrp2/113
-supportstatus: Current
-maintainer: javelinanddart
-oem: Samsung
-ddof: "/dev/block/mmcblk0p22"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1864048"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 1 T-Mobile"
+codename: quincytmo
+downloadfolder: quincytmo
+oldurl: http://teamw.in/project/twrp2/113
+supportstatus: Current
+maintainer: javelinanddart
+oem: Samsung
+ddof: "/dev/block/mmcblk0p22"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1864048"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2att.markdown b/_devices/samsunggalaxynote2att.markdown
index 4cc8805..d061564 100644
--- a/_devices/samsunggalaxynote2att.markdown
+++ b/_devices/samsunggalaxynote2att.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 AT&T"
-codename: t0lteatt
-downloadfolder: t0lteatt
-oldurl: http://teamw.in/project/twrp2/124
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1981198"
-devicetree: "https://github.com/TeamWin/android_device_samsung_t0lteatt"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 AT&T"
+codename: t0lteatt
+downloadfolder: t0lteatt
+oldurl: http://teamw.in/project/twrp2/124
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1981198"
+devicetree: "https://github.com/TeamWin/android_device_samsung_t0lteatt"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2canada.markdown b/_devices/samsunggalaxynote2canada.markdown
index 20eb648..af705bc 100644
--- a/_devices/samsunggalaxynote2canada.markdown
+++ b/_devices/samsunggalaxynote2canada.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 Canada"
-codename: t0ltecan
-downloadfolder: t0ltecan
-oldurl: http://teamw.in/project/twrp2/126
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-devicetree: "https://github.com/TeamWin/android_device_samsung_t0ltecan"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 Canada"
+codename: t0ltecan
+downloadfolder: t0ltecan
+oldurl: http://teamw.in/project/twrp2/126
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+devicetree: "https://github.com/TeamWin/android_device_samsung_t0ltecan"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2n7100.markdown b/_devices/samsunggalaxynote2n7100.markdown
index 8925ec5..9940d18 100644
--- a/_devices/samsunggalaxynote2n7100.markdown
+++ b/_devices/samsunggalaxynote2n7100.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 N7100"
-codename: t03g
-downloadfolder: t03g
-oldurl: http://teamw.in/project/twrp2/115
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-devicetree: "https://github.com/TeamWin/android_device_samsung_t03g"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1938733"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 N7100"
+codename: t03g
+downloadfolder: t03g
+oldurl: http://teamw.in/project/twrp2/115
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+devicetree: "https://github.com/TeamWin/android_device_samsung_t03g"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1938733"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2n7105.markdown b/_devices/samsunggalaxynote2n7105.markdown
index 4de4ad3..c426c57 100644
--- a/_devices/samsunggalaxynote2n7105.markdown
+++ b/_devices/samsunggalaxynote2n7105.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 N7105"
-codename: t0lte
-downloadfolder: t0lte
-oldurl: http://teamw.in/project/twrp2/125
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-devicetree: "https://github.com/TeamWin/android_device_t0lte"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 N7105"
+codename: t0lte
+downloadfolder: t0lte
+oldurl: http://teamw.in/project/twrp2/125
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+devicetree: "https://github.com/TeamWin/android_device_t0lte"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2sprint.markdown b/_devices/samsunggalaxynote2sprint.markdown
index 80cca0e..7a786db 100644
--- a/_devices/samsunggalaxynote2sprint.markdown
+++ b/_devices/samsunggalaxynote2sprint.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 Sprint"
-codename: l900
-downloadfolder: l900
-oldurl: http://teamw.in/project/twrp2/117
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1956939"
-devicetree: "https://github.com/TeamWin/twrp_device_samsung_l900"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 Sprint"
+codename: l900
+downloadfolder: l900
+oldurl: http://teamw.in/project/twrp2/117
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1956939"
+devicetree: "https://github.com/TeamWin/twrp_device_samsung_l900"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2t0ltektt.markdown b/_devices/samsunggalaxynote2t0ltektt.markdown
index f33b1f3..0b8d13c 100644
--- a/_devices/samsunggalaxynote2t0ltektt.markdown
+++ b/_devices/samsunggalaxynote2t0ltektt.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 LTE Korea"
-codename: t0ltektt
-downloadfolder: t0ltektt
-oldurl: http://teamw.in/project/twrp2/152
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-devicetree: "https://github.com/TeamWin/android_device_samsung_t0ltektt"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 LTE Korea"
+codename: t0ltektt
+downloadfolder: t0ltektt
+oldurl: http://teamw.in/project/twrp2/152
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+devicetree: "https://github.com/TeamWin/android_device_samsung_t0ltektt"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2t0lteskt.markdown b/_devices/samsunggalaxynote2t0lteskt.markdown
index bd1a39e..4809400 100644
--- a/_devices/samsunggalaxynote2t0lteskt.markdown
+++ b/_devices/samsunggalaxynote2t0lteskt.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 LTE SK Telecom"
-codename: t0lteskt
-downloadfolder: t0lteskt
-oldurl: http://teamw.in/project/twrp2/151
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-devicetree: "https://github.com/TeamWin/android_device_samsung_t0lteskt"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 LTE SK Telecom"
+codename: t0lteskt
+downloadfolder: t0lteskt
+oldurl: http://teamw.in/project/twrp2/151
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+devicetree: "https://github.com/TeamWin/android_device_samsung_t0lteskt"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2tmobile.markdown b/_devices/samsunggalaxynote2tmobile.markdown
index 634ec94..b398765 100644
--- a/_devices/samsunggalaxynote2tmobile.markdown
+++ b/_devices/samsunggalaxynote2tmobile.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 T-Mobile"
-codename: t0ltetmo
-downloadfolder: t0ltetmo
-oldurl: http://teamw.in/project/twrp2/123
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1966105"
-devicetree: "https://github.com/TeamWin/android_device_samsung_t0ltetmo"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 T-Mobile"
+codename: t0ltetmo
+downloadfolder: t0ltetmo
+oldurl: http://teamw.in/project/twrp2/123
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1966105"
+devicetree: "https://github.com/TeamWin/android_device_samsung_t0ltetmo"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote2verizon.markdown b/_devices/samsunggalaxynote2verizon.markdown
index 808d302..19182a7 100644
--- a/_devices/samsunggalaxynote2verizon.markdown
+++ b/_devices/samsunggalaxynote2verizon.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 2 Verizon"
-codename: t0ltevzw
-downloadfolder: t0ltevzw
-oldurl: http://teamw.in/project/twrp2/133
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2045829"
-devicetree: "https://github.com/TeamWin/device_android_t0ltevzw"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 2 Verizon"
+codename: t0ltevzw
+downloadfolder: t0ltevzw
+oldurl: http://teamw.in/project/twrp2/133
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2045829"
+devicetree: "https://github.com/TeamWin/device_android_t0ltevzw"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3internationalexynos.markdown b/_devices/samsunggalaxynote3internationalexynos.markdown
index b0a87e4..71c2310 100644
--- a/_devices/samsunggalaxynote3internationalexynos.markdown
+++ b/_devices/samsunggalaxynote3internationalexynos.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 3 International Exynos"
-codename: ha3g
-downloadfolder: ha3g
-oldurl: http://teamw.in/project/twrp2/204
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_ha3g"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2494245"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 3 International Exynos"
+codename: ha3g
+downloadfolder: ha3g
+oldurl: http://teamw.in/project/twrp2/204
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_ha3g"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2494245"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3neo.markdown b/_devices/samsunggalaxynote3neo.markdown
index 0255770..8341aaa 100644
--- a/_devices/samsunggalaxynote3neo.markdown
+++ b/_devices/samsunggalaxynote3neo.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 3 Neo"
-codename: hlltexx
-downloadfolder: hlltexx
-oldurl: http://teamw.in/project/twrp2/202
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_hllte"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2719163"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 3 Neo"
+codename: hlltexx
+downloadfolder: hlltexx
+oldurl: http://teamw.in/project/twrp2/202
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hllte"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2719163"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3neon750.markdown b/_devices/samsunggalaxynote3neon750.markdown
index 6e0707c..d840b92 100644
--- a/_devices/samsunggalaxynote3neon750.markdown
+++ b/_devices/samsunggalaxynote3neon750.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Note 3 Neo N750"
-codename: hl3g
-downloadfolder: hl3g
-supportstatus: Current
-maintainer: FireLord
-oem: Samsung
-ddof: "/dev/block/mmcblk0p10"
-devicetree: "https://github.com/TeamWin/android_device_samsung_hl3g"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 3 Neo N750"
+codename: hl3g
+downloadfolder: hl3g
+supportstatus: Current
+maintainer: FireLord
+oem: Samsung
+ddof: "/dev/block/mmcblk0p10"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hl3g"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3qualcomm.markdown b/_devices/samsunggalaxynote3qualcomm.markdown
index 21214ce..40392f4 100644
--- a/_devices/samsunggalaxynote3qualcomm.markdown
+++ b/_devices/samsunggalaxynote3qualcomm.markdown
@@ -1,60 +1,60 @@
----
-layout: device
-title:  "Samsung Galaxy Note 3 Qualcomm"
-codename: hlte
-downloadfolder: hlte
-oldurl: http://teamw.in/project/twrp2/202
-supportstatus: Current
-maintainer: jcadduono
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_hlte"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2494245"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-<p class="text"><strong>Warning</strong>: You must have a KitKat (Android 4.4) or newer bootloader in order for TWRP to work on this device.</p>
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">Europe &amp; Americas (SM-N9005, SM-N900A, SM-N900W8, SM-N900T, SM-N900R4, SM-N900P, SM-N900V):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hlte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-N900K, SM-N900L, SM-N900S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hlteskt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Japan (SCL22, SC-01F):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hltekdi">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 3 Qualcomm"
+codename: hlte
+downloadfolder: hlte
+oldurl: http://teamw.in/project/twrp2/202
+supportstatus: Current
+maintainer: jcadduono
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_hlte"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2494245"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+<p class="text"><strong>Warning</strong>: You must have a KitKat (Android 4.4) or newer bootloader in order for TWRP to work on this device.</p>
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">Europe &amp; Americas (SM-N9005, SM-N900A, SM-N900W8, SM-N900T, SM-N900R4, SM-N900P, SM-N900V):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hlte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-N900K, SM-N900L, SM-N900S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hlteskt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Japan (SCL22, SC-01F):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hltekdi">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgecan.markdown b/_devices/samsunggalaxynote4edgecan.markdown
index d6ffb68..38e0d03 100644
--- a/_devices/samsunggalaxynote4edgecan.markdown
+++ b/_devices/samsunggalaxynote4edgecan.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (Canada)"
-codename: tbltecan
-downloadfolder: tbltecan
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tbltecan"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (Canada)"
+codename: tbltecan
+downloadfolder: tbltecan
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tbltecan"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgeint.markdown b/_devices/samsunggalaxynote4edgeint.markdown
index 6eb8405..66422c5 100644
--- a/_devices/samsunggalaxynote4edgeint.markdown
+++ b/_devices/samsunggalaxynote4edgeint.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (International)"
-codename: tblte
-downloadfolder: tblte
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tblte"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (International)"
+codename: tblte
+downloadfolder: tblte
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tblte"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgekorea.markdown b/_devices/samsunggalaxynote4edgekorea.markdown
index a6053f7..74a8d3a 100644
--- a/_devices/samsunggalaxynote4edgekorea.markdown
+++ b/_devices/samsunggalaxynote4edgekorea.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (Korea)"
-codename: tbltedt
-downloadfolder: tbltedt
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tbltedt"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (Korea)"
+codename: tbltedt
+downloadfolder: tbltedt
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tbltedt"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgespr.markdown b/_devices/samsunggalaxynote4edgespr.markdown
index 89a2aae..d59b5dc 100644
--- a/_devices/samsunggalaxynote4edgespr.markdown
+++ b/_devices/samsunggalaxynote4edgespr.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (Sprint)"
-codename: tbltespr
-downloadfolder: tbltespr
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tbltespr"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (Sprint)"
+codename: tbltespr
+downloadfolder: tbltespr
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tbltespr"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgetmo.markdown b/_devices/samsunggalaxynote4edgetmo.markdown
index 5599d26..a7dc868 100644
--- a/_devices/samsunggalaxynote4edgetmo.markdown
+++ b/_devices/samsunggalaxynote4edgetmo.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (T-Mobile)"
-codename: tbltetmo
-downloadfolder: tbltetmo
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tbltetmo"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (T-Mobile)"
+codename: tbltetmo
+downloadfolder: tbltetmo
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tbltetmo"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgeusc.markdown b/_devices/samsunggalaxynote4edgeusc.markdown
index db70468..715fbd3 100644
--- a/_devices/samsunggalaxynote4edgeusc.markdown
+++ b/_devices/samsunggalaxynote4edgeusc.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (US Celluar)"
-codename: tblteusc
-downloadfolder: tblteusc
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tblteusc"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (US Celluar)"
+codename: tblteusc
+downloadfolder: tblteusc
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tblteusc"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4edgevzw.markdown b/_devices/samsunggalaxynote4edgevzw.markdown
index 2a2d6cf..9f642d4 100644
--- a/_devices/samsunggalaxynote4edgevzw.markdown
+++ b/_devices/samsunggalaxynote4edgevzw.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Edge (Verizon)"
-codename: tbltevzw
-downloadfolder: tbltevzw
-supportstatus: Current
-maintainer: mickey387
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tbltevzw"
-xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Edge (Verizon)"
+codename: tbltevzw
+downloadfolder: tbltevzw
+supportstatus: Current
+maintainer: mickey387
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tbltevzw"
+xdathread: "http://forum.xda-developers.com/note-edge/development/twrp-915fy-915tmo-moment-t3129459"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4exynos3g.markdown b/_devices/samsunggalaxynote4exynos3g.markdown
index 58b3bf7..b581bb4 100644
--- a/_devices/samsunggalaxynote4exynos3g.markdown
+++ b/_devices/samsunggalaxynote4exynos3g.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Exynos 3g"
-codename: tre3gxx
-downloadfolder: tre3gxx
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/15540000.dwmmc0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_tre3gxx"
-xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Exynos 3g"
+codename: tre3gxx
+downloadfolder: tre3gxx
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/15540000.dwmmc0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_tre3gxx"
+xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4exynoslte.markdown b/_devices/samsunggalaxynote4exynoslte.markdown
index 2d324eb..7db7ab3 100644
--- a/_devices/samsunggalaxynote4exynoslte.markdown
+++ b/_devices/samsunggalaxynote4exynoslte.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Exynos LTE"
-codename: treltexx
-downloadfolder: treltexx
-oldurl: http://teamw.in/project/twrp2/273
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/15540000.dwmmc0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_treltexx"
-xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Exynos LTE"
+codename: treltexx
+downloadfolder: treltexx
+oldurl: http://teamw.in/project/twrp2/273
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/15540000.dwmmc0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_treltexx"
+xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4qualcomm.markdown b/_devices/samsunggalaxynote4qualcomm.markdown
index 8a7ef33..710616c 100644
--- a/_devices/samsunggalaxynote4qualcomm.markdown
+++ b/_devices/samsunggalaxynote4qualcomm.markdown
@@ -1,96 +1,96 @@
----
-layout: device
-title:  "Samsung Galaxy Note 4 Qualcomm"
-codename: trlte
-oldurl: http://teamw.in/project/twrp2/266
-supportstatus: Current
-maintainer: bigbiff
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">Canada:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trltecan">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">India:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trltedt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">International (N910-F):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trltexx">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Sprint:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trltespr">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">T-Mobile:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trltetmo">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Verizon:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trltevzw">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">US Celluar:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}trlteusc">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Qualcomm"
+codename: trlte
+oldurl: http://teamw.in/project/twrp2/266
+supportstatus: Current
+maintainer: bigbiff
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">Canada:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trltecan">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">India:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trltedt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">International (N910-F):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trltexx">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Sprint:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trltespr">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">T-Mobile:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trltetmo">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Verizon:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trltevzw">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">US Celluar:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}trlteusc">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote80.markdown b/_devices/samsunggalaxynote80.markdown
index 20b2778..c86b61a 100644
--- a/_devices/samsunggalaxynote80.markdown
+++ b/_devices/samsunggalaxynote80.markdown
@@ -1,46 +1,46 @@
----
-layout: device
-title:  "Samsung Galaxy Note 8.0"
-codename: n5100
-downloadfolder: n5100
-supportstatus: Current
-maintainer: RGIB
-oem: Samsung
-devicetree: "https://github.com/omnirom/android_device_samsung_n5100"
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">n5100:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}n5100">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">n5110:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}n5110">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note 8.0"
+codename: n5100
+downloadfolder: n5100
+supportstatus: Current
+maintainer: RGIB
+oem: Samsung
+devicetree: "https://github.com/omnirom/android_device_samsung_n5100"
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">n5100:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}n5100">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">n5110:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}n5110">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynoten7000.markdown b/_devices/samsunggalaxynoten7000.markdown
index 694b866..73302d4 100644
--- a/_devices/samsunggalaxynoten7000.markdown
+++ b/_devices/samsunggalaxynoten7000.markdown
@@ -1,11 +1,11 @@
----
-layout: device
-title:  "Samsung Galaxy Note 1 N7000"
-codename: n7000
-downloadfolder: n7000
-supportstatus: NEVER
-maintainer: None
-oem: Samsung
----
-
-The Samsung Galaxy Note 1 n7000 model will NEVER receive official TWRP support. The n7000 does not have a separately bootable recovery partition. Instead, you are stuck with whatever recovery is included in your ROM or kernel or boot image. You may find TWRP included in some ROMs, kernels, or boot images, especially if you can find OmniROM for your device.
+---
+layout: device
+title:  "Samsung Galaxy Note 1 N7000"
+codename: n7000
+downloadfolder: n7000
+supportstatus: NEVER
+maintainer: None
+oem: Samsung
+---
+
+The Samsung Galaxy Note 1 n7000 model will NEVER receive official TWRP support. The n7000 does not have a separately bootable recovery partition. Instead, you are stuck with whatever recovery is included in your ROM or kernel or boot image. You may find TWRP included in some ROMs, kernels, or boot images, especially if you can find OmniROM for your device.
diff --git a/_devices/samsunggalaxynotepro122exynos3g.markdown b/_devices/samsunggalaxynotepro122exynos3g.markdown
index 74c8461..76a1e98 100644
--- a/_devices/samsunggalaxynotepro122exynos3g.markdown
+++ b/_devices/samsunggalaxynotepro122exynos3g.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note Pro 12.2 Exynos 3G"
-codename: v1a3gxx
-downloadfolder: v1a3gxx
-oldurl: http://teamw.in/project/twrp2/263
-supportstatus: Current
-maintainer: None
-oem: Samsung
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2706982"
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note Pro 12.2 Exynos 3G"
+codename: v1a3gxx
+downloadfolder: v1a3gxx
+oldurl: http://teamw.in/project/twrp2/263
+supportstatus: Current
+maintainer: None
+oem: Samsung
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2706982"
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynotepro122exynoswifi.markdown b/_devices/samsunggalaxynotepro122exynoswifi.markdown
index 784facf..67194f8 100644
--- a/_devices/samsunggalaxynotepro122exynoswifi.markdown
+++ b/_devices/samsunggalaxynotepro122exynoswifi.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note Pro 12.2 Exynos Wi-Fi"
-codename: v1awifi
-downloadfolder: v1awifi
-oldurl: http://teamw.in/project/twrp2/224
-supportstatus: Current
-maintainer: None
-oem: Samsung
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2706982"
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note Pro 12.2 Exynos Wi-Fi"
+codename: v1awifi
+downloadfolder: v1awifi
+oldurl: http://teamw.in/project/twrp2/224
+supportstatus: Current
+maintainer: None
+oem: Samsung
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2706982"
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynotepro122qcom.markdown b/_devices/samsunggalaxynotepro122qcom.markdown
index 8a00360..cf71875 100644
--- a/_devices/samsunggalaxynotepro122qcom.markdown
+++ b/_devices/samsunggalaxynotepro122qcom.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Note Pro 12.2 Qualcomm LTE SM-P905"
-codename: viennaltexx
-downloadfolder: viennaltexx
-oldurl: http://teamw.in/project/twrp2/237
-supportstatus: Current
-maintainer: None
-oem: Samsung
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2706982"
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Note Pro 12.2 Qualcomm LTE SM-P905"
+codename: viennaltexx
+downloadfolder: viennaltexx
+oldurl: http://teamw.in/project/twrp2/237
+supportstatus: Current
+maintainer: None
+oem: Samsung
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2706982"
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyprevail.markdown b/_devices/samsunggalaxyprevail.markdown
index 076f02a..4162544 100644
--- a/_devices/samsunggalaxyprevail.markdown
+++ b/_devices/samsunggalaxyprevail.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Prevail"
-codename: prevail2spr
-downloadfolder: prevail2spr
-oldurl: http://teamw.in/project/twrp2/215
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p15"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Prevail"
+codename: prevail2spr
+downloadfolder: prevail2spr
+oldurl: http://teamw.in/project/twrp2/215
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p15"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyreverb.markdown b/_devices/samsunggalaxyreverb.markdown
index 00960d4..72f77a8 100644
--- a/_devices/samsunggalaxyreverb.markdown
+++ b/_devices/samsunggalaxyreverb.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Reverb"
-codename: iconvmu
-downloadfolder: iconvmu
-oldurl: http://teamw.in/project/twrp2/208
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p15"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Reverb"
+codename: iconvmu
+downloadfolder: iconvmu
+oldurl: http://teamw.in/project/twrp2/208
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p15"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyrugbypro.markdown b/_devices/samsunggalaxyrugbypro.markdown
index 26752c7..f36d8ac 100644
--- a/_devices/samsunggalaxyrugbypro.markdown
+++ b/_devices/samsunggalaxyrugbypro.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Rugby Pro SGH-i547"
-codename: comanche
-downloadfolder: comanche
-oldurl: http://teamw.in/project/twrp2/132
-supportstatus: No Longer Updated
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/android_device_samsung_comanche"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Rugby Pro SGH-i547"
+codename: comanche
+downloadfolder: comanche
+oldurl: http://teamw.in/project/twrp2/132
+supportstatus: No Longer Updated
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/android_device_samsung_comanche"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys2exhilarate.markdown b/_devices/samsunggalaxys2exhilarate.markdown
index ef714e4..1a1e179 100644
--- a/_devices/samsunggalaxys2exhilarate.markdown
+++ b/_devices/samsunggalaxys2exhilarate.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S2 Exhilarate SGH-i577"
-codename: exhilarate
-downloadfolder: exhilarate
-oldurl: http://teamw.in/project/twrp2/195
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p22"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S2 Exhilarate SGH-i577"
+codename: exhilarate
+downloadfolder: exhilarate
+oldurl: http://teamw.in/project/twrp2/195
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p22"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys2hercules.markdown b/_devices/samsunggalaxys2hercules.markdown
index d03b8b8..b209b8c 100644
--- a/_devices/samsunggalaxys2hercules.markdown
+++ b/_devices/samsunggalaxys2hercules.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy S2 Hercules T-Mobile SGH-t989"
-codename: hercules
-downloadfolder: hercules
-oldurl: http://teamw.in/project/twrp2/101
-supportstatus: Current
-maintainer: javelinanddart
-oem: Samsung
-devicetree: https://github.com/TeamWin/android_device_samsung_hercules
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1768742"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S2 Hercules T-Mobile SGH-t989"
+codename: hercules
+downloadfolder: hercules
+oldurl: http://teamw.in/project/twrp2/101
+supportstatus: Current
+maintainer: javelinanddart
+oem: Samsung
+devicetree: https://github.com/TeamWin/android_device_samsung_hercules
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1768742"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
diff --git a/_devices/samsunggalaxys2i9100.markdown b/_devices/samsunggalaxys2i9100.markdown
index f31f36a..ce475a3 100644
--- a/_devices/samsunggalaxys2i9100.markdown
+++ b/_devices/samsunggalaxys2i9100.markdown
@@ -1,53 +1,53 @@
----
-layout: device
-title:  "Samsung Galaxy S2 i9100"
-codename: i9100
-downloadfolder: i9100
-supportstatus: Currently Supported via IsoRec
-maintainer: arnab
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
-xdathread: "http://forum.xda-developers.com/galaxy-s2/development-derivatives/recovery-twrp-3-0-0-0-t3330457"
-devicetree: "https://github.com/TeamWin/android_device_samsung_i9100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-NOTE: The i9100 does not support a separately bootable recovery partition. To install and use TWRP, you will need to install a custom kernel or boot image that supports IsoRec. You can find out more about IsoRec [here](http://forum.xda-developers.com/galaxy-s2/orig-development/isorec-isolated-recovery-galaxy-s2-t3291176).
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-<html>
-<div class='page-heading'>Flash via HeimdallSuite (Windows only):</div>
-<a id='heimdall'></a>
-<hr />
-<p class="text">Download HeimdallSuite & Samsung USB Drivers</p>
-<p class="text">Install Samsung USB Drivers</p>
-<p class="text">Connect the phone in Download mode (Vol. Down + Home + Power)</p>
-<p class="text">Go to Heimdall Suite/Drivers & open 'zadig' (Run in admin mode)</p>
-<p class="text">Select 'List All Devices' under 'Options'</p>
-<p class="text">Select 'Gadget Serial' & 'libusb0 (v1.2.5.0)' from the drop menu & scroll menu respectively</p>
-<p class="text">Click on Install/Replace Driver</p>
-<p class="text">Close 'zadig'</p>
-<p class="text">Reboot again into Download mode</p>
-<p class="text">Open 'heimdall-frontend'</p>
-<p class="text">Select 'Utilities' tab & click on 'Detect' under 'Detect Device' option</p>
-<p class="text">Make sure the 'Output' window says 'Device Detected'</p>
-<p class="text">Scroll down to 'Download PIT' section & click on 'Save As...' under 'Destination File'</p>
-<p class="text">Type any name under 'Name:' and select 'Save'. Do not give any filename extensions</p>
-<p class="text">Click on 'Download'</p>
-<p class="text">Reboot again into Download mode</p>
-<p class="text">Select 'Flash' tab</p>
-<p class="text">Load the downloaded pit under 'PIT'. Do not select 'Repartition' checkbox</p>
-<p class="text">Click the 'Add' button under 'Partitions (Files)'</p>
-<p class="text">Select 'RECOVERY' from the drop down menu in 'Partition Name' under 'Partition Details'. Make sure 'Partition ID' reads 7</p>
-<p class="text">Download the latest TWRP file from the download link above</p>
-<p class="text">Load the img image under 'File'</p>
-<p class="text">Now click on 'Start'</p>
-<p class="text">The image will get flashed in '/dev/block/mmcblk0p6' partition under mountpoint '/recovery'</p>
-<p class="text">Device will automatically restart when flashing is complete</p>
-</html>
+---
+layout: device
+title:  "Samsung Galaxy S2 i9100"
+codename: i9100
+downloadfolder: i9100
+supportstatus: Currently Supported via IsoRec
+maintainer: arnab
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+xdathread: "http://forum.xda-developers.com/galaxy-s2/development-derivatives/recovery-twrp-3-0-0-0-t3330457"
+devicetree: "https://github.com/TeamWin/android_device_samsung_i9100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+NOTE: The i9100 does not support a separately bootable recovery partition. To install and use TWRP, you will need to install a custom kernel or boot image that supports IsoRec. You can find out more about IsoRec [here](http://forum.xda-developers.com/galaxy-s2/orig-development/isorec-isolated-recovery-galaxy-s2-t3291176).
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+<html>
+<div class='page-heading'>Flash via HeimdallSuite (Windows only):</div>
+<a id='heimdall'></a>
+<hr />
+<p class="text">Download HeimdallSuite & Samsung USB Drivers</p>
+<p class="text">Install Samsung USB Drivers</p>
+<p class="text">Connect the phone in Download mode (Vol. Down + Home + Power)</p>
+<p class="text">Go to Heimdall Suite/Drivers & open 'zadig' (Run in admin mode)</p>
+<p class="text">Select 'List All Devices' under 'Options'</p>
+<p class="text">Select 'Gadget Serial' & 'libusb0 (v1.2.5.0)' from the drop menu & scroll menu respectively</p>
+<p class="text">Click on Install/Replace Driver</p>
+<p class="text">Close 'zadig'</p>
+<p class="text">Reboot again into Download mode</p>
+<p class="text">Open 'heimdall-frontend'</p>
+<p class="text">Select 'Utilities' tab & click on 'Detect' under 'Detect Device' option</p>
+<p class="text">Make sure the 'Output' window says 'Device Detected'</p>
+<p class="text">Scroll down to 'Download PIT' section & click on 'Save As...' under 'Destination File'</p>
+<p class="text">Type any name under 'Name:' and select 'Save'. Do not give any filename extensions</p>
+<p class="text">Click on 'Download'</p>
+<p class="text">Reboot again into Download mode</p>
+<p class="text">Select 'Flash' tab</p>
+<p class="text">Load the downloaded pit under 'PIT'. Do not select 'Repartition' checkbox</p>
+<p class="text">Click the 'Add' button under 'Partitions (Files)'</p>
+<p class="text">Select 'RECOVERY' from the drop down menu in 'Partition Name' under 'Partition Details'. Make sure 'Partition ID' reads 7</p>
+<p class="text">Download the latest TWRP file from the download link above</p>
+<p class="text">Load the img image under 'File'</p>
+<p class="text">Now click on 'Start'</p>
+<p class="text">The image will get flashed in '/dev/block/mmcblk0p6' partition under mountpoint '/recovery'</p>
+<p class="text">Device will automatically restart when flashing is complete</p>
+</html>
diff --git a/_devices/samsunggalaxys2plus.markdown b/_devices/samsunggalaxys2plus.markdown
index e486ff3..a4701a4 100644
--- a/_devices/samsunggalaxys2plus.markdown
+++ b/_devices/samsunggalaxys2plus.markdown
@@ -1,45 +1,45 @@
----
-layout: device
-title:  "Samsung Galaxy S2 Plus"
-codename: s2ve
-oldurl: http://teamw.in/project/twrp2/250
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">s2ve:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}s2ve">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">s2vep:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}s2vep">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S2 Plus"
+codename: s2ve
+oldurl: http://teamw.in/project/twrp2/250
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">s2ve:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}s2ve">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">s2vep:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}s2vep">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys2skyrocket.markdown b/_devices/samsunggalaxys2skyrocket.markdown
index 5ecb071..ce6d8a5 100644
--- a/_devices/samsunggalaxys2skyrocket.markdown
+++ b/_devices/samsunggalaxys2skyrocket.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy S2 AT&T Skyrocket SGH-i727"
-codename: skyrocket
-downloadfolder: skyrocket
-oldurl: http://teamw.in/project/twrp2/94
-supportstatus: Current
-maintainer: javelinanddart
-oem: Samsung
-devicetree: https://github.com/TeamWin/android_device_samsung_skyrocket
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1622917"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S2 AT&T Skyrocket SGH-i727"
+codename: skyrocket
+downloadfolder: skyrocket
+oldurl: http://teamw.in/project/twrp2/94
+supportstatus: Current
+maintainer: javelinanddart
+oem: Samsung
+devicetree: https://github.com/TeamWin/android_device_samsung_skyrocket
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1622917"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
diff --git a/_devices/samsunggalaxys3att.markdown b/_devices/samsunggalaxys3att.markdown
index 5dc76dc..67f24cc 100644
--- a/_devices/samsunggalaxys3att.markdown
+++ b/_devices/samsunggalaxys3att.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S3 AT&T"
-codename: d2att
-downloadfolder: d2att
-oldurl: http://teamw.in/project/twrp2/104
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/device_samsung_d2att"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 AT&T"
+codename: d2att
+downloadfolder: d2att
+oldurl: http://teamw.in/project/twrp2/104
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/device_samsung_d2att"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3canada.markdown b/_devices/samsunggalaxys3canada.markdown
index 047bb4c..be203de 100644
--- a/_devices/samsunggalaxys3canada.markdown
+++ b/_devices/samsunggalaxys3canada.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Canada"
-codename: d2can
-downloadfolder: d2can
-oldurl: http://teamw.in/project/twrp2/149
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/device_samsung_d2can"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Canada"
+codename: d2can
+downloadfolder: d2can
+oldurl: http://teamw.in/project/twrp2/149
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/device_samsung_d2can"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3cricket.markdown b/_devices/samsunggalaxys3cricket.markdown
index 50be720..0e74541 100644
--- a/_devices/samsunggalaxys3cricket.markdown
+++ b/_devices/samsunggalaxys3cricket.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Cricket"
-codename: d2cri
-downloadfolder: d2cri
-oldurl: http://teamw.in/project/twrp2/161
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Cricket"
+codename: d2cri
+downloadfolder: d2cri
+oldurl: http://teamw.in/project/twrp2/161
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3internationalexynos.markdown b/_devices/samsunggalaxys3internationalexynos.markdown
index ed5c7e9..fba9bd4 100644
--- a/_devices/samsunggalaxys3internationalexynos.markdown
+++ b/_devices/samsunggalaxys3internationalexynos.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy S3 International Exynos"
-codename: i9300
-downloadfolder: i9300
-oldurl: http://teamw.in/project/twrp2/114
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
-devicetree: "https://github.com/TeamWin/android_device_samsung_i9300"
-xdathread: "http://forum.xda-developers.com/galaxy-s3/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t1943592"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 International Exynos"
+codename: i9300
+downloadfolder: i9300
+oldurl: http://teamw.in/project/twrp2/114
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+devicetree: "https://github.com/TeamWin/android_device_samsung_i9300"
+xdathread: "http://forum.xda-developers.com/galaxy-s3/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t1943592"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3internationallte.markdown b/_devices/samsunggalaxys3internationallte.markdown
index 47ede64..54c85e6 100644
--- a/_devices/samsunggalaxys3internationallte.markdown
+++ b/_devices/samsunggalaxys3internationallte.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S3 International LTE"
-codename: i9305
-downloadfolder: i9305
-oldurl: http://teamw.in/project/twrp2/145
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p9"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 International LTE"
+codename: i9305
+downloadfolder: i9305
+oldurl: http://teamw.in/project/twrp2/145
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p9"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3metropcs.markdown b/_devices/samsunggalaxys3metropcs.markdown
index 3ec16a8..63830fa 100644
--- a/_devices/samsunggalaxys3metropcs.markdown
+++ b/_devices/samsunggalaxys3metropcs.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Metro PCS"
-codename: d2mtr
-downloadfolder: d2mtr
-oldurl: http://teamw.in/project/twrp2/118
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Metro PCS"
+codename: d2mtr
+downloadfolder: d2mtr
+oldurl: http://teamw.in/project/twrp2/118
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3mini.markdown b/_devices/samsunggalaxys3mini.markdown
index f5dbc2e..b19fcf2 100644
--- a/_devices/samsunggalaxys3mini.markdown
+++ b/_devices/samsunggalaxys3mini.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Mini"
-codename: golden
-downloadfolder: golden
-oldurl: http://teamw.in/project/twrp2/118
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
-devicetree: "https://github.com/TeamWin/android_device_samsung_golden"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Mini"
+codename: golden
+downloadfolder: golden
+oldurl: http://teamw.in/project/twrp2/118
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+devicetree: "https://github.com/TeamWin/android_device_samsung_golden"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3neo.markdown b/_devices/samsunggalaxys3neo.markdown
index 7e63e5f..8ee7561 100644
--- a/_devices/samsunggalaxys3neo.markdown
+++ b/_devices/samsunggalaxys3neo.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Neo i9301i"
-codename: s3ve3g
-downloadfolder: s3ve3g
-supportstatus: Current
-maintainer: MoonPWR
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_s3ve3g"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Neo i9301i"
+codename: s3ve3g
+downloadfolder: s3ve3g
+supportstatus: Current
+maintainer: MoonPWR
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_s3ve3g"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3sprint.markdown b/_devices/samsunggalaxys3sprint.markdown
index b1f4f5a..ad655c1 100644
--- a/_devices/samsunggalaxys3sprint.markdown
+++ b/_devices/samsunggalaxys3sprint.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Sprint"
-codename: d2spr
-downloadfolder: d2spr
-oldurl: http://teamw.in/project/twrp2/107
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/device_samsung_d2spr"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1809307"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Sprint"
+codename: d2spr
+downloadfolder: d2spr
+oldurl: http://teamw.in/project/twrp2/107
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/device_samsung_d2spr"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1809307"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3tmobile.markdown b/_devices/samsunggalaxys3tmobile.markdown
index 5fff290..230c4f6 100644
--- a/_devices/samsunggalaxys3tmobile.markdown
+++ b/_devices/samsunggalaxys3tmobile.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy S3 T-Mobile"
-codename: d2tmo
-downloadfolder: d2tmo
-oldurl: http://teamw.in/project/twrp2/106
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/device_samsung_d2tmo"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1809313"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 T-Mobile"
+codename: d2tmo
+downloadfolder: d2tmo
+oldurl: http://teamw.in/project/twrp2/106
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/device_samsung_d2tmo"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1809313"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3uscellular.markdown b/_devices/samsunggalaxys3uscellular.markdown
index 954370a..9b8b45e 100644
--- a/_devices/samsunggalaxys3uscellular.markdown
+++ b/_devices/samsunggalaxys3uscellular.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S3 US Cellular"
-codename: d2usc
-downloadfolder: d2usc
-oldurl: http://teamw.in/project/twrp2/121
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/android_device_samsung_d2usc"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 US Cellular"
+codename: d2usc
+downloadfolder: d2usc
+oldurl: http://teamw.in/project/twrp2/121
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/android_device_samsung_d2usc"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys3verizon.markdown b/_devices/samsunggalaxys3verizon.markdown
index bed2836..07adaff 100644
--- a/_devices/samsunggalaxys3verizon.markdown
+++ b/_devices/samsunggalaxys3verizon.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy S3 Verizon"
-codename: d2vzw
-downloadfolder: d2vzw
-oldurl: http://teamw.in/project/twrp2/102
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
-devicetree: "https://github.com/TeamWin/device_samsung_d2vzw"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1768142"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S3 Verizon"
+codename: d2vzw
+downloadfolder: d2vzw
+oldurl: http://teamw.in/project/twrp2/102
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+devicetree: "https://github.com/TeamWin/device_samsung_d2vzw"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1768142"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4active.markdown b/_devices/samsunggalaxys4active.markdown
index 1b58c81..8fe059b 100644
--- a/_devices/samsunggalaxys4active.markdown
+++ b/_devices/samsunggalaxys4active.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Active"
-codename: jactivelte
-downloadfolder: jactivelte
-supportstatus: Current
-maintainer: jcadduono
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Note: This TWRP build will almost certainly NOT work on the USA AT&T model as that model probably has a locked bootloader (like pretty much every other AT&T device).
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Active"
+codename: jactivelte
+downloadfolder: jactivelte
+supportstatus: Current
+maintainer: jcadduono
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Note: This TWRP build will almost certainly NOT work on the USA AT&T model as that model probably has a locked bootloader (like pretty much every other AT&T device).
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4att.markdown b/_devices/samsunggalaxys4att.markdown
index 2328558..0774ca8 100644
--- a/_devices/samsunggalaxys4att.markdown
+++ b/_devices/samsunggalaxys4att.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S4 AT&T"
-codename: jflteatt
-downloadfolder: jflteatt
-oldurl: http://teamw.in/project/twrp2/174
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2262996"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Only the earliest S4 for AT&T has a bootloader that is vulnerable to loki. If you took any updates or bought your device later on, you cannot install TWRP. Chances are, if you don't already have TWRP installed, you cannot use TWRP.
-Our images are already patched with loki so just root and flash. You cannot flash TWRP with Odin on this model.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 AT&T"
+codename: jflteatt
+downloadfolder: jflteatt
+oldurl: http://teamw.in/project/twrp2/174
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2262996"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Only the earliest S4 for AT&T has a bootloader that is vulnerable to loki. If you took any updates or bought your device later on, you cannot install TWRP. Chances are, if you don't already have TWRP installed, you cannot use TWRP.
+Our images are already patched with loki so just root and flash. You cannot flash TWRP with Odin on this model.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4canada.markdown b/_devices/samsunggalaxys4canada.markdown
index 8807f50..5423991 100644
--- a/_devices/samsunggalaxys4canada.markdown
+++ b/_devices/samsunggalaxys4canada.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Canada"
-codename: jfltecan
-downloadfolder: jfltecan
-oldurl: http://teamw.in/project/twrp2/175
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Canada"
+codename: jfltecan
+downloadfolder: jfltecan
+oldurl: http://teamw.in/project/twrp2/175
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4cricket.markdown b/_devices/samsunggalaxys4cricket.markdown
index db27f61..81d32f0 100644
--- a/_devices/samsunggalaxys4cricket.markdown
+++ b/_devices/samsunggalaxys4cricket.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Cricket"
-codename: jfltecri
-downloadfolder: jfltecri
-oldurl: http://teamw.in/project/twrp2/176
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Cricket"
+codename: jfltecri
+downloadfolder: jfltecri
+oldurl: http://teamw.in/project/twrp2/176
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4cspire.markdown b/_devices/samsunggalaxys4cspire.markdown
index 8de2ff0..445a499 100644
--- a/_devices/samsunggalaxys4cspire.markdown
+++ b/_devices/samsunggalaxys4cspire.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 C-Spire"
-codename: jfltespi
-downloadfolder: jfltespi
-oldurl: http://teamw.in/project/twrp2/177
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 C-Spire"
+codename: jfltespi
+downloadfolder: jfltespi
+oldurl: http://teamw.in/project/twrp2/177
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4googleedition.markdown b/_devices/samsunggalaxys4googleedition.markdown
index 79257de..aab7776 100644
--- a/_devices/samsunggalaxys4googleedition.markdown
+++ b/_devices/samsunggalaxys4googleedition.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Google Edition"
-codename: jgedlte
-downloadfolder: jgedlte
-oldurl: http://teamw.in/project/twrp2/192
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Google Edition"
+codename: jgedlte
+downloadfolder: jgedlte
+oldurl: http://teamw.in/project/twrp2/192
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4internationalexynos.markdown b/_devices/samsunggalaxys4internationalexynos.markdown
index 048360e..2c0645e 100644
--- a/_devices/samsunggalaxys4internationalexynos.markdown
+++ b/_devices/samsunggalaxys4internationalexynos.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 International Exynos"
-codename: i9500
-downloadfolder: i9500
-oldurl: http://teamw.in/project/twrp2/191
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p10"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 International Exynos"
+codename: i9500
+downloadfolder: i9500
+oldurl: http://teamw.in/project/twrp2/191
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p10"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4internationalqualcomm.markdown b/_devices/samsunggalaxys4internationalqualcomm.markdown
index 71e3119..55d5490 100644
--- a/_devices/samsunggalaxys4internationalqualcomm.markdown
+++ b/_devices/samsunggalaxys4internationalqualcomm.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S4 International Qualcomm"
-codename: jfltexx
-downloadfolder: jfltexx
-oldurl: http://teamw.in/project/twrp2/182
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
-devicetree: "https://github.com/TeamWin/android_device_samsung_jfltexx"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 International Qualcomm"
+codename: jfltexx
+downloadfolder: jfltexx
+oldurl: http://teamw.in/project/twrp2/182
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+devicetree: "https://github.com/TeamWin/android_device_samsung_jfltexx"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4ltea.markdown b/_devices/samsunggalaxys4ltea.markdown
index 764a3a5..d5edcc6 100644
--- a/_devices/samsunggalaxys4ltea.markdown
+++ b/_devices/samsunggalaxys4ltea.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy S4 LTE Advanced i9506"
-codename: ks01lte
-downloadfolder: ks01lte
-supportstatus: Current
-maintainer: mikeioannina
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 LTE Advanced i9506"
+codename: ks01lte
+downloadfolder: ks01lte
+supportstatus: Current
+maintainer: mikeioannina
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4mini64bit.markdown b/_devices/samsunggalaxys4mini64bit.markdown
index 5f7d9a5..f0132c0 100644
--- a/_devices/samsunggalaxys4mini64bit.markdown
+++ b/_devices/samsunggalaxys4mini64bit.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Mini 64 bit ONLY"
-codename: serranoveltexx
-downloadfolder: serranoveltexx
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/soc.0/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_serranoveltexx"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Mini 64 bit ONLY"
+codename: serranoveltexx
+downloadfolder: serranoveltexx
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/soc.0/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_serranoveltexx"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4miniuscellular.markdown b/_devices/samsunggalaxys4miniuscellular.markdown
index c566b5e..c4de882 100644
--- a/_devices/samsunggalaxys4miniuscellular.markdown
+++ b/_devices/samsunggalaxys4miniuscellular.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Mini US Cellular"
-codename: serranolteusc
-downloadfolder: serranolteusc
-supportstatus: Current
-maintainer: jason972000
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_samsung_serranolteusc"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Mini US Cellular"
+codename: serranolteusc
+downloadfolder: serranolteusc
+supportstatus: Current
+maintainer: jason972000
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_serranolteusc"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4sprint.markdown b/_devices/samsunggalaxys4sprint.markdown
index f9ffbb2..c12089c 100644
--- a/_devices/samsunggalaxys4sprint.markdown
+++ b/_devices/samsunggalaxys4sprint.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Sprint"
-codename: jfltespr
-downloadfolder: jfltespr
-oldurl: http://teamw.in/project/twrp2/178
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2262999"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Sprint"
+codename: jfltespr
+downloadfolder: jfltespr
+oldurl: http://teamw.in/project/twrp2/178
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2262999"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4tmobile.markdown b/_devices/samsunggalaxys4tmobile.markdown
index 086caa0..eb490b1 100644
--- a/_devices/samsunggalaxys4tmobile.markdown
+++ b/_devices/samsunggalaxys4tmobile.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S4 T-Mobile"
-codename: jfltetmo
-downloadfolder: jfltetmo
-oldurl: http://teamw.in/project/twrp2/179
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2263001"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 T-Mobile"
+codename: jfltetmo
+downloadfolder: jfltetmo
+oldurl: http://teamw.in/project/twrp2/179
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2263001"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4uscellular.markdown b/_devices/samsunggalaxys4uscellular.markdown
index 11f7272..82fa630 100644
--- a/_devices/samsunggalaxys4uscellular.markdown
+++ b/_devices/samsunggalaxys4uscellular.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy S4 US Cellular"
-codename: jflteusc
-downloadfolder: jflteusc
-oldurl: http://teamw.in/project/twrp2/180
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 US Cellular"
+codename: jflteusc
+downloadfolder: jflteusc
+oldurl: http://teamw.in/project/twrp2/180
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys4verizon.markdown b/_devices/samsunggalaxys4verizon.markdown
index f2b3d5f..d32349b 100644
--- a/_devices/samsunggalaxys4verizon.markdown
+++ b/_devices/samsunggalaxys4verizon.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S4 Verizon"
-codename: jfltevzw
-downloadfolder: jfltevzw
-oldurl: http://teamw.in/project/twrp2/181
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p21"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2292565"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-Only the earliest S4 for Verizon has a bootloader that is vulnerable to loki. If you took any updates or bought your device later on, you cannot install TWRP. Chances are, if you don't already have TWRP installed, you cannot use TWRP.
-Our images are already patched with loki so just root and flash. You cannot flash TWRP with Odin on this model.
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S4 Verizon"
+codename: jfltevzw
+downloadfolder: jfltevzw
+oldurl: http://teamw.in/project/twrp2/181
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p21"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2292565"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Only the earliest S4 for Verizon has a bootloader that is vulnerable to loki. If you took any updates or bought your device later on, you cannot install TWRP. Chances are, if you don't already have TWRP installed, you cannot use TWRP.
+Our images are already patched with loki so just root and flash. You cannot flash TWRP with Odin on this model.
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys5neoexynos.markdown b/_devices/samsunggalaxys5neoexynos.markdown
index 5c7d374..a43cc6e 100644
--- a/_devices/samsunggalaxys5neoexynos.markdown
+++ b/_devices/samsunggalaxys5neoexynos.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy S5 Neo Exynos"
-codename: s5neolte
-downloadfolder: s5neolte
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/13540000.dwmmc0/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S5 Neo Exynos"
+codename: s5neolte
+downloadfolder: s5neolte
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/13540000.dwmmc0/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys5plus.markdown b/_devices/samsunggalaxys5plus.markdown
index 35dee91..50aa3f7 100644
--- a/_devices/samsunggalaxys5plus.markdown
+++ b/_devices/samsunggalaxys5plus.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy S5 Plus"
-codename: kccat6
-downloadfolder: kccat6
-supportstatus: Current
-maintainer: jcadduono
-devicetree: "https://github.com/TeamWin/android_device_samsung_kccat6"
-xdathread: "http://forum.xda-developers.com/galaxy-s5/orig-development/recovery-team-win-recovery-project-t3350160"
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S5 Plus"
+codename: kccat6
+downloadfolder: kccat6
+supportstatus: Current
+maintainer: jcadduono
+devicetree: "https://github.com/TeamWin/android_device_samsung_kccat6"
+xdathread: "http://forum.xda-developers.com/galaxy-s5/orig-development/recovery-team-win-recovery-project-t3350160"
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys5qualcomm.markdown b/_devices/samsunggalaxys5qualcomm.markdown
index 0b2e4f9..9f2de97 100644
--- a/_devices/samsunggalaxys5qualcomm.markdown
+++ b/_devices/samsunggalaxys5qualcomm.markdown
@@ -1,78 +1,78 @@
----
-layout: device
-title: "Samsung Galaxy S5 Qualcomm"
-codename: klte
-downloadfolder: klte
-oldurl: http://teamw.in/project/twrp2/229
-supportstatus: Current
-maintainer: jcadduono
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_klte"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2727406"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">International, Americas, and Oceanic (SM-G900F, SM-G900W8, SM-G900T, SM-G900M, SM-G900P, SM-G900V, SM-G900I):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}klte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">International Duos (SM-G900FD):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}klteduos">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">China &amp; China Duos (SM-G9006V, SM-G9008V, SM-G9006W, SM-G9008W, SM-G9009W):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}kltechn">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Japan (SCL23, SC-04F):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}kltekdi">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-G900K, SM-G900L, SM-G900S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}klteskt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Samsung Galaxy S5 Qualcomm"
+codename: klte
+downloadfolder: klte
+oldurl: http://teamw.in/project/twrp2/229
+supportstatus: Current
+maintainer: jcadduono
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_klte"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2727406"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">International, Americas, and Oceanic (SM-G900F, SM-G900W8, SM-G900T, SM-G900M, SM-G900P, SM-G900V, SM-G900I):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}klte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">International Duos (SM-G900FD):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}klteduos">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">China &amp; China Duos (SM-G9006V, SM-G9008V, SM-G9006W, SM-G9008W, SM-G9009W):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}kltechn">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Japan (SCL23, SC-04F):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}kltekdi">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-G900K, SM-G900L, SM-G900S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}klteskt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys6.markdown b/_devices/samsunggalaxys6.markdown
index 5661f8b..90026c6 100644
--- a/_devices/samsunggalaxys6.markdown
+++ b/_devices/samsunggalaxys6.markdown
@@ -1,99 +1,99 @@
----
-layout: device
-title: "Samsung Galaxy S6"
-codename: zeroflte
-downloadfolder: zeroflte
-supportstatus: Current
-maintainer: "jcadduono, bigbiff"
-oem: Samsung
-ddof: "/dev/block/platform/15570000.ufs/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_zeroflte"
-xdathread: "http://forum.xda-developers.com/galaxy-s6/orig-development/twrp-t3080940"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include dmverity.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">International GSM (SM-G920F, SM-G920FD, SM-G920I):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroflte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Canada (SM-G920W8):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerofltecan">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">T-Mobile (SM-G920T):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerofltetmo">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Sprint (SM-G920P):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerofltespr">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">US Cellular (SM-G920R4):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroflteusc">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">China &amp; China Duos (SM-G9200, SM-G9208, SM-G9209):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerofltezt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-G920K, SM-G920L, SM-G920S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroflteskt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Samsung Galaxy S6"
+codename: zeroflte
+downloadfolder: zeroflte
+supportstatus: Current
+maintainer: "jcadduono, bigbiff"
+oem: Samsung
+ddof: "/dev/block/platform/15570000.ufs/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_zeroflte"
+xdathread: "http://forum.xda-developers.com/galaxy-s6/orig-development/twrp-t3080940"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">International GSM (SM-G920F, SM-G920FD, SM-G920I):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroflte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Canada (SM-G920W8):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerofltecan">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">T-Mobile (SM-G920T):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerofltetmo">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Sprint (SM-G920P):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerofltespr">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">US Cellular (SM-G920R4):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroflteusc">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">China &amp; China Duos (SM-G9200, SM-G9208, SM-G9209):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerofltezt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-G920K, SM-G920L, SM-G920S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroflteskt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys6edge.markdown b/_devices/samsunggalaxys6edge.markdown
index 909fffb..53c7c66 100644
--- a/_devices/samsunggalaxys6edge.markdown
+++ b/_devices/samsunggalaxys6edge.markdown
@@ -1,99 +1,99 @@
----
-layout: device
-title: "Samsung Galaxy S6 edge"
-codename: zerolte
-downloadfolder: zerolte
-supportstatus: Current
-maintainer: "jcadduono, bigbiff"
-oem: Samsung
-ddof: "/dev/block/platform/15570000.ufs/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_zerolte"
-xdathread: "http://forum.xda-developers.com/galaxy-s6-edge/orig-development/recovery-official-twrp-galaxy-s6-edge-t3354508"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include dmverity.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">International GSM (SM-G925F, SM-G925FD, SM-G925I):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerolte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Canada (SM-G925W8):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroltecan">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">T-Mobile (SM-G925T):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroltetmo">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Sprint (SM-G925P):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroltespr">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">US Cellular (SM-G925R4):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerolteusc">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">China (SM-G9250):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zeroltezt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-G925K, SM-G925L, SM-G925S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zerolteskt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Samsung Galaxy S6 edge"
+codename: zerolte
+downloadfolder: zerolte
+supportstatus: Current
+maintainer: "jcadduono, bigbiff"
+oem: Samsung
+ddof: "/dev/block/platform/15570000.ufs/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_zerolte"
+xdathread: "http://forum.xda-developers.com/galaxy-s6-edge/orig-development/recovery-official-twrp-galaxy-s6-edge-t3354508"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">International GSM (SM-G925F, SM-G925FD, SM-G925I):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerolte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Canada (SM-G925W8):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroltecan">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">T-Mobile (SM-G925T):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroltetmo">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Sprint (SM-G925P):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroltespr">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">US Cellular (SM-G925R4):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerolteusc">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">China (SM-G9250):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zeroltezt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-G925K, SM-G925L, SM-G925S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zerolteskt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys6edgeplus.markdown b/_devices/samsunggalaxys6edgeplus.markdown
index 2c3b19d..e2dd954 100644
--- a/_devices/samsunggalaxys6edgeplus.markdown
+++ b/_devices/samsunggalaxys6edgeplus.markdown
@@ -1,99 +1,99 @@
----
-layout: device
-title: "Samsung Galaxy S6 edge+"
-codename: zenlte
-downloadfolder: zenlte
-supportstatus: Current
-maintainer: "jcadduono"
-oem: Samsung
-ddof: "/dev/block/platform/15570000.ufs/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_zenlte"
-xdathread: "http://forum.xda-developers.com/s6-edge-plus/orig-development/recovery-official-twrp-galaxy-s6-edge-t3354492"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include dmverity.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">International GSM (SM-G928F, SM-G928FD, SM-G928G, SM-G928I):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenlte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Canada (SM-G928W8):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenltecan">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">T-Mobile (SM-G928T):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenltetmo">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Sprint (SM-G928P):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenltespr">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">US Cellular (SM-G928R4):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenlteusc">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">China &amp; China Duos (SM-G9280, SM-G9287, SM-G9287C):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenltezt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-G928K, SM-G928L, SM-G928S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}zenlteskt">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Samsung Galaxy S6 edge+"
+codename: zenlte
+downloadfolder: zenlte
+supportstatus: Current
+maintainer: "jcadduono"
+oem: Samsung
+ddof: "/dev/block/platform/15570000.ufs/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin?utf8=%E2%9C%93&query=android_device_samsung_zenlte"
+xdathread: "http://forum.xda-developers.com/s6-edge-plus/orig-development/recovery-official-twrp-galaxy-s6-edge-t3354492"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">International GSM (SM-G928F, SM-G928FD, SM-G928G, SM-G928I):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenlte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Canada (SM-G928W8):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenltecan">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">T-Mobile (SM-G928T):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenltetmo">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Sprint (SM-G928P):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenltespr">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">US Cellular (SM-G928R4):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenlteusc">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">China &amp; China Duos (SM-G9280, SM-G9287, SM-G9287C):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenltezt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-G928K, SM-G928L, SM-G928S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}zenlteskt">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys7.markdown b/_devices/samsunggalaxys7.markdown
index 75a5469..5867672 100644
--- a/_devices/samsunggalaxys7.markdown
+++ b/_devices/samsunggalaxys7.markdown
@@ -1,49 +1,49 @@
----
-layout: device
-title: "Samsung Galaxy S7 (Exynos)"
-codename: herolte
-downloadfolder: herolte
-supportstatus: Current
-maintainer: jcadduono
-devicetree: "https://github.com/TeamWin/android_device_samsung_herolte"
-xdathread: "http://forum.xda-developers.com/galaxy-s7/development/recovery-official-twrp-herolte-t3333770"
-oem: Samsung
-ddof: "/dev/block/platform/155a0000.ufs/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include dmverity.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">International &amp; Canada (SM-G930F, SM-G930FD, SM-G930X, SM-G930W8):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}herolte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-G930K, SM-G930L, SM-G930S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}heroltekor">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Samsung Galaxy S7 (Exynos)"
+codename: herolte
+downloadfolder: herolte
+supportstatus: Current
+maintainer: jcadduono
+devicetree: "https://github.com/TeamWin/android_device_samsung_herolte"
+xdathread: "http://forum.xda-developers.com/galaxy-s7/development/recovery-official-twrp-herolte-t3333770"
+oem: Samsung
+ddof: "/dev/block/platform/155a0000.ufs/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">International &amp; Canada (SM-G930F, SM-G930FD, SM-G930X, SM-G930W8):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}herolte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-G930K, SM-G930L, SM-G930S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}heroltekor">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxys7edge.markdown b/_devices/samsunggalaxys7edge.markdown
index 0cc7c65..6926a4f 100644
--- a/_devices/samsunggalaxys7edge.markdown
+++ b/_devices/samsunggalaxys7edge.markdown
@@ -1,49 +1,49 @@
----
-layout: device
-title: "Samsung Galaxy S7 edge (Exynos)"
-codename: hero2lte
-downloadfolder: hero2lte
-supportstatus: Current
-maintainer: jcadduono
-devicetree: "https://github.com/TeamWin/android_device_samsung_hero2lte"
-xdathread: "http://forum.xda-developers.com/s7-edge/development/recovery-official-twrp-hero2lte-3-0-0-0-t3334084"
-oem: Samsung
-ddof: "/dev/block/platform/155a0000.ufs/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include dmverity.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">International &amp; Canada (SM-G935F, SM-G935FD, SM-G935X, SM-G935W8):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hero2lte">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">Korea (SM-G935K, SM-G935L, SM-G935S):</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}hero2ltekor">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Samsung Galaxy S7 edge (Exynos)"
+codename: hero2lte
+downloadfolder: hero2lte
+supportstatus: Current
+maintainer: jcadduono
+devicetree: "https://github.com/TeamWin/android_device_samsung_hero2lte"
+xdathread: "http://forum.xda-developers.com/s7-edge/development/recovery-official-twrp-hero2lte-3-0-0-0-t3334084"
+oem: Samsung
+ddof: "/dev/block/platform/155a0000.ufs/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">International &amp; Canada (SM-G935F, SM-G935FD, SM-G935X, SM-G935W8):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hero2lte">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">Korea (SM-G935K, SM-G935L, SM-G935S):</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}hero2ltekor">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxysblaze4g.markdown b/_devices/samsunggalaxysblaze4g.markdown
index 4206d88..8e2d57b 100644
--- a/_devices/samsunggalaxysblaze4g.markdown
+++ b/_devices/samsunggalaxysblaze4g.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Samsung Galaxy S Blaze 4G"
-codename: SGH-T769
-downloadfolder: t769
-supportstatus: Current
-maintainer: javelinanddart
-oem: Samsung
-devicetree: https://github.com/TeamWin/android_device_samsung_t769
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy S Blaze 4G"
+codename: SGH-T769
+downloadfolder: t769
+supportstatus: Current
+maintainer: javelinanddart
+oem: Samsung
+devicetree: https://github.com/TeamWin/android_device_samsung_t769
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
diff --git a/_devices/samsunggalaxystarpro.markdown b/_devices/samsunggalaxystarpro.markdown
index 4d8061b..83b5459 100644
--- a/_devices/samsunggalaxystarpro.markdown
+++ b/_devices/samsunggalaxystarpro.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Star Pro"
-codename: logan2g
-downloadfolder: logan2g
-supportstatus: Current
-maintainer: FireLord
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Star Pro"
+codename: logan2g
+downloadfolder: logan2g
+supportstatus: Current
+maintainer: FireLord
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxystellar4g.markdown b/_devices/samsunggalaxystellar4g.markdown
index ac411d5..9d71faa 100644
--- a/_devices/samsunggalaxystellar4g.markdown
+++ b/_devices/samsunggalaxystellar4g.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Stellar 4G (SCH-i200 Verizon)"
-codename: jaspervzw
-downloadfolder: jaspervzw
-oldurl: http://teamw.in/project/twrp2/122
-supportstatus: No Longer Updated
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/mmcblk0p18"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Stellar 4G (SCH-i200 Verizon)"
+codename: jaspervzw
+downloadfolder: jaspervzw
+oldurl: http://teamw.in/project/twrp2/122
+supportstatus: No Longer Updated
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/mmcblk0p18"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab2101.markdown b/_devices/samsunggalaxytab2101.markdown
index ed7c70b..6379eb1 100644
--- a/_devices/samsunggalaxytab2101.markdown
+++ b/_devices/samsunggalaxytab2101.markdown
@@ -1,47 +1,47 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 2 10.1"
-codename: p5100
-downloadfolder: p5100
-oldurl: http://teamw.in/project/twrp2/283
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/omnirom/android_device_samsung_p5100"
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">p5100:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}p5100">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">p5110:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}p5110">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 2 10.1"
+codename: p5100
+downloadfolder: p5100
+oldurl: http://teamw.in/project/twrp2/283
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/omnirom/android_device_samsung_p5100"
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">p5100:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}p5100">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">p5110:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}p5110">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab270.markdown b/_devices/samsunggalaxytab270.markdown
index e8d1198..20082b1 100644
--- a/_devices/samsunggalaxytab270.markdown
+++ b/_devices/samsunggalaxytab270.markdown
@@ -1,47 +1,47 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 2 7.0"
-codename: p3100
-downloadfolder: p3100
-oldurl: http://teamw.in/project/twrp2/283
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/omnirom/android_device_samsung_p3100"
-ddof: "/dev/block/mmcblk0p6"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">p3100:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}p3100">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">p3110:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}p3110">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 2 7.0"
+codename: p3100
+downloadfolder: p3100
+oldurl: http://teamw.in/project/twrp2/283
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/omnirom/android_device_samsung_p3100"
+ddof: "/dev/block/mmcblk0p6"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">p3100:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}p3100">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">p3110:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}p3110">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab370lte.markdown b/_devices/samsunggalaxytab370lte.markdown
index b82965c..0001144 100644
--- a/_devices/samsunggalaxytab370lte.markdown
+++ b/_devices/samsunggalaxytab370lte.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 3 7.0 LTE"
-codename: lt02ltetmo
-downloadfolder: lt02ltetmo
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-devicetree: "https://github.com/TeamWin/device_samsung_lt02ltetmo"
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 3 7.0 LTE"
+codename: lt02ltetmo
+downloadfolder: lt02ltetmo
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+devicetree: "https://github.com/TeamWin/device_samsung_lt02ltetmo"
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab3lite703g.markdown b/_devices/samsunggalaxytab3lite703g.markdown
index 2d4e4c6..a3fe8a7 100644
--- a/_devices/samsunggalaxytab3lite703g.markdown
+++ b/_devices/samsunggalaxytab3lite703g.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 3 Lite 7.0 3G"
-codename: goyave
-downloadfolder: goyave
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-devicetree: "https://github.com/TeamWin/device_samsung_goyave"
-ddof: "/dev/block/platform/sprd-sdhci.3/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 3 Lite 7.0 3G"
+codename: goyave
+downloadfolder: goyave
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+devicetree: "https://github.com/TeamWin/device_samsung_goyave"
+ddof: "/dev/block/platform/sprd-sdhci.3/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab4101.markdown b/_devices/samsunggalaxytab4101.markdown
index cf5403b..6e10f51 100644
--- a/_devices/samsunggalaxytab4101.markdown
+++ b/_devices/samsunggalaxytab4101.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 4 10.1 (all variants)"
-codename: matisse
-downloadfolder: matisse
-supportstatus: Current
-maintainer: sub77
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 4 10.1 (all variants)"
+codename: matisse
+downloadfolder: matisse
+supportstatus: Current
+maintainer: sub77
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab470.markdown b/_devices/samsunggalaxytab470.markdown
index e4a4e32..0052d7b 100644
--- a/_devices/samsunggalaxytab470.markdown
+++ b/_devices/samsunggalaxytab470.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 4 7.0"
-codename: degas
-downloadfolder: degas
-oldurl: http://teamw.in/project/twrp2/248
-supportstatus: Current
-maintainer: None
-oem: Samsung
-ddof: "dev/block/platform/soc.2/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 4 7.0"
+codename: degas
+downloadfolder: degas
+oldurl: http://teamw.in/project/twrp2/248
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "dev/block/platform/soc.2/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytab77.markdown b/_devices/samsunggalaxytab77.markdown
index b4c0068..9629aa0 100644
--- a/_devices/samsunggalaxytab77.markdown
+++ b/_devices/samsunggalaxytab77.markdown
@@ -1,55 +1,55 @@
----
-layout: device
-title:  "Samsung Galaxy Tab 7.7"
-codename: p6810
-downloadfolder: degas
-oldurl: http://teamw.in/project/twrp2/108
-supportstatus: Current
-maintainer: None
-oem: Samsung
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-<div class='page-heading'>Download Links:</div>
-<hr />
-<p class="text">i815:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}i815">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">p6800:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}p6800">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-<p class="text">p6810:</p>
-<ul>
-{% for mirror in site.data.mirrors %}
-  <li>
-    <a href="{{ mirror.baseurl }}p6810">
-      {{ mirror.description }}
-    </a>
-  </li>
-{% endfor %}
-</ul>
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab 7.7"
+codename: p6810
+downloadfolder: degas
+oldurl: http://teamw.in/project/twrp2/108
+supportstatus: Current
+maintainer: None
+oem: Samsung
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">i815:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}i815">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">p6800:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}p6800">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+<p class="text">p6810:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}p6810">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytaba80lte.markdown b/_devices/samsunggalaxytaba80lte.markdown
index 52c3d87..09fc2e0 100644
--- a/_devices/samsunggalaxytaba80lte.markdown
+++ b/_devices/samsunggalaxytaba80lte.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Tab A 8.0 LTE SM-A800i"
-codename: a8hplte
-downloadfolder: a8hplte
-supportstatus: Current
-maintainer: Grace5921
-oem: Samsung
-ddof: "/dev/block/mmcblk0p10"
-devicetree: "https://github.com/TeamWin/android_device_samsung_a8hplte"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab A 8.0 LTE SM-A800i"
+codename: a8hplte
+downloadfolder: a8hplte
+supportstatus: Current
+maintainer: Grace5921
+oem: Samsung
+ddof: "/dev/block/mmcblk0p10"
+devicetree: "https://github.com/TeamWin/android_device_samsung_a8hplte"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabpro101exynoswifi.markdown b/_devices/samsunggalaxytabpro101exynoswifi.markdown
index 0c98f62..39ae906 100644
--- a/_devices/samsunggalaxytabpro101exynoswifi.markdown
+++ b/_devices/samsunggalaxytabpro101exynoswifi.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Tab Pro 10.1 Wi-Fi"
-codename: picassowifi
-downloadfolder: picassowifi
-oldurl: http://teamw.in/project/twrp2/253
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/TeamWin/android_device_samsung_picassowifi"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab Pro 10.1 Wi-Fi"
+codename: picassowifi
+downloadfolder: picassowifi
+oldurl: http://teamw.in/project/twrp2/253
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/TeamWin/android_device_samsung_picassowifi"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabpro101lte.markdown b/_devices/samsunggalaxytabpro101lte.markdown
index d117668..efa6123 100644
--- a/_devices/samsunggalaxytabpro101lte.markdown
+++ b/_devices/samsunggalaxytabpro101lte.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Tab Pro 10.1 LTE"
-codename: picassoltexx
-downloadfolder: picassoltexx
-oldurl: http://teamw.in/project/twrp2/230
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/TeamWin/android_device_samsung_picassoltexx"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab Pro 10.1 LTE"
+codename: picassoltexx
+downloadfolder: picassoltexx
+oldurl: http://teamw.in/project/twrp2/230
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/TeamWin/android_device_samsung_picassoltexx"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabpro122exynoswifi.markdown b/_devices/samsunggalaxytabpro122exynoswifi.markdown
index 46e5c9f..a85ba9e 100644
--- a/_devices/samsunggalaxytabpro122exynoswifi.markdown
+++ b/_devices/samsunggalaxytabpro122exynoswifi.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Tab Pro 12.2 Wi-Fi"
-codename: v2wifixx
-downloadfolder: v2wifixx
-oldurl: http://teamw.in/project/twrp2/244
-supportstatus: Current
-maintainer: None
-oem: Samsung
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab Pro 12.2 Wi-Fi"
+codename: v2wifixx
+downloadfolder: v2wifixx
+oldurl: http://teamw.in/project/twrp2/244
+supportstatus: Current
+maintainer: None
+oem: Samsung
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabpro8.4exynoswifi.markdown b/_devices/samsunggalaxytabpro8.4exynoswifi.markdown
index dd62765..90b4a46 100644
--- a/_devices/samsunggalaxytabpro8.4exynoswifi.markdown
+++ b/_devices/samsunggalaxytabpro8.4exynoswifi.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Tab Pro 8.4 Wi-Fi"
-codename: mondrianwifiue
-downloadfolder: mondrianwifiue
-oldurl: http://teamw.in/project/twrp2/220
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/TeamWin/android_device_samsung_mondrianwifiue"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab Pro 8.4 Wi-Fi"
+codename: mondrianwifiue
+downloadfolder: mondrianwifiue
+oldurl: http://teamw.in/project/twrp2/220
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/TeamWin/android_device_samsung_mondrianwifiue"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabpro8.4lte.markdown b/_devices/samsunggalaxytabpro8.4lte.markdown
index c6a0582..2d5023f 100644
--- a/_devices/samsunggalaxytabpro8.4lte.markdown
+++ b/_devices/samsunggalaxytabpro8.4lte.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Tab Pro 8.4 LTE"
-codename: mondrianlte
-downloadfolder: mondrianlte
-oldurl: http://teamw.in/project/twrp2/222
-supportstatus: Current
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/TeamWin/android_device_samsung_mondrianlte"
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab Pro 8.4 LTE"
+codename: mondrianlte
+downloadfolder: mondrianlte
+oldurl: http://teamw.in/project/twrp2/222
+supportstatus: Current
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/TeamWin/android_device_samsung_mondrianlte"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2679825"
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabs105.markdown b/_devices/samsunggalaxytabs105.markdown
index 1096dbd..36c1024 100644
--- a/_devices/samsunggalaxytabs105.markdown
+++ b/_devices/samsunggalaxytabs105.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Tab S 10.5 Wi-Fi"
-codename: chagallwifi
-downloadfolder: chagallwifi
-oldurl: http://teamw.in/project/twrp2/239
-supportstatus: Current
-maintainer: deadman96385
-oem: Samsung
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_chagallwifi"
-xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab S 10.5 Wi-Fi"
+codename: chagallwifi
+downloadfolder: chagallwifi
+oldurl: http://teamw.in/project/twrp2/239
+supportstatus: Current
+maintainer: deadman96385
+oem: Samsung
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_chagallwifi"
+xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabs105lte.markdown b/_devices/samsunggalaxytabs105lte.markdown
index b7da7b4..f7a4ca7 100644
--- a/_devices/samsunggalaxytabs105lte.markdown
+++ b/_devices/samsunggalaxytabs105lte.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Tab S 10.5 LTE"
-codename: chagalllte
-downloadfolder: chagalllte
-supportstatus: Current
-maintainer: deadman96385
-oem: Samsung
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_chagalllte"
-xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab S 10.5 LTE"
+codename: chagalllte
+downloadfolder: chagalllte
+supportstatus: Current
+maintainer: deadman96385
+oem: Samsung
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_chagalllte"
+xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabs84.markdown b/_devices/samsunggalaxytabs84.markdown
index e31490b..0c5deb0 100644
--- a/_devices/samsunggalaxytabs84.markdown
+++ b/_devices/samsunggalaxytabs84.markdown
@@ -1,27 +1,27 @@
----
-layout: device
-title:  "Samsung Galaxy Tab S 8.4 Wi-Fi"
-codename: klimtwifi
-downloadfolder: klimtwifi
-oldurl: http://teamw.in/project/twrp2/238
-supportstatus: Current
-maintainer: deadman96385
-oem: Samsung
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_klimtwifi"
-xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab S 8.4 Wi-Fi"
+codename: klimtwifi
+downloadfolder: klimtwifi
+oldurl: http://teamw.in/project/twrp2/238
+supportstatus: Current
+maintainer: deadman96385
+oem: Samsung
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_klimtwifi"
+xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytabs84lte.markdown b/_devices/samsunggalaxytabs84lte.markdown
index 98aa065..b1dc077 100644
--- a/_devices/samsunggalaxytabs84lte.markdown
+++ b/_devices/samsunggalaxytabs84lte.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy Tab S 8.4 LTE"
-codename: klimtlte
-downloadfolder: klimtlte
-supportstatus: Current
-maintainer: deadman96385
-oem: Samsung
-ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_klimtlte"
-xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Tab S 8.4 LTE"
+codename: klimtlte
+downloadfolder: klimtlte
+supportstatus: Current
+maintainer: deadman96385
+oem: Samsung
+ddof: "/dev/block/platform/dw_mmc.0/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_klimtlte"
+xdathread: "http://forum.xda-developers.com/galaxy-tab-s/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2817100"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytrend.markdown b/_devices/samsunggalaxytrend.markdown
index ec87ac1..7361fcc 100644
--- a/_devices/samsunggalaxytrend.markdown
+++ b/_devices/samsunggalaxytrend.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Trend"
-codename: kyleve
-downloadfolder: kyleve
-supportstatus: Current
-maintainer: Grace5921
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
-devicetree: "https://github.com/TeamWin/device_samsung_kyleve"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Trend"
+codename: kyleve
+downloadfolder: kyleve
+supportstatus: Current
+maintainer: Grace5921
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+devicetree: "https://github.com/TeamWin/device_samsung_kyleve"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxytrendlite.markdown b/_devices/samsunggalaxytrendlite.markdown
index c5925f4..2810353 100644
--- a/_devices/samsunggalaxytrendlite.markdown
+++ b/_devices/samsunggalaxytrendlite.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Trend Lite"
-codename: kylevess
-downloadfolder: kylevess
-supportstatus: Current
-maintainer: Grace5921
-oem: Samsung
-ddof: "/dev/block/mmcblk0p6"
-devicetree: "https://github.com/TeamWin/device_samsung_kylevess"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Trend Lite"
+codename: kylevess
+downloadfolder: kylevess
+supportstatus: Current
+maintainer: Grace5921
+oem: Samsung
+ddof: "/dev/block/mmcblk0p6"
+devicetree: "https://github.com/TeamWin/device_samsung_kylevess"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyv.markdown b/_devices/samsunggalaxyv.markdown
index 99d87a3..b6e6276 100644
--- a/_devices/samsunggalaxyv.markdown
+++ b/_devices/samsunggalaxyv.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Samsung Galaxy V SM-G313HZ"
-codename: vivalto3gvn
-downloadfolder: vivalto3gvn
-supportstatus: Current
-maintainer: cleverior.ipul
-oem: Samsung
-ddof: "/dev/block/mmcblk0p12"
-devicetree: "https://github.com/TeamWin/android_device_samsung_vivalto3gvn"
-xdathread: "http://forum.xda-developers.com/ace-4/development/recovery-twrp-3-0-0-0-samsung-galaxy-t3311593"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy V SM-G313HZ"
+codename: vivalto3gvn
+downloadfolder: vivalto3gvn
+supportstatus: Current
+maintainer: cleverior.ipul
+oem: Samsung
+ddof: "/dev/block/mmcblk0p12"
+devicetree: "https://github.com/TeamWin/android_device_samsung_vivalto3gvn"
+xdathread: "http://forum.xda-developers.com/ace-4/development/recovery-twrp-3-0-0-0-samsung-galaxy-t3311593"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyvictory4glte.markdown b/_devices/samsunggalaxyvictory4glte.markdown
index adae9d1..e29354e 100644
--- a/_devices/samsunggalaxyvictory4glte.markdown
+++ b/_devices/samsunggalaxyvictory4glte.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Victory 4G LTE"
-codename: goghspr
-downloadfolder: goghspr
-oldurl: http://teamw.in/project/twrp2/165
-supportstatus: No Longer Updated
-maintainer: None
-oem: Samsung
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Victory 4G LTE"
+codename: goghspr
+downloadfolder: goghspr
+oldurl: http://teamw.in/project/twrp2/165
+supportstatus: No Longer Updated
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxyxcover3.markdown b/_devices/samsunggalaxyxcover3.markdown
index dab6494..f2184fc 100644
--- a/_devices/samsunggalaxyxcover3.markdown
+++ b/_devices/samsunggalaxyxcover3.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Samsung Galaxy Xcover 3"
-codename: xcover3ltexx
-downloadfolder: xcover3ltexx
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-ddof: "/dev/block/platform/soc.2/by-name/RECOVERY"
-devicetree: "https://github.com/TeamWin/android_device_samsung_xcover3ltexx"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include odininstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Samsung Galaxy Xcover 3"
+codename: xcover3ltexx
+downloadfolder: xcover3ltexx
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+ddof: "/dev/block/platform/soc.2/by-name/RECOVERY"
+devicetree: "https://github.com/TeamWin/android_device_samsung_xcover3ltexx"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggearlive.markdown b/_devices/samsunggearlive.markdown
index d1247fa..a0175f7 100644
--- a/_devices/samsunggearlive.markdown
+++ b/_devices/samsunggearlive.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Gear Live"
-codename: sprat
-downloadfolder: sprat
-oldurl: http://teamw.in/project/twrp2/243
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Samsung
-devicetree: "https://github.com/TeamWin/android_device_samsung_sprat"
-xdathread: "http://forum.xda-developers.com/gear-live/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2828336"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Gear Live"
+codename: sprat
+downloadfolder: sprat
+oldurl: http://teamw.in/project/twrp2/243
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Samsung
+devicetree: "https://github.com/TeamWin/android_device_samsung_sprat"
+xdathread: "http://forum.xda-developers.com/gear-live/orig-development/recovery-twrp-2-7-1-0-touch-recovery-t2828336"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/samsungnexus10.markdown b/_devices/samsungnexus10.markdown
index ab137de..6803706 100644
--- a/_devices/samsungnexus10.markdown
+++ b/_devices/samsungnexus10.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Samsung Nexus 10"
-codename: manta
-downloadfolder: manta
-oldurl: http://teamw.in/project/twrp2/128
-supportstatus: Current
-maintainer: Dees_Troy
-oem: HTC
-devicetree: https://github.com/TeamWin/device_samsung_manta
-xdathread: "http://forum.xda-developers.com/showthread.php?t=1997878"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Nexus 10"
+codename: manta
+downloadfolder: manta
+oldurl: http://teamw.in/project/twrp2/128
+supportstatus: Current
+maintainer: Dees_Troy
+oem: HTC
+devicetree: https://github.com/TeamWin/device_samsung_manta
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1997878"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/samsungnexuss.markdown b/_devices/samsungnexuss.markdown
index 07640b8..81cc787 100644
--- a/_devices/samsungnexuss.markdown
+++ b/_devices/samsungnexuss.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Samsung Nexus S"
-codename: crespo
-downloadfolder: crespo
-oldurl: http://teamw.in/project/twrp2/44
-supportstatus: No longer updated
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/TeamWin/device_samsung_crespo"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Nexus S"
+codename: crespo
+downloadfolder: crespo
+oldurl: http://teamw.in/project/twrp2/44
+supportstatus: No longer updated
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/TeamWin/device_samsung_crespo"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/samsungnexuss4g.markdown b/_devices/samsungnexuss4g.markdown
index 89a2a2a..5826923 100644
--- a/_devices/samsungnexuss4g.markdown
+++ b/_devices/samsungnexuss4g.markdown
@@ -1,23 +1,23 @@
----
-layout: device
-title:  "Samsung Nexus S 4G"
-codename: crespo4g
-downloadfolder: crespo4g
-oldurl: http://teamw.in/project/twrp2/74
-supportstatus: No longer updated
-maintainer: None
-oem: Samsung
-devicetree: "https://github.com/TeamWin/device_samsung_crespo4g"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Samsung Nexus S 4G"
+codename: crespo4g
+downloadfolder: crespo4g
+oldurl: http://teamw.in/project/twrp2/74
+supportstatus: No longer updated
+maintainer: None
+oem: Samsung
+devicetree: "https://github.com/TeamWin/device_samsung_crespo4g"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/silentcircleblackphone2.markdown b/_devices/silentcircleblackphone2.markdown
index c2ab34e..03c2bb0 100644
--- a/_devices/silentcircleblackphone2.markdown
+++ b/_devices/silentcircleblackphone2.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Silent Circle Blackphone 2"
-codename: bp2
-downloadfolder: bp2
-supportstatus: Current
-maintainer: None
-oem: Silent Circle
-devicetree: https://github.com/TeamWin/android_device_silentcircle_bp2
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Silent Circle Blackphone 2"
+codename: bp2
+downloadfolder: bp2
+supportstatus: Current
+maintainer: None
+oem: Silent Circle
+devicetree: https://github.com/TeamWin/android_device_silentcircle_bp2
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/sonyxperial.markdown b/_devices/sonyxperial.markdown
index bcc2a45..9134709 100644
--- a/_devices/sonyxperial.markdown
+++ b/_devices/sonyxperial.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Sony Xperia L"
-codename: taoshan
-downloadfolder: taoshan
-oldurl: http://teamw.in/project/twrp2/286
-supportstatus: Current
-maintainer: None
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia L"
+codename: taoshan
+downloadfolder: taoshan
+oldurl: http://teamw.in/project/twrp2/286
+supportstatus: Current
+maintainer: None
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiam.markdown b/_devices/sonyxperiam.markdown
index 830809c..76cc33e 100644
--- a/_devices/sonyxperiam.markdown
+++ b/_devices/sonyxperiam.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Sony Xperia M"
-codename: nicki
-downloadfolder: nicki
-supportstatus: Current
-maintainer: cucumber09
-oem: Sony
-devicetree: https://github.com/TeamWin/android_device_sony_nicki
-xdathread: http://forum.xda-developers.com/showthread.php?t=3147051
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia M"
+codename: nicki
+downloadfolder: nicki
+supportstatus: Current
+maintainer: cucumber09
+oem: Sony
+devicetree: https://github.com/TeamWin/android_device_sony_nicki
+xdathread: http://forum.xda-developers.com/showthread.php?t=3147051
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperias.markdown b/_devices/sonyxperias.markdown
index fdf8cb3..269b7a2 100644
--- a/_devices/sonyxperias.markdown
+++ b/_devices/sonyxperias.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Sony Xperia S"
-codename: nozomi
-downloadfolder: nozomi
-oldurl: http://teamw.in/project/twrp2/144
-supportstatus: Current
-maintainer: None
-oem: Sony
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2172060"
-ddof: /dev/block/mmcblk0p11
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia S"
+codename: nozomi
+downloadfolder: nozomi
+oldurl: http://teamw.in/project/twrp2/144
+supportstatus: Current
+maintainer: None
+oem: Sony
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2172060"
+ddof: /dev/block/mmcblk0p11
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiasp.markdown b/_devices/sonyxperiasp.markdown
index c1afeb4..a22826e 100644
--- a/_devices/sonyxperiasp.markdown
+++ b/_devices/sonyxperiasp.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Sony Xperia SP"
-codename: huashan
-downloadfolder: huashan
-supportstatus: Current
-maintainer: AdrianDC
-oem: Sony
-xdathread: "http://forum.xda-developers.com/showthread.php?t=3309938"
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia SP"
+codename: huashan
+downloadfolder: huashan
+supportstatus: Current
+maintainer: AdrianDC
+oem: Sony
+xdathread: "http://forum.xda-developers.com/showthread.php?t=3309938"
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiat.markdown b/_devices/sonyxperiat.markdown
index 5c36e9c..a1e2cdc 100644
--- a/_devices/sonyxperiat.markdown
+++ b/_devices/sonyxperiat.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Sony Xperia T"
-codename: mint
-downloadfolder: mint
-oldurl: http://teamw.in/project/twrp2/143
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Sony
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2115726"
-ddof: /dev/block/mmcblk0p11
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia T"
+codename: mint
+downloadfolder: mint
+oldurl: http://teamw.in/project/twrp2/143
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Sony
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2115726"
+ddof: /dev/block/mmcblk0p11
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiaz.markdown b/_devices/sonyxperiaz.markdown
index 5e3f715..2d5444f 100644
--- a/_devices/sonyxperiaz.markdown
+++ b/_devices/sonyxperiaz.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Sony Xperia Z"
-codename: yuga
-downloadfolder: yuga
-oldurl: http://teamw.in/project/twrp2/187
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z"
+codename: yuga
+downloadfolder: yuga
+oldurl: http://teamw.in/project/twrp2/187
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiaz1.markdown b/_devices/sonyxperiaz1.markdown
index c36a9e6..935ca6d 100644
--- a/_devices/sonyxperiaz1.markdown
+++ b/_devices/sonyxperiaz1.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Sony Xperia Z1"
-codename: honami
-downloadfolder: honami
-supportstatus: Current
-maintainer: sdtbarbarossa
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z1"
+codename: honami
+downloadfolder: honami
+supportstatus: Current
+maintainer: sdtbarbarossa
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiaz2.markdown b/_devices/sonyxperiaz2.markdown
index d4ec11e..da21fd0 100644
--- a/_devices/sonyxperiaz2.markdown
+++ b/_devices/sonyxperiaz2.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Sony Xperia Z2"
-codename: sirius
-downloadfolder: sirius
-oldurl: http://teamw.in/project/twrp2/232
-supportstatus: Current
-maintainer: None
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z2"
+codename: sirius
+downloadfolder: sirius
+oldurl: http://teamw.in/project/twrp2/232
+supportstatus: Current
+maintainer: None
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiaz3compact.markdown b/_devices/sonyxperiaz3compact.markdown
index 27bda82..b0e452c 100644
--- a/_devices/sonyxperiaz3compact.markdown
+++ b/_devices/sonyxperiaz3compact.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Sony Xperia Z3 Compact"
-codename: z3c
-downloadfolder: z3c
-supportstatus: Current
-maintainer: someone755
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z3 Compact"
+codename: z3c
+downloadfolder: z3c
+supportstatus: Current
+maintainer: someone755
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiaz3tabetcompact.markdown b/_devices/sonyxperiaz3tabetcompact.markdown
index c681a5f..903a75a 100644
--- a/_devices/sonyxperiaz3tabetcompact.markdown
+++ b/_devices/sonyxperiaz3tabetcompact.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Sony Xperia Z3 Tablet Compact Wi-Fi"
-codename: scorpion_windy
-downloadfolder: scorpion_windy
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z3 Tablet Compact Wi-Fi"
+codename: scorpion_windy
+downloadfolder: scorpion_windy
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiazl.markdown b/_devices/sonyxperiazl.markdown
index 995ebf0..3d50fe9 100644
--- a/_devices/sonyxperiazl.markdown
+++ b/_devices/sonyxperiazl.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Sony Xperia ZL"
-codename: odin
-downloadfolder: odin
-supportstatus: Current
-maintainer: humberos
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia ZL"
+codename: odin
+downloadfolder: odin
+supportstatus: Current
+maintainer: humberos
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiazr.markdown b/_devices/sonyxperiazr.markdown
index 780ec3a..3e2554c 100644
--- a/_devices/sonyxperiazr.markdown
+++ b/_devices/sonyxperiazr.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "Sony Xperia ZR"
-codename: dogo
-downloadfolder: dogo
-supportstatus: Current
-maintainer: Chippa-a
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia ZR"
+codename: dogo
+downloadfolder: dogo
+supportstatus: Current
+maintainer: Chippa-a
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiaztablet.markdown b/_devices/sonyxperiaztablet.markdown
index 741f0d0..837aba5 100644
--- a/_devices/sonyxperiaztablet.markdown
+++ b/_devices/sonyxperiaztablet.markdown
@@ -1,26 +1,26 @@
----
-layout: device
-title:  "Sony Xperia Z Tablet"
-codename: pollux_windy
-downloadfolder: pollux_windy
-oldurl: http://teamw.in/project/twrp2/185
-supportstatus: Current
-maintainer: Dees_Troy
-oem: Sony
-xdathread: "http://forum.xda-developers.com/showthread.php?t=2413289"
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z Tablet"
+codename: pollux_windy
+downloadfolder: pollux_windy
+oldurl: http://teamw.in/project/twrp2/185
+supportstatus: Current
+maintainer: Dees_Troy
+oem: Sony
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2413289"
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/sonyxperiazultra.markdown b/_devices/sonyxperiazultra.markdown
index 29f19f2..683956c 100644
--- a/_devices/sonyxperiazultra.markdown
+++ b/_devices/sonyxperiazultra.markdown
@@ -1,25 +1,25 @@
----
-layout: device
-title:  "Sony Xperia Z Ultra"
-codename: togari
-downloadfolder: togari
-oldurl: http://teamw.in/project/twrp2/219
-supportstatus: Current
-maintainer: None
-oem: Sony
-ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include fotakernelnote.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "Sony Xperia Z Ultra"
+codename: togari
+downloadfolder: togari
+oldurl: http://teamw.in/project/twrp2/219
+supportstatus: Current
+maintainer: None
+oem: Sony
+ddof: /dev/block/platform/msm_sdcc.1/by-name/FOTAKernel
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include fotakernelnote.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/xiaomimi22s.markdown b/_devices/xiaomimi22s.markdown
index 4910fb1..a708ad2 100644
--- a/_devices/xiaomimi22s.markdown
+++ b/_devices/xiaomimi22s.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Mi 2/2S"
-codename: aries
-downloadfolder: aries
-supportstatus: Current
-maintainer: juliusssssmiui
-oem: Xiaomi
-devicetree: https://github.com/TeamWin/android_device_xiaomi_aries
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Mi 2/2S"
+codename: aries
+downloadfolder: aries
+supportstatus: Current
+maintainer: juliusssssmiui
+oem: Xiaomi
+devicetree: https://github.com/TeamWin/android_device_xiaomi_aries
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomimi3.markdown b/_devices/xiaomimi3.markdown
index e738d19..b2b99f3 100644
--- a/_devices/xiaomimi3.markdown
+++ b/_devices/xiaomimi3.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Mi 3"
-codename: cancro
-downloadfolder: cancro
-oldurl: http://teamw.in/project/twrp2/288
-supportstatus: Current
-maintainer: None
-oem: Xiaomi
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Mi 3"
+codename: cancro
+downloadfolder: cancro
+oldurl: http://teamw.in/project/twrp2/288
+supportstatus: Current
+maintainer: None
+oem: Xiaomi
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomimi4c.markdown b/_devices/xiaomimi4c.markdown
index 34e69b5..2861da8 100644
--- a/_devices/xiaomimi4c.markdown
+++ b/_devices/xiaomimi4c.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Mi 4c"
-codename: libra
-downloadfolder: libra
-supportstatus: Current
-maintainer: juliusssssmiui
-oem: Xiaomi
-devicetree: https://github.com/TeamWin/android_device_xiaomi_libra
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Mi 4c"
+codename: libra
+downloadfolder: libra
+supportstatus: Current
+maintainer: juliusssssmiui
+oem: Xiaomi
+devicetree: https://github.com/TeamWin/android_device_xiaomi_libra
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomimi4i.markdown b/_devices/xiaomimi4i.markdown
index 65e1d40..3aea828 100644
--- a/_devices/xiaomimi4i.markdown
+++ b/_devices/xiaomimi4i.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Mi 4i"
-codename: ferrari
-downloadfolder: ferrari
-supportstatus: Current
-maintainer: juliusssssmiui
-oem: Xiaomi
-devicetree: https://github.com/TeamWin/android_device_xiaomi_ferrari
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Mi 4i"
+codename: ferrari
+downloadfolder: ferrari
+supportstatus: Current
+maintainer: juliusssssmiui
+oem: Xiaomi
+devicetree: https://github.com/TeamWin/android_device_xiaomi_ferrari
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomimipad.markdown b/_devices/xiaomimipad.markdown
index 937394f..599938f 100644
--- a/_devices/xiaomimipad.markdown
+++ b/_devices/xiaomimipad.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Mi Pad"
-codename: mocha
-downloadfolder: mocha
-supportstatus: Current
-maintainer: juliusssssmiui
-oem: Xiaomi
-devicetree: https://github.com/TeamWin/android_device_xiaomi_mocha
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Mi Pad"
+codename: mocha
+downloadfolder: mocha
+supportstatus: Current
+maintainer: juliusssssmiui
+oem: Xiaomi
+devicetree: https://github.com/TeamWin/android_device_xiaomi_mocha
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomiredmi1s.markdown b/_devices/xiaomiredmi1s.markdown
index e6027a1..e1296f7 100644
--- a/_devices/xiaomiredmi1s.markdown
+++ b/_devices/xiaomiredmi1s.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Redmi 1S"
-codename: armani
-downloadfolder: armani
-oldurl: http://teamw.in/project/twrp2/241
-supportstatus: Current
-maintainer: fefifofum
-oem: Xiaomi
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Redmi 1S"
+codename: armani
+downloadfolder: armani
+oldurl: http://teamw.in/project/twrp2/241
+supportstatus: Current
+maintainer: fefifofum
+oem: Xiaomi
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomiredminote2.markdown b/_devices/xiaomiredminote2.markdown
index b992d1a..b8c6656 100644
--- a/_devices/xiaomiredminote2.markdown
+++ b/_devices/xiaomiredminote2.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Xiaomi Redmi Note 2"
-codename: hermes
-downloadfolder: hermes
-supportstatus: Current
-maintainer: juliusssssmiui
-oem: Xiaomi
-devicetree: https://github.com/TeamWin/android_device_xiaomi_hermes
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Redmi Note 2"
+codename: hermes
+downloadfolder: hermes
+supportstatus: Current
+maintainer: juliusssssmiui
+oem: Xiaomi
+devicetree: https://github.com/TeamWin/android_device_xiaomi_hermes
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/xiaomiredminote3mtk.markdown b/_devices/xiaomiredminote3mtk.markdown
index ee128cb..ae11b32 100644
--- a/_devices/xiaomiredminote3mtk.markdown
+++ b/_devices/xiaomiredminote3mtk.markdown
@@ -1,28 +1,28 @@
----
-layout: device
-title: "Xiaomi Redmi Note 3 MTK"
-codename: hennessy
-downloadfolder: hennessy
-supportstatus: Current
-maintainer: HostZero
-oem: Xiaomi
-ddof: "/dev/block/platform/mtk-msdc.0/by-name/recovery"
-devicetree: "https://github.com/TeamWin/android_device_xiaomi_hennessy"
-xdathread: "http://forum.xda-developers.com/redmi-note-3/xiaomi-redmi-note-3-mediatek-roms-kernels-recoveries--other-development/official-twrp-redmi-note-3-mtk-t3395841"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include xiaomiunlock.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title: "Xiaomi Redmi Note 3 MTK"
+codename: hennessy
+downloadfolder: hennessy
+supportstatus: Current
+maintainer: HostZero
+oem: Xiaomi
+ddof: "/dev/block/platform/mtk-msdc.0/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_xiaomi_hennessy"
+xdathread: "http://forum.xda-developers.com/redmi-note-3/xiaomi-redmi-note-3-mediatek-roms-kernels-recoveries--other-development/official-twrp-redmi-note-3-mtk-t3395841"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include xiaomiunlock.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/xiaomiredminote4gsinglesim.markdown b/_devices/xiaomiredminote4gsinglesim.markdown
index 784d8e8..b081aa1 100644
--- a/_devices/xiaomiredminote4gsinglesim.markdown
+++ b/_devices/xiaomiredminote4gsinglesim.markdown
@@ -1,21 +1,21 @@
----
-layout: device
-title:  "Xiaomi Redmi Note 4G (Single SIM)"
-codename: dior
-downloadfolder: dior
-supportstatus: Current
-maintainer: myhellonearth
-oem: Xiaomi
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Xiaomi Redmi Note 4G (Single SIM)"
+codename: dior
+downloadfolder: dior
+supportstatus: Current
+maintainer: myhellonearth
+oem: Xiaomi
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/yuyureka.markdown b/_devices/yuyureka.markdown
index 3cf4bfe..5307f65 100644
--- a/_devices/yuyureka.markdown
+++ b/_devices/yuyureka.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Yu Yureka"
-codename: tomato
-downloadfolder: tomato
-oldurl: http://teamw.in/project/twrp2/284
-supportstatus: Current
-maintainer: Abhishek Aggarwal
-oem: Yu
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Yu Yureka"
+codename: tomato
+downloadfolder: tomato
+oldurl: http://teamw.in/project/twrp2/284
+supportstatus: Current
+maintainer: Abhishek Aggarwal
+oem: Yu
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/ztebladeapex2.markdown b/_devices/ztebladeapex2.markdown
index ec2496b..dc933ae 100644
--- a/_devices/ztebladeapex2.markdown
+++ b/_devices/ztebladeapex2.markdown
@@ -1,24 +1,24 @@
----
-layout: device
-title:  "ZTE Blade Apex 2"
-codename: P892E10
-downloadfolder: P892E10
-supportstatus: Current
-maintainer: None
-oem: ZTE
-devicetree: https://github.com/TeamWin/android_device_zte_P892E10
-ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
-#xdathread: "http://forum.xda-developers.com/g4/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3125859"
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include ddinstall.html %}
+---
+layout: device
+title:  "ZTE Blade Apex 2"
+codename: P892E10
+downloadfolder: P892E10
+supportstatus: Current
+maintainer: None
+oem: ZTE
+devicetree: https://github.com/TeamWin/android_device_zte_P892E10
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+#xdathread: "http://forum.xda-developers.com/g4/orig-development/recovery-twrp-2-8-6-0-touch-recovery-t3125859"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/zukz1.markdown b/_devices/zukz1.markdown
index a59a8e2..e393071 100644
--- a/_devices/zukz1.markdown
+++ b/_devices/zukz1.markdown
@@ -1,22 +1,22 @@
----
-layout: device
-title:  "Zuk Z1"
-codename: ham
-downloadfolder: Z1
-supportstatus: Current
-maintainer: juliusssssmiui
-oem: Zuk
-devicetree: https://github.com/TeamWin/android_device_zuk_Z1
----
-
-{% include disclaimer.html %}
-
-{% include supportstatus.html %}
-
-{% include appinstall.html %}
-
-{% include download.html %}
-
-{% include twrpinstall.html %}
-
-{% include fastbootinstall.html %}
+---
+layout: device
+title:  "Zuk Z1"
+codename: ham
+downloadfolder: Z1
+supportstatus: Current
+maintainer: juliusssssmiui
+oem: Zuk
+devicetree: https://github.com/TeamWin/android_device_zuk_Z1
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
