diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..badbc02
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+_site
+.sass-cache
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 0000000..615dfea
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1,21 @@
+# Site settings
+title: TeamWin - TWRP
+description: > # this means to ignore newlines until "baseurl:"
+  This is the Team Win website and the official home of TWRP! 
+  Here you will find the list of officially supported devices
+  and instructions for installing TWRP on those devices.
+baseurl: "" # the subpath of your site, e.g. /blog/
+url: "http://twrp.me" # the base hostname & protocol for your site
+github_username: TeamWin
+
+# Build settings
+markdown: kramdown
+keep_files: [project, twrp_view_all_devices, officialota, datamedia, twrpfaq, whattobackup, whattowipe, securetwrp, removetwrp, noos, contactus/submit.php]
+exclude: [project, twrp_view_all_devices, officialota, datamedia, twrpfaq, whattobackup, whattowipe, securetwrp, removetwrp, noos, contactus/submit.php]
+
+collections:
+  devices:
+    output: true
+
+  faq:
+    output: true
diff --git a/_data/mirrors.yml b/_data/mirrors.yml
new file mode 100644
index 0000000..4098f95
--- /dev/null
+++ b/_data/mirrors.yml
@@ -0,0 +1,5 @@
+- description: Techerrata in Germany
+  baseurl: http://techerrata.com/browse/twrp2/
+
+- description: Goo.im
+  baseurl: https://goo.im/devs/OpenRecovery/
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 %}
diff --git a/_drafts/newtwrpversion.markdown b/_drafts/newtwrpversion.markdown
new file mode 100644
index 0000000..075ee2d
--- /dev/null
+++ b/_drafts/newtwrpversion.markdown
@@ -0,0 +1,16 @@
+---
+layout: post
+title:  "TWRP 2.8.5.0 Released"
+date:   2015-02-12 08:44:12
+categories: site update
+version: 2.8.5.0
+---
+
+TWRP {{ page.version }} is out now for all currently supported devices.
+
+What's new in {{ page.version }}:
+
+  * 
+  * Other small fixes and improvements
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_faq/ADBSideload.markdown b/_faq/ADBSideload.markdown
new file mode 100644
index 0000000..1e7f887
--- /dev/null
+++ b/_faq/ADBSideload.markdown
@@ -0,0 +1,23 @@
+---
+layout: post
+title:  "What is ADB Sideload and how can I use it?"
+---
+
+<div class='page-heading'>What is ADB sideload?</div>
+<hr />
+ADB sideload is a new feature that was added to AOSP recovery in Jelly Bean.  As of version 2.3, TWRP now supports ADB sideload mode.  ADB sideload is a different ADB mode that you can use to push and install a zip using one command from your computer.  Most likely ADB sideload won't be very useful for your average recovery user, but ADB sideload can be a huge time-saver for a ROM developer.
+
+<div class='page-heading'>How do I use ADB sideload?</div>
+<hr />
+
+<ol>
+<li>Have a recovery installed on your device that supports ADB sideload like TWRP 2.3 or higher</li>
+<li>Have newer ADB binaries installed on your computer.  If it's been a while since you installed ADB on your computer, you may need to get the latest ADB binaries in platform-tools from the Android SDK.  You will need version 1.0.29 or higher (1.0.32 or higher is required for TWRP versions 2.8.2.0 and higher).  You can find your current version by typing "adb version" at the command line.</li>
+<li>Set the device into ADB sideload mode. In TWRP you do this by going to Advanced then ADB Sideload.</li>
+<li>From the command line, type adb sideload /path/to/rom.zip</li>
+</ol>
+For TWRP versions lower than 2.8.2.0, the file will be copied to your device to whatever the current storage location is that you have selected in the mount page.  It will always be placed in the root of that storage location and named sideload.zip (e.g. /sdcard/sideload.zip) and it will automatically delete / overwrite any existing sideload.zip you may have on your device.  As soon as the file is copied to your device, it will automatically be installed.  When the install is finished you will be presented with a reboot system button so that you can reboot to test your zip.
+
+TWRP versions 2.8.2.0 and higher will stream the zip from your PC without storing it on your device. If you wish to store the zip on your device for later, you should not use sideload and instead use adb push or some other method to copy the zip to the device.
+
+Note that sideload mode is a separate ADB mode. While in sideload mode, regular ADB commands will not work. Once the zip has been copied to the device and the install starts (or if you hit the cancel button) regular ADB mode will resume.
diff --git a/_faq/datamedia.markdown b/_faq/datamedia.markdown
new file mode 100644
index 0000000..eb2a7ed
--- /dev/null
+++ b/_faq/datamedia.markdown
@@ -0,0 +1,20 @@
+---
+layout: post
+title:  "What is a data/media device?"
+---
+
+I'm writing this page because there seems to be a lot of confusion about how many of the newer Android devices work. Starting in Honeycomb 3.0 with the Xoom, Google changed the way that they handled storage.  Instead of having a "data" partition with your apps and a separate "sdcard" partition for storage, Google started giving you a single, very large data partition.  Inside /data is a folder at /data/media that contains all of the contents of what you think of as your internal sdcard.
+
+Since /data/media is part of /data, we pretty much never actually format the data partition. Formatting data, of course, also removes the media folder that contains the internal sdcard. When you choose a factory reset, instead of formatting, we use rm -rf commands to remove all the folders except for the media folder so that we can remove all of your apps and settings while leaving your "sdcard" intact. In TWRP we also have a wipe internal storage option that rm -rf's the media folder and a "Format Data" option that formats to recreate the entire file system in case something goes completely wrong or to remove device encryption.
+
+When you're booted to Android, Android fuses the media folder to /sdcard and emulates a FAT files system that doesn't have permissions for legacy apps. We don't currently have fuse in recovery, so we just add an extra mount command to mount /data/media to /sdcard so in recovery you still have to worry about permissions on /sdcard.
+
+Because the "internal sdcard" is not a true FAT file system, you can't mount it via USB storage. Well, that's not technically true, but the vast majority of people use Windows computers and Windows doesn't recognize ext4. If we were to allow you to mount the data partition via USB storage, Windows would claim that the device wasn't formatted and offer to format it for you, which, as you can imagine, would be a disaster. The whole ext4 setup is another reason that Android switched to using MTP for transferring files. Most of these devices don't have the necessary kernel configuration to even support USB storage mode, so it's not very easy to enable USB storage if we even wanted to try. With TWRP 2.8.0.0 and higher, we now support MTP. MTP is the protocol most newer devices use to transfer files on your PC. If for some reason MTP is not working for you or if you're using an older version of TWRP, you can use adb to push and pull files to and from your device.
+
+As a special note, if you choose to do a factory reset from your ROM, even if the ROM says that it will wipe everything including the internal storage, well, that's not what TWRP will do. A stock AOSP recovery would format data including the "sdcard" but TWRP will use its regular factory reset setup that leaves the internal storage intact.
+
+There are a couple of nice gains with using this setup vs the old data + FAT storage partition.  With /data/media you, as the user get more control over how you use your storage. If you have a ton of apps, then that's no problem since you have a huge data partition to work with. If you don't have a lot of apps, you get more room to use for storing things like movies. Further, ext4 doesn't suffer from the 4GB file size limit that FAT has, so you can have a large, high-def movie on your device if you like. I'm sure another motivating factor was to get Android away from using FAT which is a Microsoft creation. Performance on ext4 in Android is also probably better than FAT. As a downside, data media devices tend to store a lot more app data in the "data" section and so backups on these devices tend to be larger.
+
+Android 4.2 has changed things with /data/media devices a little bit due to the multi-user support that came in 4.2. Each user is assigned a subfolder in /data/media. The main user gets /data/media/0 and subsequent users get /data/media/10 and /data/media/11 and so on. If you switch users in Android 4.2, the system will remount the /sdcard folder to point to the proper user's folder. TWRP has been updated to use the /data/media/0 folder starting in 2.3.2.0.
+
+Another "feature" of 4.2 is that when you "update" to 4.2 it may attempt to upgrade your /data/media to multi-user. If you're running an older version of TWRP than 2.3.2.0 or newer, a factory reset may trigger multiple upgrades, causing your "sdcard" to get moved to /data/media/0 then /data/media/0/0 and then /data/media/0/0/0 and so on depending on how many times you "upgraded". This may cause backups to not be visible in TWRP. Also, there currently isn't a good way to go back to a 4.1 ROM after using a 4.2 ROM without having to manually move your files around.
diff --git a/_faq/howtocompiletwrp.markdown b/_faq/howtocompiletwrp.markdown
new file mode 100644
index 0000000..e267ce9
--- /dev/null
+++ b/_faq/howtocompiletwrp.markdown
@@ -0,0 +1,6 @@
+---
+layout: post
+title:  "How can I get TWRP for my device? (how to compile TWRP)"
+---
+
+We can't afford to buy every device made and many times certain devices are only available in other countries. TWRP is fully open source, so you can port TWRP to your device using our [compile guide here](http://forum.xda-developers.com/showthread.php?p=32965365).
diff --git a/_faq/noos.markdown b/_faq/noos.markdown
new file mode 100644
index 0000000..23566d8
--- /dev/null
+++ b/_faq/noos.markdown
@@ -0,0 +1,14 @@
+---
+layout: post
+title:  "No OS Installed! Are you sure you wish to reboot?"
+---
+
+If you're seeing this message in TWRP, this usually means that, one way or another, you have wiped your system partition. How you can fix this issue depends on what device you have and how you want to go about fixing it.
+
+If you have a backup, you may be able to restore your backup to reinstate a working system or OS.
+
+You may be able to find a new "ROM" for your device at places like XDA or use Google to try to locate one. If you have TWRP 2.8.0.0 or newer you may be able to simply plug your device into your computer and use MTP to transfer files. If your device has a removable SD card you can use a card reader to easily transfer the flashable zip to the card then install it under the Install button in TWRP. On some devices you may also be able to use a USB thumb drive along with a special "On-The-Go" cable known as USB OTG to get the file installed. Some devices may support USB mass storage mode (found under the mount menu) to easily copy the file to the device. If all else fails, you can install ADB drivers and software to transfer files using adb push or pull. If you are using Windows (as most people do), it may be difficult to get your computer to properly recognize your device. Windows is really picky about its drivers. You may have to force install a driver or try something like universal or naked ADB drivers.
+
+If the above does not work for you, you can search again on XDA or Google to locate a guide for returning your device back to stock. The process varies depending on what type and brand of device you have. For HTC devices search for "RUU back to stock" plus your device's name. For Samsung search for "Odin back to stock" plus your device name. LG devices often use a "KDZ return to stock" plus your device name. Google posts factory images for Nexus devices here. Motorola posts factory images for some devices here.
+
+If you still can't get your device working, don't bother using the Contact Us button on our web page. We won't respond to these kinds of support requests.
diff --git a/_faq/officialota.markdown b/_faq/officialota.markdown
new file mode 100644
index 0000000..b495f18
--- /dev/null
+++ b/_faq/officialota.markdown
@@ -0,0 +1,14 @@
+---
+layout: post
+title:  "Official OTA Updates and TWRP"
+---
+
+Installing official updates from your manufacturer or carrier is not supported by TWRP.
+
+Most official updates are differential in nature. On a completely stock device when used in the way that Google and manufacturers intend, users will never modify the system partition. A differential update means that the update does not replace the entire system. In many cases the update doesn't even replace entire files and instead just patches the difference between the old file and the new file to bring it up to date for the new version. This method makes the updates smaller which is good when you have thousands of devices that will be downloading the update over a carrier's data network, usually within a short time frame. Unfortunately this method also means that users who have modified their system by rooting, installing busybox, and removing unwanted system apps may experience unexpected behavior when they install a differential update.
+
+Also, device manufacturers may have made changes to their recoveries that we aren't aware of and device makers do not have to release source code for their recoveries (AOSP recovery is Apache license which does not require them to release their source for these changes). Those changes may not be present or supported by TWRP which may result in unexpected behavior, especially when it comes to updating items like radios, bootloaders, and modems.
+
+Installing official updates usually removes root and replaces your custom recovery with a copy of a stock recovery. Most of the time the best way to get a new update onto your device is to simply wait a couple of days for ROM makers for your device to come up with ROMs that are based on the new update that you can safely and easily install.
+
+If you've read all this and still insist that you want to install an official update from your manufacturer, the recommended process is to first return your device to completely stock including replacing TWRP with a copy of the stock recovery. Because the methods for returning to stock vary depending on the device, you will need to use Google to locate a guide for returning to stock and/or finding and installing a copy of the stock recovery. Note that there is no "uninstall process" for removing TWRP. In almost all cases the process is to simply install a different recovery.
diff --git a/_faq/removetwrp.markdown b/_faq/removetwrp.markdown
new file mode 100644
index 0000000..7e00b2e
--- /dev/null
+++ b/_faq/removetwrp.markdown
@@ -0,0 +1,8 @@
+---
+layout: post
+title:  "How can I uninstall or remove TWRP from my device?"
+---
+
+For the vast majority of devices, you don't actually remove TWRP to get back to the stock recovery. Installing a different recovery is your only real option. Simply install whatever recovery that you want and that will overwrite or replace TWRP. Usually you can follow the instructions on our website for installing TWRP manually, only use the file for whatever recovery you are choosing to install instead of the TWRP file.
+
+Note, we don't keep or maintain a database of stock recoveries. If you are trying to reinstall the stock recovery, you will have to find a copy of the stock recovery on your own.
diff --git a/_faq/securetwrp.markdown b/_faq/securetwrp.markdown
new file mode 100644
index 0000000..82439c1
--- /dev/null
+++ b/_faq/securetwrp.markdown
@@ -0,0 +1,12 @@
+---
+layout: post
+title:  "Why doesn't TWRP have password protection?"
+---
+
+I've had people ask enough for a protected TWRP that I'm creating this page as a response so I don't have to retype. If you're seeing this page, you're probably asking, "Why doesn't TWRP offer password protection?" You want to lock down your device so that a would-be theif won't be able to wipe your device to get past your lockscreen and/or so they can't wipe away that cool app you bought from the Play Store that will let you track your stolen device via GPS. Well, here's the short answer:
+
+Nothing trumps physical access to your device. If you've lost it, there's no way that TWRP can secure it.
+
+For a longer answer, it's very easy for anyone with just a little bit of knowledge to get around any kind of security that TWRP might have. All they have to do is flash one of the other recoveries that's available that doesn't have password protection to get around it. Most, if not all devices have ways to flash recovery without needing to boot to either Android or recovery (usually via fastboot or download mode / Odin). Quite literally the only way to truly secure your device would be to render the USB port completely unusable which isn't an option for most newer devices that don't have removable batteries. Even then most devices could still be worked with via jtag though it's unlikely that a thief will go to the trouble of paying for a jtag service on a device that has a broken USB port. (Note: I am not recommending that you purposely damage your USB port as it will also likely make it very difficult to recover your device if anything ever goes wrong!)
+
+I also don't want to offer a lockscreen / password protection because it offers such a superficial level of protection. Users rarely read and would skip over any disclaimers that we have that indicate that any protection that we displayed indicating that their device really isn't secure. If your device has fallen into someone else's hands, your best case scenario should be that you hope that they don't get your personal data. If you don't want someone getting your personal data, use Android's device encryption and a good lockscreen.
diff --git a/_faq/whattobackup.markdown b/_faq/whattobackup.markdown
new file mode 100644
index 0000000..2567467
--- /dev/null
+++ b/_faq/whattobackup.markdown
@@ -0,0 +1,8 @@
+---
+layout: post
+title:  "What should I back up in TWRP?"
+---
+
+The default backup options in TWRP are system, data, and boot. For most cases, this is sufficient for backing up a ROM. (Note that in some rare cases, boot isn't available for backup on certain devices). If your device has the option, backing up android_secure and/or sd-ext may be a good idea. There's usually no reason to back up cache or recovery (recovery not available for backup on some devices).
+
+Some devices have "special partitions" like WiMAX, pds, efs, etc. These partitions almost never need to be included in a normal backup. It's usually a good idea to make a single backup of these partitions and hang on to them just in case. Make use of TWRP's keyboard feature and name your backup of these special partitions accordingly.
diff --git a/_faq/whattowipe.markdown b/_faq/whattowipe.markdown
new file mode 100644
index 0000000..e5e0a8b
--- /dev/null
+++ b/_faq/whattowipe.markdown
@@ -0,0 +1,16 @@
+---
+layout: post
+title:  "What should I wipe in TWRP?"
+---
+
+If you are switching ROMs (changing from one ROM to a completely different one) then you should perform a factory reset. A factory reset wipes data and cache (which includes dalvik cache). A factory reset will also wipe sd-ext and android_secure if your device has those items. 99% of the time, this is all that you need to wipe and you only need to do it once, not three times as some people would lead you to believe.
+
+If you're installing a nightly update, then oftentimes you don't need to wipe anything at all. However, if you encounter strange behavior, then you may want to consider performing a factory reset. Of course, if the ROM maker recommends that you do a factory reset during an update, then it's a good idea to follow their recommendation.
+
+The vast majority of ROMs wipe system as part of the zip install. This means that in most cases you do not need to wipe system... ever.
+
+At this point, cache (not dalvik cache) is primarily used for recovery. It's used to store the recovery log and for storing OTA (Over The Air) updates. You probably don't need to wipe cache, and cache is already wiped as part of a factory reset.
+
+In most ROMs, dalvik cache is stored in the data partition, so if you do a factory reset, you've also wiped dalvik cache. In a few custom ROMs, especially on older devices with small data partitions, the ROM maker may have moved dalvik to the cache partition to provide you with more room for apps. Since we wipe cache with a factory reset, again, you probably don't need to wipe dalvik. There are a few situations where you may need to wipe dalvik cache when installing updates, but you will know that it's needed when you are greeted with force closes when trying to open some apps.
+
+Depending on your device and its configuration, you may have options for wiping internal storage, external storage, sd-ext, android_secure, and/or an option for formatting data. There's almost no reason that you would ever need to use these items. These options are there for convenience. For instance, if you're getting ready to sell your device, then it's a good idea to wipe everything on the device so that the new owner doesn't get your private data. Note that these wipe options may not be completely destructive. If you store especially sensitive information on your device or are really concerned about your private data, then you may need to look into other options to ensure that your data is fully destroyed.
diff --git a/_includes/appinstall.html b/_includes/appinstall.html
new file mode 100644
index 0000000..cce8a76
--- /dev/null
+++ b/_includes/appinstall.html
@@ -0,0 +1,8 @@
+<div class='page-heading'>App Install Method (Requires Root):</div>
+<hr />
+<p class="text">Download the TWRP&nbsp;Manager app:</p>
+<ul class="text">
+    <li><a href="http://play.google.com/store/apps/details?id=com.jmz.soft.twrpmanager">Play Store</a></li>
+    <li><a href="http://jmz.so/1n6IJDL">No Play Store?&nbsp;Find a direct download link at the bottom of this page.</a></li>
+</ul>
+<p class="text">Install the app and open it.&nbsp; Tap on Install&nbsp;TWRP. Select your device from the device list ({{ page.codename }}) and then tap on Install Recovery. The file will download and be installed automatically.</p>
diff --git a/_includes/ddinstall.html b/_includes/ddinstall.html
new file mode 100644
index 0000000..74967df
--- /dev/null
+++ b/_includes/ddinstall.html
@@ -0,0 +1,7 @@
+{% if page.ddof %}
+<div class='page-heading'>dd Install Method (Requires Root):</div>
+<hr />
+<p class="text">Download the latest image file (.img) from the download link above. Place it in the root of your /sdcard folder and rename it to twrp.img. Run the following commands via adb shell or a terminal emulator app:</p>
+<p class="text">su</p>
+<p class="text">dd if=/sdcard/twrp.img of={{ page.ddof }}</p>
+{% endif %}
diff --git a/_includes/disclaimer.html b/_includes/disclaimer.html
new file mode 100644
index 0000000..5448700
--- /dev/null
+++ b/_includes/disclaimer.html
@@ -0,0 +1,3 @@
+<div class='page-heading'>Disclaimer:</div>
+<hr />
+<p class="text">Team Win strives to provide a quality product.&nbsp; However, it is your decision to install our software on your device.&nbsp; Team Win takes no responsibility for any damage that may occur from installing or using TWRP.</p>
diff --git a/_includes/download.html b/_includes/download.html
new file mode 100644
index 0000000..919f62f
--- /dev/null
+++ b/_includes/download.html
@@ -0,0 +1,12 @@
+<div class='page-heading'>Download Links:</div>
+<hr />
+<p class="text">Current and past versions of TWRP can be found at one of the mirrors below:</p>
+<ul>
+{% for mirror in site.data.mirrors %}
+  <li>
+    <a href="{{ mirror.baseurl }}{{ page.downloadfolder }}">
+      {{ mirror.description }}
+    </a>
+  </li>
+{% endfor %}
+</ul>
diff --git a/_includes/fastbootinstall.html b/_includes/fastbootinstall.html
new file mode 100644
index 0000000..67fddc5
--- /dev/null
+++ b/_includes/fastbootinstall.html
@@ -0,0 +1,9 @@
+<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 image file and copy the file into the same folder as your adb and fastboot binaries. Rename the image to twrp.img and type:</p>
+<p class="text">fastboot flash recovery twrp.img<p></p>fastboot reboot</p>
+<p class="text">Note many devices will replace your custom recovery automatically during first boot. To prevent this, use <a href="http://www.google.com">Google</a> to find the proper key combo to enter recovery. After typing fastboot reboot, hold the key combo and boot to TWRP. Once TWRP is booted, TWRP will patch the stock ROM to prevent the stock ROM from replacing TWRP. If you don't follow this step, you will have to repeat the install.</p>
diff --git a/_includes/flashimageinstall.html b/_includes/flashimageinstall.html
new file mode 100644
index 0000000..3b213eb
--- /dev/null
+++ b/_includes/flashimageinstall.html
@@ -0,0 +1,5 @@
+<div class='page-heading'>flash_image Install Method (Requires Root):</div>
+<hr />
+<p class="text">Download the latest image file (.img) from the download link above. Place it in the root of your /sdcard folder and rename it to twrp.img. Run the following commands via adb shell or a terminal emulator app:</p>
+<p class="text">su</p>
+<p class="text">flash_image recovery /sdcard/twrp.img</p>
diff --git a/_includes/footer.html b/_includes/footer.html
new file mode 100644
index 0000000..132fa21
--- /dev/null
+++ b/_includes/footer.html
@@ -0,0 +1,49 @@
+<footer class="site-footer">
+
+  <div class="wrapper">
+
+    <div class="footer-col-wrapper">
+
+      <div class="footer-col  footer-col-2">
+        <ul class="social-media-list">
+          {% if site.github_username %}
+          <li>
+            <a href="https://github.com/{{ site.github_username }}">
+              <span class="icon  icon--github">
+                <svg viewBox="0 0 16 16">
+                  <path fill="#828282" d="M7.999,0.431c-4.285,0-7.76,3.474-7.76,7.761 c0,3.428,2.223,6.337,5.307,7.363c0.388,0.071,0.53-0.168,0.53-0.374c0-0.184-0.007-0.672-0.01-1.32 c-2.159,0.469-2.614-1.04-2.614-1.04c-0.353-0.896-0.862-1.135-0.862-1.135c-0.705-0.481,0.053-0.472,0.053-0.472 c0.779,0.055,1.189,0.8,1.189,0.8c0.692,1.186,1.816,0.843,2.258,0.645c0.071-0.502,0.271-0.843,0.493-1.037 C4.86,11.425,3.049,10.76,3.049,7.786c0-0.847,0.302-1.54,0.799-2.082C3.768,5.507,3.501,4.718,3.924,3.65 c0,0,0.652-0.209,2.134,0.796C6.677,4.273,7.34,4.187,8,4.184c0.659,0.003,1.323,0.089,1.943,0.261 c1.482-1.004,2.132-0.796,2.132-0.796c0.423,1.068,0.157,1.857,0.077,2.054c0.497,0.542,0.798,1.235,0.798,2.082 c0,2.981-1.814,3.637-3.543,3.829c0.279,0.24,0.527,0.713,0.527,1.437c0,1.037-0.01,1.874-0.01,2.129 c0,0.208,0.14,0.449,0.534,0.373c3.081-1.028,5.302-3.935,5.302-7.362C15.76,3.906,12.285,0.431,7.999,0.431z"/>
+                </svg>
+              </span>
+
+              <span class="username">{{ site.github_username }}</span>
+            </a>
+          </li>
+          {% endif %}
+
+          <li>
+            <a href="https://plus.google.com/communities/106804207647688456928">
+
+              <span class="username">TWRP on G+</span>
+            </a>
+          </li>
+        </ul>
+      </div>
+
+      <div class="footer-col  footer-col-3">
+        <p class="text">{{ site.description }}</p>
+      </div>
+    </div>
+
+<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
+<!-- twrp.me 320x100 large mobile banner -->
+<ins class="adsbygoogle"
+     style="display:inline-block;width:320px;height:100px"
+     data-ad-client="ca-pub-3594204119287048"
+     data-ad-slot="1141077597"></ins>
+<script>
+(adsbygoogle = window.adsbygoogle || []).push({});
+</script>
+
+  </div>
+
+</footer>
diff --git a/_includes/fotakernelnote.html b/_includes/fotakernelnote.html
new file mode 100644
index 0000000..d900d65
--- /dev/null
+++ b/_includes/fotakernelnote.html
@@ -0,0 +1,6 @@
+<div class='page-heading'>Notes About Sony Devices:</div>
+<hr />
+<p class="text">The Xperia devices have a recovery-in-boot arrangement. This means that the recovery is booted using the regular kernel / boot image in the device. Team Win has worked with the FreeXperia device maintainers to come up with a way to extract the ramdisk from the FOTAKernel partition and use the ramdisk from that partition instead of the recovery that is included in the boot image of your device. This means that if you install current CM nightlies and flash TWRP to the FOTAKernel partition, you will be able to use TWRP instead of the CWM or CM recovery that normally comes in a CM boot image. Other boot images including stock kernels can be repacked to include this extraction utility to allow you to use TWRP from the FOTAKernel partition. This setup allows you to choose what recovery you want to have installed and allows you to update your recovery more easily. &nbsp;Unfortunately this setup requires that the boot image that you have installed include the ramdisk extraction utility. &nbsp;The source for this utility is here:</p>
+<p class="text"><a href="https://github.com/Dees-Troy/extract_elf_ramdisk">https://github.com/Dees-Troy/extract_elf_ramdisk</a></p>
+<p class="text">This utility is designed to work in conjunction with the current methods that most AOSP ROMs use for the ramdisk and can also be used on stock kernels. This setup means that you must have a kernel or boot image installed that will use the FOTAKernel method. Most AOSP based ROMs like OmniROM or CyanogenMod will support this method. Some stock kernels may also support the FOTAKernel method.</p>
+<p class="text">What does all this mean? It means that TWRP may not work on your device unless you install other custom software as well. Check with your ROM developer to see what they support.</p>
diff --git a/_includes/head.html b/_includes/head.html
new file mode 100644
index 0000000..47057b5
--- /dev/null
+++ b/_includes/head.html
@@ -0,0 +1,12 @@
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  <title>{% if page.title %}{{ page.title }}{% else %}{{ site.title }}{% endif %}</title>
+  <meta name="description" content="{% if page.excerpt %}{{ page.excerpt | strip_html | strip_newlines | truncate: 160 }}{% else %}{{ site.description }}{% endif %}">
+
+  <link rel="stylesheet" href="{{ "/css/main.css" | prepend: site.baseurl }}">
+  <link rel="canonical" href="{{ page.url | replace:'index.html','' | prepend: site.baseurl | prepend: site.url }}">
+  <link rel="alternate" type="application/rss+xml" title="{{ site.title }}" href="{{ "/feed.xml" | prepend: site.baseurl | prepend: site.url }}" />
+</head>
diff --git a/_includes/header.html b/_includes/header.html
new file mode 100644
index 0000000..3ad432d
--- /dev/null
+++ b/_includes/header.html
@@ -0,0 +1,40 @@
+<header class="site-header">
+
+  <div class="wrapper">
+
+    <a class="site-title" href="{{ site.baseurl }}/">{{ site.title }}</a>
+
+    <nav class="site-nav">
+      <a href="#" class="menu-icon">
+        <svg viewBox="0 0 18 15">
+          <path fill="#424242" d="M18,1.484c0,0.82-0.665,1.484-1.484,1.484H1.484C0.665,2.969,0,2.304,0,1.484l0,0C0,0.665,0.665,0,1.484,0 h15.031C17.335,0,18,0.665,18,1.484L18,1.484z"/>
+          <path fill="#424242" d="M18,7.516C18,8.335,17.335,9,16.516,9H1.484C0.665,9,0,8.335,0,7.516l0,0c0-0.82,0.665-1.484,1.484-1.484 h15.031C17.335,6.031,18,6.696,18,7.516L18,7.516z"/>
+          <path fill="#424242" d="M18,13.516C18,14.335,17.335,15,16.516,15H1.484C0.665,15,0,14.335,0,13.516l0,0 c0-0.82,0.665-1.484,1.484-1.484h15.031C17.335,12.031,18,12.696,18,13.516L18,13.516z"/>
+        </svg>
+      </a>
+
+      <div class="trigger">
+        {% for page in site.pages %}
+          {% if page.title %}
+          <a class="page-link" href="{{ page.url | prepend: site.baseurl }}">{{ page.title }}</a>
+          {% endif %}
+        {% endfor %}
+      </div>
+    </nav>
+
+  </div>
+
+  <div class="wrapper">
+    <script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
+<!-- twrp.me 320x100 large mobile banner -->
+<ins class="adsbygoogle"
+     style="display:inline-block;width:320px;height:100px"
+     data-ad-client="ca-pub-3594204119287048"
+     data-ad-slot="1141077597"></ins>
+<script>
+(adsbygoogle = window.adsbygoogle || []).push({});
+</script>
+  </div>
+
+
+</header>
diff --git a/_includes/mtkinstall.html b/_includes/mtkinstall.html
new file mode 100644
index 0000000..c4c3874
--- /dev/null
+++ b/_includes/mtkinstall.html
@@ -0,0 +1,5 @@
+{% if page.mtkchipset %}
+<div class='page-heading'>MTK Flash Tool Install Method (No Root Required):</div>
+<hr />
+<p class="text">You will need a copy of the factory ROM for the device including the scatter file. You will also need to download a proper MTK Flash Tool version for the chipset of this device ({{ page.mtkchipset }}) and install the VCOM driver for MTK devices. Download the latest image file (.img) from the download link above and rename it to twrp.img and copy it into the same folder as the factory ROM. Open up the MTK flash tool and use the scatter loading button to select the scatter file for this device. Uncheck all of the boxes for all other partitions except for the RECOVERY partition. Click on the folder/filename path for RECOVERY and browse to and select the twrp.img file. Click on the Download button in the MTK Flash tool. Power off your device completely. Plug the device into the computer and wait for it to flash. If it fails to flash the first time you may have to unplug the phone and click Download again. Try this a few times. If it still doesn't work, try a different USB port and USB cable.</p>
+{% endif %}
diff --git a/_includes/odininstall.html b/_includes/odininstall.html
new file mode 100644
index 0000000..0e73c64
--- /dev/null
+++ b/_includes/odininstall.html
@@ -0,0 +1,4 @@
+<div class='page-heading'>Odin Install Method (No Root Required):</div>
+<hr />
+<p class="text">You will need to download and install Odin on your PC. Once you have Odin installed, download the proper .tar file for your device from the download link above. Power off your device. Turn on your device using the proper key combo to get into download mode and attach the device to your computer via a USB cable. Use the PDA tab or button to browse to and select the tar file that you downloaded and flash the device.</p>
+<p class="text">Note many devices will replace your custom recovery automatically during first boot. To prevent this, use <a href="http://www.google.com">Google</a> to find the proper key combo to enter recovery. After typing fastboot reboot, hold the key combo and boot to TWRP. Once TWRP is booted, TWRP will patch the stock ROM to prevent the stock ROM from replacing TWRP. If you don't follow this step, you will have to repeat the install.</p>
diff --git a/_includes/supportstatus.html b/_includes/supportstatus.html
new file mode 100644
index 0000000..66126ba
--- /dev/null
+++ b/_includes/supportstatus.html
@@ -0,0 +1,12 @@
+<div class='page-heading'>Status:</div>
+<hr />
+<p class="text">Support Status: {{ page.supportstatus }}</p>
+<p class="text">Maintainer: {{ page.maintainer }}</p>
+<p class="text">Code Name: {{ page.codename }}</p>
+{% if page.devicetree %}
+<p class="text"><a href="{{ page.devicetree }}">Device Tree / files</a></p>
+{% endif %}
+
+{% if page.xdathread %}
+<p class="text"><a href="{{ page.xdathread }}">Support thread on xda-developers</a></p>
+{% endif %}
diff --git a/_includes/twrpinstall.html b/_includes/twrpinstall.html
new file mode 100644
index 0000000..2ed3389
--- /dev/null
+++ b/_includes/twrpinstall.html
@@ -0,0 +1,3 @@
+<div class='page-heading'>TWRP Install (Requires TWRP 2.8.4 or higher already installed):</div>
+<hr />
+<p class="text">Download the latest TWRP image file (.img) from the download link and boot TWRP. Go to install and find and select the Images... button. Browse to the image that you downloaded and select it. Choose recovery and swipe to flash.</p>
diff --git a/_layouts/default.html b/_layouts/default.html
new file mode 100644
index 0000000..e4ab96f
--- /dev/null
+++ b/_layouts/default.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+
+  {% include head.html %}
+
+  <body>
+
+    {% include header.html %}
+
+    <div class="page-content">
+      <div class="wrapper">
+        {{ content }}
+      </div>
+    </div>
+
+    {% include footer.html %}
+
+  </body>
+
+</html>
diff --git a/_layouts/device.html b/_layouts/device.html
new file mode 100644
index 0000000..ca40b86
--- /dev/null
+++ b/_layouts/device.html
@@ -0,0 +1,15 @@
+---
+layout: default
+---
+<div class="post">
+
+  <header>
+    <h1 class="post-title">TWRP for {{ page.title }}</h1>
+    <p class="post-meta">{{ page.date | date: "%b %-d, %Y" }}{% if page.author %} • {{ page.author }}{% endif %}{% if page.meta %} • {{ page.meta }}{% endif %}</p>
+  </header>
+
+  <article class="post-content">
+    {{ content }}
+  </article>
+
+</div>
diff --git a/_layouts/none.html b/_layouts/none.html
new file mode 100644
index 0000000..4d9e9ca
--- /dev/null
+++ b/_layouts/none.html
@@ -0,0 +1,4 @@
+---
+layout: none
+---
+{{ content }}
diff --git a/_layouts/page.html b/_layouts/page.html
new file mode 100644
index 0000000..74c1a11
--- /dev/null
+++ b/_layouts/page.html
@@ -0,0 +1,14 @@
+---
+layout: default
+---
+<div class="post">
+
+  <header class="post-header">
+    <h1 class="post-title">{{ page.title }}</h1>
+  </header>
+
+  <article class="post-content">
+    {{ content }}
+  </article>
+
+</div>
diff --git a/_layouts/post.html b/_layouts/post.html
new file mode 100644
index 0000000..a2b4e52
--- /dev/null
+++ b/_layouts/post.html
@@ -0,0 +1,15 @@
+---
+layout: default
+---
+<div class="post">
+
+  <header class="post-header">
+    <h1 class="post-title">{{ page.title }}</h1>
+    <p class="post-meta">{{ page.date | date: "%b %-d, %Y" }}{% if page.author %} • {{ page.author }}{% endif %}{% if page.meta %} • {{ page.meta }}{% endif %}</p>
+  </header>
+
+  <article class="post-content">
+    {{ content }}
+  </article>
+
+</div>
diff --git a/_posts/2014-11-20-twrp-2.8.2.0-released.markdown b/_posts/2014-11-20-twrp-2.8.2.0-released.markdown
new file mode 100644
index 0000000..2a5df1b
--- /dev/null
+++ b/_posts/2014-11-20-twrp-2.8.2.0-released.markdown
@@ -0,0 +1,25 @@
+---
+layout: post
+title:  "TWRP 2.8.2.0 Released"
+date:   2014-11-20 09:15:42
+categories: site update
+---
+
+TWRP 2.8.2.0 is out now, but only for Nexus devices.
+
+What's new in 2.8.2.0:
+
+  * MTP fixes and improvements - you can now copy zips to the root of storage - thanks to _that
+  * Pull in all changes from Android 5.0 lollipop into TWRP
+  * Add decrypt support for Android 5.0 lollipop encrypted partitions including automatic decrypt when the default_password is in use
+  * Revert some changes to exFAT that were breaking exFAT support on some devices
+  * Other minor fixes and updates
+
+Note: At this time we do not have a GUI representation for pattern unlock. You can still decrypt patterns though by translating the pattern dots to numbers. The pattern dots correspond to numbers in the following pattern:
+<p>1 2 3</p>
+<p>4 5 6</p>
+<p>7 8 9</p>
+
+So an upper-case L would translate to a password of 14789 entered on the keyboard. Eventually we plan to add a proper pattern unlock to TWRP but it is a relatively low priority at this point.
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_posts/2014-12-22-twrp-2.8.3.0-released.markdown b/_posts/2014-12-22-twrp-2.8.3.0-released.markdown
new file mode 100644
index 0000000..fa54af1
--- /dev/null
+++ b/_posts/2014-12-22-twrp-2.8.3.0-released.markdown
@@ -0,0 +1,26 @@
+---
+layout: post
+title:  "TWRP 2.8.3.0 Released"
+date:   2014-12-22 11:19:42
+categories: site update
+---
+
+TWRP 2.8.3.0 is out now for all currently supported devices.
+
+What's new in 2.8.3.0:
+
+  * MTP fixes and improvements - you can now copy zips to the root of storage - thanks to _that
+  * MTP will now tell the host PC that storage is removed instead of disabling MTP completely
+  * MTP will now report the correct max file size based on the file system in use to the host PC (may fix transfer of large files)
+  * Update and improve fix permissions and make fixing contexts optional
+  * Update SuperSU in TWRP to 2.40 and update install process
+  * Make TWRP work properly on AArch64 (Nexus 9 is now built in true 64-bit binaries and libraries)
+  * Attempt to set correct permissions and contexts on all files placed in storage so backups will show in Android
+  * Fix kernel panic during MTP start on some devices
+  * Support unicode fonts on devices with True Type Font support
+  * Fix slider value not showing sometimes (vibration settings page)
+  * Toggle MTP off during adb sideload to set correct USB IDs
+  * Reduce library requirements for 5.0 L decrypt
+  * Other minor fixes and improvements
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_posts/2015-01-13-twrp-2.8.4.0-released.markdown b/_posts/2015-01-13-twrp-2.8.4.0-released.markdown
new file mode 100644
index 0000000..5dd2091
--- /dev/null
+++ b/_posts/2015-01-13-twrp-2.8.4.0-released.markdown
@@ -0,0 +1,24 @@
+---
+layout: post
+title:  "TWRP 2.8.4.0 Released"
+date:   2015-01-13 10:23:32
+categories: site update
+---
+
+TWRP 2.8.4.0 is out now for all currently supported devices.
+
+What's new in 2.8.4.0:
+
+  * Add flashing of boot and recovery images via the TWRP GUI (Find the Images button on the Install page)
+  * Fix some MTP related crashes and bugs
+  * Eliminate TWRP toggling USB IDs during boot if MTP is enabled
+  * Fix various adb sideload issues
+  * Improve threading of actions
+  * Eliminate separate thread for screen timeout
+  * Update libblkid to 2.25.0
+  * Use power button as back button on watch themes for easier navigation
+  * Add mutex locking to data manager
+  * Improve custom theme handling on encrypted devices
+  * Allow the stock theme to be offset by build flags so we can center a lower res theme on a higher res screen especially for watches with round screens
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_posts/2015-02-12-twrp-2.8.5.0-released.markdown b/_posts/2015-02-12-twrp-2.8.5.0-released.markdown
new file mode 100644
index 0000000..1955a3e
--- /dev/null
+++ b/_posts/2015-02-12-twrp-2.8.5.0-released.markdown
@@ -0,0 +1,22 @@
+---
+layout: post
+title:  "TWRP 2.8.5.0 Released"
+date:   2015-02-12 08:44:12
+categories: site update
+version: 2.8.5.0
+---
+
+TWRP {{ page.version }} is out now for all currently supported devices.
+
+What's new in {{ page.version }}:
+
+  * Scale the GUI - TWRP can read the theme's resolution and scale it up or down to fit the theme to your screen's resolution
+  * Backups can now be cancelled while the backup is in progress (does not include restore because we don't want to leave your device in a bad state)
+  * Improve thread handling and move input handling into the main rendering thread to improve stability
+  * Make MTP work even if unplugged and plugged back in
+  * Unify scrollable list code and make kinetic scrolling feel more natural
+  * Fix handling of mapped zip files for OTA updates (CM12 updater)
+  * USB keyboards should now work on all devices that support USB host mode via a USB OTG cable
+  * Other small fixes and improvements
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_posts/2015-03-01-welcome-to-new-site.markdown b/_posts/2015-03-01-welcome-to-new-site.markdown
new file mode 100644
index 0000000..523642f
--- /dev/null
+++ b/_posts/2015-03-01-welcome-to-new-site.markdown
@@ -0,0 +1,8 @@
+---
+layout: post
+title:  "Welcome to the New Team Win Website"
+date:   2015-03-01 15:04:05
+categories: site update
+---
+
+Welcome to the new Team Win site! This new site is powered by [jekyllrb](http://jekyllrb.com/) and our plan is to push the site up to github and accept site changes via our own Gerrit server. This crowd sourcing of site updates should help us find and fix errors faster and help streamline some of the device specific support. Hope you like it!
diff --git a/_sass/_base.scss b/_sass/_base.scss
new file mode 100644
index 0000000..e5fd0fd
--- /dev/null
+++ b/_sass/_base.scss
@@ -0,0 +1,204 @@
+/**
+ * Reset some basic elements
+ */
+body, h1, h2, h3, h4, h5, h6,
+p, blockquote, pre, hr,
+dl, dd, ol, ul, figure {
+    margin: 0;
+    padding: 0;
+}
+
+
+
+/**
+ * Basic styling
+ */
+body {
+    font-family: $base-font-family;
+    font-size: $base-font-size;
+    line-height: $base-line-height;
+    font-weight: 300;
+    color: $text-color;
+    background-color: $background-color;
+    -webkit-text-size-adjust: 100%;
+}
+
+
+
+/**
+ * Set `margin-bottom` to maintain vertical rhythm
+ */
+h1, h2, h3, h4, h5, h6,
+p, blockquote, pre,
+ul, ol, dl, figure,
+%vertical-rhythm {
+    margin-bottom: $spacing-unit / 2;
+}
+
+
+
+/**
+ * Images
+ */
+img {
+    max-width: 100%;
+    vertical-align: middle;
+}
+
+
+
+/**
+ * Figures
+ */
+figure > img {
+    display: block;
+}
+
+figcaption {
+    font-size: $small-font-size;
+}
+
+
+
+/**
+ * Lists
+ */
+ul, ol {
+    margin-left: $spacing-unit;
+}
+
+li {
+    > ul,
+    > ol {
+         margin-bottom: 0;
+    }
+}
+
+
+
+/**
+ * Headings
+ */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 300;
+}
+
+
+
+/**
+ * Links
+ */
+a {
+    color: $brand-color;
+    text-decoration: none;
+
+    &:visited {
+        color: darken($brand-color, 15%);
+    }
+
+    &:hover {
+        color: $text-color;
+        text-decoration: underline;
+    }
+}
+
+
+
+/**
+ * Blockquotes
+ */
+blockquote {
+    color: $grey-color;
+    border-left: 4px solid $grey-color-light;
+    padding-left: $spacing-unit / 2;
+    font-size: 18px;
+    letter-spacing: -1px;
+    font-style: italic;
+
+    > :last-child {
+        margin-bottom: 0;
+    }
+}
+
+
+
+/**
+ * Code formatting
+ */
+pre,
+code {
+    font-size: 15px;
+    border: 1px solid $grey-color-light;
+    border-radius: 3px;
+    background-color: #eef;
+}
+
+code {
+    padding: 1px 5px;
+}
+
+pre {
+    padding: 8px 12px;
+    overflow-x: scroll;
+
+    > code {
+        border: 0;
+        padding-right: 0;
+        padding-left: 0;
+    }
+}
+
+
+
+/**
+ * Wrapper
+ */
+.wrapper {
+    max-width: -webkit-calc(#{$content-width} - (#{$spacing-unit} * 2));
+    max-width:         calc(#{$content-width} - (#{$spacing-unit} * 2));
+    margin-right: auto;
+    margin-left: auto;
+    padding-right: $spacing-unit;
+    padding-left: $spacing-unit;
+    @extend %clearfix;
+
+    @include media-query($on-laptop) {
+        max-width: -webkit-calc(#{$content-width} - (#{$spacing-unit}));
+        max-width:         calc(#{$content-width} - (#{$spacing-unit}));
+        padding-right: $spacing-unit / 2;
+        padding-left: $spacing-unit / 2;
+    }
+}
+
+
+
+/**
+ * Clearfix
+ */
+%clearfix {
+
+    &:after {
+        content: "";
+        display: table;
+        clear: both;
+    }
+}
+
+
+
+/**
+ * Icons
+ */
+.icon {
+
+    > svg {
+        display: inline-block;
+        width: 16px;
+        height: 16px;
+        vertical-align: middle;
+
+        path {
+            fill: $grey-color;
+        }
+    }
+}
diff --git a/_sass/_layout.scss b/_sass/_layout.scss
new file mode 100644
index 0000000..def56f8
--- /dev/null
+++ b/_sass/_layout.scss
@@ -0,0 +1,236 @@
+/**
+ * Site header
+ */
+.site-header {
+    border-top: 5px solid $grey-color-dark;
+    border-bottom: 1px solid $grey-color-light;
+    min-height: 56px;
+
+    // Positioning context for the mobile navigation icon
+    position: relative;
+}
+
+.site-title {
+    font-size: 26px;
+    line-height: 56px;
+    letter-spacing: -1px;
+    margin-bottom: 0;
+    float: left;
+
+    &,
+    &:visited {
+        color: $grey-color-dark;
+    }
+}
+
+.site-nav {
+    float: right;
+    line-height: 56px;
+
+    .menu-icon {
+        display: none;
+    }
+
+    .page-link {
+        color: $text-color;
+        line-height: $base-line-height;
+
+        // Gaps between nav items, but not on the first one
+        &:not(:first-child) {
+            margin-left: 20px;
+        }
+    }
+
+    @include media-query($on-palm) {
+        position: absolute;
+        top: 9px;
+        right: 30px;
+        background-color: $background-color;
+        border: 1px solid $grey-color-light;
+        border-radius: 5px;
+        text-align: right;
+
+        .menu-icon {
+            display: block;
+            float: right;
+            width: 36px;
+            height: 26px;
+            line-height: 0;
+            padding-top: 10px;
+            text-align: center;
+
+            > svg {
+                width: 18px;
+                height: 15px;
+
+                path {
+                    fill: $grey-color-dark;
+                }
+            }
+        }
+
+        .trigger {
+            clear: both;
+            display: none;
+        }
+
+        &:hover .trigger {
+            display: block;
+            padding-bottom: 5px;
+        }
+
+        .page-link {
+            display: block;
+            padding: 5px 10px;
+        }
+    }
+}
+
+
+
+/**
+ * Site footer
+ */
+.site-footer {
+    border-top: 1px solid $grey-color-light;
+    padding: $spacing-unit 0;
+}
+
+.footer-heading {
+    font-size: 18px;
+    margin-bottom: $spacing-unit / 2;
+}
+
+.contact-list,
+.social-media-list {
+    list-style: none;
+    margin-left: 0;
+}
+
+.footer-col-wrapper {
+    font-size: 15px;
+    color: $grey-color;
+    margin-left: -$spacing-unit / 2;
+    @extend %clearfix;
+}
+
+.footer-col {
+    float: left;
+    margin-bottom: $spacing-unit / 2;
+    padding-left: $spacing-unit / 2;
+}
+
+.footer-col-1 {
+    width: -webkit-calc(35% - (#{$spacing-unit} / 2));
+    width:         calc(35% - (#{$spacing-unit} / 2));
+}
+
+.footer-col-2 {
+    width: -webkit-calc(20% - (#{$spacing-unit} / 2));
+    width:         calc(20% - (#{$spacing-unit} / 2));
+}
+
+.footer-col-3 {
+    width: -webkit-calc(45% - (#{$spacing-unit} / 2));
+    width:         calc(45% - (#{$spacing-unit} / 2));
+}
+
+@include media-query($on-laptop) {
+    .footer-col-1,
+    .footer-col-2 {
+        width: -webkit-calc(50% - (#{$spacing-unit} / 2));
+        width:         calc(50% - (#{$spacing-unit} / 2));
+    }
+
+    .footer-col-3 {
+        width: -webkit-calc(100% - (#{$spacing-unit} / 2));
+        width:         calc(100% - (#{$spacing-unit} / 2));
+    }
+}
+
+@include media-query($on-palm) {
+    .footer-col {
+        float: none;
+        width: -webkit-calc(100% - (#{$spacing-unit} / 2));
+        width:         calc(100% - (#{$spacing-unit} / 2));
+    }
+}
+
+
+
+/**
+ * Page content
+ */
+.page-content {
+    padding: $spacing-unit 0;
+}
+
+.page-heading {
+    font-size: 20px;
+}
+
+.post-list {
+    margin-left: 0;
+    list-style: none;
+
+    > li {
+        margin-bottom: $spacing-unit;
+    }
+}
+
+.post-meta {
+    font-size: $small-font-size;
+    color: $grey-color;
+}
+
+.post-link {
+    display: block;
+    font-size: 24px;
+}
+
+
+
+/**
+ * Posts
+ */
+.post-header {
+    margin-bottom: $spacing-unit;
+}
+
+.post-title {
+    font-size: 42px;
+    letter-spacing: -1px;
+    line-height: 1;
+
+    @include media-query($on-laptop) {
+        font-size: 36px;
+    }
+}
+
+.post-content {
+    margin-bottom: $spacing-unit;
+
+    h2 {
+        font-size: 32px;
+
+        @include media-query($on-laptop) {
+            font-size: 28px;
+        }
+    }
+
+    h3 {
+        font-size: 26px;
+
+        @include media-query($on-laptop) {
+            font-size: 22px;
+        }
+    }
+
+    h4 {
+        font-size: 20px;
+
+        @include media-query($on-laptop) {
+            font-size: 18px;
+        }
+    }
+}
diff --git a/_sass/_syntax-highlighting.scss b/_sass/_syntax-highlighting.scss
new file mode 100644
index 0000000..e36627d
--- /dev/null
+++ b/_sass/_syntax-highlighting.scss
@@ -0,0 +1,67 @@
+/**
+ * Syntax highlighting styles
+ */
+.highlight {
+    background: #fff;
+    @extend %vertical-rhythm;
+
+    .c     { color: #998; font-style: italic } // Comment
+    .err   { color: #a61717; background-color: #e3d2d2 } // Error
+    .k     { font-weight: bold } // Keyword
+    .o     { font-weight: bold } // Operator
+    .cm    { color: #998; font-style: italic } // Comment.Multiline
+    .cp    { color: #999; font-weight: bold } // Comment.Preproc
+    .c1    { color: #998; font-style: italic } // Comment.Single
+    .cs    { color: #999; font-weight: bold; font-style: italic } // Comment.Special
+    .gd    { color: #000; background-color: #fdd } // Generic.Deleted
+    .gd .x { color: #000; background-color: #faa } // Generic.Deleted.Specific
+    .ge    { font-style: italic } // Generic.Emph
+    .gr    { color: #a00 } // Generic.Error
+    .gh    { color: #999 } // Generic.Heading
+    .gi    { color: #000; background-color: #dfd } // Generic.Inserted
+    .gi .x { color: #000; background-color: #afa } // Generic.Inserted.Specific
+    .go    { color: #888 } // Generic.Output
+    .gp    { color: #555 } // Generic.Prompt
+    .gs    { font-weight: bold } // Generic.Strong
+    .gu    { color: #aaa } // Generic.Subheading
+    .gt    { color: #a00 } // Generic.Traceback
+    .kc    { font-weight: bold } // Keyword.Constant
+    .kd    { font-weight: bold } // Keyword.Declaration
+    .kp    { font-weight: bold } // Keyword.Pseudo
+    .kr    { font-weight: bold } // Keyword.Reserved
+    .kt    { color: #458; font-weight: bold } // Keyword.Type
+    .m     { color: #099 } // Literal.Number
+    .s     { color: #d14 } // Literal.String
+    .na    { color: #008080 } // Name.Attribute
+    .nb    { color: #0086B3 } // Name.Builtin
+    .nc    { color: #458; font-weight: bold } // Name.Class
+    .no    { color: #008080 } // Name.Constant
+    .ni    { color: #800080 } // Name.Entity
+    .ne    { color: #900; font-weight: bold } // Name.Exception
+    .nf    { color: #900; font-weight: bold } // Name.Function
+    .nn    { color: #555 } // Name.Namespace
+    .nt    { color: #000080 } // Name.Tag
+    .nv    { color: #008080 } // Name.Variable
+    .ow    { font-weight: bold } // Operator.Word
+    .w     { color: #bbb } // Text.Whitespace
+    .mf    { color: #099 } // Literal.Number.Float
+    .mh    { color: #099 } // Literal.Number.Hex
+    .mi    { color: #099 } // Literal.Number.Integer
+    .mo    { color: #099 } // Literal.Number.Oct
+    .sb    { color: #d14 } // Literal.String.Backtick
+    .sc    { color: #d14 } // Literal.String.Char
+    .sd    { color: #d14 } // Literal.String.Doc
+    .s2    { color: #d14 } // Literal.String.Double
+    .se    { color: #d14 } // Literal.String.Escape
+    .sh    { color: #d14 } // Literal.String.Heredoc
+    .si    { color: #d14 } // Literal.String.Interpol
+    .sx    { color: #d14 } // Literal.String.Other
+    .sr    { color: #009926 } // Literal.String.Regex
+    .s1    { color: #d14 } // Literal.String.Single
+    .ss    { color: #990073 } // Literal.String.Symbol
+    .bp    { color: #999 } // Name.Builtin.Pseudo
+    .vc    { color: #008080 } // Name.Variable.Class
+    .vg    { color: #008080 } // Name.Variable.Global
+    .vi    { color: #008080 } // Name.Variable.Instance
+    .il    { color: #099 } // Literal.Number.Integer.Long
+}
diff --git a/about.md b/about.md
new file mode 100644
index 0000000..3eb7fef
--- /dev/null
+++ b/about.md
@@ -0,0 +1,13 @@
+---
+layout: page
+title: About
+permalink: /about/
+---
+
+TWRP is an open source, community project. TWRP development is done by roughly 4 people at this point. We also have a large support community with many people who are willing to answer questions and help people with their devices either through our [IRC channel](http://webchat.freenode.net/?channels=twrp) or on forums like [xda-developers](http://forum.xda-developers.com/).
+
+Team Win was originally formed to work on porting WiMAX to CM7 for the HTC EVO 4G. After our work on the EVO 4G we wanted to work on a project that would work on more devices than just the EVO 4G and we settled on working on a recovery. Today TWRP is the leading custom recovery for Android phones.
+
+A custom recovery is used for installing custom software on your device. This custom software can include smaller modifications like rooting your device or even replacing the firmware of the device with a completely custom "ROM" like [OmniROM](http://omnirom.org/)
+
+You can find the source code for TWRP at [github.com/omnirom/android_bootable_recovery/](https://github.com/omnirom/android_bootable_recovery/)
diff --git a/contactus/index.html b/contactus/index.html
new file mode 100644
index 0000000..107628f
--- /dev/null
+++ b/contactus/index.html
@@ -0,0 +1,55 @@
+---
+layout: page
+title: Contact Us
+permalink: /contactus/
+---
+<script type="text/javascript">
+function validateForm() {
+	emailre = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
+	if (document.emailform.fname.value == "") {
+		alert("Please provide your first name.");
+		document.emailform.fname.focus();
+		return false;
+	}
+	if (document.emailform.lname.value == "") {
+		alert("Please provide your last name.");
+		document.emailform.lname.focus();
+		return false;
+	}
+	if (document.emailform.email.value == "" || !emailre.test(document.emailform.email.value)) {
+		alert("Please provide a valid email.");
+		document.emailform.email.focus();
+		return false;
+	}
+	if (document.emailform.subject.value == "") {
+		alert("Please provide a subject line.");
+		document.emailform.subject.focus();
+		return false;
+	}
+	if (document.emailform.emailtext.value == "") {
+		alert("Please provide email text.");
+		document.emailform.emailtext.focus();
+		return false;
+	}
+	return true;
+}
+</script>
+
+<div class="home">
+<p class="text">Less than 1% of emails will receive a reply. The vast majority of emails that we receive could be answered by <a href="../FAQ/index.html">reading the FAQ</a> or searching on <a href="http://forum.xda-developers.com/">xda-developers forums</a> for the answer.</p>
+<p class="text">If you have truly found a bug, post it in our <a href="https://github.com/TeamWin/Team-Win-Recovery-Project/issues">Github issues log</a> instead of sending an email so we can better track the bug and fix it.</p>
+<p class="text">If you are a company interested in a partnership or a developer who is interested in porting or working on TWRP, you are the 1% who will likely get a reply. Thanks for your consideration.</p>
+<form action="/contactus/submit.php" onSubmit="return validateForm();" method="POST" id="emailform" name="emailform">
+First Name:<br/>
+<input type="text" name="fname" id="fname"/><br/>
+Last Name:<br/>
+<input type="text" name="lname" id="lname"/><br/>
+Email:<br/>
+<input type="text" name="email" id="email"/><br/>
+Subject:<br/>
+<input type="text" name="subject" id="subject"/><br/>
+Message:<br/>
+<textarea rows="10" cols="50" name="emailtext" id="emailtext" form="emailform"></textarea><br/>
+<input type="submit" value="Submit"/>
+</form>
+</div>
diff --git a/css/main.scss b/css/main.scss
new file mode 100755
index 0000000..beee4e3
--- /dev/null
+++ b/css/main.scss
@@ -0,0 +1,52 @@
+---
+# Only the main Sass file needs front matter (the dashes are enough)
+---
+@charset "utf-8";
+
+
+
+// Our variables
+$base-font-family: Helvetica, Arial, sans-serif;
+$base-font-size:   16px;
+$small-font-size:  $base-font-size * 0.875;
+$base-line-height: 1.5;
+
+$spacing-unit:     30px;
+
+$text-color:       #111;
+$background-color: #fdfdfd;
+$brand-color:      #2a7ae2;
+
+$grey-color:       #828282;
+$grey-color-light: lighten($grey-color, 40%);
+$grey-color-dark:  darken($grey-color, 25%);
+
+// Width of the content area
+$content-width:    800px;
+
+$on-palm:          600px;
+$on-laptop:        800px;
+
+
+
+// Using media queries with like this:
+// @include media-query($on-palm) {
+//     .wrapper {
+//         padding-right: $spacing-unit / 2;
+//         padding-left: $spacing-unit / 2;
+//     }
+// }
+@mixin media-query($device) {
+    @media screen and (max-width: $device) {
+        @content;
+    }
+}
+
+
+
+// Import partials from `sass_dir` (defaults to `_sass`)
+@import
+        "base",
+        "layout",
+        "syntax-highlighting"
+;
diff --git a/datamedia/index.html b/datamedia/index.html
new file mode 120000
index 0000000..d902fc3
--- /dev/null
+++ b/datamedia/index.html
@@ -0,0 +1 @@
+../faq/datamedia.html
\ No newline at end of file
diff --git a/dest/jekyll-search.js b/dest/jekyll-search.js
new file mode 100644
index 0000000..04d6a0d
--- /dev/null
+++ b/dest/jekyll-search.js
@@ -0,0 +1 @@
+!function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a="function"==typeof require&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}for(var i="function"==typeof require&&require,o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module){module.exports=function(){function receivedResponse(xhr){return 200==xhr.status&&4==xhr.readyState}function handleResponse(xhr,callback){xhr.onreadystatechange=function(){if(receivedResponse(xhr))try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err,null)}}}var self=this;self.load=function(location,callback){var xhr=window.XMLHttpRequest?new XMLHttpRequest:new ActiveXObject("Microsoft.XMLHTTP");xhr.open("GET",location,!0),handleResponse(xhr,callback),xhr.send()}}},{}],2:[function(require,module){function FuzzySearchStrategy(){function createFuzzyRegExpFromString(string){return new RegExp(string.split("").join(".*?"),"gi")}var self=this;self.matches=function(string,crit){return"string"!=typeof string?!1:(string=string.trim(),!!string.match(createFuzzyRegExpFromString(crit)))}}module.exports=new FuzzySearchStrategy},{}],3:[function(require,module){function LiteralSearchStrategy(){function doMatch(string,crit){return string.toLowerCase().indexOf(crit.toLowerCase())>=0}var self=this;self.matches=function(string,crit){return"string"!=typeof string?!1:(string=string.trim(),doMatch(string,crit))}}module.exports=new LiteralSearchStrategy},{}],4:[function(require,module){module.exports=function(){function findMatches(store,crit,strategy){for(var data=store.get(),i=0;i<data.length&&matches.length<limit;i++)findMatchesInObject(data[i],crit,strategy);return matches}function findMatchesInObject(obj,crit,strategy){for(var key in obj)if(strategy.matches(obj[key],crit)){matches.push(obj);break}}function getSearchStrategy(){return fuzzy?fuzzySearchStrategy:literalSearchStrategy}var self=this,matches=[],fuzzy=!1,limit=10,fuzzySearchStrategy=require("./SearchStrategies/fuzzy"),literalSearchStrategy=require("./SearchStrategies/literal");self.setFuzzy=function(_fuzzy){fuzzy=!!_fuzzy},self.setLimit=function(_limit){limit=parseInt(_limit,10)||limit},self.search=function(data,crit){return crit?(matches.length=0,findMatches(data,crit,getSearchStrategy())):[]}}},{"./SearchStrategies/fuzzy":2,"./SearchStrategies/literal":3}],5:[function(require,module){module.exports=function(_store){function isObject(obj){return!!obj&&"[object Object]"==Object.prototype.toString.call(obj)}function isArray(obj){return!!obj&&"[object Array]"==Object.prototype.toString.call(obj)}function addObject(data){return store.push(data),data}function addArray(data){for(var added=[],i=0;i<data.length;i++)isObject(data[i])&&added.push(addObject(data[i]));return added}var self=this,store=[];isArray(_store)&&addArray(_store),self.clear=function(){return store.length=0,store},self.get=function(){return store},self.put=function(data){return isObject(data)?addObject(data):isArray(data)?addArray(data):void 0}}},{}],6:[function(require,module){module.exports=function(){var self=this,templatePattern=/\{(.*?)\}/g;self.setTemplatePattern=function(newTemplatePattern){templatePattern=newTemplatePattern},self.render=function(t,data){return t.replace(templatePattern,function(match,prop){return data[prop]||match})}}},{}],7:[function(require){!function(window){"use strict";function SimpleJekyllSearch(){function initWithJSON(){store.put(opt.dataSource),registerInput()}function initWithURL(url){jsonLoader.load(url,function(err,json){err?throwError("failed to get JSON ("+url+")"):(store.put(json),registerInput())})}function throwError(message){throw new Error("SimpleJekyllSearch --- "+message)}function validateOptions(_opt){for(var i=0;i<requiredOptions.length;i++){var req=requiredOptions[i];_opt[req]||throwError("You must specify a "+req)}}function assignOptions(_opt){for(var option in opt)opt[option]=_opt[option]||opt[option]}function isJSON(json){try{return json instanceof Object&&JSON.parse(JSON.stringify(json))}catch(e){return!1}}function emptyResultsContainer(){opt.resultsContainer.innerHTML=""}function appendToResultsContainer(text){opt.resultsContainer.innerHTML+=text}function registerInput(){opt.searchInput.addEventListener("keyup",function(e){return 0==e.target.value.length?void emptyResultsContainer():void render(searcher.search(store,e.target.value))})}function render(results){if(emptyResultsContainer(),0==results.length)return appendToResultsContainer(opt.noResultsText);for(var i=0;i<results.length;i++)appendToResultsContainer(templater.render(opt.searchResultTemplate,results[i]))}var self=this,requiredOptions=["searchInput","resultsContainer","dataSource"],opt={searchInput:null,resultsContainer:null,dataSource:[],searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',noResultsText:"No results found",limit:10,fuzzy:!1};self.init=function(_opt){validateOptions(_opt),assignOptions(_opt),isJSON(opt.dataSource)?initWithJSON(opt.dataSource):initWithURL(opt.dataSource)}}var Searcher=require("./Searcher"),Templater=require("./Templater"),Store=require("./Store"),JSONLoader=require("./JSONLoader"),searcher=new Searcher,templater=new Templater,store=new Store,jsonLoader=new JSONLoader;window.SimpleJekyllSearch=new SimpleJekyllSearch}(window,document)},{"./JSONLoader":1,"./Searcher":4,"./Store":5,"./Templater":6}]},{},[7]);
\ No newline at end of file
diff --git a/devices/index.html b/devices/index.html
new file mode 100644
index 0000000..f1ac854
--- /dev/null
+++ b/devices/index.html
@@ -0,0 +1,36 @@
+---
+layout: page
+title: Devices
+permalink: /Devices/
+---
+
+<div class="home">
+
+  <hr />
+  <p></p>
+<div class='page-heading'>Search for TWRP for your device here:</div>
+<script src="/js/jekyll-search.js"></script>
+<input type="text" id="search-input" placeholder="Search..">
+<br/><br/>
+<hr />
+<div id="results"></div>
+<br/>
+  <ul class="post-list" id="post-list">
+    {% for post in site.devices %}
+      <p>
+        <a class="post-meta" href="{{ post.url | prepend: site.baseurl }}">{{ post.title }} ({{ post.codename }})</a>
+      </p>
+    {% endfor %}
+  </ul>
+<script type='text/javascript' src='http://ajax.googleapis.com/ajax/libs/jquery/1.10.1/jquery.min.js'></script>
+    <script type="text/javascript">
+      SimpleJekyllSearch.init({
+        searchInput: document.getElementById('search-input'),
+        resultsContainer: document.getElementById('results'),
+        dataSource: '/search.json',
+        searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
+        noResultsText: 'No results found',
+        fuzzy: false,
+      })
+    </script>
+</div>
diff --git a/emailsent/index.html b/emailsent/index.html
new file mode 100644
index 0000000..7072e36
--- /dev/null
+++ b/emailsent/index.html
@@ -0,0 +1,7 @@
+---
+layout: page
+---
+
+<div class="home">
+<p>Your email has been sent.</p>
+</div>
diff --git a/faq/index.html b/faq/index.html
new file mode 100644
index 0000000..17e34f1
--- /dev/null
+++ b/faq/index.html
@@ -0,0 +1,17 @@
+---
+layout: page
+title: FAQ
+permalink: /FAQ/
+---
+
+<div class="home">
+
+  <ul class="post-list">
+    {% for post in site.faq %}
+      <p>
+        <a class="post-meta" href="{{ post.url | prepend: site.baseurl }}">{{ post.title }}</a>
+      </p>
+    {% endfor %}
+  </ul>
+
+</div>
diff --git a/feed.xml b/feed.xml
new file mode 100644
index 0000000..a6628bd
--- /dev/null
+++ b/feed.xml
@@ -0,0 +1,30 @@
+---
+layout: null
+---
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>{{ site.title | xml_escape }}</title>
+    <description>{{ site.description | xml_escape }}</description>
+    <link>{{ site.url }}{{ site.baseurl }}/</link>
+    <atom:link href="{{ "/feed.xml" | prepend: site.baseurl | prepend: site.url }}" rel="self" type="application/rss+xml"/>
+    <pubDate>{{ site.time | date_to_rfc822 }}</pubDate>
+    <lastBuildDate>{{ site.time | date_to_rfc822 }}</lastBuildDate>
+    <generator>Jekyll v{{ jekyll.version }}</generator>
+    {% for post in site.posts limit:10 %}
+      <item>
+        <title>{{ post.title | xml_escape }}</title>
+        <description>{{ post.content | xml_escape }}</description>
+        <pubDate>{{ post.date | date_to_rfc822 }}</pubDate>
+        <link>{{ post.url | prepend: site.baseurl | prepend: site.url }}</link>
+        <guid isPermaLink="true">{{ post.url | prepend: site.baseurl | prepend: site.url }}</guid>
+        {% for tag in post.tags %}
+        <category>{{ tag | xml_escape }}</category>
+        {% endfor %}
+        {% for cat in post.categories %}
+        <category>{{ cat | xml_escape }}</category>
+        {% endfor %}
+      </item>
+    {% endfor %}
+  </channel>
+</rss>
diff --git a/gulpfile.js b/gulpfile.js
new file mode 100644
index 0000000..45e1c18
--- /dev/null
+++ b/gulpfile.js
@@ -0,0 +1,47 @@
+var gulp = require('gulp');
+var browserify = require('gulp-browserify');
+var rename = require('gulp-rename');
+var using = require('gulp-using');
+var concat = require('gulp-concat');
+var uglify = require('gulp-uglify');
+
+var browserifyEntryPoint = 'src/index.js';
+
+
+
+
+
+gulp.task('default', ['js:src','js:test:unit'])
+
+gulp.task('watch',['default'], function(){
+  gulp.watch(['!'+browserifyEntryPoint,'src/**/*.js'], ['js:src','js:test:unit']);
+  gulp.watch(['!test/unit/browserifiedTests.js','test/unit/**/*Test.js'], ['js:test:unit']);
+});
+
+
+
+
+
+
+gulp.task('js:src', function() {
+  gulp.src(browserifyEntryPoint)
+    .pipe(browserify({
+      // insertGlobals : true,
+      debug : !process.env.PROD
+    }))
+    .pipe(uglify({mangle: false,compress:true}))
+    .pipe(rename('jekyll-search.js'))
+    .pipe(gulp.dest('./dest/'))
+});
+
+gulp.task('js:test:unit', function() {
+  gulp.src(['test/unit/**/*Test.js'])
+    .pipe(using())
+    .pipe(concat('browserifiedTests.js'))
+    .pipe(browserify({
+      // insertGlobals : true,
+      debug : !process.env.PROD
+    }))
+    .pipe(using())
+    .pipe(gulp.dest('./test/unit/'))
+});
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..85e396d
--- /dev/null
+++ b/index.html
@@ -0,0 +1,30 @@
+---
+layout: default
+downloadurl: "http://techerrata.com/browse/twrp2/"
+---
+
+<div class="home">
+
+<center>
+<h1 class="page-heading">Donate to Support TWRP:</h1>
+<form method="post" action="https://www.paypal.com/cgi-bin/webscr">
+    <input type="hidden" name="cmd" value="_s-xclick" /> <input type="hidden" name="hosted_button_id" value="U2KA5TM2F5Y64" /> <input type="image" border="0" name="submit" src="https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif" alt="PayPal - The safer, easier way to pay online!" /> <img width="1" height="1" border="0" src="https://www.paypalobjects.com/en_US/i/scr/pixel.gif" alt="" />
+</form>
+</center>
+<h1 class="post-meta" style="text-align: center;">Bitcoins: <a class="post-meta" href="bitcoin:1EUshGGz6KdsRJioozqFmn4FHQk4z3Ggxg?label=twrp">1EUshGGz6KdsRJioozqFmn4FHQk4z3Ggxg</a></h1>
+
+  <h1 class="page-heading">News</h1>
+
+  <ul class="post-list">
+    {% for post in site.posts %}
+      <li>
+        <span class="post-meta">{{ post.date | date: "%b %-d, %Y" }}</span>
+
+        <h2>
+          <a class="post-link" href="{{ post.url | prepend: site.baseurl }}">{{ post.title }}</a>
+        </h2>
+      </li>
+    {% endfor %}
+  </ul>
+
+</div>
diff --git a/js/jekyll-search.js b/js/jekyll-search.js
new file mode 100644
index 0000000..04d6a0d
--- /dev/null
+++ b/js/jekyll-search.js
@@ -0,0 +1 @@
+!function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a="function"==typeof require&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}for(var i="function"==typeof require&&require,o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module){module.exports=function(){function receivedResponse(xhr){return 200==xhr.status&&4==xhr.readyState}function handleResponse(xhr,callback){xhr.onreadystatechange=function(){if(receivedResponse(xhr))try{callback(null,JSON.parse(xhr.responseText))}catch(err){callback(err,null)}}}var self=this;self.load=function(location,callback){var xhr=window.XMLHttpRequest?new XMLHttpRequest:new ActiveXObject("Microsoft.XMLHTTP");xhr.open("GET",location,!0),handleResponse(xhr,callback),xhr.send()}}},{}],2:[function(require,module){function FuzzySearchStrategy(){function createFuzzyRegExpFromString(string){return new RegExp(string.split("").join(".*?"),"gi")}var self=this;self.matches=function(string,crit){return"string"!=typeof string?!1:(string=string.trim(),!!string.match(createFuzzyRegExpFromString(crit)))}}module.exports=new FuzzySearchStrategy},{}],3:[function(require,module){function LiteralSearchStrategy(){function doMatch(string,crit){return string.toLowerCase().indexOf(crit.toLowerCase())>=0}var self=this;self.matches=function(string,crit){return"string"!=typeof string?!1:(string=string.trim(),doMatch(string,crit))}}module.exports=new LiteralSearchStrategy},{}],4:[function(require,module){module.exports=function(){function findMatches(store,crit,strategy){for(var data=store.get(),i=0;i<data.length&&matches.length<limit;i++)findMatchesInObject(data[i],crit,strategy);return matches}function findMatchesInObject(obj,crit,strategy){for(var key in obj)if(strategy.matches(obj[key],crit)){matches.push(obj);break}}function getSearchStrategy(){return fuzzy?fuzzySearchStrategy:literalSearchStrategy}var self=this,matches=[],fuzzy=!1,limit=10,fuzzySearchStrategy=require("./SearchStrategies/fuzzy"),literalSearchStrategy=require("./SearchStrategies/literal");self.setFuzzy=function(_fuzzy){fuzzy=!!_fuzzy},self.setLimit=function(_limit){limit=parseInt(_limit,10)||limit},self.search=function(data,crit){return crit?(matches.length=0,findMatches(data,crit,getSearchStrategy())):[]}}},{"./SearchStrategies/fuzzy":2,"./SearchStrategies/literal":3}],5:[function(require,module){module.exports=function(_store){function isObject(obj){return!!obj&&"[object Object]"==Object.prototype.toString.call(obj)}function isArray(obj){return!!obj&&"[object Array]"==Object.prototype.toString.call(obj)}function addObject(data){return store.push(data),data}function addArray(data){for(var added=[],i=0;i<data.length;i++)isObject(data[i])&&added.push(addObject(data[i]));return added}var self=this,store=[];isArray(_store)&&addArray(_store),self.clear=function(){return store.length=0,store},self.get=function(){return store},self.put=function(data){return isObject(data)?addObject(data):isArray(data)?addArray(data):void 0}}},{}],6:[function(require,module){module.exports=function(){var self=this,templatePattern=/\{(.*?)\}/g;self.setTemplatePattern=function(newTemplatePattern){templatePattern=newTemplatePattern},self.render=function(t,data){return t.replace(templatePattern,function(match,prop){return data[prop]||match})}}},{}],7:[function(require){!function(window){"use strict";function SimpleJekyllSearch(){function initWithJSON(){store.put(opt.dataSource),registerInput()}function initWithURL(url){jsonLoader.load(url,function(err,json){err?throwError("failed to get JSON ("+url+")"):(store.put(json),registerInput())})}function throwError(message){throw new Error("SimpleJekyllSearch --- "+message)}function validateOptions(_opt){for(var i=0;i<requiredOptions.length;i++){var req=requiredOptions[i];_opt[req]||throwError("You must specify a "+req)}}function assignOptions(_opt){for(var option in opt)opt[option]=_opt[option]||opt[option]}function isJSON(json){try{return json instanceof Object&&JSON.parse(JSON.stringify(json))}catch(e){return!1}}function emptyResultsContainer(){opt.resultsContainer.innerHTML=""}function appendToResultsContainer(text){opt.resultsContainer.innerHTML+=text}function registerInput(){opt.searchInput.addEventListener("keyup",function(e){return 0==e.target.value.length?void emptyResultsContainer():void render(searcher.search(store,e.target.value))})}function render(results){if(emptyResultsContainer(),0==results.length)return appendToResultsContainer(opt.noResultsText);for(var i=0;i<results.length;i++)appendToResultsContainer(templater.render(opt.searchResultTemplate,results[i]))}var self=this,requiredOptions=["searchInput","resultsContainer","dataSource"],opt={searchInput:null,resultsContainer:null,dataSource:[],searchResultTemplate:'<li><a href="{url}" title="{desc}">{title}</a></li>',noResultsText:"No results found",limit:10,fuzzy:!1};self.init=function(_opt){validateOptions(_opt),assignOptions(_opt),isJSON(opt.dataSource)?initWithJSON(opt.dataSource):initWithURL(opt.dataSource)}}var Searcher=require("./Searcher"),Templater=require("./Templater"),Store=require("./Store"),JSONLoader=require("./JSONLoader"),searcher=new Searcher,templater=new Templater,store=new Store,jsonLoader=new JSONLoader;window.SimpleJekyllSearch=new SimpleJekyllSearch}(window,document)},{"./JSONLoader":1,"./Searcher":4,"./Store":5,"./Templater":6}]},{},[7]);
\ No newline at end of file
diff --git a/list.txt b/list.txt
new file mode 100644
index 0000000..95dee4c
--- /dev/null
+++ b/list.txt
@@ -0,0 +1,223 @@
+acericoniaa500.markdown:oldurl: http://teamw.in/project/twrp2/88
+amazonkindlefire.markdown:oldurl: http://teamw.in/project/twrp2/79
+amlogick200.markdown:oldurl: http://teamw.in/project/twrp2/289
+androidemulator.markdown:oldurl: http://teamw.in/project/twrp2/169
+androidone.markdown:oldurl: http://teamw.in/project/twrp2/268
+asusnexus720123g.markdown:oldurl: http://teamw.in/project/twrp2/150
+asusnexus72012wifi.markdown:oldurl: http://teamw.in/project/twrp2/103
+asusnexus72013lte.markdown:oldurl: http://teamw.in/project/twrp2/194
+asusnexus72013wifi.markdown:oldurl: http://teamw.in/project/twrp2/193
+asuspadfone1.markdown:oldurl: http://teamw.in/project/twrp2/172
+asuspadfone2.markdown:oldurl: http://teamw.in/project/twrp2/157
+asusTF300T.markdown:oldurl: http://teamw.in/project/twrp2/97
+asustransformerinfinityTF700T.markdown:oldurl: http://teamw.in/project/twrp2/105
+asustransformerprimeTF201.markdown:oldurl: http://teamw.in/project/twrp2/93
+asustransformerTF101.markdown:oldurl: http://teamw.in/project/twrp2/109
+barnesnoblenookcolor.markdown:oldurl: http://teamw.in/project/twrp2/43
+barnesnoblenooktablet.markdown:oldurl: http://teamw.in/project/twrp2/183
+bqaquarisee54g.markdown:oldurl: http://teamw.in/project/twrp2/274
+dellstreak7.markdown:oldurl: http://teamw.in/project/twrp2/12
+hptouchpad.markdown:oldurl: http://teamw.in/project/twrp2/75
+htcamaze4g.markdown:oldurl: http://teamw.in/project/twrp2/86
+htcbutterfly2.markdown:oldurl: http://teamw.in/project/twrp2/285
+htcbutterflyx920d.markdown:oldurl: http://teamw.in/project/twrp2/142
+htcbutterflyx920e.markdown:oldurl: http://teamw.in/project/twrp2/141
+htcdesire510usa32bit.markdown:oldurl: http://teamw.in/project/twrp2/272
+htcdesire601cdma.markdown:oldurl: http://teamw.in/project/twrp2/217
+htcdesire601gsm.markdown:oldurl: http://teamw.in/project/twrp2/279
+htcdesire610usa.markdown:oldurl: http://teamw.in/project/twrp2/246
+htcdesire816.markdown:oldurl: http://teamw.in/project/twrp2/247
+htcdesirec.markdown:oldurl: http://teamw.in/project/twrp2/160
+htcdesirehd.markdown:oldurl: http://teamw.in/project/twrp2/6
+htcdesires.markdown:oldurl: http://teamw.in/project/twrp2/68
+htcdesirex.markdown:oldurl: http://teamw.in/project/twrp2/140
+htcdroiddna.markdown:oldurl: http://teamw.in/project/twrp2/127
+htcdroidincredible2.markdown:oldurl: http://teamw.in/project/twrp2/71
+htcdroidincredible4g.markdown:oldurl: http://teamw.in/project/twrp2/139
+htcdroidincredible.markdown:oldurl: http://teamw.in/project/twrp2/4
+htcevo3dcdma.markdown:oldurl: http://teamw.in/project/twrp2/67
+htcevo3dgsm.markdown:oldurl: http://teamw.in/project/twrp2/87
+htcevo4glte.markdown:oldurl: http://teamw.in/project/twrp2/98
+htcevo4g.markdown:oldurl: http://teamw.in/project/twrp2/3
+htcevoshift.markdown:oldurl: http://teamw.in/project/twrp2/5
+htcexplorer.markdown:oldurl: http://teamw.in/project/twrp2/163
+htcfirst.markdown:oldurl: http://teamw.in/project/twrp2/236
+htchd2.markdown:oldurl: http://teamw.in/project/twrp2/80
+htcherocdma.markdown:oldurl: http://teamw.in/project/twrp2/49
+htcincredibles.markdown:oldurl: http://teamw.in/project/twrp2/70
+htcmerge.markdown:oldurl: http://teamw.in/project/twrp2/84
+htcnexus9.markdown:oldurl: http://teamw.in/project/twrp2/269
+htcnexusone.markdown:oldurl: http://teamw.in/project/twrp2/51
+htconem7dualsim.markdown:oldurl: http://teamw.in/project/twrp2/278
+htconem7gsm.markdown:oldurl: http://teamw.in/project/twrp2/164
+htconem7sprint.markdown:oldurl: http://teamw.in/project/twrp2/171
+htconem7verizon.markdown:oldurl: http://teamw.in/project/twrp2/255
+htconem8gsm.markdown:oldurl: http://teamw.in/project/twrp2/225
+htconem8sprint.markdown:oldurl: http://teamw.in/project/twrp2/221
+htconem8verizon.markdown:oldurl: http://teamw.in/project/twrp2/226
+htconemaxsprint.markdown:oldurl: http://teamw.in/project/twrp2/211
+htconemaxverizon.markdown:oldurl: http://teamw.in/project/twrp2/210
+htconeminigsm.markdown:oldurl: http://teamw.in/project/twrp2/216
+htconess4.markdown:oldurl: http://teamw.in/project/twrp2/100
+htconesvboost.markdown:oldurl: http://teamw.in/project/twrp2/184
+htconesvcricket.markdown:oldurl: http://teamw.in/project/twrp2/188
+htconesvgsm.markdown:oldurl: http://teamw.in/project/twrp2/189
+htconesvlte.markdown:oldurl: http://teamw.in/project/twrp2/190
+htconevgsm.markdown:oldurl: http://teamw.in/project/twrp2/119
+htconevvirgin.markdown:oldurl: http://teamw.in/project/twrp2/120
+htconevx.markdown:oldurl: http://teamw.in/project/twrp2/158
+htconexatt.markdown:oldurl: http://teamw.in/project/twrp2/99
+htconexinternational.markdown:oldurl: http://teamw.in/project/twrp2/95
+htconexplusatt.markdown:oldurl: http://teamw.in/project/twrp2/131
+htconexplusinternational.markdown:oldurl: http://teamw.in/project/twrp2/130
+htcsensation.markdown:oldurl: http://teamw.in/project/twrp2/66
+htcsensationxl.markdown:oldurl: http://teamw.in/project/twrp2/134
+htcthunderbolt.markdown:oldurl: http://teamw.in/project/twrp2/10
+htcvivid.markdown:oldurl: http://teamw.in/project/twrp2/76
+htcwildfires.markdown:oldurl: http://teamw.in/project/twrp2/111
+huaweiascendmate2.markdown:oldurl: http://teamw.in/project/twrp2/265
+huaweig510.markdown:oldurl: http://teamw.in/project/twrp2/170
+huaweiu8815.markdown:oldurl: http://teamw.in/project/twrp2/136
+huaweiy300.markdown:oldurl: http://teamw.in/project/twrp2/166
+kazamthunderq45.markdown:oldurl: http://teamw.in/project/twrp2/287
+kazamtornado348.markdown:oldurl: http://teamw.in/project/twrp2/290
+lgg2.markdown:oldurl: http://teamw.in/project/twrp2/197
+lgg3att.markdown:oldurl: http://teamw.in/project/twrp2/256
+lgg3canadabellrogers.markdown:oldurl: http://teamw.in/project/twrp2/261
+lgg3canadawindvideotronsasktel.markdown:oldurl: http://teamw.in/project/twrp2/260
+lgg3europe.markdown:oldurl: http://teamw.in/project/twrp2/262
+lgg3korea.markdown:oldurl: http://teamw.in/project/twrp2/259
+lgg3sprint.markdown:oldurl: http://teamw.in/project/twrp2/258
+lgg3tmo.markdown:oldurl: http://teamw.in/project/twrp2/249
+lgg3uscellular.markdown:oldurl: http://teamw.in/project/twrp2/276
+lgg3verizon.markdown:oldurl: http://teamw.in/project/twrp2/257
+lggflexkorean.markdown:oldurl: http://teamw.in/project/twrp2/212
+lggpad83.markdown:oldurl: http://teamw.in/project/twrp2/213
+lggwatch.markdown:oldurl: http://teamw.in/project/twrp2/242
+lggwatchr.markdown:oldurl: http://teamw.in/project/twrp2/281
+lgnexus4.markdown:oldurl: http://teamw.in/project/twrp2/129
+lgnexus5.markdown:oldurl: http://teamw.in/project/twrp2/205
+lgnitrohd.markdown:oldurl: http://teamw.in/project/twrp2/162
+lgoptimus2x.markdown:oldurl: http://teamw.in/project/twrp2/65
+lgoptimus4xhd.markdown:oldurl: http://teamw.in/project/twrp2/240
+lgoptimusblack.markdown:oldurl: http://teamw.in/project/twrp2/116
+lgoptimusfuel.markdown:oldurl: http://teamw.in/project/twrp2/277
+lgoptimusgatt.markdown:oldurl: http://teamw.in/project/twrp2/154
+lgoptimusgsprint.markdown:oldurl: http://teamw.in/project/twrp2/155
+lgoptimuslte.markdown:oldurl: http://teamw.in/project/twrp2/167
+lgoptimusone.markdown:oldurl: http://teamw.in/project/twrp2/73
+lgoptimusslider.markdown:oldurl: http://teamw.in/project/twrp2/168
+lgtmobileg2x.markdown:oldurl: http://teamw.in/project/twrp2/63
+micromaxcanvasmagnus.markdown:oldurl: http://teamw.in/project/twrp2/271
+motorolaatrix4g.markdown:oldurl: http://teamw.in/project/twrp2/72
+motoroladefy.markdown:oldurl: http://teamw.in/project/twrp2/91
+motorolamoto360.markdown:oldurl: http://teamw.in/project/twrp2/280
+motorolamotoe.markdown:oldurl: http://teamw.in/project/twrp2/235
+motorolamotog2013.markdown:oldurl: http://teamw.in/project/twrp2/233
+motorolamotog2014.markdown:oldurl: http://teamw.in/project/twrp2/275
+motorolamotox2013.markdown:oldurl: http://teamw.in/project/twrp2/234
+motorolamotox2014.markdown:oldurl: http://teamw.in/project/twrp2/264
+motorolanexus6.markdown:oldurl: http://teamw.in/project/twrp2/270
+motorolaphoton4g.markdown:oldurl: http://teamw.in/project/twrp2/82
+motorolaphotonq.markdown:oldurl: http://teamw.in/project/twrp2/137
+motorolaxoom.markdown:oldurl: http://teamw.in/project/twrp2/61
+omatetruesmart.markdown:oldurl: http://teamw.in/project/twrp2/214
+oneplusone.markdown:oldurl: http://teamw.in/project/twrp2/231
+oppofind5.markdown:oldurl: http://teamw.in/project/twrp2/156
+oppofind7.markdown:oldurl: http://teamw.in/project/twrp2/245
+oppon1.markdown:oldurl: http://teamw.in/project/twrp2/209
+oppon3.markdown:oldurl: http://teamw.in/project/twrp2/209
+oppor819.markdown:oldurl: http://teamw.in/project/twrp2/209
+samsungefascinate.markdown:oldurl: http://teamw.in/project/twrp2/40
+samsungepic4g.markdown:oldurl: http://teamw.in/project/twrp2/13
+samsunggalaxyalpha.markdown:oldurl: http://teamw.in/project/twrp2/267
+samsunggalaxygrandduos.markdown:oldurl: http://teamw.in/project/twrp2/252
+samsunggalaxymega58.markdown:oldurl: http://teamw.in/project/twrp2/196
+samsunggalaxymega63.markdown:oldurl: http://teamw.in/project/twrp2/199
+samsunggalaxynexusgsm.markdown:oldurl: http://teamw.in/project/twrp2/90
+samsunggalaxynexussprint.markdown:oldurl: http://teamw.in/project/twrp2/92
+samsunggalaxynexusverizon.markdown:oldurl: http://teamw.in/project/twrp2/89
+samsunggalaxynote1012014exynos.markdown:oldurl: http://teamw.in/project/twrp2/206
+samsunggalaxynote1012014qcom.markdown:oldurl: http://teamw.in/project/twrp2/207
+samsunggalaxynote101.markdown:oldurl: http://teamw.in/project/twrp2/110
+samsunggalaxynote1att.markdown:oldurl: http://teamw.in/project/twrp2/96
+samsunggalaxynote1tmobile.markdown:oldurl: http://teamw.in/project/twrp2/113
+samsunggalaxynote2att.markdown:oldurl: http://teamw.in/project/twrp2/124
+samsunggalaxynote2canada.markdown:oldurl: http://teamw.in/project/twrp2/126
+samsunggalaxynote2n7100.markdown:oldurl: http://teamw.in/project/twrp2/115
+samsunggalaxynote2n7105.markdown:oldurl: http://teamw.in/project/twrp2/125
+samsunggalaxynote2sprint.markdown:oldurl: http://teamw.in/project/twrp2/117
+samsunggalaxynote2t0ltektt.markdown:oldurl: http://teamw.in/project/twrp2/152
+samsunggalaxynote2t0lteskt.markdown:oldurl: http://teamw.in/project/twrp2/151
+samsunggalaxynote2tmobile.markdown:oldurl: http://teamw.in/project/twrp2/123
+samsunggalaxynote2verizon.markdown:oldurl: http://teamw.in/project/twrp2/133
+samsunggalaxynote3canada.markdown:oldurl: http://teamw.in/project/twrp2/200
+samsunggalaxynote3internationalexynos.markdown:oldurl: http://teamw.in/project/twrp2/204
+samsunggalaxynote3internationalqualcomm.markdown:oldurl: http://teamw.in/project/twrp2/202
+samsunggalaxynote3neo.markdown:oldurl: http://teamw.in/project/twrp2/202
+samsunggalaxynote3sprint.markdown:oldurl: http://teamw.in/project/twrp2/201
+samsunggalaxynote3tmobile.markdown:oldurl: http://teamw.in/project/twrp2/198
+samsunggalaxynote3uscellular.markdown:oldurl: http://teamw.in/project/twrp2/218
+samsunggalaxynote3verizon.markdown:oldurl: http://teamw.in/project/twrp2/251
+samsunggalaxynote4exynos.markdown:oldurl: http://teamw.in/project/twrp2/273
+samsunggalaxynote4qualcomm.markdown:oldurl: http://teamw.in/project/twrp2/266
+samsunggalaxynotepro122exynos3g.markdown:oldurl: http://teamw.in/project/twrp2/263
+samsunggalaxynotepro122exynoswifi.markdown:oldurl: http://teamw.in/project/twrp2/224
+samsunggalaxynotepro122qcom.markdown:oldurl: http://teamw.in/project/twrp2/237
+samsunggalaxyprevail.markdown:oldurl: http://teamw.in/project/twrp2/215
+samsunggalaxyreverb.markdown:oldurl: http://teamw.in/project/twrp2/208
+samsunggalaxyrugbypro.markdown:oldurl: http://teamw.in/project/twrp2/132
+samsunggalaxys2exhilarate.markdown:oldurl: http://teamw.in/project/twrp2/195
+samsunggalaxys2hercules.markdown:oldurl: http://teamw.in/project/twrp2/101
+samsunggalaxys2plus.markdown:oldurl: http://teamw.in/project/twrp2/250
+samsunggalaxys2skyrocket.markdown:oldurl: http://teamw.in/project/twrp2/94
+samsunggalaxys3att.markdown:oldurl: http://teamw.in/project/twrp2/104
+samsunggalaxys3canada.markdown:oldurl: http://teamw.in/project/twrp2/149
+samsunggalaxys3cricket.markdown:oldurl: http://teamw.in/project/twrp2/161
+samsunggalaxys3internationalexynos.markdown:oldurl: http://teamw.in/project/twrp2/114
+samsunggalaxys3internationallte.markdown:oldurl: http://teamw.in/project/twrp2/145
+samsunggalaxys3metropcs.markdown:oldurl: http://teamw.in/project/twrp2/118
+samsunggalaxys3mini.markdown:oldurl: http://teamw.in/project/twrp2/118
+samsunggalaxys3sprint.markdown:oldurl: http://teamw.in/project/twrp2/107
+samsunggalaxys3tmobile.markdown:oldurl: http://teamw.in/project/twrp2/106
+samsunggalaxys3uscellular.markdown:oldurl: http://teamw.in/project/twrp2/121
+samsunggalaxys3verizon.markdown:oldurl: http://teamw.in/project/twrp2/102
+samsunggalaxys4att.markdown:oldurl: http://teamw.in/project/twrp2/174
+samsunggalaxys4canada.markdown:oldurl: http://teamw.in/project/twrp2/175
+samsunggalaxys4cricket.markdown:oldurl: http://teamw.in/project/twrp2/176
+samsunggalaxys4cspire.markdown:oldurl: http://teamw.in/project/twrp2/177
+samsunggalaxys4googleedition.markdown:oldurl: http://teamw.in/project/twrp2/192
+samsunggalaxys4internationalexynos.markdown:oldurl: http://teamw.in/project/twrp2/191
+samsunggalaxys4internationalqualcomm.markdown:oldurl: http://teamw.in/project/twrp2/182
+samsunggalaxys4sprint.markdown:oldurl: http://teamw.in/project/twrp2/178
+samsunggalaxys4tmobile.markdown:oldurl: http://teamw.in/project/twrp2/179
+samsunggalaxys4uscellular.markdown:oldurl: http://teamw.in/project/twrp2/180
+samsunggalaxys4verizon.markdown:oldurl: http://teamw.in/project/twrp2/181
+samsunggalaxys5qualcomm.markdown:oldurl: http://teamw.in/project/twrp2/229
+samsunggalaxystellar4g.markdown:oldurl: http://teamw.in/project/twrp2/122
+samsunggalaxytab2101.markdown:oldurl: http://teamw.in/project/twrp2/283
+samsunggalaxytab270.markdown:oldurl: http://teamw.in/project/twrp2/283
+samsunggalaxytab470.markdown:oldurl: http://teamw.in/project/twrp2/248
+samsunggalaxytab77.markdown:oldurl: http://teamw.in/project/twrp2/108
+samsunggalaxytabpro101exynoswifi.markdown:oldurl: http://teamw.in/project/twrp2/253
+samsunggalaxytabpro101lte.markdown:oldurl: http://teamw.in/project/twrp2/230
+samsunggalaxytabpro122exynoswifi.markdown:oldurl: http://teamw.in/project/twrp2/244
+samsunggalaxytabpro8.4exynoswifi.markdown:oldurl: http://teamw.in/project/twrp2/220
+samsunggalaxytabpro8.4lte.markdown:oldurl: http://teamw.in/project/twrp2/222
+samsunggalaxytabs105.markdown:oldurl: http://teamw.in/project/twrp2/239
+samsunggalaxytabs84.markdown:oldurl: http://teamw.in/project/twrp2/238
+samsunggalaxyvictory4glte.markdown:oldurl: http://teamw.in/project/twrp2/165
+samsunggearlive.markdown:oldurl: http://teamw.in/project/twrp2/243
+samsungnexus10.markdown:oldurl: http://teamw.in/project/twrp2/128
+samsungnexuss4g.markdown:oldurl: http://teamw.in/project/twrp2/74
+samsungnexuss.markdown:oldurl: http://teamw.in/project/twrp2/44
+sonyxperial.markdown:oldurl: http://teamw.in/project/twrp2/286
+sonyxperias.markdown:oldurl: http://teamw.in/project/twrp2/144
+sonyxperiat.markdown:oldurl: http://teamw.in/project/twrp2/143
+sonyxperiaz2.markdown:oldurl: http://teamw.in/project/twrp2/232
+sonyxperiaz.markdown:oldurl: http://teamw.in/project/twrp2/187
+sonyxperiaztablet.markdown:oldurl: http://teamw.in/project/twrp2/185
+sonyxperiazultra.markdown:oldurl: http://teamw.in/project/twrp2/219
+xiaomimi3.markdown:oldurl: http://teamw.in/project/twrp2/288
+xiaomiredmi1s.markdown:oldurl: http://teamw.in/project/twrp2/241
+yuyureka.markdown:oldurl: http://teamw.in/project/twrp2/284
diff --git a/noos/index.html b/noos/index.html
new file mode 120000
index 0000000..70543cd
--- /dev/null
+++ b/noos/index.html
@@ -0,0 +1 @@
+../faq/noos.html
\ No newline at end of file
diff --git a/officialota/index.html b/officialota/index.html
new file mode 120000
index 0000000..0e8f443
--- /dev/null
+++ b/officialota/index.html
@@ -0,0 +1 @@
+../faq/officialota.html
\ No newline at end of file
diff --git a/project/twrp2/10/index.html b/project/twrp2/10/index.html
new file mode 120000
index 0000000..5560b88
--- /dev/null
+++ b/project/twrp2/10/index.html
@@ -0,0 +1 @@
+../../../devices/htcthunderbolt.html
\ No newline at end of file
diff --git a/project/twrp2/100/index.html b/project/twrp2/100/index.html
new file mode 120000
index 0000000..94d0acf
--- /dev/null
+++ b/project/twrp2/100/index.html
@@ -0,0 +1 @@
+../../../devices/htconess4.html
\ No newline at end of file
diff --git a/project/twrp2/101/index.html b/project/twrp2/101/index.html
new file mode 120000
index 0000000..f1c9ac2
--- /dev/null
+++ b/project/twrp2/101/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys2hercules.html
\ No newline at end of file
diff --git a/project/twrp2/102/index.html b/project/twrp2/102/index.html
new file mode 120000
index 0000000..2864074
--- /dev/null
+++ b/project/twrp2/102/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3verizon.html
\ No newline at end of file
diff --git a/project/twrp2/103/index.html b/project/twrp2/103/index.html
new file mode 120000
index 0000000..a607f65
--- /dev/null
+++ b/project/twrp2/103/index.html
@@ -0,0 +1 @@
+../../../devices/asusnexus72012wifi.html
\ No newline at end of file
diff --git a/project/twrp2/104/index.html b/project/twrp2/104/index.html
new file mode 120000
index 0000000..624bd42
--- /dev/null
+++ b/project/twrp2/104/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3att.html
\ No newline at end of file
diff --git a/project/twrp2/105/index.html b/project/twrp2/105/index.html
new file mode 120000
index 0000000..28e36e1
--- /dev/null
+++ b/project/twrp2/105/index.html
@@ -0,0 +1 @@
+../../../devices/asustransformerinfinityTF700T.html
\ No newline at end of file
diff --git a/project/twrp2/106/index.html b/project/twrp2/106/index.html
new file mode 120000
index 0000000..b8a5173
--- /dev/null
+++ b/project/twrp2/106/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3tmobile.html
\ No newline at end of file
diff --git a/project/twrp2/107/index.html b/project/twrp2/107/index.html
new file mode 120000
index 0000000..de299d1
--- /dev/null
+++ b/project/twrp2/107/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3sprint.html
\ No newline at end of file
diff --git a/project/twrp2/108/index.html b/project/twrp2/108/index.html
new file mode 120000
index 0000000..ccee50a
--- /dev/null
+++ b/project/twrp2/108/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytab77.html
\ No newline at end of file
diff --git a/project/twrp2/109/index.html b/project/twrp2/109/index.html
new file mode 120000
index 0000000..7d378b7
--- /dev/null
+++ b/project/twrp2/109/index.html
@@ -0,0 +1 @@
+../../../devices/asustransformerTF101.html
\ No newline at end of file
diff --git a/project/twrp2/110/index.html b/project/twrp2/110/index.html
new file mode 120000
index 0000000..c6cafbc
--- /dev/null
+++ b/project/twrp2/110/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote101.html
\ No newline at end of file
diff --git a/project/twrp2/111/index.html b/project/twrp2/111/index.html
new file mode 120000
index 0000000..f0d5695
--- /dev/null
+++ b/project/twrp2/111/index.html
@@ -0,0 +1 @@
+../../../devices/htcwildfires.html
\ No newline at end of file
diff --git a/project/twrp2/113/index.html b/project/twrp2/113/index.html
new file mode 120000
index 0000000..a268be2
--- /dev/null
+++ b/project/twrp2/113/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote1tmobile.html
\ No newline at end of file
diff --git a/project/twrp2/114/index.html b/project/twrp2/114/index.html
new file mode 120000
index 0000000..48588a5
--- /dev/null
+++ b/project/twrp2/114/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3internationalexynos.html
\ No newline at end of file
diff --git a/project/twrp2/115/index.html b/project/twrp2/115/index.html
new file mode 120000
index 0000000..f5ab11f
--- /dev/null
+++ b/project/twrp2/115/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2n7100.html
\ No newline at end of file
diff --git a/project/twrp2/116/index.html b/project/twrp2/116/index.html
new file mode 120000
index 0000000..b31abef
--- /dev/null
+++ b/project/twrp2/116/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimusblack.html
\ No newline at end of file
diff --git a/project/twrp2/117/index.html b/project/twrp2/117/index.html
new file mode 120000
index 0000000..04a1486
--- /dev/null
+++ b/project/twrp2/117/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2sprint.html
\ No newline at end of file
diff --git a/project/twrp2/118/index.html b/project/twrp2/118/index.html
new file mode 120000
index 0000000..6041605
--- /dev/null
+++ b/project/twrp2/118/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3metropcs.html
\ No newline at end of file
diff --git a/project/twrp2/119/index.html b/project/twrp2/119/index.html
new file mode 120000
index 0000000..cafa621
--- /dev/null
+++ b/project/twrp2/119/index.html
@@ -0,0 +1 @@
+../../../devices/htconevgsm.html
\ No newline at end of file
diff --git a/project/twrp2/12/index.html b/project/twrp2/12/index.html
new file mode 120000
index 0000000..40763ba
--- /dev/null
+++ b/project/twrp2/12/index.html
@@ -0,0 +1 @@
+../../../devices/dellstreak7.html
\ No newline at end of file
diff --git a/project/twrp2/120/index.html b/project/twrp2/120/index.html
new file mode 120000
index 0000000..a68f412
--- /dev/null
+++ b/project/twrp2/120/index.html
@@ -0,0 +1 @@
+../../../devices/htconevvirgin.html
\ No newline at end of file
diff --git a/project/twrp2/121/index.html b/project/twrp2/121/index.html
new file mode 120000
index 0000000..4d9195e
--- /dev/null
+++ b/project/twrp2/121/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3uscellular.html
\ No newline at end of file
diff --git a/project/twrp2/122/index.html b/project/twrp2/122/index.html
new file mode 120000
index 0000000..59cd9f5
--- /dev/null
+++ b/project/twrp2/122/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxystellar4g.html
\ No newline at end of file
diff --git a/project/twrp2/123/index.html b/project/twrp2/123/index.html
new file mode 120000
index 0000000..6032d22
--- /dev/null
+++ b/project/twrp2/123/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2tmobile.html
\ No newline at end of file
diff --git a/project/twrp2/124/index.html b/project/twrp2/124/index.html
new file mode 120000
index 0000000..961e53e
--- /dev/null
+++ b/project/twrp2/124/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2att.html
\ No newline at end of file
diff --git a/project/twrp2/125/index.html b/project/twrp2/125/index.html
new file mode 120000
index 0000000..caab153
--- /dev/null
+++ b/project/twrp2/125/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2n7105.html
\ No newline at end of file
diff --git a/project/twrp2/126/index.html b/project/twrp2/126/index.html
new file mode 120000
index 0000000..44c64f2
--- /dev/null
+++ b/project/twrp2/126/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2canada.html
\ No newline at end of file
diff --git a/project/twrp2/127/index.html b/project/twrp2/127/index.html
new file mode 120000
index 0000000..07d41a2
--- /dev/null
+++ b/project/twrp2/127/index.html
@@ -0,0 +1 @@
+../../../devices/htcdroiddna.html
\ No newline at end of file
diff --git a/project/twrp2/128/index.html b/project/twrp2/128/index.html
new file mode 120000
index 0000000..93d978a
--- /dev/null
+++ b/project/twrp2/128/index.html
@@ -0,0 +1 @@
+../../../devices/samsungnexus10.html
\ No newline at end of file
diff --git a/project/twrp2/129/index.html b/project/twrp2/129/index.html
new file mode 120000
index 0000000..b903239
--- /dev/null
+++ b/project/twrp2/129/index.html
@@ -0,0 +1 @@
+../../../devices/lgnexus4.html
\ No newline at end of file
diff --git a/project/twrp2/13/index.html b/project/twrp2/13/index.html
new file mode 120000
index 0000000..e4bd1a0
--- /dev/null
+++ b/project/twrp2/13/index.html
@@ -0,0 +1 @@
+../../../devices/samsungepic4g.html
\ No newline at end of file
diff --git a/project/twrp2/130/index.html b/project/twrp2/130/index.html
new file mode 120000
index 0000000..29e47c7
--- /dev/null
+++ b/project/twrp2/130/index.html
@@ -0,0 +1 @@
+../../../devices/htconexplusinternational.html
\ No newline at end of file
diff --git a/project/twrp2/131/index.html b/project/twrp2/131/index.html
new file mode 120000
index 0000000..89ba96d
--- /dev/null
+++ b/project/twrp2/131/index.html
@@ -0,0 +1 @@
+../../../devices/htconexplusatt.html
\ No newline at end of file
diff --git a/project/twrp2/132/index.html b/project/twrp2/132/index.html
new file mode 120000
index 0000000..b9596a8
--- /dev/null
+++ b/project/twrp2/132/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxyrugbypro.html
\ No newline at end of file
diff --git a/project/twrp2/133/index.html b/project/twrp2/133/index.html
new file mode 120000
index 0000000..07bd987
--- /dev/null
+++ b/project/twrp2/133/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2verizon.html
\ No newline at end of file
diff --git a/project/twrp2/134/index.html b/project/twrp2/134/index.html
new file mode 120000
index 0000000..d1c65e4
--- /dev/null
+++ b/project/twrp2/134/index.html
@@ -0,0 +1 @@
+../../../devices/htcsensationxl.html
\ No newline at end of file
diff --git a/project/twrp2/136/index.html b/project/twrp2/136/index.html
new file mode 120000
index 0000000..33aa501
--- /dev/null
+++ b/project/twrp2/136/index.html
@@ -0,0 +1 @@
+../../../devices/huaweiu8815.html
\ No newline at end of file
diff --git a/project/twrp2/137/index.html b/project/twrp2/137/index.html
new file mode 120000
index 0000000..beb5151
--- /dev/null
+++ b/project/twrp2/137/index.html
@@ -0,0 +1 @@
+../../../devices/motorolaphotonq.html
\ No newline at end of file
diff --git a/project/twrp2/139/index.html b/project/twrp2/139/index.html
new file mode 120000
index 0000000..3e82fa9
--- /dev/null
+++ b/project/twrp2/139/index.html
@@ -0,0 +1 @@
+../../../devices/htcdroidincredible4g.html
\ No newline at end of file
diff --git a/project/twrp2/140/index.html b/project/twrp2/140/index.html
new file mode 120000
index 0000000..dbb4476
--- /dev/null
+++ b/project/twrp2/140/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesirex.html
\ No newline at end of file
diff --git a/project/twrp2/141/index.html b/project/twrp2/141/index.html
new file mode 120000
index 0000000..c22f1a9
--- /dev/null
+++ b/project/twrp2/141/index.html
@@ -0,0 +1 @@
+../../../devices/htcbutterflyx920e.html
\ No newline at end of file
diff --git a/project/twrp2/142/index.html b/project/twrp2/142/index.html
new file mode 120000
index 0000000..0682f4b
--- /dev/null
+++ b/project/twrp2/142/index.html
@@ -0,0 +1 @@
+../../../devices/htcbutterflyx920d.html
\ No newline at end of file
diff --git a/project/twrp2/143/index.html b/project/twrp2/143/index.html
new file mode 120000
index 0000000..a06d9e3
--- /dev/null
+++ b/project/twrp2/143/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperiat.html
\ No newline at end of file
diff --git a/project/twrp2/144/index.html b/project/twrp2/144/index.html
new file mode 120000
index 0000000..e6931be
--- /dev/null
+++ b/project/twrp2/144/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperias.html
\ No newline at end of file
diff --git a/project/twrp2/145/index.html b/project/twrp2/145/index.html
new file mode 120000
index 0000000..8f61808
--- /dev/null
+++ b/project/twrp2/145/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3internationallte.html
\ No newline at end of file
diff --git a/project/twrp2/149/index.html b/project/twrp2/149/index.html
new file mode 120000
index 0000000..5c66194
--- /dev/null
+++ b/project/twrp2/149/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3canada.html
\ No newline at end of file
diff --git a/project/twrp2/150/index.html b/project/twrp2/150/index.html
new file mode 120000
index 0000000..068c01c
--- /dev/null
+++ b/project/twrp2/150/index.html
@@ -0,0 +1 @@
+../../../devices/asusnexus720123g.html
\ No newline at end of file
diff --git a/project/twrp2/151/index.html b/project/twrp2/151/index.html
new file mode 120000
index 0000000..ef86ae5
--- /dev/null
+++ b/project/twrp2/151/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2t0lteskt.html
\ No newline at end of file
diff --git a/project/twrp2/152/index.html b/project/twrp2/152/index.html
new file mode 120000
index 0000000..daa4a9e
--- /dev/null
+++ b/project/twrp2/152/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote2t0ltektt.html
\ No newline at end of file
diff --git a/project/twrp2/154/index.html b/project/twrp2/154/index.html
new file mode 120000
index 0000000..b2bcdb9
--- /dev/null
+++ b/project/twrp2/154/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimusgatt.html
\ No newline at end of file
diff --git a/project/twrp2/155/index.html b/project/twrp2/155/index.html
new file mode 120000
index 0000000..20ff9df
--- /dev/null
+++ b/project/twrp2/155/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimusgsprint.html
\ No newline at end of file
diff --git a/project/twrp2/156/index.html b/project/twrp2/156/index.html
new file mode 120000
index 0000000..d1e3d22
--- /dev/null
+++ b/project/twrp2/156/index.html
@@ -0,0 +1 @@
+../../../devices/oppofind5.html
\ No newline at end of file
diff --git a/project/twrp2/157/index.html b/project/twrp2/157/index.html
new file mode 120000
index 0000000..b89cac0
--- /dev/null
+++ b/project/twrp2/157/index.html
@@ -0,0 +1 @@
+../../../devices/asuspadfone2.html
\ No newline at end of file
diff --git a/project/twrp2/158/index.html b/project/twrp2/158/index.html
new file mode 120000
index 0000000..eb7db8a
--- /dev/null
+++ b/project/twrp2/158/index.html
@@ -0,0 +1 @@
+../../../devices/htconevx.html
\ No newline at end of file
diff --git a/project/twrp2/160/index.html b/project/twrp2/160/index.html
new file mode 120000
index 0000000..a9dcd9b
--- /dev/null
+++ b/project/twrp2/160/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesirec.html
\ No newline at end of file
diff --git a/project/twrp2/161/index.html b/project/twrp2/161/index.html
new file mode 120000
index 0000000..e27e256
--- /dev/null
+++ b/project/twrp2/161/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys3cricket.html
\ No newline at end of file
diff --git a/project/twrp2/162/index.html b/project/twrp2/162/index.html
new file mode 120000
index 0000000..a9b08f8
--- /dev/null
+++ b/project/twrp2/162/index.html
@@ -0,0 +1 @@
+../../../devices/lgnitrohd.html
\ No newline at end of file
diff --git a/project/twrp2/163/index.html b/project/twrp2/163/index.html
new file mode 120000
index 0000000..3d00d32
--- /dev/null
+++ b/project/twrp2/163/index.html
@@ -0,0 +1 @@
+../../../devices/htcexplorer.html
\ No newline at end of file
diff --git a/project/twrp2/164/index.html b/project/twrp2/164/index.html
new file mode 120000
index 0000000..8d85957
--- /dev/null
+++ b/project/twrp2/164/index.html
@@ -0,0 +1 @@
+../../../devices/htconem7gsm.html
\ No newline at end of file
diff --git a/project/twrp2/165/index.html b/project/twrp2/165/index.html
new file mode 120000
index 0000000..7378554
--- /dev/null
+++ b/project/twrp2/165/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxyvictory4glte.html
\ No newline at end of file
diff --git a/project/twrp2/166/index.html b/project/twrp2/166/index.html
new file mode 120000
index 0000000..6e2bfde
--- /dev/null
+++ b/project/twrp2/166/index.html
@@ -0,0 +1 @@
+../../../devices/huaweiy300.html
\ No newline at end of file
diff --git a/project/twrp2/167/index.html b/project/twrp2/167/index.html
new file mode 120000
index 0000000..4e41b8c
--- /dev/null
+++ b/project/twrp2/167/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimuslte.html
\ No newline at end of file
diff --git a/project/twrp2/168/index.html b/project/twrp2/168/index.html
new file mode 120000
index 0000000..552377d
--- /dev/null
+++ b/project/twrp2/168/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimusslider.html
\ No newline at end of file
diff --git a/project/twrp2/169/index.html b/project/twrp2/169/index.html
new file mode 120000
index 0000000..0dca440
--- /dev/null
+++ b/project/twrp2/169/index.html
@@ -0,0 +1 @@
+../../../devices/androidemulator.html
\ No newline at end of file
diff --git a/project/twrp2/170/index.html b/project/twrp2/170/index.html
new file mode 120000
index 0000000..5b89615
--- /dev/null
+++ b/project/twrp2/170/index.html
@@ -0,0 +1 @@
+../../../devices/huaweig510.html
\ No newline at end of file
diff --git a/project/twrp2/171/index.html b/project/twrp2/171/index.html
new file mode 120000
index 0000000..ab5676c
--- /dev/null
+++ b/project/twrp2/171/index.html
@@ -0,0 +1 @@
+../../../devices/htconem7sprint.html
\ No newline at end of file
diff --git a/project/twrp2/172/index.html b/project/twrp2/172/index.html
new file mode 120000
index 0000000..2887905
--- /dev/null
+++ b/project/twrp2/172/index.html
@@ -0,0 +1 @@
+../../../devices/asuspadfone1.html
\ No newline at end of file
diff --git a/project/twrp2/174/index.html b/project/twrp2/174/index.html
new file mode 120000
index 0000000..fe3f7db
--- /dev/null
+++ b/project/twrp2/174/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4att.html
\ No newline at end of file
diff --git a/project/twrp2/175/index.html b/project/twrp2/175/index.html
new file mode 120000
index 0000000..0702b69
--- /dev/null
+++ b/project/twrp2/175/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4canada.html
\ No newline at end of file
diff --git a/project/twrp2/176/index.html b/project/twrp2/176/index.html
new file mode 120000
index 0000000..720b618
--- /dev/null
+++ b/project/twrp2/176/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4cricket.html
\ No newline at end of file
diff --git a/project/twrp2/177/index.html b/project/twrp2/177/index.html
new file mode 120000
index 0000000..cbe9a05
--- /dev/null
+++ b/project/twrp2/177/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4cspire.html
\ No newline at end of file
diff --git a/project/twrp2/178/index.html b/project/twrp2/178/index.html
new file mode 120000
index 0000000..c862029
--- /dev/null
+++ b/project/twrp2/178/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4sprint.html
\ No newline at end of file
diff --git a/project/twrp2/179/index.html b/project/twrp2/179/index.html
new file mode 120000
index 0000000..3a16e96
--- /dev/null
+++ b/project/twrp2/179/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4tmobile.html
\ No newline at end of file
diff --git a/project/twrp2/180/index.html b/project/twrp2/180/index.html
new file mode 120000
index 0000000..d83f64b
--- /dev/null
+++ b/project/twrp2/180/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4uscellular.html
\ No newline at end of file
diff --git a/project/twrp2/181/index.html b/project/twrp2/181/index.html
new file mode 120000
index 0000000..9044a64
--- /dev/null
+++ b/project/twrp2/181/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4verizon.html
\ No newline at end of file
diff --git a/project/twrp2/182/index.html b/project/twrp2/182/index.html
new file mode 120000
index 0000000..5db16fa
--- /dev/null
+++ b/project/twrp2/182/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4internationalqualcomm.html
\ No newline at end of file
diff --git a/project/twrp2/183/index.html b/project/twrp2/183/index.html
new file mode 120000
index 0000000..a5f3c28
--- /dev/null
+++ b/project/twrp2/183/index.html
@@ -0,0 +1 @@
+../../../devices/barnesnoblenooktablet.html
\ No newline at end of file
diff --git a/project/twrp2/184/index.html b/project/twrp2/184/index.html
new file mode 120000
index 0000000..5d02fd0
--- /dev/null
+++ b/project/twrp2/184/index.html
@@ -0,0 +1 @@
+../../../devices/htconesvboost.html
\ No newline at end of file
diff --git a/project/twrp2/185/index.html b/project/twrp2/185/index.html
new file mode 120000
index 0000000..a49121a
--- /dev/null
+++ b/project/twrp2/185/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperiaztablet.html
\ No newline at end of file
diff --git a/project/twrp2/187/index.html b/project/twrp2/187/index.html
new file mode 120000
index 0000000..8c01230
--- /dev/null
+++ b/project/twrp2/187/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperiaz.html
\ No newline at end of file
diff --git a/project/twrp2/188/index.html b/project/twrp2/188/index.html
new file mode 120000
index 0000000..b3a1356
--- /dev/null
+++ b/project/twrp2/188/index.html
@@ -0,0 +1 @@
+../../../devices/htconesvcricket.html
\ No newline at end of file
diff --git a/project/twrp2/189/index.html b/project/twrp2/189/index.html
new file mode 120000
index 0000000..ee0d100
--- /dev/null
+++ b/project/twrp2/189/index.html
@@ -0,0 +1 @@
+../../../devices/htconesvgsm.html
\ No newline at end of file
diff --git a/project/twrp2/190/index.html b/project/twrp2/190/index.html
new file mode 120000
index 0000000..3b8c1d7
--- /dev/null
+++ b/project/twrp2/190/index.html
@@ -0,0 +1 @@
+../../../devices/htconesvlte.html
\ No newline at end of file
diff --git a/project/twrp2/191/index.html b/project/twrp2/191/index.html
new file mode 120000
index 0000000..e33298d
--- /dev/null
+++ b/project/twrp2/191/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4internationalexynos.html
\ No newline at end of file
diff --git a/project/twrp2/192/index.html b/project/twrp2/192/index.html
new file mode 120000
index 0000000..7f3ec26
--- /dev/null
+++ b/project/twrp2/192/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys4googleedition.html
\ No newline at end of file
diff --git a/project/twrp2/193/index.html b/project/twrp2/193/index.html
new file mode 120000
index 0000000..4e73324
--- /dev/null
+++ b/project/twrp2/193/index.html
@@ -0,0 +1 @@
+../../../devices/asusnexus72013wifi.html
\ No newline at end of file
diff --git a/project/twrp2/194/index.html b/project/twrp2/194/index.html
new file mode 120000
index 0000000..9a6802b
--- /dev/null
+++ b/project/twrp2/194/index.html
@@ -0,0 +1 @@
+../../../devices/asusnexus72013lte.html
\ No newline at end of file
diff --git a/project/twrp2/195/index.html b/project/twrp2/195/index.html
new file mode 120000
index 0000000..1c0edad
--- /dev/null
+++ b/project/twrp2/195/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys2exhilarate.html
\ No newline at end of file
diff --git a/project/twrp2/196/index.html b/project/twrp2/196/index.html
new file mode 120000
index 0000000..6f93377
--- /dev/null
+++ b/project/twrp2/196/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxymega58.html
\ No newline at end of file
diff --git a/project/twrp2/197/index.html b/project/twrp2/197/index.html
new file mode 120000
index 0000000..be840d0
--- /dev/null
+++ b/project/twrp2/197/index.html
@@ -0,0 +1 @@
+../../../devices/lgg2.html
\ No newline at end of file
diff --git a/project/twrp2/198/index.html b/project/twrp2/198/index.html
new file mode 120000
index 0000000..dddb424
--- /dev/null
+++ b/project/twrp2/198/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3tmobile.html
\ No newline at end of file
diff --git a/project/twrp2/199/index.html b/project/twrp2/199/index.html
new file mode 120000
index 0000000..3b82e4e
--- /dev/null
+++ b/project/twrp2/199/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxymega63.html
\ No newline at end of file
diff --git a/project/twrp2/200/index.html b/project/twrp2/200/index.html
new file mode 120000
index 0000000..5ab102a
--- /dev/null
+++ b/project/twrp2/200/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3canada.html
\ No newline at end of file
diff --git a/project/twrp2/201/index.html b/project/twrp2/201/index.html
new file mode 120000
index 0000000..2e19af7
--- /dev/null
+++ b/project/twrp2/201/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3sprint.html
\ No newline at end of file
diff --git a/project/twrp2/202/index.html b/project/twrp2/202/index.html
new file mode 120000
index 0000000..53a5df4
--- /dev/null
+++ b/project/twrp2/202/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3internationalqualcomm.html
\ No newline at end of file
diff --git a/project/twrp2/204/index.html b/project/twrp2/204/index.html
new file mode 120000
index 0000000..ad2cc2b
--- /dev/null
+++ b/project/twrp2/204/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3internationalexynos.html
\ No newline at end of file
diff --git a/project/twrp2/205/index.html b/project/twrp2/205/index.html
new file mode 120000
index 0000000..3394fd6
--- /dev/null
+++ b/project/twrp2/205/index.html
@@ -0,0 +1 @@
+../../../devices/lgnexus5.html
\ No newline at end of file
diff --git a/project/twrp2/206/index.html b/project/twrp2/206/index.html
new file mode 120000
index 0000000..218672c
--- /dev/null
+++ b/project/twrp2/206/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote1012014exynos.html
\ No newline at end of file
diff --git a/project/twrp2/207/index.html b/project/twrp2/207/index.html
new file mode 120000
index 0000000..5af0836
--- /dev/null
+++ b/project/twrp2/207/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote1012014qcom.html
\ No newline at end of file
diff --git a/project/twrp2/208/index.html b/project/twrp2/208/index.html
new file mode 120000
index 0000000..6ca2e01
--- /dev/null
+++ b/project/twrp2/208/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxyreverb.html
\ No newline at end of file
diff --git a/project/twrp2/209/index.html b/project/twrp2/209/index.html
new file mode 120000
index 0000000..033a93d
--- /dev/null
+++ b/project/twrp2/209/index.html
@@ -0,0 +1 @@
+../../../devices/oppon1.html
\ No newline at end of file
diff --git a/project/twrp2/210/index.html b/project/twrp2/210/index.html
new file mode 120000
index 0000000..5e55c69
--- /dev/null
+++ b/project/twrp2/210/index.html
@@ -0,0 +1 @@
+../../../devices/htconemaxverizon.html
\ No newline at end of file
diff --git a/project/twrp2/211/index.html b/project/twrp2/211/index.html
new file mode 120000
index 0000000..d04b57f
--- /dev/null
+++ b/project/twrp2/211/index.html
@@ -0,0 +1 @@
+../../../devices/htconemaxsprint.html
\ No newline at end of file
diff --git a/project/twrp2/212/index.html b/project/twrp2/212/index.html
new file mode 120000
index 0000000..450da43
--- /dev/null
+++ b/project/twrp2/212/index.html
@@ -0,0 +1 @@
+../../../devices/lggflexkorean.html
\ No newline at end of file
diff --git a/project/twrp2/213/index.html b/project/twrp2/213/index.html
new file mode 120000
index 0000000..6571331
--- /dev/null
+++ b/project/twrp2/213/index.html
@@ -0,0 +1 @@
+../../../devices/lggpad83.html
\ No newline at end of file
diff --git a/project/twrp2/214/index.html b/project/twrp2/214/index.html
new file mode 120000
index 0000000..79e0e25
--- /dev/null
+++ b/project/twrp2/214/index.html
@@ -0,0 +1 @@
+../../../devices/omatetruesmart.html
\ No newline at end of file
diff --git a/project/twrp2/215/index.html b/project/twrp2/215/index.html
new file mode 120000
index 0000000..5661a8c
--- /dev/null
+++ b/project/twrp2/215/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxyprevail.html
\ No newline at end of file
diff --git a/project/twrp2/216/index.html b/project/twrp2/216/index.html
new file mode 120000
index 0000000..3da4672
--- /dev/null
+++ b/project/twrp2/216/index.html
@@ -0,0 +1 @@
+../../../devices/htconeminigsm.html
\ No newline at end of file
diff --git a/project/twrp2/217/index.html b/project/twrp2/217/index.html
new file mode 120000
index 0000000..eac25c4
--- /dev/null
+++ b/project/twrp2/217/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesire601cdma.html
\ No newline at end of file
diff --git a/project/twrp2/218/index.html b/project/twrp2/218/index.html
new file mode 120000
index 0000000..f8803e4
--- /dev/null
+++ b/project/twrp2/218/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3uscellular.html
\ No newline at end of file
diff --git a/project/twrp2/219/index.html b/project/twrp2/219/index.html
new file mode 120000
index 0000000..5d97fda
--- /dev/null
+++ b/project/twrp2/219/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperiazultra.html
\ No newline at end of file
diff --git a/project/twrp2/220/index.html b/project/twrp2/220/index.html
new file mode 120000
index 0000000..f1d7b50
--- /dev/null
+++ b/project/twrp2/220/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabpro8.html
\ No newline at end of file
diff --git a/project/twrp2/221/index.html b/project/twrp2/221/index.html
new file mode 120000
index 0000000..91c45c7
--- /dev/null
+++ b/project/twrp2/221/index.html
@@ -0,0 +1 @@
+../../../devices/htconem8sprint.html
\ No newline at end of file
diff --git a/project/twrp2/222/index.html b/project/twrp2/222/index.html
new file mode 120000
index 0000000..f1d7b50
--- /dev/null
+++ b/project/twrp2/222/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabpro8.html
\ No newline at end of file
diff --git a/project/twrp2/224/index.html b/project/twrp2/224/index.html
new file mode 120000
index 0000000..49703dc
--- /dev/null
+++ b/project/twrp2/224/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynotepro122exynoswifi.html
\ No newline at end of file
diff --git a/project/twrp2/225/index.html b/project/twrp2/225/index.html
new file mode 120000
index 0000000..814de6d
--- /dev/null
+++ b/project/twrp2/225/index.html
@@ -0,0 +1 @@
+../../../devices/htconem8gsm.html
\ No newline at end of file
diff --git a/project/twrp2/226/index.html b/project/twrp2/226/index.html
new file mode 120000
index 0000000..26523c6
--- /dev/null
+++ b/project/twrp2/226/index.html
@@ -0,0 +1 @@
+../../../devices/htconem8verizon.html
\ No newline at end of file
diff --git a/project/twrp2/229/index.html b/project/twrp2/229/index.html
new file mode 120000
index 0000000..d932b98
--- /dev/null
+++ b/project/twrp2/229/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys5qualcomm.html
\ No newline at end of file
diff --git a/project/twrp2/230/index.html b/project/twrp2/230/index.html
new file mode 120000
index 0000000..c6c35dd
--- /dev/null
+++ b/project/twrp2/230/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabpro101lte.html
\ No newline at end of file
diff --git a/project/twrp2/231/index.html b/project/twrp2/231/index.html
new file mode 120000
index 0000000..1532f85
--- /dev/null
+++ b/project/twrp2/231/index.html
@@ -0,0 +1 @@
+../../../devices/oneplusone.html
\ No newline at end of file
diff --git a/project/twrp2/232/index.html b/project/twrp2/232/index.html
new file mode 120000
index 0000000..eeefe2d
--- /dev/null
+++ b/project/twrp2/232/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperiaz2.html
\ No newline at end of file
diff --git a/project/twrp2/233/index.html b/project/twrp2/233/index.html
new file mode 120000
index 0000000..a7d515f
--- /dev/null
+++ b/project/twrp2/233/index.html
@@ -0,0 +1 @@
+../../../devices/motorolamotog2013.html
\ No newline at end of file
diff --git a/project/twrp2/234/index.html b/project/twrp2/234/index.html
new file mode 120000
index 0000000..4500be7
--- /dev/null
+++ b/project/twrp2/234/index.html
@@ -0,0 +1 @@
+../../../devices/motorolamotox2013.html
\ No newline at end of file
diff --git a/project/twrp2/235/index.html b/project/twrp2/235/index.html
new file mode 120000
index 0000000..99d0b61
--- /dev/null
+++ b/project/twrp2/235/index.html
@@ -0,0 +1 @@
+../../../devices/motorolamotoe.html
\ No newline at end of file
diff --git a/project/twrp2/236/index.html b/project/twrp2/236/index.html
new file mode 120000
index 0000000..35d7084
--- /dev/null
+++ b/project/twrp2/236/index.html
@@ -0,0 +1 @@
+../../../devices/htcfirst.html
\ No newline at end of file
diff --git a/project/twrp2/237/index.html b/project/twrp2/237/index.html
new file mode 120000
index 0000000..0e9dcfa
--- /dev/null
+++ b/project/twrp2/237/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynotepro122qcom.html
\ No newline at end of file
diff --git a/project/twrp2/238/index.html b/project/twrp2/238/index.html
new file mode 120000
index 0000000..0f887b8
--- /dev/null
+++ b/project/twrp2/238/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabs84.html
\ No newline at end of file
diff --git a/project/twrp2/239/index.html b/project/twrp2/239/index.html
new file mode 120000
index 0000000..96def58
--- /dev/null
+++ b/project/twrp2/239/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabs105.html
\ No newline at end of file
diff --git a/project/twrp2/240/index.html b/project/twrp2/240/index.html
new file mode 120000
index 0000000..a8981b5
--- /dev/null
+++ b/project/twrp2/240/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimus4xhd.html
\ No newline at end of file
diff --git a/project/twrp2/241/index.html b/project/twrp2/241/index.html
new file mode 120000
index 0000000..bbd1347
--- /dev/null
+++ b/project/twrp2/241/index.html
@@ -0,0 +1 @@
+../../../devices/xiaomiredmi1s.html
\ No newline at end of file
diff --git a/project/twrp2/242/index.html b/project/twrp2/242/index.html
new file mode 120000
index 0000000..d6a9ce7
--- /dev/null
+++ b/project/twrp2/242/index.html
@@ -0,0 +1 @@
+../../../devices/lggwatch.html
\ No newline at end of file
diff --git a/project/twrp2/243/index.html b/project/twrp2/243/index.html
new file mode 120000
index 0000000..13f423b
--- /dev/null
+++ b/project/twrp2/243/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggearlive.html
\ No newline at end of file
diff --git a/project/twrp2/244/index.html b/project/twrp2/244/index.html
new file mode 120000
index 0000000..32a93d9
--- /dev/null
+++ b/project/twrp2/244/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabpro122exynoswifi.html
\ No newline at end of file
diff --git a/project/twrp2/245/index.html b/project/twrp2/245/index.html
new file mode 120000
index 0000000..4996099
--- /dev/null
+++ b/project/twrp2/245/index.html
@@ -0,0 +1 @@
+../../../devices/oppofind7.html
\ No newline at end of file
diff --git a/project/twrp2/246/index.html b/project/twrp2/246/index.html
new file mode 120000
index 0000000..8712e35
--- /dev/null
+++ b/project/twrp2/246/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesire610usa.html
\ No newline at end of file
diff --git a/project/twrp2/247/index.html b/project/twrp2/247/index.html
new file mode 120000
index 0000000..9213d3b
--- /dev/null
+++ b/project/twrp2/247/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesire816.html
\ No newline at end of file
diff --git a/project/twrp2/248/index.html b/project/twrp2/248/index.html
new file mode 120000
index 0000000..0700e01
--- /dev/null
+++ b/project/twrp2/248/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytab470.html
\ No newline at end of file
diff --git a/project/twrp2/249/index.html b/project/twrp2/249/index.html
new file mode 120000
index 0000000..c58b56f
--- /dev/null
+++ b/project/twrp2/249/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3tmo.html
\ No newline at end of file
diff --git a/project/twrp2/250/index.html b/project/twrp2/250/index.html
new file mode 120000
index 0000000..c3a4222
--- /dev/null
+++ b/project/twrp2/250/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys2plus.html
\ No newline at end of file
diff --git a/project/twrp2/251/index.html b/project/twrp2/251/index.html
new file mode 120000
index 0000000..39bb74b
--- /dev/null
+++ b/project/twrp2/251/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote3verizon.html
\ No newline at end of file
diff --git a/project/twrp2/252/index.html b/project/twrp2/252/index.html
new file mode 120000
index 0000000..cd07f05
--- /dev/null
+++ b/project/twrp2/252/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxygrandduos.html
\ No newline at end of file
diff --git a/project/twrp2/253/index.html b/project/twrp2/253/index.html
new file mode 120000
index 0000000..c9a32f9
--- /dev/null
+++ b/project/twrp2/253/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytabpro101exynoswifi.html
\ No newline at end of file
diff --git a/project/twrp2/255/index.html b/project/twrp2/255/index.html
new file mode 120000
index 0000000..0a22bdf
--- /dev/null
+++ b/project/twrp2/255/index.html
@@ -0,0 +1 @@
+../../../devices/htconem7verizon.html
\ No newline at end of file
diff --git a/project/twrp2/256/index.html b/project/twrp2/256/index.html
new file mode 120000
index 0000000..5521c8b
--- /dev/null
+++ b/project/twrp2/256/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3att.html
\ No newline at end of file
diff --git a/project/twrp2/257/index.html b/project/twrp2/257/index.html
new file mode 120000
index 0000000..658c1c0
--- /dev/null
+++ b/project/twrp2/257/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3verizon.html
\ No newline at end of file
diff --git a/project/twrp2/258/index.html b/project/twrp2/258/index.html
new file mode 120000
index 0000000..9ce52e5
--- /dev/null
+++ b/project/twrp2/258/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3sprint.html
\ No newline at end of file
diff --git a/project/twrp2/259/index.html b/project/twrp2/259/index.html
new file mode 120000
index 0000000..528f9a9
--- /dev/null
+++ b/project/twrp2/259/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3korea.html
\ No newline at end of file
diff --git a/project/twrp2/260/index.html b/project/twrp2/260/index.html
new file mode 120000
index 0000000..f12683a
--- /dev/null
+++ b/project/twrp2/260/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3canadawindvideotronsasktel.html
\ No newline at end of file
diff --git a/project/twrp2/261/index.html b/project/twrp2/261/index.html
new file mode 120000
index 0000000..9b395d3
--- /dev/null
+++ b/project/twrp2/261/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3canadabellrogers.html
\ No newline at end of file
diff --git a/project/twrp2/262/index.html b/project/twrp2/262/index.html
new file mode 120000
index 0000000..f6e3fe4
--- /dev/null
+++ b/project/twrp2/262/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3europe.html
\ No newline at end of file
diff --git a/project/twrp2/263/index.html b/project/twrp2/263/index.html
new file mode 120000
index 0000000..60969b9
--- /dev/null
+++ b/project/twrp2/263/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynotepro122exynos3g.html
\ No newline at end of file
diff --git a/project/twrp2/264/index.html b/project/twrp2/264/index.html
new file mode 120000
index 0000000..f846cba
--- /dev/null
+++ b/project/twrp2/264/index.html
@@ -0,0 +1 @@
+../../../devices/motorolamotox2014.html
\ No newline at end of file
diff --git a/project/twrp2/265/index.html b/project/twrp2/265/index.html
new file mode 120000
index 0000000..54b5000
--- /dev/null
+++ b/project/twrp2/265/index.html
@@ -0,0 +1 @@
+../../../devices/huaweiascendmate2.html
\ No newline at end of file
diff --git a/project/twrp2/266/index.html b/project/twrp2/266/index.html
new file mode 120000
index 0000000..0b023f6
--- /dev/null
+++ b/project/twrp2/266/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote4qualcomm.html
\ No newline at end of file
diff --git a/project/twrp2/267/index.html b/project/twrp2/267/index.html
new file mode 120000
index 0000000..9f35362
--- /dev/null
+++ b/project/twrp2/267/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxyalpha.html
\ No newline at end of file
diff --git a/project/twrp2/268/index.html b/project/twrp2/268/index.html
new file mode 120000
index 0000000..0ea4b17
--- /dev/null
+++ b/project/twrp2/268/index.html
@@ -0,0 +1 @@
+../../../devices/androidone.html
\ No newline at end of file
diff --git a/project/twrp2/269/index.html b/project/twrp2/269/index.html
new file mode 120000
index 0000000..57096aa
--- /dev/null
+++ b/project/twrp2/269/index.html
@@ -0,0 +1 @@
+../../../devices/htcnexus9.html
\ No newline at end of file
diff --git a/project/twrp2/270/index.html b/project/twrp2/270/index.html
new file mode 120000
index 0000000..adb475c
--- /dev/null
+++ b/project/twrp2/270/index.html
@@ -0,0 +1 @@
+../../../devices/motorolanexus6.html
\ No newline at end of file
diff --git a/project/twrp2/271/index.html b/project/twrp2/271/index.html
new file mode 120000
index 0000000..f493123
--- /dev/null
+++ b/project/twrp2/271/index.html
@@ -0,0 +1 @@
+../../../devices/micromaxcanvasmagnus.html
\ No newline at end of file
diff --git a/project/twrp2/272/index.html b/project/twrp2/272/index.html
new file mode 120000
index 0000000..c2f227c
--- /dev/null
+++ b/project/twrp2/272/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesire510usa32bit.html
\ No newline at end of file
diff --git a/project/twrp2/273/index.html b/project/twrp2/273/index.html
new file mode 120000
index 0000000..d17a7c8
--- /dev/null
+++ b/project/twrp2/273/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote4exynos.html
\ No newline at end of file
diff --git a/project/twrp2/274/index.html b/project/twrp2/274/index.html
new file mode 120000
index 0000000..19ade42
--- /dev/null
+++ b/project/twrp2/274/index.html
@@ -0,0 +1 @@
+../../../devices/bqaquarisee54g.html
\ No newline at end of file
diff --git a/project/twrp2/275/index.html b/project/twrp2/275/index.html
new file mode 120000
index 0000000..53e3577
--- /dev/null
+++ b/project/twrp2/275/index.html
@@ -0,0 +1 @@
+../../../devices/motorolamotog2014.html
\ No newline at end of file
diff --git a/project/twrp2/276/index.html b/project/twrp2/276/index.html
new file mode 120000
index 0000000..23ecd32
--- /dev/null
+++ b/project/twrp2/276/index.html
@@ -0,0 +1 @@
+../../../devices/lgg3uscellular.html
\ No newline at end of file
diff --git a/project/twrp2/277/index.html b/project/twrp2/277/index.html
new file mode 120000
index 0000000..fa9c035
--- /dev/null
+++ b/project/twrp2/277/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimusfuel.html
\ No newline at end of file
diff --git a/project/twrp2/278/index.html b/project/twrp2/278/index.html
new file mode 120000
index 0000000..f0de492
--- /dev/null
+++ b/project/twrp2/278/index.html
@@ -0,0 +1 @@
+../../../devices/htconem7dualsim.html
\ No newline at end of file
diff --git a/project/twrp2/279/index.html b/project/twrp2/279/index.html
new file mode 120000
index 0000000..7868cf6
--- /dev/null
+++ b/project/twrp2/279/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesire601gsm.html
\ No newline at end of file
diff --git a/project/twrp2/280/index.html b/project/twrp2/280/index.html
new file mode 120000
index 0000000..7ec4a0b
--- /dev/null
+++ b/project/twrp2/280/index.html
@@ -0,0 +1 @@
+../../../devices/motorolamoto360.html
\ No newline at end of file
diff --git a/project/twrp2/281/index.html b/project/twrp2/281/index.html
new file mode 120000
index 0000000..bd819a1
--- /dev/null
+++ b/project/twrp2/281/index.html
@@ -0,0 +1 @@
+../../../devices/lggwatchr.html
\ No newline at end of file
diff --git a/project/twrp2/283/index.html b/project/twrp2/283/index.html
new file mode 120000
index 0000000..8ae1195
--- /dev/null
+++ b/project/twrp2/283/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxytab2101.html
\ No newline at end of file
diff --git a/project/twrp2/284/index.html b/project/twrp2/284/index.html
new file mode 120000
index 0000000..7f60d31
--- /dev/null
+++ b/project/twrp2/284/index.html
@@ -0,0 +1 @@
+../../../devices/yuyureka.html
\ No newline at end of file
diff --git a/project/twrp2/285/index.html b/project/twrp2/285/index.html
new file mode 120000
index 0000000..1866634
--- /dev/null
+++ b/project/twrp2/285/index.html
@@ -0,0 +1 @@
+../../../devices/htcbutterfly2.html
\ No newline at end of file
diff --git a/project/twrp2/286/index.html b/project/twrp2/286/index.html
new file mode 120000
index 0000000..92cfef5
--- /dev/null
+++ b/project/twrp2/286/index.html
@@ -0,0 +1 @@
+../../../devices/sonyxperial.html
\ No newline at end of file
diff --git a/project/twrp2/287/index.html b/project/twrp2/287/index.html
new file mode 120000
index 0000000..2c51d4c
--- /dev/null
+++ b/project/twrp2/287/index.html
@@ -0,0 +1 @@
+../../../devices/kazamthunderq45.html
\ No newline at end of file
diff --git a/project/twrp2/288/index.html b/project/twrp2/288/index.html
new file mode 120000
index 0000000..afb07b7
--- /dev/null
+++ b/project/twrp2/288/index.html
@@ -0,0 +1 @@
+../../../devices/xiaomimi3.html
\ No newline at end of file
diff --git a/project/twrp2/289/index.html b/project/twrp2/289/index.html
new file mode 120000
index 0000000..464c500
--- /dev/null
+++ b/project/twrp2/289/index.html
@@ -0,0 +1 @@
+../../../devices/amlogick200.html
\ No newline at end of file
diff --git a/project/twrp2/290/index.html b/project/twrp2/290/index.html
new file mode 120000
index 0000000..48adc82
--- /dev/null
+++ b/project/twrp2/290/index.html
@@ -0,0 +1 @@
+../../../devices/kazamtornado348.html
\ No newline at end of file
diff --git a/project/twrp2/3/index.html b/project/twrp2/3/index.html
new file mode 120000
index 0000000..11b4598
--- /dev/null
+++ b/project/twrp2/3/index.html
@@ -0,0 +1 @@
+../../../devices/htcevo4g.html
\ No newline at end of file
diff --git a/project/twrp2/4/index.html b/project/twrp2/4/index.html
new file mode 120000
index 0000000..a2d4d2f
--- /dev/null
+++ b/project/twrp2/4/index.html
@@ -0,0 +1 @@
+../../../devices/htcdroidincredible.html
\ No newline at end of file
diff --git a/project/twrp2/40/index.html b/project/twrp2/40/index.html
new file mode 120000
index 0000000..6ce9185
--- /dev/null
+++ b/project/twrp2/40/index.html
@@ -0,0 +1 @@
+../../../devices/samsungefascinate.html
\ No newline at end of file
diff --git a/project/twrp2/43/index.html b/project/twrp2/43/index.html
new file mode 120000
index 0000000..86ec65c
--- /dev/null
+++ b/project/twrp2/43/index.html
@@ -0,0 +1 @@
+../../../devices/barnesnoblenookcolor.html
\ No newline at end of file
diff --git a/project/twrp2/44/index.html b/project/twrp2/44/index.html
new file mode 120000
index 0000000..b260075
--- /dev/null
+++ b/project/twrp2/44/index.html
@@ -0,0 +1 @@
+../../../devices/samsungnexuss.html
\ No newline at end of file
diff --git a/project/twrp2/49/index.html b/project/twrp2/49/index.html
new file mode 120000
index 0000000..171ee10
--- /dev/null
+++ b/project/twrp2/49/index.html
@@ -0,0 +1 @@
+../../../devices/htcherocdma.html
\ No newline at end of file
diff --git a/project/twrp2/5/index.html b/project/twrp2/5/index.html
new file mode 120000
index 0000000..731c81a
--- /dev/null
+++ b/project/twrp2/5/index.html
@@ -0,0 +1 @@
+../../../devices/htcevoshift.html
\ No newline at end of file
diff --git a/project/twrp2/51/index.html b/project/twrp2/51/index.html
new file mode 120000
index 0000000..6072cf2
--- /dev/null
+++ b/project/twrp2/51/index.html
@@ -0,0 +1 @@
+../../../devices/htcnexusone.html
\ No newline at end of file
diff --git a/project/twrp2/6/index.html b/project/twrp2/6/index.html
new file mode 120000
index 0000000..a37474a
--- /dev/null
+++ b/project/twrp2/6/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesirehd.html
\ No newline at end of file
diff --git a/project/twrp2/61/index.html b/project/twrp2/61/index.html
new file mode 120000
index 0000000..374ae34
--- /dev/null
+++ b/project/twrp2/61/index.html
@@ -0,0 +1 @@
+../../../devices/motorolaxoom.html
\ No newline at end of file
diff --git a/project/twrp2/63/index.html b/project/twrp2/63/index.html
new file mode 120000
index 0000000..46b9ed1
--- /dev/null
+++ b/project/twrp2/63/index.html
@@ -0,0 +1 @@
+../../../devices/lgtmobileg2x.html
\ No newline at end of file
diff --git a/project/twrp2/65/index.html b/project/twrp2/65/index.html
new file mode 120000
index 0000000..8e107dd
--- /dev/null
+++ b/project/twrp2/65/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimus2x.html
\ No newline at end of file
diff --git a/project/twrp2/66/index.html b/project/twrp2/66/index.html
new file mode 120000
index 0000000..6f50cba
--- /dev/null
+++ b/project/twrp2/66/index.html
@@ -0,0 +1 @@
+../../../devices/htcsensation.html
\ No newline at end of file
diff --git a/project/twrp2/67/index.html b/project/twrp2/67/index.html
new file mode 120000
index 0000000..4ec98c6
--- /dev/null
+++ b/project/twrp2/67/index.html
@@ -0,0 +1 @@
+../../../devices/htcevo3dcdma.html
\ No newline at end of file
diff --git a/project/twrp2/68/index.html b/project/twrp2/68/index.html
new file mode 120000
index 0000000..4691c6e
--- /dev/null
+++ b/project/twrp2/68/index.html
@@ -0,0 +1 @@
+../../../devices/htcdesires.html
\ No newline at end of file
diff --git a/project/twrp2/70/index.html b/project/twrp2/70/index.html
new file mode 120000
index 0000000..a2bfc8d
--- /dev/null
+++ b/project/twrp2/70/index.html
@@ -0,0 +1 @@
+../../../devices/htcincredibles.html
\ No newline at end of file
diff --git a/project/twrp2/71/index.html b/project/twrp2/71/index.html
new file mode 120000
index 0000000..1b5a61b
--- /dev/null
+++ b/project/twrp2/71/index.html
@@ -0,0 +1 @@
+../../../devices/htcdroidincredible2.html
\ No newline at end of file
diff --git a/project/twrp2/72/index.html b/project/twrp2/72/index.html
new file mode 120000
index 0000000..2a09e60
--- /dev/null
+++ b/project/twrp2/72/index.html
@@ -0,0 +1 @@
+../../../devices/motorolaatrix4g.html
\ No newline at end of file
diff --git a/project/twrp2/73/index.html b/project/twrp2/73/index.html
new file mode 120000
index 0000000..d4c6558
--- /dev/null
+++ b/project/twrp2/73/index.html
@@ -0,0 +1 @@
+../../../devices/lgoptimusone.html
\ No newline at end of file
diff --git a/project/twrp2/74/index.html b/project/twrp2/74/index.html
new file mode 120000
index 0000000..798b107
--- /dev/null
+++ b/project/twrp2/74/index.html
@@ -0,0 +1 @@
+../../../devices/samsungnexuss4g.html
\ No newline at end of file
diff --git a/project/twrp2/75/index.html b/project/twrp2/75/index.html
new file mode 120000
index 0000000..e7d7efb
--- /dev/null
+++ b/project/twrp2/75/index.html
@@ -0,0 +1 @@
+../../../devices/hptouchpad.html
\ No newline at end of file
diff --git a/project/twrp2/76/index.html b/project/twrp2/76/index.html
new file mode 120000
index 0000000..7b877e5
--- /dev/null
+++ b/project/twrp2/76/index.html
@@ -0,0 +1 @@
+../../../devices/htcvivid.html
\ No newline at end of file
diff --git a/project/twrp2/79/index.html b/project/twrp2/79/index.html
new file mode 120000
index 0000000..0da8837
--- /dev/null
+++ b/project/twrp2/79/index.html
@@ -0,0 +1 @@
+../../../devices/amazonkindlefire.html
\ No newline at end of file
diff --git a/project/twrp2/80/index.html b/project/twrp2/80/index.html
new file mode 120000
index 0000000..0066946
--- /dev/null
+++ b/project/twrp2/80/index.html
@@ -0,0 +1 @@
+../../../devices/htchd2.html
\ No newline at end of file
diff --git a/project/twrp2/82/index.html b/project/twrp2/82/index.html
new file mode 120000
index 0000000..5520fb0
--- /dev/null
+++ b/project/twrp2/82/index.html
@@ -0,0 +1 @@
+../../../devices/motorolaphoton4g.html
\ No newline at end of file
diff --git a/project/twrp2/84/index.html b/project/twrp2/84/index.html
new file mode 120000
index 0000000..3fd99da
--- /dev/null
+++ b/project/twrp2/84/index.html
@@ -0,0 +1 @@
+../../../devices/htcmerge.html
\ No newline at end of file
diff --git a/project/twrp2/86/index.html b/project/twrp2/86/index.html
new file mode 120000
index 0000000..04050cc
--- /dev/null
+++ b/project/twrp2/86/index.html
@@ -0,0 +1 @@
+../../../devices/htcamaze4g.html
\ No newline at end of file
diff --git a/project/twrp2/87/index.html b/project/twrp2/87/index.html
new file mode 120000
index 0000000..2095b21
--- /dev/null
+++ b/project/twrp2/87/index.html
@@ -0,0 +1 @@
+../../../devices/htcevo3dgsm.html
\ No newline at end of file
diff --git a/project/twrp2/88/index.html b/project/twrp2/88/index.html
new file mode 120000
index 0000000..91022b6
--- /dev/null
+++ b/project/twrp2/88/index.html
@@ -0,0 +1 @@
+../../../devices/acericoniaa500.html
\ No newline at end of file
diff --git a/project/twrp2/89/index.html b/project/twrp2/89/index.html
new file mode 120000
index 0000000..6ed335b
--- /dev/null
+++ b/project/twrp2/89/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynexusverizon.html
\ No newline at end of file
diff --git a/project/twrp2/90/index.html b/project/twrp2/90/index.html
new file mode 120000
index 0000000..e4912e5
--- /dev/null
+++ b/project/twrp2/90/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynexusgsm.html
\ No newline at end of file
diff --git a/project/twrp2/91/index.html b/project/twrp2/91/index.html
new file mode 120000
index 0000000..a5c098f
--- /dev/null
+++ b/project/twrp2/91/index.html
@@ -0,0 +1 @@
+../../../devices/motoroladefy.html
\ No newline at end of file
diff --git a/project/twrp2/92/index.html b/project/twrp2/92/index.html
new file mode 120000
index 0000000..1c035ed
--- /dev/null
+++ b/project/twrp2/92/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynexussprint.html
\ No newline at end of file
diff --git a/project/twrp2/93/index.html b/project/twrp2/93/index.html
new file mode 120000
index 0000000..d926a26
--- /dev/null
+++ b/project/twrp2/93/index.html
@@ -0,0 +1 @@
+../../../devices/asustransformerprimeTF201.html
\ No newline at end of file
diff --git a/project/twrp2/94/index.html b/project/twrp2/94/index.html
new file mode 120000
index 0000000..9454815
--- /dev/null
+++ b/project/twrp2/94/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxys2skyrocket.html
\ No newline at end of file
diff --git a/project/twrp2/95/index.html b/project/twrp2/95/index.html
new file mode 120000
index 0000000..d00acb9
--- /dev/null
+++ b/project/twrp2/95/index.html
@@ -0,0 +1 @@
+../../../devices/htconexinternational.html
\ No newline at end of file
diff --git a/project/twrp2/96/index.html b/project/twrp2/96/index.html
new file mode 120000
index 0000000..653ab25
--- /dev/null
+++ b/project/twrp2/96/index.html
@@ -0,0 +1 @@
+../../../devices/samsunggalaxynote1att.html
\ No newline at end of file
diff --git a/project/twrp2/97/index.html b/project/twrp2/97/index.html
new file mode 120000
index 0000000..fd66a2e
--- /dev/null
+++ b/project/twrp2/97/index.html
@@ -0,0 +1 @@
+../../../devices/asusTF300T.html
\ No newline at end of file
diff --git a/project/twrp2/98/index.html b/project/twrp2/98/index.html
new file mode 120000
index 0000000..0372854
--- /dev/null
+++ b/project/twrp2/98/index.html
@@ -0,0 +1 @@
+../../../devices/htcevo4glte.html
\ No newline at end of file
diff --git a/project/twrp2/99/index.html b/project/twrp2/99/index.html
new file mode 120000
index 0000000..8406170
--- /dev/null
+++ b/project/twrp2/99/index.html
@@ -0,0 +1 @@
+../../../devices/htconexatt.html
\ No newline at end of file
diff --git a/removetwrp/index.html b/removetwrp/index.html
new file mode 120000
index 0000000..e39790a
--- /dev/null
+++ b/removetwrp/index.html
@@ -0,0 +1 @@
+../faq/removetwrp.html
\ No newline at end of file
diff --git a/search.json b/search.json
new file mode 100644
index 0000000..5e400e3
--- /dev/null
+++ b/search.json
@@ -0,0 +1,12 @@
+---
+layout: none
+---
+[
+    {% for device in site.devices %}
+       {
+         "title"    : "{{ device.title | escape }} ({{ device.codename }})",
+         "desc"     : "TWRP for {{ device.title | escape }}",
+         "url"      : "{{ device.url }}"
+       } {% if forloop.last %}{% else %},{% endif %}
+   {% endfor %}
+]
diff --git a/search/index.html b/search/index.html
new file mode 100644
index 0000000..3a0fccd
--- /dev/null
+++ b/search/index.html
@@ -0,0 +1,20 @@
+---
+layout: page
+---
+
+<div class='page-heading'>Search for TWRP for your device here:</div>
+<hr />
+<script src="/js/jekyll-search.js"></script>
+<input type="text" id="search-input" placeholder="Search..">
+<div id="results"></div>
+<script type='text/javascript' src='http://ajax.googleapis.com/ajax/libs/jquery/1.10.1/jquery.min.js'></script>  
+    <script type="text/javascript">
+      SimpleJekyllSearch.init({
+        searchInput: document.getElementById('search-input'),
+        resultsContainer: document.getElementById('results'),
+        dataSource: 'http://twrp.me/search.json',
+        searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
+        noResultsText: 'No results found',
+        fuzzy: false,
+      })
+    </script>
diff --git a/securetwrp/index.html b/securetwrp/index.html
new file mode 120000
index 0000000..edce05b
--- /dev/null
+++ b/securetwrp/index.html
@@ -0,0 +1 @@
+../faq/securetwrp.html
\ No newline at end of file
diff --git a/src/JSONLoader.js b/src/JSONLoader.js
new file mode 100644
index 0000000..10e2840
--- /dev/null
+++ b/src/JSONLoader.js
@@ -0,0 +1,26 @@
+module.exports = function JSONLoader(){
+  var self = this;
+
+  function receivedResponse(xhr){
+    return xhr.status==200 && xhr.readyState==4;
+  }
+
+  function handleResponse(xhr,callback){
+    xhr.onreadystatechange = function(){
+      if ( receivedResponse(xhr) ){
+        try{
+          callback(null,JSON.parse(xhr.responseText) );
+        }catch(err){
+          callback(err,null);
+        }    
+      }
+    }
+  }
+
+  self.load = function(location,callback){
+    var xhr = (window.XMLHttpRequest) ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");
+    xhr.open("GET", location, true);
+    handleResponse(xhr,callback);
+    xhr.send();
+  };
+};
\ No newline at end of file
diff --git a/src/SearchStrategies/fuzzy.js b/src/SearchStrategies/fuzzy.js
new file mode 100644
index 0000000..ab26035
--- /dev/null
+++ b/src/SearchStrategies/fuzzy.js
@@ -0,0 +1,15 @@
+module.exports = new FuzzySearchStrategy();
+
+function FuzzySearchStrategy(){
+  var self = this;
+
+  function createFuzzyRegExpFromString(string){
+    return new RegExp( string.split('').join('.*?'), 'gi');
+  }
+
+  self.matches = function(string,crit){
+    if( typeof string !== 'string' ) return false;
+    string = string.trim();
+    return !!string.match(createFuzzyRegExpFromString(crit));
+  };
+};
\ No newline at end of file
diff --git a/src/SearchStrategies/literal.js b/src/SearchStrategies/literal.js
new file mode 100644
index 0000000..9bddbe9
--- /dev/null
+++ b/src/SearchStrategies/literal.js
@@ -0,0 +1,15 @@
+module.exports = new LiteralSearchStrategy();
+
+function LiteralSearchStrategy(){
+  var self = this;
+
+  function doMatch(string,crit){
+    return string.toLowerCase().indexOf(crit.toLowerCase()) >= 0;
+  }
+
+  self.matches = function(string,crit){
+    if( typeof string !== 'string' ) return false;
+    string = string.trim();
+    return doMatch(string,crit);
+  };
+};
\ No newline at end of file
diff --git a/src/Searcher.js b/src/Searcher.js
new file mode 100644
index 0000000..99626dd
--- /dev/null
+++ b/src/Searcher.js
@@ -0,0 +1,42 @@
+module.exports = function Searcher(){
+  var self = this;
+
+  var matches = [];
+
+  var fuzzy = false;
+  var limit = 10;
+
+  var fuzzySearchStrategy = require('./SearchStrategies/fuzzy');
+  var literalSearchStrategy = require('./SearchStrategies/literal');
+
+  self.setFuzzy = function(_fuzzy){ fuzzy = !!_fuzzy; };
+
+  self.setLimit = function(_limit){ limit = parseInt(_limit,10) || limit; };
+
+  self.search = function(data,crit){
+    if( !crit ) return [];
+    matches.length = 0;
+    return findMatches(data,crit,getSearchStrategy());
+  };
+
+  function findMatches(store,crit,strategy){
+    var data = store.get();
+    for(var i = 0; i < data.length && matches.length < limit; i++) {
+      findMatchesInObject(data[i],crit,strategy);
+    }
+    return matches;
+  }
+
+  function findMatchesInObject(obj,crit,strategy){
+    for(var key in obj) {
+      if( strategy.matches(obj[key], crit) ){
+        matches.push(obj);
+        break;
+      }
+    }
+  }
+
+  function getSearchStrategy(){
+    return fuzzy ? fuzzySearchStrategy : literalSearchStrategy;
+  }
+};
\ No newline at end of file
diff --git a/src/Store.js b/src/Store.js
new file mode 100644
index 0000000..af4a060
--- /dev/null
+++ b/src/Store.js
@@ -0,0 +1,40 @@
+module.exports = function Store(_store){
+  var self = this;
+
+  var store = [];
+
+  if( isArray(_store) ){
+    addArray(_store);
+  }
+
+  function isObject(obj){ return !!obj && Object.prototype.toString.call(obj) == '[object Object]'; }
+  function isArray(obj){ return !!obj && Object.prototype.toString.call(obj) == '[object Array]'; }
+
+  function addObject(data){
+    store.push(data);
+    return data;
+  }
+
+  function addArray(data){
+    var added = [];
+    for (var i = 0; i < data.length; i++)
+      if( isObject(data[i]) )
+        added.push(addObject(data[i]));
+    return added;
+  }
+
+  self.clear = function(){
+    store.length = 0;
+    return store;
+  };
+
+  self.get = function(){
+    return store;
+  };
+
+  self.put = function(data){
+    if( isObject(data) ) return addObject(data);
+    if( isArray(data) ) return addArray(data);
+    return undefined;
+  };
+};
\ No newline at end of file
diff --git a/src/Templater.js b/src/Templater.js
new file mode 100644
index 0000000..c3a6580
--- /dev/null
+++ b/src/Templater.js
@@ -0,0 +1,15 @@
+module.exports = function Templater(){
+  var self = this;
+
+  var templatePattern = /\{(.*?)\}/g;
+
+  self.setTemplatePattern = function(newTemplatePattern){
+    templatePattern = newTemplatePattern;
+  };
+
+  self.render = function(t, data){
+    return t.replace(templatePattern, function(match, prop) {
+      return data[prop] || match;
+    });
+  };
+};
\ No newline at end of file
diff --git a/src/index.js b/src/index.js
new file mode 100644
index 0000000..881a944
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,113 @@
+;(function(window,document,undefined){
+  'use strict';
+  
+  var Searcher = require('./Searcher');
+  var Templater = require('./Templater');
+  var Store = require('./Store');
+  var JSONLoader = require('./JSONLoader');
+
+  var searcher = new Searcher();
+  var templater = new Templater();
+  var store = new Store();
+  var jsonLoader = new JSONLoader();
+
+
+  window.SimpleJekyllSearch = new SimpleJekyllSearch();
+  function SimpleJekyllSearch(){
+    var self = this;
+
+    var requiredOptions = [
+      'searchInput',
+      'resultsContainer',
+      'dataSource',
+    ];
+    var opt = {
+      searchInput: null,
+      resultsContainer: null,
+      dataSource: [],
+      searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
+      noResultsText: 'No results found',
+      limit: 10,
+      fuzzy: false,
+    };
+
+    function initWithJSON(json){
+      store.put(opt.dataSource);
+      registerInput();      
+    }
+
+    function initWithURL(url){
+      jsonLoader.load(url, function gotJSON(err,json){
+        if( !err ) {
+          store.put(json);
+          registerInput();
+        }else{
+          throwError('failed to get JSON (' + url + ')');
+        }
+      });
+    }
+
+    self.init = function(_opt){
+      validateOptions(_opt);
+      assignOptions(_opt);
+      if( isJSON(opt.dataSource) ){
+        initWithJSON(opt.dataSource);
+      }else{
+        initWithURL(opt.dataSource);
+      }
+    };
+
+
+    function throwError(message){ throw new Error('SimpleJekyllSearch --- '+ message); }
+
+    function validateOptions(_opt){
+      for(var i = 0; i < requiredOptions.length; i++){
+        var req = requiredOptions[i];
+        if( !_opt[req] )
+          throwError('You must specify a ' + req);
+      }
+    }
+
+    function assignOptions(_opt){
+      for(var option in opt)
+        opt[option] = _opt[option] || opt[option];
+    }
+
+    function isJSON(json){
+      try{
+        return json instanceof Object && JSON.parse(JSON.stringify(json));
+      }catch(e){
+        return false;
+      }
+    }
+
+    function emptyResultsContainer(){
+      opt.resultsContainer.innerHTML = '';    
+    }
+
+    function appendToResultsContainer(text){
+      opt.resultsContainer.innerHTML += text;
+    }
+
+    function registerInput(){
+      opt.searchInput.addEventListener('keyup', function(e){
+        if( e.target.value.length == 0 ){
+          emptyResultsContainer();
+          return;
+        }
+        render( searcher.search(store, e.target.value) );
+      });
+    }
+
+    function render(results){
+      emptyResultsContainer();
+      if( results.length == 0 ){
+        return appendToResultsContainer(opt.noResultsText);
+      }
+      for (var i = 0; i < results.length; i++) {
+        appendToResultsContainer( templater.render(opt.searchResultTemplate, results[i]) );
+      };
+    }
+
+  };
+})(window,document);
diff --git a/twrp_view_all_devices/index.html b/twrp_view_all_devices/index.html
new file mode 120000
index 0000000..246cf0e
--- /dev/null
+++ b/twrp_view_all_devices/index.html
@@ -0,0 +1 @@
+../Devices/index.html
\ No newline at end of file
diff --git a/twrpfaq/index.html b/twrpfaq/index.html
new file mode 120000
index 0000000..c448754
--- /dev/null
+++ b/twrpfaq/index.html
@@ -0,0 +1 @@
+../FAQ/index.html
\ No newline at end of file
diff --git a/whattobackup/index.html b/whattobackup/index.html
new file mode 120000
index 0000000..c7d170c
--- /dev/null
+++ b/whattobackup/index.html
@@ -0,0 +1 @@
+../faq/whattobackup.html
\ No newline at end of file
diff --git a/whattowipe/index.html b/whattowipe/index.html
new file mode 120000
index 0000000..1cdd96f
--- /dev/null
+++ b/whattowipe/index.html
@@ -0,0 +1 @@
+../faq/whattowipe.html
\ No newline at end of file
