WIP.
diff --git a/_data/idl-fns.yml b/_data/idl-fns.yml
index cbf6aef..3a1ae85 100644
--- a/_data/idl-fns.yml
+++ b/_data/idl-fns.yml
@@ -381,9 +381,9 @@
   - name: tok_index
     sig: |
       <b>tok_index</b>(t: Token<em><sub>opt</sub></em>) ⇒ Long
-    synopsis: Returns token's index in the original user input
+    synopsis: Returns token's index in the original input
     desc: |
-      Returns <a class="not-code" target="javadoc" href="/apis/latest/org/apache/nlpcraft/model/NCToken.html#getIndex()">token's index</a> in the original user input. Note that this is an index of the token and not of the character.
+      Returns <a class="not-code" target="javadoc" href="/apis/latest/org/apache/nlpcraft/model/NCToken.html#getIndex()">token's index</a> in the original input. Note that this is an index of the token and not of the character.
       If <code>t</code> is not provided the current token is assumed.
     usage: |
       // Result: 'true' if index of this token in the original input is equal to 1.
@@ -494,6 +494,62 @@
       // Result: 'true' if there is a token with parent ID 'owner' after this token.
       tok_is_before_parent('owner')
 
+  - name: tok_all
+    sig: |
+      <b>tok_all</b>() ⇒ List[Token]
+    synopsis: |
+      Returns all tokens from the original input
+    desc: |
+      Returns all tokens from the original input.
+    usage: |
+      // Result: list of all tokens for the original input.
+      tok_all()
+
+  - name: tok_count
+    sig: |
+      <b>tok_count</b>() ⇒ Long
+    synopsis: |
+      Returns number of tokens from the original input
+    desc: |
+      Returns number of tokens from the original input.
+      It is equivalent to <code>size(tok_all())</code>
+    usage: |
+      // Result: number of all tokens for the original input.
+      tok_count()
+
+  - name: tok_all_for_id
+    sig: |
+      <b>tok_all_for_id</b>(id: String) ⇒ List[Token]
+    synopsis: |
+      Returns list of tokens from the original input with ID <code>id</code>
+    desc: |
+      Returns list of tokens from the original input with ID <code>id</code>.
+    usage: |
+      // Result: list of tokens for the original input that have ID 'id'.
+      tok_all_for_id('id')
+
+  - name: tok_all_for_parent
+    sig: |
+      <b>tok_all_for_id</b>(parentId: String) ⇒ List[Token]
+    synopsis: |
+      Returns list of tokens from the original input with parent ID <code>parentId</code>
+    desc: |
+      Returns list of tokens from the original input with parent ID <code>parentId</code>.
+    usage: |
+      // Result: list of tokens for the original input that have parent ID 'id'.
+      tok_all_for_parent('id')
+
+  - name: tok_all_for_group
+    sig: |
+      <b>tok_all_for_group</b>(grp: String) ⇒ List[Token]
+    synopsis: |
+      Returns list of tokens from the original input that belong to the group <code>grp</code>
+    desc: |
+      Returns list of tokens from the original input that belong to the group <code>grp</code>.
+    usage: |
+      // Result: list of tokens for the original input that belong to th group 'grp'.
+      tok_all_for_group('grp')
+
 fn-datetime:
   - name: year
     sig: |
diff --git a/_scss/misc.scss b/_scss/misc.scss
index acd1755..0ba96a7 100644
--- a/_scss/misc.scss
+++ b/_scss/misc.scss
@@ -373,7 +373,6 @@
 }
 
 code {
-    font-size: 105%;
     white-space: nowrap !important;
     color: #C0392B;
 
diff --git a/intent-matching.html b/intent-matching.html
index 78823d9..88d47ab 100644
--- a/intent-matching.html
+++ b/intent-matching.html
@@ -118,7 +118,7 @@
             <li>
                 IDL is a lazily evaluated language, i.e. expressions are evaluated only when required during runtime. That
                 means that evaluated left-to-right logical AND and OR operators, for example, skip their right-part expressions if the left expression result is
-                determinative for the overall result - so called short-circuit evaluation. Some IDL functions like
+                determinative for the overall result - so-called short-circuit evaluation. Some IDL functions like
                 <code>if</code> and <code>or_else</code> also provide the similar short-circuit evaluation.
             </li>
         </ul>
@@ -192,12 +192,33 @@
                                     <td><code>ordered</code></td>
                                     <td><code>Boolean</code></td>
                                     <td>
-                                        Whether or not this intent is ordered.
-                                        For ordered intent the specified order of terms is important for matching this intent.
-                                        If intent is unordered its terms can be found in any order in the input text.
-                                        Note that ordered intent significantly limits the user input it can match. In most cases
-                                        the ordered intent is only applicable to processing of a formal grammar (like a programming language)
-                                        and mostly unsuitable for the natural language processing.
+                                        <p>
+                                            Whether or not this intent is ordered.
+                                            For ordered intent the specified order of terms is important for matching this intent.
+                                            If intent is unordered its terms can be found in any order in the input text.
+                                            Note that ordered intent significantly limits the user input it can match. In most cases
+                                            the ordered intent is only applicable to processing of a formal grammar (like a programming language)
+                                            and mostly unsuitable for the natural language processing.
+                                        </p>
+                                        <p>
+                                            Note that while the <code>ordered</code> flag affect entire intent and all its
+                                            terms, you can define the individual term that depends on the position of the token.
+                                            This, in fact, allows you have a subset of terms that order dependant. See
+                                            the following <a href="#idl_functions">IDL functions</a> for details:
+                                        </p>
+                                        <ul>
+                                            <li><code>tok_index()</code></li>
+                                            <li><code>tok_all()</code></li>
+                                            <li><code>tok_count()</code></li>
+                                            <li><code>tok_is_last()</code></li>
+                                            <li><code>tok_is_first()</code></li>
+                                            <li><code>tok_is_before_id()</code></li>
+                                            <li><code>tok_is_before_parent()</code></li>
+                                            <li><code>tok_is_before_group()</code></li>
+                                            <li><code>tok_is_after_id()</code></li>
+                                            <li><code>tok_is_after_parent()</code></li>
+                                            <li><code>tok_is_after_group()</code></li>
+                                        </ul>
                                     </td>
                                     <td><code>false</code></td>
                                 </tr>