diff --git a/_asus/asuszenfonemaxm2.markdown b/_asus/asuszenfonemaxm2.markdown
new file mode 100644
index 0000000..1cd90c6
--- /dev/null
+++ b/_asus/asuszenfonemaxm2.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title: "ASUS ZenFone Max M2"
+codename: X01AD
+oem: Asus
+downloadfolder: X01AD
+supportstatus: Current
+maintainer: rohanpls
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: https://github.com/rohanpls/twrp_asus_X01AD
+xdathread: "https://forum.xda-developers.com/max-m2/development/recovery-twrp-3-3-0-x-t3926913"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_asus/asuszenfonemaxprom2.markdown b/_asus/asuszenfonemaxprom2.markdown
new file mode 100644
index 0000000..12b8226
--- /dev/null
+++ b/_asus/asuszenfonemaxprom2.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title: "ASUS ZenFone Max Pro M2"
+codename: X01BD
+oem: Asus
+downloadfolder: X01BD
+supportstatus: Current
+maintainer: kubersharma001, bauuuuu
+ddof: "/dev/block/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_asus_X01BD
+xdathread: "https://forum.xda-developers.com/max-pro-m2/development/recovery-twrp-asus-zenfone-max-pro-m2-t3917145"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_config.yml b/_config.yml
index ac441e6..8882cda 100644
--- a/_config.yml
+++ b/_config.yml
@@ -104,7 +104,7 @@
   lg:
     output: true
 
-  LYF:
+  lyf:
     output: true
 
   marshall:
@@ -175,6 +175,9 @@
 
   twrp:
     output: true
+  
+  umidigi:
+    output: true
 
   unihertz:
     output: true
@@ -182,6 +185,9 @@
   vanzo:
     output: true
 
+  vestel:
+    output: true
+
   wileyfox:
     output: true
 
diff --git a/_google/androidonefifthgeneration.markdown b/_google/androidonefifthgeneration.markdown
new file mode 100644
index 0000000..9a1dec9
--- /dev/null
+++ b/_google/androidonefifthgeneration.markdown
@@ -0,0 +1,33 @@
+---
+layout: device
+title:  "Android One Fifth Generation"
+codename: gm9pro_sprout
+downloadfolder: gm9pro_sprout
+supportstatus: Current
+maintainer: oguzbakir
+oem: Google
+devicetree: https://github.com/TeamWin/android_device_google_gm9pro_sprout
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+
+<div class='page-heading'>Installation:</div>
+If you already have TWRP installed:
+Download the latest zip and install the zip using TWRP.
+
+If you do not already have TWRP installed:
+Download the img, move img to fastboot directory. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+
+fastboot boot path/to/twrp.img
+
+This will temporarily boot TWRP on your device. If you are using a lockscreen pin/pattern/password and do not get prompted to enter your passord, reboot to the bootloader and try again.
+
+If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
+
diff --git a/_google/androidonefifthgengm8.markdown b/_google/androidonefifthgengm8.markdown
new file mode 100644
index 0000000..e63a664
--- /dev/null
+++ b/_google/androidonefifthgengm8.markdown
@@ -0,0 +1,26 @@
+---
+layout: device
+title:  "Android One Fifth Generation (GM 8)"
+codename: gm8_sprout
+downloadfolder: gm8_sprout
+supportstatus: Current
+maintainer: Yigit Emre Yanik (yey59)
+oem: Google
+devicetree: https://github.com/TeamWin/android_device_google_gm8_sprout
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+
+<div class='page-heading'>Installation:</div>
+IMPORTANT : Only works with "9.0 April sec. patch!"
+
+Install on your active slot
+
+Sample : fastboot flash boot_(activeslot) twrp.img
diff --git a/_google/googlepixel3xl.markdown b/_google/googlepixel3xl.markdown
index ce5f34a..ae68eda 100644
--- a/_google/googlepixel3xl.markdown
+++ b/_google/googlepixel3xl.markdown
@@ -12,7 +12,7 @@
 {% include disclaimer.html %}
 
 {% include supportstatus.html %}
-MTP does not work at this time. ADB only works on the flashed version of TWRP. Unfortunately it does not work on the fastboot version of TWRP. You may need to use a USB-OTG cable and a USB thumb drive to transfer files. TWRP may take a little longer than usual to boot on this device.
+TWRP may take a little longer than usual to boot on this device.
 
 {% include download.html %}
 
diff --git a/_htc/htcdesire12+.markdown b/_htc/htcdesire12+.markdown
new file mode 100644
index 0000000..03579d1
--- /dev/null
+++ b/_htc/htcdesire12+.markdown
@@ -0,0 +1,33 @@
+---
+layout: device
+title:  "HTC Desire 12+"
+codename: brepdugl
+downloadfolder: brepdugl
+supportstatus: Current
+maintainer: sabpprook
+oem: HTC
+devicetree: "https://github.com/TeamWin/android_device_htc_brepdugl"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+NOTE:
+Updates may break decrypt in TWRP.
+Release 3.3.0-0 supports HTC's firmware 1.100.xxx.y with security patch state of 1st April 2019.
+
+{% include download.html %}
+
+<div class='page-heading'>Unlock Bootloader:</div>
+NOTE:
+This perform will erase all the data from your device, please do it after backup.
+
+Go into developer options and enable USB debugging and OEM unlock.
+
+<p class="code">adb reboot bootloader</p>
+
+<p class="code">fastboot flashing unlock</p>
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_htc/htconea9.markdown b/_htc/htconea9.markdown
index dc41359..f840be5 100644
--- a/_htc/htconea9.markdown
+++ b/_htc/htconea9.markdown
@@ -4,7 +4,7 @@
 codename: hiae
 downloadfolder: hiae
 supportstatus: Current
-maintainer: None
+maintainer: Captain_Throwback
 oem: HTC
 ddof: "/dev/block/bootdevice/by-name/recovery"
 devicetree: "https://github.com/teamwin/android_device_htc_hiae"
diff --git a/_htc/htcu12+.markdown b/_htc/htcu12+.markdown
index cab6ec8..5dbef93 100644
--- a/_htc/htcu12+.markdown
+++ b/_htc/htcu12+.markdown
@@ -18,6 +18,10 @@
 MTP is working starting with Release 3.2.3-1.
 Release 3.2.3-2 supports HTC´s firmware 1.30.xxx.y with security patch state of 1st September 2018.
 Release 3.2.3-3 supports HTC´s firmware 1.53.xxx.y with security patch state of 1st December 2018.
+Release 3.2.3-4 supports HTC´s firmware 1.53.xxx.y with security patch state of 1st December 2018. Starting with 3.2.3-4 booting TWRP won´t mount system RW, therefore no longer impacting OTA functionality by solely booting TWRP.
+Release 3.2.3-5 supports HTC´s firmware 1.57.xxx.y with security patch state of 1st January 2019.
+Release 3.3.0-0 supports HTC´s firmware 1.62.xxx.y with security patch state of 1st February 2019.
+Release 3.3.0-1 supports HTC´s firmware 1.68.xxx.y with security patch state of 1st April 2019.
 
 {% include download.html %}
 
@@ -27,7 +31,9 @@
 
 If you do not already have TWRP installed:
 Download both the img and the zip. Make sure you download the img, that matches your current firmware´s security patch date before booting it! As of HTC´s Software Update 1.30.xxx.y the security patch state changed to 1st September 2018.
-As of HTC´s Software Update 1.53.xxx.y the security patch state changed to 1st December 2018. To confirm which version to boot, take a look at the XDA thread! All the needed information is usually available there. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold power button until device vibrates, when vibration kicks in let go of the power button and hit immediately volume down button. Your device should now be in the bootloader. Boot now to download mode. Connect the device to your PC. Open a command window and run the following command from the proper location:
+As of HTC´s Software Update 1.53.xxx.y the security patch state changed to 1st December 2018. As of HTC´s Software Update 1.57.xxx.y the security patch state changed to 1st January 2019.
+As of HTC´s Software Update 1.62.xxx.y the security patch state changed to 1st February 2019. As of HTC´s Software Update 1.68.xxx.y the security patch state changed to 1st April 2019.
+To confirm which version to boot, take a look at the XDA thread! All the needed information is usually available there. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold power button until device vibrates, when vibration kicks in let go of the power button and hit immediately volume down button. Your device should now be in the bootloader. Boot now to download mode. Connect the device to your PC. Open a command window and run the following command from the proper location:
 
 fastboot boot path/to/twrp.img
 
@@ -35,4 +41,7 @@
 
 adb push path/to/twrp.zip /
 
-Go to install and browse to the zip and install the zip. The zip will install TWRP to both boot slots. Please note: If you were previously rooted and want to keep your device rooted or want to root, you now have to flash the root.zip.
+Go to install, browse to the zip and install the zip. The zip will install TWRP to both boot slots. Please note: If you were previously rooted and want to keep your device rooted or want to root, you now have to flash the root.zip.
+
+As of TWRP 3.3.0-0 TWRP can also be flashed permanently via the "Install Recovery Ramdisk" option inside a temporarily booted TWRP, which can be choosen when selecting an .img file!
+Please note: If you were previously rooted and want to keep your device rooted or want to root, you now have to flash the root.zip.
diff --git a/_htc/htcuultra.markdown b/_htc/htcuultra.markdown
index 19adf08..ac6daa9 100644
--- a/_htc/htcuultra.markdown
+++ b/_htc/htcuultra.markdown
@@ -4,7 +4,7 @@
 codename: oce
 downloadfolder: oce
 supportstatus: Current
-maintainer: None
+maintainer: TARKZiM
 oem: HTC
 ddof: "/dev/block/bootdevice/by-name/recovery"
 devicetree: "https://github.com/TeamWin/android_device_htc_oce"
diff --git a/_huawei/huaweiascendy550.markdown b/_huawei/huaweiascendy550.markdown
index 5d2ab40..8064467 100644
--- a/_huawei/huaweiascendy550.markdown
+++ b/_huawei/huaweiascendy550.markdown
@@ -3,7 +3,7 @@
 title:  "Huawei Ascend Y550"
 codename: y550
 downloadfolder: y550
-supportstatus: Current
+supportstatus: Not Supported
 maintainer: Hacker432
 oem: Huawei
 devicetree: https://github.com/TeamWin/android_device_huawei_y550
diff --git a/_includes/fastbootabinstall.html b/_includes/fastbootabinstall.html
new file mode 100644
index 0000000..b4988fd
--- /dev/null
+++ b/_includes/fastbootabinstall.html
@@ -0,0 +1,20 @@
+<html>
+<div class='page-heading'>Installation:</div>
+If you already have TWRP installed:
+Download the latest zip and install the zip using TWRP.
+
+If you do not already have TWRP installed:
+Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+
+fastboot boot path/to/twrp.img
+
+This will temporarily boot TWRP on your device. Use adb to push the zip onto your device:
+
+<pre>
+adb push path/to/twrp.zip /
+</pre>
+
+Go to install and browse to the zip and install the zip. The zip will install TWRP to both boot slots. Installing TWRP at this time will remove root if you are currently rooted.
+
+If you accidently flash TWRP to your device using fastboot instead of temporarily booting the image, you will need to download the latest factory image for your device and reflash the boot image.
+</html>
diff --git a/_includes/footer.html b/_includes/footer.html
index b1497b0..b851909 100644
--- a/_includes/footer.html
+++ b/_includes/footer.html
@@ -1,7 +1,7 @@
 <footer class="site-footer">
 
   <div class="wrapper">
-    <p class="text">&copy; 2014 to 2018 Team Win LLC.<br>Use of this site constitutes agreement to our <a href="https://twrp.me/terms/termsofservice.html">Terms of Service</a> and our <a href="https://twrp.me/terms/cookiepolicy.html">use of cookies</a></p>
+    <p class="text">&copy; 2014 to 2019 Team Win LLC.<br>Use of this site constitutes agreement to our <a href="https://twrp.me/terms/termsofservice.html">Terms of Service</a> and our <a href="https://twrp.me/terms/cookiepolicy.html">use of cookies</a></p>
     <div class="footer-col-wrapper">
 
       <div class="footer-col  footer-col-2">
@@ -20,12 +20,6 @@
           </li>
           {% endif %}
 
-          <li>
-            <a href="https://plus.google.com/communities/106804207647688456928">
-
-              <span class="username">TWRP on G+</span>
-            </a>
-          </li>
         </ul>
       </div>
 
diff --git a/_includes/footer404.html b/_includes/footer404.html
index d8df263..002d977 100644
--- a/_includes/footer404.html
+++ b/_includes/footer404.html
@@ -1,7 +1,7 @@
 <footer class="site-footer">
 
   <div class="wrapper">
-    <p class="text">&copy; 2014 to 2018 Team Win LLC.<br>Use of this site constitutes agreement to our <a href="https://twrp.me/terms/termsofservice.html">Terms of Service</a> and our <a href="https://twrp.me/terms/cookiepolicy.html">use of cookies</a></p>
+    <p class="text">&copy; 2014 to 2019 Team Win LLC.<br>Use of this site constitutes agreement to our <a href="https://twrp.me/terms/termsofservice.html">Terms of Service</a> and our <a href="https://twrp.me/terms/cookiepolicy.html">use of cookies</a></p>
     <div class="footer-col-wrapper">
 
       <div class="footer-col  footer-col-2">
@@ -20,12 +20,6 @@
           </li>
           {% endif %}
 
-          <li>
-            <a href="https://plus.google.com/communities/106804207647688456928">
-
-              <span class="username">TWRP on G+</span>
-            </a>
-          </li>
         </ul>
       </div>
 
diff --git a/_includes/samsungsystemasroot.html b/_includes/samsungsystemasroot.html
new file mode 100644
index 0000000..cb93190
--- /dev/null
+++ b/_includes/samsungsystemasroot.html
@@ -0,0 +1,10 @@
+<div class='page-heading'>This device uses system-as-root in an A-only partition configuration.</div>
+<hr />
+
+<p class="text">If you intend to root your ({{ page.codename }}) device, be advised that Magisk will be installed to the <tt>recovery</tt> partition, not the usual <tt>boot</tt> partition. Both TWRP and Magisk-rooted Android boot using the recovery kernel, with the device's hardware keys used to choose between TWRP and Android at boot time.</p>
+
+<p class"text">You are therefore strongly advised to first <a href="https://topjohnwu.github.io/Magisk/samsung">root your device with Magisk</a> and then pre-root a TWRP image before flashing it to recovery. The usual path of installing TWRP prior to rooting is problematic on this device, because the Magisk installer does not support installation to recovery from TWRP. Furthermore, prior rooting of the device with Magisk carries the significant advantage of disabling various device protection mechanisms that you will otherwise need to take care of manually.</p>
+
+<p class="text">If you wish to install TWRP without rooting, there are numerous pitfalls to consider. For example, a stock device is protected by Android Verified Boot. This is implemented as a <tt>vbmeta</tt> partition that contains cryptographic digests for verifying the integrity of <tt>boot.img</tt>, <tt>recovery.img</tt> and other partitions/images. Flashing TWRP without first flashing a <tt>vbmeta</tt> image with verity disabled will render your device unable to boot.</p>
+
+<p class="text">Please bear all of the above in mind when considering the installation methods listed below, and refer to the device's TWRP support thread on XDA for detailed information about installation and the associated hazards. Details of the firmware version(s) with which the current TWRP image's kernel is compatible can be found in the TWRP changelog for this device.</p>
diff --git a/_lenovo/lenovo_X704F.markdown b/_lenovo/lenovo_X704F.markdown
new file mode 100644
index 0000000..460cc47
--- /dev/null
+++ b/_lenovo/lenovo_X704F.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Lenovo Tab4 10 Plus"
+codename: X704F
+downloadfolder: X704F
+supportstatus: Current
+maintainer: codeworkx, yener90
+oem: Lenovo
+devicetree: https://github.com/teamwin/android_device_lenovo_X704F
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_lenovo/lenovok5fpr.markdown b/_lenovo/lenovok5fpr.markdown
new file mode 100644
index 0000000..70847f3
--- /dev/null
+++ b/_lenovo/lenovok5fpr.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "Lenovo K4 Note"
+codename: k5fpr
+downloadfolder: k5fpr
+supportstatus: Current
+maintainer: Mohan Cm(mohancm)
+oem: Lenovo
+devicetree: "https://github.com/TeamWin/android_device_lenovo_k5fpr"
+xdathread: "https://forum.xda-developers.com/k4-note/development/recovery-twrp-3-0-2-0-touch-recovery-t3530374"
+---
+
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
\ No newline at end of file
diff --git a/_lenovo/lenovomanning.markdown b/_lenovo/lenovomanning.markdown
new file mode 100644
index 0000000..78861a5
--- /dev/null
+++ b/_lenovo/lenovomanning.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Lenovo K8 Note"
+codename: manning
+downloadfolder: manning
+supportstatus: Current
+maintainer: Maanush2004
+oem: Lenovo
+devicetree: https://github.com/TeamWin/android_device_lenovo_manning
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_lenovo/lenovop2a42.markdown b/_lenovo/lenovop2a42.markdown
index 7b83614..3eabe0c 100644
--- a/_lenovo/lenovop2a42.markdown
+++ b/_lenovo/lenovop2a42.markdown
@@ -1,14 +1,14 @@
 ---
 layout: device
 title: "Lenovo P2a42"
-codename: kuntao_row
+codename: kuntao
 oem: Lenovo
-downloadfolder: kuntao_row
+downloadfolder: kuntao
 supportstatus: Current
-maintainer: Celoxocis
+maintainer: Darshan M. (darshan1205)
 ddof: "/dev/block/bootdevice/by-name/recovery"
-devicetree: https://github.com/TeamWin/android_device_lenovo_p2a42
-xdathread: "https://forum.xda-developers.com/android/development/recovery-unofficial-twrp-lenovo-p2-3-0-t3533659"
+devicetree: https://github.com/TeamWin/android_device_lenovo_kuntao
+xdathread: "https://forum.xda-developers.com/lenovo-p2/development/recovery-twrp-3-3-1-0-lenovo-p2-t3932598"
 fastbootunlock: true
 ---
 
diff --git a/_LYF/LYFmobee01a.markdown b/_lyf/lyfmobee01a.markdown
similarity index 97%
rename from _LYF/LYFmobee01a.markdown
rename to _lyf/lyfmobee01a.markdown
index 844a7a5..33ade45 100644
--- a/_LYF/LYFmobee01a.markdown
+++ b/_lyf/lyfmobee01a.markdown
@@ -6,7 +6,7 @@
 supportstatus: Current
 maintainer: Mohd Faraz
 devicetree: https://github.com/TeamWin/android_device_LYF_mobee01a
-oem: LYF
+oem: Lyf
 ---
 
 {% include disclaimer.html %}
diff --git a/_mobvoi/mobvoiticwatchc2.markdown b/_mobvoi/mobvoiticwatchc2.markdown
new file mode 100644
index 0000000..60db136
--- /dev/null
+++ b/_mobvoi/mobvoiticwatchc2.markdown
@@ -0,0 +1,25 @@
+---
+layout: device
+title:  "Mobvoi TicWatch C2"
+codename: skipjack
+downloadfolder: skipjack
+supportstatus: Current
+maintainer: simonsmh
+devicetree: https://github.com/TeamWin/android_device_mobvoi_skipjack
+oem: Mobvoi
+ddof: "/dev/block/platform/soc/7824900.sdhci/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_motorola/motorolamotoe5.markdown b/_motorola/motorolamotoe5.markdown
new file mode 100644
index 0000000..ea168b3
--- /dev/null
+++ b/_motorola/motorolamotoe5.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Moto E5"
+codename: nora
+downloadfolder: nora
+supportstatus: Current
+maintainer: SamarV-121
+oem: Motorola
+devicetree: https://github.com/TeamWin/android_device_moto_nora
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_motorola/motorolamotoe5play.markdown b/_motorola/motorolamotoe5play.markdown
new file mode 100644
index 0000000..46002cb
--- /dev/null
+++ b/_motorola/motorolamotoe5play.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Moto E5 Play"
+codename: james
+downloadfolder: james
+devicetree: https://github.com/TeamWin/android_device_motorola_james
+supportstatus: Current
+maintainer: deadman96385
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
\ No newline at end of file
diff --git a/_motorola/motorolamotoe5plus.markdown b/_motorola/motorolamotoe5plus.markdown
new file mode 100644
index 0000000..8362a33
--- /dev/null
+++ b/_motorola/motorolamotoe5plus.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Motorola Moto E5 Plus"
+codename: hannah
+downloadfolder: hannah
+devicetree: https://github.com/TeamWin/android_device_motorola_hannah
+supportstatus: Current
+maintainer: Karthick111
+oem: Motorola
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_nokia/nokia61plus.markdown b/_nokia/nokia61plus.markdown
new file mode 100644
index 0000000..90eb73a
--- /dev/null
+++ b/_nokia/nokia61plus.markdown
@@ -0,0 +1,23 @@
+---
+layout: device
+title:  "Nokia 6.1 Plus"
+codename: DRG
+downloadfolder: DRG
+supportstatus: Current
+maintainer: Raghu Varma
+devicetree: https://github.com/TeamWin/android_device_nokia_DRG
+oem: Nokia
+xdathread: https://forum.xda-developers.com/nokia-6-1-plus/development/recovery-twrp-3-2-3-0-team-win-recovery-t3893909
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_oem/LYF.markdown b/_oem/lyf.markdown
similarity index 72%
rename from _oem/LYF.markdown
rename to _oem/lyf.markdown
index d02505b..254ae3f 100644
--- a/_oem/LYF.markdown
+++ b/_oem/lyf.markdown
@@ -1,4 +1,4 @@
 ---
 layout: device
-oem: LYF
+oem: Lyf
 ---
diff --git a/_oem/LYF.markdown b/_oem/umidigi.markdown
similarity index 63%
copy from _oem/LYF.markdown
copy to _oem/umidigi.markdown
index d02505b..735bac0 100644
--- a/_oem/LYF.markdown
+++ b/_oem/umidigi.markdown
@@ -1,4 +1,4 @@
 ---
 layout: device
-oem: LYF
----
+oem: Umidigi
+---
\ No newline at end of file
diff --git a/_oem/LYF.markdown b/_oem/vestel.markdown
similarity index 65%
copy from _oem/LYF.markdown
copy to _oem/vestel.markdown
index d02505b..32dc7c4 100644
--- a/_oem/LYF.markdown
+++ b/_oem/vestel.markdown
@@ -1,4 +1,4 @@
 ---
 layout: device
-oem: LYF
+oem: Vestel
 ---
diff --git a/_oneplus/oneplus6.markdown b/_oneplus/oneplus6.markdown
index 9298bc6..190784d 100644
--- a/_oneplus/oneplus6.markdown
+++ b/_oneplus/oneplus6.markdown
@@ -7,6 +7,7 @@
 maintainer: Dees_Troy, Mauronofrio
 oem: OnePlus
 devicetree: https://github.com/TeamWin/android_device_oneplus_enchilada
+xdathread: "https://forum.xda-developers.com/oneplus-6/development/recovery-unofficial-twrp-touch-recovery-t3860815"
 ---
 
 {% include disclaimer.html %}
diff --git a/_oneplus/oneplus6t.markdown b/_oneplus/oneplus6t.markdown
index 84d9d18..0258edf 100644
--- a/_oneplus/oneplus6t.markdown
+++ b/_oneplus/oneplus6t.markdown
@@ -7,6 +7,7 @@
 maintainer: Mauronofrio
 oem: OnePlus
 devicetree: https://github.com/TeamWin/android_device_oneplus_fajita
+xdathread: "https://forum.xda-developers.com/oneplus-6t/development/recovery-unofficial-twrp-touch-recovery-t3861482"
 ---
 
 {% include disclaimer.html %}
diff --git a/_oneplus/oneplus7.markdown b/_oneplus/oneplus7.markdown
new file mode 100644
index 0000000..08c7320
--- /dev/null
+++ b/_oneplus/oneplus7.markdown
@@ -0,0 +1,31 @@
+---
+layout: device
+title:  "OnePlus 7 (guacamoleb)"
+codename: guacamoleb
+downloadfolder: guacamoleb
+supportstatus: Current
+maintainer: Mauronofrio
+oem: OnePlus
+devicetree: https://github.com/TeamWin/android_device_oneplus_guacamoleb
+xdathread: "https://forum.xda-developers.com/showthread.php?t=3932943"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+OnePlus 7 Install Instructions
+
+Read these instructions and follow them carefully.
+The OnePlus 7 uses the newer AB partition scheme first introduced on the Pixel 1. As such there is no recovery partition. Instead, the recovery is part of the boot image. You will temporarily boot TWRP to perform and later perform a more permanent TWRP installation. First download the TWRP zip file directly on your device. If you don't download the zip file to your device first for any reason, you will need to adb push the zip to the device because MTP is not currently working on the OnePlus 7 in TWRP. If you are unable to use adb, you can also use a USB stick with an OTG cable, if you have those handy.
+Power off the device. Hold volume up to get into fastboot mode. Run this command on your computer:
+`fastboot boot twrp-3.3.1-0-guacamoleb.img`
+
+In TWRP, tap on Install and browse to the zip and install it (the zip will probably be in /sdcard/Downloads). TWRP will now be installed to both slots. TWRP is now installed and you can reboot and use your device as normal.
+
+If `fastboot boot` command doesn't work you need to root your device and flash the TWRP installer (remember that flashing the TWRP installer you will lose the root).
+
+If you already have a TWRP installed and you want to update your actual TWRP follow this instructions:
+In TWRP, tap on Install and browse to the zip and install it (the zip will probably be in /sdcard/Downloads). TWRP will now be installed to both slots. TWRP is now installed and you can reboot and use your device as normal.
diff --git a/_oneplus/oneplus7pro.markdown b/_oneplus/oneplus7pro.markdown
new file mode 100644
index 0000000..d73a256
--- /dev/null
+++ b/_oneplus/oneplus7pro.markdown
@@ -0,0 +1,31 @@
+---
+layout: device
+title:  "OnePlus 7 Pro (guacamole)"
+codename: guacamole
+downloadfolder: guacamole
+supportstatus: Current
+maintainer: Mauronofrio
+oem: OnePlus
+devicetree: https://github.com/TeamWin/android_device_oneplus_guacamole
+xdathread: "https://forum.xda-developers.com/showthread.php?t=3931322"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include download.html %}
+
+OnePlus 7 Pro Install Instructions
+
+Read these instructions and follow them carefully.
+The OnePlus 7 Pro uses the newer AB partition scheme first introduced on the Pixel 1. As such there is no recovery partition. Instead, the recovery is part of the boot image. You will temporarily boot TWRP to perform and later perform a more permanent TWRP installation. First download the TWRP zip file directly on your device. If you don't download the zip file to your device first for any reason, you will need to adb push the zip to the device because MTP is not currently working on the OnePlus 7 Pro in TWRP. If you are unable to use adb, you can also use a USB stick with an OTG cable, if you have those handy.
+Power off the device. Hold volume up to get into fastboot mode. Run this command on your computer:
+`fastboot boot twrp-3.3.1-0-guacamole.img`
+
+In TWRP, tap on Install and browse to the zip and install it (the zip will probably be in /sdcard/Downloads). TWRP will now be installed to both slots. TWRP is now installed and you can reboot and use your device as normal.
+
+If `fastboot boot` command doesn't work you need to root your device and flash the TWRP installer (remember that flashing the TWRP installer you will lose the root).
+
+If you already have a TWRP installed and you want to update your actual TWRP follow this instructions:
+In TWRP, tap on Install and browse to the zip and install it (the zip will probably be in /sdcard/Downloads). TWRP will now be installed to both slots. TWRP is now installed and you can reboot and use your device as normal.
diff --git a/_oppo/realme3pro.markdown b/_oppo/realme3pro.markdown
new file mode 100644
index 0000000..67d6cec
--- /dev/null
+++ b/_oppo/realme3pro.markdown
@@ -0,0 +1,22 @@
+---
+layout: device
+title:  "Realme 3 Pro"
+codename: RMX1851
+downloadfolder: RMX1851
+supportstatus: Current
+maintainer: SamarV-121
+oem: Oppo
+devicetree: https://github.com/TeamWin/android_device_oppo_RMX1851
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include mtkinstall.html %}
diff --git a/_oukitel/oukitelk10.markdown b/_oukitel/oukitelk10.markdown
new file mode 100644
index 0000000..c338467
--- /dev/null
+++ b/_oukitel/oukitelk10.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title: "OUKITEL K10"
+codename: k10
+oem: Oukitel
+downloadfolder: k10
+supportstatus: Current
+maintainer: chankruze
+ddof: "/dev/block/platform/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_oukitel_k10
+xdathread: "https://forum.xda-developers.com/android/development/recovery-twrp-3-3-0-0-oukitel-k10-t3925703"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_oukitel/oukitelwp1.markdown b/_oukitel/oukitelwp1.markdown
new file mode 100644
index 0000000..ea84114
--- /dev/null
+++ b/_oukitel/oukitelwp1.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title: "OUKITEL WP1"
+codename: wp1
+oem: Oukitel
+downloadfolder: wp1
+supportstatus: Current
+maintainer: chankruze
+ddof: "/dev/block/platform/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_oukitel_wp1
+xdathread: "https://forum.xda-developers.com/android/development/twrp-twrp-3-3-0-0-oukitel-wp1-t3933827"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_posts/2019-04-15-twrp-3.3.0-0-released.markdown b/_posts/2019-04-15-twrp-3.3.0-0-released.markdown
new file mode 100644
index 0000000..72202ed
--- /dev/null
+++ b/_posts/2019-04-15-twrp-3.3.0-0-released.markdown
@@ -0,0 +1,33 @@
+---
+layout: post
+title:  "TWRP 3.3.0-0 Released"
+date:   2019-04-15 09:39:42
+categories: site update
+version: 3.3.0-0
+---
+
+TWRP {{ page.version }} is out now for most currently supported devices.
+
+What's new in {{ page.version }}:
+
+	* Merge AOSP 9.0 r3 (Dees_Troy)
+	* Use ANDROID_ROOT variable instead of hard coding to /system (CaptainThrowback)
+	* Decrypt FBE on 9.0 and metadata decrypt (Dees_Troy)
+	* vold decrypt updates (CaptainThrowback and nijel8)
+	* Support vibration on LED class devices (notsyncing)
+	* Metadata decrypt support for Pixel 3 (Dees_Troy)
+	* Support rotating the display via build flag (vladimiroltean)
+	* Reboot to EDL mode button (mauronofrio)
+	* Support MTP on FFS devices (bigbiff)
+	* Update FDE decrypt to support keymaster 3 and 4 (Dees_Troy)
+	* Detect mkfs.f2fs version to properly format on f2fs partitions (Dees_Troy)
+	* Allow TWRP to use md5 and sha256 checksums for zip installs (bigbiff)
+	* TWRP can use /data/cache/recovery and /persist/cache/recovery on AB devices with no cache partition (bigbiff)
+	* Switch part of advanced menus in TWRP to use a listbox of options (Dees_Troy)
+	* Use magiskboot to allow repacking boot images for installing TWRP (Dees_Troy with thanks to topjohnwu of course)
+
+Want to get notifications when we release new versions of TWRP? [Install the TWRP app and select your device!](https://twrp.me/app)
+
+We need your help! The bulk of TWRP work is done by a handful of people on a volunteer basis. We have pushed most of our device files to [our github](http://github.com/TeamWin/) and we have [a gerrit instance](http://gerrit.twrp.me). If you have the ability, please help us maintain our official devices and/or add your device to our official device list. Thanks in advance!
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_posts/2019-05-22-twrp-3.3.1-0-released.markdown b/_posts/2019-05-22-twrp-3.3.1-0-released.markdown
new file mode 100644
index 0000000..0bd54c4
--- /dev/null
+++ b/_posts/2019-05-22-twrp-3.3.1-0-released.markdown
@@ -0,0 +1,23 @@
+---
+layout: post
+title:  "TWRP 3.3.1-0 Released"
+date:   2019-05-22 09:39:42
+categories: site update
+version: 3.3.1-0
+---
+
+TWRP {{ page.version }} is out now for most currently supported devices.
+
+What's new in {{ page.version }}:
+
+	* Fix selinux issues during formatting - dianlujitao
+	* Various fixes for toybox and toolbox builds - CaptainThrowback and bigbiff
+	* Flash both A and B partitions when installing a recovery ramdisk - Dees_Troy
+	* Add option to uninstall TWRP app from /system - Dees_Troy
+	* Create digest for subpartitions - bigbiff
+
+Want to get notifications when we release new versions of TWRP? [Install the TWRP app and select your device!](https://twrp.me/app)
+
+We need your help! The bulk of TWRP work is done by a handful of people on a volunteer basis. We have pushed most of our device files to [our github](http://github.com/TeamWin/) and we have [a gerrit instance](http://gerrit.twrp.me). If you have the ability, please help us maintain our official devices and/or add your device to our official device list. Thanks in advance!
+
+Head over to the [devices page](http://twrp.me/Devices) to find install instructions and download links.
diff --git a/_samsung/samsunggalaxynote4qualcomm.markdown b/_samsung/samsunggalaxynote4qualcomm.markdown
index 37c4cf5..3c03dda 100644
--- a/_samsung/samsunggalaxynote4qualcomm.markdown
+++ b/_samsung/samsunggalaxynote4qualcomm.markdown
@@ -8,7 +8,7 @@
 oem: Samsung
 ddof: "/dev/block/platform/msm_sdcc.1/by-name/recovery"
 devicetree: "https://github.com/TeamWin/android_device_samsung_trlte"
-xdathread: "http://forum.xda-developers.com/note-4/orig-development/tool-utility-twrp-2-8-1-x-teamwin-t2956011"
+xdathread: "https://forum.xda-developers.com/note-4/snapdragon-dev/recovery-twrp-3-3-1-0-t3933427"
 ---
 
 {% include disclaimer.html %}
diff --git a/_samsung/samsunggalaxys10.markdown b/_samsung/samsunggalaxys10.markdown
new file mode 100644
index 0000000..134b147
--- /dev/null
+++ b/_samsung/samsunggalaxys10.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title: "Samsung Galaxy S10 (Exynos)"
+codename: beyond1lte
+downloadfolder: beyond1lte
+supportstatus: Current
+maintainer: ianmacd (credit to geiti94 for the initial unofficial release)
+devicetree: "https://github.com/TeamWin/android_device_samsung_beyond1lte"
+xdathread: "https://forum.xda-developers.com/s10-plus/development/recovery-twrp-3-3-0-galaxy-s10-exynos-t3924856"
+oem: Samsung
+ddof: "/dev/block/platform/13d60000.ufs/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include samsungsystemasroot.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_samsung/samsunggalaxys10e.markdown b/_samsung/samsunggalaxys10e.markdown
new file mode 100644
index 0000000..f96b391
--- /dev/null
+++ b/_samsung/samsunggalaxys10e.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title: "Samsung Galaxy S10e (Exynos)"
+codename: beyond0lte
+downloadfolder: beyond0lte
+supportstatus: Current
+maintainer: ianmacd (credit to geiti94 for the initial unofficial release)
+devicetree: "https://github.com/TeamWin/android_device_samsung_beyond0lte"
+xdathread: "https://forum.xda-developers.com/s10-plus/development/recovery-twrp-3-3-0-galaxy-s10-exynos-t3924856"
+oem: Samsung
+ddof: "/dev/block/platform/13d60000.ufs/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include samsungsystemasroot.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_samsung/samsunggalaxys10plus.markdown b/_samsung/samsunggalaxys10plus.markdown
new file mode 100644
index 0000000..d6d01a9
--- /dev/null
+++ b/_samsung/samsunggalaxys10plus.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title: "Samsung Galaxy S10+ (Exynos)"
+codename: beyond2lte
+downloadfolder: beyond2lte
+supportstatus: Current
+maintainer: ianmacd (credit to geiti94 for the initial unofficial release)
+devicetree: "https://github.com/TeamWin/android_device_samsung_beyond2lte"
+xdathread: "https://forum.xda-developers.com/s10-plus/development/recovery-twrp-3-3-0-galaxy-s10-exynos-t3924856"
+oem: Samsung
+ddof: "/dev/block/platform/13d60000.ufs/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include samsungsystemasroot.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_samsung/samsunggalaxys7.markdown b/_samsung/samsunggalaxys7.markdown
index 7993af6..8e0226e 100644
--- a/_samsung/samsunggalaxys7.markdown
+++ b/_samsung/samsunggalaxys7.markdown
@@ -4,7 +4,7 @@
 codename: herolte
 downloadfolder: "International &amp; Canada (SM-G930F, SM-G930FD, SM-G930X, SM-G930W8)|herolte|Korea (SM-G930K, SM-G930L, SM-G930S)|heroltekor"
 supportstatus: Current
-maintainer: jcadduono
+maintainer: ivanmeler
 devicetree: "https://github.com/TeamWin/android_device_samsung_herolte"
 xdathread: "http://forum.xda-developers.com/galaxy-s7/development/recovery-official-twrp-herolte-t3333770"
 oem: Samsung
diff --git a/_samsung/samsunggalaxys7edge.markdown b/_samsung/samsunggalaxys7edge.markdown
index 215b236..3a2bdcc 100644
--- a/_samsung/samsunggalaxys7edge.markdown
+++ b/_samsung/samsunggalaxys7edge.markdown
@@ -4,7 +4,7 @@
 codename: hero2lte
 downloadfolder: "International &amp; Canada (SM-G935F, SM-G935FD, SM-G935X, SM-G935W8)|hero2lte|Korea (SM-G935K, SM-G935L, SM-G935S)|hero2ltekor"
 supportstatus: Current
-maintainer: jcadduono
+maintainer: ivanmeler
 devicetree: "https://github.com/TeamWin/android_device_samsung_hero2lte"
 xdathread: "http://forum.xda-developers.com/s7-edge/development/recovery-official-twrp-hero2lte-3-0-0-0-t3334084"
 oem: Samsung
diff --git a/_samsung/samsunggalaxys9plusqcom.markdown b/_samsung/samsunggalaxys9plusqcom.markdown
new file mode 100644
index 0000000..2d24a78
--- /dev/null
+++ b/_samsung/samsunggalaxys9plusqcom.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title: "Samsung Galaxy S9+ (Snapdragon)"
+codename: star2qltechn
+downloadfolder: star2qltechn
+supportstatus: Current
+maintainer: klabit87
+devicetree: "https://github.com/TeamWin/android_device_samsung_star2qltechn"
+oem: Samsung
+ddof: "/dev/block/platform/soc/1d84000.ufshc/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_samsung/samsunggalaxys9qcom.markdown b/_samsung/samsunggalaxys9qcom.markdown
new file mode 100644
index 0000000..f267892
--- /dev/null
+++ b/_samsung/samsunggalaxys9qcom.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title: "Samsung Galaxy S9 (Snapdragon)"
+codename: starqltechn
+downloadfolder: starqltechn
+supportstatus: Current
+maintainer: klabit87
+devicetree: "https://github.com/TeamWin/android_device_samsung_starqltechn"
+oem: Samsung
+ddof: "/dev/block/platform/soc/1d84000.ufshc/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_samsung/samsunggalaxytabs4qcom.markdown b/_samsung/samsunggalaxytabs4qcom.markdown
new file mode 100644
index 0000000..b917d9f
--- /dev/null
+++ b/_samsung/samsunggalaxytabs4qcom.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title: "Samsung Galaxy Tab S4"
+codename: gts4lwifi
+downloadfolder: gts4lwifi
+supportstatus: Current
+maintainer: mentalmuso
+devicetree: "https://github.com/TeamWin/android_device_samsung_gts4lwifi"
+oem: Samsung
+ddof: "/dev/block/platform/soc/1da4000.ufshc/by-name/recovery"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include odininstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_sony/sonyxperiaxa2.markdown b/_sony/sonyxperiaxa2.markdown
index 8089245..3e04ca8 100644
--- a/_sony/sonyxperiaxa2.markdown
+++ b/_sony/sonyxperiaxa2.markdown
@@ -21,7 +21,7 @@
 Download the latest zip and install the zip using TWRP.
 
 If you do not already have TWRP installed:
-Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume up and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
 
 fastboot boot path/to/twrp.img
 
diff --git a/_sony/sonyxperiaxa2plus.markdown b/_sony/sonyxperiaxa2plus.markdown
index 271329b..ef2f14f 100644
--- a/_sony/sonyxperiaxa2plus.markdown
+++ b/_sony/sonyxperiaxa2plus.markdown
@@ -21,7 +21,7 @@
 Download the latest zip and install the zip using TWRP.
 
 If you do not already have TWRP installed:
-Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume up and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
 
 fastboot boot path/to/twrp.img
 
diff --git a/_sony/sonyxperiaxa2ultra.markdown b/_sony/sonyxperiaxa2ultra.markdown
index 019436a..31506c4 100644
--- a/_sony/sonyxperiaxa2ultra.markdown
+++ b/_sony/sonyxperiaxa2ultra.markdown
@@ -21,7 +21,7 @@
 Download the latest zip and install the zip using TWRP.
 
 If you do not already have TWRP installed:
-Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume down and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
+Download both the img and the zip. You will need to have fastboot binaries and the correct drivers installed. Power off your device completely. Hold volume up and turn on the device. Your device should now be in the bootloader. Connect the device to your PC. Open a command window and run the following command from the proper location:
 
 fastboot boot path/to/twrp.img
 
diff --git a/_umidigi/f1play.markdown b/_umidigi/f1play.markdown
new file mode 100644
index 0000000..90bab57
--- /dev/null
+++ b/_umidigi/f1play.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title: "UMIDIGI F1 Play"
+codename: f1_play
+oem: Umidigi
+downloadfolder: f1_play
+supportstatus: Current
+maintainer: chankruze
+ddof: "/dev/block/platform/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_umidigi_f1_play
+xdathread: "https://forum.xda-developers.com/android/development/twrp-twrp-3-3-0-0-umidigi-f1-play-t3933829"
+---
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_umidigi/onemax.markdown b/_umidigi/onemax.markdown
new file mode 100644
index 0000000..0e05f10
--- /dev/null
+++ b/_umidigi/onemax.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title: "UMIDIGI One Max"
+codename: One_Max
+oem: Umidigi
+downloadfolder: one_max
+supportstatus: Current
+maintainer: chankruze
+ddof: "/dev/block/platform/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_umidigi_one_max
+xdathread: "https://forum.xda-developers.com/android/development/twrp-twrp-3-3-0-0-umidigi-one-max-t3926615"
+---
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_umidigi/s3pro.markdown b/_umidigi/s3pro.markdown
new file mode 100644
index 0000000..f00a0f2
--- /dev/null
+++ b/_umidigi/s3pro.markdown
@@ -0,0 +1,25 @@
+---
+layout: device
+title: "UMIDIGI S3 Pro"
+codename: aubrey
+oem: Umidigi
+downloadfolder: aubrey
+supportstatus: Current
+maintainer: chankruze
+ddof: "/dev/block/platform/bootdevice/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_umidigi_aubrey
+xdathread: "https://forum.xda-developers.com/android/development/twrp-twrp-3-3-x-umidigi-s3-pro-t3936550"
+---
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_vestel/vestelvenusv4.markdown b/_vestel/vestelvenusv4.markdown
new file mode 100644
index 0000000..2b53a70
--- /dev/null
+++ b/_vestel/vestelvenusv4.markdown
@@ -0,0 +1,27 @@
+---
+layout: device
+title: "Vestel Venus V4"
+codename: orka
+oem: Vestel
+downloadfolder: orka
+supportstatus: Current
+maintainer: barishirece
+ddof: "/dev/block/platform/mtk-msdc.0/11230000.msdc0/by-name/recovery"
+devicetree: https://github.com/TeamWin/android_device_vestel_orka
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include dmverity.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_xiaomi/xiaomimia2.markdown b/_xiaomi/xiaomimia2.markdown
index 89dc9e0..5bda100 100644
--- a/_xiaomi/xiaomimia2.markdown
+++ b/_xiaomi/xiaomimia2.markdown
@@ -21,4 +21,4 @@
 
 {% include twrpinstall.html %}
 
-{% include fastbootinstall.html %}
+{% include fastbootabinstall.html %}
diff --git a/_xiaomi/xiaomimix3.markdown b/_xiaomi/xiaomimix3.markdown
new file mode 100644
index 0000000..874c5c2
--- /dev/null
+++ b/_xiaomi/xiaomimix3.markdown
@@ -0,0 +1,25 @@
+---
+layout: device
+title:  "Xiaomi Mi MIX 3"
+codename: perseus
+downloadfolder: perseus
+supportstatus: Current
+maintainer: Mauronofrio
+devicetree: https://github.com/TeamWin/android_device_xiaomi_perseus
+oem: Xiaomi
+xdathread: "https://forum.xda-developers.com/mi-mix-3/development/recovery-unofficial-twrp-recovery-t3901261"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include xiaomiunlock.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_xiaomi/xiaomiredminote6.markdown b/_xiaomi/xiaomiredminote6.markdown
new file mode 100644
index 0000000..59bba29
--- /dev/null
+++ b/_xiaomi/xiaomiredminote6.markdown
@@ -0,0 +1,24 @@
+---
+layout: device
+title:  "Xiaomi Redmi Note 6"
+codename: tulip
+downloadfolder: tulip
+supportstatus: Current
+maintainer: Mauronofrio
+devicetree: https://github.com/TeamWin/android_device_xiaomi_tulip
+oem: Xiaomi
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include xiaomiunlock.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
diff --git a/_xiaomi/xiaomiredminote7pro.markdown b/_xiaomi/xiaomiredminote7pro.markdown
new file mode 100644
index 0000000..4520ef3
--- /dev/null
+++ b/_xiaomi/xiaomiredminote7pro.markdown
@@ -0,0 +1,28 @@
+---
+layout: device
+title:  "Xiaomi Redmi Note 7 Pro"
+codename: violet
+downloadfolder: violet
+supportstatus: Current
+maintainer: Adarsh.S.Kushwah (Doomsday101)
+devicetree: https://github.com/TeamWin/android_device_xiaomi_violet.git
+oem: Xiaomi
+ddof: "/dev/block/bootdevice/by-name/recovery"
+xdathread: "https://forum.xda-developers.com/redmi-note-7-pro/development/recovery-t3917669"
+---
+
+{% include disclaimer.html %}
+
+{% include supportstatus.html %}
+
+{% include xiaomiunlock.html %}
+
+{% include appinstall.html %}
+
+{% include download.html %}
+
+{% include twrpinstall.html %}
+
+{% include fastbootinstall.html %}
+
+{% include ddinstall.html %}
diff --git a/_zuk/zukz2row.markdown b/_zuk/zukz2row.markdown
index 141ad39..765ff3a 100644
--- a/_zuk/zukz2row.markdown
+++ b/_zuk/zukz2row.markdown
@@ -4,10 +4,10 @@
 codename: z2_row
 downloadfolder: z2_row
 supportstatus: Current
-maintainer: cosmedd
+maintainer: DD3Boh
 oem: ZUK
 devicetree: https://github.com/TeamWin/android_device_zuk_z2_row
-xdathread: https://forum.xda-developers.com/zuk-z2-pro/development/recovery-official-twrp-zuk-z2-pro-t3714651
+xdathread: https://forum.xda-developers.com/zuk-z2-pro/development/teamwin-recovery-project-3-2-3-zuk-z2-t3903727
 ---
 
 {% include disclaimer.html %}
diff --git a/oem/LYF.html b/oem/lyf.html
similarity index 83%
rename from oem/LYF.html
rename to oem/lyf.html
index 1006ac8..830fb08 100644
--- a/oem/LYF.html
+++ b/oem/lyf.html
@@ -1,7 +1,7 @@
 ---
 layout: oem
 title: LYF
-permalink: /Devices/LYF/
+permalink: /Devices/Lyf/
 exclude: true
 ---
 
@@ -9,7 +9,7 @@
 
   <hr />
   <ul class="post-list" id="post-list">
-    {% for post in site.LYF %}
+    {% for post in site.lyf %}
       <p>
 	<strong><a href="{{ post.url | prepend: site.baseurl }}">{{ post.title }} ({{ post.codename }})</a></strong>
       </p>
diff --git a/oem/umidigi.html b/oem/umidigi.html
new file mode 100644
index 0000000..a8126c9
--- /dev/null
+++ b/oem/umidigi.html
@@ -0,0 +1,16 @@
+---
+layout: oem
+title: UMIDIGI
+permalink: /Devices/Umidigi/
+exclude: true
+---
+<div class="home">
+    <hr />
+    <ul class="post-list" id="post-list">
+        {% for post in site.umidigi %}
+        <p>
+            <strong><a href="{{ post.url | prepend: site.baseurl }}">{{ post.title }} ({{ post.codename }})</a></strong>
+        </p>
+        {% endfor %}
+    </ul>
+</div>
\ No newline at end of file
diff --git a/oem/LYF.html b/oem/vestel.html
similarity index 77%
copy from oem/LYF.html
copy to oem/vestel.html
index 1006ac8..b83b189 100644
--- a/oem/LYF.html
+++ b/oem/vestel.html
@@ -1,7 +1,7 @@
 ---
 layout: oem
-title: LYF
-permalink: /Devices/LYF/
+title: Vestel
+permalink: /Devices/Vestel/
 exclude: true
 ---
 
@@ -9,7 +9,7 @@
 
   <hr />
   <ul class="post-list" id="post-list">
-    {% for post in site.LYF %}
+    {% for post in site.vestel %}
       <p>
 	<strong><a href="{{ post.url | prepend: site.baseurl }}">{{ post.title }} ({{ post.codename }})</a></strong>
       </p>
