diff --git a/documentation/crysl/index.html b/documentation/crysl/index.html
index d4f0e52..6b94b72 100644
--- a/documentation/crysl/index.html
+++ b/documentation/crysl/index.html
@@ -306,9 +306,9 @@
 
 <h2 id="addition-or-modification-of-crysl-rules">Addition or Modification of CrySL Rules</h2>
 
-<p>All <em>CrySL</em> rules currently used by CogniCrypt are present in the repository named <a href="https://github.com/CROSSINGTUD/Crypto-API-Rules">Crypto-API-Rules</a>. As of June 2019, it contains three project[s], each one with CrySL specifications for Java Cryptography Architecture, Google Tink, and BouncyCastle through its lightweight API. You need to clone the corresponding project and import it as a maven project into Eclipse where you have already installed CogniCrypt and the <em>CrySL</em> plugins. These plugins let you update the <em>CrySL</em> rules on the fly. You can edit them or even add new rules. CogniCrypt automatically parses these rules and takes them into account in any future analyses.</p>
+<p>All <em>CrySL</em> rules currently used by CogniCrypt are present in the repository named <a href="https://github.com/CROSSINGTUD/Crypto-API-Rules">Crypto-API-Rules</a>. As of June 2019, it contains three project, one each for the APIs of Java Cryptography Architecture, Google Tink, and BouncyCastle through its lightweight API. You need to clone the corresponding project and import it as a maven project into Eclipse where you have already installed CogniCrypt and the <em>CrySL</em> plugins. These plugins let you update the <em>CrySL</em> rules on the fly. You can edit them or even add new rules. CogniCrypt automatically parses these rules and takes them into account in any future analyses.</p>
 
-<p>The following tutorial describes how to modify <em>CrySL</em> rules on the fly. The first screenshot shows an example code which uses <code>KeyGenerator</code> that is created with correct algorithm, namely &ldquo;AES&rdquo;, and later initialized with a proper keySize i.e. 128. Hence the plugin doesn&rsquo;t show any error markers.</p>
+<p>The below tutorial describes how to modify <em>CrySL</em> rules on the fly. The first screenshot shows an example code which uses <code>KeyGenerator</code> that is created with correct algorithm, namely &ldquo;AES&rdquo;, and later initialized with a proper keySize i.e. 128. Hence the plugin doesn&rsquo;t show any error markers.</p>
 
 <div class="imgbox">
     <img class="center-fit" src='./images/correctcode.png' alt="An example code without any misuse">
