diff --git a/_devices/acericoniaa500.markdown b/_devices/acericoniaa500.markdown
new file mode 100644
index 0000000..473a8ac
--- /dev/null
+++ b/_devices/acericoniaa500.markdown
@@ -0,0 +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 %}
diff --git a/_devices/amazonkindlefire.markdown b/_devices/amazonkindlefire.markdown
new file mode 100644
index 0000000..6a6e399
--- /dev/null
+++ b/_devices/amazonkindlefire.markdown
@@ -0,0 +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 %}
diff --git a/_devices/amlogick200.markdown b/_devices/amlogick200.markdown
new file mode 100644
index 0000000..56683b1
--- /dev/null
+++ b/_devices/amlogick200.markdown
@@ -0,0 +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>
diff --git a/_devices/androidemulator.markdown b/_devices/androidemulator.markdown
new file mode 100644
index 0000000..d6947af
--- /dev/null
+++ b/_devices/androidemulator.markdown
@@ -0,0 +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>
diff --git a/_devices/androidone.markdown b/_devices/androidone.markdown
new file mode 100644
index 0000000..da95aa1
--- /dev/null
+++ b/_devices/androidone.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Android One"
+codename: sprout
+downloadfolder: sprout
+oldurl: http://teamw.in/project/twrp2/268
+supportstatus: Current
+maintainer: varunchitre15
+oem: Various MediaTek
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/asusTF300T.markdown b/_devices/asusTF300T.markdown
new file mode 100644
index 0000000..53ab0d6
--- /dev/null
+++ b/_devices/asusTF300T.markdown
@@ -0,0 +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>
+
+
diff --git a/_devices/asusnexus720123g.markdown b/_devices/asusnexus720123g.markdown
new file mode 100644
index 0000000..5be672a
--- /dev/null
+++ b/_devices/asusnexus720123g.markdown
@@ -0,0 +1,23 @@
+---
+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
+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
new file mode 100644
index 0000000..ac27916
--- /dev/null
+++ b/_devices/asusnexus72012wifi.markdown
@@ -0,0 +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_lge_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
new file mode 100644
index 0000000..92cdf5b
--- /dev/null
+++ b/_devices/asusnexus72013lte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/asusnexus72013wifi.markdown b/_devices/asusnexus72013wifi.markdown
new file mode 100644
index 0000000..76d6156
--- /dev/null
+++ b/_devices/asusnexus72013wifi.markdown
@@ -0,0 +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 %}
diff --git a/_devices/asuspadfone1.markdown b/_devices/asuspadfone1.markdown
new file mode 100644
index 0000000..9bf2d38
--- /dev/null
+++ b/_devices/asuspadfone1.markdown
@@ -0,0 +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 %}
diff --git a/_devices/asuspadfone2.markdown b/_devices/asuspadfone2.markdown
new file mode 100644
index 0000000..4df8720
--- /dev/null
+++ b/_devices/asuspadfone2.markdown
@@ -0,0 +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 %}
diff --git a/_devices/asustransformerTF101.markdown b/_devices/asustransformerTF101.markdown
new file mode 100644
index 0000000..5b9f187
--- /dev/null
+++ b/_devices/asustransformerTF101.markdown
@@ -0,0 +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 %}
diff --git a/_devices/asustransformerinfinityTF700T.markdown b/_devices/asustransformerinfinityTF700T.markdown
new file mode 100644
index 0000000..d38902c
--- /dev/null
+++ b/_devices/asustransformerinfinityTF700T.markdown
@@ -0,0 +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>
diff --git a/_devices/asustransformerprimeTF201.markdown b/_devices/asustransformerprimeTF201.markdown
new file mode 100644
index 0000000..b155c16
--- /dev/null
+++ b/_devices/asustransformerprimeTF201.markdown
@@ -0,0 +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>
+
+
diff --git a/_devices/barnesnoblenookcolor.markdown b/_devices/barnesnoblenookcolor.markdown
new file mode 100644
index 0000000..742eb97
--- /dev/null
+++ b/_devices/barnesnoblenookcolor.markdown
@@ -0,0 +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.
diff --git a/_devices/barnesnoblenooktablet.markdown b/_devices/barnesnoblenooktablet.markdown
new file mode 100644
index 0000000..a425e03
--- /dev/null
+++ b/_devices/barnesnoblenooktablet.markdown
@@ -0,0 +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>
diff --git a/_devices/bqaquarisee54g.markdown b/_devices/bqaquarisee54g.markdown
new file mode 100644
index 0000000..7173884
--- /dev/null
+++ b/_devices/bqaquarisee54g.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "BQ Aquaris E5 4G"
+codename: vegetalte
+downloadfolder: aquarise5
+oldurl: http://teamw.in/project/twrp2/274
+supportstatus: Current
+maintainer: Kra1o5
+oem: BQ
+devicetree: https://github.com/TeamWin/android_device_bq_aquarise5
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/dellstreak7.markdown b/_devices/dellstreak7.markdown
new file mode 100644
index 0000000..085163a
--- /dev/null
+++ b/_devices/dellstreak7.markdown
@@ -0,0 +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 %}
diff --git a/_devices/hptouchpad.markdown b/_devices/hptouchpad.markdown
new file mode 100644
index 0000000..724a604
--- /dev/null
+++ b/_devices/hptouchpad.markdown
@@ -0,0 +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>
diff --git a/_devices/htcamaze4g.markdown b/_devices/htcamaze4g.markdown
new file mode 100644
index 0000000..49ff1f7
--- /dev/null
+++ b/_devices/htcamaze4g.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcbutterfly2.markdown b/_devices/htcbutterfly2.markdown
new file mode 100644
index 0000000..bc53fae
--- /dev/null
+++ b/_devices/htcbutterfly2.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcbutterflyx920d.markdown b/_devices/htcbutterflyx920d.markdown
new file mode 100644
index 0000000..f39d844
--- /dev/null
+++ b/_devices/htcbutterflyx920d.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcbutterflyx920e.markdown b/_devices/htcbutterflyx920e.markdown
new file mode 100644
index 0000000..505eca4
--- /dev/null
+++ b/_devices/htcbutterflyx920e.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesire510usa32bit.markdown b/_devices/htcdesire510usa32bit.markdown
new file mode 100644
index 0000000..10c7c63
--- /dev/null
+++ b/_devices/htcdesire510usa32bit.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesire601cdma.markdown b/_devices/htcdesire601cdma.markdown
new file mode 100644
index 0000000..d58cdb5
--- /dev/null
+++ b/_devices/htcdesire601cdma.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesire601gsm.markdown b/_devices/htcdesire601gsm.markdown
new file mode 100644
index 0000000..a141ce7
--- /dev/null
+++ b/_devices/htcdesire601gsm.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesire610usa.markdown b/_devices/htcdesire610usa.markdown
new file mode 100644
index 0000000..7f780a2
--- /dev/null
+++ b/_devices/htcdesire610usa.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesire816.markdown b/_devices/htcdesire816.markdown
new file mode 100644
index 0000000..b3254e2
--- /dev/null
+++ b/_devices/htcdesire816.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesirec.markdown b/_devices/htcdesirec.markdown
new file mode 100644
index 0000000..b59e1d7
--- /dev/null
+++ b/_devices/htcdesirec.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesirehd.markdown b/_devices/htcdesirehd.markdown
new file mode 100644
index 0000000..290d313
--- /dev/null
+++ b/_devices/htcdesirehd.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesires.markdown b/_devices/htcdesires.markdown
new file mode 100644
index 0000000..d75f211
--- /dev/null
+++ b/_devices/htcdesires.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdesirex.markdown b/_devices/htcdesirex.markdown
new file mode 100644
index 0000000..c9e6d54
--- /dev/null
+++ b/_devices/htcdesirex.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdroiddna.markdown b/_devices/htcdroiddna.markdown
new file mode 100644
index 0000000..3f1aef6
--- /dev/null
+++ b/_devices/htcdroiddna.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdroidincredible.markdown b/_devices/htcdroidincredible.markdown
new file mode 100644
index 0000000..c24e743
--- /dev/null
+++ b/_devices/htcdroidincredible.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdroidincredible2.markdown b/_devices/htcdroidincredible2.markdown
new file mode 100644
index 0000000..50215e9
--- /dev/null
+++ b/_devices/htcdroidincredible2.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcdroidincredible4g.markdown b/_devices/htcdroidincredible4g.markdown
new file mode 100644
index 0000000..7deb90d
--- /dev/null
+++ b/_devices/htcdroidincredible4g.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcevo3dcdma.markdown b/_devices/htcevo3dcdma.markdown
new file mode 100644
index 0000000..1cb905d
--- /dev/null
+++ b/_devices/htcevo3dcdma.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "HTC EVO 3D CDMA 4G WiMAX"
+codename: shooter
+downloadfolder: shooter
+oldurl: http://teamw.in/project/twrp2/67
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_shooter
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1400614"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/htcevo3dgsm.markdown b/_devices/htcevo3dgsm.markdown
new file mode 100644
index 0000000..6bba3ee
--- /dev/null
+++ b/_devices/htcevo3dgsm.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcevo4g.markdown b/_devices/htcevo4g.markdown
new file mode 100644
index 0000000..49345fb
--- /dev/null
+++ b/_devices/htcevo4g.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "HTC EVO 4G"
+codename: supersonic
+downloadfolder: supersonic
+oldurl: http://teamw.in/project/twrp2/3
+supportstatus: No longer updated
+maintainer: None
+oem: HTC
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1400645"
+---
+
+{% 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
new file mode 100644
index 0000000..8e1d635
--- /dev/null
+++ b/_devices/htcevo4glte.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "HTC EVO 4G LTE"
+codename: jewel
+downloadfolder: jewel
+oldurl: http://teamw.in/project/twrp2/98
+supportstatus: Current
+maintainer: Dees_Troy
+oem: HTC
+devicetree: https://github.com/TeamWin/device_htc_jewel
+xdathread: "http://forum.xda-developers.com/showthread.php?t=1675738"
+ddof: "/dev/block/mmcblk0p22"
+---
+
+{% 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/htcevoshift.markdown b/_devices/htcevoshift.markdown
new file mode 100644
index 0000000..02cb40c
--- /dev/null
+++ b/_devices/htcevoshift.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcexplorer.markdown b/_devices/htcexplorer.markdown
new file mode 100644
index 0000000..dc65dc7
--- /dev/null
+++ b/_devices/htcexplorer.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "HTC Explorer"
+codename: pico
+downloadfolder: pico
+oldurl: http://teamw.in/project/twrp2/163
+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/htcfirst.markdown b/_devices/htcfirst.markdown
new file mode 100644
index 0000000..4d00f86
--- /dev/null
+++ b/_devices/htcfirst.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htchd2.markdown b/_devices/htchd2.markdown
new file mode 100644
index 0000000..7fa9cd8
--- /dev/null
+++ b/_devices/htchd2.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcherocdma.markdown b/_devices/htcherocdma.markdown
new file mode 100644
index 0000000..5cc3ca7
--- /dev/null
+++ b/_devices/htcherocdma.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcincredibles.markdown b/_devices/htcincredibles.markdown
new file mode 100644
index 0000000..bd18e96
--- /dev/null
+++ b/_devices/htcincredibles.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcmerge.markdown b/_devices/htcmerge.markdown
new file mode 100644
index 0000000..96c2bc0
--- /dev/null
+++ b/_devices/htcmerge.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcnexus9.markdown b/_devices/htcnexus9.markdown
new file mode 100644
index 0000000..24eecef
--- /dev/null
+++ b/_devices/htcnexus9.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcnexusone.markdown b/_devices/htcnexusone.markdown
new file mode 100644
index 0000000..87c48de
--- /dev/null
+++ b/_devices/htcnexusone.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconem7dualsim.markdown b/_devices/htconem7dualsim.markdown
new file mode 100644
index 0000000..d0b69ed
--- /dev/null
+++ b/_devices/htconem7dualsim.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconem7gsm.markdown b/_devices/htconem7gsm.markdown
new file mode 100644
index 0000000..ba686b4
--- /dev/null
+++ b/_devices/htconem7gsm.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconem7sprint.markdown b/_devices/htconem7sprint.markdown
new file mode 100644
index 0000000..2b72768
--- /dev/null
+++ b/_devices/htconem7sprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconem7verizon.markdown b/_devices/htconem7verizon.markdown
new file mode 100644
index 0000000..83e9369
--- /dev/null
+++ b/_devices/htconem7verizon.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconem8gsm.markdown b/_devices/htconem8gsm.markdown
new file mode 100644
index 0000000..767b62d
--- /dev/null
+++ b/_devices/htconem8gsm.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "HTC One m8 GSM"
+codename: m8
+downloadfolder: m8
+oldurl: http://teamw.in/project/twrp2/225
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/mmcblk0p43"
+devicetree: "https://github.com/teamwin/omni_device_m8_TWRP"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2717932"
+---
+
+{% 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/htconem8sprint.markdown b/_devices/htconem8sprint.markdown
new file mode 100644
index 0000000..f498362
--- /dev/null
+++ b/_devices/htconem8sprint.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "HTC One m8 Sprint"
+codename: m8whl
+downloadfolder: m8_whl
+oldurl: http://teamw.in/project/twrp2/221
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/mmcblk0p43"
+devicetree: "https://github.com/teamwin/omni_device_m8_TWRP"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2717932"
+---
+
+{% 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/htconem8verizon.markdown b/_devices/htconem8verizon.markdown
new file mode 100644
index 0000000..f3e6d5a
--- /dev/null
+++ b/_devices/htconem8verizon.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "HTC One m8 Verizon"
+codename: m8wlv
+downloadfolder: m8_wlv
+oldurl: http://teamw.in/project/twrp2/226
+supportstatus: Current
+maintainer: CaptainThrowback
+oem: HTC
+ddof: "/dev/block/mmcblk0p44"
+devicetree: "https://github.com/teamwin/omni_device_m8_TWRP"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2717932"
+---
+
+{% 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
new file mode 100644
index 0000000..557c20d
--- /dev/null
+++ b/_devices/htconemaxsprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconemaxverizon.markdown b/_devices/htconemaxverizon.markdown
new file mode 100644
index 0000000..8f24d24
--- /dev/null
+++ b/_devices/htconemaxverizon.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconeminigsm.markdown b/_devices/htconeminigsm.markdown
new file mode 100644
index 0000000..498403d
--- /dev/null
+++ b/_devices/htconeminigsm.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "HTC One Mini"
+codename: t4ul
+downloadfolder: t4ul
+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/htconess3.markdown b/_devices/htconess3.markdown
new file mode 100644
index 0000000..8c037c0
--- /dev/null
+++ b/_devices/htconess3.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconess4.markdown b/_devices/htconess4.markdown
new file mode 100644
index 0000000..15b1799
--- /dev/null
+++ b/_devices/htconess4.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconess4specialedition.markdown b/_devices/htconess4specialedition.markdown
new file mode 100644
index 0000000..ccb4605
--- /dev/null
+++ b/_devices/htconess4specialedition.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconesvboost.markdown b/_devices/htconesvboost.markdown
new file mode 100644
index 0000000..2d1c731
--- /dev/null
+++ b/_devices/htconesvboost.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconesvcricket.markdown b/_devices/htconesvcricket.markdown
new file mode 100644
index 0000000..92793e5
--- /dev/null
+++ b/_devices/htconesvcricket.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconesvgsm.markdown b/_devices/htconesvgsm.markdown
new file mode 100644
index 0000000..5304bcb
--- /dev/null
+++ b/_devices/htconesvgsm.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconesvlte.markdown b/_devices/htconesvlte.markdown
new file mode 100644
index 0000000..32c20a7
--- /dev/null
+++ b/_devices/htconesvlte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconevgsm.markdown b/_devices/htconevgsm.markdown
new file mode 100644
index 0000000..febf203
--- /dev/null
+++ b/_devices/htconevgsm.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconevvirgin.markdown b/_devices/htconevvirgin.markdown
new file mode 100644
index 0000000..c1f3ec3
--- /dev/null
+++ b/_devices/htconevvirgin.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconevx.markdown b/_devices/htconevx.markdown
new file mode 100644
index 0000000..963a5d5
--- /dev/null
+++ b/_devices/htconevx.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconexatt.markdown b/_devices/htconexatt.markdown
new file mode 100644
index 0000000..9611f35
--- /dev/null
+++ b/_devices/htconexatt.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconexinternational.markdown b/_devices/htconexinternational.markdown
new file mode 100644
index 0000000..4a768cb
--- /dev/null
+++ b/_devices/htconexinternational.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconexplusatt.markdown b/_devices/htconexplusatt.markdown
new file mode 100644
index 0000000..fff922d
--- /dev/null
+++ b/_devices/htconexplusatt.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htconexplusinternational.markdown b/_devices/htconexplusinternational.markdown
new file mode 100644
index 0000000..b011dc1
--- /dev/null
+++ b/_devices/htconexplusinternational.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcsensation.markdown b/_devices/htcsensation.markdown
new file mode 100644
index 0000000..415d8f6
--- /dev/null
+++ b/_devices/htcsensation.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcsensationxl.markdown b/_devices/htcsensationxl.markdown
new file mode 100644
index 0000000..eb80ce4
--- /dev/null
+++ b/_devices/htcsensationxl.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcthunderbolt.markdown b/_devices/htcthunderbolt.markdown
new file mode 100644
index 0000000..dd91950
--- /dev/null
+++ b/_devices/htcthunderbolt.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcvivid.markdown b/_devices/htcvivid.markdown
new file mode 100644
index 0000000..2572c9a
--- /dev/null
+++ b/_devices/htcvivid.markdown
@@ -0,0 +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 %}
diff --git a/_devices/htcwildfires.markdown b/_devices/htcwildfires.markdown
new file mode 100644
index 0000000..dcfd836
--- /dev/null
+++ b/_devices/htcwildfires.markdown
@@ -0,0 +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 %}
diff --git a/_devices/huaweiascendmate2.markdown b/_devices/huaweiascendmate2.markdown
new file mode 100644
index 0000000..d1e0322
--- /dev/null
+++ b/_devices/huaweiascendmate2.markdown
@@ -0,0 +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 %}
diff --git a/_devices/huaweig510.markdown b/_devices/huaweig510.markdown
new file mode 100644
index 0000000..09b96c6
--- /dev/null
+++ b/_devices/huaweig510.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "Huawei G510"
+codename: u8951
+downloadfolder: u8951
+oldurl: http://teamw.in/project/twrp2/170
+supportstatus: Current
+maintainer: Kra1o5
+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/huaweiu8815.markdown b/_devices/huaweiu8815.markdown
new file mode 100644
index 0000000..bfe9172
--- /dev/null
+++ b/_devices/huaweiu8815.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "Huawei U8815"
+codename: u8815
+downloadfolder: u8815
+oldurl: http://teamw.in/project/twrp2/136
+supportstatus: Current
+maintainer: Kra1o5
+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
new file mode 100644
index 0000000..c738651
--- /dev/null
+++ b/_devices/huaweiy300.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "Huawei Y300"
+codename: u8833
+downloadfolder: u8833
+oldurl: http://teamw.in/project/twrp2/166
+supportstatus: Current
+maintainer: Kra1o5
+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/kazamthunderq45.markdown b/_devices/kazamthunderq45.markdown
new file mode 100644
index 0000000..a4165f4
--- /dev/null
+++ b/_devices/kazamthunderq45.markdown
@@ -0,0 +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 %}
diff --git a/_devices/kazamtornado348.markdown b/_devices/kazamtornado348.markdown
new file mode 100644
index 0000000..72eec21
--- /dev/null
+++ b/_devices/kazamtornado348.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg2.markdown b/_devices/lgg2.markdown
new file mode 100644
index 0000000..b9cc4cd
--- /dev/null
+++ b/_devices/lgg2.markdown
@@ -0,0 +1,93 @@
+---
+layout: device
+title:  "LG G2"
+codename: G2
+downloadfolder: G2
+oldurl: http://teamw.in/project/twrp2/197
+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 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
new file mode 100644
index 0000000..27f97b7
--- /dev/null
+++ b/_devices/lgg3att.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3canadabellrogers.markdown b/_devices/lgg3canadabellrogers.markdown
new file mode 100644
index 0000000..8146278
--- /dev/null
+++ b/_devices/lgg3canadabellrogers.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3canadawindvideotronsasktel.markdown b/_devices/lgg3canadawindvideotronsasktel.markdown
new file mode 100644
index 0000000..434488d
--- /dev/null
+++ b/_devices/lgg3canadawindvideotronsasktel.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3europe.markdown b/_devices/lgg3europe.markdown
new file mode 100644
index 0000000..9eda797
--- /dev/null
+++ b/_devices/lgg3europe.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3korea.markdown b/_devices/lgg3korea.markdown
new file mode 100644
index 0000000..17a0579
--- /dev/null
+++ b/_devices/lgg3korea.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3sprint.markdown b/_devices/lgg3sprint.markdown
new file mode 100644
index 0000000..1c775ae
--- /dev/null
+++ b/_devices/lgg3sprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3tmo.markdown b/_devices/lgg3tmo.markdown
new file mode 100644
index 0000000..01c7ea6
--- /dev/null
+++ b/_devices/lgg3tmo.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3uscellular.markdown b/_devices/lgg3uscellular.markdown
new file mode 100644
index 0000000..2291b85
--- /dev/null
+++ b/_devices/lgg3uscellular.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgg3verizon.markdown b/_devices/lgg3verizon.markdown
new file mode 100644
index 0000000..4a6819b
--- /dev/null
+++ b/_devices/lgg3verizon.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lggflexkorean.markdown b/_devices/lggflexkorean.markdown
new file mode 100644
index 0000000..710255b
--- /dev/null
+++ b/_devices/lggflexkorean.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lggpad83.markdown b/_devices/lggpad83.markdown
new file mode 100644
index 0000000..409c4a4
--- /dev/null
+++ b/_devices/lggpad83.markdown
@@ -0,0 +1,25 @@
+---
+layout: device
+title:  "LG G Pad 8.3 Google Edition"
+codename: awifi
+downloadfolder: awifi
+oldurl: http://teamw.in/project/twrp2/213
+supportstatus: Current
+maintainer: None
+oem: LG
+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 %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lggwatch.markdown b/_devices/lggwatch.markdown
new file mode 100644
index 0000000..774d281
--- /dev/null
+++ b/_devices/lggwatch.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lggwatchr.markdown b/_devices/lggwatchr.markdown
new file mode 100644
index 0000000..12aca7d
--- /dev/null
+++ b/_devices/lggwatchr.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgnexus4.markdown b/_devices/lgnexus4.markdown
new file mode 100644
index 0000000..b290acc
--- /dev/null
+++ b/_devices/lgnexus4.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgnexus5.markdown b/_devices/lgnexus5.markdown
new file mode 100644
index 0000000..3873ce6
--- /dev/null
+++ b/_devices/lgnexus5.markdown
@@ -0,0 +1,24 @@
+---
+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 %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_devices/lgnitrohd.markdown b/_devices/lgnitrohd.markdown
new file mode 100644
index 0000000..4eceabf
--- /dev/null
+++ b/_devices/lgnitrohd.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimus2x.markdown b/_devices/lgoptimus2x.markdown
new file mode 100644
index 0000000..8fa8660
--- /dev/null
+++ b/_devices/lgoptimus2x.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimus4xhd.markdown b/_devices/lgoptimus4xhd.markdown
new file mode 100644
index 0000000..06e0c53
--- /dev/null
+++ b/_devices/lgoptimus4xhd.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimusblack.markdown b/_devices/lgoptimusblack.markdown
new file mode 100644
index 0000000..646e7fa
--- /dev/null
+++ b/_devices/lgoptimusblack.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimusfuel.markdown b/_devices/lgoptimusfuel.markdown
new file mode 100644
index 0000000..9f8e986
--- /dev/null
+++ b/_devices/lgoptimusfuel.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimusgatt.markdown b/_devices/lgoptimusgatt.markdown
new file mode 100644
index 0000000..9345c4a
--- /dev/null
+++ b/_devices/lgoptimusgatt.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimusgsprint.markdown b/_devices/lgoptimusgsprint.markdown
new file mode 100644
index 0000000..113e4d2
--- /dev/null
+++ b/_devices/lgoptimusgsprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimuslte.markdown b/_devices/lgoptimuslte.markdown
new file mode 100644
index 0000000..65515b8
--- /dev/null
+++ b/_devices/lgoptimuslte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimusone.markdown b/_devices/lgoptimusone.markdown
new file mode 100644
index 0000000..3d80a23
--- /dev/null
+++ b/_devices/lgoptimusone.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgoptimusslider.markdown b/_devices/lgoptimusslider.markdown
new file mode 100644
index 0000000..0713e91
--- /dev/null
+++ b/_devices/lgoptimusslider.markdown
@@ -0,0 +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 %}
diff --git a/_devices/lgtmobileg2x.markdown b/_devices/lgtmobileg2x.markdown
new file mode 100644
index 0000000..ec7d7f9
--- /dev/null
+++ b/_devices/lgtmobileg2x.markdown
@@ -0,0 +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>
diff --git a/_devices/micromaxcanvasmagnus.markdown b/_devices/micromaxcanvasmagnus.markdown
new file mode 100644
index 0000000..9e6ce83
--- /dev/null
+++ b/_devices/micromaxcanvasmagnus.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motorolaatrix4g.markdown b/_devices/motorolaatrix4g.markdown
new file mode 100644
index 0000000..9c76cdb
--- /dev/null
+++ b/_devices/motorolaatrix4g.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motoroladefy.markdown b/_devices/motoroladefy.markdown
new file mode 100644
index 0000000..473c3a1
--- /dev/null
+++ b/_devices/motoroladefy.markdown
@@ -0,0 +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>
diff --git a/_devices/motorolamoto360.markdown b/_devices/motorolamoto360.markdown
new file mode 100644
index 0000000..3968020
--- /dev/null
+++ b/_devices/motorolamoto360.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motorolamotoe.markdown b/_devices/motorolamotoe.markdown
new file mode 100644
index 0000000..b4cb449
--- /dev/null
+++ b/_devices/motorolamotoe.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Moto E"
+codename: condor
+downloadfolder: condor
+oldurl: http://teamw.in/project/twrp2/235
+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/motorolamotog2013.markdown b/_devices/motorolamotog2013.markdown
new file mode 100644
index 0000000..d9e01b3
--- /dev/null
+++ b/_devices/motorolamotog2013.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Moto G 2013"
+codename: xt1032
+downloadfolder: xt1032
+oldurl: http://teamw.in/project/twrp2/233
+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/motorolamotog2014.markdown b/_devices/motorolamotog2014.markdown
new file mode 100644
index 0000000..c4311b0
--- /dev/null
+++ b/_devices/motorolamotog2014.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Moto G 2014"
+codename: titan
+downloadfolder: titan
+oldurl: http://teamw.in/project/twrp2/275
+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/motorolamotox2013.markdown b/_devices/motorolamotox2013.markdown
new file mode 100644
index 0000000..00a991d
--- /dev/null
+++ b/_devices/motorolamotox2013.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motorolamotox2014.markdown b/_devices/motorolamotox2014.markdown
new file mode 100644
index 0000000..32284e2
--- /dev/null
+++ b/_devices/motorolamotox2014.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motorolanexus6.markdown b/_devices/motorolanexus6.markdown
new file mode 100644
index 0000000..53e52a0
--- /dev/null
+++ b/_devices/motorolanexus6.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motorolaphoton4g.markdown b/_devices/motorolaphoton4g.markdown
new file mode 100644
index 0000000..dc7b42e
--- /dev/null
+++ b/_devices/motorolaphoton4g.markdown
@@ -0,0 +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 %}
diff --git a/_devices/motorolaphotonq.markdown b/_devices/motorolaphotonq.markdown
new file mode 100644
index 0000000..5886ff3
--- /dev/null
+++ b/_devices/motorolaphotonq.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Photon Q"
+codename: asanti
+downloadfolder: asanti
+oldurl: http://teamw.in/project/twrp2/137
+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/motorolaxoom.markdown b/_devices/motorolaxoom.markdown
new file mode 100644
index 0000000..7bc5db4
--- /dev/null
+++ b/_devices/motorolaxoom.markdown
@@ -0,0 +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 %}
diff --git a/_devices/omatetruesmart.markdown b/_devices/omatetruesmart.markdown
new file mode 100644
index 0000000..8e41762
--- /dev/null
+++ b/_devices/omatetruesmart.markdown
@@ -0,0 +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 %}
diff --git a/_devices/oneplusone.markdown b/_devices/oneplusone.markdown
new file mode 100644
index 0000000..4cc3ac6
--- /dev/null
+++ b/_devices/oneplusone.markdown
@@ -0,0 +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 %}
diff --git a/_devices/oppofind5.markdown b/_devices/oppofind5.markdown
new file mode 100644
index 0000000..77f3014
--- /dev/null
+++ b/_devices/oppofind5.markdown
@@ -0,0 +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 %}
diff --git a/_devices/oppofind7.markdown b/_devices/oppofind7.markdown
new file mode 100644
index 0000000..86fd342
--- /dev/null
+++ b/_devices/oppofind7.markdown
@@ -0,0 +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 %}
diff --git a/_devices/oppon1.markdown b/_devices/oppon1.markdown
new file mode 100644
index 0000000..f6841cb
--- /dev/null
+++ b/_devices/oppon1.markdown
@@ -0,0 +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 %}
diff --git a/_devices/oppon3.markdown b/_devices/oppon3.markdown
new file mode 100644
index 0000000..35011d2
--- /dev/null
+++ b/_devices/oppon3.markdown
@@ -0,0 +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 %}
diff --git a/_devices/oppor819.markdown b/_devices/oppor819.markdown
new file mode 100644
index 0000000..756defe
--- /dev/null
+++ b/_devices/oppor819.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Oppo R819"
+codename: n3
+downloadfolder: n3
+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
new file mode 100644
index 0000000..f78a439
--- /dev/null
+++ b/_devices/samsungefascinate.markdown
@@ -0,0 +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>
diff --git a/_devices/samsungepic4g.markdown b/_devices/samsungepic4g.markdown
new file mode 100644
index 0000000..c8b2814
--- /dev/null
+++ b/_devices/samsungepic4g.markdown
@@ -0,0 +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>
diff --git a/_devices/samsunggalaxyalpha.markdown b/_devices/samsunggalaxyalpha.markdown
new file mode 100644
index 0000000..8052971
--- /dev/null
+++ b/_devices/samsunggalaxyalpha.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxygrandduos.markdown b/_devices/samsunggalaxygrandduos.markdown
new file mode 100644
index 0000000..7720278
--- /dev/null
+++ b/_devices/samsunggalaxygrandduos.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxymega58.markdown b/_devices/samsunggalaxymega58.markdown
new file mode 100644
index 0000000..c31e7f9
--- /dev/null
+++ b/_devices/samsunggalaxymega58.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxymega63.markdown b/_devices/samsunggalaxymega63.markdown
new file mode 100644
index 0000000..108b8bc
--- /dev/null
+++ b/_devices/samsunggalaxymega63.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynexusgsm.markdown b/_devices/samsunggalaxynexusgsm.markdown
new file mode 100644
index 0000000..6e9e4ae
--- /dev/null
+++ b/_devices/samsunggalaxynexusgsm.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "Samsung Galaxy Nexus (GSM)"
+codename: maguro
+downloadfolder: maguro
+oldurl: http://teamw.in/project/twrp2/90
+supportstatus: Current
+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
new file mode 100644
index 0000000..21e1c19
--- /dev/null
+++ b/_devices/samsunggalaxynexussprint.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "Samsung Galaxy Nexus (Sprint)"
+codename: toroplus
+downloadfolder: toroplus
+oldurl: http://teamw.in/project/twrp2/92
+supportstatus: Current
+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
new file mode 100644
index 0000000..a307234
--- /dev/null
+++ b/_devices/samsunggalaxynexusverizon.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "Samsung Galaxy Nexus (Verizon)"
+codename: toro
+downloadfolder: toro
+oldurl: http://teamw.in/project/twrp2/89
+supportstatus: Current
+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
new file mode 100644
index 0000000..2873a2c
--- /dev/null
+++ b/_devices/samsunggalaxynote101.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote1012014exynos.markdown b/_devices/samsunggalaxynote1012014exynos.markdown
new file mode 100644
index 0000000..a9fe022
--- /dev/null
+++ b/_devices/samsunggalaxynote1012014exynos.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote1012014qcom.markdown b/_devices/samsunggalaxynote1012014qcom.markdown
new file mode 100644
index 0000000..f1ced0b
--- /dev/null
+++ b/_devices/samsunggalaxynote1012014qcom.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote1att.markdown b/_devices/samsunggalaxynote1att.markdown
new file mode 100644
index 0000000..a6e303d
--- /dev/null
+++ b/_devices/samsunggalaxynote1att.markdown
@@ -0,0 +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: None
+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
new file mode 100644
index 0000000..4dd9e4f
--- /dev/null
+++ b/_devices/samsunggalaxynote1tmobile.markdown
@@ -0,0 +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: None
+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
new file mode 100644
index 0000000..4cc8805
--- /dev/null
+++ b/_devices/samsunggalaxynote2att.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2canada.markdown b/_devices/samsunggalaxynote2canada.markdown
new file mode 100644
index 0000000..20eb648
--- /dev/null
+++ b/_devices/samsunggalaxynote2canada.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2n7100.markdown b/_devices/samsunggalaxynote2n7100.markdown
new file mode 100644
index 0000000..8925ec5
--- /dev/null
+++ b/_devices/samsunggalaxynote2n7100.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2n7105.markdown b/_devices/samsunggalaxynote2n7105.markdown
new file mode 100644
index 0000000..4de4ad3
--- /dev/null
+++ b/_devices/samsunggalaxynote2n7105.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2sprint.markdown b/_devices/samsunggalaxynote2sprint.markdown
new file mode 100644
index 0000000..80cca0e
--- /dev/null
+++ b/_devices/samsunggalaxynote2sprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2t0ltektt.markdown b/_devices/samsunggalaxynote2t0ltektt.markdown
new file mode 100644
index 0000000..f33b1f3
--- /dev/null
+++ b/_devices/samsunggalaxynote2t0ltektt.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2t0lteskt.markdown b/_devices/samsunggalaxynote2t0lteskt.markdown
new file mode 100644
index 0000000..bd1a39e
--- /dev/null
+++ b/_devices/samsunggalaxynote2t0lteskt.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2tmobile.markdown b/_devices/samsunggalaxynote2tmobile.markdown
new file mode 100644
index 0000000..634ec94
--- /dev/null
+++ b/_devices/samsunggalaxynote2tmobile.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote2verizon.markdown b/_devices/samsunggalaxynote2verizon.markdown
new file mode 100644
index 0000000..808d302
--- /dev/null
+++ b/_devices/samsunggalaxynote2verizon.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote3canada.markdown b/_devices/samsunggalaxynote3canada.markdown
new file mode 100644
index 0000000..e2f08b3
--- /dev/null
+++ b/_devices/samsunggalaxynote3canada.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 3 Canada"
+codename: hltecan
+downloadfolder: hltecan
+oldurl: http://teamw.in/project/twrp2/200
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hltecan"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2494245"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Use the 4.3 version of TWRP if you have never upgraded kitkat  bootloader. Otherwise make sure you use the 4.4 version. These versions of TWRP have different DTBs and will fail to boot if you do not match your bootloader.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3internationalexynos.markdown b/_devices/samsunggalaxynote3internationalexynos.markdown
new file mode 100644
index 0000000..b0a87e4
--- /dev/null
+++ b/_devices/samsunggalaxynote3internationalexynos.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote3internationalqualcomm.markdown b/_devices/samsunggalaxynote3internationalqualcomm.markdown
new file mode 100644
index 0000000..703316f
--- /dev/null
+++ b/_devices/samsunggalaxynote3internationalqualcomm.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 3 International Qualcomm"
+codename: hlte
+downloadfolder: hlte
+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_hlte"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2494245"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Use the 4.3 version of TWRP if you have never upgraded kitkat  bootloader. Otherwise make sure you use the 4.4 version. These versions of TWRP have different DTBs and will fail to boot if you do not match your bootloader.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3neo.markdown b/_devices/samsunggalaxynote3neo.markdown
new file mode 100644
index 0000000..0255770
--- /dev/null
+++ b/_devices/samsunggalaxynote3neo.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynote3sprint.markdown b/_devices/samsunggalaxynote3sprint.markdown
new file mode 100644
index 0000000..14ab32a
--- /dev/null
+++ b/_devices/samsunggalaxynote3sprint.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 3 Sprint"
+codename: hltespr
+downloadfolder: hltespr
+oldurl: http://teamw.in/project/twrp2/201
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hltespr"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2471564"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Use the 4.3 version of TWRP if you have never upgraded kitkat  bootloader. Otherwise make sure you use the 4.4 version. These versions of TWRP have different DTBs and will fail to boot if you do not match your bootloader.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3tmobile.markdown b/_devices/samsunggalaxynote3tmobile.markdown
new file mode 100644
index 0000000..69a1761
--- /dev/null
+++ b/_devices/samsunggalaxynote3tmobile.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 3 T-Mobile"
+codename: hltetmo
+downloadfolder: hltetmo
+oldurl: http://teamw.in/project/twrp2/198
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hltetmo"
+xdathread: "http://forum.xda-developers.com/showthread.php?t=2467001"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Use the 4.3 version of TWRP if you have never upgraded kitkat  bootloader. Otherwise make sure you use the 4.4 version. These versions of TWRP have different DTBs and will fail to boot if you do not match your bootloader.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3uscellular.markdown b/_devices/samsunggalaxynote3uscellular.markdown
new file mode 100644
index 0000000..17a2eee
--- /dev/null
+++ b/_devices/samsunggalaxynote3uscellular.markdown
@@ -0,0 +1,25 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 3 US Cellular"
+codename: hlteusc
+downloadfolder: hlteusc
+oldurl: http://teamw.in/project/twrp2/218
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hlteusc"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Use the 4.3 version of TWRP if you have never upgraded kitkat  bootloader. Otherwise make sure you use the 4.4 version. These versions of TWRP have different DTBs and will fail to boot if you do not match your bootloader.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote3verizon.markdown b/_devices/samsunggalaxynote3verizon.markdown
new file mode 100644
index 0000000..b924d69
--- /dev/null
+++ b/_devices/samsunggalaxynote3verizon.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 3 Verizon"
+codename: hltevzw
+downloadfolder: hltevzw
+oldurl: http://teamw.in/project/twrp2/251
+supportstatus: Current
+maintainer: None
+oem: Samsung
+ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
+devicetree: "https://github.com/TeamWin/android_device_samsung_hltevzw"
+xdathread: "http://forum.xda-developers.com/verizon-galaxy-note-3/orig-development/twrp-t2879345"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+Use the 4.3 version of TWRP if you have never upgraded kitkat  bootloader. Otherwise make sure you use the 4.4 version. These versions of TWRP have different DTBs and will fail to boot if you do not match your bootloader.
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynote4exynos.markdown b/_devices/samsunggalaxynote4exynos.markdown
new file mode 100644
index 0000000..2de9d50
--- /dev/null
+++ b/_devices/samsunggalaxynote4exynos.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Exynos"
+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
new file mode 100644
index 0000000..17d0a78
--- /dev/null
+++ b/_devices/samsunggalaxynote4qualcomm.markdown
@@ -0,0 +1,86 @@
+---
+layout: device
+title:  "Samsung Galaxy Note 4 Qualcomm"
+codename: trlte
+oldurl: http://teamw.in/project/twrp2/266
+supportstatus: Current
+maintainer: None
+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>
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_devices/samsunggalaxynotepro122exynos3g.markdown b/_devices/samsunggalaxynotepro122exynos3g.markdown
new file mode 100644
index 0000000..74c8461
--- /dev/null
+++ b/_devices/samsunggalaxynotepro122exynos3g.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynotepro122exynoswifi.markdown b/_devices/samsunggalaxynotepro122exynoswifi.markdown
new file mode 100644
index 0000000..784facf
--- /dev/null
+++ b/_devices/samsunggalaxynotepro122exynoswifi.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxynotepro122qcom.markdown b/_devices/samsunggalaxynotepro122qcom.markdown
new file mode 100644
index 0000000..8a00360
--- /dev/null
+++ b/_devices/samsunggalaxynotepro122qcom.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxyprevail.markdown b/_devices/samsunggalaxyprevail.markdown
new file mode 100644
index 0000000..076f02a
--- /dev/null
+++ b/_devices/samsunggalaxyprevail.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxyreverb.markdown b/_devices/samsunggalaxyreverb.markdown
new file mode 100644
index 0000000..00960d4
--- /dev/null
+++ b/_devices/samsunggalaxyreverb.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxyrugbypro.markdown b/_devices/samsunggalaxyrugbypro.markdown
new file mode 100644
index 0000000..26752c7
--- /dev/null
+++ b/_devices/samsunggalaxyrugbypro.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys2exhilarate.markdown b/_devices/samsunggalaxys2exhilarate.markdown
new file mode 100644
index 0000000..ef714e4
--- /dev/null
+++ b/_devices/samsunggalaxys2exhilarate.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys2hercules.markdown b/_devices/samsunggalaxys2hercules.markdown
new file mode 100644
index 0000000..e91960a
--- /dev/null
+++ b/_devices/samsunggalaxys2hercules.markdown
@@ -0,0 +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: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/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/samsunggalaxys2plus.markdown b/_devices/samsunggalaxys2plus.markdown
new file mode 100644
index 0000000..e486ff3
--- /dev/null
+++ b/_devices/samsunggalaxys2plus.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys2skyrocket.markdown b/_devices/samsunggalaxys2skyrocket.markdown
new file mode 100644
index 0000000..864ed70
--- /dev/null
+++ b/_devices/samsunggalaxys2skyrocket.markdown
@@ -0,0 +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: None
+oem: Samsung
+devicetree: https://github.com/TeamWin/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
new file mode 100644
index 0000000..5dc76dc
--- /dev/null
+++ b/_devices/samsunggalaxys3att.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3canada.markdown b/_devices/samsunggalaxys3canada.markdown
new file mode 100644
index 0000000..047bb4c
--- /dev/null
+++ b/_devices/samsunggalaxys3canada.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3cricket.markdown b/_devices/samsunggalaxys3cricket.markdown
new file mode 100644
index 0000000..50be720
--- /dev/null
+++ b/_devices/samsunggalaxys3cricket.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3internationalexynos.markdown b/_devices/samsunggalaxys3internationalexynos.markdown
new file mode 100644
index 0000000..ed5c7e9
--- /dev/null
+++ b/_devices/samsunggalaxys3internationalexynos.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3internationallte.markdown b/_devices/samsunggalaxys3internationallte.markdown
new file mode 100644
index 0000000..47ede64
--- /dev/null
+++ b/_devices/samsunggalaxys3internationallte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3metropcs.markdown b/_devices/samsunggalaxys3metropcs.markdown
new file mode 100644
index 0000000..3ec16a8
--- /dev/null
+++ b/_devices/samsunggalaxys3metropcs.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3mini.markdown b/_devices/samsunggalaxys3mini.markdown
new file mode 100644
index 0000000..f5dbc2e
--- /dev/null
+++ b/_devices/samsunggalaxys3mini.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3sprint.markdown b/_devices/samsunggalaxys3sprint.markdown
new file mode 100644
index 0000000..b1f4f5a
--- /dev/null
+++ b/_devices/samsunggalaxys3sprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3tmobile.markdown b/_devices/samsunggalaxys3tmobile.markdown
new file mode 100644
index 0000000..5fff290
--- /dev/null
+++ b/_devices/samsunggalaxys3tmobile.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3uscellular.markdown b/_devices/samsunggalaxys3uscellular.markdown
new file mode 100644
index 0000000..954370a
--- /dev/null
+++ b/_devices/samsunggalaxys3uscellular.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys3verizon.markdown b/_devices/samsunggalaxys3verizon.markdown
new file mode 100644
index 0000000..bed2836
--- /dev/null
+++ b/_devices/samsunggalaxys3verizon.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4att.markdown b/_devices/samsunggalaxys4att.markdown
new file mode 100644
index 0000000..2328558
--- /dev/null
+++ b/_devices/samsunggalaxys4att.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4canada.markdown b/_devices/samsunggalaxys4canada.markdown
new file mode 100644
index 0000000..8807f50
--- /dev/null
+++ b/_devices/samsunggalaxys4canada.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4cricket.markdown b/_devices/samsunggalaxys4cricket.markdown
new file mode 100644
index 0000000..db27f61
--- /dev/null
+++ b/_devices/samsunggalaxys4cricket.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4cspire.markdown b/_devices/samsunggalaxys4cspire.markdown
new file mode 100644
index 0000000..8de2ff0
--- /dev/null
+++ b/_devices/samsunggalaxys4cspire.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4googleedition.markdown b/_devices/samsunggalaxys4googleedition.markdown
new file mode 100644
index 0000000..79257de
--- /dev/null
+++ b/_devices/samsunggalaxys4googleedition.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4internationalexynos.markdown b/_devices/samsunggalaxys4internationalexynos.markdown
new file mode 100644
index 0000000..048360e
--- /dev/null
+++ b/_devices/samsunggalaxys4internationalexynos.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4internationalqualcomm.markdown b/_devices/samsunggalaxys4internationalqualcomm.markdown
new file mode 100644
index 0000000..71e3119
--- /dev/null
+++ b/_devices/samsunggalaxys4internationalqualcomm.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4sprint.markdown b/_devices/samsunggalaxys4sprint.markdown
new file mode 100644
index 0000000..f9ffbb2
--- /dev/null
+++ b/_devices/samsunggalaxys4sprint.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4tmobile.markdown b/_devices/samsunggalaxys4tmobile.markdown
new file mode 100644
index 0000000..086caa0
--- /dev/null
+++ b/_devices/samsunggalaxys4tmobile.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4uscellular.markdown b/_devices/samsunggalaxys4uscellular.markdown
new file mode 100644
index 0000000..11f7272
--- /dev/null
+++ b/_devices/samsunggalaxys4uscellular.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys4verizon.markdown b/_devices/samsunggalaxys4verizon.markdown
new file mode 100644
index 0000000..f2b3d5f
--- /dev/null
+++ b/_devices/samsunggalaxys4verizon.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxys5qualcomm.markdown b/_devices/samsunggalaxys5qualcomm.markdown
new file mode 100644
index 0000000..ddb7e82
--- /dev/null
+++ b/_devices/samsunggalaxys5qualcomm.markdown
@@ -0,0 +1,25 @@
+---
+layout: device
+title:  "Samsung Galaxy S4 Qualcomm"
+codename: klte
+downloadfolder: klte
+oldurl: http://teamw.in/project/twrp2/229
+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/samsunggalaxystellar4g.markdown b/_devices/samsunggalaxystellar4g.markdown
new file mode 100644
index 0000000..ac411d5
--- /dev/null
+++ b/_devices/samsunggalaxystellar4g.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytab2101.markdown b/_devices/samsunggalaxytab2101.markdown
new file mode 100644
index 0000000..ed7c70b
--- /dev/null
+++ b/_devices/samsunggalaxytab2101.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytab270.markdown b/_devices/samsunggalaxytab270.markdown
new file mode 100644
index 0000000..e8d1198
--- /dev/null
+++ b/_devices/samsunggalaxytab270.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytab470.markdown b/_devices/samsunggalaxytab470.markdown
new file mode 100644
index 0000000..e4a4e32
--- /dev/null
+++ b/_devices/samsunggalaxytab470.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytab77.markdown b/_devices/samsunggalaxytab77.markdown
new file mode 100644
index 0000000..b4c0068
--- /dev/null
+++ b/_devices/samsunggalaxytab77.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytabpro101exynoswifi.markdown b/_devices/samsunggalaxytabpro101exynoswifi.markdown
new file mode 100644
index 0000000..0c98f62
--- /dev/null
+++ b/_devices/samsunggalaxytabpro101exynoswifi.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytabpro101lte.markdown b/_devices/samsunggalaxytabpro101lte.markdown
new file mode 100644
index 0000000..d117668
--- /dev/null
+++ b/_devices/samsunggalaxytabpro101lte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytabpro122exynoswifi.markdown b/_devices/samsunggalaxytabpro122exynoswifi.markdown
new file mode 100644
index 0000000..46e5c9f
--- /dev/null
+++ b/_devices/samsunggalaxytabpro122exynoswifi.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytabpro8.4exynoswifi.markdown b/_devices/samsunggalaxytabpro8.4exynoswifi.markdown
new file mode 100644
index 0000000..dd62765
--- /dev/null
+++ b/_devices/samsunggalaxytabpro8.4exynoswifi.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytabpro8.4lte.markdown b/_devices/samsunggalaxytabpro8.4lte.markdown
new file mode 100644
index 0000000..c6a0582
--- /dev/null
+++ b/_devices/samsunggalaxytabpro8.4lte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggalaxytabs105.markdown b/_devices/samsunggalaxytabs105.markdown
new file mode 100644
index 0000000..e803ee9
--- /dev/null
+++ b/_devices/samsunggalaxytabs105.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "Samsung Galaxy Tab S 10.5"
+codename: chagallwifi
+downloadfolder: chagallwifi
+oldurl: http://teamw.in/project/twrp2/239
+supportstatus: Current
+maintainer: None
+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/samsunggalaxytabs84.markdown b/_devices/samsunggalaxytabs84.markdown
new file mode 100644
index 0000000..1fc509a
--- /dev/null
+++ b/_devices/samsunggalaxytabs84.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title:  "Samsung Galaxy Tab S 8.4"
+codename: klimtwifi
+downloadfolder: klimtwifi
+oldurl: http://teamw.in/project/twrp2/238
+supportstatus: Current
+maintainer: None
+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/samsunggalaxyvictory4glte.markdown b/_devices/samsunggalaxyvictory4glte.markdown
new file mode 100644
index 0000000..adae9d1
--- /dev/null
+++ b/_devices/samsunggalaxyvictory4glte.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsunggearlive.markdown b/_devices/samsunggearlive.markdown
new file mode 100644
index 0000000..d1247fa
--- /dev/null
+++ b/_devices/samsunggearlive.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsungnexus10.markdown b/_devices/samsungnexus10.markdown
new file mode 100644
index 0000000..ab137de
--- /dev/null
+++ b/_devices/samsungnexus10.markdown
@@ -0,0 +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 %}
diff --git a/_devices/samsungnexuss.markdown b/_devices/samsungnexuss.markdown
new file mode 100644
index 0000000..f4d45de
--- /dev/null
+++ b/_devices/samsungnexuss.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "Samsung Nexus S"
+codename: crespo
+downloadfolder: crespo
+oldurl: http://teamw.in/project/twrp2/44
+supportstatus: Current
+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
new file mode 100644
index 0000000..380e3dc
--- /dev/null
+++ b/_devices/samsungnexuss4g.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "Samsung Nexus S 4G"
+codename: crespo4g
+downloadfolder: crespo4g
+oldurl: http://teamw.in/project/twrp2/74
+supportstatus: Current
+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/sonyxperial.markdown b/_devices/sonyxperial.markdown
new file mode 100644
index 0000000..bcc2a45
--- /dev/null
+++ b/_devices/sonyxperial.markdown
@@ -0,0 +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 %}
diff --git a/_devices/sonyxperias.markdown b/_devices/sonyxperias.markdown
new file mode 100644
index 0000000..fdf8cb3
--- /dev/null
+++ b/_devices/sonyxperias.markdown
@@ -0,0 +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 %}
diff --git a/_devices/sonyxperiat.markdown b/_devices/sonyxperiat.markdown
new file mode 100644
index 0000000..5c36e9c
--- /dev/null
+++ b/_devices/sonyxperiat.markdown
@@ -0,0 +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 %}
diff --git a/_devices/sonyxperiaz.markdown b/_devices/sonyxperiaz.markdown
new file mode 100644
index 0000000..5e3f715
--- /dev/null
+++ b/_devices/sonyxperiaz.markdown
@@ -0,0 +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 %}
diff --git a/_devices/sonyxperiaz2.markdown b/_devices/sonyxperiaz2.markdown
new file mode 100644
index 0000000..d4ec11e
--- /dev/null
+++ b/_devices/sonyxperiaz2.markdown
@@ -0,0 +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 %}
diff --git a/_devices/sonyxperiaztablet.markdown b/_devices/sonyxperiaztablet.markdown
new file mode 100644
index 0000000..741f0d0
--- /dev/null
+++ b/_devices/sonyxperiaztablet.markdown
@@ -0,0 +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 %}
diff --git a/_devices/sonyxperiazultra.markdown b/_devices/sonyxperiazultra.markdown
new file mode 100644
index 0000000..29f19f2
--- /dev/null
+++ b/_devices/sonyxperiazultra.markdown
@@ -0,0 +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 %}
diff --git a/_devices/xiaomimi3.markdown b/_devices/xiaomimi3.markdown
new file mode 100644
index 0000000..e738d19
--- /dev/null
+++ b/_devices/xiaomimi3.markdown
@@ -0,0 +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 %}
diff --git a/_devices/xiaomiredmi1s.markdown b/_devices/xiaomiredmi1s.markdown
new file mode 100644
index 0000000..e5a4176
--- /dev/null
+++ b/_devices/xiaomiredmi1s.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Xiaomi Redmi 1s"
+codename: armani
+downloadfolder: armani
+oldurl: http://teamw.in/project/twrp2/241
+supportstatus: Current
+maintainer: Kra1o5
+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
new file mode 100644
index 0000000..aea9246
--- /dev/null
+++ b/_devices/yuyureka.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Yu Yureka"
+codename: tomato
+downloadfolder: tomato
+oldurl: http://teamw.in/project/twrp2/284
+supportstatus: Current
+maintainer: None
+oem: Yu
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
