diff --git a/_includes/samsungsystemasroot.html b/_includes/samsungsystemasroot.html
index 829de36..cb93190 100644
--- a/_includes/samsungsystemasroot.html
+++ b/_includes/samsungsystemasroot.html
@@ -3,7 +3,7 @@
 
 <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 root your device with Magisk 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">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>
 
