Merge pull request #61 from ruphy/depfix

Port to docusaurus 2.0
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
index 6d7ac02..bbd6019 100644
--- a/.github/workflows/cd.yml
+++ b/.github/workflows/cd.yml
@@ -22,7 +22,7 @@
       - name: Commit changes
         run: |
           git checkout -b asf-site origin/asf-site
-          docker run --rm milagro-site tar c -C /app/website/build/incubator-milagro . | tar -x
+          docker run --rm milagro-site tar c -C /app/website/build . | tar -x
           date > build-date.txt
           git config user.name "Continuous Delivery Bot"
           git config user.email github-actions@github.com
diff --git a/docker-compose.yml b/docker-compose.yml
index 6711192..89bf56b 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -8,11 +8,5 @@
       - 35729:35729
     volumes:
       - ./docs:/app/docs
-      - ./website/blog:/app/website/blog
-      - ./website/core:/app/website/core
-      - ./website/i18n:/app/website/i18n
-      - ./website/pages:/app/website/pages
-      - ./website/static:/app/website/static
-      - ./website/sidebars.json:/app/website/sidebars.json
-      - ./website/siteConfig.js:/app/website/siteConfig.js
+      - ./website:/app/website
     working_dir: /app/website
diff --git a/docs/amcl-c-api-2.0.0.md b/docs/amcl-c-api-2.0.0.md
index 69f5fab..ba12dc1 100644
--- a/docs/amcl-c-api-2.0.0.md
+++ b/docs/amcl-c-api-2.0.0.md
@@ -3,7 +3,6 @@
 title: AMCL C API 2.0.0
 sidebar_label: AMCL C API 2.0.0
 ---
-
 Doxygen support is available for Milagro Crypto Library.
 
 An online version of the Doxygen output is available for viewing in a web browser <a href="/cdocs/index.html" target="_blank">here</a>.
@@ -11,7 +10,5 @@
 PDF of the Doxygen output is available for download <a href="/files/amcl-doxygen-2.0.0.pdf" target="_blank">here</a>.
 
 
-
-<!--
 Supported admonition types are: caution, note, important, tip, warning.
--->
+
diff --git a/docs/amcl-javascript-api.md b/docs/amcl-javascript-api.md
index f8a48f9..2d5a0f7 100644
--- a/docs/amcl-javascript-api.md
+++ b/docs/amcl-javascript-api.md
@@ -3,16 +3,15 @@
 title: AMCL JavaScript API
 sidebar_label: AMCL JavaScript API
 ---
+_MCJS - Milagro Crypto JavaScript_
 
-*MCJS - Milagro Crypto JavaScript*
+-   MCJS is a standards compliant JavaScript cryptographic library with no
+    external dependencies except for the random seed source.
 
-* MCJS is a standards compliant JavaScript cryptographic library with no
-external dependencies except for the random seed source.
+-   MCJS supports the standards for RSA, ECDH, ECIES, ECDSA and M-PIN, AES-GCM
+    encryption/decryption, SHA256, SHA384, SHA512 and SHA3 hash functions and a
+    cryptographically secure random number generator. Furthermore we recently
+    added New Hope, a post-quantum key exchange.
 
-* MCJS supports the standards for RSA, ECDH, ECIES, ECDSA and M-PIN, AES-GCM
-encryption/decryption, SHA256, SHA384, SHA512 and SHA3 hash functions and a
-cryptographically secure random number generator. Furthermore we recently
-added New Hope, a post-quantum key exchange.
-
-* MCJS is [Node.js](https://nodejs.org/en/) compatible and browser compatible
-(see some examples by going to the next page).
\ No newline at end of file
+-   MCJS is [Node.js](https://nodejs.org/en/) compatible and browser compatible
+    (see some examples by going to the next page).
diff --git a/docs/amcl-overview.md b/docs/amcl-overview.md
index c2253de..c14ac4c 100644
--- a/docs/amcl-overview.md
+++ b/docs/amcl-overview.md
@@ -4,6 +4,7 @@
 sidebar_label: AMCL Overview
 ---
 ## Introduction
+
 One of the major mysteries in the real-world of crypto is resistance to the exploitation of new research ideas. Its not that cryptographic research has failed to throw up new ideas that have the potential for commercial exploitation -- far from it. But in the real-world, 1970's crypto rules supreme, and very little happens that isn't PKI/RSA based. The reasons for this are many and varied. However one part of the puzzle might be the non-availability of easy-to-use open source cryptographic tools, that do not require in depth cryptographic expertise to deploy.
 
 There are many crypto libraries out there. Many offer a bewildering variety of cryptographic primitives, at different levels of security. Many use extensive assembly language in order to be as fast as possible. Many are very **BIG**, even bloated. Some rely on other external libraries. Many were designed by academics for academics, and so are not really suitable for commercial use. Many are otherwise excellent, but not written in our favorite language.
@@ -16,7 +17,7 @@
 
 The C version of AMCL is configured at compile time for 16, 32 or 64 bit processors, and for a specific elliptic curve. The Java and Javascript versions are (obviously) processor agnostic, but the same choices of elliptic curve are available.
 
-AMCL is written with an awareness of the abilities of modern pipelined processors. In particular there was an awareness that the unpredictable program branch should be avoided at all costs, not only as it slows down the processor, but as it may open the door to side-channel attacks. The innocuous looking ```if``` statement - unless its outcome can be accurately predicted - is the enemy of quality crypto software.
+AMCL is written with an awareness of the abilities of modern pipelined processors. In particular there was an awareness that the unpredictable program branch should be avoided at all costs, not only as it slows down the processor, but as it may open the door to side-channel attacks. The innocuous looking `if` statement - unless its outcome can be accurately predicted - is the enemy of quality crypto software.
 
 In the sequel we refer to the C version of AMCL, unless otherwise specified. We emphasis that all AMCL versions are completely self-contained. No external libraries or packages are required to implement all of the supported cryptographic functionality (other than for an external entropy source).
 
@@ -25,8 +26,9 @@
 The modules that make up AMCL are shown below, with some indication of how they interact. Several example APIs will be provided to implement common protocols. Note that all interaction with the API is via machine-independent endian-indifferent arrays of bytes (a.k.a. octet strings). Therefore the underlying workings of the library are invisible to the consumer of its services.
 
 ![client](/img/clint.eps.jpg)
+
 <figure>
-  <caption><strong>Figure 1.</strong> AMCL Library  </caption>
+  <strong>Figure 1.</strong> AMCL Library  
 </figure>
 
 ## Handling **BIG** Numbers
@@ -41,19 +43,19 @@
 
 [^first]: [Curve41417 Karatsuba revisited](http://eprint.iacr.org/2014/526)
 
-Note that almost all arithmetic takes place modulo a 256-bit prime number, the modulus representing the field over which the elliptic curve is defined, here denoted as \\( p \\).
+Note that almost all arithmetic takes place modulo a 256-bit prime number, the modulus representing the field over which the elliptic curve is defined, here denoted as $p$.
 
-On 64-bit processors, AMCL represents numbers to the base \\( 2^{56} \\) in a 5 element array, the Word Excess is 7 bits, and for a 256-bit modulus the Field Excess is 24 bits.
+On 64-bit processors, AMCL represents numbers to the base $2^{56}$ in a 5 element array, the Word Excess is 7 bits, and for a 256-bit modulus the Field Excess is 24 bits.
 
-On 32-bit processors, AMCL represents numbers to the base \\( 2^{29} \\) in a 9 element array, the Word Excess is 2 bits, and for a 256-bit modulus the Field Excess is 5 bits.
+On 32-bit processors, AMCL represents numbers to the base $2^{29}$ in a 9 element array, the Word Excess is 2 bits, and for a 256-bit modulus the Field Excess is 5 bits.
 
-On 16-bit processors, AMCL represents numbers to the base \\( 2^{13} \\) in a 20 element array, the Word Excess is 2 bits, and for a 256-bit modulus the Field Excess is 4 bits.
+On 16-bit processors, AMCL represents numbers to the base $2^{13}$ in a 20 element array, the Word Excess is 2 bits, and for a 256-bit modulus the Field Excess is 4 bits.
 
 Such a representation of a 256-bit number is referred to as a **BIG**. Addition or subtraction of a pair of **BIG**s, results in another **BIG**.
 
 The Java version uses exactly the same 32-bit representation as above.
 
-For Javascript (where all numbers are stored as 64-bit floating point with a 52-bit mantissa, but mostly manipulated as 32-bit integers), numbers are represented to the base \\( 2^{24} \\) in an 11 element array, the Word Excess is 7 bits, and the Field Excess for a 256-bit modulus is 8 bits.
+For Javascript (where all numbers are stored as 64-bit floating point with a 52-bit mantissa, but mostly manipulated as 32-bit integers), numbers are represented to the base $2^{24}$ in an 11 element array, the Word Excess is 7 bits, and the Field Excess for a 256-bit modulus is 8 bits.
 
 ### Addition and Subtraction
 
@@ -65,44 +67,45 @@
 
 Note that these two mechanisms associated with the word excess and the field excess (often confused in the literature) operate largely independently of each other.
 
-AMCL has no support for negative numbers. Therefore subtraction will be implemented as field negation followed by addition. However a field element \\( x \\) can be negated by simply calculating \\( −x = e.p − x \\), where \\( e \\) is the current excess associated with \\( x \\). Therefore subtraction will be implemented as field negation followed by addition. In practice it is more convenient to round \\( e \\) up to next highest power of 2, in which case \\( e.p \\) can be calculated by a simple shift.
+AMCL has no support for negative numbers. Therefore subtraction will be implemented as field negation followed by addition. However a field element $x$ can be negated by simply calculating $−x = e.p − x$, where $e$ is the current excess associated with $x$. Therefore subtraction will be implemented as field negation followed by addition. In practice it is more convenient to round $e$ up to next highest power of 2, in which case $e.p$ can be calculated by a simple shift.
 
 ![client](/img/words.eps.jpg)
+
 <figure>
-  <caption><strong>Figure 2.</strong> AMCL Library</caption>
+  <strong>Figure 2.</strong> AMCL Library
 </figure>
-<br>
+<br />
 Normalization of extended numbers requires the word excess of each digit to be shifted right by the number of base bits, and added to the next digit, working right to left. Note that when numbers are subtracted digit-by-digit individual digits may become negative. However since we are avoiding using the sign bit, due to the magic of 2's complement arithmetic, this all works fine without any conditional branches.
 
 Final full reduction of unreduced field elements is carried out using a simple shift-and-subtract of the modulus, with one subtraction needed for every bit in the actual field excess. Such reductions will rarely be required, as they are slow and hard to do in constant time. Ideally it should only be required at the end of a complex operation like an elliptic curve point multiplication. 
 
 So with careful programming we avoid any unpredictable program branches. Since the length of field elements is fixed at compile time, it is expected that the compiler will unroll most of the time-critical loops. In any case the conditional branch required at the foot of a fixed-size loop can be accurately predicted by modern hardware.
 
-Worst case field excesses are easy to calculate. If two elements \\( a \\) and \\( b \\) are to be added, and if their current field excesses are \\( e_{a} \\) and \\( e_{b} \\) respectively, then clearly their sum will have a worst-case field excess of \\( e_{a}+e_{b} \\). By careful programming and choice of number base, full reductions can be largely eliminated[^second].
+Worst case field excesses are easy to calculate. If two elements $a$ and $b$ are to be added, and if their current field excesses are $e_{a}$ and $e_{b}$ respectively, then clearly their sum will have a worst-case field excess of $e_{a}+e_{b}$. By careful programming and choice of number base, full reductions can be largely eliminated[^second].
 
 [^second]: [Slothful Reduction](http://eprint.iacr.org/2017/437)
 
 ### Multiplication and Reduction
 
-To support multiplication of **BIG**s, we will require a double-length ***DBIG*** type. Also the partial products that arise in the process of long multiplication will require a double-length data type. Fortunately many popular C compilers, like Gnu GCC, always support an integer type that is double the native word-length. For Java the "int" type is 32-bits and there is a double-length "long" type which is 64-bit. Of course for Javascript a double length type is not possible, and so the partial products must be accommodated within the 52-bit mantissa.
+To support multiplication of **BIG**s, we will require a double-length **_DBIG_** type. Also the partial products that arise in the process of long multiplication will require a double-length data type. Fortunately many popular C compilers, like Gnu GCC, always support an integer type that is double the native word-length. For Java the "int" type is 32-bits and there is a double-length "long" type which is 64-bit. Of course for Javascript a double length type is not possible, and so the partial products must be accommodated within the 52-bit mantissa.
 
 Multiprecision multiplication is performed column by column, propagating the carries, working from right-to-left, but using the fast method described in[^third]. At the foot of each column the total is split into the sum for that column, and the carry to the next column. If the numbers are normalized prior to the multiplication, then with the word excesses that we have chosen, this will not result in overflow. The DBIG product will be automatically normalized as a result of this process. Squaring can be done in a similar fashion but at a slightly lower cost.
 
 [^third]:[Missing a trick: Karatsuba variations](http://eprint.iacr.org/2015/1247)
 
-The method used for full reduction of a **DBIG** back to a **BIG** depends on the form of the modulus. We choose to support three distinct types of modulus, (a) pseudo Mersenne of the form \\( 2^n-c \\) where \\( c \\) is small and $n$ is the size of the modulus in bits, (b) Montgomery-friendly of the form \\( k.2^n-1 \\), and (c) moduli of no special form. For cases (b) and (c) we convert all field elements to Montgomery's \\( n \\)-residue form, and use Montgomery's fast method for modular reduction.
+The method used for full reduction of a **DBIG** back to a **BIG** depends on the form of the modulus. We choose to support three distinct types of modulus, (a) pseudo Mersenne of the form $2^n-c$ where $c$ is small and $n$ is the size of the modulus in bits, (b) Montgomery-friendly of the form $k.2^n-1$, and (c) moduli of no special form. For cases (b) and (c) we convert all field elements to Montgomery's $n$-residue form, and use Montgomery's fast method for modular reduction.
 
-In all cases the **DBIG** number to be reduced \\( y \\) must be in the range \\( 0<y<pR \\) (a requirement of Montgomery's method), and the result \\( x \\) is guaranteed to be in the range \\( 0<x<2p \\) , where \\( R=2^{256+FE} \\) for a 256-bit modulus. Note that the **BIG** result will be (nearly) fully reduced. The fact than we allow \\( x \\) to be larger than \\( p \\) means that we can avoid the notorious Montgomery "final subtraction". Independent of the method used for reduction, we have found that it is much easier to obtain reduction in constant time to a value less than \\( 2p \\), than a full reduction to less than \\( p \\).
+In all cases the **DBIG** number to be reduced $y$ must be in the range $0&lt;y&lt;pR$ (a requirement of Montgomery's method), and the result $x$ is guaranteed to be in the range $0&lt;x&lt;2p$ , where $R=2^{256+FE}$ for a 256-bit modulus. Note that the **BIG** result will be (nearly) fully reduced. The fact than we allow $x$ to be larger than $p$ means that we can avoid the notorious Montgomery "final subtraction". Independent of the method used for reduction, we have found that it is much easier to obtain reduction in constant time to a value less than $2p$, than a full reduction to less than $p$.
 
-Observe how unreduced numbers involved in complex calculations tend to be (nearly fully) reduced if they are involved in a modular multiplication. So for example if field element \\( x \\) has a large field excess, and if we calculate \\( x=x.y \\), then as long as the unreduced product is less than \\( pR \\), the result will be a nearly fully reduced \\( x \\). So in many cases there is a natural tendency for field excesses not to grow without limit, and not to overflow, without requiring explicit action on our part.
+Observe how unreduced numbers involved in complex calculations tend to be (nearly fully) reduced if they are involved in a modular multiplication. So for example if field element $x$ has a large field excess, and if we calculate $x=x.y$, then as long as the unreduced product is less than $pR$, the result will be a nearly fully reduced $x$. So in many cases there is a natural tendency for field excesses not to grow without limit, and not to overflow, without requiring explicit action on our part.
 
 Consider now a sequence of code that adds, subtracts and multiplies field elements, as might arise in elliptic curve additions and doublings. Assume that the code has been analysed and that normalisation code has been inserted where needed. Assume that the reduction code that activates if there is a possibility of an element overflowing its field excess, while present, never in fact is triggered (due to the behaviour described above). Then we assert that once a program has initialised no unpredicted branches will occur during field arithmetic, and therefore the code will execute in constant time.
 
 ## Extension Field arithmetic
 
-To support cryptographic pairings we will need support for extension fields. We use a towering of extensions as required for BN curves and as required for higher security BLS curves. An element of the quadratic extension field will be represented as \\( f=a+ib \\), where \\( i \\) is the square root of the quadratic non-residue -1. To add, subtract and multiply them we use the obvious methods.
+To support cryptographic pairings we will need support for extension fields. We use a towering of extensions as required for BN curves and as required for higher security BLS curves. An element of the quadratic extension field will be represented as $f=a+ib$, where $i$ is the square root of the quadratic non-residue -1. To add, subtract and multiply them we use the obvious methods.
 
-However for negation we can construct \\( -f=-a-ib \\) as \\( b-(a+b)+i.(a-(a+b) \\) which requires only one base field negation. A similar idea can be used recursively for higher order extensions, so that only one base field negation is ever required.
+However for negation we can construct $-f=-a-ib$ as $b-(a+b)+i.(a-(a+b)$ which requires only one base field negation. A similar idea can be used recursively for higher order extensions, so that only one base field negation is ever required.
 
 ## Elliptic Curves
 
@@ -110,15 +113,15 @@
 
 $$y^2=x^3+Ax+B$$
 
-where \\( A=0 \\) or \\( A=-3 \\). Edwards curves are supported using both regular and twisted Edwards format:
+where $A=0$ or $A=-3$. Edwards curves are supported using both regular and twisted Edwards format:
 
 $$Ax^2+y^2=1+Bx^2y^2$$
 
-where \\( A=1 \\) or \\( A=-1 \\). Montgomery curves are represented as:
+where $A=1$ or $A=-1$. Montgomery curves are represented as:
 
 $$y^2=x^3+Ax^2+x$$
 
-where \\( A \\) must be small. As mentioned in the introduction, in all cases we use exception-free formulae if available, as this facilitates constant time imple- mentation, even if this invokes a significant performance penalty.
+where $A$ must be small. As mentioned in the introduction, in all cases we use exception-free formulae if available, as this facilitates constant time imple- mentation, even if this invokes a significant performance penalty.
 
 In the particular case of elliptic curve point multiplication, there are potentially a myriad of very dangerous side-channel attacks that arise from using the classic double-and-add algorithm and its variants. Vulnerabilities arise if branches are taken that depend on secret bits, or if data is even accessed using secret values as indices. Many types of counter-measures have been suggested. The simplest solution is to use a constant-time algorithm like the Montgomery ladder, which has a very simple structure, uses very little  memory and has no key-bit-dependent branches.
 
@@ -137,7 +140,7 @@
 
 Secret key operations like RSA decryption use the Montgomery ladder to achieve side-channel-attack resistance.
 
-The implementation can currently support \\( 1024.2^n \\) bit fields, so for example 2048-bit RSA can be used to get reasonably close to the AES-128-bit level of security, and if desired 4096 bit RSA can be used to comfortably exceed it.
+The implementation can currently support $1024.2^n$ bit fields, so for example 2048-bit RSA can be used to get reasonably close to the AES-128-bit level of security, and if desired 4096 bit RSA can be used to comfortably exceed it.
 
 Note that this code is supported independently of the elliptic curve code. So for example RSA and ECC can be run together within a single application.
 
@@ -164,12 +167,12 @@
 
 However the development roadmap view might change in later versions depending on the project supporters in-the-field experiences of using AMCL.
 
----
+* * *
 
 :::note See an error in this documentation? 
 Submit a pull request on the development branch of [Milagro Website Repo](https://github.com/apache/incubator-milagro).
 :::
 
-<!--
+
 Supported admonition types are: caution, note, important, tip, warning.
--->
\ No newline at end of file
+
diff --git a/docs/contributor-guide.md b/docs/contributor-guide.md
index da763c7..bbb5f9e 100644
--- a/docs/contributor-guide.md
+++ b/docs/contributor-guide.md
@@ -3,8 +3,8 @@
 title: Contributor's Guide
 sidebar_label: Contributor's Guide
 ---
-
 # Become a contributor
+
 ## Apache Milagro Mailing List
 
 If you'd like to contribute, the first step is to subscribe to our developer's mailing list. Please send an email to:
@@ -24,6 +24,4 @@
 
 Please use the "Issues" tab on these repos to report any bugs or feature requests. 
 
-<!--
-Supported admonition types are: caution, note, important, tip, warning.
--->
+
diff --git a/docs/cryptojs/aes.md b/docs/cryptojs/aes.md
index 2206442..562dcfd 100644
--- a/docs/cryptojs/aes.md
+++ b/docs/cryptojs/aes.md
@@ -3,117 +3,126 @@
 title: AES
 sidebar_label: AES
 ---
-
-<a name="AES"></a>
+<a name="AES" />
 
 ## AES
+
 **Kind**: global class  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-* [AES](#AES)
-    * [new AES()](#new_AES_new)
-    * [.reset(m, iv)](#AES+reset)
-    * [.getreg()](#AES+getreg) ⇒
-    * [.init(m, n, key, iv)](#AES+init)
-    * [.ecb_encrypt(buff)](#AES+ecb_encrypt)
-    * [.ecb_decrypt(buff)](#AES+ecb_decrypt)
-    * [.encrypt(buff)](#AES+encrypt)
-    * [.decrypt(buff)](#AES+decrypt)
-    * [.end()](#AES+end)
+-   [AES](#AES)
+    -   [new AES()](#new_AES_new)
+    -   [.reset(m, iv)](#AES+reset)
+    -   [.getreg()](#AES+getreg) ⇒
+    -   [.init(m, n, key, iv)](#AES+init)
+    -   [.ecb_encrypt(buff)](#AES+ecb_encrypt)
+    -   [.ecb_decrypt(buff)](#AES+ecb_decrypt)
+    -   [.encrypt(buff)](#AES+encrypt)
+    -   [.decrypt(buff)](#AES+decrypt)
+    -   [.end()](#AES+end)
 
-<a name="new_AES_new"></a>
+<a name="new_AES_new" />
 
 ### new AES()
+
 Creates an instance of AES.
 
-<a name="AES+reset"></a>
+<a name="AES+reset" />
 
 ### aeS.reset(m, iv)
+
 Reset AES mode or IV
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| m | The new active mode of operation (ECB, CBC, OFB, CFB etc) |
-| iv | The new Initialisation Vector |
+| Param | Description                                               |
+| ----- | --------------------------------------------------------- |
+| m     | The new active mode of operation (ECB, CBC, OFB, CFB etc) |
+| iv    | The new Initialisation Vector                             |
 
-<a name="AES+getreg"></a>
+<a name="AES+getreg" />
 
 ### aeS.getreg() ⇒
+
 Reset Extract chaining vector
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
 **Returns**: f the extracted chaining vector  
-**this**: <code>{AES}</code>  
-<a name="AES+init"></a>
+**this**: <code>{"{"}AES{"}"}</code>  
+<a name="AES+init" />
 
 ### aeS.init(m, n, key, iv)
+
 Initialise an instance of AES and its mode of operation
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| m | is the active mode of operation (ECB, CBC, OFB, CFB etc) |
-| n | is the key length in bytes, 16, 24 or 32 |
-| key | the AES key as an array of 16 bytes |
-| iv | the Initialisation Vector |
+| Param | Description                                              |
+| ----- | -------------------------------------------------------- |
+| m     | is the active mode of operation (ECB, CBC, OFB, CFB etc) |
+| n     | is the key length in bytes, 16, 24 or 32                 |
+| key   | the AES key as an array of 16 bytes                      |
+| iv    | the Initialisation Vector                                |
 
-<a name="AES+ecb_encrypt"></a>
+<a name="AES+ecb_encrypt" />
 
-### aeS.ecb\_encrypt(buff)
+### aeS.ecb_encrypt(buff)
+
 Encrypt a single 16 byte block in ECB mode
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-| Param | Type | Description |
-| --- | --- | --- |
-| buff | <code>string</code> | is an array of 16 plaintext bytes, on exit becomes ciphertext |
+| Param | Type                | Description                                                   |
+| ----- | ------------------- | ------------------------------------------------------------- |
+| buff  | <code>string</code> | is an array of 16 plaintext bytes, on exit becomes ciphertext |
 
-<a name="AES+ecb_decrypt"></a>
+<a name="AES+ecb_decrypt" />
 
-### aeS.ecb\_decrypt(buff)
+### aeS.ecb_decrypt(buff)
+
 Decrypt a single 16 byte block in ECB mode
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| buff | is an array of 16 cipherext bytes, on exit becomes plaintext |
+| Param | Description                                                  |
+| ----- | ------------------------------------------------------------ |
+| buff  | is an array of 16 cipherext bytes, on exit becomes plaintext |
 
-<a name="AES+encrypt"></a>
+<a name="AES+encrypt" />
 
 ### aeS.encrypt(buff)
+
 Encrypt using selected mode of operation
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-| Param | Type | Description |
-| --- | --- | --- |
-| buff | <code>string</code> | is an array of 16 plaintext bytes, on exit becomes ciphertext |
+| Param | Type                | Description                                                   |
+| ----- | ------------------- | ------------------------------------------------------------- |
+| buff  | <code>string</code> | is an array of 16 plaintext bytes, on exit becomes ciphertext |
 
-<a name="AES+decrypt"></a>
+<a name="AES+decrypt" />
 
 ### aeS.decrypt(buff)
+
 Decrypt using selected mode of operation
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
 
-| Param | Type | Description |
-| --- | --- | --- |
-| buff | <code>string</code> | is an array of 16 cipherext bytes, on exit becomes plaintext |
+| Param | Type                | Description                                                  |
+| ----- | ------------------- | ------------------------------------------------------------ |
+| buff  | <code>string</code> | is an array of 16 cipherext bytes, on exit becomes plaintext |
 
-<a name="AES+end"></a>
+<a name="AES+end" />
 
 ### aeS.end()
+
 Clean up and delete left-overs
 
 **Kind**: instance method of [<code>AES</code>](#AES)  
-**this**: <code>{AES}</code>  
+**this**: <code>{"{"}AES{"}"}</code>  
diff --git a/docs/cryptojs/amcl-javascript-api.md b/docs/cryptojs/amcl-javascript-api.md
index 720d2d4..118cd1f 100644
--- a/docs/cryptojs/amcl-javascript-api.md
+++ b/docs/cryptojs/amcl-javascript-api.md
@@ -3,16 +3,15 @@
 title: AMCL JavaScript API
 sidebar_label: AMCL JavaScript API
 ---
+_MCJS - Milagro Crypto JavaScript_
 
-*MCJS - Milagro Crypto JavaScript*
+-   MCJS is a standards compliant JavaScript cryptographic library with no
+    external dependencies except for the random seed source.
 
-* MCJS is a standards compliant JavaScript cryptographic library with no
-external dependencies except for the random seed source.
+-   MCJS supports the standards for RSA, ECDH, ECIES, ECDSA and M-PIN, AES-GCM
+    encryption/decryption, SHA256, SHA384, SHA512 and SHA3 hash functions and a
+    cryptographically secure random number generator. Furthermore we recently
+    added New Hope, a post-quantum key exchange.
 
-* MCJS supports the standards for RSA, ECDH, ECIES, ECDSA and M-PIN, AES-GCM
-encryption/decryption, SHA256, SHA384, SHA512 and SHA3 hash functions and a
-cryptographically secure random number generator. Furthermore we recently
-added New Hope, a post-quantum key exchange.
-
-* MCJS is [Node.js](https://nodejs.org/en/) compatible and browser compatible
-(see some examples below).
\ No newline at end of file
+-   MCJS is [Node.js](https://nodejs.org/en/) compatible and browser compatible
+    (see some examples below).
diff --git a/docs/cryptojs/big.md b/docs/cryptojs/big.md
index cfbce02..ce3cc07 100644
--- a/docs/cryptojs/big.md
+++ b/docs/cryptojs/big.md
@@ -3,532 +3,585 @@
 title: BIG
 sidebar_label: BIG
 ---
-
-<a name="BIG"></a>
+<a name="BIG" />
 
 ## BIG
+
 **Kind**: global class  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 
-* [BIG](#BIG)
-    * [new BIG()](#new_BIG_new)
-    * _instance_
-        * [.zero()](#BIG+zero) ⇒
-        * [.one()](#BIG+one) ⇒
-        * [.iszilch()](#BIG+iszilch) ⇒
-        * [.isunity()](#BIG+isunity) ⇒
-        * [.cswap()](#BIG+cswap)
-        * [.cmove()](#BIG+cmove)
-        * [.copy()](#BIG+copy) ⇒
-        * [.hcopy()](#BIG+hcopy) ⇒
-        * [.rcopy()](#BIG+rcopy) ⇒
-        * [.norm()](#BIG+norm) ⇒
-        * [.fshr()](#BIG+fshr) ⇒
-        * [.shr()](#BIG+shr) ⇒
-        * [.fshl()](#BIG+fshl) ⇒
-        * [.shl()](#BIG+shl) ⇒
-        * [.nbits()](#BIG+nbits) ⇒
-        * [.toString()](#BIG+toString) ⇒
-        * [.add()](#BIG+add) ⇒
-        * [.or()](#BIG+or) ⇒
-        * [.plus()](#BIG+plus) ⇒
-        * [.inc()](#BIG+inc) ⇒
-        * [.sub()](#BIG+sub) ⇒
-        * [.rsub()](#BIG+rsub) ⇒
-        * [.dec()](#BIG+dec) ⇒
-        * [.minus()](#BIG+minus) ⇒
-        * [.imul()](#BIG+imul) ⇒
-        * [.tobytearray()](#BIG+tobytearray)
-        * [.toBytes()](#BIG+toBytes)
-        * [.muladd()](#BIG+muladd)
-        * [.pmul()](#BIG+pmul) ⇒
-        * [.pxmul()](#BIG+pxmul) ⇒
-        * [.div3()](#BIG+div3) ⇒
-        * [.mod2m()](#BIG+mod2m) ⇒
-        * [.invmod2m()](#BIG+invmod2m) ⇒
-        * [.mod()](#BIG+mod) ⇒
-        * [.div()](#BIG+div) ⇒
-        * [.parity()](#BIG+parity) ⇒
-        * [.bit()](#BIG+bit) ⇒
-        * [.lastbits()](#BIG+lastbits) ⇒
-        * [.jacobi()](#BIG+jacobi) ⇒
-        * [.invmodp()](#BIG+invmodp) ⇒
-        * [.powmod()](#BIG+powmod) ⇒
-    * _static_
-        * [.frombytearray()](#BIG.frombytearray) ⇒
-        * [.smul()](#BIG.smul) ⇒
-        * [.comp()](#BIG.comp) ⇒
-        * [.random()](#BIG.random) ⇒
-        * [.randomnum()](#BIG.randomnum) ⇒
-        * [.mul()](#BIG.mul) ⇒
-        * [.sqr()](#BIG.sqr) ⇒
-        * [.modmul()](#BIG.modmul) ⇒
-        * [.modsqr()](#BIG.modsqr) ⇒
-        * [.modneg()](#BIG.modneg) ⇒
-        * [.invmod256()](#BIG.invmod256) ⇒
+-   [BIG](#BIG)
+    -   [new BIG()](#new_BIG_new)
+    -   _instance_
+        -   [.zero()](#BIG+zero) ⇒
+        -   [.one()](#BIG+one) ⇒
+        -   [.iszilch()](#BIG+iszilch) ⇒
+        -   [.isunity()](#BIG+isunity) ⇒
+        -   [.cswap()](#BIG+cswap)
+        -   [.cmove()](#BIG+cmove)
+        -   [.copy()](#BIG+copy) ⇒
+        -   [.hcopy()](#BIG+hcopy) ⇒
+        -   [.rcopy()](#BIG+rcopy) ⇒
+        -   [.norm()](#BIG+norm) ⇒
+        -   [.fshr()](#BIG+fshr) ⇒
+        -   [.shr()](#BIG+shr) ⇒
+        -   [.fshl()](#BIG+fshl) ⇒
+        -   [.shl()](#BIG+shl) ⇒
+        -   [.nbits()](#BIG+nbits) ⇒
+        -   [.toString()](#BIG+toString) ⇒
+        -   [.add()](#BIG+add) ⇒
+        -   [.or()](#BIG+or) ⇒
+        -   [.plus()](#BIG+plus) ⇒
+        -   [.inc()](#BIG+inc) ⇒
+        -   [.sub()](#BIG+sub) ⇒
+        -   [.rsub()](#BIG+rsub) ⇒
+        -   [.dec()](#BIG+dec) ⇒
+        -   [.minus()](#BIG+minus) ⇒
+        -   [.imul()](#BIG+imul) ⇒
+        -   [.tobytearray()](#BIG+tobytearray)
+        -   [.toBytes()](#BIG+toBytes)
+        -   [.muladd()](#BIG+muladd)
+        -   [.pmul()](#BIG+pmul) ⇒
+        -   [.pxmul()](#BIG+pxmul) ⇒
+        -   [.div3()](#BIG+div3) ⇒
+        -   [.mod2m()](#BIG+mod2m) ⇒
+        -   [.invmod2m()](#BIG+invmod2m) ⇒
+        -   [.mod()](#BIG+mod) ⇒
+        -   [.div()](#BIG+div) ⇒
+        -   [.parity()](#BIG+parity) ⇒
+        -   [.bit()](#BIG+bit) ⇒
+        -   [.lastbits()](#BIG+lastbits) ⇒
+        -   [.jacobi()](#BIG+jacobi) ⇒
+        -   [.invmodp()](#BIG+invmodp) ⇒
+        -   [.powmod()](#BIG+powmod) ⇒
+    -   _static_
+        -   [.frombytearray()](#BIG.frombytearray) ⇒
+        -   [.smul()](#BIG.smul) ⇒
+        -   [.comp()](#BIG.comp) ⇒
+        -   [.random()](#BIG.random) ⇒
+        -   [.randomnum()](#BIG.randomnum) ⇒
+        -   [.mul()](#BIG.mul) ⇒
+        -   [.sqr()](#BIG.sqr) ⇒
+        -   [.modmul()](#BIG.modmul) ⇒
+        -   [.modsqr()](#BIG.modsqr) ⇒
+        -   [.modneg()](#BIG.modneg) ⇒
+        -   [.invmod256()](#BIG.invmod256) ⇒
 
-<a name="new_BIG_new"></a>
+<a name="new_BIG_new" />
 
 ### new BIG()
+
 General purpose Constructor
 
-<a name="BIG+zero"></a>
+<a name="BIG+zero" />
 
 ### biG.zero() ⇒
+
 set to zero
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
-<a name="BIG+one"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+one" />
 
 ### biG.one() ⇒
+
 set to one
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
-<a name="BIG+iszilch"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+iszilch" />
 
 ### biG.iszilch() ⇒
+
 test for zero
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: True if zero  
-**this**: <code>{BIG}</code>  
-<a name="BIG+isunity"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+isunity" />
 
 ### biG.isunity() ⇒
+
 test for unity
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: True if one  
-**this**: <code>{BIG}</code>  
-<a name="BIG+cswap"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+cswap" />
 
 ### biG.cswap()
+
 Conditional swap of two BIGs depending on d using XOR - no branches
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: b BIG number  
 **Parameter**: d BIG number  
-<a name="BIG+cmove"></a>
+<a name="BIG+cmove" />
 
 ### biG.cmove()
+
 Conditional move of BIG depending on d using XOR - no branches
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: b BIG number  
 **Parameter**: d BIG number  
-<a name="BIG+copy"></a>
+<a name="BIG+copy" />
 
 ### biG.copy() ⇒
+
 Copy from another BIG
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: The BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: y BIG number  
-<a name="BIG+hcopy"></a>
+<a name="BIG+hcopy" />
 
 ### biG.hcopy() ⇒
+
 copy from bottom half of ctx.DBIG
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: The new BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: y BIG number  
-<a name="BIG+rcopy"></a>
+<a name="BIG+rcopy" />
 
 ### biG.rcopy() ⇒
+
 copy from ROM
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: The BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: y BIG number in ROM  
-<a name="BIG+norm"></a>
+<a name="BIG+norm" />
 
 ### biG.norm() ⇒
-normalise BIG - force all digits < 2^BASEBITS
+
+normalise BIG - force all digits &lt; 2^BASEBITS
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
-<a name="BIG+fshr"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+fshr" />
 
 ### biG.fshr() ⇒
+
 Quick Fast shifts a BIG right by a small number of bits - input must be normalised, output will be normalised
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: r The shifted out part  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: k Number of bits to shift  
-<a name="BIG+shr"></a>
+<a name="BIG+shr" />
 
 ### biG.shr() ⇒
+
 General shift right by k bits
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: k Number of bits to shift  
-<a name="BIG+fshl"></a>
+<a name="BIG+fshl" />
 
 ### biG.fshl() ⇒
+
 Fast shifts a BIG left by a small number of bits - input must be normalised, output will be normalised
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: r The shifted out part  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: k Number of bits to shift  
-<a name="BIG+shl"></a>
+<a name="BIG+shl" />
 
 ### biG.shl() ⇒
+
 General shift left by k bits
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: k Number of bits to shift  
-<a name="BIG+nbits"></a>
+<a name="BIG+nbits" />
 
 ### biG.nbits() ⇒
+
 length in bits
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: The number of bigs in BIG object  
-**this**: <code>{BIG}</code>  
-<a name="BIG+toString"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+toString" />
 
 ### biG.toString() ⇒
+
 Convert to string
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: string representation of a BIG number  
-**this**: <code>{BIG}</code>  
-<a name="BIG+add"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+add" />
 
 ### biG.add() ⇒
+
 Sum two BIG mumbers
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this+=y  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: y BIG object  
-<a name="BIG+or"></a>
+<a name="BIG+or" />
 
 ### biG.or() ⇒
+
 OR two BIG mumbers
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this|=y  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: y BIG object  
-<a name="BIG+plus"></a>
+<a name="BIG+plus" />
 
 ### biG.plus() ⇒
+
 Sum two BIG mumbers
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this+x  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: x BIG object  
-<a name="BIG+inc"></a>
+<a name="BIG+inc" />
 
 ### biG.inc() ⇒
+
 Sum BIG and integer
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this+=i  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: i Integer to add  
-<a name="BIG+sub"></a>
+<a name="BIG+sub" />
 
 ### biG.sub() ⇒
+
 Subtract BIG from one another
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this-=y  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: y BIG object  
-<a name="BIG+rsub"></a>
+<a name="BIG+rsub" />
 
 ### biG.rsub() ⇒
+
 Reverse subtract BIG from one another
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this=x-this  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: x BIG object  
-<a name="BIG+dec"></a>
+<a name="BIG+dec" />
 
 ### biG.dec() ⇒
+
 Subtract integer from BIG
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this-=i  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: i Integer to subtract  
-<a name="BIG+minus"></a>
+<a name="BIG+minus" />
 
 ### biG.minus() ⇒
+
 Subtract BIG
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: New BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: x BIG object  
-<a name="BIG+imul"></a>
+<a name="BIG+imul" />
 
 ### biG.imul() ⇒
+
 Multiply by small integer
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
-**Returns**: this*c  
-**this**: <code>{BIG}</code>  
+**Returns**: this\*c  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: c small integer  
-<a name="BIG+tobytearray"></a>
+<a name="BIG+tobytearray" />
 
 ### biG.tobytearray()
+
 convert this BIG to byte array
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
-**this**: <code>{BIG}</code>  
-<a name="BIG+toBytes"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+toBytes" />
 
 ### biG.toBytes()
+
 convert this to byte array
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
-**this**: <code>{BIG}</code>  
-<a name="BIG+muladd"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+muladd" />
 
 ### biG.muladd()
-this[i]+=x*y+c, and return high part
+
+this[i]+=x\*y+c, and return high part
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
-**this**: <code>{BIG}</code>  
-<a name="BIG+pmul"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+pmul" />
 
 ### biG.pmul() ⇒
+
 multiply by larger int
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: carry value  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: c large integer  
-<a name="BIG+pxmul"></a>
+<a name="BIG+pxmul" />
 
 ### biG.pxmul() ⇒
+
 multiply by still larger int - results requires a DBIG
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: DBIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: c large integer  
-<a name="BIG+div3"></a>
+<a name="BIG+div3" />
 
 ### biG.div3() ⇒
+
 divide by 3
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: carry value  
-**this**: <code>{BIG}</code>  
-<a name="BIG+mod2m"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+mod2m" />
 
 ### biG.mod2m() ⇒
+
 set x = x mod 2^m
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: m Exponent  
-<a name="BIG+invmod2m"></a>
+<a name="BIG+invmod2m" />
 
 ### biG.invmod2m() ⇒
+
 a=1/a mod 2^256. This is very fast!
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG object  
-**this**: <code>{BIG}</code>  
-<a name="BIG+mod"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+mod" />
 
 ### biG.mod() ⇒
+
 reduce this mod m
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG object  
-**this**: <code>{BIG}</code>  
-<a name="BIG+div"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+div" />
 
 ### biG.div() ⇒
+
 this/=m1
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Paramter**: m1 divisor  
-<a name="BIG+parity"></a>
+<a name="BIG+parity" />
 
 ### biG.parity() ⇒
+
 return parity of this
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG object  
-**this**: <code>{BIG}</code>  
-<a name="BIG+bit"></a>
+**this**: <code>{"{"}BIG{"}"}</code>  
+<a name="BIG+bit" />
 
 ### biG.bit() ⇒
+
 return n-th bit of this
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: bit value  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: nth bit to return  
-<a name="BIG+lastbits"></a>
+<a name="BIG+lastbits" />
 
 ### biG.lastbits() ⇒
+
 return last n bits of this
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: bit values  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: n bits to return  
-<a name="BIG+jacobi"></a>
+<a name="BIG+jacobi" />
 
 ### biG.jacobi() ⇒
+
 Jacobi Symbol (this/p)
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: 0, 1 or -1  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: p BIG number  
-<a name="BIG+invmodp"></a>
+<a name="BIG+invmodp" />
 
 ### biG.invmodp() ⇒
+
 this=1/this mod p. Binary method
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: p The BIG Modulus  
-<a name="BIG+powmod"></a>
+<a name="BIG+powmod" />
 
 ### biG.powmod() ⇒
+
 Exponentation modulo m
 
 **Kind**: instance method of [<code>BIG</code>](#BIG)  
 **Returns**: this^e mod m  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: e1 BIG number  
 **Parameter**: m  The BIG Modulus  
-<a name="BIG.frombytearray"></a>
+<a name="BIG.frombytearray" />
 
 ### BIG.frombytearray() ⇒
+
 convert from byte array to BIG
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG object  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: b Bytearray  
-<a name="BIG.smul"></a>
+<a name="BIG.smul" />
 
 ### BIG.smul() ⇒
-return a*b where product fits a BIG
+
+return a\*b where product fits a BIG
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
-**Returns**: a*b  
-**this**: <code>{BIG}</code>  
+**Returns**: a\*b  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a BIG number  
 **Parameter**: b BIG number  
-<a name="BIG.comp"></a>
+<a name="BIG.comp" />
 
 ### BIG.comp() ⇒
+
 Compare a and b
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
-**Returns**: 0 if a==b, -1 if a<b, +1 if a>b  
-**this**: <code>{BIG}</code>  
+**Returns**: 0 if a==b, -1 if a&lt;b, +1 if a&gt;b  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a BIG number (normalised)  
 **Parameter**: b BIG number (normalised  
-<a name="BIG.random"></a>
+<a name="BIG.random" />
 
 ### BIG.random() ⇒
-Get 8*MODBYTES size random number
+
+Get 8\*MODBYTES size random number
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: rng Cryptographically Secure Random Number Generator  
-<a name="BIG.randomnum"></a>
+<a name="BIG.randomnum" />
 
 ### BIG.randomnum() ⇒
+
 Create random BIG in portable way, one bit at a time
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: rng Cryptographically Secure Random Number Generator  
 **Parameter**: q The BIG Modulus  
-<a name="BIG.mul"></a>
+<a name="BIG.mul" />
 
 ### BIG.mul() ⇒
+
 Multiple two BIG numbers
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
-**Returns**: a*b as a DBIG number  
-**this**: <code>{BIG}</code>  
+**Returns**: a\*b as a DBIG number  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a BIG number  
 **Parameter**: b BIG number  
-<a name="BIG.sqr"></a>
+<a name="BIG.sqr" />
 
 ### BIG.sqr() ⇒
+
 Square two BIG numbers
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
-**Returns**: a*2 as a DBIG number  
-**this**: <code>{BIG}</code>  
+**Returns**: a\*2 as a DBIG number  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a BIG number  
-<a name="BIG.modmul"></a>
+<a name="BIG.modmul" />
 
 ### BIG.modmul() ⇒
+
 Multiple two BIG numbers modulo m
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
-**Returns**: a1*b1 mod m  as a BIG number  
-**this**: <code>{BIG}</code>  
+**Returns**: a1\*b1 mod m  as a BIG number  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a1 BIG number  
 **Parameter**: b1 BIG number  
 **Parameter**: m The BIG Modulus  
-<a name="BIG.modsqr"></a>
+<a name="BIG.modsqr" />
 
 ### BIG.modsqr() ⇒
+
 Square a BIG number modulo m
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
-**Returns**: a*2 mod m  as a BIG number  
-**this**: <code>{BIG}</code>  
+**Returns**: a\*2 mod m  as a BIG number  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a1 BIG number  
 **Parameter**: m The BIG Modulus  
-<a name="BIG.modneg"></a>
+<a name="BIG.modneg" />
 
 ### BIG.modneg() ⇒
+
 Inversion
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
 **Returns**: -a1 mod m  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a1 BIG number  
 **Parameter**: m The BIG Modulus  
-<a name="BIG.invmod256"></a>
+<a name="BIG.invmod256" />
 
 ### BIG.invmod256() ⇒
+
 Arazi and Qi inversion mod 256
 
 **Kind**: static method of [<code>BIG</code>](#BIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: a BIG number  
diff --git a/docs/cryptojs/bls.md b/docs/cryptojs/bls.md
index 0073b9f..c4fa086 100644
--- a/docs/cryptojs/bls.md
+++ b/docs/cryptojs/bls.md
@@ -3,108 +3,117 @@
 title: BLS
 sidebar_label: BLS
 ---
-
-<a name="BLS"></a>
+<a name="BLS" />
 
 ## BLS
+
 **Kind**: global class  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 
-* [BLS](#BLS)
-    * [new BLS()](#new_BLS_new)
-    * [.bytestostring()](#BLS.bytestostring) ⇒
-    * [.stringtobytes()](#BLS.stringtobytes) ⇒
-    * [.bls_hashit()](#BLS.bls_hashit) ⇒
-    * [.KeyPairGenerate()](#BLS.KeyPairGenerate) ⇒
-    * [.sign()](#BLS.sign) ⇒
-    * [.verify()](#BLS.verify) ⇒
-    * [.add_G1()](#BLS.add_G1) ⇒
-    * [.add_G2()](#BLS.add_G2) ⇒
+-   [BLS](#BLS)
+    -   [new BLS()](#new_BLS_new)
+    -   [.bytestostring()](#BLS.bytestostring) ⇒
+    -   [.stringtobytes()](#BLS.stringtobytes) ⇒
+    -   [.bls_hashit()](#BLS.bls_hashit) ⇒
+    -   [.KeyPairGenerate()](#BLS.KeyPairGenerate) ⇒
+    -   [.sign()](#BLS.sign) ⇒
+    -   [.verify()](#BLS.verify) ⇒
+    -   [.add_G1()](#BLS.add_G1) ⇒
+    -   [.add_G2()](#BLS.add_G2) ⇒
 
-<a name="new_BLS_new"></a>
+<a name="new_BLS_new" />
 
 ### new BLS()
+
 Creates an instance of BLS
 
-<a name="BLS.bytestostring"></a>
+<a name="BLS.bytestostring" />
 
 ### BLS.bytestostring() ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: string  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: b byte array  
-<a name="BLS.stringtobytes"></a>
+<a name="BLS.stringtobytes" />
 
 ### BLS.stringtobytes() ⇒
+
 Convert string to byte array
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: byte array  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: s string  
-<a name="BLS.bls_hashit"></a>
+<a name="BLS.bls_hashit" />
 
-### BLS.bls\_hashit() ⇒
+### BLS.bls_hashit() ⇒
+
 hash a message to an ECP point, using SHA3
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: ECP point  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: m message to be hashedstring  
-<a name="BLS.KeyPairGenerate"></a>
+<a name="BLS.KeyPairGenerate" />
 
 ### BLS.KeyPairGenerate() ⇒
+
 Generate key pair
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: Error code  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: rng Cryptographically Secure Random Number Generator  
 **Parameter**: S Private key  
 **Parameter**: W Public key  
-<a name="BLS.sign"></a>
+<a name="BLS.sign" />
 
 ### BLS.sign() ⇒
+
 Sign message
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: Error code  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: SIG Singature  
 **Parameter**: m Message to sign  
 **Parameter**: S Private key  
-<a name="BLS.verify"></a>
+<a name="BLS.verify" />
 
 ### BLS.verify() ⇒
+
 Verify message
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: Error code  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: SIG Signature  
 **Parameter**: m Message to sign  
 **Parameter**: W Public key  
-<a name="BLS.add_G1"></a>
+<a name="BLS.add_G1" />
 
-### BLS.add\_G1() ⇒
+### BLS.add_G1() ⇒
+
 R=R1+R2 in group G1
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: Error code  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: R1 G1 Point  
 **Parameter**: R2 G1 Point  
 **Parameter**: R G1 Point  
-<a name="BLS.add_G2"></a>
+<a name="BLS.add_G2" />
 
-### BLS.add\_G2() ⇒
+### BLS.add_G2() ⇒
+
 W=W1+W2 in group G2
 
 **Kind**: static method of [<code>BLS</code>](#BLS)  
 **Returns**: Error code  
-**this**: <code>{BLS}</code>  
+**this**: <code>{"{"}BLS{"}"}</code>  
 **Parameter**: W1 G2 Point  
 **Parameter**: W2 G2 Point  
 **Parameter**: R G2 Point  
diff --git a/docs/cryptojs/bls192.md b/docs/cryptojs/bls192.md
index a28ca04..af0af4f 100644
--- a/docs/cryptojs/bls192.md
+++ b/docs/cryptojs/bls192.md
@@ -3,108 +3,117 @@
 title: BLS192
 sidebar_label: BLS192
 ---
-
-<a name="BLS192"></a>
+<a name="BLS192" />
 
 ## BLS192
+
 **Kind**: global class  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 
-* [BLS192](#BLS192)
-    * [new BLS192()](#new_BLS192_new)
-    * [.bytestostring()](#BLS192.bytestostring) ⇒
-    * [.stringtobytes()](#BLS192.stringtobytes) ⇒
-    * [.bls_hashit()](#BLS192.bls_hashit) ⇒
-    * [.KeyPairGenerate()](#BLS192.KeyPairGenerate) ⇒
-    * [.sign()](#BLS192.sign) ⇒
-    * [.verify()](#BLS192.verify) ⇒
-    * [.add_G1()](#BLS192.add_G1) ⇒
-    * [.add_G2()](#BLS192.add_G2) ⇒
+-   [BLS192](#BLS192)
+    -   [new BLS192()](#new_BLS192_new)
+    -   [.bytestostring()](#BLS192.bytestostring) ⇒
+    -   [.stringtobytes()](#BLS192.stringtobytes) ⇒
+    -   [.bls_hashit()](#BLS192.bls_hashit) ⇒
+    -   [.KeyPairGenerate()](#BLS192.KeyPairGenerate) ⇒
+    -   [.sign()](#BLS192.sign) ⇒
+    -   [.verify()](#BLS192.verify) ⇒
+    -   [.add_G1()](#BLS192.add_G1) ⇒
+    -   [.add_G2()](#BLS192.add_G2) ⇒
 
-<a name="new_BLS192_new"></a>
+<a name="new_BLS192_new" />
 
 ### new BLS192()
+
 Creates an instance of BLS192
 
-<a name="BLS192.bytestostring"></a>
+<a name="BLS192.bytestostring" />
 
 ### BLS192.bytestostring() ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: string  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: b byte array  
-<a name="BLS192.stringtobytes"></a>
+<a name="BLS192.stringtobytes" />
 
 ### BLS192.stringtobytes() ⇒
+
 Convert string to byte array
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: byte array  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: s string  
-<a name="BLS192.bls_hashit"></a>
+<a name="BLS192.bls_hashit" />
 
-### BLS192.bls\_hashit() ⇒
+### BLS192.bls_hashit() ⇒
+
 hash a message to an ECP point, using SHA3
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: ECP point  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: m message to be hashedstring  
-<a name="BLS192.KeyPairGenerate"></a>
+<a name="BLS192.KeyPairGenerate" />
 
 ### BLS192.KeyPairGenerate() ⇒
+
 Generate key pair
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: rng Cryptographically Secure Random Number Generator  
 **Parameter**: S Private key  
 **Parameter**: W Public key  
-<a name="BLS192.sign"></a>
+<a name="BLS192.sign" />
 
 ### BLS192.sign() ⇒
+
 Sign message
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: SIG Singature  
 **Parameter**: m Message to sign  
 **Parameter**: S Private key  
-<a name="BLS192.verify"></a>
+<a name="BLS192.verify" />
 
 ### BLS192.verify() ⇒
+
 Verify message
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: SIG Signature  
 **Parameter**: m Message to sign  
 **Parameter**: W Public key  
-<a name="BLS192.add_G1"></a>
+<a name="BLS192.add_G1" />
 
-### BLS192.add\_G1() ⇒
+### BLS192.add_G1() ⇒
+
 R=R1+R2 in group G1
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: R1 G1 Point  
 **Parameter**: R2 G1 Point  
 **Parameter**: R G1 Point  
-<a name="BLS192.add_G2"></a>
+<a name="BLS192.add_G2" />
 
-### BLS192.add\_G2() ⇒
+### BLS192.add_G2() ⇒
+
 W=W1+W2 in group G2
 
 **Kind**: static method of [<code>BLS192</code>](#BLS192)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: W1 G2 Point  
 **Parameter**: W2 G2 Point  
 **Parameter**: R G2 Point  
diff --git a/docs/cryptojs/bls256.md b/docs/cryptojs/bls256.md
index 2a2c47b..566ecf9 100644
--- a/docs/cryptojs/bls256.md
+++ b/docs/cryptojs/bls256.md
@@ -3,108 +3,117 @@
 title: BLS256
 sidebar_label: BLS256
 ---
-
-<a name="BLS256"></a>
+<a name="BLS256" />
 
 ## BLS256
+
 **Kind**: global class  
-**this**: <code>{BLS256}</code>  
+**this**: <code>{"{"}BLS256{"}"}</code>  
 
-* [BLS256](#BLS256)
-    * [new BLS256()](#new_BLS256_new)
-    * [.bytestostring()](#BLS256.bytestostring) ⇒
-    * [.stringtobytes()](#BLS256.stringtobytes) ⇒
-    * [.bls_hashit()](#BLS256.bls_hashit) ⇒
-    * [.KeyPairGenerate()](#BLS256.KeyPairGenerate) ⇒
-    * [.sign()](#BLS256.sign) ⇒
-    * [.verify()](#BLS256.verify) ⇒
-    * [.add_G1()](#BLS256.add_G1) ⇒
-    * [.add_G2()](#BLS256.add_G2) ⇒
+-   [BLS256](#BLS256)
+    -   [new BLS256()](#new_BLS256_new)
+    -   [.bytestostring()](#BLS256.bytestostring) ⇒
+    -   [.stringtobytes()](#BLS256.stringtobytes) ⇒
+    -   [.bls_hashit()](#BLS256.bls_hashit) ⇒
+    -   [.KeyPairGenerate()](#BLS256.KeyPairGenerate) ⇒
+    -   [.sign()](#BLS256.sign) ⇒
+    -   [.verify()](#BLS256.verify) ⇒
+    -   [.add_G1()](#BLS256.add_G1) ⇒
+    -   [.add_G2()](#BLS256.add_G2) ⇒
 
-<a name="new_BLS256_new"></a>
+<a name="new_BLS256_new" />
 
 ### new BLS256()
+
 Creates an instance of BLS256
 
-<a name="BLS256.bytestostring"></a>
+<a name="BLS256.bytestostring" />
 
 ### BLS256.bytestostring() ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: string  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: b byte array  
-<a name="BLS256.stringtobytes"></a>
+<a name="BLS256.stringtobytes" />
 
 ### BLS256.stringtobytes() ⇒
+
 Convert string to byte array
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: byte array  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: s string  
-<a name="BLS256.bls_hashit"></a>
+<a name="BLS256.bls_hashit" />
 
-### BLS256.bls\_hashit() ⇒
+### BLS256.bls_hashit() ⇒
+
 hash a message to an ECP point, using SHA3
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: ECP point  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: m message to be hashedstring  
-<a name="BLS256.KeyPairGenerate"></a>
+<a name="BLS256.KeyPairGenerate" />
 
 ### BLS256.KeyPairGenerate() ⇒
+
 Generate key pair
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: rng Cryptographically Secure Random Number Generator  
 **Parameter**: S Private key  
 **Parameter**: W Public key  
-<a name="BLS256.sign"></a>
+<a name="BLS256.sign" />
 
 ### BLS256.sign() ⇒
+
 Sign message
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: SIG Singature  
 **Parameter**: m Message to sign  
 **Parameter**: S Private key  
-<a name="BLS256.verify"></a>
+<a name="BLS256.verify" />
 
 ### BLS256.verify() ⇒
+
 Verify message
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: SIG Signature  
 **Parameter**: m Message to sign  
 **Parameter**: W Public key  
-<a name="BLS256.add_G1"></a>
+<a name="BLS256.add_G1" />
 
-### BLS256.add\_G1() ⇒
+### BLS256.add_G1() ⇒
+
 R=R1+R2 in group G1
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: R1 G1 Point  
 **Parameter**: R2 G1 Point  
 **Parameter**: R G1 Point  
-<a name="BLS256.add_G2"></a>
+<a name="BLS256.add_G2" />
 
-### BLS256.add\_G2() ⇒
+### BLS256.add_G2() ⇒
+
 W=W1+W2 in group G2
 
 **Kind**: static method of [<code>BLS256</code>](#BLS256)  
 **Returns**: Error code  
-**this**: <code>{BLS192}</code>  
+**this**: <code>{"{"}BLS192{"}"}</code>  
 **Parameter**: W1 G2 Point  
 **Parameter**: W2 G2 Point  
 **Parameter**: R G2 Point  
diff --git a/docs/cryptojs/dbig.md b/docs/cryptojs/dbig.md
index 515139f..0190b75 100644
--- a/docs/cryptojs/dbig.md
+++ b/docs/cryptojs/dbig.md
@@ -3,174 +3,191 @@
 title: DBIG
 sidebar_label: DBIG
 ---
-
-<a name="DBIG"></a>
+<a name="DBIG" />
 
 ## DBIG
+
 **Kind**: global class  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 
-* [DBIG](#DBIG)
-    * [new DBIG()](#new_DBIG_new)
-    * _instance_
-        * [.zero()](#DBIG+zero) ⇒
-        * [.copy()](#DBIG+copy) ⇒
-        * [.hcopy()](#DBIG+hcopy) ⇒
-        * [.norm()](#DBIG+norm) ⇒
-        * [.muladd()](#DBIG+muladd)
-        * [.shr()](#DBIG+shr) ⇒
-        * [.shl()](#DBIG+shl) ⇒
-        * [.cmove()](#DBIG+cmove)
-        * [.add()](#DBIG+add) ⇒
-        * [.sub()](#DBIG+sub) ⇒
-        * [.nbits()](#DBIG+nbits) ⇒
-        * [.toString()](#DBIG+toString) ⇒
-        * [.mod()](#DBIG+mod) ⇒
-        * [.div()](#DBIG+div) ⇒
-        * [.split()](#DBIG+split) ⇒
-    * _static_
-        * [.comp()](#DBIG.comp) ⇒
+-   [DBIG](#DBIG)
+    -   [new DBIG()](#new_DBIG_new)
+    -   _instance_
+        -   [.zero()](#DBIG+zero) ⇒
+        -   [.copy()](#DBIG+copy) ⇒
+        -   [.hcopy()](#DBIG+hcopy) ⇒
+        -   [.norm()](#DBIG+norm) ⇒
+        -   [.muladd()](#DBIG+muladd)
+        -   [.shr()](#DBIG+shr) ⇒
+        -   [.shl()](#DBIG+shl) ⇒
+        -   [.cmove()](#DBIG+cmove)
+        -   [.add()](#DBIG+add) ⇒
+        -   [.sub()](#DBIG+sub) ⇒
+        -   [.nbits()](#DBIG+nbits) ⇒
+        -   [.toString()](#DBIG+toString) ⇒
+        -   [.mod()](#DBIG+mod) ⇒
+        -   [.div()](#DBIG+div) ⇒
+        -   [.split()](#DBIG+split) ⇒
+    -   _static_
+        -   [.comp()](#DBIG.comp) ⇒
 
-<a name="new_DBIG_new"></a>
+<a name="new_DBIG_new" />
 
 ### new DBIG()
+
 General purpose Constructor
 
-<a name="DBIG+zero"></a>
+<a name="DBIG+zero" />
 
 ### dbiG.zero() ⇒
+
 set to zero
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: BIG number  
-**this**: <code>{DBIG}</code>  
-<a name="DBIG+copy"></a>
+**this**: <code>{"{"}DBIG{"}"}</code>  
+<a name="DBIG+copy" />
 
 ### dbiG.copy() ⇒
+
 set to b
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: DBIG number  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: b DBIG number  
-<a name="DBIG+hcopy"></a>
+<a name="DBIG+hcopy" />
 
 ### dbiG.hcopy() ⇒
+
 copy from ctx.BIG
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: DBIG number  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: b BIG number  
-<a name="DBIG+norm"></a>
+<a name="DBIG+norm" />
 
 ### dbiG.norm() ⇒
-normalise DBIG - force all digits < 2^BASEBITS
+
+normalise DBIG - force all digits &lt; 2^BASEBITS
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: DBIG number  
-**this**: <code>{DBIG}</code>  
-<a name="DBIG+muladd"></a>
+**this**: <code>{"{"}DBIG{"}"}</code>  
+<a name="DBIG+muladd" />
 
 ### dbiG.muladd()
-this[i]+=x*y+c, and return high part
+
+this[i]+=x\*y+c, and return high part
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
-**this**: <code>{DBIG}</code>  
-<a name="DBIG+shr"></a>
+**this**: <code>{"{"}DBIG{"}"}</code>  
+<a name="DBIG+shr" />
 
 ### dbiG.shr() ⇒
+
 General shift right by k bits
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: BIG number  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: k Number of bits to shift  
-<a name="DBIG+shl"></a>
+<a name="DBIG+shl" />
 
 ### dbiG.shl() ⇒
+
 General shift left by k bits
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: BIG number  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: k Number of bits to shift  
-<a name="DBIG+cmove"></a>
+<a name="DBIG+cmove" />
 
 ### dbiG.cmove()
+
 Conditional move of BIG depending on d using XOR - no branches
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: b DBIG number  
 **Parameter**: d DBIG number  
-<a name="DBIG+add"></a>
+<a name="DBIG+add" />
 
 ### dbiG.add() ⇒
+
 Sum two DBIG mumbers
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: this+=x  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: x DBIG object  
-<a name="DBIG+sub"></a>
+<a name="DBIG+sub" />
 
 ### dbiG.sub() ⇒
+
 Subtract DBIG from one another
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: this-=x  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: x BIG object  
-<a name="DBIG+nbits"></a>
+<a name="DBIG+nbits" />
 
 ### dbiG.nbits() ⇒
+
 length in bits
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: The number of bigs in DBIG object  
-**this**: <code>{DBIG}</code>  
-<a name="DBIG+toString"></a>
+**this**: <code>{"{"}DBIG{"}"}</code>  
+<a name="DBIG+toString" />
 
 ### dbiG.toString() ⇒
+
 Convert to string
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: string representation of a BIG number  
-**this**: <code>{DBIG}</code>  
-<a name="DBIG+mod"></a>
+**this**: <code>{"{"}DBIG{"}"}</code>  
+<a name="DBIG+mod" />
 
 ### dbiG.mod() ⇒
+
 reduces this DBIG mod a ctx.BIG, and returns the ctx.BIG
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: BIG object  
-**this**: <code>{DBIG}</code>  
-<a name="DBIG+div"></a>
+**this**: <code>{"{"}DBIG{"}"}</code>  
+<a name="DBIG+div" />
 
 ### dbiG.div() ⇒
+
 this/=c
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: DBIG number  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Paramter**: c divisor  
-<a name="DBIG+split"></a>
+<a name="DBIG+split" />
 
 ### dbiG.split() ⇒
+
 split this DBIG at position n, return higher half, keep lower half
 
 **Kind**: instance method of [<code>DBIG</code>](#DBIG)  
 **Returns**: lower half BIG number  
-**this**: <code>{DBIG}</code>  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Paramter**: n Position to splitdivisor  
-<a name="DBIG.comp"></a>
+<a name="DBIG.comp" />
 
 ### DBIG.comp() ⇒
+
 Compare a and b
 
 **Kind**: static method of [<code>DBIG</code>](#DBIG)  
-**Returns**: 0 if a==b, -1 if a<b, +1 if a>b  
-**this**: <code>{DBIG}</code>  
+**Returns**: 0 if a==b, -1 if a&lt;b, +1 if a&gt;b  
+**this**: <code>{"{"}DBIG{"}"}</code>  
 **Parameter**: a DBIG number (normalised)  
 **Parameter**: b DBIG number (normalised  
diff --git a/docs/cryptojs/ecdh.md b/docs/cryptojs/ecdh.md
index 2778e68..9c63109 100644
--- a/docs/cryptojs/ecdh.md
+++ b/docs/cryptojs/ecdh.md
@@ -3,200 +3,216 @@
 title: ECDH
 sidebar_label: ECDH
 ---
-
-<a name="ECDH"></a>
+<a name="ECDH" />
 
 ## ECDH
+
 **Kind**: global class  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 
-* [ECDH](#ECDH)
-    * [new ECDH()](#new_ECDH_new)
-    * [.inttobytes()](#ECDH.inttobytes) ⇒
-    * [.bytestostring()](#ECDH.bytestostring) ⇒
-    * [.stringtobytes()](#ECDH.stringtobytes) ⇒
-    * [.hashit()](#ECDH.hashit) ⇒
-    * [.KDF2()](#ECDH.KDF2) ⇒
-    * [.PBKDF2()](#ECDH.PBKDF2) ⇒
-    * [.HMAC()](#ECDH.HMAC) ⇒
-    * [.AES_CBC_IV0_ENCRYPT()](#ECDH.AES_CBC_IV0_ENCRYPT) ⇒
-    * [.AES_CBC_IV0_DECRYPT()](#ECDH.AES_CBC_IV0_DECRYPT) ⇒
-    * [.KEY_PAIR_GENERATE()](#ECDH.KEY_PAIR_GENERATE) ⇒
-    * [.PUBLIC_KEY_VALIDATE()](#ECDH.PUBLIC_KEY_VALIDATE) ⇒
-    * [.ECPSVDP_DH()](#ECDH.ECPSVDP_DH) ⇒
-    * [.ECPSP_DSA()](#ECDH.ECPSP_DSA) ⇒
-    * [.ECPVP_DSA()](#ECDH.ECPVP_DSA) ⇒
-    * [.ECIES_ENCRYPT()](#ECDH.ECIES_ENCRYPT) ⇒
-    * [.ECIES_DECRYPT()](#ECDH.ECIES_DECRYPT) ⇒
+-   [ECDH](#ECDH)
+    -   [new ECDH()](#new_ECDH_new)
+    -   [.inttobytes()](#ECDH.inttobytes) ⇒
+    -   [.bytestostring()](#ECDH.bytestostring) ⇒
+    -   [.stringtobytes()](#ECDH.stringtobytes) ⇒
+    -   [.hashit()](#ECDH.hashit) ⇒
+    -   [.KDF2()](#ECDH.KDF2) ⇒
+    -   [.PBKDF2()](#ECDH.PBKDF2) ⇒
+    -   [.HMAC()](#ECDH.HMAC) ⇒
+    -   [.AES_CBC_IV0_ENCRYPT()](#ECDH.AES_CBC_IV0_ENCRYPT) ⇒
+    -   [.AES_CBC_IV0_DECRYPT()](#ECDH.AES_CBC_IV0_DECRYPT) ⇒
+    -   [.KEY_PAIR_GENERATE()](#ECDH.KEY_PAIR_GENERATE) ⇒
+    -   [.PUBLIC_KEY_VALIDATE()](#ECDH.PUBLIC_KEY_VALIDATE) ⇒
+    -   [.ECPSVDP_DH()](#ECDH.ECPSVDP_DH) ⇒
+    -   [.ECPSP_DSA()](#ECDH.ECPSP_DSA) ⇒
+    -   [.ECPVP_DSA()](#ECDH.ECPVP_DSA) ⇒
+    -   [.ECIES_ENCRYPT()](#ECDH.ECIES_ENCRYPT) ⇒
+    -   [.ECIES_DECRYPT()](#ECDH.ECIES_DECRYPT) ⇒
 
-<a name="new_ECDH_new"></a>
+<a name="new_ECDH_new" />
 
 ### new ECDH()
+
 Creates an instance of ECDH
 
-<a name="ECDH.inttobytes"></a>
+<a name="ECDH.inttobytes" />
 
 ### ECDH.inttobytes() ⇒
+
 Convert Integer to n-byte array
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: byte array  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: n integer  
 **Parameter**: len integer length  
-<a name="ECDH.bytestostring"></a>
+<a name="ECDH.bytestostring" />
 
 ### ECDH.bytestostring() ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: string  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: b byte array  
-<a name="ECDH.stringtobytes"></a>
+<a name="ECDH.stringtobytes" />
 
 ### ECDH.stringtobytes() ⇒
+
 Convert string to byte array
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: byte array  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: s string  
-<a name="ECDH.hashit"></a>
+<a name="ECDH.hashit" />
 
 ### ECDH.hashit() ⇒
+
 general purpose hash function w=hash(B|n)
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: w output  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: A byte array involved in the hash  
 **Parameter**: n integer involved in the hash  
 **Parameter**: pad padding  
-<a name="ECDH.KDF2"></a>
+<a name="ECDH.KDF2" />
 
 ### ECDH.KDF2() ⇒
+
 IEEE-1363 Key Derivation Function - generates key K from inputs Z and P
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: K derived key  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: Z input byte array  
 **Parameter**: P input key derivation parameters - can be NULL  
 **Parameter**: 0len is output desired length of key  
-<a name="ECDH.PBKDF2"></a>
+<a name="ECDH.PBKDF2" />
 
 ### ECDH.PBKDF2() ⇒
+
 Password Based Key Derivation Function - generates key K from password, salt and repeat counter
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: key derived key  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: Pass input password  
 **Parameter**: Salt salt value  
 **Parameter**: rep Number of times to be iterated.  
 **Parameter**: 0len is output desired length of key  
-<a name="ECDH.HMAC"></a>
+<a name="ECDH.HMAC" />
 
 ### ECDH.HMAC() ⇒
+
 HMAC of message M using key K to create tag of length tag.length
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: error code  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: M input message  
 **Parameter**: K input encryption key  
 **Parameter**: tag is the output HMAC  
-<a name="ECDH.AES_CBC_IV0_ENCRYPT"></a>
+<a name="ECDH.AES_CBC_IV0_ENCRYPT" />
 
-### ECDH.AES\_CBC\_IV0\_ENCRYPT() ⇒
+### ECDH.AES_CBC_IV0_ENCRYPT() ⇒
+
 AES encrypts a plaintext to a ciphtertext
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: C Ciphertext  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: M input message  
 **Parameter**: K AES key  
-<a name="ECDH.AES_CBC_IV0_DECRYPT"></a>
+<a name="ECDH.AES_CBC_IV0_DECRYPT" />
 
-### ECDH.AES\_CBC\_IV0\_DECRYPT() ⇒
+### ECDH.AES_CBC_IV0_DECRYPT() ⇒
+
 AES encrypts a plaintext to a ciphtertext
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: P Plaintext  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: C Ciphertext  
 **Parameter**: K AES key  
-<a name="ECDH.KEY_PAIR_GENERATE"></a>
+<a name="ECDH.KEY_PAIR_GENERATE" />
 
-### ECDH.KEY\_PAIR\_GENERATE() ⇒
+### ECDH.KEY_PAIR_GENERATE() ⇒
+
 Generate an ECC public/private key pair
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: 0 or an error code  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: rng Cryptographically Secure Random Number Generator  
 **Parameter**: S the private key  
 **Parameter**: W the output public key, which is s.G, where G is a fixed generator  
-<a name="ECDH.PUBLIC_KEY_VALIDATE"></a>
+<a name="ECDH.PUBLIC_KEY_VALIDATE" />
 
-### ECDH.PUBLIC\_KEY\_VALIDATE() ⇒
+### ECDH.PUBLIC_KEY_VALIDATE() ⇒
+
 Generate an ECC public/private key pair
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: 0 or an error code  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: W the input public key to be validated  
-<a name="ECDH.ECPSVDP_DH"></a>
+<a name="ECDH.ECPSVDP_DH" />
 
-### ECDH.ECPSVDP\_DH() ⇒
+### ECDH.ECPSVDP_DH() ⇒
+
 Generate Diffie-Hellman shared key
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: 0 or an error code  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: S the private key  
 **Parameter**: W the output public key, which is s.G, where G is a fixed generator  
 **Parameter**: K the output shared key, in fact the x-coordinate of s.W  
-<a name="ECDH.ECPSP_DSA"></a>
+<a name="ECDH.ECPSP_DSA" />
 
-### ECDH.ECPSP\_DSA() ⇒
+### ECDH.ECPSP_DSA() ⇒
+
 ECDSA Signature
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: 0 or an error code  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: RNG Cryptographically Secure Random Number Generator  
 **Parameter**: S the private key  
 **Parameter**: F the input message to be signed  
 **Parameter**: C component of the output signature  
 **Parameter**: D component of the output signature  
-<a name="ECDH.ECPVP_DSA"></a>
+<a name="ECDH.ECPVP_DSA" />
 
-### ECDH.ECPVP\_DSA() ⇒
+### ECDH.ECPVP_DSA() ⇒
+
 ECDSA Signature Verification
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: 0 or an error code  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: W the public key  
 **Parameter**: F the input message to be signed  
 **Parameter**: C component of the output signature  
 **Parameter**: D component of the output signature  
-<a name="ECDH.ECIES_ENCRYPT"></a>
+<a name="ECDH.ECIES_ENCRYPT" />
 
-### ECDH.ECIES\_ENCRYPT() ⇒
+### ECDH.ECIES_ENCRYPT() ⇒
+
 ECIES Encryption
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: C ciphertext  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: P1 input Key Derivation parameters  
 **Parameter**: P2 input Encoding parameters  
@@ -205,14 +221,15 @@
 **Parameter**: M the input message to be encrypted  
 **Parameter**: V component of the output ciphertext  
 **Parameter**: T the output HMAC tag, part of the ciphertext  
-<a name="ECDH.ECIES_DECRYPT"></a>
+<a name="ECDH.ECIES_DECRYPT" />
 
-### ECDH.ECIES\_DECRYPT() ⇒
+### ECDH.ECIES_DECRYPT() ⇒
+
 ECIES Encryption
 
 **Kind**: static method of [<code>ECDH</code>](#ECDH)  
 **Returns**: M plaintext  
-**this**: <code>{ECDH}</code>  
+**this**: <code>{"{"}ECDH{"}"}</code>  
 **Parameter**: sha is the hash type  
 **Parameter**: P1 input Key Derivation parameters  
 **Parameter**: P2 input Encoding parameters  
diff --git a/docs/cryptojs/ecp.md b/docs/cryptojs/ecp.md
index c53a04a..f645757 100644
--- a/docs/cryptojs/ecp.md
+++ b/docs/cryptojs/ecp.md
@@ -3,320 +3,349 @@
 title: ECP
 sidebar_label: ECP
 ---
-
-<a name="ECP"></a>
+<a name="ECP" />
 
 ## ECP
+
 **Kind**: global class  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-* [ECP](#ECP)
-    * [new ECP()](#new_ECP_new)
-    * _instance_
-        * [.is_infinity(1)](#ECP+is_infinity)
-        * [.cswap()](#ECP+cswap)
-        * [.cmove()](#ECP+cmove)
-        * [.select()](#ECP+select)
-        * [.copy(P)](#ECP+copy)
-        * [.neg()](#ECP+neg)
-        * [.inf()](#ECP+inf)
-        * [.setxy(ix, iy)](#ECP+setxy)
-        * [.setxi(ix, s)](#ECP+setxi)
-        * [.setx(ix)](#ECP+setx)
-        * [.affine()](#ECP+affine)
-        * [.getX()](#ECP+getX)
-        * [.getY()](#ECP+getY)
-        * [.getS()](#ECP+getS)
-        * [.getx()](#ECP+getx)
-        * [.gety()](#ECP+gety)
-        * [.getz()](#ECP+getz)
-        * [.toBytes(b)](#ECP+toBytes)
-        * [.toString()](#ECP+toString) ⇒
-        * [.dbl()](#ECP+dbl)
-        * [.add()](#ECP+add)
-        * [.sub(Q)](#ECP+sub)
-        * [.pinmul(e, bts)](#ECP+pinmul)
-        * [.cfp()](#ECP+cfp)
-        * [.mul(e)](#ECP+mul)
-        * [.mul2(e, Q, f)](#ECP+mul2)
-    * _static_
-        * [.generator()](#ECP.generator)
-        * [.fromBytes(b)](#ECP.fromBytes)
-        * [.RHS(x)](#ECP.RHS)
+-   [ECP](#ECP)
+    -   [new ECP()](#new_ECP_new)
+    -   _instance_
+        -   [.is_infinity(1)](#ECP+is_infinity)
+        -   [.cswap()](#ECP+cswap)
+        -   [.cmove()](#ECP+cmove)
+        -   [.select()](#ECP+select)
+        -   [.copy(P)](#ECP+copy)
+        -   [.neg()](#ECP+neg)
+        -   [.inf()](#ECP+inf)
+        -   [.setxy(ix, iy)](#ECP+setxy)
+        -   [.setxi(ix, s)](#ECP+setxi)
+        -   [.setx(ix)](#ECP+setx)
+        -   [.affine()](#ECP+affine)
+        -   [.getX()](#ECP+getX)
+        -   [.getY()](#ECP+getY)
+        -   [.getS()](#ECP+getS)
+        -   [.getx()](#ECP+getx)
+        -   [.gety()](#ECP+gety)
+        -   [.getz()](#ECP+getz)
+        -   [.toBytes(b)](#ECP+toBytes)
+        -   [.toString()](#ECP+toString) ⇒
+        -   [.dbl()](#ECP+dbl)
+        -   [.add()](#ECP+add)
+        -   [.sub(Q)](#ECP+sub)
+        -   [.pinmul(e, bts)](#ECP+pinmul)
+        -   [.cfp()](#ECP+cfp)
+        -   [.mul(e)](#ECP+mul)
+        -   [.mul2(e, Q, f)](#ECP+mul2)
+    -   _static_
+        -   [.generator()](#ECP.generator)
+        -   [.fromBytes(b)](#ECP.fromBytes)
+        -   [.RHS(x)](#ECP.RHS)
 
-<a name="new_ECP_new"></a>
+<a name="new_ECP_new" />
 
 ### new ECP()
+
 Creates an instance of ECP
 
-<a name="ECP+is_infinity"></a>
+<a name="ECP+is_infinity" />
 
-### ecP.is\_infinity(1)
+### ecP.is_infinity(1)
+
 Tests for ECP point equal to infinity
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| 1 | if infinity, else returns 0 |
+| Param | Description                 |
+| ----- | --------------------------- |
+| 1     | if infinity, else returns 0 |
 
-<a name="ECP+cswap"></a>
+<a name="ECP+cswap" />
 
 ### ecP.cswap()
+
 conditional swap of this and Q dependant on dCopy ECP point to another ECP point
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+cmove"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+cmove" />
 
 ### ecP.cmove()
+
 conditional move of Q to P dependant on d
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+select"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+select" />
 
 ### ecP.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+copy"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+copy" />
 
 ### ecP.copy(P)
+
 Copy ECP point to another ECP point
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | ECP instance |
+| Param | Description  |
+| ----- | ------------ |
+| P     | ECP instance |
 
-<a name="ECP+neg"></a>
+<a name="ECP+neg" />
 
 ### ecP.neg()
+
 set this=-this
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+inf"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+inf" />
 
 ### ecP.inf()
+
 Set ECP to point-at-infinity
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+setxy"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+setxy" />
 
 ### ecP.setxy(ix, iy)
+
 set this=(x,y)
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
-| iy | y-value |
+| ----- | ----------- |
+| ix    | x-value     |
+| iy    | y-value     |
 
-<a name="ECP+setxi"></a>
+<a name="ECP+setxi" />
 
 ### ecP.setxi(ix, s)
+
 set this=x, where x is ctx.BIG, y is derived from sign s
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| ix | x-value |
-| s | sign to derive y |
+| Param | Description      |
+| ----- | ---------------- |
+| ix    | x-value          |
+| s     | sign to derive y |
 
-<a name="ECP+setx"></a>
+<a name="ECP+setx" />
 
 ### ecP.setx(ix)
+
 set this=x, y calculated from curve equation
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
+| ----- | ----------- |
+| ix    | x-value     |
 
-<a name="ECP+affine"></a>
+<a name="ECP+affine" />
 
 ### ecP.affine()
+
 convert this to affine, from (x,y,z) to (x,y)
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+getX"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+getX" />
 
 ### ecP.getX()
+
 extract affine x as ctx.FP2
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+getY"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+getY" />
 
 ### ecP.getY()
+
 extract affine y as ctx.FP2
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+getS"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+getS" />
 
 ### ecP.getS()
+
 get sign of Y
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+getx"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+getx" />
 
 ### ecP.getx()
+
 extract x as ctx.FP
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+gety"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+gety" />
 
 ### ecP.gety()
+
 extract y as ctx.FP
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+getz"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+getz" />
 
 ### ecP.getz()
+
 extract z as ctx.FP
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+toBytes"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+toBytes" />
 
 ### ecP.toBytes(b)
+
 convert this to byte arrayextract projective x
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte array output |
+| Param | Description       |
+| ----- | ----------------- |
+| b     | byte array output |
 
-<a name="ECP+toString"></a>
+<a name="ECP+toString" />
 
 ### ecP.toString() ⇒
+
 convert this to hex string
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
 **Returns**: hex string  
-**this**: <code>{ECP}</code>  
-<a name="ECP+dbl"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+dbl" />
 
 ### ecP.dbl()
+
 this+=this
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+add"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+add" />
 
 ### ecP.add()
+
 Adds ECP instances
 
 param Q ECP instance
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+sub"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+sub" />
 
 ### ecP.sub(Q)
+
 Subtracts ECP instance Q  from this
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP instance |
+| Param | Description  |
+| ----- | ------------ |
+| Q     | ECP instance |
 
-<a name="ECP+pinmul"></a>
+<a name="ECP+pinmul" />
 
 ### ecP.pinmul(e, bts)
+
 constant time multiply by small integer of length bts - use ladder
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | small integer |
-| bts | e bit length |
+| Param | Description   |
+| ----- | ------------- |
+| e     | small integer |
+| bts   | e bit length  |
 
-<a name="ECP+cfp"></a>
+<a name="ECP+cfp" />
 
 ### ecP.cfp()
+
 multiply this by the curves cofactor
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP+mul"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP+mul" />
 
 ### ecP.mul(e)
+
 Multiplies an ECP instance P by a BIG, side-channel resistant
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG number multiplier |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG number multiplier |
 
-<a name="ECP+mul2"></a>
+<a name="ECP+mul2" />
 
 ### ecP.mul2(e, Q, f)
+
 Return e.this+f.Q
 
 **Kind**: instance method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG number multiplier |
-| Q | ECP instance |
-| f | BIG number multiplier |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG number multiplier |
+| Q     | ECP instance          |
+| f     | BIG number multiplier |
 
-<a name="ECP.generator"></a>
+<a name="ECP.generator" />
 
 ### ECP.generator()
+
 Set group generator
 
 **Kind**: static method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
-<a name="ECP.fromBytes"></a>
+**this**: <code>{"{"}ECP{"}"}</code>  
+<a name="ECP.fromBytes" />
 
 ### ECP.fromBytes(b)
+
 convert from byte array to point
 
 **Kind**: static method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | input byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| b     | input byte array |
 
-<a name="ECP.RHS"></a>
+<a name="ECP.RHS" />
 
 ### ECP.RHS(x)
+
 Calculate RHS of the curve equation
 
 **Kind**: static method of [<code>ECP</code>](#ECP)  
-**this**: <code>{ECP}</code>  
+**this**: <code>{"{"}ECP{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| x | x-value |
-
+| ----- | ----------- |
+| x     | x-value     |
diff --git a/docs/cryptojs/ecp2.md b/docs/cryptojs/ecp2.md
index 51601c3..fa7de4f 100644
--- a/docs/cryptojs/ecp2.md
+++ b/docs/cryptojs/ecp2.md
@@ -3,282 +3,309 @@
 title: ECP2
 sidebar_label: ECP2
 ---
-
-<a name="ECP2"></a>
+<a name="ECP2" />
 
 ## ECP2
+
 **Kind**: global class  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-* [ECP2](#ECP2)
-    * [new ECP2()](#new_ECP2_new)
-    * _instance_
-        * [.is_infinity(1)](#ECP2+is_infinity)
-        * [.copy(P)](#ECP2+copy)
-        * [.inf()](#ECP2+inf)
-        * [.cmove()](#ECP2+cmove)
-        * [.select()](#ECP2+select)
-        * [.equals(Q)](#ECP2+equals)
-        * [.neg()](#ECP2+neg)
-        * [.affine()](#ECP2+affine)
-        * [.getX()](#ECP2+getX)
-        * [.getY()](#ECP2+getY)
-        * [.getx()](#ECP2+getx)
-        * [.gety()](#ECP2+gety)
-        * [.getz()](#ECP2+getz)
-        * [.toBytes(b)](#ECP2+toBytes)
-        * [.toString()](#ECP2+toString) ⇒
-        * [.setxy(ix, iy)](#ECP2+setxy)
-        * [.setx(ix)](#ECP2+setx)
-        * [.frob()](#ECP2+frob)
-        * [.dbl()](#ECP2+dbl)
-        * [.add()](#ECP2+add)
-        * [.sub(Q)](#ECP2+sub)
-        * [.mul(e)](#ECP2+mul)
-    * _static_
-        * [.generator()](#ECP2.generator)
-        * [.fromBytes(b)](#ECP2.fromBytes)
-        * [.RHS(x)](#ECP2.RHS)
-        * [.mul4()](#ECP2.mul4)
+-   [ECP2](#ECP2)
+    -   [new ECP2()](#new_ECP2_new)
+    -   _instance_
+        -   [.is_infinity(1)](#ECP2+is_infinity)
+        -   [.copy(P)](#ECP2+copy)
+        -   [.inf()](#ECP2+inf)
+        -   [.cmove()](#ECP2+cmove)
+        -   [.select()](#ECP2+select)
+        -   [.equals(Q)](#ECP2+equals)
+        -   [.neg()](#ECP2+neg)
+        -   [.affine()](#ECP2+affine)
+        -   [.getX()](#ECP2+getX)
+        -   [.getY()](#ECP2+getY)
+        -   [.getx()](#ECP2+getx)
+        -   [.gety()](#ECP2+gety)
+        -   [.getz()](#ECP2+getz)
+        -   [.toBytes(b)](#ECP2+toBytes)
+        -   [.toString()](#ECP2+toString) ⇒
+        -   [.setxy(ix, iy)](#ECP2+setxy)
+        -   [.setx(ix)](#ECP2+setx)
+        -   [.frob()](#ECP2+frob)
+        -   [.dbl()](#ECP2+dbl)
+        -   [.add()](#ECP2+add)
+        -   [.sub(Q)](#ECP2+sub)
+        -   [.mul(e)](#ECP2+mul)
+    -   _static_
+        -   [.generator()](#ECP2.generator)
+        -   [.fromBytes(b)](#ECP2.fromBytes)
+        -   [.RHS(x)](#ECP2.RHS)
+        -   [.mul4()](#ECP2.mul4)
 
-<a name="new_ECP2_new"></a>
+<a name="new_ECP2_new" />
 
 ### new ECP2()
+
 Creates an instance of ECP2
 
-<a name="ECP2+is_infinity"></a>
+<a name="ECP2+is_infinity" />
 
-### ecP2.is\_infinity(1)
+### ecP2.is_infinity(1)
+
 Tests for ECP2 point equal to infinity
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| 1 | if infinity, else returns 0 |
+| Param | Description                 |
+| ----- | --------------------------- |
+| 1     | if infinity, else returns 0 |
 
-<a name="ECP2+copy"></a>
+<a name="ECP2+copy" />
 
 ### ecP2.copy(P)
+
 Copy ECP2 point to another ECP2 point
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | ECP2 instance |
+| Param | Description   |
+| ----- | ------------- |
+| P     | ECP2 instance |
 
-<a name="ECP2+inf"></a>
+<a name="ECP2+inf" />
 
 ### ecP2.inf()
+
 Set ECP2 to point-at-infinity
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+cmove"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+cmove" />
 
 ### ecP2.cmove()
+
 conditional move of Q to P dependant on d
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+select"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+select" />
 
 ### ecP2.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+equals"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+equals" />
 
 ### ecP2.equals(Q)
+
 Test P == Q
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP2 instance |
+| Param | Description   |
+| ----- | ------------- |
+| Q     | ECP2 instance |
 
-<a name="ECP2+neg"></a>
+<a name="ECP2+neg" />
 
 ### ecP2.neg()
+
 set this=-this
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+affine"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+affine" />
 
 ### ecP2.affine()
+
 convert this to affine, from (x,y,z) to (x,y)
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+getX"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+getX" />
 
 ### ecP2.getX()
+
 extract affine x as ctx.FP2
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+getY"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+getY" />
 
 ### ecP2.getY()
+
 extract affine y as ctx.FP2
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+getx"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+getx" />
 
 ### ecP2.getx()
+
 extract projective x
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+gety"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+gety" />
 
 ### ecP2.gety()
+
 extract projective y
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+getz"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+getz" />
 
 ### ecP2.getz()
+
 extract projective z
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+toBytes"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+toBytes" />
 
 ### ecP2.toBytes(b)
+
 convert this to byte arrayextract projective x
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte array output |
+| Param | Description       |
+| ----- | ----------------- |
+| b     | byte array output |
 
-<a name="ECP2+toString"></a>
+<a name="ECP2+toString" />
 
 ### ecP2.toString() ⇒
+
 convert this to hex string
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
 **Returns**: hex string  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+setxy"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+setxy" />
 
 ### ecP2.setxy(ix, iy)
+
 set this=(x,y)
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
-| iy | y-value |
+| ----- | ----------- |
+| ix    | x-value     |
+| iy    | y-value     |
 
-<a name="ECP2+setx"></a>
+<a name="ECP2+setx" />
 
 ### ecP2.setx(ix)
+
 set this=(x,.)
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
+| ----- | ----------- |
+| ix    | x-value     |
 
-<a name="ECP2+frob"></a>
+<a name="ECP2+frob" />
 
 ### ecP2.frob()
-set this*=q, where q is Modulus, using Frobenius
+
+set this\*=q, where q is Modulus, using Frobenius
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+dbl"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+dbl" />
 
 ### ecP2.dbl()
+
 this+=this
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+add"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+add" />
 
 ### ecP2.add()
+
 Adds ECP2 instances
 
 param Q ECP2 instance
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2+sub"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2+sub" />
 
 ### ecP2.sub(Q)
+
 Subtracts ECP instance Q  from this
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP2 instance |
+| Param | Description   |
+| ----- | ------------- |
+| Q     | ECP2 instance |
 
-<a name="ECP2+mul"></a>
+<a name="ECP2+mul" />
 
 ### ecP2.mul(e)
+
 Multiplies an ECP2 instance P by a BIG, side-channel resistant
 
 **Kind**: instance method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG number multiplier |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG number multiplier |
 
-<a name="ECP2.generator"></a>
+<a name="ECP2.generator" />
 
 ### ECP2.generator()
+
 Set group generator
 
 **Kind**: static method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
-<a name="ECP2.fromBytes"></a>
+**this**: <code>{"{"}ECP2{"}"}</code>  
+<a name="ECP2.fromBytes" />
 
 ### ECP2.fromBytes(b)
+
 convert from byte array to point
 
 **Kind**: static method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | input byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| b     | input byte array |
 
-<a name="ECP2.RHS"></a>
+<a name="ECP2.RHS" />
 
 ### ECP2.RHS(x)
+
 Calculate RHS of curve equation x^3+B
 
 **Kind**: static method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| x | x-value |
+| ----- | ----------- |
+| x     | x-value     |
 
-<a name="ECP2.mul4"></a>
+<a name="ECP2.mul4" />
 
 ### ECP2.mul4()
-Calculate P=u0.Q0+u1*Q1+u2*Q2+u3*Q3
+
+Calculate P=u0.Q0+u1_Q1+u2_Q2+u3\*Q3
 
 **Kind**: static method of [<code>ECP2</code>](#ECP2)  
-**this**: <code>{ECP2}</code>  
+**this**: <code>{"{"}ECP2{"}"}</code>  
diff --git a/docs/cryptojs/ecp4.md b/docs/cryptojs/ecp4.md
index 87fca81..5d98c30 100644
--- a/docs/cryptojs/ecp4.md
+++ b/docs/cryptojs/ecp4.md
@@ -3,282 +3,309 @@
 title: ECP4
 sidebar_label: ECP4
 ---
-
-<a name="ECP4"></a>
+<a name="ECP4" />
 
 ## ECP4
+
 **Kind**: global class  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-* [ECP4](#ECP4)
-    * [new ECP4()](#new_ECP4_new)
-    * _instance_
-        * [.is_infinity(1)](#ECP4+is_infinity)
-        * [.copy(P)](#ECP4+copy)
-        * [.inf()](#ECP4+inf)
-        * [.cmove()](#ECP4+cmove)
-        * [.select()](#ECP4+select)
-        * [.equals(Q)](#ECP4+equals)
-        * [.neg()](#ECP4+neg)
-        * [.affine()](#ECP4+affine)
-        * [.getX()](#ECP4+getX)
-        * [.getY()](#ECP4+getY)
-        * [.getx()](#ECP4+getx)
-        * [.gety()](#ECP4+gety)
-        * [.getz()](#ECP4+getz)
-        * [.toBytes(b)](#ECP4+toBytes)
-        * [.toString()](#ECP4+toString) ⇒
-        * [.setxy(ix, iy)](#ECP4+setxy)
-        * [.setx(ix)](#ECP4+setx)
-        * [.frob()](#ECP4+frob)
-        * [.dbl()](#ECP4+dbl)
-        * [.add()](#ECP4+add)
-        * [.sub(Q)](#ECP4+sub)
-        * [.mul(e)](#ECP4+mul)
-    * _static_
-        * [.generator()](#ECP4.generator)
-        * [.fromBytes(b)](#ECP4.fromBytes)
-        * [.RHS(x)](#ECP4.RHS)
-        * [.mul8()](#ECP4.mul8)
+-   [ECP4](#ECP4)
+    -   [new ECP4()](#new_ECP4_new)
+    -   _instance_
+        -   [.is_infinity(1)](#ECP4+is_infinity)
+        -   [.copy(P)](#ECP4+copy)
+        -   [.inf()](#ECP4+inf)
+        -   [.cmove()](#ECP4+cmove)
+        -   [.select()](#ECP4+select)
+        -   [.equals(Q)](#ECP4+equals)
+        -   [.neg()](#ECP4+neg)
+        -   [.affine()](#ECP4+affine)
+        -   [.getX()](#ECP4+getX)
+        -   [.getY()](#ECP4+getY)
+        -   [.getx()](#ECP4+getx)
+        -   [.gety()](#ECP4+gety)
+        -   [.getz()](#ECP4+getz)
+        -   [.toBytes(b)](#ECP4+toBytes)
+        -   [.toString()](#ECP4+toString) ⇒
+        -   [.setxy(ix, iy)](#ECP4+setxy)
+        -   [.setx(ix)](#ECP4+setx)
+        -   [.frob()](#ECP4+frob)
+        -   [.dbl()](#ECP4+dbl)
+        -   [.add()](#ECP4+add)
+        -   [.sub(Q)](#ECP4+sub)
+        -   [.mul(e)](#ECP4+mul)
+    -   _static_
+        -   [.generator()](#ECP4.generator)
+        -   [.fromBytes(b)](#ECP4.fromBytes)
+        -   [.RHS(x)](#ECP4.RHS)
+        -   [.mul8()](#ECP4.mul8)
 
-<a name="new_ECP4_new"></a>
+<a name="new_ECP4_new" />
 
 ### new ECP4()
+
 Creates an instance of ECP4
 
-<a name="ECP4+is_infinity"></a>
+<a name="ECP4+is_infinity" />
 
-### ecP4.is\_infinity(1)
+### ecP4.is_infinity(1)
+
 Tests for ECP4 point equal to infinity
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| 1 | if infinity, else returns 0 |
+| Param | Description                 |
+| ----- | --------------------------- |
+| 1     | if infinity, else returns 0 |
 
-<a name="ECP4+copy"></a>
+<a name="ECP4+copy" />
 
 ### ecP4.copy(P)
+
 Copy ECP4 point to another ECP4 point
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | ECP4 instance |
+| Param | Description   |
+| ----- | ------------- |
+| P     | ECP4 instance |
 
-<a name="ECP4+inf"></a>
+<a name="ECP4+inf" />
 
 ### ecP4.inf()
+
 conditional move of Q to P dependant on d
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+cmove"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+cmove" />
 
 ### ecP4.cmove()
+
 conditional move of Q to P dependant on d
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+select"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+select" />
 
 ### ecP4.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+equals"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+equals" />
 
 ### ecP4.equals(Q)
+
 Test P == Q
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP4 instance |
+| Param | Description   |
+| ----- | ------------- |
+| Q     | ECP4 instance |
 
-<a name="ECP4+neg"></a>
+<a name="ECP4+neg" />
 
 ### ecP4.neg()
+
 set this=-this
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+affine"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+affine" />
 
 ### ecP4.affine()
+
 convert this to affine, from (x,y,z) to (x,y)
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+getX"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+getX" />
 
 ### ecP4.getX()
+
 extract affine x as ctx.FP2
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+getY"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+getY" />
 
 ### ecP4.getY()
+
 extract affine y as ctx.FP2
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+getx"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+getx" />
 
 ### ecP4.getx()
+
 extract projective x
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+gety"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+gety" />
 
 ### ecP4.gety()
+
 extract projective y
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+getz"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+getz" />
 
 ### ecP4.getz()
+
 extract projective z
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+toBytes"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+toBytes" />
 
 ### ecP4.toBytes(b)
+
 convert this to byte arrayextract projective x
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte array output |
+| Param | Description       |
+| ----- | ----------------- |
+| b     | byte array output |
 
-<a name="ECP4+toString"></a>
+<a name="ECP4+toString" />
 
 ### ecP4.toString() ⇒
+
 convert this to hex string
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
 **Returns**: hex string  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+setxy"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+setxy" />
 
 ### ecP4.setxy(ix, iy)
+
 set this=(x,y)
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
-| iy | y-value |
+| ----- | ----------- |
+| ix    | x-value     |
+| iy    | y-value     |
 
-<a name="ECP4+setx"></a>
+<a name="ECP4+setx" />
 
 ### ecP4.setx(ix)
+
 set this=(x,.)
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
+| ----- | ----------- |
+| ix    | x-value     |
 
-<a name="ECP4+frob"></a>
+<a name="ECP4+frob" />
 
 ### ecP4.frob()
-set this*=q, where q is Modulus, using Frobenius
+
+set this\*=q, where q is Modulus, using Frobenius
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+dbl"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+dbl" />
 
 ### ecP4.dbl()
+
 this+=this
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+add"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+add" />
 
 ### ecP4.add()
+
 Adds ECP4 instances
 
 param Q ECP4 instance
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4+sub"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4+sub" />
 
 ### ecP4.sub(Q)
+
 Subtracts ECP instance Q  from this
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP4 instance |
+| Param | Description   |
+| ----- | ------------- |
+| Q     | ECP4 instance |
 
-<a name="ECP4+mul"></a>
+<a name="ECP4+mul" />
 
 ### ecP4.mul(e)
+
 Multiplies an ECP4 instance P by a BIG, side-channel resistant
 
 **Kind**: instance method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG number multiplier |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG number multiplier |
 
-<a name="ECP4.generator"></a>
+<a name="ECP4.generator" />
 
 ### ECP4.generator()
+
 Set group generator
 
 **Kind**: static method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
-<a name="ECP4.fromBytes"></a>
+**this**: <code>{"{"}ECP4{"}"}</code>  
+<a name="ECP4.fromBytes" />
 
 ### ECP4.fromBytes(b)
+
 convert from byte array to point
 
 **Kind**: static method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | input byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| b     | input byte array |
 
-<a name="ECP4.RHS"></a>
+<a name="ECP4.RHS" />
 
 ### ECP4.RHS(x)
+
 Calculate RHS of curve equation x^3+B
 
 **Kind**: static method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| x | x-value |
+| ----- | ----------- |
+| x     | x-value     |
 
-<a name="ECP4.mul8"></a>
+<a name="ECP4.mul8" />
 
 ### ECP4.mul8()
-Calculate P=u0.Q0+u1*Q1+u2*Q2+u3*Q3...
+
+Calculate P=u0.Q0+u1_Q1+u2_Q2+u3\*Q3...
 
 **Kind**: static method of [<code>ECP4</code>](#ECP4)  
-**this**: <code>{ECP4}</code>  
+**this**: <code>{"{"}ECP4{"}"}</code>  
diff --git a/docs/cryptojs/ecp8.md b/docs/cryptojs/ecp8.md
index 05234cf..c862d37 100644
--- a/docs/cryptojs/ecp8.md
+++ b/docs/cryptojs/ecp8.md
@@ -3,282 +3,309 @@
 title: ECP8
 sidebar_label: ECP8
 ---
-
-<a name="ECP8"></a>
+<a name="ECP8" />
 
 ## ECP8
+
 **Kind**: global class  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-* [ECP8](#ECP8)
-    * [new ECP8()](#new_ECP8_new)
-    * _instance_
-        * [.is_infinity(1)](#ECP8+is_infinity)
-        * [.copy(P)](#ECP8+copy)
-        * [.inf()](#ECP8+inf)
-        * [.cmove()](#ECP8+cmove)
-        * [.select()](#ECP8+select)
-        * [.equals(Q)](#ECP8+equals)
-        * [.neg()](#ECP8+neg)
-        * [.affine()](#ECP8+affine)
-        * [.getX()](#ECP8+getX)
-        * [.getY()](#ECP8+getY)
-        * [.getx()](#ECP8+getx)
-        * [.gety()](#ECP8+gety)
-        * [.getz()](#ECP8+getz)
-        * [.toBytes(b)](#ECP8+toBytes)
-        * [.toString()](#ECP8+toString) ⇒
-        * [.setxy(ix, iy)](#ECP8+setxy)
-        * [.setx(ix)](#ECP8+setx)
-        * [.frob()](#ECP8+frob)
-        * [.dbl()](#ECP8+dbl)
-        * [.add()](#ECP8+add)
-        * [.sub(Q)](#ECP8+sub)
-        * [.mul(e)](#ECP8+mul)
-    * _static_
-        * [.generator()](#ECP8.generator)
-        * [.fromBytes(b)](#ECP8.fromBytes)
-        * [.RHS(x)](#ECP8.RHS)
-        * [.mul16()](#ECP8.mul16)
+-   [ECP8](#ECP8)
+    -   [new ECP8()](#new_ECP8_new)
+    -   _instance_
+        -   [.is_infinity(1)](#ECP8+is_infinity)
+        -   [.copy(P)](#ECP8+copy)
+        -   [.inf()](#ECP8+inf)
+        -   [.cmove()](#ECP8+cmove)
+        -   [.select()](#ECP8+select)
+        -   [.equals(Q)](#ECP8+equals)
+        -   [.neg()](#ECP8+neg)
+        -   [.affine()](#ECP8+affine)
+        -   [.getX()](#ECP8+getX)
+        -   [.getY()](#ECP8+getY)
+        -   [.getx()](#ECP8+getx)
+        -   [.gety()](#ECP8+gety)
+        -   [.getz()](#ECP8+getz)
+        -   [.toBytes(b)](#ECP8+toBytes)
+        -   [.toString()](#ECP8+toString) ⇒
+        -   [.setxy(ix, iy)](#ECP8+setxy)
+        -   [.setx(ix)](#ECP8+setx)
+        -   [.frob()](#ECP8+frob)
+        -   [.dbl()](#ECP8+dbl)
+        -   [.add()](#ECP8+add)
+        -   [.sub(Q)](#ECP8+sub)
+        -   [.mul(e)](#ECP8+mul)
+    -   _static_
+        -   [.generator()](#ECP8.generator)
+        -   [.fromBytes(b)](#ECP8.fromBytes)
+        -   [.RHS(x)](#ECP8.RHS)
+        -   [.mul16()](#ECP8.mul16)
 
-<a name="new_ECP8_new"></a>
+<a name="new_ECP8_new" />
 
 ### new ECP8()
+
 Creates an instance of ECP8
 
-<a name="ECP8+is_infinity"></a>
+<a name="ECP8+is_infinity" />
 
-### ecP8.is\_infinity(1)
+### ecP8.is_infinity(1)
+
 Tests for ECP8 point equal to infinity
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| 1 | if infinity, else returns 0 |
+| Param | Description                 |
+| ----- | --------------------------- |
+| 1     | if infinity, else returns 0 |
 
-<a name="ECP8+copy"></a>
+<a name="ECP8+copy" />
 
 ### ecP8.copy(P)
+
 Copy ECP8 point to another ECP8 point
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | ECP8 instance |
+| Param | Description   |
+| ----- | ------------- |
+| P     | ECP8 instance |
 
-<a name="ECP8+inf"></a>
+<a name="ECP8+inf" />
 
 ### ecP8.inf()
+
 Set ECP8 to point-at-infinity
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+cmove"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+cmove" />
 
 ### ecP8.cmove()
+
 conditional move of Q to P dependant on d
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+select"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+select" />
 
 ### ecP8.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+equals"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+equals" />
 
 ### ecP8.equals(Q)
+
 Test P == Q
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP8 instance |
+| Param | Description   |
+| ----- | ------------- |
+| Q     | ECP8 instance |
 
-<a name="ECP8+neg"></a>
+<a name="ECP8+neg" />
 
 ### ecP8.neg()
+
 set this=-this
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+affine"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+affine" />
 
 ### ecP8.affine()
+
 convert this to affine, from (x,y,z) to (x,y)
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+getX"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+getX" />
 
 ### ecP8.getX()
+
 extract affine x as ctx.FP2
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+getY"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+getY" />
 
 ### ecP8.getY()
+
 extract affine y as ctx.FP2
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+getx"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+getx" />
 
 ### ecP8.getx()
+
 extract projective x
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+gety"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+gety" />
 
 ### ecP8.gety()
+
 extract projective y
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+getz"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+getz" />
 
 ### ecP8.getz()
+
 extract projective z
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+toBytes"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+toBytes" />
 
 ### ecP8.toBytes(b)
+
 convert this to byte arrayextract projective x
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte array output |
+| Param | Description       |
+| ----- | ----------------- |
+| b     | byte array output |
 
-<a name="ECP8+toString"></a>
+<a name="ECP8+toString" />
 
 ### ecP8.toString() ⇒
+
 convert this to hex string
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
 **Returns**: hex string  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+setxy"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+setxy" />
 
 ### ecP8.setxy(ix, iy)
+
 set this=(x,y)
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
-| iy | y-value |
+| ----- | ----------- |
+| ix    | x-value     |
+| iy    | y-value     |
 
-<a name="ECP8+setx"></a>
+<a name="ECP8+setx" />
 
 ### ecP8.setx(ix)
+
 set this=(x,.)
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| ix | x-value |
+| ----- | ----------- |
+| ix    | x-value     |
 
-<a name="ECP8+frob"></a>
+<a name="ECP8+frob" />
 
 ### ecP8.frob()
-set this*=q, where q is Modulus, using Frobenius
+
+set this\*=q, where q is Modulus, using Frobenius
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+dbl"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+dbl" />
 
 ### ecP8.dbl()
+
 this+=this
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+add"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+add" />
 
 ### ecP8.add()
+
 Adds ECP8 instances
 
 param Q ECP8 instance
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8+sub"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8+sub" />
 
 ### ecP8.sub(Q)
+
 Subtracts ECP instance Q  from this
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| Q | ECP8 instance |
+| Param | Description   |
+| ----- | ------------- |
+| Q     | ECP8 instance |
 
-<a name="ECP8+mul"></a>
+<a name="ECP8+mul" />
 
 ### ecP8.mul(e)
+
 Multiplies an ECP8 instance P by a BIG, side-channel resistant
 
 **Kind**: instance method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG number multiplier |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG number multiplier |
 
-<a name="ECP8.generator"></a>
+<a name="ECP8.generator" />
 
 ### ECP8.generator()
+
 Set group generator
 
 **Kind**: static method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
-<a name="ECP8.fromBytes"></a>
+**this**: <code>{"{"}ECP8{"}"}</code>  
+<a name="ECP8.fromBytes" />
 
 ### ECP8.fromBytes(b)
+
 convert from byte array to point
 
 **Kind**: static method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | input byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| b     | input byte array |
 
-<a name="ECP8.RHS"></a>
+<a name="ECP8.RHS" />
 
 ### ECP8.RHS(x)
+
 Calculate RHS of curve equation x^3+B
 
 **Kind**: static method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| x | x-value |
+| ----- | ----------- |
+| x     | x-value     |
 
-<a name="ECP8.mul16"></a>
+<a name="ECP8.mul16" />
 
 ### ECP8.mul16()
-Calculate P=u0.Q0+u1*Q1+u2*Q2+u3*Q3...
+
+Calculate P=u0.Q0+u1_Q1+u2_Q2+u3\*Q3...
 
 **Kind**: static method of [<code>ECP8</code>](#ECP8)  
-**this**: <code>{ECP8}</code>  
+**this**: <code>{"{"}ECP8{"}"}</code>  
diff --git a/docs/cryptojs/ff.md b/docs/cryptojs/ff.md
index 25af78e..024834d 100644
--- a/docs/cryptojs/ff.md
+++ b/docs/cryptojs/ff.md
@@ -3,459 +3,504 @@
 title: FF
 sidebar_label: FF
 ---
-
-<a name="FF"></a>
+<a name="FF" />
 
 ## FF
+
 **Kind**: global class  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-* [FF](#FF)
-    * [new FF()](#new_FF_new)
-    * _instance_
-        * [.set(m)](#FF+set)
-        * [.copy(b)](#FF+copy)
-        * [.rcopy(b)](#FF+rcopy)
-        * [.dsucopy()](#FF+dsucopy)
-        * [.dscopy()](#FF+dscopy)
-        * [.sducopy()](#FF+sducopy)
-        * [.iszilch()](#FF+iszilch)
-        * [.shrw()](#FF+shrw)
-        * [.shlw()](#FF+shlw)
-        * [.parity()](#FF+parity)
-        * [.radd()](#FF+radd)
-        * [.rinc()](#FF+rinc)
-        * [.rsub()](#FF+rsub)
-        * [.rdec()](#FF+rdec)
-        * [.add()](#FF+add)
-        * [.sub()](#FF+sub)
-        * [.revsub()](#FF+revsub)
-        * [.inc()](#FF+inc)
-        * [.rnorm()](#FF+rnorm)
-        * [.shl()](#FF+shl)
-        * [.shr()](#FF+shr)
-        * [.toString()](#FF+toString)
-        * [.toBytes()](#FF+toBytes)
-        * [.karmul()](#FF+karmul)
-        * [.lmul()](#FF+lmul)
-        * [.mod()](#FF+mod)
-        * [.reduce(N, ND)](#FF+reduce) ⇒
-        * [.dmod(b)](#FF+dmod) ⇒
-        * [.invmodp()](#FF+invmodp)
-        * [.nres()](#FF+nres)
-        * [.invmod2m()](#FF+invmod2m)
-        * [.randomnum()](#FF+randomnum)
-        * [.modmul()](#FF+modmul)
-        * [.modsqr()](#FF+modsqr)
-        * [.skpow(e, p)](#FF+skpow)
-        * [.skspow(e, p)](#FF+skspow)
-        * [.power(e, p)](#FF+power)
-        * [.pow(e, p)](#FF+pow)
-        * [.pow2(e, y, f, p)](#FF+pow2)
-        * [.cfactor(s)](#FF+cfactor) ⇒
-    * _static_
-        * [.comp(a, b)](#FF.comp) ⇒
-        * [.cswap()](#FF.cswap)
-        * [.mul()](#FF.mul)
-        * [.sqr()](#FF.sqr)
-        * [.prime(p, rmg)](#FF.prime)
+-   [FF](#FF)
+    -   [new FF()](#new_FF_new)
+    -   _instance_
+        -   [.set(m)](#FF+set)
+        -   [.copy(b)](#FF+copy)
+        -   [.rcopy(b)](#FF+rcopy)
+        -   [.dsucopy()](#FF+dsucopy)
+        -   [.dscopy()](#FF+dscopy)
+        -   [.sducopy()](#FF+sducopy)
+        -   [.iszilch()](#FF+iszilch)
+        -   [.shrw()](#FF+shrw)
+        -   [.shlw()](#FF+shlw)
+        -   [.parity()](#FF+parity)
+        -   [.radd()](#FF+radd)
+        -   [.rinc()](#FF+rinc)
+        -   [.rsub()](#FF+rsub)
+        -   [.rdec()](#FF+rdec)
+        -   [.add()](#FF+add)
+        -   [.sub()](#FF+sub)
+        -   [.revsub()](#FF+revsub)
+        -   [.inc()](#FF+inc)
+        -   [.rnorm()](#FF+rnorm)
+        -   [.shl()](#FF+shl)
+        -   [.shr()](#FF+shr)
+        -   [.toString()](#FF+toString)
+        -   [.toBytes()](#FF+toBytes)
+        -   [.karmul()](#FF+karmul)
+        -   [.lmul()](#FF+lmul)
+        -   [.mod()](#FF+mod)
+        -   [.reduce(N, ND)](#FF+reduce) ⇒
+        -   [.dmod(b)](#FF+dmod) ⇒
+        -   [.invmodp()](#FF+invmodp)
+        -   [.nres()](#FF+nres)
+        -   [.invmod2m()](#FF+invmod2m)
+        -   [.randomnum()](#FF+randomnum)
+        -   [.modmul()](#FF+modmul)
+        -   [.modsqr()](#FF+modsqr)
+        -   [.skpow(e, p)](#FF+skpow)
+        -   [.skspow(e, p)](#FF+skspow)
+        -   [.power(e, p)](#FF+power)
+        -   [.pow(e, p)](#FF+pow)
+        -   [.pow2(e, y, f, p)](#FF+pow2)
+        -   [.cfactor(s)](#FF+cfactor) ⇒
+    -   _static_
+        -   [.comp(a, b)](#FF.comp) ⇒
+        -   [.cswap()](#FF.cswap)
+        -   [.mul()](#FF.mul)
+        -   [.sqr()](#FF.sqr)
+        -   [.prime(p, rmg)](#FF.prime)
 
-<a name="new_FF_new"></a>
+<a name="new_FF_new" />
 
 ### new FF()
+
 Creates an instance of FF.
 
-<a name="FF+set"></a>
+<a name="FF+set" />
 
 ### fF.set(m)
+
 set to integer
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| m | Integer value to be set to |
+| Param | Description                |
+| ----- | -------------------------- |
+| m     | Integer value to be set to |
 
-<a name="FF+copy"></a>
+<a name="FF+copy" />
 
 ### fF.copy(b)
+
 copy from FF b
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | FF element to copy from |
+| Param | Description             |
+| ----- | ----------------------- |
+| b     | FF element to copy from |
 
-<a name="FF+rcopy"></a>
+<a name="FF+rcopy" />
 
 ### fF.rcopy(b)
+
 copy from FF b
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | FF element to copy from |
+| Param | Description             |
+| ----- | ----------------------- |
+| b     | FF element to copy from |
 
-<a name="FF+dsucopy"></a>
+<a name="FF+dsucopy" />
 
 ### fF.dsucopy()
-x=y<<n
+
+x=y&lt;&lt;n
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+dscopy"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+dscopy" />
 
 ### fF.dscopy()
+
 x=y
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+sducopy"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+sducopy" />
 
 ### fF.sducopy()
-x=y>>n
+
+x=y&gt;&gt;n
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+iszilch"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+iszilch" />
 
 ### fF.iszilch()
+
 test equals 0
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+shrw"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+shrw" />
 
 ### fF.shrw()
+
 shift right by BIGBITS-bit words
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+shlw"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+shlw" />
 
 ### fF.shlw()
+
 shift left by BIGBITS-bit words
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+parity"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+parity" />
 
 ### fF.parity()
+
 extract last bit
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+radd"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+radd" />
 
 ### fF.radd()
+
 recursive add
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+rinc"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+rinc" />
 
 ### fF.rinc()
+
 recursive inc
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+rsub"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+rsub" />
 
 ### fF.rsub()
+
 recursive sub
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+rdec"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+rdec" />
 
 ### fF.rdec()
+
 recursive dec
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+add"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+add" />
 
 ### fF.add()
+
 simple add
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+sub"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+sub" />
 
 ### fF.sub()
+
 simple sub
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+revsub"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+revsub" />
 
 ### fF.revsub()
+
 reverse sub
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+inc"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+inc" />
 
 ### fF.inc()
+
 increment/decrement by a small integer
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+rnorm"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+rnorm" />
 
 ### fF.rnorm()
-normalise - but hold any overflow in top part unless n<0
+
+normalise - but hold any overflow in top part unless n&lt;0
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+shl"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+shl" />
 
 ### fF.shl()
+
 shift left by one bit
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+shr"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+shr" />
 
 ### fF.shr()
+
 shift right by one bit
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+toString"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+toString" />
 
 ### fF.toString()
+
 Convert to Hex String
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+toBytes"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+toBytes" />
 
 ### fF.toBytes()
+
 Convert FFs to/from byte arrays
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+karmul"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+karmul" />
 
 ### fF.karmul()
-z=x*y, t is workspace
+
+z=x\*y, t is workspace
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+lmul"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+lmul" />
 
 ### fF.lmul()
-return low part of product this*y
+
+return low part of product this\*y
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+mod"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+mod" />
 
 ### fF.mod()
+
 Set b=b mod c
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+reduce"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+reduce" />
 
 ### fF.reduce(N, ND) ⇒
+
 return this mod modulus
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
 **Returns**: this mod N  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| N | Mmodulus |
-| ND | Montgomery Constant |
+| Param | Description         |
+| ----- | ------------------- |
+| N     | Mmodulus            |
+| ND    | Montgomery Constant |
 
-<a name="FF+dmod"></a>
+<a name="FF+dmod" />
 
 ### fF.dmod(b) ⇒
+
 Reduces a double-length FF with respect to a given modulus
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
 **Returns**: this mod N  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| b | Mmodulus |
+| ----- | ----------- |
+| b     | Mmodulus    |
 
-<a name="FF+invmodp"></a>
+<a name="FF+invmodp" />
 
 ### fF.invmodp()
-Set return=1/this mod p. Binary method - a<p on entry
+
+Set return=1/this mod p. Binary method - a&lt;p on entry
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+nres"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+nres" />
 
 ### fF.nres()
+
 nresidue mod m
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+invmod2m"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+invmod2m" />
 
 ### fF.invmod2m()
+
 U=1/a mod 2^m - Arazi & Qi
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+randomnum"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+randomnum" />
 
 ### fF.randomnum()
+
 generate random x
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+modmul"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+modmul" />
 
 ### fF.modmul()
-this*=y mod p
+
+this\*=y mod p
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+modsqr"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+modsqr" />
 
 ### fF.modsqr()
-this*=y mod p
+
+this\*=y mod p
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF+skpow"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF+skpow" />
 
 ### fF.skpow(e, p)
+
 this=this^e mod p using side-channel resistant Montgomery Ladder, for large e
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| e | exponent |
-| p | modulus |
+| ----- | ----------- |
+| e     | exponent    |
+| p     | modulus     |
 
-<a name="FF+skspow"></a>
+<a name="FF+skspow" />
 
 ### fF.skspow(e, p)
+
 this=this^e mod p using side-channel resistant Montgomery Ladder, for short e
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| e | exponent |
-| p | modulus |
+| ----- | ----------- |
+| e     | exponent    |
+| p     | modulus     |
 
-<a name="FF+power"></a>
+<a name="FF+power" />
 
 ### fF.power(e, p)
+
 raise to an integer power - right-to-left method
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| e | exponent |
-| p | modulus |
+| ----- | ----------- |
+| e     | exponent    |
+| p     | modulus     |
 
-<a name="FF+pow"></a>
+<a name="FF+pow" />
 
 ### fF.pow(e, p)
+
 this=this^e mod p, faster but not side channel resistant
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| e | exponent |
-| p | modulus |
+| ----- | ----------- |
+| e     | exponent    |
+| p     | modulus     |
 
-<a name="FF+pow2"></a>
+<a name="FF+pow2" />
 
 ### fF.pow2(e, y, f, p)
+
 double exponentiation r=x^e.y^f mod p
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| e | exponent |
-| y | FF instance |
-| f | exponent |
-| p | modulus |
+| ----- | ----------- |
+| e     | exponent    |
+| y     | FF instance |
+| f     | exponent    |
+| p     | modulus     |
 
-<a name="FF+cfactor"></a>
+<a name="FF+cfactor" />
 
 ### fF.cfactor(s) ⇒
+
 Test if an FF has factor in common with integer s
 
 **Kind**: instance method of [<code>FF</code>](#FF)  
 **Returns**: true or false  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | integerexponent |
+| Param | Description     |
+| ----- | --------------- |
+| s     | integerexponent |
 
-<a name="FF.comp"></a>
+<a name="FF.comp" />
 
 ### FF.comp(a, b) ⇒
+
 compare a and b - must be normalised, and of same length
 
 **Kind**: static method of [<code>FF</code>](#FF)  
 **Returns**: zero of error codetrue or false  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| a | FF number |
-| b | FF number |
+| ----- | ----------- |
+| a     | FF number   |
+| b     | FF number   |
 
-<a name="FF.cswap"></a>
+<a name="FF.cswap" />
 
 ### FF.cswap()
+
 in-place swapping using xor - side channel resistant - lengths must be the same
 
 **Kind**: static method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF.mul"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF.mul" />
 
 ### FF.mul()
-z=x*y. Assumes x and y are of same length.
+
+z=x\*y. Assumes x and y are of same length.
 
 **Kind**: static method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF.sqr"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF.sqr" />
 
 ### FF.sqr()
+
 z=x^2
 
 **Kind**: static method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
-<a name="FF.prime"></a>
+**this**: <code>{"{"}FF{"}"}</code>  
+<a name="FF.prime" />
 
 ### FF.prime(p, rmg)
+
 Miller-Rabin test for primality.
 
 **Kind**: static method of [<code>FF</code>](#FF)  
-**this**: <code>{FF}</code>  
+**this**: <code>{"{"}FF{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| p | FF instance to be tested |
-| rmg | an instance of a Cryptographically Secure Random Number Generator |
-
+| Param | Description                                                       |
+| ----- | ----------------------------------------------------------------- |
+| p     | FF instance to be tested                                          |
+| rmg   | an instance of a Cryptographically Secure Random Number Generator |
diff --git a/docs/cryptojs/fp.md b/docs/cryptojs/fp.md
index fa2c0d8..c150dd8 100644
--- a/docs/cryptojs/fp.md
+++ b/docs/cryptojs/fp.md
@@ -3,286 +3,312 @@
 title: FP
 sidebar_label: FP
 ---
-
-<a name="FP"></a>
+<a name="FP" />
 
 ## FP
+
 **Kind**: global class  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-* [FP](#FP)
-    * [new FP(x)](#new_FP_new)
-    * _instance_
-        * [.zero()](#FP+zero)
-        * [.rcopy(x)](#FP+rcopy)
-        * [.bcopy(x)](#FP+bcopy)
-        * [.copy(x)](#FP+copy)
-        * [.cswap()](#FP+cswap)
-        * [.cmove(g, d)](#FP+cmove)
-        * [.nres()](#FP+nres)
-        * [.redc()](#FP+redc)
-        * [.toString()](#FP+toString)
-        * [.iszilch()](#FP+iszilch)
-        * [.reduce()](#FP+reduce)
-        * [.one()](#FP+one)
-        * [.norm()](#FP+norm)
-        * [.mul(b)](#FP+mul)
-        * [.imul(s)](#FP+imul)
-        * [.sqr()](#FP+sqr)
-        * [.neg(x)](#FP+neg)
-        * [.sub(x)](#FP+sub)
-        * [.div2()](#FP+div2)
-        * [.fpow()](#FP+fpow)
-        * [.inverse()](#FP+inverse)
-        * [.equals(x)](#FP+equals)
-        * [.pow(e)](#FP+pow)
-        * [.jacobi()](#FP+jacobi)
-        * [.sqrt()](#FP+sqrt)
-    * _static_
-        * [.mod()](#FP.mod)
+-   [FP](#FP)
+    -   [new FP(x)](#new_FP_new)
+    -   _instance_
+        -   [.zero()](#FP+zero)
+        -   [.rcopy(x)](#FP+rcopy)
+        -   [.bcopy(x)](#FP+bcopy)
+        -   [.copy(x)](#FP+copy)
+        -   [.cswap()](#FP+cswap)
+        -   [.cmove(g, d)](#FP+cmove)
+        -   [.nres()](#FP+nres)
+        -   [.redc()](#FP+redc)
+        -   [.toString()](#FP+toString)
+        -   [.iszilch()](#FP+iszilch)
+        -   [.reduce()](#FP+reduce)
+        -   [.one()](#FP+one)
+        -   [.norm()](#FP+norm)
+        -   [.mul(b)](#FP+mul)
+        -   [.imul(s)](#FP+imul)
+        -   [.sqr()](#FP+sqr)
+        -   [.neg(x)](#FP+neg)
+        -   [.sub(x)](#FP+sub)
+        -   [.div2()](#FP+div2)
+        -   [.fpow()](#FP+fpow)
+        -   [.inverse()](#FP+inverse)
+        -   [.equals(x)](#FP+equals)
+        -   [.pow(e)](#FP+pow)
+        -   [.jacobi()](#FP+jacobi)
+        -   [.sqrt()](#FP+sqrt)
+    -   _static_
+        -   [.mod()](#FP.mod)
 
-<a name="new_FP_new"></a>
+<a name="new_FP_new" />
 
 ### new FP(x)
+
 Creates an instance of FP.
 
+| Param | Description       |
+| ----- | ----------------- |
+| x     | FP / BIG instance |
 
-| Param | Description |
-| --- | --- |
-| x | FP / BIG instance |
-
-<a name="FP+zero"></a>
+<a name="FP+zero" />
 
 ### fP.zero()
+
 Set FP to zero
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+rcopy"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+rcopy" />
 
 ### fP.rcopy(x)
+
 copy from a ctx.BIG in ROM
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP instance to be copied |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP instance to be copied |
 
-<a name="FP+bcopy"></a>
+<a name="FP+bcopy" />
 
 ### fP.bcopy(x)
+
 copy from another ctx.BIG
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP instance to be copied |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP instance to be copied |
 
-<a name="FP+copy"></a>
+<a name="FP+copy" />
 
 ### fP.copy(x)
+
 Copy FP to another FP
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP instance to be copied |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP instance to be copied |
 
-<a name="FP+cswap"></a>
+<a name="FP+cswap" />
 
 ### fP.cswap()
+
 Conditional constant time swap of two FP numbers
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{BIG}</code>  
+**this**: <code>{"{"}BIG{"}"}</code>  
 **Parameter**: b FP number  
 **Parameter**: d Integer  
-<a name="FP+cmove"></a>
+<a name="FP+cmove" />
 
 ### fP.cmove(g, d)
+
 Conditional copy of FP number
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP instance                |
+| d     | copy depends on this value |
 
-<a name="FP+nres"></a>
+<a name="FP+nres" />
 
 ### fP.nres()
+
 Converts from BIG integer to residue form mod Modulus
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+redc"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+redc" />
 
 ### fP.redc()
+
 Converts from residue form back to BIG integer form
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+toString"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+toString" />
 
 ### fP.toString()
+
 convert to hex string
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+iszilch"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+iszilch" />
 
 ### fP.iszilch()
+
 Tests for FP equal to zero
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+reduce"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+reduce" />
 
 ### fP.reduce()
+
 Reduces all components of possibly unreduced FP mod Modulus
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+one"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+one" />
 
 ### fP.one()
+
 Set FP to unity
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+norm"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+norm" />
 
 ### fP.norm()
+
 Normalises the components of an FP
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+mul"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+mul" />
 
 ### fP.mul(b)
+
 Fast Modular multiplication of two FPs, mod Modulus
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | FP number, the multiplier |
+| Param | Description               |
+| ----- | ------------------------- |
+| b     | FP number, the multiplier |
 
-<a name="FP+imul"></a>
+<a name="FP+imul" />
 
 ### fP.imul(s)
+
 Multiplication of an FP by a small integer
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | integer |
+| ----- | ----------- |
+| s     | integer     |
 
-<a name="FP+sqr"></a>
+<a name="FP+sqr" />
 
 ### fP.sqr()
+
 Fast Squaring of an FP
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+neg"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+neg" />
 
 ### fP.neg(x)
+
 negate this
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP instance to be set to one |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| x     | FP instance to be set to one |
 
-<a name="FP+sub"></a>
+<a name="FP+sub" />
 
 ### fP.sub(x)
+
 subtraction of two FPs
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| x | FP instance |
+| ----- | ----------- |
+| x     | FP instance |
 
-<a name="FP+div2"></a>
+<a name="FP+div2" />
 
 ### fP.div2()
+
 Divide an FP by 2
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+fpow"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+fpow" />
 
 ### fP.fpow()
+
 return this^(p-3)/4 or this^(p-5)/8
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+inverse"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+inverse" />
 
 ### fP.inverse()
+
 Inverting an FP
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+equals"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+equals" />
 
 ### fP.equals(x)
+
 Tests for equality of two FP instances
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP instance to compare |
+| Param | Description            |
+| ----- | ---------------------- |
+| x     | FP instance to compare |
 
-<a name="FP+pow"></a>
+<a name="FP+pow" />
 
 ### fP.pow(e)
+
 Raises an FP to the power of a BIG
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP+jacobi"></a>
+<a name="FP+jacobi" />
 
 ### fP.jacobi()
+
 return jacobi symbol (this/Modulus)
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP+sqrt"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP+sqrt" />
 
 ### fP.sqrt()
+
 Fast Modular square root of a an FP, mod Modulus
 
 **Kind**: instance method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
-<a name="FP.mod"></a>
+**this**: <code>{"{"}FP{"}"}</code>  
+<a name="FP.mod" />
 
 ### FP.mod()
+
 reduce a ctx.DBIG to a ctx.BIG using a "special" modulus
 
 **Kind**: static method of [<code>FP</code>](#FP)  
-**this**: <code>{FP}</code>  
+**this**: <code>{"{"}FP{"}"}</code>  
diff --git a/docs/cryptojs/fp12.md b/docs/cryptojs/fp12.md
index 59e56a9..c7efb56 100644
--- a/docs/cryptojs/fp12.md
+++ b/docs/cryptojs/fp12.md
@@ -3,356 +3,389 @@
 title: FP12
 sidebar_label: FP12
 ---
-
-<a name="FP12"></a>
+<a name="FP12" />
 
 ## FP12
+
 **Kind**: global class  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-* [FP12](#FP12)
-    * [new FP12()](#new_FP12_new)
-    * _instance_
-        * [.reduce()](#FP12+reduce)
-        * [.norm()](#FP12+norm)
-        * [.iszilch()](#FP12+iszilch)
-        * [.isunity()](#FP12+isunity)
-        * [.cmove(g, d)](#FP12+cmove)
-        * [.select()](#FP12+select)
-        * [.geta()](#FP12+geta)
-        * [.getb()](#FP12+getb)
-        * [.getc()](#FP12+getc)
-        * [.equals(x)](#FP12+equals)
-        * [.copy(x)](#FP12+copy)
-        * [.one(x)](#FP12+one)
-        * [.zero()](#FP12+zero)
-        * [.conj()](#FP12+conj)
-        * [.set(d, e, f)](#FP12+set)
-        * [.seta(d)](#FP12+seta)
-        * [.usqr()](#FP12+usqr)
-        * [.sqr()](#FP12+sqr)
-        * [.mul(y)](#FP12+mul)
-        * [.smul(y)](#FP12+smul)
-        * [.ssmul(y)](#FP12+ssmul)
-        * [.inverse()](#FP12+inverse)
-        * [.frob(f)](#FP12+frob)
-        * [.trace()](#FP12+trace)
-        * [.toString()](#FP12+toString)
-        * [.toBytes(w)](#FP12+toBytes)
-        * [.pow(e)](#FP12+pow)
-        * [.pinpow(e, bts)](#FP12+pinpow)
-        * [.compow(e, r)](#FP12+compow)
-    * _static_
-        * [.fromBytes(w)](#FP12.fromBytes)
-        * [.teq()](#FP12.teq)
-        * [.pow4()](#FP12.pow4)
+-   [FP12](#FP12)
+    -   [new FP12()](#new_FP12_new)
+    -   _instance_
+        -   [.reduce()](#FP12+reduce)
+        -   [.norm()](#FP12+norm)
+        -   [.iszilch()](#FP12+iszilch)
+        -   [.isunity()](#FP12+isunity)
+        -   [.cmove(g, d)](#FP12+cmove)
+        -   [.select()](#FP12+select)
+        -   [.geta()](#FP12+geta)
+        -   [.getb()](#FP12+getb)
+        -   [.getc()](#FP12+getc)
+        -   [.equals(x)](#FP12+equals)
+        -   [.copy(x)](#FP12+copy)
+        -   [.one(x)](#FP12+one)
+        -   [.zero()](#FP12+zero)
+        -   [.conj()](#FP12+conj)
+        -   [.set(d, e, f)](#FP12+set)
+        -   [.seta(d)](#FP12+seta)
+        -   [.usqr()](#FP12+usqr)
+        -   [.sqr()](#FP12+sqr)
+        -   [.mul(y)](#FP12+mul)
+        -   [.smul(y)](#FP12+smul)
+        -   [.ssmul(y)](#FP12+ssmul)
+        -   [.inverse()](#FP12+inverse)
+        -   [.frob(f)](#FP12+frob)
+        -   [.trace()](#FP12+trace)
+        -   [.toString()](#FP12+toString)
+        -   [.toBytes(w)](#FP12+toBytes)
+        -   [.pow(e)](#FP12+pow)
+        -   [.pinpow(e, bts)](#FP12+pinpow)
+        -   [.compow(e, r)](#FP12+compow)
+    -   _static_
+        -   [.fromBytes(w)](#FP12.fromBytes)
+        -   [.teq()](#FP12.teq)
+        -   [.pow4()](#FP12.pow4)
 
-<a name="new_FP12_new"></a>
+<a name="new_FP12_new" />
 
 ### new FP12()
+
 Creates an instance of FP12.
 
-<a name="FP12+reduce"></a>
+<a name="FP12+reduce" />
 
 ### fP12.reduce()
+
 Reduces all components of possibly unreduced FP12 mod Modulus
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+norm"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+norm" />
 
 ### fP12.norm()
+
 Normalises the components of an FP12
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+iszilch"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+iszilch" />
 
 ### fP12.iszilch()
+
 Tests for FP12 equal to zero
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+isunity"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+isunity" />
 
 ### fP12.isunity()
+
 Tests for FP12 equal to unity
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+cmove"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+cmove" />
 
 ### fP12.cmove(g, d)
+
 Conditional copy of FP12 number
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP12 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP12 instance              |
+| d     | copy depends on this value |
 
-<a name="FP12+select"></a>
+<a name="FP12+select" />
 
 ### fP12.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+geta"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+geta" />
 
 ### fP12.geta()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+getb"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+getb" />
 
 ### fP12.getb()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+getc"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+getc" />
 
 ### fP12.getc()
+
 extract c from this
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+equals"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+equals" />
 
 ### fP12.equals(x)
+
 Tests for equality of two FP12s
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP12 instance to compare |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP12 instance to compare |
 
-<a name="FP12+copy"></a>
+<a name="FP12+copy" />
 
 ### fP12.copy(x)
+
 Copy FP12 to another FP12
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP12 instance to be copied |
+| Param | Description                |
+| ----- | -------------------------- |
+| x     | FP12 instance to be copied |
 
-<a name="FP12+one"></a>
+<a name="FP12+one" />
 
 ### fP12.one(x)
+
 Set FP12 to unity
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP12 instance to be set to one |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| x     | FP12 instance to be set to one |
 
-<a name="FP12+zero"></a>
+<a name="FP12+zero" />
 
 ### fP12.zero()
+
 Set FP12 to zero
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+conj"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+conj" />
 
 ### fP12.conj()
+
 Conjugation of FP12
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+set"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+set" />
 
 ### fP12.set(d, e, f)
+
 Set FP12 from three FP4 values
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | FP4 instance |
-| e | FP4 instance |
-| f | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| d     | FP4 instance |
+| e     | FP4 instance |
+| f     | FP4 instance |
 
-<a name="FP12+seta"></a>
+<a name="FP12+seta" />
 
 ### fP12.seta(d)
+
 Set FP12 from one FP4 value
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| d     | FP4 instance |
 
-<a name="FP12+usqr"></a>
+<a name="FP12+usqr" />
 
 ### fP12.usqr()
+
 Fast Squaring of an FP12 in "unitary" form
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+sqr"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+sqr" />
 
 ### fP12.sqr()
+
 Fast Squaring of an FP12
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+mul"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+mul" />
 
 ### fP12.mul(y)
+
 Full unconditional Multiplication of two FP12s
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP12 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP12 instance, the multiplier |
 
-<a name="FP12+smul"></a>
+<a name="FP12+smul" />
 
 ### fP12.smul(y)
+
 Fast multiplication of two sparse FP12s that arises from ATE pairing line functions
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP12 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP12 instance, the multiplier |
 
-<a name="FP12+ssmul"></a>
+<a name="FP12+ssmul" />
 
 ### fP12.ssmul(y)
+
 Fast multiplication of what may be sparse multiplicands
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP12 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP12 instance, the multiplier |
 
-<a name="FP12+inverse"></a>
+<a name="FP12+inverse" />
 
 ### fP12.inverse()
+
 Inverting an FP12
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+frob"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+frob" />
 
 ### fP12.frob(f)
+
 Raises an FP12 to the power of the internal modulus p, using the Frobenius
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| f | Modulus |
+| ----- | ----------- |
+| f     | Modulus     |
 
-<a name="FP12+trace"></a>
+<a name="FP12+trace" />
 
 ### fP12.trace()
+
 Calculate the trace of an FP12
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+toString"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+toString" />
 
 ### fP12.toString()
+
 convert this to hex string
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12+toBytes"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12+toBytes" />
 
 ### fP12.toBytes(w)
+
 convert this to byte array
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| w | Byte array |
+| ----- | ----------- |
+| w     | Byte array  |
 
-<a name="FP12+pow"></a>
+<a name="FP12+pow" />
 
 ### fP12.pow(e)
+
 Raises an FP12 to the power of a BIG
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP12+pinpow"></a>
+<a name="FP12+pinpow" />
 
 ### fP12.pinpow(e, bts)
+
 Raises an FP12 instance x to a small integer power, side-channel resistant
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | small integer exponent |
-| bts | maximum number of bits in exponent |
+| Param | Description                        |
+| ----- | ---------------------------------- |
+| e     | small integer exponent             |
+| bts   | maximum number of bits in exponent |
 
-<a name="FP12+compow"></a>
+<a name="FP12+compow" />
 
 ### fP12.compow(e, r)
+
 Raises an FP12 instance to a BIG power, compressed to FP4
 
 **Kind**: instance method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG exponent |
-| r | BIG group order |
+| Param | Description     |
+| ----- | --------------- |
+| e     | BIG exponent    |
+| r     | BIG group order |
 
-<a name="FP12.fromBytes"></a>
+<a name="FP12.fromBytes" />
 
 ### FP12.fromBytes(w)
+
 convert from byte array to FP12
 
 **Kind**: static method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| w | Byte array |
+| ----- | ----------- |
+| w     | Byte array  |
 
-<a name="FP12.teq"></a>
+<a name="FP12.teq" />
 
 ### FP12.teq()
+
 return 1 if b==c, no branching
 
 **Kind**: static method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
-<a name="FP12.pow4"></a>
+**this**: <code>{"{"}FP12{"}"}</code>  
+<a name="FP12.pow4" />
 
 ### FP12.pow4()
+
 p=q0^u0.q1^u1.q2^u2.q3^u3
 
 **Kind**: static method of [<code>FP12</code>](#FP12)  
-**this**: <code>{FP12}</code>  
+**this**: <code>{"{"}FP12{"}"}</code>  
diff --git a/docs/cryptojs/fp16.md b/docs/cryptojs/fp16.md
index a638215..ec185b5 100644
--- a/docs/cryptojs/fp16.md
+++ b/docs/cryptojs/fp16.md
@@ -3,390 +3,427 @@
 title: FP16
 sidebar_label: FP16
 ---
-
-<a name="FP16"></a>
+<a name="FP16" />
 
 ## FP16
+
 **Kind**: global class  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-* [FP16](#FP16)
-    * [new FP16()](#new_FP16_new)
-    * [.reduce()](#FP16+reduce)
-    * [.norm()](#FP16+norm)
-    * [.iszilch()](#FP16+iszilch)
-    * [.isunity()](#FP16+isunity)
-    * [.cmove(g, d)](#FP16+cmove)
-    * [.isreal()](#FP16+isreal)
-    * [.real()](#FP16+real)
-    * [.geta()](#FP16+geta)
-    * [.getb()](#FP16+getb)
-    * [.equals(x)](#FP16+equals)
-    * [.copy(x)](#FP16+copy)
-    * [.zero()](#FP16+zero)
-    * [.one(x)](#FP16+one)
-    * [.set(c, d)](#FP16+set)
-    * [.seta(c)](#FP16+seta)
-    * [.neg()](#FP16+neg)
-    * [.conj()](#FP16+conj)
-    * [.nconj()](#FP16+nconj)
-    * [.add(x)](#FP16+add)
-    * [.sub(x)](#FP16+sub)
-    * [.pmul(s)](#FP16+pmul)
-    * [.qmul(s)](#FP16+qmul)
-    * [.imul(s)](#FP16+imul)
-    * [.sqr()](#FP16+sqr)
-    * [.mul(y)](#FP16+mul)
-    * [.toString()](#FP16+toString)
-    * [.inverse()](#FP16+inverse)
-    * [.times_i()](#FP16+times_i)
-    * [.times_i2()](#FP16+times_i2)
-    * [.times_i4()](#FP16+times_i4)
-    * [.frob(f)](#FP16+frob)
-    * [.pow(e)](#FP16+pow)
-    * [.xtr_A(w, y, z)](#FP16+xtr_A)
-    * [.xtr_D()](#FP16+xtr_D)
-    * [.xtr_pow(n)](#FP16+xtr_pow)
-    * [.xtr_pow2()](#FP16+xtr_pow2)
+-   [FP16](#FP16)
+    -   [new FP16()](#new_FP16_new)
+    -   [.reduce()](#FP16+reduce)
+    -   [.norm()](#FP16+norm)
+    -   [.iszilch()](#FP16+iszilch)
+    -   [.isunity()](#FP16+isunity)
+    -   [.cmove(g, d)](#FP16+cmove)
+    -   [.isreal()](#FP16+isreal)
+    -   [.real()](#FP16+real)
+    -   [.geta()](#FP16+geta)
+    -   [.getb()](#FP16+getb)
+    -   [.equals(x)](#FP16+equals)
+    -   [.copy(x)](#FP16+copy)
+    -   [.zero()](#FP16+zero)
+    -   [.one(x)](#FP16+one)
+    -   [.set(c, d)](#FP16+set)
+    -   [.seta(c)](#FP16+seta)
+    -   [.neg()](#FP16+neg)
+    -   [.conj()](#FP16+conj)
+    -   [.nconj()](#FP16+nconj)
+    -   [.add(x)](#FP16+add)
+    -   [.sub(x)](#FP16+sub)
+    -   [.pmul(s)](#FP16+pmul)
+    -   [.qmul(s)](#FP16+qmul)
+    -   [.imul(s)](#FP16+imul)
+    -   [.sqr()](#FP16+sqr)
+    -   [.mul(y)](#FP16+mul)
+    -   [.toString()](#FP16+toString)
+    -   [.inverse()](#FP16+inverse)
+    -   [.times_i()](#FP16+times_i)
+    -   [.times_i2()](#FP16+times_i2)
+    -   [.times_i4()](#FP16+times_i4)
+    -   [.frob(f)](#FP16+frob)
+    -   [.pow(e)](#FP16+pow)
+    -   [.xtr_A(w, y, z)](#FP16+xtr_A)
+    -   [.xtr_D()](#FP16+xtr_D)
+    -   [.xtr_pow(n)](#FP16+xtr_pow)
+    -   [.xtr_pow2()](#FP16+xtr_pow2)
 
-<a name="new_FP16_new"></a>
+<a name="new_FP16_new" />
 
 ### new FP16()
+
 Creates an instance of FP16.
 
-<a name="FP16+reduce"></a>
+<a name="FP16+reduce" />
 
 ### fP16.reduce()
+
 Reduces all components of possibly unreduced FP16 mod Modulus
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+norm"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+norm" />
 
 ### fP16.norm()
+
 Normalises the components of an FP16
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+iszilch"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+iszilch" />
 
 ### fP16.iszilch()
+
 Tests for FP16 equal to zero
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+isunity"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+isunity" />
 
 ### fP16.isunity()
+
 Tests for FP16 equal to unity
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+cmove"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+cmove" />
 
 ### fP16.cmove(g, d)
+
 Conditional copy of FP16 number
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP16 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP16 instance              |
+| d     | copy depends on this value |
 
-<a name="FP16+isreal"></a>
+<a name="FP16+isreal" />
 
 ### fP16.isreal()
+
 test is w real? That is in a+ib test b is zero
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+real"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+real" />
 
 ### fP16.real()
+
 extract real part a
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+geta"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+geta" />
 
 ### fP16.geta()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+getb"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+getb" />
 
 ### fP16.getb()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+equals"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+equals" />
 
 ### fP16.equals(x)
+
 Tests for equality of two FP16s
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP16 instance to compare |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP16 instance to compare |
 
-<a name="FP16+copy"></a>
+<a name="FP16+copy" />
 
 ### fP16.copy(x)
+
 Copy FP16 to another FP16
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP16 instance to be copied |
+| Param | Description                |
+| ----- | -------------------------- |
+| x     | FP16 instance to be copied |
 
-<a name="FP16+zero"></a>
+<a name="FP16+zero" />
 
 ### fP16.zero()
+
 Set FP16 to zero
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+one"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+one" />
 
 ### fP16.one(x)
+
 Set FP16 to unity
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP16 instance to be set to one |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| x     | FP16 instance to be set to one |
 
-<a name="FP16+set"></a>
+<a name="FP16+set" />
 
 ### fP16.set(c, d)
+
 Set FP16 from two FP8 values
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP8 instance |
-| d | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP8 instance |
+| d     | FP8 instance |
 
-<a name="FP16+seta"></a>
+<a name="FP16+seta" />
 
 ### fP16.seta(c)
+
 Set FP16 from one FP8 value
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP8 instance |
 
-<a name="FP16+neg"></a>
+<a name="FP16+neg" />
 
 ### fP16.neg()
+
 this=-this
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+conj"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+conj" />
 
 ### fP16.conj()
+
 Conjugation of FP16
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+nconj"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+nconj" />
 
 ### fP16.nconj()
+
 Negative conjugation of FP16
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+add"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+add" />
 
 ### fP16.add(x)
+
 addition of two FP16s
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP16 instance |
+| Param | Description   |
+| ----- | ------------- |
+| x     | FP16 instance |
 
-<a name="FP16+sub"></a>
+<a name="FP16+sub" />
 
 ### fP16.sub(x)
+
 subtraction of two FP16s
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP16 instance |
+| Param | Description   |
+| ----- | ------------- |
+| x     | FP16 instance |
 
-<a name="FP16+pmul"></a>
+<a name="FP16+pmul" />
 
 ### fP16.pmul(s)
+
 Multiplication of an FP16 by an FP8
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| s     | FP8 instance |
 
-<a name="FP16+qmul"></a>
+<a name="FP16+qmul" />
 
 ### fP16.qmul(s)
+
 Multiplication of an FP16 by an FP2
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP2 instance |
+| Param | Description  |
+| ----- | ------------ |
+| s     | FP2 instance |
 
-<a name="FP16+imul"></a>
+<a name="FP16+imul" />
 
 ### fP16.imul(s)
+
 Multiplication of an FP16 by a small integer
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | integer |
+| ----- | ----------- |
+| s     | integer     |
 
-<a name="FP16+sqr"></a>
+<a name="FP16+sqr" />
 
 ### fP16.sqr()
+
 Fast Squaring of an FP16
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+mul"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+mul" />
 
 ### fP16.mul(y)
+
 Full unconditional Multiplication of two FP16s
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP16 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP16 instance, the multiplier |
 
-<a name="FP16+toString"></a>
+<a name="FP16+toString" />
 
 ### fP16.toString()
+
 convert this to hex string
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+inverse"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+inverse" />
 
 ### fP16.inverse()
+
 Inverting an FP16
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+times_i"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+times_i" />
 
-### fP16.times\_i()
+### fP16.times_i()
+
 multiplies an FP16 instance by irreducible polynomial sqrt(1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+times_i2"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+times_i2" />
 
-### fP16.times\_i2()
+### fP16.times_i2()
+
 multiplies an FP16 instance by irreducible polynomial (1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+times_i4"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+times_i4" />
 
-### fP16.times\_i4()
+### fP16.times_i4()
+
 multiplies an FP16 instance by irreducible polynomial (1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+frob"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+frob" />
 
 ### fP16.frob(f)
+
 Raises an FP16 to the power of the internal modulus p, using the Frobenius
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| f | Modulus |
+| ----- | ----------- |
+| f     | Modulus     |
 
-<a name="FP16+pow"></a>
+<a name="FP16+pow" />
 
 ### fP16.pow(e)
+
 Raises an FP16 to the power of a BIG
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP16+xtr_A"></a>
+<a name="FP16+xtr_A" />
 
-### fP16.xtr\_A(w, y, z)
-Calculates the XTR addition function r=w*x-conj(x)*y+z
+### fP16.xtr_A(w, y, z)
+
+Calculates the XTR addition function r=w_x-conj(x)_y+z
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| w | FP16 instance |
-| y | FP16 instance |
-| z | FP16 instance |
+| Param | Description   |
+| ----- | ------------- |
+| w     | FP16 instance |
+| y     | FP16 instance |
+| z     | FP16 instance |
 
-<a name="FP16+xtr_D"></a>
+<a name="FP16+xtr_D" />
 
-### fP16.xtr\_D()
-Calculates the XTR doubling function r=x^2-2*conj(x)
+### fP16.xtr_D()
+
+Calculates the XTR doubling function r=x^2-2\*conj(x)
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
-<a name="FP16+xtr_pow"></a>
+**this**: <code>{"{"}FP16{"}"}</code>  
+<a name="FP16+xtr_pow" />
 
-### fP16.xtr\_pow(n)
+### fP16.xtr_pow(n)
+
 Calculates FP16 trace of an FP16 raised to the power of a BIG number
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| n | Big number |
+| ----- | ----------- |
+| n     | Big number  |
 
-<a name="FP16+xtr_pow2"></a>
+<a name="FP16+xtr_pow2" />
 
-### fP16.xtr\_pow2()
+### fP16.xtr_pow2()
+
 Calculates FP16 trace of c^a.d^b, where c and d are derived from FP16 traces of FP16s
 
 **Kind**: instance method of [<code>FP16</code>](#FP16)  
-**this**: <code>{FP16}</code>  
+**this**: <code>{"{"}FP16{"}"}</code>  
diff --git a/docs/cryptojs/fp2.md b/docs/cryptojs/fp2.md
index 3ecdb68..d955ec9 100644
--- a/docs/cryptojs/fp2.md
+++ b/docs/cryptojs/fp2.md
@@ -3,353 +3,385 @@
 title: FP2
 sidebar_label: FP2
 ---
-
-<a name="FP2"></a>
+<a name="FP2" />
 
 ## FP2
+
 **Kind**: global class  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-* [FP2](#FP2)
-    * [new FP2()](#new_FP2_new)
-    * [.reduce()](#FP2+reduce)
-    * [.norm()](#FP2+norm)
-    * [.iszilch()](#FP2+iszilch)
-    * [.isunity()](#FP2+isunity)
-    * [.cmove(g, d)](#FP2+cmove)
-    * [.equals(x)](#FP2+equals)
-    * [.getA()](#FP2+getA)
-    * [.getB()](#FP2+getB)
-    * [.set(c, d)](#FP2+set)
-    * [.seta(c)](#FP2+seta)
-    * [.bset(c, d)](#FP2+bset)
-    * [.bseta(c)](#FP2+bseta)
-    * [.copy(x)](#FP2+copy)
-    * [.zero()](#FP2+zero)
-    * [.one(x)](#FP2+one)
-    * [.neg(x)](#FP2+neg)
-    * [.conj()](#FP2+conj)
-    * [.add(x)](#FP2+add)
-    * [.sub(x)](#FP2+sub)
-    * [.pmul(s)](#FP2+pmul)
-    * [.imul(s)](#FP2+imul)
-    * [.sqr()](#FP2+sqr)
-    * [.mul(y)](#FP2+mul)
-    * [.sqrt()](#FP2+sqrt) ⇒
-    * [.toString()](#FP2+toString)
-    * [.inverse()](#FP2+inverse)
-    * [.div2()](#FP2+div2)
-    * [.times_i()](#FP2+times_i)
-    * [.mul_ip()](#FP2+mul_ip)
-    * [.div_ip2()](#FP2+div_ip2)
-    * [.div_ip()](#FP2+div_ip)
-    * [.pow(e)](#FP2+pow)
+-   [FP2](#FP2)
+    -   [new FP2()](#new_FP2_new)
+    -   [.reduce()](#FP2+reduce)
+    -   [.norm()](#FP2+norm)
+    -   [.iszilch()](#FP2+iszilch)
+    -   [.isunity()](#FP2+isunity)
+    -   [.cmove(g, d)](#FP2+cmove)
+    -   [.equals(x)](#FP2+equals)
+    -   [.getA()](#FP2+getA)
+    -   [.getB()](#FP2+getB)
+    -   [.set(c, d)](#FP2+set)
+    -   [.seta(c)](#FP2+seta)
+    -   [.bset(c, d)](#FP2+bset)
+    -   [.bseta(c)](#FP2+bseta)
+    -   [.copy(x)](#FP2+copy)
+    -   [.zero()](#FP2+zero)
+    -   [.one(x)](#FP2+one)
+    -   [.neg(x)](#FP2+neg)
+    -   [.conj()](#FP2+conj)
+    -   [.add(x)](#FP2+add)
+    -   [.sub(x)](#FP2+sub)
+    -   [.pmul(s)](#FP2+pmul)
+    -   [.imul(s)](#FP2+imul)
+    -   [.sqr()](#FP2+sqr)
+    -   [.mul(y)](#FP2+mul)
+    -   [.sqrt()](#FP2+sqrt) ⇒
+    -   [.toString()](#FP2+toString)
+    -   [.inverse()](#FP2+inverse)
+    -   [.div2()](#FP2+div2)
+    -   [.times_i()](#FP2+times_i)
+    -   [.mul_ip()](#FP2+mul_ip)
+    -   [.div_ip2()](#FP2+div_ip2)
+    -   [.div_ip()](#FP2+div_ip)
+    -   [.pow(e)](#FP2+pow)
 
-<a name="new_FP2_new"></a>
+<a name="new_FP2_new" />
 
 ### new FP2()
+
 Creates an instance of FP2.
 
-<a name="FP2+reduce"></a>
+<a name="FP2+reduce" />
 
 ### fP2.reduce()
+
 Reduces all components of possibly unreduced FP2 mod Modulus
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+norm"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+norm" />
 
 ### fP2.norm()
+
 Normalises the components of an FP2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+iszilch"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+iszilch" />
 
 ### fP2.iszilch()
+
 Tests for FP2 equal to zero
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+isunity"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+isunity" />
 
 ### fP2.isunity()
+
 Tests for FP2 equal to unity
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+cmove"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+cmove" />
 
 ### fP2.cmove(g, d)
+
 Conditional copy of FP2 number
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP2 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP2 instance               |
+| d     | copy depends on this value |
 
-<a name="FP2+equals"></a>
+<a name="FP2+equals" />
 
 ### fP2.equals(x)
+
 Tests for equality of two FP2 instances
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP2 instance to compare |
+| Param | Description             |
+| ----- | ----------------------- |
+| x     | FP2 instance to compare |
 
-<a name="FP2+getA"></a>
+<a name="FP2+getA" />
 
 ### fP2.getA()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+getB"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+getB" />
 
 ### fP2.getB()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+set"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+set" />
 
 ### fP2.set(c, d)
+
 Set FP2 from two FP values
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| c | FP instance |
-| d | FP instance |
+| ----- | ----------- |
+| c     | FP instance |
+| d     | FP instance |
 
-<a name="FP2+seta"></a>
+<a name="FP2+seta" />
 
 ### fP2.seta(c)
+
 Set FP2 from one FP value
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| c | FP instance |
+| ----- | ----------- |
+| c     | FP instance |
 
-<a name="FP2+bset"></a>
+<a name="FP2+bset" />
 
 ### fP2.bset(c, d)
+
 Set FP2 from two BIG values
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | BIG instance |
-| d | BIG instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | BIG instance |
+| d     | BIG instance |
 
-<a name="FP2+bseta"></a>
+<a name="FP2+bseta" />
 
 ### fP2.bseta(c)
+
 Set FP2 from one BIG value
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | BIG instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | BIG instance |
 
-<a name="FP2+copy"></a>
+<a name="FP2+copy" />
 
 ### fP2.copy(x)
+
 Copy FP2 to another FP2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP2 instance to be copied |
+| Param | Description               |
+| ----- | ------------------------- |
+| x     | FP2 instance to be copied |
 
-<a name="FP2+zero"></a>
+<a name="FP2+zero" />
 
 ### fP2.zero()
+
 Set FP2 to zero
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+one"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+one" />
 
 ### fP2.one(x)
+
 Set FP2 to unity
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP2 instance to be set to one |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| x     | FP2 instance to be set to one |
 
-<a name="FP2+neg"></a>
+<a name="FP2+neg" />
 
 ### fP2.neg(x)
+
 negate this
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP2 instance to be set to one |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| x     | FP2 instance to be set to one |
 
-<a name="FP2+conj"></a>
+<a name="FP2+conj" />
 
 ### fP2.conj()
+
 Conjugation of FP2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+add"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+add" />
 
 ### fP2.add(x)
+
 addition of two FP2s
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP2 instance |
+| Param | Description  |
+| ----- | ------------ |
+| x     | FP2 instance |
 
-<a name="FP2+sub"></a>
+<a name="FP2+sub" />
 
 ### fP2.sub(x)
+
 subtraction of two FP2s
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP2 instance |
+| Param | Description  |
+| ----- | ------------ |
+| x     | FP2 instance |
 
-<a name="FP2+pmul"></a>
+<a name="FP2+pmul" />
 
 ### fP2.pmul(s)
+
 Multiplication of an FP2 by an FP8
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| s     | FP8 instance |
 
-<a name="FP2+imul"></a>
+<a name="FP2+imul" />
 
 ### fP2.imul(s)
+
 Multiplication of an FP2 by a small integer
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | integer |
+| ----- | ----------- |
+| s     | integer     |
 
-<a name="FP2+sqr"></a>
+<a name="FP2+sqr" />
 
 ### fP2.sqr()
+
 Fast Squaring of an FP2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+mul"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+mul" />
 
 ### fP2.mul(y)
+
 Full unconditional Multiplication of two FP2s
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP2 instance, the multiplier |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| y     | FP2 instance, the multiplier |
 
-<a name="FP2+sqrt"></a>
+<a name="FP2+sqrt" />
 
 ### fP2.sqrt() ⇒
-sqrt(a+ib) = sqrt(a+sqrt(a*a-n*b*b)/2)+ib/(2*sqrt(a+sqrt(a*a-n*b*b)/2))
+
+sqrt(a+ib) = sqrt(a+sqrt(a_a-n_b_b)/2)+ib/(2_sqrt(a+sqrt(a_a-n_b\*b)/2))
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
 **Returns**: true if this is QR  
-**this**: <code>{FP2}</code>  
-<a name="FP2+toString"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+toString" />
 
 ### fP2.toString()
+
 convert this to hex string
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+inverse"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+inverse" />
 
 ### fP2.inverse()
+
 Inverting an FP2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+div2"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+div2" />
 
 ### fP2.div2()
+
 Divide an FP2 by 2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+times_i"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+times_i" />
 
-### fP2.times\_i()
+### fP2.times_i()
+
 Multiply an FP2 by sqrt(-1)
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+mul_ip"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+mul_ip" />
 
-### fP2.mul\_ip()
+### fP2.mul_ip()
+
 Multiply an FP2 by (1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+div_ip2"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+div_ip2" />
 
-### fP2.div\_ip2()
+### fP2.div_ip2()
+
 Divide an FP2 by (1+sqrt(-1))/2
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+div_ip"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+div_ip" />
 
-### fP2.div\_ip()
+### fP2.div_ip()
+
 Divide an FP2 by (1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
-<a name="FP2+pow"></a>
+**this**: <code>{"{"}FP2{"}"}</code>  
+<a name="FP2+pow" />
 
 ### fP2.pow(e)
+
 Raises an FP2 to the power of a BIG
 
 **Kind**: instance method of [<code>FP2</code>](#FP2)  
-**this**: <code>{FP2}</code>  
+**this**: <code>{"{"}FP2{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
-
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
diff --git a/docs/cryptojs/fp24.md b/docs/cryptojs/fp24.md
index 8db0545..5255b6a 100644
--- a/docs/cryptojs/fp24.md
+++ b/docs/cryptojs/fp24.md
@@ -3,356 +3,389 @@
 title: FP24
 sidebar_label: FP24
 ---
-
-<a name="FP24"></a>
+<a name="FP24" />
 
 ## FP24
+
 **Kind**: global class  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-* [FP24](#FP24)
-    * [new FP24()](#new_FP24_new)
-    * _instance_
-        * [.reduce()](#FP24+reduce)
-        * [.norm()](#FP24+norm)
-        * [.iszilch()](#FP24+iszilch)
-        * [.isunity()](#FP24+isunity)
-        * [.cmove(g, d)](#FP24+cmove)
-        * [.select()](#FP24+select)
-        * [.geta()](#FP24+geta)
-        * [.getb()](#FP24+getb)
-        * [.getc()](#FP24+getc)
-        * [.equals(x)](#FP24+equals)
-        * [.copy(x)](#FP24+copy)
-        * [.one(x)](#FP24+one)
-        * [.zero()](#FP24+zero)
-        * [.conj()](#FP24+conj)
-        * [.set(d, e, f)](#FP24+set)
-        * [.seta(c)](#FP24+seta)
-        * [.usqr()](#FP24+usqr)
-        * [.sqr()](#FP24+sqr)
-        * [.mul(y)](#FP24+mul)
-        * [.smul(y)](#FP24+smul)
-        * [.ssmul(y)](#FP24+ssmul)
-        * [.inverse()](#FP24+inverse)
-        * [.frob(f)](#FP24+frob)
-        * [.trace()](#FP24+trace)
-        * [.toString()](#FP24+toString)
-        * [.toBytes(w)](#FP24+toBytes)
-        * [.pow(e)](#FP24+pow)
-        * [.pinpow(e, bts)](#FP24+pinpow)
-        * [.compow(e, r)](#FP24+compow)
-    * _static_
-        * [.fromBytes(w)](#FP24.fromBytes)
-        * [.teq()](#FP24.teq)
-        * [.pow8()](#FP24.pow8)
+-   [FP24](#FP24)
+    -   [new FP24()](#new_FP24_new)
+    -   _instance_
+        -   [.reduce()](#FP24+reduce)
+        -   [.norm()](#FP24+norm)
+        -   [.iszilch()](#FP24+iszilch)
+        -   [.isunity()](#FP24+isunity)
+        -   [.cmove(g, d)](#FP24+cmove)
+        -   [.select()](#FP24+select)
+        -   [.geta()](#FP24+geta)
+        -   [.getb()](#FP24+getb)
+        -   [.getc()](#FP24+getc)
+        -   [.equals(x)](#FP24+equals)
+        -   [.copy(x)](#FP24+copy)
+        -   [.one(x)](#FP24+one)
+        -   [.zero()](#FP24+zero)
+        -   [.conj()](#FP24+conj)
+        -   [.set(d, e, f)](#FP24+set)
+        -   [.seta(c)](#FP24+seta)
+        -   [.usqr()](#FP24+usqr)
+        -   [.sqr()](#FP24+sqr)
+        -   [.mul(y)](#FP24+mul)
+        -   [.smul(y)](#FP24+smul)
+        -   [.ssmul(y)](#FP24+ssmul)
+        -   [.inverse()](#FP24+inverse)
+        -   [.frob(f)](#FP24+frob)
+        -   [.trace()](#FP24+trace)
+        -   [.toString()](#FP24+toString)
+        -   [.toBytes(w)](#FP24+toBytes)
+        -   [.pow(e)](#FP24+pow)
+        -   [.pinpow(e, bts)](#FP24+pinpow)
+        -   [.compow(e, r)](#FP24+compow)
+    -   _static_
+        -   [.fromBytes(w)](#FP24.fromBytes)
+        -   [.teq()](#FP24.teq)
+        -   [.pow8()](#FP24.pow8)
 
-<a name="new_FP24_new"></a>
+<a name="new_FP24_new" />
 
 ### new FP24()
+
 Creates an instance of FP24.
 
-<a name="FP24+reduce"></a>
+<a name="FP24+reduce" />
 
 ### fP24.reduce()
+
 Reduces all components of possibly unreduced FP24 mod Modulus
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+norm"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+norm" />
 
 ### fP24.norm()
+
 Normalises the components of an FP24
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+iszilch"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+iszilch" />
 
 ### fP24.iszilch()
+
 Tests for FP24 equal to zero
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+isunity"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+isunity" />
 
 ### fP24.isunity()
+
 Tests for FP24 equal to unity
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+cmove"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+cmove" />
 
 ### fP24.cmove(g, d)
+
 Conditional copy of FP24 number
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP24 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP24 instance              |
+| d     | copy depends on this value |
 
-<a name="FP24+select"></a>
+<a name="FP24+select" />
 
 ### fP24.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+geta"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+geta" />
 
 ### fP24.geta()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+getb"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+getb" />
 
 ### fP24.getb()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+getc"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+getc" />
 
 ### fP24.getc()
+
 extract c from this
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+equals"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+equals" />
 
 ### fP24.equals(x)
+
 Tests for equality of two FP24s
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP24 instance to compare |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP24 instance to compare |
 
-<a name="FP24+copy"></a>
+<a name="FP24+copy" />
 
 ### fP24.copy(x)
+
 Copy FP24 to another FP24
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP24 instance to be copied |
+| Param | Description                |
+| ----- | -------------------------- |
+| x     | FP24 instance to be copied |
 
-<a name="FP24+one"></a>
+<a name="FP24+one" />
 
 ### fP24.one(x)
+
 Set FP24 to unity
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP24 instance to be set to one |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| x     | FP24 instance to be set to one |
 
-<a name="FP24+zero"></a>
+<a name="FP24+zero" />
 
 ### fP24.zero()
+
 Set FP24 to zero
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+conj"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+conj" />
 
 ### fP24.conj()
+
 Conjugation of FP24
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+set"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+set" />
 
 ### fP24.set(d, e, f)
+
 Set FP24 from three FP8 values
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | FP8 instance |
-| e | FP8 instance |
-| f | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| d     | FP8 instance |
+| e     | FP8 instance |
+| f     | FP8 instance |
 
-<a name="FP24+seta"></a>
+<a name="FP24+seta" />
 
 ### fP24.seta(c)
+
 Set FP24 from one FP8 value
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP8 instance |
 
-<a name="FP24+usqr"></a>
+<a name="FP24+usqr" />
 
 ### fP24.usqr()
+
 Fast Squaring of an FP24 in "unitary" form
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+sqr"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+sqr" />
 
 ### fP24.sqr()
+
 Fast Squaring of an FP24
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+mul"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+mul" />
 
 ### fP24.mul(y)
+
 Full unconditional Multiplication of two FP24s
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP24 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP24 instance, the multiplier |
 
-<a name="FP24+smul"></a>
+<a name="FP24+smul" />
 
 ### fP24.smul(y)
+
 Fast multiplication of two sparse FP24s that arises from ATE pairing line functions
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP24 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP24 instance, the multiplier |
 
-<a name="FP24+ssmul"></a>
+<a name="FP24+ssmul" />
 
 ### fP24.ssmul(y)
+
 Fast multiplication of what may be sparse multiplicands
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP24 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP24 instance, the multiplier |
 
-<a name="FP24+inverse"></a>
+<a name="FP24+inverse" />
 
 ### fP24.inverse()
+
 Inverting an FP24
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+frob"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+frob" />
 
 ### fP24.frob(f)
+
 Raises an FP24 to the power of the internal modulus p, using the Frobenius
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| f | Modulus |
+| ----- | ----------- |
+| f     | Modulus     |
 
-<a name="FP24+trace"></a>
+<a name="FP24+trace" />
 
 ### fP24.trace()
+
 Calculate the trace of an FP24
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+toString"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+toString" />
 
 ### fP24.toString()
+
 convert this to hex string
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24+toBytes"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24+toBytes" />
 
 ### fP24.toBytes(w)
+
 convert this to byte array
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| w | Byte array |
+| ----- | ----------- |
+| w     | Byte array  |
 
-<a name="FP24+pow"></a>
+<a name="FP24+pow" />
 
 ### fP24.pow(e)
+
 Raises an FP24 to the power of a BIG
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP24+pinpow"></a>
+<a name="FP24+pinpow" />
 
 ### fP24.pinpow(e, bts)
+
 Raises an FP24 instance x to a small integer power, side-channel resistant
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | small integer exponent |
-| bts | maximum number of bits in exponent |
+| Param | Description                        |
+| ----- | ---------------------------------- |
+| e     | small integer exponent             |
+| bts   | maximum number of bits in exponent |
 
-<a name="FP24+compow"></a>
+<a name="FP24+compow" />
 
 ### fP24.compow(e, r)
+
 Raises an FP24 instance to a BIG power, compressed to FP4
 
 **Kind**: instance method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG exponent |
-| r | BIG group order |
+| Param | Description     |
+| ----- | --------------- |
+| e     | BIG exponent    |
+| r     | BIG group order |
 
-<a name="FP24.fromBytes"></a>
+<a name="FP24.fromBytes" />
 
 ### FP24.fromBytes(w)
+
 convert from byte array to FP24
 
 **Kind**: static method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| w | Byte array |
+| ----- | ----------- |
+| w     | Byte array  |
 
-<a name="FP24.teq"></a>
+<a name="FP24.teq" />
 
 ### FP24.teq()
+
 return 1 if b==c, no branching
 
 **Kind**: static method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
-<a name="FP24.pow8"></a>
+**this**: <code>{"{"}FP24{"}"}</code>  
+<a name="FP24.pow8" />
 
 ### FP24.pow8()
+
 p=q0^u0.q1^u1.q2^u2.q3^u3...
 
 **Kind**: static method of [<code>FP24</code>](#FP24)  
-**this**: <code>{FP24}</code>  
+**this**: <code>{"{"}FP24{"}"}</code>  
diff --git a/docs/cryptojs/fp4.md b/docs/cryptojs/fp4.md
index c55177a..a7acd98 100644
--- a/docs/cryptojs/fp4.md
+++ b/docs/cryptojs/fp4.md
@@ -3,406 +3,445 @@
 title: FP4
 sidebar_label: FP4
 ---
-
-<a name="FP4"></a>
+<a name="FP4" />
 
 ## FP4
+
 **Kind**: global class  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-* [FP4](#FP4)
-    * [new FP4()](#new_FP4_new)
-    * [.reduce()](#FP4+reduce)
-    * [.norm()](#FP4+norm)
-    * [.iszilch()](#FP4+iszilch)
-    * [.isunity()](#FP4+isunity)
-    * [.cmove(g, d)](#FP4+cmove)
-    * [.isreal()](#FP4+isreal)
-    * [.real()](#FP4+real)
-    * [.geta()](#FP4+geta)
-    * [.getb()](#FP4+getb)
-    * [.equals(x)](#FP4+equals)
-    * [.copy(x)](#FP4+copy)
-    * [.zero()](#FP4+zero)
-    * [.one(x)](#FP4+one)
-    * [.set(c, d)](#FP4+set)
-    * [.seta(c)](#FP4+seta)
-    * [.neg()](#FP4+neg)
-    * [.conj()](#FP4+conj)
-    * [.nconj()](#FP4+nconj)
-    * [.add(x)](#FP4+add)
-    * [.sub(x)](#FP4+sub)
-    * [.pmul(s)](#FP4+pmul)
-    * [.imul(s)](#FP4+imul)
-    * [.sqr()](#FP4+sqr)
-    * [.mul(y)](#FP4+mul)
-    * [.toString()](#FP4+toString)
-    * [.inverse()](#FP4+inverse)
-    * [.times_i()](#FP4+times_i)
-    * [.frob(f)](#FP4+frob)
-    * [.pow(e)](#FP4+pow)
-    * [.xtr_A(w, y, z)](#FP4+xtr_A)
-    * [.xtr_D()](#FP4+xtr_D)
-    * [.xtr_pow(n)](#FP4+xtr_pow)
-    * [.xtr_pow2()](#FP4+xtr_pow2)
-    * [.div2()](#FP4+div2)
-    * [.div_i()](#FP4+div_i)
-    * [.div_2i()](#FP4+div_2i)
-    * [.qmul(s)](#FP4+qmul)
-    * [.sqrt()](#FP4+sqrt)
+-   [FP4](#FP4)
+    -   [new FP4()](#new_FP4_new)
+    -   [.reduce()](#FP4+reduce)
+    -   [.norm()](#FP4+norm)
+    -   [.iszilch()](#FP4+iszilch)
+    -   [.isunity()](#FP4+isunity)
+    -   [.cmove(g, d)](#FP4+cmove)
+    -   [.isreal()](#FP4+isreal)
+    -   [.real()](#FP4+real)
+    -   [.geta()](#FP4+geta)
+    -   [.getb()](#FP4+getb)
+    -   [.equals(x)](#FP4+equals)
+    -   [.copy(x)](#FP4+copy)
+    -   [.zero()](#FP4+zero)
+    -   [.one(x)](#FP4+one)
+    -   [.set(c, d)](#FP4+set)
+    -   [.seta(c)](#FP4+seta)
+    -   [.neg()](#FP4+neg)
+    -   [.conj()](#FP4+conj)
+    -   [.nconj()](#FP4+nconj)
+    -   [.add(x)](#FP4+add)
+    -   [.sub(x)](#FP4+sub)
+    -   [.pmul(s)](#FP4+pmul)
+    -   [.imul(s)](#FP4+imul)
+    -   [.sqr()](#FP4+sqr)
+    -   [.mul(y)](#FP4+mul)
+    -   [.toString()](#FP4+toString)
+    -   [.inverse()](#FP4+inverse)
+    -   [.times_i()](#FP4+times_i)
+    -   [.frob(f)](#FP4+frob)
+    -   [.pow(e)](#FP4+pow)
+    -   [.xtr_A(w, y, z)](#FP4+xtr_A)
+    -   [.xtr_D()](#FP4+xtr_D)
+    -   [.xtr_pow(n)](#FP4+xtr_pow)
+    -   [.xtr_pow2()](#FP4+xtr_pow2)
+    -   [.div2()](#FP4+div2)
+    -   [.div_i()](#FP4+div_i)
+    -   [.div_2i()](#FP4+div_2i)
+    -   [.qmul(s)](#FP4+qmul)
+    -   [.sqrt()](#FP4+sqrt)
 
-<a name="new_FP4_new"></a>
+<a name="new_FP4_new" />
 
 ### new FP4()
+
 Creates an instance of FP4
 
-<a name="FP4+reduce"></a>
+<a name="FP4+reduce" />
 
 ### fP4.reduce()
+
 Reduces all components of possibly unreduced FP4 mod Modulus
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+norm"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+norm" />
 
 ### fP4.norm()
+
 Normalises the components of an FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+iszilch"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+iszilch" />
 
 ### fP4.iszilch()
+
 Tests for FP4 equal to zero
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+isunity"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+isunity" />
 
 ### fP4.isunity()
+
 Tests for FP4 equal to unity
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+cmove"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+cmove" />
 
 ### fP4.cmove(g, d)
+
 Conditional copy of FP4 number
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP4 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP4 instance               |
+| d     | copy depends on this value |
 
-<a name="FP4+isreal"></a>
+<a name="FP4+isreal" />
 
 ### fP4.isreal()
+
 test is w real? That is in a+ib test b is zero
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+real"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+real" />
 
 ### fP4.real()
+
 extract real part a
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+geta"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+geta" />
 
 ### fP4.geta()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+getb"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+getb" />
 
 ### fP4.getb()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+equals"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+equals" />
 
 ### fP4.equals(x)
+
 Tests for equality of two FP4s
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP4 instance to compare |
+| Param | Description             |
+| ----- | ----------------------- |
+| x     | FP4 instance to compare |
 
-<a name="FP4+copy"></a>
+<a name="FP4+copy" />
 
 ### fP4.copy(x)
+
 Copy FP4 to another FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP4 instance to be copied |
+| Param | Description               |
+| ----- | ------------------------- |
+| x     | FP4 instance to be copied |
 
-<a name="FP4+zero"></a>
+<a name="FP4+zero" />
 
 ### fP4.zero()
+
 Set FP4 to zero
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+one"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+one" />
 
 ### fP4.one(x)
+
 Set FP4 to unity
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP4 instance to be set to one |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| x     | FP4 instance to be set to one |
 
-<a name="FP4+set"></a>
+<a name="FP4+set" />
 
 ### fP4.set(c, d)
+
 Set FP4 from two FP2 values
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP2 instance |
-| d | FP2 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP2 instance |
+| d     | FP2 instance |
 
-<a name="FP4+seta"></a>
+<a name="FP4+seta" />
 
 ### fP4.seta(c)
+
 Set FP4 from one FP2 value
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP2 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP2 instance |
 
-<a name="FP4+neg"></a>
+<a name="FP4+neg" />
 
 ### fP4.neg()
+
 Negation of FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+conj"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+conj" />
 
 ### fP4.conj()
+
 Conjugation of FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+nconj"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+nconj" />
 
 ### fP4.nconj()
+
 Negative conjugation of FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+add"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+add" />
 
 ### fP4.add(x)
+
 addition of two FP4s
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| x     | FP4 instance |
 
-<a name="FP4+sub"></a>
+<a name="FP4+sub" />
 
 ### fP4.sub(x)
+
 subtraction of two FP4s
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| x     | FP4 instance |
 
-<a name="FP4+pmul"></a>
+<a name="FP4+pmul" />
 
 ### fP4.pmul(s)
+
 Multiplication of an FP4 by an FP8
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| s     | FP8 instance |
 
-<a name="FP4+imul"></a>
+<a name="FP4+imul" />
 
 ### fP4.imul(s)
+
 Multiplication of an FP4 by an integer
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | integer multiplier |
+| Param | Description        |
+| ----- | ------------------ |
+| s     | integer multiplier |
 
-<a name="FP4+sqr"></a>
+<a name="FP4+sqr" />
 
 ### fP4.sqr()
+
 Fast Squaring of an FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+mul"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+mul" />
 
 ### fP4.mul(y)
+
 Full unconditional Multiplication of two FP4s
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP4 instance, the multiplier |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| y     | FP4 instance, the multiplier |
 
-<a name="FP4+toString"></a>
+<a name="FP4+toString" />
 
 ### fP4.toString()
+
 convert to hex string
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+inverse"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+inverse" />
 
 ### fP4.inverse()
+
 Inverting an FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+times_i"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+times_i" />
 
-### fP4.times\_i()
+### fP4.times_i()
+
 multiplies an FP4 instance by irreducible polynomial sqrt(1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+frob"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+frob" />
 
 ### fP4.frob(f)
+
 Raises an FP4 to the power of the internal modulus p, using the Frobenius
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| f | Modulus |
+| ----- | ----------- |
+| f     | Modulus     |
 
-<a name="FP4+pow"></a>
+<a name="FP4+pow" />
 
 ### fP4.pow(e)
+
 Raises an FP4 to the power of a BIG
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP4+xtr_A"></a>
+<a name="FP4+xtr_A" />
 
-### fP4.xtr\_A(w, y, z)
-Calculates the XTR addition function r=w*x-conj(x)*y+z
+### fP4.xtr_A(w, y, z)
+
+Calculates the XTR addition function r=w_x-conj(x)_y+z
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| w | FP4 instance |
-| y | FP4 instance |
-| z | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| w     | FP4 instance |
+| y     | FP4 instance |
+| z     | FP4 instance |
 
-<a name="FP4+xtr_D"></a>
+<a name="FP4+xtr_D" />
 
-### fP4.xtr\_D()
-Calculates the XTR doubling function r=x^2-2*conj(x)
+### fP4.xtr_D()
+
+Calculates the XTR doubling function r=x^2-2\*conj(x)
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+xtr_pow"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+xtr_pow" />
 
-### fP4.xtr\_pow(n)
+### fP4.xtr_pow(n)
+
 Calculates FP4 trace of an FP4 raised to the power of a BIG number
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| n | Big number |
+| ----- | ----------- |
+| n     | Big number  |
 
-<a name="FP4+xtr_pow2"></a>
+<a name="FP4+xtr_pow2" />
 
-### fP4.xtr\_pow2()
+### fP4.xtr_pow2()
+
 Calculates FP4 trace of c^a.d^b, where c and d are derived from FP4 traces of FP4s
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+div2"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+div2" />
 
 ### fP4.div2()
+
 Divide an FP4 by 2
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+div_i"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+div_i" />
 
-### fP4.div\_i()
+### fP4.div_i()
+
 Divide FP4 number by QNR
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+div_2i"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+div_2i" />
 
-### fP4.div\_2i()
+### fP4.div_2i()
+
 Divide an FP4 by QNR/2
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
-<a name="FP4+qmul"></a>
+**this**: <code>{"{"}FP4{"}"}</code>  
+<a name="FP4+qmul" />
 
 ### fP4.qmul(s)
+
 Multiplication of an FP4 by an FP
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP multiplier |
+| Param | Description   |
+| ----- | ------------- |
+| s     | FP multiplier |
 
-<a name="FP4+sqrt"></a>
+<a name="FP4+sqrt" />
 
 ### fP4.sqrt()
+
 Calculate square root of an FP4
 
 **Kind**: instance method of [<code>FP4</code>](#FP4)  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
diff --git a/docs/cryptojs/fp48.md b/docs/cryptojs/fp48.md
index d95e5ac..caf1a3b 100644
--- a/docs/cryptojs/fp48.md
+++ b/docs/cryptojs/fp48.md
@@ -3,356 +3,389 @@
 title: FP48
 sidebar_label: FP48
 ---
-
-<a name="FP48"></a>
+<a name="FP48" />
 
 ## FP48
+
 **Kind**: global class  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-* [FP48](#FP48)
-    * [new FP48()](#new_FP48_new)
-    * _instance_
-        * [.reduce()](#FP48+reduce)
-        * [.norm()](#FP48+norm)
-        * [.iszilch()](#FP48+iszilch)
-        * [.isunity()](#FP48+isunity)
-        * [.cmove(g, d)](#FP48+cmove)
-        * [.select()](#FP48+select)
-        * [.geta()](#FP48+geta)
-        * [.getb()](#FP48+getb)
-        * [.getc()](#FP48+getc)
-        * [.equals(x)](#FP48+equals)
-        * [.copy(x)](#FP48+copy)
-        * [.one(x)](#FP48+one)
-        * [.zero()](#FP48+zero)
-        * [.conj()](#FP48+conj)
-        * [.set(d, e, f)](#FP48+set)
-        * [.seta(c)](#FP48+seta)
-        * [.usqr()](#FP48+usqr)
-        * [.sqr()](#FP48+sqr)
-        * [.mul(y)](#FP48+mul)
-        * [.smul(y)](#FP48+smul)
-        * [.ssmul(y)](#FP48+ssmul)
-        * [.inverse()](#FP48+inverse)
-        * [.frob(f)](#FP48+frob)
-        * [.trace()](#FP48+trace)
-        * [.toString()](#FP48+toString)
-        * [.toBytes(w)](#FP48+toBytes)
-        * [.pow(e)](#FP48+pow)
-        * [.pinpow(e, bts)](#FP48+pinpow)
-        * [.compow(e, r)](#FP48+compow)
-    * _static_
-        * [.fromBytes(w)](#FP48.fromBytes)
-        * [.teq()](#FP48.teq)
-        * [.pow16()](#FP48.pow16)
+-   [FP48](#FP48)
+    -   [new FP48()](#new_FP48_new)
+    -   _instance_
+        -   [.reduce()](#FP48+reduce)
+        -   [.norm()](#FP48+norm)
+        -   [.iszilch()](#FP48+iszilch)
+        -   [.isunity()](#FP48+isunity)
+        -   [.cmove(g, d)](#FP48+cmove)
+        -   [.select()](#FP48+select)
+        -   [.geta()](#FP48+geta)
+        -   [.getb()](#FP48+getb)
+        -   [.getc()](#FP48+getc)
+        -   [.equals(x)](#FP48+equals)
+        -   [.copy(x)](#FP48+copy)
+        -   [.one(x)](#FP48+one)
+        -   [.zero()](#FP48+zero)
+        -   [.conj()](#FP48+conj)
+        -   [.set(d, e, f)](#FP48+set)
+        -   [.seta(c)](#FP48+seta)
+        -   [.usqr()](#FP48+usqr)
+        -   [.sqr()](#FP48+sqr)
+        -   [.mul(y)](#FP48+mul)
+        -   [.smul(y)](#FP48+smul)
+        -   [.ssmul(y)](#FP48+ssmul)
+        -   [.inverse()](#FP48+inverse)
+        -   [.frob(f)](#FP48+frob)
+        -   [.trace()](#FP48+trace)
+        -   [.toString()](#FP48+toString)
+        -   [.toBytes(w)](#FP48+toBytes)
+        -   [.pow(e)](#FP48+pow)
+        -   [.pinpow(e, bts)](#FP48+pinpow)
+        -   [.compow(e, r)](#FP48+compow)
+    -   _static_
+        -   [.fromBytes(w)](#FP48.fromBytes)
+        -   [.teq()](#FP48.teq)
+        -   [.pow16()](#FP48.pow16)
 
-<a name="new_FP48_new"></a>
+<a name="new_FP48_new" />
 
 ### new FP48()
+
 Creates an instance of FP48.
 
-<a name="FP48+reduce"></a>
+<a name="FP48+reduce" />
 
 ### fP48.reduce()
+
 Reduces all components of possibly unreduced FP48 mod Modulus
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+norm"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+norm" />
 
 ### fP48.norm()
+
 Normalises the components of an FP48
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+iszilch"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+iszilch" />
 
 ### fP48.iszilch()
+
 Tests for FP48 equal to zero
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+isunity"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+isunity" />
 
 ### fP48.isunity()
+
 Tests for FP48 equal to unity
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+cmove"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+cmove" />
 
 ### fP48.cmove(g, d)
+
 Conditional copy of FP48 number
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP48 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP48 instance              |
+| d     | copy depends on this value |
 
-<a name="FP48+select"></a>
+<a name="FP48+select" />
 
 ### fP48.select()
+
 Constant time select from pre-computed table
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+geta"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+geta" />
 
 ### fP48.geta()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+getb"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+getb" />
 
 ### fP48.getb()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+getc"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+getc" />
 
 ### fP48.getc()
+
 extract c from this
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+equals"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+equals" />
 
 ### fP48.equals(x)
+
 Tests for equality of two FP48s
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP48 instance to compare |
+| Param | Description              |
+| ----- | ------------------------ |
+| x     | FP48 instance to compare |
 
-<a name="FP48+copy"></a>
+<a name="FP48+copy" />
 
 ### fP48.copy(x)
+
 Copy FP48 to another FP48
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP48 instance to be copied |
+| Param | Description                |
+| ----- | -------------------------- |
+| x     | FP48 instance to be copied |
 
-<a name="FP48+one"></a>
+<a name="FP48+one" />
 
 ### fP48.one(x)
+
 Set FP48 to unity
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP48 instance to be set to one |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| x     | FP48 instance to be set to one |
 
-<a name="FP48+zero"></a>
+<a name="FP48+zero" />
 
 ### fP48.zero()
+
 Set FP48 to zero
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+conj"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+conj" />
 
 ### fP48.conj()
+
 Conjugation of FP48
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+set"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+set" />
 
 ### fP48.set(d, e, f)
+
 Set FP48 from three FP16 values
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | FP16 instance |
-| e | FP16 instance |
-| f | FP16 instance |
+| Param | Description   |
+| ----- | ------------- |
+| d     | FP16 instance |
+| e     | FP16 instance |
+| f     | FP16 instance |
 
-<a name="FP48+seta"></a>
+<a name="FP48+seta" />
 
 ### fP48.seta(c)
+
 Set FP48 from one FP16 value
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP16 instance |
+| Param | Description   |
+| ----- | ------------- |
+| c     | FP16 instance |
 
-<a name="FP48+usqr"></a>
+<a name="FP48+usqr" />
 
 ### fP48.usqr()
+
 Fast Squaring of an FP48 in "unitary" form
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+sqr"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+sqr" />
 
 ### fP48.sqr()
+
 Fast Squaring of an FP48
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+mul"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+mul" />
 
 ### fP48.mul(y)
+
 Full unconditional Multiplication of two FP48s
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP48 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP48 instance, the multiplier |
 
-<a name="FP48+smul"></a>
+<a name="FP48+smul" />
 
 ### fP48.smul(y)
+
 Fast multiplication of two sparse FP48s that arises from ATE pairing line functions
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP48 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP48 instance, the multiplier |
 
-<a name="FP48+ssmul"></a>
+<a name="FP48+ssmul" />
 
 ### fP48.ssmul(y)
+
 Fast multiplication of what may be sparse multiplicands
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP48 instance, the multiplier |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| y     | FP48 instance, the multiplier |
 
-<a name="FP48+inverse"></a>
+<a name="FP48+inverse" />
 
 ### fP48.inverse()
+
 Inverting an FP48
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+frob"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+frob" />
 
 ### fP48.frob(f)
+
 Raises an FP48 to the power of the internal modulus p, using the Frobenius
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| f | Modulus |
+| ----- | ----------- |
+| f     | Modulus     |
 
-<a name="FP48+trace"></a>
+<a name="FP48+trace" />
 
 ### fP48.trace()
+
 Calculate the trace of an FP48
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+toString"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+toString" />
 
 ### fP48.toString()
+
 convert this to hex string
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48+toBytes"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48+toBytes" />
 
 ### fP48.toBytes(w)
+
 convert this to byte array
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| w | Byte array |
+| ----- | ----------- |
+| w     | Byte array  |
 
-<a name="FP48+pow"></a>
+<a name="FP48+pow" />
 
 ### fP48.pow(e)
+
 Raises an FP48 to the power of a BIG
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP48+pinpow"></a>
+<a name="FP48+pinpow" />
 
 ### fP48.pinpow(e, bts)
+
 Raises an FP48 instance x to a small integer power, side-channel resistant
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | small integer exponent |
-| bts | maximum number of bits in exponent |
+| Param | Description                        |
+| ----- | ---------------------------------- |
+| e     | small integer exponent             |
+| bts   | maximum number of bits in exponent |
 
-<a name="FP48+compow"></a>
+<a name="FP48+compow" />
 
 ### fP48.compow(e, r)
+
 Raises an FP48 instance to a BIG power, compressed to FP4
 
 **Kind**: instance method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG exponent |
-| r | BIG group order |
+| Param | Description     |
+| ----- | --------------- |
+| e     | BIG exponent    |
+| r     | BIG group order |
 
-<a name="FP48.fromBytes"></a>
+<a name="FP48.fromBytes" />
 
 ### FP48.fromBytes(w)
+
 convert from byte array to FP48
 
 **Kind**: static method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| w | Byte array |
+| ----- | ----------- |
+| w     | Byte array  |
 
-<a name="FP48.teq"></a>
+<a name="FP48.teq" />
 
 ### FP48.teq()
+
 return 1 if b==c, no branching
 
 **Kind**: static method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
-<a name="FP48.pow16"></a>
+**this**: <code>{"{"}FP48{"}"}</code>  
+<a name="FP48.pow16" />
 
 ### FP48.pow16()
+
 p=q0^u0.q1^u1.q2^u2.q3^u3...
 
 **Kind**: static method of [<code>FP48</code>](#FP48)  
-**this**: <code>{FP48}</code>  
+**this**: <code>{"{"}FP48{"}"}</code>  
diff --git a/docs/cryptojs/fp8.md b/docs/cryptojs/fp8.md
index e878757..0bf9345 100644
--- a/docs/cryptojs/fp8.md
+++ b/docs/cryptojs/fp8.md
@@ -3,441 +3,482 @@
 title: FP8
 sidebar_label: FP8
 ---
-
-<a name="FP8"></a>
+<a name="FP8" />
 
 ## FP8
+
 **Kind**: global class  
-**this**: <code>{FP4}</code>  
+**this**: <code>{"{"}FP4{"}"}</code>  
 
-* [FP8](#FP8)
-    * [new FP8(c, d)](#new_FP8_new)
-    * [.reduce()](#FP8+reduce)
-    * [.norm()](#FP8+norm)
-    * [.iszilch()](#FP8+iszilch)
-    * [.isunity()](#FP8+isunity)
-    * [.cmove(g, d)](#FP8+cmove)
-    * [.isreal()](#FP8+isreal)
-    * [.real()](#FP8+real)
-    * [.geta()](#FP8+geta)
-    * [.getb()](#FP8+getb)
-    * [.equals(x)](#FP8+equals)
-    * [.copy(x)](#FP8+copy)
-    * [.zero()](#FP8+zero)
-    * [.one(x)](#FP8+one)
-    * [.set(c, d)](#FP8+set)
-    * [.seta(c)](#FP8+seta)
-    * [.neg()](#FP8+neg)
-    * [.conj()](#FP8+conj)
-    * [.nconj()](#FP8+nconj)
-    * [.add(x)](#FP8+add)
-    * [.sub(x)](#FP8+sub)
-    * [.pmul(s)](#FP8+pmul)
-    * [.imul(s)](#FP8+imul)
-    * [.sqr()](#FP8+sqr)
-    * [.mul(y)](#FP8+mul)
-    * [.toString()](#FP8+toString)
-    * [.inverse()](#FP8+inverse)
-    * [.times_i()](#FP8+times_i)
-    * [.times_i2()](#FP8+times_i2)
-    * [.frob(f)](#FP8+frob)
-    * [.pow(e)](#FP8+pow)
-    * [.xtr_A(w, y, z)](#FP8+xtr_A)
-    * [.xtr_D()](#FP8+xtr_D)
-    * [.xtr_pow(n)](#FP8+xtr_pow)
-    * [.xtr_pow2()](#FP8+xtr_pow2)
-    * [.div2()](#FP8+div2)
-    * [.div_i()](#FP8+div_i)
-    * [.div_i2()](#FP8+div_i2)
-    * [.div_2i()](#FP8+div_2i)
-    * [.qmul(s)](#FP8+qmul)
-    * [.tmul(s)](#FP8+tmul)
-    * [.sqrt()](#FP8+sqrt)
+-   [FP8](#FP8)
+    -   [new FP8(c, d)](#new_FP8_new)
+    -   [.reduce()](#FP8+reduce)
+    -   [.norm()](#FP8+norm)
+    -   [.iszilch()](#FP8+iszilch)
+    -   [.isunity()](#FP8+isunity)
+    -   [.cmove(g, d)](#FP8+cmove)
+    -   [.isreal()](#FP8+isreal)
+    -   [.real()](#FP8+real)
+    -   [.geta()](#FP8+geta)
+    -   [.getb()](#FP8+getb)
+    -   [.equals(x)](#FP8+equals)
+    -   [.copy(x)](#FP8+copy)
+    -   [.zero()](#FP8+zero)
+    -   [.one(x)](#FP8+one)
+    -   [.set(c, d)](#FP8+set)
+    -   [.seta(c)](#FP8+seta)
+    -   [.neg()](#FP8+neg)
+    -   [.conj()](#FP8+conj)
+    -   [.nconj()](#FP8+nconj)
+    -   [.add(x)](#FP8+add)
+    -   [.sub(x)](#FP8+sub)
+    -   [.pmul(s)](#FP8+pmul)
+    -   [.imul(s)](#FP8+imul)
+    -   [.sqr()](#FP8+sqr)
+    -   [.mul(y)](#FP8+mul)
+    -   [.toString()](#FP8+toString)
+    -   [.inverse()](#FP8+inverse)
+    -   [.times_i()](#FP8+times_i)
+    -   [.times_i2()](#FP8+times_i2)
+    -   [.frob(f)](#FP8+frob)
+    -   [.pow(e)](#FP8+pow)
+    -   [.xtr_A(w, y, z)](#FP8+xtr_A)
+    -   [.xtr_D()](#FP8+xtr_D)
+    -   [.xtr_pow(n)](#FP8+xtr_pow)
+    -   [.xtr_pow2()](#FP8+xtr_pow2)
+    -   [.div2()](#FP8+div2)
+    -   [.div_i()](#FP8+div_i)
+    -   [.div_i2()](#FP8+div_i2)
+    -   [.div_2i()](#FP8+div_2i)
+    -   [.qmul(s)](#FP8+qmul)
+    -   [.tmul(s)](#FP8+tmul)
+    -   [.sqrt()](#FP8+sqrt)
 
-<a name="new_FP8_new"></a>
+<a name="new_FP8_new" />
 
 ### new FP8(c, d)
+
 Creates an instance of FP8
 
+| Param | Description        |
+| ----- | ------------------ |
+| c     | FP8 / FP4 instance |
+| d     | FP4 instance       |
 
-| Param | Description |
-| --- | --- |
-| c | FP8 / FP4 instance |
-| d | FP4 instance |
-
-<a name="FP8+reduce"></a>
+<a name="FP8+reduce" />
 
 ### fP8.reduce()
+
 Reduces all components of possibly unreduced FP8 mod Modulus
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+norm"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+norm" />
 
 ### fP8.norm()
+
 Normalises the components of an FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+iszilch"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+iszilch" />
 
 ### fP8.iszilch()
+
 Tests for FP8 equal to zero
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+isunity"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+isunity" />
 
 ### fP8.isunity()
+
 Tests for FP8 equal to unity
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+cmove"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+cmove" />
 
 ### fP8.cmove(g, d)
+
 Conditional copy of FP8 number
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| g | FP8 instance |
-| d | copy depends on this value |
+| Param | Description                |
+| ----- | -------------------------- |
+| g     | FP8 instance               |
+| d     | copy depends on this value |
 
-<a name="FP8+isreal"></a>
+<a name="FP8+isreal" />
 
 ### fP8.isreal()
+
 test is w real? That is in a+ib test b is zero
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+real"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+real" />
 
 ### fP8.real()
+
 extract real part a
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+geta"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+geta" />
 
 ### fP8.geta()
+
 extract a from this
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+getb"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+getb" />
 
 ### fP8.getb()
+
 extract b from this
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+equals"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+equals" />
 
 ### fP8.equals(x)
+
 Tests for equality of two FP8s
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP8 instance to compare |
+| Param | Description             |
+| ----- | ----------------------- |
+| x     | FP8 instance to compare |
 
-<a name="FP8+copy"></a>
+<a name="FP8+copy" />
 
 ### fP8.copy(x)
+
 Copy FP8 to another FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP8 instance to be copied |
+| Param | Description               |
+| ----- | ------------------------- |
+| x     | FP8 instance to be copied |
 
-<a name="FP8+zero"></a>
+<a name="FP8+zero" />
 
 ### fP8.zero()
+
 Set FP8 to zero
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+one"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+one" />
 
 ### fP8.one(x)
+
 Set FP8 to unity
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP8 instance to be set to one |
+| Param | Description                   |
+| ----- | ----------------------------- |
+| x     | FP8 instance to be set to one |
 
-<a name="FP8+set"></a>
+<a name="FP8+set" />
 
 ### fP8.set(c, d)
+
 Set FP8 from two FP4 values
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP4 instance |
-| d | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP4 instance |
+| d     | FP4 instance |
 
-<a name="FP8+seta"></a>
+<a name="FP8+seta" />
 
 ### fP8.seta(c)
+
 Set FP8 from one FP4 value
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP4 instance |
+| Param | Description  |
+| ----- | ------------ |
+| c     | FP4 instance |
 
-<a name="FP8+neg"></a>
+<a name="FP8+neg" />
 
 ### fP8.neg()
+
 Negation of FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+conj"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+conj" />
 
 ### fP8.conj()
+
 Conjugation of FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+nconj"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+nconj" />
 
 ### fP8.nconj()
+
 Negative conjugation of FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+add"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+add" />
 
 ### fP8.add(x)
+
 addition of two FP8s
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| x     | FP8 instance |
 
-<a name="FP8+sub"></a>
+<a name="FP8+sub" />
 
 ### fP8.sub(x)
+
 subtraction of two FP8s
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| x | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| x     | FP8 instance |
 
-<a name="FP8+pmul"></a>
+<a name="FP8+pmul" />
 
 ### fP8.pmul(s)
+
 Multiplication of an FP8 by an FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| s     | FP8 instance |
 
-<a name="FP8+imul"></a>
+<a name="FP8+imul" />
 
 ### fP8.imul(s)
+
 Multiplication of an FP8 by a small integer
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | integer |
+| ----- | ----------- |
+| s     | integer     |
 
-<a name="FP8+sqr"></a>
+<a name="FP8+sqr" />
 
 ### fP8.sqr()
+
 Fast Squaring of an FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+mul"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+mul" />
 
 ### fP8.mul(y)
+
 Full unconditional Multiplication of two FP8s
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | FP8 instance, the multiplier |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| y     | FP8 instance, the multiplier |
 
-<a name="FP8+toString"></a>
+<a name="FP8+toString" />
 
 ### fP8.toString()
+
 convert to hex string
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+inverse"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+inverse" />
 
 ### fP8.inverse()
+
 Inverting an FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+times_i"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+times_i" />
 
-### fP8.times\_i()
+### fP8.times_i()
+
 multiplies an FP8 instance by irreducible polynomial sqrt(1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+times_i2"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+times_i2" />
 
-### fP8.times\_i2()
+### fP8.times_i2()
+
 multiplies an FP8 instance by irreducible polynomial (1+sqrt(-1))
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+frob"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+frob" />
 
 ### fP8.frob(f)
+
 Raises an FP8 to the power of the internal modulus p, using the Frobenius
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| f | Modulus |
+| ----- | ----------- |
+| f     | Modulus     |
 
-<a name="FP8+pow"></a>
+<a name="FP8+pow" />
 
 ### fP8.pow(e)
+
 Raises an FP8 to the power of a BIG
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| e | BIG instance exponent |
+| Param | Description           |
+| ----- | --------------------- |
+| e     | BIG instance exponent |
 
-<a name="FP8+xtr_A"></a>
+<a name="FP8+xtr_A" />
 
-### fP8.xtr\_A(w, y, z)
-Calculates the XTR addition function r=w*x-conj(x)*y+z
+### fP8.xtr_A(w, y, z)
+
+Calculates the XTR addition function r=w_x-conj(x)_y+z
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| w | FP8 instance |
-| y | FP8 instance |
-| z | FP8 instance |
+| Param | Description  |
+| ----- | ------------ |
+| w     | FP8 instance |
+| y     | FP8 instance |
+| z     | FP8 instance |
 
-<a name="FP8+xtr_D"></a>
+<a name="FP8+xtr_D" />
 
-### fP8.xtr\_D()
-Calculates the XTR doubling function r=x^2-2*conj(x)
+### fP8.xtr_D()
+
+Calculates the XTR doubling function r=x^2-2\*conj(x)
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+xtr_pow"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+xtr_pow" />
 
-### fP8.xtr\_pow(n)
+### fP8.xtr_pow(n)
+
 Calculates FP8 trace of an FP8 raised to the power of a BIG number
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| n | Big number |
+| ----- | ----------- |
+| n     | Big number  |
 
-<a name="FP8+xtr_pow2"></a>
+<a name="FP8+xtr_pow2" />
 
-### fP8.xtr\_pow2()
+### fP8.xtr_pow2()
+
 Calculates FP8 trace of c^a.d^b, where c and d are derived from FP8 traces of FP8s
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+div2"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+div2" />
 
 ### fP8.div2()
+
 Divide an FP8 by 2
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+div_i"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+div_i" />
 
-### fP8.div\_i()
+### fP8.div_i()
+
 Divide FP8 number by QNR
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+div_i2"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+div_i2" />
 
-### fP8.div\_i2()
+### fP8.div_i2()
+
 Divide an FP8 by QNR twice
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+div_2i"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+div_2i" />
 
-### fP8.div\_2i()
+### fP8.div_2i()
+
 Divide an FP8 by QNR/2
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
-<a name="FP8+qmul"></a>
+**this**: <code>{"{"}FP8{"}"}</code>  
+<a name="FP8+qmul" />
 
 ### fP8.qmul(s)
+
 Multiplication of an FP8 by an FP2
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP2 multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| s     | FP2 multiplier |
 
-<a name="FP8+tmul"></a>
+<a name="FP8+tmul" />
 
 ### fP8.tmul(s)
+
 Multiplication of an FP8 by an FP
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| s | FP multiplier |
+| Param | Description   |
+| ----- | ------------- |
+| s     | FP multiplier |
 
-<a name="FP8+sqrt"></a>
+<a name="FP8+sqrt" />
 
 ### fP8.sqrt()
+
 Calculate square root of an FP8
 
 **Kind**: instance method of [<code>FP8</code>](#FP8)  
-**this**: <code>{FP8}</code>  
+**this**: <code>{"{"}FP8{"}"}</code>  
diff --git a/docs/cryptojs/gcm.md b/docs/cryptojs/gcm.md
index 9fe74a5..c3c434f 100644
--- a/docs/cryptojs/gcm.md
+++ b/docs/cryptojs/gcm.md
@@ -3,78 +3,82 @@
 title: GCM
 sidebar_label: GCM
 ---
-
-<a name="GCM"></a>
+<a name="GCM" />
 
 ## GCM
+
 **Kind**: global class  
-**this**: <code>{GCM}</code>  
+**this**: <code>{"{"}GCM{"}"}</code>  
 
-* [GCM](#GCM)
-    * [new GCM()](#new_GCM_new)
-    * [.init(nk, key, niv, iv)](#GCM+init)
-    * [.add_header(header, len)](#GCM+add_header)
-    * [.add_plain(plain, len)](#GCM+add_plain) ⇒
-    * [.add_cipher(cipher, len)](#GCM+add_cipher) ⇒
+-   [GCM](#GCM)
+    -   [new GCM()](#new_GCM_new)
+    -   [.init(nk, key, niv, iv)](#GCM+init)
+    -   [.add_header(header, len)](#GCM+add_header)
+    -   [.add_plain(plain, len)](#GCM+add_plain) ⇒
+    -   [.add_cipher(cipher, len)](#GCM+add_cipher) ⇒
 
-<a name="new_GCM_new"></a>
+<a name="new_GCM_new" />
 
 ### new GCM()
+
 Creates an instance of GCM
 
-<a name="GCM+init"></a>
+<a name="GCM+init" />
 
 ### gcM.init(nk, key, niv, iv)
+
 Initialize GCM mode
 
 **Kind**: instance method of [<code>GCM</code>](#GCM)  
-**this**: <code>{GCM}</code>  
+**this**: <code>{"{"}GCM{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| nk | is the key length in bytes, 16, 24 or 32 |
-| key | the AES key as an array of 16 bytes |
-| niv | the number of bytes in the Initialisation Vector (IV) |
-| iv | the IV |
+| Param | Description                                           |
+| ----- | ----------------------------------------------------- |
+| nk    | is the key length in bytes, 16, 24 or 32              |
+| key   | the AES key as an array of 16 bytes                   |
+| niv   | the number of bytes in the Initialisation Vector (IV) |
+| iv    | the IV                                                |
 
-<a name="GCM+add_header"></a>
+<a name="GCM+add_header" />
 
-### gcM.add\_header(header, len)
+### gcM.add_header(header, len)
+
 Add header (material to be authenticated but not encrypted)
 
 **Kind**: instance method of [<code>GCM</code>](#GCM)  
-**this**: <code>{GCM}</code>  
+**this**: <code>{"{"}GCM{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
+| Param  | Description                        |
+| ------ | ---------------------------------- |
 | header | is the header material to be added |
-| len | the number of bytes in the header |
+| len    | the number of bytes in the header  |
 
-<a name="GCM+add_plain"></a>
+<a name="GCM+add_plain" />
 
-### gcM.add\_plain(plain, len) ⇒
+### gcM.add_plain(plain, len) ⇒
+
 Add plaintext and extract ciphertext
 
 **Kind**: instance method of [<code>GCM</code>](#GCM)  
 **Returns**: cipher is the ciphertext generated  
-**this**: <code>{GCM}</code>  
+**this**: <code>{"{"}GCM{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
+| Param | Description                           |
+| ----- | ------------------------------------- |
 | plain | is the plaintext material to be added |
-| len | the number of bytes in the plaintext |
+| len   | the number of bytes in the plaintext  |
 
-<a name="GCM+add_cipher"></a>
+<a name="GCM+add_cipher" />
 
-### gcM.add\_cipher(cipher, len) ⇒
+### gcM.add_cipher(cipher, len) ⇒
+
 Add Ciphertext - decrypts to plaintext
 
 **Kind**: instance method of [<code>GCM</code>](#GCM)  
 **Returns**: plain is the plaintext material generated  
-**this**: <code>{GCM}</code>  
+**this**: <code>{"{"}GCM{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| cipher | is the ciphertext to be added |
-| len | the number of bytes in the plaintext |
-
+| Param  | Description                          |
+| ------ | ------------------------------------ |
+| cipher | is the ciphertext to be added        |
+| len    | the number of bytes in the plaintext |
diff --git a/docs/cryptojs/hash256.md b/docs/cryptojs/hash256.md
index 1570ad9..fe2faca 100644
--- a/docs/cryptojs/hash256.md
+++ b/docs/cryptojs/hash256.md
@@ -3,74 +3,80 @@
 title: HASH256
 sidebar_label: HASH256
 ---
-
-<a name="HASH256"></a>
+<a name="HASH256" />
 
 ## HASH256
+
 **Kind**: global class  
-**this**: <code>{HASH256}</code>  
+**this**: <code>{"{"}HASH256{"}"}</code>  
 
-* [HASH256](#HASH256)
-    * [new HASH256()](#new_HASH256_new)
-    * [.init()](#HASH256+init)
-    * [.process(byt)](#HASH256+process)
-    * [.process_array(b)](#HASH256+process_array)
-    * [.process_num(n)](#HASH256+process_num)
-    * [.hash()](#HASH256+hash) ⇒
+-   [HASH256](#HASH256)
+    -   [new HASH256()](#new_HASH256_new)
+    -   [.init()](#HASH256+init)
+    -   [.process(byt)](#HASH256+process)
+    -   [.process_array(b)](#HASH256+process_array)
+    -   [.process_num(n)](#HASH256+process_num)
+    -   [.hash()](#HASH256+hash) ⇒
 
-<a name="new_HASH256_new"></a>
+<a name="new_HASH256_new" />
 
 ### new HASH256()
+
 Creates an instance of HASH256
 
-<a name="HASH256+init"></a>
+<a name="HASH256+init" />
 
 ### hasH256.init()
+
 Initialise Hash function
 
 **Kind**: instance method of [<code>HASH256</code>](#HASH256)  
-**this**: <code>{HASH256}</code>  
-<a name="HASH256+process"></a>
+**this**: <code>{"{"}HASH256{"}"}</code>  
+<a name="HASH256+process" />
 
 ### hasH256.process(byt)
+
 Process a single byte
 
 **Kind**: instance method of [<code>HASH256</code>](#HASH256)  
-**this**: <code>{HASH256}</code>  
+**this**: <code>{"{"}HASH256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| byt | byte to be included in hash |
+| Param | Description                 |
+| ----- | --------------------------- |
+| byt   | byte to be included in hash |
 
-<a name="HASH256+process_array"></a>
+<a name="HASH256+process_array" />
 
-### hasH256.process\_array(b)
+### hasH256.process_array(b)
+
 Process an array of bytes
 
 **Kind**: instance method of [<code>HASH256</code>](#HASH256)  
-**this**: <code>{HASH256}</code>  
+**this**: <code>{"{"}HASH256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte arrray to be included in hash |
+| Param | Description                        |
+| ----- | ---------------------------------- |
+| b     | byte arrray to be included in hash |
 
-<a name="HASH256+process_num"></a>
+<a name="HASH256+process_num" />
 
-### hasH256.process\_num(n)
+### hasH256.process_num(n)
+
 Process a 32-bit integer
 
 **Kind**: instance method of [<code>HASH256</code>](#HASH256)  
-**this**: <code>{HASH256}</code>  
+**this**: <code>{"{"}HASH256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| n | Integer to be included in hash |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| n     | Integer to be included in hash |
 
-<a name="HASH256+hash"></a>
+<a name="HASH256+hash" />
 
 ### hasH256.hash() ⇒
+
 Generate 32-byte hash
 
 **Kind**: instance method of [<code>HASH256</code>](#HASH256)  
 **Returns**: digest 32-byte hash  
-**this**: <code>{HASH256}</code>  
+**this**: <code>{"{"}HASH256{"}"}</code>  
diff --git a/docs/cryptojs/hash384.md b/docs/cryptojs/hash384.md
index 24a176a..6b954c0 100644
--- a/docs/cryptojs/hash384.md
+++ b/docs/cryptojs/hash384.md
@@ -3,74 +3,80 @@
 title: HASH384
 sidebar_label: HASH384
 ---
-
-<a name="HASH384"></a>
+<a name="HASH384" />
 
 ## HASH384
+
 **Kind**: global class  
-**this**: <code>{HASH384}</code>  
+**this**: <code>{"{"}HASH384{"}"}</code>  
 
-* [HASH384](#HASH384)
-    * [new HASH384()](#new_HASH384_new)
-    * [.init()](#HASH384+init)
-    * [.process(byt)](#HASH384+process)
-    * [.process_array(b)](#HASH384+process_array)
-    * [.process_num(n)](#HASH384+process_num)
-    * [.hash()](#HASH384+hash) ⇒
+-   [HASH384](#HASH384)
+    -   [new HASH384()](#new_HASH384_new)
+    -   [.init()](#HASH384+init)
+    -   [.process(byt)](#HASH384+process)
+    -   [.process_array(b)](#HASH384+process_array)
+    -   [.process_num(n)](#HASH384+process_num)
+    -   [.hash()](#HASH384+hash) ⇒
 
-<a name="new_HASH384_new"></a>
+<a name="new_HASH384_new" />
 
 ### new HASH384()
+
 Creates an instance of HASH384
 
-<a name="HASH384+init"></a>
+<a name="HASH384+init" />
 
 ### hasH384.init()
+
 Initialise Hash function
 
 **Kind**: instance method of [<code>HASH384</code>](#HASH384)  
-**this**: <code>{HASH384}</code>  
-<a name="HASH384+process"></a>
+**this**: <code>{"{"}HASH384{"}"}</code>  
+<a name="HASH384+process" />
 
 ### hasH384.process(byt)
+
 Process a single byte
 
 **Kind**: instance method of [<code>HASH384</code>](#HASH384)  
-**this**: <code>{HASH384}</code>  
+**this**: <code>{"{"}HASH384{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| byt | byte to be included in hash |
+| Param | Description                 |
+| ----- | --------------------------- |
+| byt   | byte to be included in hash |
 
-<a name="HASH384+process_array"></a>
+<a name="HASH384+process_array" />
 
-### hasH384.process\_array(b)
+### hasH384.process_array(b)
+
 Process an array of bytes
 
 **Kind**: instance method of [<code>HASH384</code>](#HASH384)  
-**this**: <code>{HASH384}</code>  
+**this**: <code>{"{"}HASH384{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte arrray to be included in hash |
+| Param | Description                        |
+| ----- | ---------------------------------- |
+| b     | byte arrray to be included in hash |
 
-<a name="HASH384+process_num"></a>
+<a name="HASH384+process_num" />
 
-### hasH384.process\_num(n)
+### hasH384.process_num(n)
+
 Process a 32-bit integer
 
 **Kind**: instance method of [<code>HASH384</code>](#HASH384)  
-**this**: <code>{HASH384}</code>  
+**this**: <code>{"{"}HASH384{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| n | Integer to be included in hash |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| n     | Integer to be included in hash |
 
-<a name="HASH384+hash"></a>
+<a name="HASH384+hash" />
 
 ### hasH384.hash() ⇒
+
 Generate 32-byte hash
 
 **Kind**: instance method of [<code>HASH384</code>](#HASH384)  
 **Returns**: digest 32-byte hash  
-**this**: <code>{HASH384}</code>  
+**this**: <code>{"{"}HASH384{"}"}</code>  
diff --git a/docs/cryptojs/hash512.md b/docs/cryptojs/hash512.md
index 1d4b471..9d5f62d 100644
--- a/docs/cryptojs/hash512.md
+++ b/docs/cryptojs/hash512.md
@@ -3,74 +3,80 @@
 title: HASH512
 sidebar_label: HASH512
 ---
-
-<a name="HASH512"></a>
+<a name="HASH512" />
 
 ## HASH512
+
 **Kind**: global class  
-**this**: <code>{HASH512}</code>  
+**this**: <code>{"{"}HASH512{"}"}</code>  
 
-* [HASH512](#HASH512)
-    * [new HASH512()](#new_HASH512_new)
-    * [.init()](#HASH512+init)
-    * [.process(byt)](#HASH512+process)
-    * [.process_array(b)](#HASH512+process_array)
-    * [.process_num(n)](#HASH512+process_num)
-    * [.hash()](#HASH512+hash) ⇒
+-   [HASH512](#HASH512)
+    -   [new HASH512()](#new_HASH512_new)
+    -   [.init()](#HASH512+init)
+    -   [.process(byt)](#HASH512+process)
+    -   [.process_array(b)](#HASH512+process_array)
+    -   [.process_num(n)](#HASH512+process_num)
+    -   [.hash()](#HASH512+hash) ⇒
 
-<a name="new_HASH512_new"></a>
+<a name="new_HASH512_new" />
 
 ### new HASH512()
+
 Creates an instance of HASH512
 
-<a name="HASH512+init"></a>
+<a name="HASH512+init" />
 
 ### hasH512.init()
+
 Initialise Hash function
 
 **Kind**: instance method of [<code>HASH512</code>](#HASH512)  
-**this**: <code>{HASH512}</code>  
-<a name="HASH512+process"></a>
+**this**: <code>{"{"}HASH512{"}"}</code>  
+<a name="HASH512+process" />
 
 ### hasH512.process(byt)
+
 Process a single byte
 
 **Kind**: instance method of [<code>HASH512</code>](#HASH512)  
-**this**: <code>{HASH512}</code>  
+**this**: <code>{"{"}HASH512{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| byt | byte to be included in hash |
+| Param | Description                 |
+| ----- | --------------------------- |
+| byt   | byte to be included in hash |
 
-<a name="HASH512+process_array"></a>
+<a name="HASH512+process_array" />
 
-### hasH512.process\_array(b)
+### hasH512.process_array(b)
+
 Process an array of bytes
 
 **Kind**: instance method of [<code>HASH512</code>](#HASH512)  
-**this**: <code>{HASH512}</code>  
+**this**: <code>{"{"}HASH512{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| b | byte arrray to be included in hash |
+| Param | Description                        |
+| ----- | ---------------------------------- |
+| b     | byte arrray to be included in hash |
 
-<a name="HASH512+process_num"></a>
+<a name="HASH512+process_num" />
 
-### hasH512.process\_num(n)
+### hasH512.process_num(n)
+
 Process a 32-bit integer
 
 **Kind**: instance method of [<code>HASH512</code>](#HASH512)  
-**this**: <code>{HASH512}</code>  
+**this**: <code>{"{"}HASH512{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| n | Integer to be included in hash |
+| Param | Description                    |
+| ----- | ------------------------------ |
+| n     | Integer to be included in hash |
 
-<a name="HASH512+hash"></a>
+<a name="HASH512+hash" />
 
 ### hasH512.hash() ⇒
+
 Generate 32-byte hash
 
 **Kind**: instance method of [<code>HASH512</code>](#HASH512)  
 **Returns**: digest 32-byte hash  
-**this**: <code>{HASH512}</code>  
+**this**: <code>{"{"}HASH512{"}"}</code>  
diff --git a/docs/cryptojs/mpin.md b/docs/cryptojs/mpin.md
index a243e5c..d93bd75 100644
--- a/docs/cryptojs/mpin.md
+++ b/docs/cryptojs/mpin.md
@@ -3,578 +3,610 @@
 title: MPIN
 sidebar_label: MPIN
 ---
-
-
-<a name="MPIN"></a>
+<a name="MPIN" />
 
 ## MPIN
+
 **Kind**: global class  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-* [MPIN](#MPIN)
-    * [new MPIN()](#new_MPIN_new)
-    * [.today()](#MPIN.today) ⇒
-    * [.bytestostring(b)](#MPIN.bytestostring) ⇒
-    * [.stringtobytes(s)](#MPIN.stringtobytes) ⇒
-    * [.comparebytes(a, b)](#MPIN.comparebytes) ⇒
-    * [.mpin_hash(c, U)](#MPIN.mpin_hash) ⇒
-    * [.hashit(sha, n, B)](#MPIN.hashit) ⇒
-    * [.map(u, cb)](#MPIN.map) ⇒
-    * [.unmap(u, P)](#MPIN.unmap) ⇒
-    * [.RECOMBINE_G1(R1, R2, R)](#MPIN.RECOMBINE_G1) ⇒
-    * [.RECOMBINE_G2(W1, W2, W)](#MPIN.RECOMBINE_G2) ⇒
-    * [.HASH_ID(sha, ID)](#MPIN.HASH_ID) ⇒
-    * [.RANDOM_GENERATE(rng, S)](#MPIN.RANDOM_GENERATE) ⇒
-    * [.EXTRACT_PIN()](#MPIN.EXTRACT_PIN) ⇒
-    * [.EXTRACT_FACTOR()](#MPIN.EXTRACT_FACTOR) ⇒
-    * [.RESTORE_FACTOR()](#MPIN.RESTORE_FACTOR) ⇒
-    * [.GET_SERVER_SECRET(S, SST)](#MPIN.GET_SERVER_SECRET) ⇒
-    * [.GET_G1_MULTIPLE(type, x, G, W)](#MPIN.GET_G1_MULTIPLE) ⇒
-    * [.GET_CLIENT_SECRET(S, CID, CST)](#MPIN.GET_CLIENT_SECRET) ⇒
-    * [.GET_CLIENT_PERMIT(sha, date, S, CID, CTT)](#MPIN.GET_CLIENT_PERMIT) ⇒
-    * [.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT)](#MPIN.CLIENT_1) ⇒
-    * [.CLIENT_2(X, Y, SEC)](#MPIN.CLIENT_2) ⇒
-    * [.SERVER_1(sha, date, CID, HID, HTID)](#MPIN.SERVER_1) ⇒
-    * [.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa)](#MPIN.SERVER_2) ⇒
-    * [.KANGAROO(E, F)](#MPIN.KANGAROO) ⇒
-    * [.GET_TIME()](#MPIN.GET_TIME) ⇒
-    * [.GET_Y(sha, TimeValue, xCID, Y)](#MPIN.GET_Y) ⇒
-    * [.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message)](#MPIN.CLIENT) ⇒
-    * [.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa)](#MPIN.SERVER) ⇒
-    * [.PRECOMPUTE(TOKEN, CID, G1, G2)](#MPIN.PRECOMPUTE) ⇒
-    * [.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W)](#MPIN.HASH_ALL) ⇒
-    * [.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK)](#MPIN.CLIENT_KEY) ⇒
-    * [.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK)](#MPIN.SERVER_KEY) ⇒
-    * [.GET_DVS_KEYPAIR(rng, Z, Pa)](#MPIN.GET_DVS_KEYPAIR) ⇒
+-   [MPIN](#MPIN)
+    -   [new MPIN()](#new_MPIN_new)
+    -   [.today()](#MPIN.today) ⇒
+    -   [.bytestostring(b)](#MPIN.bytestostring) ⇒
+    -   [.stringtobytes(s)](#MPIN.stringtobytes) ⇒
+    -   [.comparebytes(a, b)](#MPIN.comparebytes) ⇒
+    -   [.mpin_hash(c, U)](#MPIN.mpin_hash) ⇒
+    -   [.hashit(sha, n, B)](#MPIN.hashit) ⇒
+    -   [.map(u, cb)](#MPIN.map) ⇒
+    -   [.unmap(u, P)](#MPIN.unmap) ⇒
+    -   [.RECOMBINE_G1(R1, R2, R)](#MPIN.RECOMBINE_G1) ⇒
+    -   [.RECOMBINE_G2(W1, W2, W)](#MPIN.RECOMBINE_G2) ⇒
+    -   [.HASH_ID(sha, ID)](#MPIN.HASH_ID) ⇒
+    -   [.RANDOM_GENERATE(rng, S)](#MPIN.RANDOM_GENERATE) ⇒
+    -   [.EXTRACT_PIN()](#MPIN.EXTRACT_PIN) ⇒
+    -   [.EXTRACT_FACTOR()](#MPIN.EXTRACT_FACTOR) ⇒
+    -   [.RESTORE_FACTOR()](#MPIN.RESTORE_FACTOR) ⇒
+    -   [.GET_SERVER_SECRET(S, SST)](#MPIN.GET_SERVER_SECRET) ⇒
+    -   [.GET_G1_MULTIPLE(type, x, G, W)](#MPIN.GET_G1_MULTIPLE) ⇒
+    -   [.GET_CLIENT_SECRET(S, CID, CST)](#MPIN.GET_CLIENT_SECRET) ⇒
+    -   [.GET_CLIENT_PERMIT(sha, date, S, CID, CTT)](#MPIN.GET_CLIENT_PERMIT) ⇒
+    -   [.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT)](#MPIN.CLIENT_1) ⇒
+    -   [.CLIENT_2(X, Y, SEC)](#MPIN.CLIENT_2) ⇒
+    -   [.SERVER_1(sha, date, CID, HID, HTID)](#MPIN.SERVER_1) ⇒
+    -   [.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa)](#MPIN.SERVER_2) ⇒
+    -   [.KANGAROO(E, F)](#MPIN.KANGAROO) ⇒
+    -   [.GET_TIME()](#MPIN.GET_TIME) ⇒
+    -   [.GET_Y(sha, TimeValue, xCID, Y)](#MPIN.GET_Y) ⇒
+    -   [.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message)](#MPIN.CLIENT) ⇒
+    -   [.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa)](#MPIN.SERVER) ⇒
+    -   [.PRECOMPUTE(TOKEN, CID, G1, G2)](#MPIN.PRECOMPUTE) ⇒
+    -   [.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W)](#MPIN.HASH_ALL) ⇒
+    -   [.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK)](#MPIN.CLIENT_KEY) ⇒
+    -   [.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK)](#MPIN.SERVER_KEY) ⇒
+    -   [.GET_DVS_KEYPAIR(rng, Z, Pa)](#MPIN.GET_DVS_KEYPAIR) ⇒
 
-<a name="new_MPIN_new"></a>
+<a name="new_MPIN_new" />
 
 ### new MPIN()
+
 Creates an instance of MPIN
 
-<a name="MPIN.today"></a>
+<a name="MPIN.today" />
 
 ### MPIN.today() ⇒
+
 Get epoch time for today
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: time in slots since epoch  
-**this**: <code>{MPIN}</code>  
-<a name="MPIN.bytestostring"></a>
+**this**: <code>{"{"}MPIN{"}"}</code>  
+<a name="MPIN.bytestostring" />
 
 ### MPIN.bytestostring(b) ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: s string  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| b | byte array |
+| ----- | ----------- |
+| b     | byte array  |
 
-<a name="MPIN.stringtobytes"></a>
+<a name="MPIN.stringtobytes" />
 
 ### MPIN.stringtobytes(s) ⇒
+
 Convert a string to byte array
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: b byte array  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | string |
+| ----- | ----------- |
+| s     | string      |
 
-<a name="MPIN.comparebytes"></a>
+<a name="MPIN.comparebytes" />
 
 ### MPIN.comparebytes(a, b) ⇒
+
 Convert byte arrays
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: true if equal  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| a | byte array |
-| b | byte array |
+| ----- | ----------- |
+| a     | byte array  |
+| b     | byte array  |
 
-<a name="MPIN.mpin_hash"></a>
+<a name="MPIN.mpin_hash" />
 
-### MPIN.mpin\_hash(c, U) ⇒
+### MPIN.mpin_hash(c, U) ⇒
+
 Hash values
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: R hash value  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP8 instance |
-| U | ECP unstancebyte array |
+| Param | Description            |
+| ----- | ---------------------- |
+| c     | FP8 instance           |
+| U     | ECP unstancebyte array |
 
-<a name="MPIN.hashit"></a>
+<a name="MPIN.hashit" />
 
 ### MPIN.hashit(sha, n, B) ⇒
+
 General purpose hash function
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: R hash value  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| n | Integer |
-| B | byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| sha   | is the hash type |
+| n     | Integer          |
+| B     | byte array       |
 
-<a name="MPIN.map"></a>
+<a name="MPIN.map" />
 
 ### MPIN.map(u, cb) ⇒
+
 maps a random u to a point on the curve
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: P ECP pointhash value  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| u | BIG numberInteger |
-| cb | an integer representing the "sign" of y, in fact its least significant bit. |
+| Param | Description                                                                 |
+| ----- | --------------------------------------------------------------------------- |
+| u     | BIG numberInteger                                                           |
+| cb    | an integer representing the "sign" of y, in fact its least significant bit. |
 
-<a name="MPIN.unmap"></a>
+<a name="MPIN.unmap" />
 
 ### MPIN.unmap(u, P) ⇒
+
 returns u derived from P. Random value in range 1 to return value should then be added to u
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: r Value that should be added to u to derive P  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| u | BIG numberInteger |
-| P | ECP pointhash value |
+| Param | Description         |
+| ----- | ------------------- |
+| u     | BIG numberInteger   |
+| P     | ECP pointhash value |
 
-<a name="MPIN.RECOMBINE_G1"></a>
+<a name="MPIN.RECOMBINE_G1" />
 
-### MPIN.RECOMBINE\_G1(R1, R2, R) ⇒
+### MPIN.RECOMBINE_G1(R1, R2, R) ⇒
+
 Add two members from the group G1
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| R1 | Input member of G1 |
-| R2 | Input member of G1 |
-| R | Output member of G1. R=R1+R2 |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| R1    | Input member of G1           |
+| R2    | Input member of G1           |
+| R     | Output member of G1. R=R1+R2 |
 
-<a name="MPIN.RECOMBINE_G2"></a>
+<a name="MPIN.RECOMBINE_G2" />
 
-### MPIN.RECOMBINE\_G2(W1, W2, W) ⇒
+### MPIN.RECOMBINE_G2(W1, W2, W) ⇒
+
 Add two members from the group G2
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| W1 | Input member of G2 |
-| W2 | Input member of G2 |
-| W | Output member of G2. W=W1+W2 |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| W1    | Input member of G2           |
+| W2    | Input member of G2           |
+| W     | Output member of G2. W=W1+W2 |
 
-<a name="MPIN.HASH_ID"></a>
+<a name="MPIN.HASH_ID" />
 
-### MPIN.HASH\_ID(sha, ID) ⇒
+### MPIN.HASH_ID(sha, ID) ⇒
+
 Hash the identity
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: hash value  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| ID | Identity as byte array |
+| Param | Description            |
+| ----- | ---------------------- |
+| sha   | is the hash type       |
+| ID    | Identity as byte array |
 
-<a name="MPIN.RANDOM_GENERATE"></a>
+<a name="MPIN.RANDOM_GENERATE" />
 
-### MPIN.RANDOM\_GENERATE(rng, S) ⇒
+### MPIN.RANDOM_GENERATE(rng, S) ⇒
+
 Create random secret
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | cryptographically secure random number generator |
-| S | Random secret value |
+| Param | Description                                      |
+| ----- | ------------------------------------------------ |
+| rng   | cryptographically secure random number generator |
+| S     | Random secret value                              |
 
-<a name="MPIN.EXTRACT_PIN"></a>
+<a name="MPIN.EXTRACT_PIN" />
 
-### MPIN.EXTRACT\_PIN() ⇒
+### MPIN.EXTRACT_PIN() ⇒
+
 Extract a PIN number from a client secret
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: token  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: pin PIN value  
 **Parameter**: TOKEN Client secret  
-<a name="MPIN.EXTRACT_FACTOR"></a>
+<a name="MPIN.EXTRACT_FACTOR" />
 
-### MPIN.EXTRACT\_FACTOR() ⇒
+### MPIN.EXTRACT_FACTOR() ⇒
+
 Extract factor from TOKEN for identity CID
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: token  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: factor Value to extract  
 **Parameter**: facbits Number of bits in factor  
 **Parameter**: TOKEN Token value  
-<a name="MPIN.RESTORE_FACTOR"></a>
+<a name="MPIN.RESTORE_FACTOR" />
 
-### MPIN.RESTORE\_FACTOR() ⇒
+### MPIN.RESTORE_FACTOR() ⇒
+
 Restore factor to TOKEN for identity CID
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: token  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: factor Value to extract  
 **Parameter**: facbits Number of bits in factor  
 **Parameter**: TOKEN Token value  
-<a name="MPIN.GET_SERVER_SECRET"></a>
+<a name="MPIN.GET_SERVER_SECRET" />
 
-### MPIN.GET\_SERVER\_SECRET(S, SST) ⇒
+### MPIN.GET_SERVER_SECRET(S, SST) ⇒
+
 Create a server secret in G2 from a master secret
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| S | Master secret |
-| SST | Server secret = s.Q where Q is a fixed generator of G2 |
+| Param | Description                                            |
+| ----- | ------------------------------------------------------ |
+| S     | Master secret                                          |
+| SST   | Server secret = s.Q where Q is a fixed generator of G2 |
 
-<a name="MPIN.GET_G1_MULTIPLE"></a>
+<a name="MPIN.GET_G1_MULTIPLE" />
 
-### MPIN.GET\_G1\_MULTIPLE(type, x, G, W) ⇒
+### MPIN.GET_G1_MULTIPLE(type, x, G, W) ⇒
+
 Find a random multiple of a point in G1
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 **Parameter**: rng cryptographically secure random number generator  
 
-| Param | Description |
-| --- | --- |
-| type | determines type of action to be taken |
-| x | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| G | if type=0 a point in G1, else an octet to be mapped to G1 |
-| W | the output =x.G or x.M(G), where M(.) is a mapping |
+| Param | Description                                                                                |
+| ----- | ------------------------------------------------------------------------------------------ |
+| type  | determines type of action to be taken                                                      |
+| x     | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
+| G     | if type=0 a point in G1, else an octet to be mapped to G1                                  |
+| W     | the output =x.G or x.M(G), where M(.) is a mapping                                         |
 
-<a name="MPIN.GET_CLIENT_SECRET"></a>
+<a name="MPIN.GET_CLIENT_SECRET" />
 
-### MPIN.GET\_CLIENT\_SECRET(S, CID, CST) ⇒
+### MPIN.GET_CLIENT_SECRET(S, CID, CST) ⇒
+
 Create a client secret in G1 from a master secret and the client ID
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| S | is an input master secret |
-| CID | is the input client identity |
-| CST | is the full client secret = s.H(ID) |
+| Param | Description                         |
+| ----- | ----------------------------------- |
+| S     | is an input master secret           |
+| CID   | is the input client identity        |
+| CST   | is the full client secret = s.H(ID) |
 
-<a name="MPIN.GET_CLIENT_PERMIT"></a>
+<a name="MPIN.GET_CLIENT_PERMIT" />
 
-### MPIN.GET\_CLIENT\_PERMIT(sha, date, S, CID, CTT) ⇒
+### MPIN.GET_CLIENT_PERMIT(sha, date, S, CID, CTT) ⇒
+
 Create a Time Permit in G1 from a master secret and the client ID
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. |
-| S | is an input master secret |
-| CID | is the input client identity |
-| CTT | is a Time Permit for the given date = s.H(d|H(ID)) |
+| Param | Description                                 |        |
+| ----- | ------------------------------------------- | ------ |
+| sha   | is the hash type                            |        |
+| date  | is input date, in days since the epoch.     |        |
+| S     | is an input master secret                   |        |
+| CID   | is the input client identity                |        |
+| CTT   | is a Time Permit for the given date = s.H(d | H(ID)) |
 
-<a name="MPIN.CLIENT_1"></a>
+<a name="MPIN.CLIENT_1" />
 
-### MPIN.CLIENT\_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT) ⇒
+### MPIN.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT) ⇒
+
 Perform first pass of the client side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CLIENT_ID | is the input client identity |
-| rng | is a pointer to a cryptographically secure random number generator |
-| X | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| pin | is the input PIN number |
-| TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| SEC | is output = CS+TP, where CS=is the reconstructed client secret, and TP is the time permit |
-| xID | is output = x.H(ID) |
-| xCID | is output = x.(H(ID)+H(d|H(ID))) |
-| PERMIT | is the input time permit |
+| Param     | Description                                                                                |         |
+| --------- | ------------------------------------------------------------------------------------------ | ------- |
+| sha       | is the hash type                                                                           |         |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled                  |         |
+| CLIENT_ID | is the input client identity                                                               |         |
+| rng       | is a pointer to a cryptographically secure random number generator                         |         |
+| X         | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |         |
+| pin       | is the input PIN number                                                                    |         |
+| TOKEN     | is the input M-Pin token (the client secret with PIN portion removed)                      |         |
+| SEC       | is output = CS+TP, where CS=is the reconstructed client secret, and TP is the time permit  |         |
+| xID       | is output = x.H(ID)                                                                        |         |
+| xCID      | is output = x.(H(ID)+H(d                                                                   | H(ID))) |
+| PERMIT    | is the input time permit                                                                   |         |
 
-<a name="MPIN.CLIENT_2"></a>
+<a name="MPIN.CLIENT_2" />
 
-### MPIN.CLIENT\_2(X, Y, SEC) ⇒
+### MPIN.CLIENT_2(X, Y, SEC) ⇒
+
 Perform second pass of the client side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| X | an input, a locally generated random number |
-| Y | an input random challenge from the server |
-| SEC | on output = -(x+y).V |
+| Param | Description                                 |
+| ----- | ------------------------------------------- |
+| X     | an input, a locally generated random number |
+| Y     | an input random challenge from the server   |
+| SEC   | on output = -(x+y).V                        |
 
-<a name="MPIN.SERVER_1"></a>
+<a name="MPIN.SERVER_1" />
 
-### MPIN.SERVER\_1(sha, date, CID, HID, HTID) ⇒
+### MPIN.SERVER_1(sha, date, CID, HID, HTID) ⇒
+
 Perform first pass of the server side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CID | is the input claimed client identity |
-| HID | is output H(ID), a hash of the client ID |
-| HTID | is output H(ID)+H(d|H(ID)) |
+| Param | Description                                                               |        |
+| ----- | ------------------------------------------------------------------------- | ------ |
+| sha   | is the hash type                                                          |        |
+| date  | is input date, in days since the epoch. Set to 0 if Time permits disabled |        |
+| CID   | is the input claimed client identity                                      |        |
+| HID   | is output H(ID), a hash of the client ID                                  |        |
+| HTID  | is output H(ID)+H(d                                                       | H(ID)) |
 
-<a name="MPIN.SERVER_2"></a>
+<a name="MPIN.SERVER_2" />
 
-### MPIN.SERVER\_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa) ⇒
+### MPIN.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa) ⇒
+
 Perform third pass on the server side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| HID | is input H(ID), a hash of the client ID |
-| HTID | is input H(ID)+H(d|H(ID)) |
-| Y | is the input server's randomly generated challenge |
-| SST | is the input server secret |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| mSEC | is an input from the client |
-| E | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| F | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| Pa | is the input public key from the client, z.Q or NULL if the client uses regular mpin |
+| Param | Description                                                                          |         |
+| ----- | ------------------------------------------------------------------------------------ | ------- |
+| date  | is input date, in days since the epoch. Set to 0 if Time permits disabled            |         |
+| HID   | is input H(ID), a hash of the client ID                                              |         |
+| HTID  | is input H(ID)+H(d                                                                   | H(ID))  |
+| Y     | is the input server's randomly generated challenge                                   |         |
+| SST   | is the input server secret                                                           |         |
+| xID   | is input from the client = x.H(ID)                                                   |         |
+| xCID  | is input from the client= x.(H(ID)+H(d                                               | H(ID))) |
+| mSEC  | is an input from the client                                                          |         |
+| E     | is an output to help the Kangaroos to find the PIN error, or NULL if not required    |         |
+| F     | is an output to help the Kangaroos to find the PIN error, or NULL if not required    |         |
+| Pa    | is the input public key from the client, z.Q or NULL if the client uses regular mpin |         |
 
-<a name="MPIN.KANGAROO"></a>
+<a name="MPIN.KANGAROO" />
 
 ### MPIN.KANGAROO(E, F) ⇒
+
 Use Kangaroos to find PIN error
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: 0 if Kangaroos failed, or the PIN error e  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| E | a member of the group GT |
-| F | a member of the group GT =  E^e |
+| Param | Description                     |
+| ----- | ------------------------------- |
+| E     | a member of the group GT        |
+| F     | a member of the group GT =  E^e |
 
-<a name="MPIN.GET_TIME"></a>
+<a name="MPIN.GET_TIME" />
 
-### MPIN.GET\_TIME() ⇒
+### MPIN.GET_TIME() ⇒
+
 Time since epoch
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: time since epoch  
-**this**: <code>{MPIN}</code>  
-<a name="MPIN.GET_Y"></a>
+**this**: <code>{"{"}MPIN{"}"}</code>  
+<a name="MPIN.GET_Y" />
 
-### MPIN.GET\_Y(sha, TimeValue, xCID, Y) ⇒
+### MPIN.GET_Y(sha, TimeValue, xCID, Y) ⇒
+
 Generate Y=H(s,O), where s is epoch time, O is a byte array, and H(.) is a hash function
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| TimeValue | is epoch time in seconds |
-| xCID | input bytearray is an input octet |
-| Y | output value |
+| Param     | Description                       |
+| --------- | --------------------------------- |
+| sha       | is the hash type                  |
+| TimeValue | is epoch time in seconds          |
+| xCID      | input bytearray is an input octet |
+| Y         | output value                      |
 
-<a name="MPIN.CLIENT"></a>
+<a name="MPIN.CLIENT" />
 
 ### MPIN.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message) ⇒
+
 Perform client side of the one-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CLIENT_ID | is the input client identity |
-| rng | is a pointer to a cryptographically secure random number generator |
-| X | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| pin | is the input PIN number |
-| TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| SEC | is output = -(x+y)(CS+TP), where CS is the reconstructed client secret, and TP is the time permit |
-| xID | is output = x.H(ID) |
-| xCID | is output = x.(H(ID)+H(d|H(ID))) |
-| PERMIT | is the input time permit |
-| TimeValue | is input epoch time in seconds - a timestamp |
-| Y | is output H(t|U) or H(t|UT) if Time Permits enabled |
-| Message | is the message to be signed |
+| Param     | Description                                                                                       |           |                             |
+| --------- | ------------------------------------------------------------------------------------------------- | --------- | --------------------------- |
+| sha       | is the hash type                                                                                  |           |                             |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled                         |           |                             |
+| CLIENT_ID | is the input client identity                                                                      |           |                             |
+| rng       | is a pointer to a cryptographically secure random number generator                                |           |                             |
+| X         | an output internally randomly generated if R!=NULL, otherwise must be provided as an input        |           |                             |
+| pin       | is the input PIN number                                                                           |           |                             |
+| TOKEN     | is the input M-Pin token (the client secret with PIN portion removed)                             |           |                             |
+| SEC       | is output = -(x+y)(CS+TP), where CS is the reconstructed client secret, and TP is the time permit |           |                             |
+| xID       | is output = x.H(ID)                                                                               |           |                             |
+| xCID      | is output = x.(H(ID)+H(d                                                                          | H(ID)))   |                             |
+| PERMIT    | is the input time permit                                                                          |           |                             |
+| TimeValue | is input epoch time in seconds - a timestamp                                                      |           |                             |
+| Y         | is output H(t                                                                                     | U) or H(t | UT) if Time Permits enabled |
+| Message   | is the message to be signed                                                                       |           |                             |
 
-<a name="MPIN.SERVER"></a>
+<a name="MPIN.SERVER" />
 
 ### MPIN.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa) ⇒
+
 Perform server side of the one-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| HID | is output H(ID), a hash of the client ID |
-| HTID | is output H(ID)+H(d|H(ID)) |
-| Y | is output H(t|U) or H(t|UT) if Time Permits enabled |
-| SST | is the input server secret |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| mSEC | is an input from the client |
-| E | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| F | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| CID | is the input claimed client identity |
-| TimeValue | is input epoch time in seconds - a timestamp |
-| MESSAGE | is the message to be signed |
-| Pa | is input from the client z.Q or NULL if the key-escrow less scheme is not used |
+| Param     | Description                                                                       |           |                             |
+| --------- | --------------------------------------------------------------------------------- | --------- | --------------------------- |
+| sha       | is the hash type                                                                  |           |                             |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled         |           |                             |
+| HID       | is output H(ID), a hash of the client ID                                          |           |                             |
+| HTID      | is output H(ID)+H(d                                                               | H(ID))    |                             |
+| Y         | is output H(t                                                                     | U) or H(t | UT) if Time Permits enabled |
+| SST       | is the input server secret                                                        |           |                             |
+| xID       | is input from the client = x.H(ID)                                                |           |                             |
+| xCID      | is input from the client= x.(H(ID)+H(d                                            | H(ID)))   |                             |
+| mSEC      | is an input from the client                                                       |           |                             |
+| E         | is an output to help the Kangaroos to find the PIN error, or NULL if not required |           |                             |
+| F         | is an output to help the Kangaroos to find the PIN error, or NULL if not required |           |                             |
+| CID       | is the input claimed client identity                                              |           |                             |
+| TimeValue | is input epoch time in seconds - a timestamp                                      |           |                             |
+| MESSAGE   | is the message to be signed                                                       |           |                             |
+| Pa        | is input from the client z.Q or NULL if the key-escrow less scheme is not used    |           |                             |
 
-<a name="MPIN.PRECOMPUTE"></a>
+<a name="MPIN.PRECOMPUTE" />
 
 ### MPIN.PRECOMPUTE(TOKEN, CID, G1, G2) ⇒
+
 Precompute values for use by the client side of M-Pin Full
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
+| Param | Description                                                           |
+| ----- | --------------------------------------------------------------------- |
 | TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| CID | is the input client identity |
-| G1 | precomputed output |
-| G2 | precomputed output |
+| CID   | is the input client identity                                          |
+| G1    | precomputed output                                                    |
+| G2    | precomputed output                                                    |
 
-<a name="MPIN.HASH_ALL"></a>
+<a name="MPIN.HASH_ALL" />
 
-### MPIN.HASH\_ALL(sha, HID, xID, xCID, SEC, Y, R, W) ⇒
+### MPIN.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W) ⇒
+
 Hash the session transcript
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: H the output is the hash of all of the above that apply  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| HID | is the hashed input client ID = H(ID) |
-| xID | is the client output = x.H(ID) |
-| xCID | is the client output = x.(H(ID)+H(T|H(ID))) |
-| SEC | is the client part response |
-| Y | is the server challenge |
-| R | is the client part response |
-| W | is the server part response |
+| Param | Description                           |         |
+| ----- | ------------------------------------- | ------- |
+| sha   | is the hash type                      |         |
+| HID   | is the hashed input client ID = H(ID) |         |
+| xID   | is the client output = x.H(ID)        |         |
+| xCID  | is the client output = x.(H(ID)+H(T   | H(ID))) |
+| SEC   | is the client part response           |         |
+| Y     | is the server challenge               |         |
+| R     | is the client part response           |         |
+| W     | is the server part response           |         |
 
-<a name="MPIN.CLIENT_KEY"></a>
+<a name="MPIN.CLIENT_KEY" />
 
-### MPIN.CLIENT\_KEY(sha, G1, G2, pin, R, X, H, wCID, CK) ⇒
+### MPIN.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK) ⇒
+
 Calculate Key on Client side for M-Pin Full
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| G1 | precomputed input |
-| G2 | precomputed input |
-| pin | is the input PIN number |
-| R | is an input, a locally generated random number |
-| X | is an input, a locally generated random number |
-| H | is an input, hash of the protocol transcript |
-| wCID | is the input Server-side Diffie-Hellman component |
-| CK | is the output calculated shared key |
+| Param | Description                                       |
+| ----- | ------------------------------------------------- |
+| sha   | is the hash type                                  |
+| G1    | precomputed input                                 |
+| G2    | precomputed input                                 |
+| pin   | is the input PIN number                           |
+| R     | is an input, a locally generated random number    |
+| X     | is an input, a locally generated random number    |
+| H     | is an input, hash of the protocol transcript      |
+| wCID  | is the input Server-side Diffie-Hellman component |
+| CK    | is the output calculated shared key               |
 
-<a name="MPIN.SERVER_KEY"></a>
+<a name="MPIN.SERVER_KEY" />
 
-### MPIN.SERVER\_KEY(h, Z, SST, W, H, HID, xID, xCID, SK) ⇒
+### MPIN.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK) ⇒
+
 Calculate Key on Server side for M-Pin Full
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| h | is the hash type |
-| Z | is the input Client-side Diffie-Hellman component |
-| SST | is the input server secret |
-| W | is an input random number generated by the server |
-| H | is an input, hash of the protocol transcript |
-| HID | is the hashed input client ID = H(ID) |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| SK | is the output calculated shared key |
+| Param | Description                                       |         |
+| ----- | ------------------------------------------------- | ------- |
+| h     | is the hash type                                  |         |
+| Z     | is the input Client-side Diffie-Hellman component |         |
+| SST   | is the input server secret                        |         |
+| W     | is an input random number generated by the server |         |
+| H     | is an input, hash of the protocol transcript      |         |
+| HID   | is the hashed input client ID = H(ID)             |         |
+| xID   | is input from the client = x.H(ID)                |         |
+| xCID  | is input from the client= x.(H(ID)+H(d            | H(ID))) |
+| SK    | is the output calculated shared key               |         |
 
-<a name="MPIN.GET_DVS_KEYPAIR"></a>
+<a name="MPIN.GET_DVS_KEYPAIR" />
 
-### MPIN.GET\_DVS\_KEYPAIR(rng, Z, Pa) ⇒
+### MPIN.GET_DVS_KEYPAIR(rng, Z, Pa) ⇒
+
 Generates a random public key for the client z.Q
 
 **Kind**: static method of [<code>MPIN</code>](#MPIN)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN}</code>  
+**this**: <code>{"{"}MPIN{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | cryptographically secure random number generator |
-| Z | an output internally randomly generated if R!=NULL, otherwise it must be provided as an input |
-| Pa | the output public key for the client |
-
+| Param | Description                                                                                   |
+| ----- | --------------------------------------------------------------------------------------------- |
+| rng   | cryptographically secure random number generator                                              |
+| Z     | an output internally randomly generated if R!=NULL, otherwise it must be provided as an input |
+| Pa    | the output public key for the client                                                          |
diff --git a/docs/cryptojs/mpin192.md b/docs/cryptojs/mpin192.md
index 2ed4f5f..adcc560 100644
--- a/docs/cryptojs/mpin192.md
+++ b/docs/cryptojs/mpin192.md
@@ -3,577 +3,610 @@
 title: MPIN192
 sidebar_label: MPIN192
 ---
-
-<a name="MPIN192"></a>
+<a name="MPIN192" />
 
 ## MPIN192
+
 **Kind**: global class  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-* [MPIN192](#MPIN192)
-    * [new MPIN192()](#new_MPIN192_new)
-    * [.today()](#MPIN192.today) ⇒
-    * [.bytestostring(b)](#MPIN192.bytestostring) ⇒
-    * [.stringtobytes(s)](#MPIN192.stringtobytes) ⇒
-    * [.comparebytes(a, b)](#MPIN192.comparebytes) ⇒
-    * [.mpin_hash(c, U)](#MPIN192.mpin_hash) ⇒
-    * [.hashit(sha, n, B)](#MPIN192.hashit) ⇒
-    * [.map(u, cb)](#MPIN192.map) ⇒
-    * [.unmap(u, P)](#MPIN192.unmap) ⇒
-    * [.RECOMBINE_G1(R1, R2, R)](#MPIN192.RECOMBINE_G1) ⇒
-    * [.RECOMBINE_G2(W1, W2, W)](#MPIN192.RECOMBINE_G2) ⇒
-    * [.HASH_ID(sha, ID)](#MPIN192.HASH_ID) ⇒
-    * [.RANDOM_GENERATE(rng, S)](#MPIN192.RANDOM_GENERATE) ⇒
-    * [.EXTRACT_PIN()](#MPIN192.EXTRACT_PIN) ⇒
-    * [.EXTRACT_FACTOR()](#MPIN192.EXTRACT_FACTOR) ⇒
-    * [.RESTORE_FACTOR()](#MPIN192.RESTORE_FACTOR) ⇒
-    * [.GET_SERVER_SECRET(S, SST)](#MPIN192.GET_SERVER_SECRET) ⇒
-    * [.GET_G1_MULTIPLE(type, x, G, W)](#MPIN192.GET_G1_MULTIPLE) ⇒
-    * [.GET_CLIENT_SECRET(S, CID, CST)](#MPIN192.GET_CLIENT_SECRET) ⇒
-    * [.GET_CLIENT_PERMIT(sha, date, S, CID, CTT)](#MPIN192.GET_CLIENT_PERMIT) ⇒
-    * [.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT)](#MPIN192.CLIENT_1) ⇒
-    * [.CLIENT_2(X, Y, SEC)](#MPIN192.CLIENT_2) ⇒
-    * [.SERVER_1(sha, date, CID, HID, HTID)](#MPIN192.SERVER_1) ⇒
-    * [.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa)](#MPIN192.SERVER_2) ⇒
-    * [.KANGAROO(E, F)](#MPIN192.KANGAROO) ⇒
-    * [.GET_TIME()](#MPIN192.GET_TIME) ⇒
-    * [.GET_Y(sha, TimeValue, xCID, Y)](#MPIN192.GET_Y) ⇒
-    * [.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message)](#MPIN192.CLIENT) ⇒
-    * [.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa)](#MPIN192.SERVER) ⇒
-    * [.PRECOMPUTE(TOKEN, CID, G1, G2)](#MPIN192.PRECOMPUTE) ⇒
-    * [.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W)](#MPIN192.HASH_ALL) ⇒
-    * [.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK)](#MPIN192.CLIENT_KEY) ⇒
-    * [.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK)](#MPIN192.SERVER_KEY) ⇒
-    * [.GET_DVS_KEYPAIR(rng, Z, Pa)](#MPIN192.GET_DVS_KEYPAIR) ⇒
+-   [MPIN192](#MPIN192)
+    -   [new MPIN192()](#new_MPIN192_new)
+    -   [.today()](#MPIN192.today) ⇒
+    -   [.bytestostring(b)](#MPIN192.bytestostring) ⇒
+    -   [.stringtobytes(s)](#MPIN192.stringtobytes) ⇒
+    -   [.comparebytes(a, b)](#MPIN192.comparebytes) ⇒
+    -   [.mpin_hash(c, U)](#MPIN192.mpin_hash) ⇒
+    -   [.hashit(sha, n, B)](#MPIN192.hashit) ⇒
+    -   [.map(u, cb)](#MPIN192.map) ⇒
+    -   [.unmap(u, P)](#MPIN192.unmap) ⇒
+    -   [.RECOMBINE_G1(R1, R2, R)](#MPIN192.RECOMBINE_G1) ⇒
+    -   [.RECOMBINE_G2(W1, W2, W)](#MPIN192.RECOMBINE_G2) ⇒
+    -   [.HASH_ID(sha, ID)](#MPIN192.HASH_ID) ⇒
+    -   [.RANDOM_GENERATE(rng, S)](#MPIN192.RANDOM_GENERATE) ⇒
+    -   [.EXTRACT_PIN()](#MPIN192.EXTRACT_PIN) ⇒
+    -   [.EXTRACT_FACTOR()](#MPIN192.EXTRACT_FACTOR) ⇒
+    -   [.RESTORE_FACTOR()](#MPIN192.RESTORE_FACTOR) ⇒
+    -   [.GET_SERVER_SECRET(S, SST)](#MPIN192.GET_SERVER_SECRET) ⇒
+    -   [.GET_G1_MULTIPLE(type, x, G, W)](#MPIN192.GET_G1_MULTIPLE) ⇒
+    -   [.GET_CLIENT_SECRET(S, CID, CST)](#MPIN192.GET_CLIENT_SECRET) ⇒
+    -   [.GET_CLIENT_PERMIT(sha, date, S, CID, CTT)](#MPIN192.GET_CLIENT_PERMIT) ⇒
+    -   [.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT)](#MPIN192.CLIENT_1) ⇒
+    -   [.CLIENT_2(X, Y, SEC)](#MPIN192.CLIENT_2) ⇒
+    -   [.SERVER_1(sha, date, CID, HID, HTID)](#MPIN192.SERVER_1) ⇒
+    -   [.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa)](#MPIN192.SERVER_2) ⇒
+    -   [.KANGAROO(E, F)](#MPIN192.KANGAROO) ⇒
+    -   [.GET_TIME()](#MPIN192.GET_TIME) ⇒
+    -   [.GET_Y(sha, TimeValue, xCID, Y)](#MPIN192.GET_Y) ⇒
+    -   [.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message)](#MPIN192.CLIENT) ⇒
+    -   [.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa)](#MPIN192.SERVER) ⇒
+    -   [.PRECOMPUTE(TOKEN, CID, G1, G2)](#MPIN192.PRECOMPUTE) ⇒
+    -   [.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W)](#MPIN192.HASH_ALL) ⇒
+    -   [.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK)](#MPIN192.CLIENT_KEY) ⇒
+    -   [.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK)](#MPIN192.SERVER_KEY) ⇒
+    -   [.GET_DVS_KEYPAIR(rng, Z, Pa)](#MPIN192.GET_DVS_KEYPAIR) ⇒
 
-<a name="new_MPIN192_new"></a>
+<a name="new_MPIN192_new" />
 
 ### new MPIN192()
+
 Creates an instance of MPIN192
 
-<a name="MPIN192.today"></a>
+<a name="MPIN192.today" />
 
 ### MPIN192.today() ⇒
+
 Get epoch time
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: time in slots since epoch  
-**this**: <code>{MPIN192}</code>  
-<a name="MPIN192.bytestostring"></a>
+**this**: <code>{"{"}MPIN192{"}"}</code>  
+<a name="MPIN192.bytestostring" />
 
 ### MPIN192.bytestostring(b) ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: s string  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| b | byte array |
+| ----- | ----------- |
+| b     | byte array  |
 
-<a name="MPIN192.stringtobytes"></a>
+<a name="MPIN192.stringtobytes" />
 
 ### MPIN192.stringtobytes(s) ⇒
+
 Convert a string to byte array
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: b byte array  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | string |
+| ----- | ----------- |
+| s     | string      |
 
-<a name="MPIN192.comparebytes"></a>
+<a name="MPIN192.comparebytes" />
 
 ### MPIN192.comparebytes(a, b) ⇒
+
 Convert byte arrays
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: true if equal  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| a | byte array |
-| b | byte array |
+| ----- | ----------- |
+| a     | byte array  |
+| b     | byte array  |
 
-<a name="MPIN192.mpin_hash"></a>
+<a name="MPIN192.mpin_hash" />
 
-### MPIN192.mpin\_hash(c, U) ⇒
+### MPIN192.mpin_hash(c, U) ⇒
+
 Hash values
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: R hash value  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP8 instance |
-| U | ECP unstancebyte array |
+| Param | Description            |
+| ----- | ---------------------- |
+| c     | FP8 instance           |
+| U     | ECP unstancebyte array |
 
-<a name="MPIN192.hashit"></a>
+<a name="MPIN192.hashit" />
 
 ### MPIN192.hashit(sha, n, B) ⇒
+
 General purpose hash function
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: R hash value  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| n | Integer |
-| B | byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| sha   | is the hash type |
+| n     | Integer          |
+| B     | byte array       |
 
-<a name="MPIN192.map"></a>
+<a name="MPIN192.map" />
 
 ### MPIN192.map(u, cb) ⇒
+
 maps a random u to a point on the curve
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: P ECP pointhash value  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| u | BIG numberInteger |
-| cb | an integer representing the "sign" of y, in fact its least significant bit. |
+| Param | Description                                                                 |
+| ----- | --------------------------------------------------------------------------- |
+| u     | BIG numberInteger                                                           |
+| cb    | an integer representing the "sign" of y, in fact its least significant bit. |
 
-<a name="MPIN192.unmap"></a>
+<a name="MPIN192.unmap" />
 
 ### MPIN192.unmap(u, P) ⇒
+
 returns u derived from P. Random value in range 1 to return value should then be added to u
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: r Value that should be added to u to derive P  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| u | BIG numberInteger |
-| P | ECP pointhash value |
+| Param | Description         |
+| ----- | ------------------- |
+| u     | BIG numberInteger   |
+| P     | ECP pointhash value |
 
-<a name="MPIN192.RECOMBINE_G1"></a>
+<a name="MPIN192.RECOMBINE_G1" />
 
-### MPIN192.RECOMBINE\_G1(R1, R2, R) ⇒
+### MPIN192.RECOMBINE_G1(R1, R2, R) ⇒
+
 Add two members from the group G1
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| R1 | Input member of G1 |
-| R2 | Input member of G1 |
-| R | Output member of G1. R=R1+R2 |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| R1    | Input member of G1           |
+| R2    | Input member of G1           |
+| R     | Output member of G1. R=R1+R2 |
 
-<a name="MPIN192.RECOMBINE_G2"></a>
+<a name="MPIN192.RECOMBINE_G2" />
 
-### MPIN192.RECOMBINE\_G2(W1, W2, W) ⇒
+### MPIN192.RECOMBINE_G2(W1, W2, W) ⇒
+
 Add two members from the group G2
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| W1 | Input member of G2 |
-| W2 | Input member of G2 |
-| W | Output member of G2. W=W1+W2 |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| W1    | Input member of G2           |
+| W2    | Input member of G2           |
+| W     | Output member of G2. W=W1+W2 |
 
-<a name="MPIN192.HASH_ID"></a>
+<a name="MPIN192.HASH_ID" />
 
-### MPIN192.HASH\_ID(sha, ID) ⇒
+### MPIN192.HASH_ID(sha, ID) ⇒
+
 Hash the identity
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: hash value  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| ID | Identity as byte array |
+| Param | Description            |
+| ----- | ---------------------- |
+| sha   | is the hash type       |
+| ID    | Identity as byte array |
 
-<a name="MPIN192.RANDOM_GENERATE"></a>
+<a name="MPIN192.RANDOM_GENERATE" />
 
-### MPIN192.RANDOM\_GENERATE(rng, S) ⇒
+### MPIN192.RANDOM_GENERATE(rng, S) ⇒
+
 Create random secret
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | cryptographically secure random number generator |
-| S | Random secret value |
+| Param | Description                                      |
+| ----- | ------------------------------------------------ |
+| rng   | cryptographically secure random number generator |
+| S     | Random secret value                              |
 
-<a name="MPIN192.EXTRACT_PIN"></a>
+<a name="MPIN192.EXTRACT_PIN" />
 
-### MPIN192.EXTRACT\_PIN() ⇒
+### MPIN192.EXTRACT_PIN() ⇒
+
 Extract a PIN number from a client secret
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: token  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: pin PIN value  
 **Parameter**: TOKEN Client secret  
-<a name="MPIN192.EXTRACT_FACTOR"></a>
+<a name="MPIN192.EXTRACT_FACTOR" />
 
-### MPIN192.EXTRACT\_FACTOR() ⇒
+### MPIN192.EXTRACT_FACTOR() ⇒
+
 Extract factor from TOKEN for identity CID
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: token  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: factor Value to extract  
 **Parameter**: facbits Number of bits in factor  
 **Parameter**: TOKEN Token value  
-<a name="MPIN192.RESTORE_FACTOR"></a>
+<a name="MPIN192.RESTORE_FACTOR" />
 
-### MPIN192.RESTORE\_FACTOR() ⇒
+### MPIN192.RESTORE_FACTOR() ⇒
+
 Restore factor to TOKEN for identity CID
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: token  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: factor Value to extract  
 **Parameter**: facbits Number of bits in factor  
 **Parameter**: TOKEN Token value  
-<a name="MPIN192.GET_SERVER_SECRET"></a>
+<a name="MPIN192.GET_SERVER_SECRET" />
 
-### MPIN192.GET\_SERVER\_SECRET(S, SST) ⇒
+### MPIN192.GET_SERVER_SECRET(S, SST) ⇒
+
 Create a server secret in G2 from a master secret
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| S | Master secret |
-| SST | Server secret = s.Q where Q is a fixed generator of G2 |
+| Param | Description                                            |
+| ----- | ------------------------------------------------------ |
+| S     | Master secret                                          |
+| SST   | Server secret = s.Q where Q is a fixed generator of G2 |
 
-<a name="MPIN192.GET_G1_MULTIPLE"></a>
+<a name="MPIN192.GET_G1_MULTIPLE" />
 
-### MPIN192.GET\_G1\_MULTIPLE(type, x, G, W) ⇒
+### MPIN192.GET_G1_MULTIPLE(type, x, G, W) ⇒
+
 Find a random multiple of a point in G1
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 **Parameter**: rng cryptographically secure random number generator  
 
-| Param | Description |
-| --- | --- |
-| type | determines type of action to be taken |
-| x | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| G | if type=0 a point in G1, else an octet to be mapped to G1 |
-| W | the output =x.G or x.M(G), where M(.) is a mapping |
+| Param | Description                                                                                |
+| ----- | ------------------------------------------------------------------------------------------ |
+| type  | determines type of action to be taken                                                      |
+| x     | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
+| G     | if type=0 a point in G1, else an octet to be mapped to G1                                  |
+| W     | the output =x.G or x.M(G), where M(.) is a mapping                                         |
 
-<a name="MPIN192.GET_CLIENT_SECRET"></a>
+<a name="MPIN192.GET_CLIENT_SECRET" />
 
-### MPIN192.GET\_CLIENT\_SECRET(S, CID, CST) ⇒
+### MPIN192.GET_CLIENT_SECRET(S, CID, CST) ⇒
+
 Create a client secret in G1 from a master secret and the client ID
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| S | is an input master secret |
-| CID | is the input client identity |
-| CST | is the full client secret = s.H(ID) |
+| Param | Description                         |
+| ----- | ----------------------------------- |
+| S     | is an input master secret           |
+| CID   | is the input client identity        |
+| CST   | is the full client secret = s.H(ID) |
 
-<a name="MPIN192.GET_CLIENT_PERMIT"></a>
+<a name="MPIN192.GET_CLIENT_PERMIT" />
 
-### MPIN192.GET\_CLIENT\_PERMIT(sha, date, S, CID, CTT) ⇒
+### MPIN192.GET_CLIENT_PERMIT(sha, date, S, CID, CTT) ⇒
+
 Create a Time Permit in G1 from a master secret and the client ID
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. |
-| S | is an input master secret |
-| CID | is the input client identity |
-| CTT | is a Time Permit for the given date = s.H(d|H(ID)) |
+| Param | Description                                 |        |
+| ----- | ------------------------------------------- | ------ |
+| sha   | is the hash type                            |        |
+| date  | is input date, in days since the epoch.     |        |
+| S     | is an input master secret                   |        |
+| CID   | is the input client identity                |        |
+| CTT   | is a Time Permit for the given date = s.H(d | H(ID)) |
 
-<a name="MPIN192.CLIENT_1"></a>
+<a name="MPIN192.CLIENT_1" />
 
-### MPIN192.CLIENT\_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT) ⇒
+### MPIN192.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT) ⇒
+
 Perform first pass of the client side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CLIENT_ID | is the input client identity |
-| rng | is a pointer to a cryptographically secure random number generator |
-| X | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| pin | is the input PIN number |
-| TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| SEC | is output = CS+TP, where CS=is the reconstructed client secret, and TP is the time permit |
-| xID | is output = x.H(ID) |
-| xCID | is output = x.(H(ID)+H(d|H(ID))) |
-| PERMIT | is the input time permit |
+| Param     | Description                                                                                |         |
+| --------- | ------------------------------------------------------------------------------------------ | ------- |
+| sha       | is the hash type                                                                           |         |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled                  |         |
+| CLIENT_ID | is the input client identity                                                               |         |
+| rng       | is a pointer to a cryptographically secure random number generator                         |         |
+| X         | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |         |
+| pin       | is the input PIN number                                                                    |         |
+| TOKEN     | is the input M-Pin token (the client secret with PIN portion removed)                      |         |
+| SEC       | is output = CS+TP, where CS=is the reconstructed client secret, and TP is the time permit  |         |
+| xID       | is output = x.H(ID)                                                                        |         |
+| xCID      | is output = x.(H(ID)+H(d                                                                   | H(ID))) |
+| PERMIT    | is the input time permit                                                                   |         |
 
-<a name="MPIN192.CLIENT_2"></a>
+<a name="MPIN192.CLIENT_2" />
 
-### MPIN192.CLIENT\_2(X, Y, SEC) ⇒
+### MPIN192.CLIENT_2(X, Y, SEC) ⇒
+
 Perform second pass of the client side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| X | an input, a locally generated random number |
-| Y | an input random challenge from the server |
-| SEC | on output = -(x+y).V |
+| Param | Description                                 |
+| ----- | ------------------------------------------- |
+| X     | an input, a locally generated random number |
+| Y     | an input random challenge from the server   |
+| SEC   | on output = -(x+y).V                        |
 
-<a name="MPIN192.SERVER_1"></a>
+<a name="MPIN192.SERVER_1" />
 
-### MPIN192.SERVER\_1(sha, date, CID, HID, HTID) ⇒
+### MPIN192.SERVER_1(sha, date, CID, HID, HTID) ⇒
+
 Perform first pass of the server side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CID | is the input claimed client identity |
-| HID | is output H(ID), a hash of the client ID |
-| HTID | is output H(ID)+H(d|H(ID)) |
+| Param | Description                                                               |        |
+| ----- | ------------------------------------------------------------------------- | ------ |
+| sha   | is the hash type                                                          |        |
+| date  | is input date, in days since the epoch. Set to 0 if Time permits disabled |        |
+| CID   | is the input claimed client identity                                      |        |
+| HID   | is output H(ID), a hash of the client ID                                  |        |
+| HTID  | is output H(ID)+H(d                                                       | H(ID)) |
 
-<a name="MPIN192.SERVER_2"></a>
+<a name="MPIN192.SERVER_2" />
 
-### MPIN192.SERVER\_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa) ⇒
+### MPIN192.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa) ⇒
+
 Perform third pass on the server side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| HID | is input H(ID), a hash of the client ID |
-| HTID | is input H(ID)+H(d|H(ID)) |
-| Y | is the input server's randomly generated challenge |
-| SST | is the input server secret |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| mSEC | is an input from the client |
-| E | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| F | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| Pa | is the input public key from the client, z.Q or NULL if the client uses regular mpin |
+| Param | Description                                                                          |         |
+| ----- | ------------------------------------------------------------------------------------ | ------- |
+| date  | is input date, in days since the epoch. Set to 0 if Time permits disabled            |         |
+| HID   | is input H(ID), a hash of the client ID                                              |         |
+| HTID  | is input H(ID)+H(d                                                                   | H(ID))  |
+| Y     | is the input server's randomly generated challenge                                   |         |
+| SST   | is the input server secret                                                           |         |
+| xID   | is input from the client = x.H(ID)                                                   |         |
+| xCID  | is input from the client= x.(H(ID)+H(d                                               | H(ID))) |
+| mSEC  | is an input from the client                                                          |         |
+| E     | is an output to help the Kangaroos to find the PIN error, or NULL if not required    |         |
+| F     | is an output to help the Kangaroos to find the PIN error, or NULL if not required    |         |
+| Pa    | is the input public key from the client, z.Q or NULL if the client uses regular mpin |         |
 
-<a name="MPIN192.KANGAROO"></a>
+<a name="MPIN192.KANGAROO" />
 
 ### MPIN192.KANGAROO(E, F) ⇒
+
 Use Kangaroos to find PIN error
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: 0 if Kangaroos failed, or the PIN error e  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| E | a member of the group GT |
-| F | a member of the group GT =  E^e |
+| Param | Description                     |
+| ----- | ------------------------------- |
+| E     | a member of the group GT        |
+| F     | a member of the group GT =  E^e |
 
-<a name="MPIN192.GET_TIME"></a>
+<a name="MPIN192.GET_TIME" />
 
-### MPIN192.GET\_TIME() ⇒
+### MPIN192.GET_TIME() ⇒
+
 Time since epoch
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: time since epoch  
-**this**: <code>{MPIN192}</code>  
-<a name="MPIN192.GET_Y"></a>
+**this**: <code>{"{"}MPIN192{"}"}</code>  
+<a name="MPIN192.GET_Y" />
 
-### MPIN192.GET\_Y(sha, TimeValue, xCID, Y) ⇒
+### MPIN192.GET_Y(sha, TimeValue, xCID, Y) ⇒
+
 Generate Y=H(s,O), where s is epoch time, O is a byte array, and H(.) is a hash function
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| TimeValue | is epoch time in seconds |
-| xCID | input bytearray is an input octet |
-| Y | output value |
+| Param     | Description                       |
+| --------- | --------------------------------- |
+| sha       | is the hash type                  |
+| TimeValue | is epoch time in seconds          |
+| xCID      | input bytearray is an input octet |
+| Y         | output value                      |
 
-<a name="MPIN192.CLIENT"></a>
+<a name="MPIN192.CLIENT" />
 
 ### MPIN192.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message) ⇒
+
 Perform client side of the one-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CLIENT_ID | is the input client identity |
-| rng | is a pointer to a cryptographically secure random number generator |
-| X | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| pin | is the input PIN number |
-| TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| SEC | is output = -(x+y)(CS+TP), where CS is the reconstructed client secret, and TP is the time permit |
-| xID | is output = x.H(ID) |
-| xCID | is output = x.(H(ID)+H(d|H(ID))) |
-| PERMIT | is the input time permit |
-| TimeValue | is input epoch time in seconds - a timestamp |
-| Y | is output H(t|U) or H(t|UT) if Time Permits enabled |
-| Message | is the message to be signed |
+| Param     | Description                                                                                       |           |                             |
+| --------- | ------------------------------------------------------------------------------------------------- | --------- | --------------------------- |
+| sha       | is the hash type                                                                                  |           |                             |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled                         |           |                             |
+| CLIENT_ID | is the input client identity                                                                      |           |                             |
+| rng       | is a pointer to a cryptographically secure random number generator                                |           |                             |
+| X         | an output internally randomly generated if R!=NULL, otherwise must be provided as an input        |           |                             |
+| pin       | is the input PIN number                                                                           |           |                             |
+| TOKEN     | is the input M-Pin token (the client secret with PIN portion removed)                             |           |                             |
+| SEC       | is output = -(x+y)(CS+TP), where CS is the reconstructed client secret, and TP is the time permit |           |                             |
+| xID       | is output = x.H(ID)                                                                               |           |                             |
+| xCID      | is output = x.(H(ID)+H(d                                                                          | H(ID)))   |                             |
+| PERMIT    | is the input time permit                                                                          |           |                             |
+| TimeValue | is input epoch time in seconds - a timestamp                                                      |           |                             |
+| Y         | is output H(t                                                                                     | U) or H(t | UT) if Time Permits enabled |
+| Message   | is the message to be signed                                                                       |           |                             |
 
-<a name="MPIN192.SERVER"></a>
+<a name="MPIN192.SERVER" />
 
 ### MPIN192.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa) ⇒
+
 Perform server side of the one-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| HID | is output H(ID), a hash of the client ID |
-| HTID | is output H(ID)+H(d|H(ID)) |
-| Y | is output H(t|U) or H(t|UT) if Time Permits enabled |
-| SST | is the input server secret |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| mSEC | is an input from the client |
-| E | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| F | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| CID | is the input claimed client identity |
-| TimeValue | is input epoch time in seconds - a timestamp |
-| MESSAGE | is the message to be signed |
-| Pa | is input from the client z.Q or NULL if the key-escrow less scheme is not used |
+| Param     | Description                                                                       |           |                             |
+| --------- | --------------------------------------------------------------------------------- | --------- | --------------------------- |
+| sha       | is the hash type                                                                  |           |                             |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled         |           |                             |
+| HID       | is output H(ID), a hash of the client ID                                          |           |                             |
+| HTID      | is output H(ID)+H(d                                                               | H(ID))    |                             |
+| Y         | is output H(t                                                                     | U) or H(t | UT) if Time Permits enabled |
+| SST       | is the input server secret                                                        |           |                             |
+| xID       | is input from the client = x.H(ID)                                                |           |                             |
+| xCID      | is input from the client= x.(H(ID)+H(d                                            | H(ID)))   |                             |
+| mSEC      | is an input from the client                                                       |           |                             |
+| E         | is an output to help the Kangaroos to find the PIN error, or NULL if not required |           |                             |
+| F         | is an output to help the Kangaroos to find the PIN error, or NULL if not required |           |                             |
+| CID       | is the input claimed client identity                                              |           |                             |
+| TimeValue | is input epoch time in seconds - a timestamp                                      |           |                             |
+| MESSAGE   | is the message to be signed                                                       |           |                             |
+| Pa        | is input from the client z.Q or NULL if the key-escrow less scheme is not used    |           |                             |
 
-<a name="MPIN192.PRECOMPUTE"></a>
+<a name="MPIN192.PRECOMPUTE" />
 
 ### MPIN192.PRECOMPUTE(TOKEN, CID, G1, G2) ⇒
+
 Precompute values for use by the client side of M-Pin Full
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
+| Param | Description                                                           |
+| ----- | --------------------------------------------------------------------- |
 | TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| CID | is the input client identity |
-| G1 | precomputed output |
-| G2 | precomputed output |
+| CID   | is the input client identity                                          |
+| G1    | precomputed output                                                    |
+| G2    | precomputed output                                                    |
 
-<a name="MPIN192.HASH_ALL"></a>
+<a name="MPIN192.HASH_ALL" />
 
-### MPIN192.HASH\_ALL(sha, HID, xID, xCID, SEC, Y, R, W) ⇒
+### MPIN192.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W) ⇒
+
 Hash the session transcript
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: H the output is the hash of all of the above that apply  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| HID | is the hashed input client ID = H(ID) |
-| xID | is the client output = x.H(ID) |
-| xCID | is the client output = x.(H(ID)+H(T|H(ID))) |
-| SEC | is the client part response |
-| Y | is the server challenge |
-| R | is the client part response |
-| W | is the server part response |
+| Param | Description                           |         |
+| ----- | ------------------------------------- | ------- |
+| sha   | is the hash type                      |         |
+| HID   | is the hashed input client ID = H(ID) |         |
+| xID   | is the client output = x.H(ID)        |         |
+| xCID  | is the client output = x.(H(ID)+H(T   | H(ID))) |
+| SEC   | is the client part response           |         |
+| Y     | is the server challenge               |         |
+| R     | is the client part response           |         |
+| W     | is the server part response           |         |
 
-<a name="MPIN192.CLIENT_KEY"></a>
+<a name="MPIN192.CLIENT_KEY" />
 
-### MPIN192.CLIENT\_KEY(sha, G1, G2, pin, R, X, H, wCID, CK) ⇒
+### MPIN192.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK) ⇒
+
 Calculate Key on Client side for M-Pin Full
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| G1 | precomputed input |
-| G2 | precomputed input |
-| pin | is the input PIN number |
-| R | is an input, a locally generated random number |
-| X | is an input, a locally generated random number |
-| H | is an input, hash of the protocol transcript |
-| wCID | is the input Server-side Diffie-Hellman component |
-| CK | is the output calculated shared key |
+| Param | Description                                       |
+| ----- | ------------------------------------------------- |
+| sha   | is the hash type                                  |
+| G1    | precomputed input                                 |
+| G2    | precomputed input                                 |
+| pin   | is the input PIN number                           |
+| R     | is an input, a locally generated random number    |
+| X     | is an input, a locally generated random number    |
+| H     | is an input, hash of the protocol transcript      |
+| wCID  | is the input Server-side Diffie-Hellman component |
+| CK    | is the output calculated shared key               |
 
-<a name="MPIN192.SERVER_KEY"></a>
+<a name="MPIN192.SERVER_KEY" />
 
-### MPIN192.SERVER\_KEY(h, Z, SST, W, H, HID, xID, xCID, SK) ⇒
+### MPIN192.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK) ⇒
+
 Calculate Key on Server side for M-Pin Full
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| h | is the hash type |
-| Z | is the input Client-side Diffie-Hellman component |
-| SST | is the input server secret |
-| W | is an input random number generated by the server |
-| H | is an input, hash of the protocol transcript |
-| HID | is the hashed input client ID = H(ID) |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| SK | is the output calculated shared key |
+| Param | Description                                       |         |
+| ----- | ------------------------------------------------- | ------- |
+| h     | is the hash type                                  |         |
+| Z     | is the input Client-side Diffie-Hellman component |         |
+| SST   | is the input server secret                        |         |
+| W     | is an input random number generated by the server |         |
+| H     | is an input, hash of the protocol transcript      |         |
+| HID   | is the hashed input client ID = H(ID)             |         |
+| xID   | is input from the client = x.H(ID)                |         |
+| xCID  | is input from the client= x.(H(ID)+H(d            | H(ID))) |
+| SK    | is the output calculated shared key               |         |
 
-<a name="MPIN192.GET_DVS_KEYPAIR"></a>
+<a name="MPIN192.GET_DVS_KEYPAIR" />
 
-### MPIN192.GET\_DVS\_KEYPAIR(rng, Z, Pa) ⇒
+### MPIN192.GET_DVS_KEYPAIR(rng, Z, Pa) ⇒
+
 Generates a random public key for the client z.Q
 
 **Kind**: static method of [<code>MPIN192</code>](#MPIN192)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN192}</code>  
+**this**: <code>{"{"}MPIN192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | cryptographically secure random number generator |
-| Z | an output internally randomly generated if R!=NULL, otherwise it must be provided as an input |
-| Pa | the output public key for the client |
-
+| Param | Description                                                                                   |
+| ----- | --------------------------------------------------------------------------------------------- |
+| rng   | cryptographically secure random number generator                                              |
+| Z     | an output internally randomly generated if R!=NULL, otherwise it must be provided as an input |
+| Pa    | the output public key for the client                                                          |
diff --git a/docs/cryptojs/mpin256.md b/docs/cryptojs/mpin256.md
index 0aabfb2..a9cdc84 100644
--- a/docs/cryptojs/mpin256.md
+++ b/docs/cryptojs/mpin256.md
@@ -3,561 +3,592 @@
 title: MPIN256
 sidebar_label: MPIN256
 ---
-
-
-<a name="MPIN256"></a>
+<a name="MPIN256" />
 
 ## MPIN256
+
 **Kind**: global class  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-* [MPIN256](#MPIN256)
-    * [new MPIN256()](#new_MPIN256_new)
-    * [.today()](#MPIN256.today) ⇒
-    * [.bytestostring(b)](#MPIN256.bytestostring) ⇒
-    * [.stringtobytes(s)](#MPIN256.stringtobytes) ⇒
-    * [.comparebytes(a, b)](#MPIN256.comparebytes) ⇒
-    * [.mpin_hash(c, U)](#MPIN256.mpin_hash) ⇒
-    * [.hashit(sha, n, B)](#MPIN256.hashit) ⇒
-    * [.map(u, cb)](#MPIN256.map) ⇒
-    * [.unmap(u, P)](#MPIN256.unmap) ⇒
-    * [.RECOMBINE_G1(R1, R2, R)](#MPIN256.RECOMBINE_G1) ⇒
-    * [.RECOMBINE_G2(W1, W2, W)](#MPIN256.RECOMBINE_G2) ⇒
-    * [.HASH_ID(sha, ID)](#MPIN256.HASH_ID) ⇒
-    * [.RANDOM_GENERATE(rng, S)](#MPIN256.RANDOM_GENERATE) ⇒
-    * [.EXTRACT_PIN()](#MPIN256.EXTRACT_PIN) ⇒
-    * [.EXTRACT_FACTOR()](#MPIN256.EXTRACT_FACTOR) ⇒
-    * [.RESTORE_FACTOR()](#MPIN256.RESTORE_FACTOR) ⇒
-    * [.GET_SERVER_SECRET(S, SST)](#MPIN256.GET_SERVER_SECRET) ⇒
-    * [.GET_G1_MULTIPLE(type, x, G, W)](#MPIN256.GET_G1_MULTIPLE) ⇒
-    * [.GET_CLIENT_SECRET(S, CID, CST)](#MPIN256.GET_CLIENT_SECRET) ⇒
-    * [.GET_CLIENT_PERMIT(sha, date, S, CID, CTT)](#MPIN256.GET_CLIENT_PERMIT) ⇒
-    * [.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT)](#MPIN256.CLIENT_1) ⇒
-    * [.CLIENT_2(X, Y, SEC)](#MPIN256.CLIENT_2) ⇒
-    * [.SERVER_1(sha, date, CID, HID, HTID)](#MPIN256.SERVER_1) ⇒
-    * [.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa)](#MPIN256.SERVER_2) ⇒
-    * [.KANGAROO(E, F)](#MPIN256.KANGAROO) ⇒
-    * [.GET_TIME()](#MPIN256.GET_TIME) ⇒
-    * [.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message)](#MPIN256.CLIENT) ⇒
-    * [.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa)](#MPIN256.SERVER) ⇒
-    * [.PRECOMPUTE(TOKEN, CID, G1, G2)](#MPIN256.PRECOMPUTE) ⇒
-    * [.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W)](#MPIN256.HASH_ALL) ⇒
-    * [.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK)](#MPIN256.CLIENT_KEY) ⇒
-    * [.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK)](#MPIN256.SERVER_KEY) ⇒
-    * [.GET_DVS_KEYPAIR(rng, Z, Pa)](#MPIN256.GET_DVS_KEYPAIR) ⇒
+-   [MPIN256](#MPIN256)
+    -   [new MPIN256()](#new_MPIN256_new)
+    -   [.today()](#MPIN256.today) ⇒
+    -   [.bytestostring(b)](#MPIN256.bytestostring) ⇒
+    -   [.stringtobytes(s)](#MPIN256.stringtobytes) ⇒
+    -   [.comparebytes(a, b)](#MPIN256.comparebytes) ⇒
+    -   [.mpin_hash(c, U)](#MPIN256.mpin_hash) ⇒
+    -   [.hashit(sha, n, B)](#MPIN256.hashit) ⇒
+    -   [.map(u, cb)](#MPIN256.map) ⇒
+    -   [.unmap(u, P)](#MPIN256.unmap) ⇒
+    -   [.RECOMBINE_G1(R1, R2, R)](#MPIN256.RECOMBINE_G1) ⇒
+    -   [.RECOMBINE_G2(W1, W2, W)](#MPIN256.RECOMBINE_G2) ⇒
+    -   [.HASH_ID(sha, ID)](#MPIN256.HASH_ID) ⇒
+    -   [.RANDOM_GENERATE(rng, S)](#MPIN256.RANDOM_GENERATE) ⇒
+    -   [.EXTRACT_PIN()](#MPIN256.EXTRACT_PIN) ⇒
+    -   [.EXTRACT_FACTOR()](#MPIN256.EXTRACT_FACTOR) ⇒
+    -   [.RESTORE_FACTOR()](#MPIN256.RESTORE_FACTOR) ⇒
+    -   [.GET_SERVER_SECRET(S, SST)](#MPIN256.GET_SERVER_SECRET) ⇒
+    -   [.GET_G1_MULTIPLE(type, x, G, W)](#MPIN256.GET_G1_MULTIPLE) ⇒
+    -   [.GET_CLIENT_SECRET(S, CID, CST)](#MPIN256.GET_CLIENT_SECRET) ⇒
+    -   [.GET_CLIENT_PERMIT(sha, date, S, CID, CTT)](#MPIN256.GET_CLIENT_PERMIT) ⇒
+    -   [.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT)](#MPIN256.CLIENT_1) ⇒
+    -   [.CLIENT_2(X, Y, SEC)](#MPIN256.CLIENT_2) ⇒
+    -   [.SERVER_1(sha, date, CID, HID, HTID)](#MPIN256.SERVER_1) ⇒
+    -   [.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa)](#MPIN256.SERVER_2) ⇒
+    -   [.KANGAROO(E, F)](#MPIN256.KANGAROO) ⇒
+    -   [.GET_TIME()](#MPIN256.GET_TIME) ⇒
+    -   [.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message)](#MPIN256.CLIENT) ⇒
+    -   [.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa)](#MPIN256.SERVER) ⇒
+    -   [.PRECOMPUTE(TOKEN, CID, G1, G2)](#MPIN256.PRECOMPUTE) ⇒
+    -   [.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W)](#MPIN256.HASH_ALL) ⇒
+    -   [.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK)](#MPIN256.CLIENT_KEY) ⇒
+    -   [.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK)](#MPIN256.SERVER_KEY) ⇒
+    -   [.GET_DVS_KEYPAIR(rng, Z, Pa)](#MPIN256.GET_DVS_KEYPAIR) ⇒
 
-<a name="new_MPIN256_new"></a>
+<a name="new_MPIN256_new" />
 
 ### new MPIN256()
+
 Creates an instance of MPIN256
 
-<a name="MPIN256.today"></a>
+<a name="MPIN256.today" />
 
 ### MPIN256.today() ⇒
+
 Get epoch time for day
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: time in slots since epoch  
-**this**: <code>{MPIN256}</code>  
-<a name="MPIN256.bytestostring"></a>
+**this**: <code>{"{"}MPIN256{"}"}</code>  
+<a name="MPIN256.bytestostring" />
 
 ### MPIN256.bytestostring(b) ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: s string  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| b | byte array |
+| ----- | ----------- |
+| b     | byte array  |
 
-<a name="MPIN256.stringtobytes"></a>
+<a name="MPIN256.stringtobytes" />
 
 ### MPIN256.stringtobytes(s) ⇒
+
 Convert a string to byte array
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: b byte array  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | string |
+| ----- | ----------- |
+| s     | string      |
 
-<a name="MPIN256.comparebytes"></a>
+<a name="MPIN256.comparebytes" />
 
 ### MPIN256.comparebytes(a, b) ⇒
+
 Convert byte arrays
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: true if equal  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| a | byte array |
-| b | byte array |
+| ----- | ----------- |
+| a     | byte array  |
+| b     | byte array  |
 
-<a name="MPIN256.mpin_hash"></a>
+<a name="MPIN256.mpin_hash" />
 
-### MPIN256.mpin\_hash(c, U) ⇒
+### MPIN256.mpin_hash(c, U) ⇒
+
 Hash values
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: R hash value  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| c | FP8 instance |
-| U | ECP unstancebyte array |
+| Param | Description            |
+| ----- | ---------------------- |
+| c     | FP8 instance           |
+| U     | ECP unstancebyte array |
 
-<a name="MPIN256.hashit"></a>
+<a name="MPIN256.hashit" />
 
 ### MPIN256.hashit(sha, n, B) ⇒
+
 General purpose hash function
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: R hash value  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| n | Integer |
-| B | byte array |
+| Param | Description      |
+| ----- | ---------------- |
+| sha   | is the hash type |
+| n     | Integer          |
+| B     | byte array       |
 
-<a name="MPIN256.map"></a>
+<a name="MPIN256.map" />
 
 ### MPIN256.map(u, cb) ⇒
+
 maps a random u to a point on the curve
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: P ECP pointhash value  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| u | BIG numberInteger |
-| cb | an integer representing the "sign" of y, in fact its least significant bit. |
+| Param | Description                                                                 |
+| ----- | --------------------------------------------------------------------------- |
+| u     | BIG numberInteger                                                           |
+| cb    | an integer representing the "sign" of y, in fact its least significant bit. |
 
-<a name="MPIN256.unmap"></a>
+<a name="MPIN256.unmap" />
 
 ### MPIN256.unmap(u, P) ⇒
+
 returns u derived from P. Random value in range 1 to return value should then be added to u
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: r Value that should be added to u to derive P  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| u | BIG numberInteger |
-| P | ECP pointhash value |
+| Param | Description         |
+| ----- | ------------------- |
+| u     | BIG numberInteger   |
+| P     | ECP pointhash value |
 
-<a name="MPIN256.RECOMBINE_G1"></a>
+<a name="MPIN256.RECOMBINE_G1" />
 
-### MPIN256.RECOMBINE\_G1(R1, R2, R) ⇒
+### MPIN256.RECOMBINE_G1(R1, R2, R) ⇒
+
 Add two members from the group G1
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| R1 | Input member of G1 |
-| R2 | Input member of G1 |
-| R | Output member of G1. R=R1+R2 |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| R1    | Input member of G1           |
+| R2    | Input member of G1           |
+| R     | Output member of G1. R=R1+R2 |
 
-<a name="MPIN256.RECOMBINE_G2"></a>
+<a name="MPIN256.RECOMBINE_G2" />
 
-### MPIN256.RECOMBINE\_G2(W1, W2, W) ⇒
+### MPIN256.RECOMBINE_G2(W1, W2, W) ⇒
+
 Add two members from the group G2
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| W1 | Input member of G2 |
-| W2 | Input member of G2 |
-| W | Output member of G2. W=W1+W2 |
+| Param | Description                  |
+| ----- | ---------------------------- |
+| W1    | Input member of G2           |
+| W2    | Input member of G2           |
+| W     | Output member of G2. W=W1+W2 |
 
-<a name="MPIN256.HASH_ID"></a>
+<a name="MPIN256.HASH_ID" />
 
-### MPIN256.HASH\_ID(sha, ID) ⇒
+### MPIN256.HASH_ID(sha, ID) ⇒
+
 Hash the identity
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: hash value  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| ID | Identity as byte array |
+| Param | Description            |
+| ----- | ---------------------- |
+| sha   | is the hash type       |
+| ID    | Identity as byte array |
 
-<a name="MPIN256.RANDOM_GENERATE"></a>
+<a name="MPIN256.RANDOM_GENERATE" />
 
-### MPIN256.RANDOM\_GENERATE(rng, S) ⇒
+### MPIN256.RANDOM_GENERATE(rng, S) ⇒
+
 Create random secret
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | cryptographically secure random number generator |
-| S | Random secret value |
+| Param | Description                                      |
+| ----- | ------------------------------------------------ |
+| rng   | cryptographically secure random number generator |
+| S     | Random secret value                              |
 
-<a name="MPIN256.EXTRACT_PIN"></a>
+<a name="MPIN256.EXTRACT_PIN" />
 
-### MPIN256.EXTRACT\_PIN() ⇒
+### MPIN256.EXTRACT_PIN() ⇒
+
 Extract a PIN number from a client secret
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: token  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: pin PIN value  
 **Parameter**: TOKEN Client secret  
-<a name="MPIN256.EXTRACT_FACTOR"></a>
+<a name="MPIN256.EXTRACT_FACTOR" />
 
-### MPIN256.EXTRACT\_FACTOR() ⇒
+### MPIN256.EXTRACT_FACTOR() ⇒
+
 Extract factor from TOKEN for identity CID
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: token  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: factor Value to extract  
 **Parameter**: facbits Number of bits in factor  
 **Parameter**: TOKEN Token value  
-<a name="MPIN256.RESTORE_FACTOR"></a>
+<a name="MPIN256.RESTORE_FACTOR" />
 
-### MPIN256.RESTORE\_FACTOR() ⇒
+### MPIN256.RESTORE_FACTOR() ⇒
+
 Restore factor to TOKEN for identity CID
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: token  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 **Parameter**: sha hash type  
 **Parameter**: CID Client identity  
 **Parameter**: factor Value to extract  
 **Parameter**: facbits Number of bits in factor  
 **Parameter**: TOKEN Token value  
-<a name="MPIN256.GET_SERVER_SECRET"></a>
+<a name="MPIN256.GET_SERVER_SECRET" />
 
-### MPIN256.GET\_SERVER\_SECRET(S, SST) ⇒
+### MPIN256.GET_SERVER_SECRET(S, SST) ⇒
+
 Create a server secret in G2 from a master secret
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| S | Master secret |
-| SST | Server secret = s.Q where Q is a fixed generator of G2 |
+| Param | Description                                            |
+| ----- | ------------------------------------------------------ |
+| S     | Master secret                                          |
+| SST   | Server secret = s.Q where Q is a fixed generator of G2 |
 
-<a name="MPIN256.GET_G1_MULTIPLE"></a>
+<a name="MPIN256.GET_G1_MULTIPLE" />
 
-### MPIN256.GET\_G1\_MULTIPLE(type, x, G, W) ⇒
+### MPIN256.GET_G1_MULTIPLE(type, x, G, W) ⇒
+
 Find a random multiple of a point in G1
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 **Parameter**: rng cryptographically secure random number generator  
 
-| Param | Description |
-| --- | --- |
-| type | determines type of action to be taken |
-| x | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| G | if type=0 a point in G1, else an octet to be mapped to G1 |
-| W | the output =x.G or x.M(G), where M(.) is a mapping |
+| Param | Description                                                                                |
+| ----- | ------------------------------------------------------------------------------------------ |
+| type  | determines type of action to be taken                                                      |
+| x     | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
+| G     | if type=0 a point in G1, else an octet to be mapped to G1                                  |
+| W     | the output =x.G or x.M(G), where M(.) is a mapping                                         |
 
-<a name="MPIN256.GET_CLIENT_SECRET"></a>
+<a name="MPIN256.GET_CLIENT_SECRET" />
 
-### MPIN256.GET\_CLIENT\_SECRET(S, CID, CST) ⇒
+### MPIN256.GET_CLIENT_SECRET(S, CID, CST) ⇒
+
 Create a client secret in G1 from a master secret and the client ID
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| S | is an input master secret |
-| CID | is the input client identity |
-| CST | is the full client secret = s.H(ID) |
+| Param | Description                         |
+| ----- | ----------------------------------- |
+| S     | is an input master secret           |
+| CID   | is the input client identity        |
+| CST   | is the full client secret = s.H(ID) |
 
-<a name="MPIN256.GET_CLIENT_PERMIT"></a>
+<a name="MPIN256.GET_CLIENT_PERMIT" />
 
-### MPIN256.GET\_CLIENT\_PERMIT(sha, date, S, CID, CTT) ⇒
+### MPIN256.GET_CLIENT_PERMIT(sha, date, S, CID, CTT) ⇒
+
 Create a Time Permit in G1 from a master secret and the client ID
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. |
-| S | is an input master secret |
-| CID | is the input client identity |
-| CTT | is a Time Permit for the given date = s.H(d|H(ID)) |
+| Param | Description                                 |        |
+| ----- | ------------------------------------------- | ------ |
+| sha   | is the hash type                            |        |
+| date  | is input date, in days since the epoch.     |        |
+| S     | is an input master secret                   |        |
+| CID   | is the input client identity                |        |
+| CTT   | is a Time Permit for the given date = s.H(d | H(ID)) |
 
-<a name="MPIN256.CLIENT_1"></a>
+<a name="MPIN256.CLIENT_1" />
 
-### MPIN256.CLIENT\_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT) ⇒
+### MPIN256.CLIENT_1(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT) ⇒
+
 Perform first pass of the client side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CLIENT_ID | is the input client identity |
-| rng | is a pointer to a cryptographically secure random number generator |
-| X | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| pin | is the input PIN number |
-| TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| SEC | is output = CS+TP, where CS=is the reconstructed client secret, and TP is the time permit |
-| xID | is output = x.H(ID) |
-| xCID | is output = x.(H(ID)+H(d|H(ID))) |
-| PERMIT | is the input time permit |
+| Param     | Description                                                                                |         |
+| --------- | ------------------------------------------------------------------------------------------ | ------- |
+| sha       | is the hash type                                                                           |         |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled                  |         |
+| CLIENT_ID | is the input client identity                                                               |         |
+| rng       | is a pointer to a cryptographically secure random number generator                         |         |
+| X         | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |         |
+| pin       | is the input PIN number                                                                    |         |
+| TOKEN     | is the input M-Pin token (the client secret with PIN portion removed)                      |         |
+| SEC       | is output = CS+TP, where CS=is the reconstructed client secret, and TP is the time permit  |         |
+| xID       | is output = x.H(ID)                                                                        |         |
+| xCID      | is output = x.(H(ID)+H(d                                                                   | H(ID))) |
+| PERMIT    | is the input time permit                                                                   |         |
 
-<a name="MPIN256.CLIENT_2"></a>
+<a name="MPIN256.CLIENT_2" />
 
-### MPIN256.CLIENT\_2(X, Y, SEC) ⇒
+### MPIN256.CLIENT_2(X, Y, SEC) ⇒
+
 Perform second pass of the client side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| X | an input, a locally generated random number |
-| Y | an input random challenge from the server |
-| SEC | on output = -(x+y).V |
+| Param | Description                                 |
+| ----- | ------------------------------------------- |
+| X     | an input, a locally generated random number |
+| Y     | an input random challenge from the server   |
+| SEC   | on output = -(x+y).V                        |
 
-<a name="MPIN256.SERVER_1"></a>
+<a name="MPIN256.SERVER_1" />
 
-### MPIN256.SERVER\_1(sha, date, CID, HID, HTID) ⇒
+### MPIN256.SERVER_1(sha, date, CID, HID, HTID) ⇒
+
 Perform first pass of the server side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CID | is the input claimed client identity |
-| HID | is output H(ID), a hash of the client ID |
-| HTID | is output H(ID)+H(d|H(ID)) |
+| Param | Description                                                               |        |
+| ----- | ------------------------------------------------------------------------- | ------ |
+| sha   | is the hash type                                                          |        |
+| date  | is input date, in days since the epoch. Set to 0 if Time permits disabled |        |
+| CID   | is the input claimed client identity                                      |        |
+| HID   | is output H(ID), a hash of the client ID                                  |        |
+| HTID  | is output H(ID)+H(d                                                       | H(ID)) |
 
-<a name="MPIN256.SERVER_2"></a>
+<a name="MPIN256.SERVER_2" />
 
-### MPIN256.SERVER\_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa) ⇒
+### MPIN256.SERVER_2(date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, Pa) ⇒
+
 Perform third pass on the server side of the 3-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| HID | is input H(ID), a hash of the client ID |
-| HTID | is input H(ID)+H(d|H(ID)) |
-| Y | is the input server's randomly generated challenge |
-| SST | is the input server secret |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| mSEC | is an input from the client |
-| E | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| F | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| Pa | is the input public key from the client, z.Q or NULL if the client uses regular mpin |
+| Param | Description                                                                          |         |
+| ----- | ------------------------------------------------------------------------------------ | ------- |
+| date  | is input date, in days since the epoch. Set to 0 if Time permits disabled            |         |
+| HID   | is input H(ID), a hash of the client ID                                              |         |
+| HTID  | is input H(ID)+H(d                                                                   | H(ID))  |
+| Y     | is the input server's randomly generated challenge                                   |         |
+| SST   | is the input server secret                                                           |         |
+| xID   | is input from the client = x.H(ID)                                                   |         |
+| xCID  | is input from the client= x.(H(ID)+H(d                                               | H(ID))) |
+| mSEC  | is an input from the client                                                          |         |
+| E     | is an output to help the Kangaroos to find the PIN error, or NULL if not required    |         |
+| F     | is an output to help the Kangaroos to find the PIN error, or NULL if not required    |         |
+| Pa    | is the input public key from the client, z.Q or NULL if the client uses regular mpin |         |
 
-<a name="MPIN256.KANGAROO"></a>
+<a name="MPIN256.KANGAROO" />
 
 ### MPIN256.KANGAROO(E, F) ⇒
+
 Use Kangaroos to find PIN error
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: 0 if Kangaroos failed, or the PIN error e  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| E | a member of the group GT |
-| F | a member of the group GT =  E^e |
+| Param | Description                     |
+| ----- | ------------------------------- |
+| E     | a member of the group GT        |
+| F     | a member of the group GT =  E^e |
 
-<a name="MPIN256.GET_TIME"></a>
+<a name="MPIN256.GET_TIME" />
 
-### MPIN256.GET\_TIME() ⇒
+### MPIN256.GET_TIME() ⇒
+
 Time since epoch
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: time since epoch  
-**this**: <code>{MPIN256}</code>  
-<a name="MPIN256.CLIENT"></a>
+**this**: <code>{"{"}MPIN256{"}"}</code>  
+<a name="MPIN256.CLIENT" />
 
 ### MPIN256.CLIENT(sha, date, CLIENT_ID, rng, X, pin, TOKEN, SEC, xID, xCID, PERMIT, TimeValue, Y, Message) ⇒
+
 Perform client side of the one-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| CLIENT_ID | is the input client identity |
-| rng | is a pointer to a cryptographically secure random number generator |
-| X | an output internally randomly generated if R!=NULL, otherwise must be provided as an input |
-| pin | is the input PIN number |
-| TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| SEC | is output = -(x+y)(CS+TP), where CS is the reconstructed client secret, and TP is the time permit |
-| xID | is output = x.H(ID) |
-| xCID | is output = x.(H(ID)+H(d|H(ID))) |
-| PERMIT | is the input time permit |
-| TimeValue | is input epoch time in seconds - a timestamp |
-| Y | is output H(t|U) or H(t|UT) if Time Permits enabled |
-| Message | is the message to be signed |
+| Param     | Description                                                                                       |           |                             |
+| --------- | ------------------------------------------------------------------------------------------------- | --------- | --------------------------- |
+| sha       | is the hash type                                                                                  |           |                             |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled                         |           |                             |
+| CLIENT_ID | is the input client identity                                                                      |           |                             |
+| rng       | is a pointer to a cryptographically secure random number generator                                |           |                             |
+| X         | an output internally randomly generated if R!=NULL, otherwise must be provided as an input        |           |                             |
+| pin       | is the input PIN number                                                                           |           |                             |
+| TOKEN     | is the input M-Pin token (the client secret with PIN portion removed)                             |           |                             |
+| SEC       | is output = -(x+y)(CS+TP), where CS is the reconstructed client secret, and TP is the time permit |           |                             |
+| xID       | is output = x.H(ID)                                                                               |           |                             |
+| xCID      | is output = x.(H(ID)+H(d                                                                          | H(ID)))   |                             |
+| PERMIT    | is the input time permit                                                                          |           |                             |
+| TimeValue | is input epoch time in seconds - a timestamp                                                      |           |                             |
+| Y         | is output H(t                                                                                     | U) or H(t | UT) if Time Permits enabled |
+| Message   | is the message to be signed                                                                       |           |                             |
 
-<a name="MPIN256.SERVER"></a>
+<a name="MPIN256.SERVER" />
 
 ### MPIN256.SERVER(sha, date, HID, HTID, Y, SST, xID, xCID, mSEC, E, F, CID, TimeValue, MESSAGE, Pa) ⇒
+
 Perform server side of the one-pass version of the M-Pin protocol
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| date | is input date, in days since the epoch. Set to 0 if Time permits disabled |
-| HID | is output H(ID), a hash of the client ID |
-| HTID | is output H(ID)+H(d|H(ID)) |
-| Y | is output H(t|U) or H(t|UT) if Time Permits enabled |
-| SST | is the input server secret |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| mSEC | is an input from the client |
-| E | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| F | is an output to help the Kangaroos to find the PIN error, or NULL if not required |
-| CID | is the input claimed client identity |
-| TimeValue | is input epoch time in seconds - a timestamp |
-| MESSAGE | is the message to be signed |
-| Pa | is input from the client z.Q or NULL if the key-escrow less scheme is not used |
+| Param     | Description                                                                       |           |                             |
+| --------- | --------------------------------------------------------------------------------- | --------- | --------------------------- |
+| sha       | is the hash type                                                                  |           |                             |
+| date      | is input date, in days since the epoch. Set to 0 if Time permits disabled         |           |                             |
+| HID       | is output H(ID), a hash of the client ID                                          |           |                             |
+| HTID      | is output H(ID)+H(d                                                               | H(ID))    |                             |
+| Y         | is output H(t                                                                     | U) or H(t | UT) if Time Permits enabled |
+| SST       | is the input server secret                                                        |           |                             |
+| xID       | is input from the client = x.H(ID)                                                |           |                             |
+| xCID      | is input from the client= x.(H(ID)+H(d                                            | H(ID)))   |                             |
+| mSEC      | is an input from the client                                                       |           |                             |
+| E         | is an output to help the Kangaroos to find the PIN error, or NULL if not required |           |                             |
+| F         | is an output to help the Kangaroos to find the PIN error, or NULL if not required |           |                             |
+| CID       | is the input claimed client identity                                              |           |                             |
+| TimeValue | is input epoch time in seconds - a timestamp                                      |           |                             |
+| MESSAGE   | is the message to be signed                                                       |           |                             |
+| Pa        | is input from the client z.Q or NULL if the key-escrow less scheme is not used    |           |                             |
 
-<a name="MPIN256.PRECOMPUTE"></a>
+<a name="MPIN256.PRECOMPUTE" />
 
 ### MPIN256.PRECOMPUTE(TOKEN, CID, G1, G2) ⇒
+
 Precompute values for use by the client side of M-Pin Full
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: O for success or else error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
+| Param | Description                                                           |
+| ----- | --------------------------------------------------------------------- |
 | TOKEN | is the input M-Pin token (the client secret with PIN portion removed) |
-| CID | is the input client identity |
-| G1 | precomputed output |
-| G2 | precomputed output |
+| CID   | is the input client identity                                          |
+| G1    | precomputed output                                                    |
+| G2    | precomputed output                                                    |
 
-<a name="MPIN256.HASH_ALL"></a>
+<a name="MPIN256.HASH_ALL" />
 
-### MPIN256.HASH\_ALL(sha, HID, xID, xCID, SEC, Y, R, W) ⇒
+### MPIN256.HASH_ALL(sha, HID, xID, xCID, SEC, Y, R, W) ⇒
+
 Hash the session transcript
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: H the output is the hash of all of the above that apply  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| HID | is the hashed input client ID = H(ID) |
-| xID | is the client output = x.H(ID) |
-| xCID | is the client output = x.(H(ID)+H(T|H(ID))) |
-| SEC | is the client part response |
-| Y | is the server challenge |
-| R | is the client part response |
-| W | is the server part response |
+| Param | Description                           |         |
+| ----- | ------------------------------------- | ------- |
+| sha   | is the hash type                      |         |
+| HID   | is the hashed input client ID = H(ID) |         |
+| xID   | is the client output = x.H(ID)        |         |
+| xCID  | is the client output = x.(H(ID)+H(T   | H(ID))) |
+| SEC   | is the client part response           |         |
+| Y     | is the server challenge               |         |
+| R     | is the client part response           |         |
+| W     | is the server part response           |         |
 
-<a name="MPIN256.CLIENT_KEY"></a>
+<a name="MPIN256.CLIENT_KEY" />
 
-### MPIN256.CLIENT\_KEY(sha, G1, G2, pin, R, X, H, wCID, CK) ⇒
+### MPIN256.CLIENT_KEY(sha, G1, G2, pin, R, X, H, wCID, CK) ⇒
+
 Calculate Key on Client side for M-Pin Full
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| G1 | precomputed input |
-| G2 | precomputed input |
-| pin | is the input PIN number |
-| R | is an input, a locally generated random number |
-| X | is an input, a locally generated random number |
-| H | is an input, hash of the protocol transcript |
-| wCID | is the input Server-side Diffie-Hellman component |
-| CK | is the output calculated shared key |
+| Param | Description                                       |
+| ----- | ------------------------------------------------- |
+| sha   | is the hash type                                  |
+| G1    | precomputed input                                 |
+| G2    | precomputed input                                 |
+| pin   | is the input PIN number                           |
+| R     | is an input, a locally generated random number    |
+| X     | is an input, a locally generated random number    |
+| H     | is an input, hash of the protocol transcript      |
+| wCID  | is the input Server-side Diffie-Hellman component |
+| CK    | is the output calculated shared key               |
 
-<a name="MPIN256.SERVER_KEY"></a>
+<a name="MPIN256.SERVER_KEY" />
 
-### MPIN256.SERVER\_KEY(h, Z, SST, W, H, HID, xID, xCID, SK) ⇒
+### MPIN256.SERVER_KEY(h, Z, SST, W, H, HID, xID, xCID, SK) ⇒
+
 Calculate Key on Server side for M-Pin Full
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| h | is the hash type |
-| Z | is the input Client-side Diffie-Hellman component |
-| SST | is the input server secret |
-| W | is an input random number generated by the server |
-| H | is an input, hash of the protocol transcript |
-| HID | is the hashed input client ID = H(ID) |
-| xID | is input from the client = x.H(ID) |
-| xCID | is input from the client= x.(H(ID)+H(d|H(ID))) |
-| SK | is the output calculated shared key |
+| Param | Description                                       |         |
+| ----- | ------------------------------------------------- | ------- |
+| h     | is the hash type                                  |         |
+| Z     | is the input Client-side Diffie-Hellman component |         |
+| SST   | is the input server secret                        |         |
+| W     | is an input random number generated by the server |         |
+| H     | is an input, hash of the protocol transcript      |         |
+| HID   | is the hashed input client ID = H(ID)             |         |
+| xID   | is input from the client = x.H(ID)                |         |
+| xCID  | is input from the client= x.(H(ID)+H(d            | H(ID))) |
+| SK    | is the output calculated shared key               |         |
 
-<a name="MPIN256.GET_DVS_KEYPAIR"></a>
+<a name="MPIN256.GET_DVS_KEYPAIR" />
 
-### MPIN256.GET\_DVS\_KEYPAIR(rng, Z, Pa) ⇒
+### MPIN256.GET_DVS_KEYPAIR(rng, Z, Pa) ⇒
+
 Generates a random public key for the client z.Q
 
 **Kind**: static method of [<code>MPIN256</code>](#MPIN256)  
 **Returns**: 0 or an error code  
-**this**: <code>{MPIN256}</code>  
+**this**: <code>{"{"}MPIN256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | cryptographically secure random number generator |
-| Z | an output internally randomly generated if R!=NULL, otherwise it must be provided as an input |
-| Pa | the output public key for the client |
-
+| Param | Description                                                                                   |
+| ----- | --------------------------------------------------------------------------------------------- |
+| rng   | cryptographically secure random number generator                                              |
+| Z     | an output internally randomly generated if R!=NULL, otherwise it must be provided as an input |
+| Pa    | the output public key for the client                                                          |
diff --git a/docs/cryptojs/pair.md b/docs/cryptojs/pair.md
index af75824..545f9c4 100644
--- a/docs/cryptojs/pair.md
+++ b/docs/cryptojs/pair.md
@@ -3,178 +3,191 @@
 title: PAIR
 sidebar_label: PAIR
 ---
-
-<a name="PAIR"></a>
+<a name="PAIR" />
 
 ## PAIR
+
 **Kind**: global class  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 
-* [PAIR](#PAIR)
-    * [new PAIR()](#new_PAIR_new)
-    * [.line()](#PAIR.line)
-    * [.initmp()](#PAIR.initmp)
-    * [.miller(r, res)](#PAIR.miller)
-    * [.another(r, P1, Q1)](#PAIR.another)
-    * [.ate(P1, Q1)](#PAIR.ate)
-    * [.ate2(P1, Q1, R1, S1)](#PAIR.ate2)
-    * [.fexp(m)](#PAIR.fexp)
-    * [.lbits()](#PAIR.lbits)
-    * [.glv()](#PAIR.glv)
-    * [.gs()](#PAIR.gs)
-    * [.G1mul(P, e)](#PAIR.G1mul) ⇒
-    * [.G2mul(P, e)](#PAIR.G2mul) ⇒
-    * [.GTpow(d, e)](#PAIR.GTpow) ⇒
+-   [PAIR](#PAIR)
+    -   [new PAIR()](#new_PAIR_new)
+    -   [.line()](#PAIR.line)
+    -   [.initmp()](#PAIR.initmp)
+    -   [.miller(r, res)](#PAIR.miller)
+    -   [.another(r, P1, Q1)](#PAIR.another)
+    -   [.ate(P1, Q1)](#PAIR.ate)
+    -   [.ate2(P1, Q1, R1, S1)](#PAIR.ate2)
+    -   [.fexp(m)](#PAIR.fexp)
+    -   [.lbits()](#PAIR.lbits)
+    -   [.glv()](#PAIR.glv)
+    -   [.gs()](#PAIR.gs)
+    -   [.G1mul(P, e)](#PAIR.G1mul) ⇒
+    -   [.G2mul(P, e)](#PAIR.G2mul) ⇒
+    -   [.GTpow(d, e)](#PAIR.GTpow) ⇒
 
-<a name="new_PAIR_new"></a>
+<a name="new_PAIR_new" />
 
 ### new PAIR()
+
 Creates an instance of PAIR
 
-<a name="PAIR.line"></a>
+<a name="PAIR.line" />
 
 ### PAIR.line()
+
 Line function
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
-<a name="PAIR.initmp"></a>
+**this**: <code>{"{"}PAIR{"}"}</code>  
+<a name="PAIR.initmp" />
 
 ### PAIR.initmp()
+
 prepare for multi-pairing
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
-<a name="PAIR.miller"></a>
+**this**: <code>{"{"}PAIR{"}"}</code>  
+<a name="PAIR.miller" />
 
 ### PAIR.miller(r, res)
+
 basic Miller loop
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| r | FP12 precomputed array of accumulated line functions |
-| res | FP12 result |
+| Param | Description                                          |
+| ----- | ---------------------------------------------------- |
+| r     | FP12 precomputed array of accumulated line functions |
+| res   | FP12 result                                          |
 
-<a name="PAIR.another"></a>
+<a name="PAIR.another" />
 
 ### PAIR.another(r, P1, Q1)
+
 Precompute line functions for n-pairing
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| r | array of precomputed FP48 products of line functions |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
+| Param | Description                                          |
+| ----- | ---------------------------------------------------- |
+| r     | array of precomputed FP48 products of line functions |
+| P1    | An element of G2                                     |
+| Q1    | An element of G1                                     |
 
-<a name="PAIR.ate"></a>
+<a name="PAIR.ate" />
 
 ### PAIR.ate(P1, Q1)
+
 Calculate Miller loop for Optimal ATE pairing e(P,Q)
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 **Result**: r An element of GT i.e. result of the pairing calculation e(P,Q)  
 
-| Param | Description |
-| --- | --- |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
+| Param | Description      |
+| ----- | ---------------- |
+| P1    | An element of G2 |
+| Q1    | An element of G1 |
 
-<a name="PAIR.ate2"></a>
+<a name="PAIR.ate2" />
 
 ### PAIR.ate2(P1, Q1, R1, S1)
+
 Calculate Miller loop for Optimal ATE double-pairing e(P,Q).e(R,S)
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 **Result**: r An element of GT i.e. result of the double pairing calculation e(P,Q).e(R,S)  
 
-| Param | Description |
-| --- | --- |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
-| R1 | An element of G2 |
-| S1 | An element of G1 |
+| Param | Description      |
+| ----- | ---------------- |
+| P1    | An element of G2 |
+| Q1    | An element of G1 |
+| R1    | An element of G2 |
+| S1    | An element of G1 |
 
-<a name="PAIR.fexp"></a>
+<a name="PAIR.fexp" />
 
 ### PAIR.fexp(m)
+
 Final exponentiation of pairing, converts output of Miller loop to element in GT
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 **Result**: r m^((p^12-1)/r) where p is modulus and r is the group order  
 
 | Param | Description |
-| --- | --- |
-| m | FP12 value |
+| ----- | ----------- |
+| m     | FP12 value  |
 
-<a name="PAIR.lbits"></a>
+<a name="PAIR.lbits" />
 
 ### PAIR.lbits()
-prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3*n
+
+prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3\*n
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
-<a name="PAIR.glv"></a>
+**this**: <code>{"{"}PAIR{"}"}</code>  
+<a name="PAIR.glv" />
 
 ### PAIR.glv()
+
 GLV method
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
-<a name="PAIR.gs"></a>
+**this**: <code>{"{"}PAIR{"}"}</code>  
+<a name="PAIR.gs" />
 
 ### PAIR.gs()
+
 Galbraith & Scott Method
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
-**this**: <code>{PAIR}</code>  
-<a name="PAIR.G1mul"></a>
+**this**: <code>{"{"}PAIR{"}"}</code>  
+<a name="PAIR.G1mul" />
 
 ### PAIR.G1mul(P, e) ⇒
+
 Fast point multiplication of a member of the group G1 by a BIG number
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
 **Returns**: R Member of G1 R=e.P  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | Member of G1 |
-| e | BIG multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| P     | Member of G1   |
+| e     | BIG multiplier |
 
-<a name="PAIR.G2mul"></a>
+<a name="PAIR.G2mul" />
 
 ### PAIR.G2mul(P, e) ⇒
+
 Multiply P by e in group G2
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
 **Returns**: R Member of G2 R=e.P  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | Member of G2 |
-| e | BIG multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| P     | Member of G2   |
+| e     | BIG multiplier |
 
-<a name="PAIR.GTpow"></a>
+<a name="PAIR.GTpow" />
 
 ### PAIR.GTpow(d, e) ⇒
+
 Fast raising of a member of GT to a BIG power
 
 **Kind**: static method of [<code>PAIR</code>](#PAIR)  
 **Returns**: r d^e  
-**this**: <code>{PAIR}</code>  
+**this**: <code>{"{"}PAIR{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | Member of GT |
-| e | BIG exponent |
-
+| Param | Description  |
+| ----- | ------------ |
+| d     | Member of GT |
+| e     | BIG exponent |
diff --git a/docs/cryptojs/pair192.md b/docs/cryptojs/pair192.md
index 015c20c..b472c23 100644
--- a/docs/cryptojs/pair192.md
+++ b/docs/cryptojs/pair192.md
@@ -3,178 +3,191 @@
 title: PAIR192
 sidebar_label: PAIR192
 ---
-
-<a name="PAIR192"></a>
+<a name="PAIR192" />
 
 ## PAIR192
+
 **Kind**: global class  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 
-* [PAIR192](#PAIR192)
-    * [new PAIR192()](#new_PAIR192_new)
-    * [.line()](#PAIR192.line)
-    * [.initmp()](#PAIR192.initmp)
-    * [.miller(r, res)](#PAIR192.miller)
-    * [.another(r, P1, Q1)](#PAIR192.another)
-    * [.ate(P1, Q1)](#PAIR192.ate)
-    * [.ate2(P1, Q1, R1, S1)](#PAIR192.ate2)
-    * [.fexp(m)](#PAIR192.fexp)
-    * [.lbits()](#PAIR192.lbits)
-    * [.glv()](#PAIR192.glv)
-    * [.gs()](#PAIR192.gs)
-    * [.G1mul(P, e)](#PAIR192.G1mul) ⇒
-    * [.G2mul(P, e)](#PAIR192.G2mul) ⇒
-    * [.GTpow(d, e)](#PAIR192.GTpow) ⇒
+-   [PAIR192](#PAIR192)
+    -   [new PAIR192()](#new_PAIR192_new)
+    -   [.line()](#PAIR192.line)
+    -   [.initmp()](#PAIR192.initmp)
+    -   [.miller(r, res)](#PAIR192.miller)
+    -   [.another(r, P1, Q1)](#PAIR192.another)
+    -   [.ate(P1, Q1)](#PAIR192.ate)
+    -   [.ate2(P1, Q1, R1, S1)](#PAIR192.ate2)
+    -   [.fexp(m)](#PAIR192.fexp)
+    -   [.lbits()](#PAIR192.lbits)
+    -   [.glv()](#PAIR192.glv)
+    -   [.gs()](#PAIR192.gs)
+    -   [.G1mul(P, e)](#PAIR192.G1mul) ⇒
+    -   [.G2mul(P, e)](#PAIR192.G2mul) ⇒
+    -   [.GTpow(d, e)](#PAIR192.GTpow) ⇒
 
-<a name="new_PAIR192_new"></a>
+<a name="new_PAIR192_new" />
 
 ### new PAIR192()
+
 Creates an instance of PAIR192
 
-<a name="PAIR192.line"></a>
+<a name="PAIR192.line" />
 
 ### PAIR192.line()
+
 Line function
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
-<a name="PAIR192.initmp"></a>
+**this**: <code>{"{"}PAIR192{"}"}</code>  
+<a name="PAIR192.initmp" />
 
 ### PAIR192.initmp()
+
 prepare for multi-pairing
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
-<a name="PAIR192.miller"></a>
+**this**: <code>{"{"}PAIR192{"}"}</code>  
+<a name="PAIR192.miller" />
 
 ### PAIR192.miller(r, res)
+
 basic Miller loop
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| r | FP24 precomputed array of accumulated line functions |
-| res | FP24 result |
+| Param | Description                                          |
+| ----- | ---------------------------------------------------- |
+| r     | FP24 precomputed array of accumulated line functions |
+| res   | FP24 result                                          |
 
-<a name="PAIR192.another"></a>
+<a name="PAIR192.another" />
 
 ### PAIR192.another(r, P1, Q1)
+
 Precompute line functions for n-pairing
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| r | array of precomputed FP24 products of line functions |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
+| Param | Description                                          |
+| ----- | ---------------------------------------------------- |
+| r     | array of precomputed FP24 products of line functions |
+| P1    | An element of G2                                     |
+| Q1    | An element of G1                                     |
 
-<a name="PAIR192.ate"></a>
+<a name="PAIR192.ate" />
 
 ### PAIR192.ate(P1, Q1)
+
 Calculate Miller loop for Optimal ATE pairing e(P,Q)
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 **Result**: r An element of GT i.e. result of the pairing calculation e(P,Q)  
 
-| Param | Description |
-| --- | --- |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
+| Param | Description      |
+| ----- | ---------------- |
+| P1    | An element of G2 |
+| Q1    | An element of G1 |
 
-<a name="PAIR192.ate2"></a>
+<a name="PAIR192.ate2" />
 
 ### PAIR192.ate2(P1, Q1, R1, S1)
+
 Calculate Miller loop for Optimal ATE double-pairing e(P,Q).e(R,S)
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 **Result**: r An element of GT i.e. result of the double pairing calculation e(P,Q).e(R,S)  
 
-| Param | Description |
-| --- | --- |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
-| R1 | An element of G2 |
-| S1 | An element of G1 |
+| Param | Description      |
+| ----- | ---------------- |
+| P1    | An element of G2 |
+| Q1    | An element of G1 |
+| R1    | An element of G2 |
+| S1    | An element of G1 |
 
-<a name="PAIR192.fexp"></a>
+<a name="PAIR192.fexp" />
 
 ### PAIR192.fexp(m)
+
 Final exponentiation of pairing, converts output of Miller loop to element in GT
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 **Result**: r m^((p^12-1)/r) where p is modulus and r is the group order  
 
 | Param | Description |
-| --- | --- |
-| m | FP24 value |
+| ----- | ----------- |
+| m     | FP24 value  |
 
-<a name="PAIR192.lbits"></a>
+<a name="PAIR192.lbits" />
 
 ### PAIR192.lbits()
-prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3*n
+
+prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3\*n
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
-<a name="PAIR192.glv"></a>
+**this**: <code>{"{"}PAIR192{"}"}</code>  
+<a name="PAIR192.glv" />
 
 ### PAIR192.glv()
+
 GLV method
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
-<a name="PAIR192.gs"></a>
+**this**: <code>{"{"}PAIR192{"}"}</code>  
+<a name="PAIR192.gs" />
 
 ### PAIR192.gs()
+
 Galbraith & Scott Method
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
-**this**: <code>{PAIR192}</code>  
-<a name="PAIR192.G1mul"></a>
+**this**: <code>{"{"}PAIR192{"}"}</code>  
+<a name="PAIR192.G1mul" />
 
 ### PAIR192.G1mul(P, e) ⇒
+
 Fast point multiplication of a member of the group G1 by a BIG number
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
 **Returns**: R Member of G1 R=e.P  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | Member of G1 |
-| e | BIG multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| P     | Member of G1   |
+| e     | BIG multiplier |
 
-<a name="PAIR192.G2mul"></a>
+<a name="PAIR192.G2mul" />
 
 ### PAIR192.G2mul(P, e) ⇒
+
 Multiply P by e in group G2
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
 **Returns**: R Member of G2 R=e.P  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | Member of G2 |
-| e | BIG multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| P     | Member of G2   |
+| e     | BIG multiplier |
 
-<a name="PAIR192.GTpow"></a>
+<a name="PAIR192.GTpow" />
 
 ### PAIR192.GTpow(d, e) ⇒
+
 Fast raising of a member of GT to a BIG power
 
 **Kind**: static method of [<code>PAIR192</code>](#PAIR192)  
 **Returns**: r d^e  
-**this**: <code>{PAIR192}</code>  
+**this**: <code>{"{"}PAIR192{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | Member of GT |
-| e | BIG exponent |
-
+| Param | Description  |
+| ----- | ------------ |
+| d     | Member of GT |
+| e     | BIG exponent |
diff --git a/docs/cryptojs/pair256.md b/docs/cryptojs/pair256.md
index 504f411..f5fcd09 100644
--- a/docs/cryptojs/pair256.md
+++ b/docs/cryptojs/pair256.md
@@ -3,178 +3,191 @@
 title: PAIR256
 sidebar_label: PAIR256
 ---
-
-<a name="PAIR256"></a>
+<a name="PAIR256" />
 
 ## PAIR256
+
 **Kind**: global class  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 
-* [PAIR256](#PAIR256)
-    * [new PAIR256()](#new_PAIR256_new)
-    * [.line()](#PAIR256.line)
-    * [.initmp()](#PAIR256.initmp)
-    * [.miller(r, res)](#PAIR256.miller)
-    * [.another(r, P1, Q1)](#PAIR256.another)
-    * [.ate(P1, Q1)](#PAIR256.ate)
-    * [.ate2(P1, Q1, R1, S1)](#PAIR256.ate2)
-    * [.fexp(m)](#PAIR256.fexp)
-    * [.lbits()](#PAIR256.lbits)
-    * [.glv()](#PAIR256.glv)
-    * [.gs()](#PAIR256.gs)
-    * [.G1mul(P, e)](#PAIR256.G1mul) ⇒
-    * [.G2mul(P, e)](#PAIR256.G2mul) ⇒
-    * [.GTpow(d, e)](#PAIR256.GTpow) ⇒
+-   [PAIR256](#PAIR256)
+    -   [new PAIR256()](#new_PAIR256_new)
+    -   [.line()](#PAIR256.line)
+    -   [.initmp()](#PAIR256.initmp)
+    -   [.miller(r, res)](#PAIR256.miller)
+    -   [.another(r, P1, Q1)](#PAIR256.another)
+    -   [.ate(P1, Q1)](#PAIR256.ate)
+    -   [.ate2(P1, Q1, R1, S1)](#PAIR256.ate2)
+    -   [.fexp(m)](#PAIR256.fexp)
+    -   [.lbits()](#PAIR256.lbits)
+    -   [.glv()](#PAIR256.glv)
+    -   [.gs()](#PAIR256.gs)
+    -   [.G1mul(P, e)](#PAIR256.G1mul) ⇒
+    -   [.G2mul(P, e)](#PAIR256.G2mul) ⇒
+    -   [.GTpow(d, e)](#PAIR256.GTpow) ⇒
 
-<a name="new_PAIR256_new"></a>
+<a name="new_PAIR256_new" />
 
 ### new PAIR256()
+
 Creates an instance of PAIR256
 
-<a name="PAIR256.line"></a>
+<a name="PAIR256.line" />
 
 ### PAIR256.line()
+
 Line function
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
-<a name="PAIR256.initmp"></a>
+**this**: <code>{"{"}PAIR256{"}"}</code>  
+<a name="PAIR256.initmp" />
 
 ### PAIR256.initmp()
+
 prepare for multi-pairing
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
-<a name="PAIR256.miller"></a>
+**this**: <code>{"{"}PAIR256{"}"}</code>  
+<a name="PAIR256.miller" />
 
 ### PAIR256.miller(r, res)
+
 basic Miller loop
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| r | FP48 precomputed array of accumulated line functions |
-| res | FP48 result |
+| Param | Description                                          |
+| ----- | ---------------------------------------------------- |
+| r     | FP48 precomputed array of accumulated line functions |
+| res   | FP48 result                                          |
 
-<a name="PAIR256.another"></a>
+<a name="PAIR256.another" />
 
 ### PAIR256.another(r, P1, Q1)
+
 Precompute line functions for n-pairing
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| r | array of precomputed FP48 products of line functions |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
+| Param | Description                                          |
+| ----- | ---------------------------------------------------- |
+| r     | array of precomputed FP48 products of line functions |
+| P1    | An element of G2                                     |
+| Q1    | An element of G1                                     |
 
-<a name="PAIR256.ate"></a>
+<a name="PAIR256.ate" />
 
 ### PAIR256.ate(P1, Q1)
+
 Calculate Miller loop for Optimal ATE pairing e(P,Q)
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 **Result**: r An element of GT i.e. result of the pairing calculation e(P,Q)  
 
-| Param | Description |
-| --- | --- |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
+| Param | Description      |
+| ----- | ---------------- |
+| P1    | An element of G2 |
+| Q1    | An element of G1 |
 
-<a name="PAIR256.ate2"></a>
+<a name="PAIR256.ate2" />
 
 ### PAIR256.ate2(P1, Q1, R1, S1)
+
 Calculate Miller loop for Optimal ATE double-pairing e(P,Q).e(R,S)
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 **Result**: r An element of GT i.e. result of the double pairing calculation e(P,Q).e(R,S)  
 
-| Param | Description |
-| --- | --- |
-| P1 | An element of G2 |
-| Q1 | An element of G1 |
-| R1 | An element of G2 |
-| S1 | An element of G1 |
+| Param | Description      |
+| ----- | ---------------- |
+| P1    | An element of G2 |
+| Q1    | An element of G1 |
+| R1    | An element of G2 |
+| S1    | An element of G1 |
 
-<a name="PAIR256.fexp"></a>
+<a name="PAIR256.fexp" />
 
 ### PAIR256.fexp(m)
+
 Final exponentiation of pairing, converts output of Miller loop to element in GT
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 **Result**: r m^((p^12-1)/r) where p is modulus and r is the group order  
 
 | Param | Description |
-| --- | --- |
-| m | FP48 value |
+| ----- | ----------- |
+| m     | FP48 value  |
 
-<a name="PAIR256.lbits"></a>
+<a name="PAIR256.lbits" />
 
 ### PAIR256.lbits()
-prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3*n
+
+prepare ate parameter, n=6u+2 (BN) or n=u (BLS), n3=3\*n
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
-<a name="PAIR256.glv"></a>
+**this**: <code>{"{"}PAIR256{"}"}</code>  
+<a name="PAIR256.glv" />
 
 ### PAIR256.glv()
+
 GLV method
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
-<a name="PAIR256.gs"></a>
+**this**: <code>{"{"}PAIR256{"}"}</code>  
+<a name="PAIR256.gs" />
 
 ### PAIR256.gs()
+
 Galbraith & Scott Method
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
-**this**: <code>{PAIR256}</code>  
-<a name="PAIR256.G1mul"></a>
+**this**: <code>{"{"}PAIR256{"}"}</code>  
+<a name="PAIR256.G1mul" />
 
 ### PAIR256.G1mul(P, e) ⇒
+
 Fast point multiplication of a member of the group G1 by a BIG number
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
 **Returns**: R Member of G1 R=e.P  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | Member of G1 |
-| e | BIG multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| P     | Member of G1   |
+| e     | BIG multiplier |
 
-<a name="PAIR256.G2mul"></a>
+<a name="PAIR256.G2mul" />
 
 ### PAIR256.G2mul(P, e) ⇒
+
 Multiply P by e in group G2
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
 **Returns**: R Member of G2 R=e.P  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| P | Member of G2 |
-| e | BIG multiplier |
+| Param | Description    |
+| ----- | -------------- |
+| P     | Member of G2   |
+| e     | BIG multiplier |
 
-<a name="PAIR256.GTpow"></a>
+<a name="PAIR256.GTpow" />
 
 ### PAIR256.GTpow(d, e) ⇒
+
 Fast raising of a member of GT to a BIG power
 
 **Kind**: static method of [<code>PAIR256</code>](#PAIR256)  
 **Returns**: r d^e  
-**this**: <code>{PAIR256}</code>  
+**this**: <code>{"{"}PAIR256{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| d | Member of GT |
-| e | BIG exponent |
-
+| Param | Description  |
+| ----- | ------------ |
+| d     | Member of GT |
+| e     | BIG exponent |
diff --git a/docs/cryptojs/rand.md b/docs/cryptojs/rand.md
index 657bc74..f0752f2 100644
--- a/docs/cryptojs/rand.md
+++ b/docs/cryptojs/rand.md
@@ -3,66 +3,72 @@
 title: RAND
 sidebar_label: RAND
 ---
-
-<a name="RAND"></a>
+<a name="RAND" />
 
 ## RAND
+
 **Kind**: global class  
-**this**: <code>{RAND}</code>  
+**this**: <code>{"{"}RAND{"}"}</code>  
 
-* [RAND](#RAND)
-    * [new RAND()](#new_RAND_new)
-    * _instance_
-        * [.clean()](#RAND+clean)
-        * [.sbrand()](#RAND+sbrand)
-        * [.seed(rawlen, raw)](#RAND+seed)
-        * [.getByte()](#RAND+getByte)
-    * _static_
-        * [.pack()](#RAND.pack)
+-   [RAND](#RAND)
+    -   [new RAND()](#new_RAND_new)
+    -   _instance_
+        -   [.clean()](#RAND+clean)
+        -   [.sbrand()](#RAND+sbrand)
+        -   [.seed(rawlen, raw)](#RAND+seed)
+        -   [.getByte()](#RAND+getByte)
+    -   _static_
+        -   [.pack()](#RAND.pack)
 
-<a name="new_RAND_new"></a>
+<a name="new_RAND_new" />
 
 ### new RAND()
+
 Creates an instance of RAND
 
-<a name="RAND+clean"></a>
+<a name="RAND+clean" />
 
 ### ranD.clean()
+
 Delete all internal state of a random number generator
 
 **Kind**: instance method of [<code>RAND</code>](#RAND)  
-**this**: <code>{RAND}</code>  
-<a name="RAND+sbrand"></a>
+**this**: <code>{"{"}RAND{"}"}</code>  
+<a name="RAND+sbrand" />
 
 ### ranD.sbrand()
+
 Marsaglia & Zaman random number generator
 
 **Kind**: instance method of [<code>RAND</code>](#RAND)  
-**this**: <code>{RAND}</code>  
-<a name="RAND+seed"></a>
+**this**: <code>{"{"}RAND{"}"}</code>  
+<a name="RAND+seed" />
 
 ### ranD.seed(rawlen, raw)
+
 Initialize RNG with some real entropy from some external source
 
 **Kind**: instance method of [<code>RAND</code>](#RAND)  
-**this**: <code>{RAND}</code>  
+**this**: <code>{"{"}RAND{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
+| Param  | Description                       |
+| ------ | --------------------------------- |
 | rawlen | the number of seed bytes provided |
-| raw | an array of seed bytes |
+| raw    | an array of seed bytes            |
 
-<a name="RAND+getByte"></a>
+<a name="RAND+getByte" />
 
 ### ranD.getByte()
+
 Get random byte
 
 **Kind**: instance method of [<code>RAND</code>](#RAND)  
-**this**: <code>{RAND}</code>  
-<a name="RAND.pack"></a>
+**this**: <code>{"{"}RAND{"}"}</code>  
+<a name="RAND.pack" />
 
 ### RAND.pack()
+
 Pack 4 bytes into a 32-bit Word
 
 **Kind**: static method of [<code>RAND</code>](#RAND)  
-**this**: <code>{RAND}</code>  
+**this**: <code>{"{"}RAND{"}"}</code>  
diff --git a/docs/cryptojs/rsa.md b/docs/cryptojs/rsa.md
index 4468b17..589efcc 100644
--- a/docs/cryptojs/rsa.md
+++ b/docs/cryptojs/rsa.md
@@ -3,226 +3,239 @@
 title: RSA
 sidebar_label: RSA
 ---
-
 ## Classes
 
 <dl>
 <dt><a href="#RSA">RSA</a></dt>
-<dd></dd>
+<dd />
 <dt><a href="#rsa_private_key">rsa_private_key</a></dt>
-<dd></dd>
+<dd />
 <dt><a href="#rsa_public_key">rsa_public_key</a></dt>
-<dd></dd>
+<dd />
 </dl>
 
-<a name="RSA"></a>
+<a name="RSA" />
 
 ## RSA
+
 **Kind**: global class  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-* [RSA](#RSA)
-    * [new RSA()](#new_RSA_new)
-    * [.bytestohex(b)](#RSA.bytestohex) ⇒
-    * [.bytestostring(b)](#RSA.bytestostring) ⇒
-    * [.stringtobytes(s)](#RSA.stringtobytes) ⇒
-    * [.hashit(sha, A, n)](#RSA.hashit) ⇒
-    * [.KEY_PAIR(rng, e, PRIV, PUB)](#RSA.KEY_PAIR)
-    * [.PKCS15(rng, e, PRIV, PUB)](#RSA.PKCS15) ⇒
-    * [.OAEP_ENCODE(sha, m, rng, P)](#RSA.OAEP_ENCODE) ⇒
-    * [.OAEP_DECODE(sha, P, f)](#RSA.OAEP_DECODE) ⇒
-    * [.PRIVATE_KEY_KILL(PRIV)](#RSA.PRIVATE_KEY_KILL)
-    * [.ENCRYPT(PUB, F, G)](#RSA.ENCRYPT)
-    * [.DECRYPT(PRIV, G, F)](#RSA.DECRYPT)
+-   [RSA](#RSA)
+    -   [new RSA()](#new_RSA_new)
+    -   [.bytestohex(b)](#RSA.bytestohex) ⇒
+    -   [.bytestostring(b)](#RSA.bytestostring) ⇒
+    -   [.stringtobytes(s)](#RSA.stringtobytes) ⇒
+    -   [.hashit(sha, A, n)](#RSA.hashit) ⇒
+    -   [.KEY_PAIR(rng, e, PRIV, PUB)](#RSA.KEY_PAIR)
+    -   [.PKCS15(rng, e, PRIV, PUB)](#RSA.PKCS15) ⇒
+    -   [.OAEP_ENCODE(sha, m, rng, P)](#RSA.OAEP_ENCODE) ⇒
+    -   [.OAEP_DECODE(sha, P, f)](#RSA.OAEP_DECODE) ⇒
+    -   [.PRIVATE_KEY_KILL(PRIV)](#RSA.PRIVATE_KEY_KILL)
+    -   [.ENCRYPT(PUB, F, G)](#RSA.ENCRYPT)
+    -   [.DECRYPT(PRIV, G, F)](#RSA.DECRYPT)
 
-<a name="new_RSA_new"></a>
+<a name="new_RSA_new" />
 
 ### new RSA()
+
 Creates an instance of RSA
 
-<a name="RSA.bytestohex"></a>
+<a name="RSA.bytestohex" />
 
 ### RSA.bytestohex(b) ⇒
+
 Convert byte array to hex string
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: s hex string  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| b | byte array |
+| ----- | ----------- |
+| b     | byte array  |
 
-<a name="RSA.bytestostring"></a>
+<a name="RSA.bytestostring" />
 
 ### RSA.bytestostring(b) ⇒
+
 Convert byte array to string
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: s string  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| b | byte array |
+| ----- | ----------- |
+| b     | byte array  |
 
-<a name="RSA.stringtobytes"></a>
+<a name="RSA.stringtobytes" />
 
 ### RSA.stringtobytes(s) ⇒
+
 Convert a string to byte array
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: b byte array  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
 | Param | Description |
-| --- | --- |
-| s | string |
+| ----- | ----------- |
+| s     | string      |
 
-<a name="RSA.hashit"></a>
+<a name="RSA.hashit" />
 
 ### RSA.hashit(sha, A, n) ⇒
+
 General purpose hash function
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: R hash value  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| A | byte array |
-| n | Integer |
+| Param | Description      |
+| ----- | ---------------- |
+| sha   | is the hash type |
+| A     | byte array       |
+| n     | Integer          |
 
-<a name="RSA.KEY_PAIR"></a>
+<a name="RSA.KEY_PAIR" />
 
-### RSA.KEY\_PAIR(rng, e, PRIV, PUB)
+### RSA.KEY_PAIR(rng, e, PRIV, PUB)
+
 RSA Key Pair Generator
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | is a pointer to a cryptographically secure random number generator |
-| e | the encryption exponent |
-| PRIV | the output RSA private key |
-| PUB | the output RSA public key |
+| Param | Description                                                        |
+| ----- | ------------------------------------------------------------------ |
+| rng   | is a pointer to a cryptographically secure random number generator |
+| e     | the encryption exponent                                            |
+| PRIV  | the output RSA private key                                         |
+| PUB   | the output RSA public key                                          |
 
-<a name="RSA.PKCS15"></a>
+<a name="RSA.PKCS15" />
 
 ### RSA.PKCS15(rng, e, PRIV, PUB) ⇒
+
 PKCS V1.5 padding of a message prior to RSA signature
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: true or false  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| rng | is a pointer to a cryptographically secure random number generator |
-| e | the encryption exponent |
-| PRIV | the output RSA private key |
-| PUB | the output RSA public key |
+| Param | Description                                                        |
+| ----- | ------------------------------------------------------------------ |
+| rng   | is a pointer to a cryptographically secure random number generator |
+| e     | the encryption exponent                                            |
+| PRIV  | the output RSA private key                                         |
+| PUB   | the output RSA public key                                          |
 
-<a name="RSA.OAEP_ENCODE"></a>
+<a name="RSA.OAEP_ENCODE" />
 
-### RSA.OAEP\_ENCODE(sha, m, rng, P) ⇒
+### RSA.OAEP_ENCODE(sha, m, rng, P) ⇒
+
 OAEP padding of a message prior to RSA encryption
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: f is the output encoding, ready for RSA encryption  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| m | is the input message |
-| rng | is a pointer to a cryptographically secure random number generator |
-| P | are input encoding parameter string (could be NULL) |
+| Param | Description                                                        |
+| ----- | ------------------------------------------------------------------ |
+| sha   | is the hash type                                                   |
+| m     | is the input message                                               |
+| rng   | is a pointer to a cryptographically secure random number generator |
+| P     | are input encoding parameter string (could be NULL)                |
 
-<a name="RSA.OAEP_DECODE"></a>
+<a name="RSA.OAEP_DECODE" />
 
-### RSA.OAEP\_DECODE(sha, P, f) ⇒
+### RSA.OAEP_DECODE(sha, P, f) ⇒
+
 OAEP unpadding of a message after RSA decryption
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
 **Returns**: r is the unpadded message  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| sha | is the hash type |
-| P | are input encoding parameter string (could be NULL) |
-| f | is the padded message |
+| Param | Description                                         |
+| ----- | --------------------------------------------------- |
+| sha   | is the hash type                                    |
+| P     | are input encoding parameter string (could be NULL) |
+| f     | is the padded message                               |
 
-<a name="RSA.PRIVATE_KEY_KILL"></a>
+<a name="RSA.PRIVATE_KEY_KILL" />
 
-### RSA.PRIVATE\_KEY\_KILL(PRIV)
+### RSA.PRIVATE_KEY_KILL(PRIV)
+
 Destroy an RSA private Key
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| PRIV | the input RSA private key. Destroyed on output. |
+| Param | Description                                     |
+| ----- | ----------------------------------------------- |
+| PRIV  | the input RSA private key. Destroyed on output. |
 
-<a name="RSA.ENCRYPT"></a>
+<a name="RSA.ENCRYPT" />
 
 ### RSA.ENCRYPT(PUB, F, G)
+
 RSA encryption of suitably padded plaintext
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| PUB | the input RSA public key |
-| F | is input padded message |
-| G | is the output ciphertext |
+| Param | Description              |
+| ----- | ------------------------ |
+| PUB   | the input RSA public key |
+| F     | is input padded message  |
+| G     | is the output ciphertext |
 
-<a name="RSA.DECRYPT"></a>
+<a name="RSA.DECRYPT" />
 
 ### RSA.DECRYPT(PRIV, G, F)
+
 RSA decryption of ciphertext
 
 **Kind**: static method of [<code>RSA</code>](#RSA)  
-**this**: <code>{RSA}</code>  
+**this**: <code>{"{"}RSA{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| PRIV | the input RSA private key |
-| G | is the input ciphertext |
-| F | is output plaintext (requires unpadding) |
+| Param | Description                              |
+| ----- | ---------------------------------------- |
+| PRIV  | the input RSA private key                |
+| G     | is the input ciphertext                  |
+| F     | is output plaintext (requires unpadding) |
 
-<a name="rsa_private_key"></a>
+<a name="rsa_private_key" />
 
-## rsa\_private\_key
+## rsa_private_key
+
 **Kind**: global class  
-**this**: <code>{rsa\_private\_key}</code>  
-<a name="new_rsa_private_key_new"></a>
+**this**: <code>{"{"}rsa_private_key{"}"}</code>  
+<a name="new_rsa_private_key_new" />
 
-### new rsa\_private\_key(n)
+### new rsa_private_key(n)
+
 Creates an instance of rsa_private_key
 
-
 | Param | Description |
-| --- | --- |
-| n | FF length |
+| ----- | ----------- |
+| n     | FF length   |
 
-<a name="rsa_public_key"></a>
+<a name="rsa_public_key" />
 
-## rsa\_public\_key
+## rsa_public_key
+
 **Kind**: global class  
-**this**: <code>{rsa\_private\_key}</code>  
-<a name="new_rsa_public_key_new"></a>
+**this**: <code>{"{"}rsa_private_key{"}"}</code>  
+<a name="new_rsa_public_key_new" />
 
-### new rsa\_public\_key(m)
+### new rsa_public_key(m)
+
 Creates an instance of rsa_public_key
 
-
 | Param | Description |
-| --- | --- |
-| m | FF length |
-
+| ----- | ----------- |
+| m     | FF length   |
diff --git a/docs/cryptojs/sha3.md b/docs/cryptojs/sha3.md
index 03dbd9c..82beb63 100644
--- a/docs/cryptojs/sha3.md
+++ b/docs/cryptojs/sha3.md
@@ -3,72 +3,75 @@
 title: SHA3
 sidebar_label: SHA3
 ---
-
-<a name="SHA3"></a>
+<a name="SHA3" />
 
 ## SHA3
+
 **Kind**: global class  
-**this**: <code>{SHA3}</code>  
+**this**: <code>{"{"}SHA3{"}"}</code>  
 
-* [SHA3](#SHA3)
-    * [new SHA3(olen)](#new_SHA3_new)
-    * [.init(olen)](#SHA3+init)
-    * [.process()](#SHA3+process)
-    * [.hash(buff)](#SHA3+hash)
-    * [.shake(buff, olen)](#SHA3+shake)
+-   [SHA3](#SHA3)
+    -   [new SHA3(olen)](#new_SHA3_new)
+    -   [.init(olen)](#SHA3+init)
+    -   [.process()](#SHA3+process)
+    -   [.hash(buff)](#SHA3+hash)
+    -   [.shake(buff, olen)](#SHA3+shake)
 
-<a name="new_SHA3_new"></a>
+<a name="new_SHA3_new" />
 
 ### new SHA3(olen)
+
 Creates an instance of SHA3
 
+| Param | Description   |
+| ----- | ------------- |
+| olen  | output length |
 
-| Param | Description |
-| --- | --- |
-| olen | output length |
-
-<a name="SHA3+init"></a>
+<a name="SHA3+init" />
 
 ### shA3.init(olen)
+
 Initialise an instance of SHA3
 
 **Kind**: instance method of [<code>SHA3</code>](#SHA3)  
-**this**: <code>{SHA3}</code>  
+**this**: <code>{"{"}SHA3{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| olen | output length |
+| Param | Description   |
+| ----- | ------------- |
+| olen  | output length |
 
-<a name="SHA3+process"></a>
+<a name="SHA3+process" />
 
 ### shA3.process()
+
 Process a byte for SHA3
 
 **Kind**: instance method of [<code>SHA3</code>](#SHA3)  
-**this**: <code>{SHA3}</code>  
+**this**: <code>{"{"}SHA3{"}"}</code>  
 **Byt**: byte of date to be processed  
-<a name="SHA3+hash"></a>
+<a name="SHA3+hash" />
 
 ### shA3.hash(buff)
+
 Create fixed length hash output of SHA3
 
 **Kind**: instance method of [<code>SHA3</code>](#SHA3)  
-**this**: <code>{SHA3}</code>  
+**this**: <code>{"{"}SHA3{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| buff | byte array to store hash |
+| Param | Description              |
+| ----- | ------------------------ |
+| buff  | byte array to store hash |
 
-<a name="SHA3+shake"></a>
+<a name="SHA3+shake" />
 
 ### shA3.shake(buff, olen)
+
 Create variable length hash output of SHA3
 
 **Kind**: instance method of [<code>SHA3</code>](#SHA3)  
-**this**: <code>{SHA3}</code>  
+**this**: <code>{"{"}SHA3{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| buff | byte array to store hash |
-| olen | length of the hash |
-
+| Param | Description              |
+| ----- | ------------------------ |
+| buff  | byte array to store hash |
+| olen  | length of the hash       |
diff --git a/docs/cryptojs/uint64.md b/docs/cryptojs/uint64.md
index 22d5a85..10f1b6a 100644
--- a/docs/cryptojs/uint64.md
+++ b/docs/cryptojs/uint64.md
@@ -3,53 +3,56 @@
 title: UInt64
 sidebar_label: UInt64
 ---
-
-<a name="UInt64"></a>
+<a name="UInt64" />
 
 ## UInt64
+
 **Kind**: global class  
-**this**: <code>{UInt64}</code>  
+**this**: <code>{"{"}UInt64{"}"}</code>  
 
-* [UInt64](#UInt64)
-    * [new UInt64(top, bot)](#new_UInt64_new)
-    * [.add(y)](#UInt64+add)
-    * [.copy()](#UInt64+copy)
-    * [.shlb()](#UInt64+shlb)
+-   [UInt64](#UInt64)
+    -   [new UInt64(top, bot)](#new_UInt64_new)
+    -   [.add(y)](#UInt64+add)
+    -   [.copy()](#UInt64+copy)
+    -   [.shlb()](#UInt64+shlb)
 
-<a name="new_UInt64_new"></a>
+<a name="new_UInt64_new" />
 
 ### new UInt64(top, bot)
+
 Creates an instance of UInt64. Rudimentary unsigned 64-bit type for SHA384 and SHA512
 
+| Param | Description    |
+| ----- | -------------- |
+| top   | Top 32 bits    |
+| bot   | Bottom 32 bits |
 
-| Param | Description |
-| --- | --- |
-| top | Top 32 bits |
-| bot | Bottom 32 bits |
-
-<a name="UInt64+add"></a>
+<a name="UInt64+add" />
 
 ### uInt64.add(y)
+
 Add value
 
 **Kind**: instance method of [<code>UInt64</code>](#UInt64)  
-**this**: <code>{UInt64}</code>  
+**this**: <code>{"{"}UInt64{"}"}</code>  
 
-| Param | Description |
-| --- | --- |
-| y | UInt64 value |
+| Param | Description  |
+| ----- | ------------ |
+| y     | UInt64 value |
 
-<a name="UInt64+copy"></a>
+<a name="UInt64+copy" />
 
 ### uInt64.copy()
+
 Copy value
 
 **Kind**: instance method of [<code>UInt64</code>](#UInt64)  
-**this**: <code>{UInt64}</code>  
-<a name="UInt64+shlb"></a>
+**this**: <code>{"{"}UInt64{"}"}</code>  
+<a name="UInt64+shlb" />
 
 ### uInt64.shlb()
+
 Shift left
 
 **Kind**: instance method of [<code>UInt64</code>](#UInt64)  
-**this**: <code>{UInt64}</code>  
+**this**: <code>{"{"}UInt64{"}"}</code>  
diff --git a/docs/d-ta-api.md b/docs/d-ta-api.md
index dafe80d..66dcf5b 100644
--- a/docs/d-ta-api.md
+++ b/docs/d-ta-api.md
@@ -3,15 +3,13 @@
 title: D-TA Node API
 sidebar_label: D-TA Node API
 ---
-
 :::tip WE NEED HELP DOCUMENTING!
 Interested in becoming a contributor? Milagro is looking for you.
-[CONTRIBUTOR'S GUIDE](/docs/contributor-guide.html).
+[CONTRIBUTOR'S GUIDE](/docs/contributor-guide).
 :::
 
 [Swagger](/swagger/index.html)
 
 
-<!--
 Supported admonition types are: caution, note, important, tip, warning.
--->
\ No newline at end of file
+
diff --git a/docs/d-ta-overview.md b/docs/d-ta-overview.md
index 966c2d2..b779ecf 100644
--- a/docs/d-ta-overview.md
+++ b/docs/d-ta-overview.md
@@ -15,10 +15,11 @@
 RC1 Release: Q1 2020
 
 # Introduction
+
 The Apache Milagro (Incubating) Decentralized Trust Authority (D-TA) is a collaborative key management server. It has two primary functions. 
 
-1. **Issue** shares of identity-based Type-3 pairing secrets for initializing zero-knowledge proof multi-factor authentication (ZKP-MFA) networks of clients and authentication servers.
-2. **Safeguards** shares of generic secrets, acting independently but in conjunction with other D-TA nodes, for the benefit of other D-TA nodes. 
+1.  **Issue** shares of identity-based Type-3 pairing secrets for initializing zero-knowledge proof multi-factor authentication (ZKP-MFA) networks of clients and authentication servers.
+2.  **Safeguards** shares of generic secrets, acting independently but in conjunction with other D-TA nodes, for the benefit of other D-TA nodes. 
 
 In the use case where it issues shares, the D-TA holds nothing except for its Master Secret and acts as a distributed private key generation server. In the use case where it is safeguarding shares of secrets, it is up to the application developer to implement back-end application logic to hold those shares securely. Examples include using Hardware Security Modules (HSMs) via an on-board PKCS#11 implementation to create a realm of key encryption keys, or multi-party computation through BLS signature aggregation.
 
@@ -26,15 +27,15 @@
 
 Operators of Decentralized Trust Authorities are segmented into three roles.
 
-1. **Principals** - These entities operate a Milagro D-TA node to securely communicate with other D-TA nodes (Fiduciaries), employing them to issues shares of secrets or safeguard shares of secrets.
+1.  **Principals** - These entities operate a Milagro D-TA node to securely communicate with other D-TA nodes (Fiduciaries), employing them to issues shares of secrets or safeguard shares of secrets.
 
-2. **Fiduciaries** - These entities operate \\( 1 + n \\) Milagro D-TAs to issue shares of secrets or safeguard shares of secrets.
+2.  **Fiduciaries** - These entities operate \\( 1 + n \\) Milagro D-TAs to issue shares of secrets or safeguard shares of secrets.
 
-3. **Beneficiaries** - These entities receive shares of secrets from Fiduciaries.
+3.  **Beneficiaries** - These entities receive shares of secrets from Fiduciaries.
 
 A D-TA facilitates secure and auditable communication between entities and service providers who can keep shares of secret keys safe (Fiduciaries). The D-TA is written in Go and uses REST services based on the GoKit microservices framework. The D-TA uses IPFS to create a shared immutable log of transactions and relies on Milagro-Crypto-C for it's crypto. Future release candidates will incorporate Tendermint for consensus protocol.
 
-# Safeguarding Secrets 
+# Safeguarding Secrets
 
 In order to safeguard a secret using the D-TA a minimum of two roles are required: a client (Principal) and a server (Fiduciary). In addition a third party can be nominated as the ultimate recipient of the secret (Beneficiary). You can run a single D-TA to provide all three roles if you want to see it in action. See the [quick start guide](/docs/dta-details/quickstart) for instructions on how to do that.
 
@@ -43,24 +44,27 @@
 ![Figure 1](/img/dta/RC1-Overview-1.png)
 
 ## Milagro D-TA Security
+
 The **Seed** is the focus of the system - the D-TA provides a method for Principals to communicate with Fiduciaries who can secure their secrets, it does not prescribe how the securing should be done. The most basic implementation of a D-TA should secure seeds in an HSM using a PKCS#11 interface. 
 
 We hope that many custodial services will adopt the Milagro D-TA as a communication protocol and that they will bring a profusion of security paradigms, by working together we can make a dynamic market place for custodial services and together make the Internet a safer place.
 
 ## The Milagro D-TA Communication Protocol
+
 The D-TA provides a secure, distributed method of communication between Beneficiaries, Principals and Fiduciaries. It aims to solve the following problems:
 
-1. How can actors in the system be identified and trusted?
+1.  How can actors in the system be identified and trusted?
 
     **Answer:** [Identity Documents](dta-details/identity-documents.md)
-2. How can records of interactions between actors in the system be trusted and verified?
+
+2.  How can records of interactions between actors in the system be trusted and verified?
 
     **Answer:** [Encrypted Envelopes](dta-details/encrypted-envelope.md) via [IPFS](dta-details/ipfs.md)
 
-3. How can different custodial services provide their own "special security sauce"?
+3.  How can different custodial services provide their own "special security sauce"?
 
     **Answer:** [Plugins](dta-details/d-ta-plugins.md)
 
 A more complete view of the Milagro D-TA ecosystem is shown below
 
-![Figure 1](/img/dta/RC1.png)
\ No newline at end of file
+![Figure 1](/img/dta/RC1.png)
diff --git a/docs/downloads.md b/docs/downloads.md
index 7fab640..147357b 100644
--- a/docs/downloads.md
+++ b/docs/downloads.md
@@ -3,7 +3,6 @@
 title: Downloads
 sidebar_label: Downloads
 ---
-
 # Project Downloads
 
 This page will be updated with all official Apache Software Foundation releases from the Apache Milagro (incubating) project.
@@ -20,8 +19,8 @@
 
 ### Source Release
 
-|[tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-crypto-c-2.0.1-incubating/apache-milagro-crypto-c-2.0.1-incubating-src.tar.gz)|[sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-2.0.1-incubating/apache-milagro-crypto-c-2.0.1-incubating-src.tar.gz.sha512)|[signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-2.0.1-incubating/apache-milagro-crypto-c-2.0.1-incubating-src.tar.gz.asc)|
-| ----- | ----- | ----- |
+| [tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-crypto-c-2.0.1-incubating/apache-milagro-crypto-c-2.0.1-incubating-src.tar.gz) | [sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-2.0.1-incubating/apache-milagro-crypto-c-2.0.1-incubating-src.tar.gz.sha512) | [signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-2.0.1-incubating/apache-milagro-crypto-c-2.0.1-incubating-src.tar.gz.asc) |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ### Release Notes
 
@@ -37,8 +36,8 @@
 
 ### Source Release
 
-|[tar.gz](https://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-mpc-0.1-incubating/apache-milagro-mpc-0.1-incubating-src.tar.gz)|[sha512](https://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-mpc-0.1-incubating/apache-milagro-mpc-0.1-incubating-src.tar.gz.sha512)|[signature](https://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-mpc-0.1-incubating/apache-milagro-mpc-0.1-incubating-src.tar.gz.asc)|
-| ----- | ----- | ----- |
+| [tar.gz](https://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-mpc-0.1-incubating/apache-milagro-mpc-0.1-incubating-src.tar.gz) | [sha512](https://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-mpc-0.1-incubating/apache-milagro-mpc-0.1-incubating-src.tar.gz.sha512) | [signature](https://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-mpc-0.1-incubating/apache-milagro-mpc-0.1-incubating-src.tar.gz.asc) |
+| ------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ### Release Notes
 
@@ -48,15 +47,14 @@
 
 none
 
-
 ## Apache Milagro Decentralized Trust Authority Incubating v0.1.0 (Alpha Release)
 
 This is the initial release of the Apache Milagro Decentralized Trust Authority server.
 
 ### Source Release
 
-|[tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-dta-0.1.0-incubating/apache-milagro-dta-0.1.0-incubating-src.tar.gz)|[sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-dta-0.1.0-incubating/apache-milagro-dta-0.1.0-incubating-src.tar.gz.sha512)|[signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-dta-0.1.0-incubating/apache-milagro-dta-0.1.0-incubating-src.tar.gz.asc)|
-| ----- | ----- | ----- |
+| [tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-dta-0.1.0-incubating/apache-milagro-dta-0.1.0-incubating-src.tar.gz) | [sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-dta-0.1.0-incubating/apache-milagro-dta-0.1.0-incubating-src.tar.gz.sha512) | [signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-dta-0.1.0-incubating/apache-milagro-dta-0.1.0-incubating-src.tar.gz.asc) |
+| --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ### Release Notes
 
@@ -72,8 +70,8 @@
 
 ### Source Release
 
-|[tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-crypto-c-1.0.0-incubating/apache-milagro-crypto-c-1.0.0-incubating-src.tar.gz)|[sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-1.0.0-incubating/apache-milagro-crypto-c-1.0.0-incubating-src.tar.gz.sha512)|[signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-1.0.0-incubating/apache-milagro-crypto-c-1.0.0-incubating-src.tar.gz.asc)|
-| ----- | ----- | ----- |
+| [tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-crypto-c-1.0.0-incubating/apache-milagro-crypto-c-1.0.0-incubating-src.tar.gz) | [sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-1.0.0-incubating/apache-milagro-crypto-c-1.0.0-incubating-src.tar.gz.sha512) | [signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-c-1.0.0-incubating/apache-milagro-crypto-c-1.0.0-incubating-src.tar.gz.asc) |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ### Release Notes
 
@@ -83,15 +81,14 @@
 
 None
 
-
 ## Apache Milagro Crypto JS Incubating v1.0.0
 
 This is the initial release of the Apache Milagro Crypto JS library.
 
 ### Source Release
 
-|[tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-crypto-js-1.0.0-incubating/apache-milagro-crypto-js-1.0.0-incubating-src.tar.gz)|[sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-js-1.0.0-incubating/apache-milagro-crypto-js-1.0.0-incubating-src.tar.gz.sha512)|[signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-js-1.0.0-incubating/apache-milagro-crypto-js-1.0.0-incubating-src.tar.gz.asc)|
-| ----- | ----- | ----- |
+| [tar.gz](http://www.apache.org/dyn/closer.cgi/incubator/milagro/apache-milagro-crypto-js-1.0.0-incubating/apache-milagro-crypto-js-1.0.0-incubating-src.tar.gz) | [sha512](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-js-1.0.0-incubating/apache-milagro-crypto-js-1.0.0-incubating-src.tar.gz.sha512) | [signature](https://www.apache.org/dist/incubator/milagro/apache-milagro-crypto-js-1.0.0-incubating/apache-milagro-crypto-js-1.0.0-incubating-src.tar.gz.asc) |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 
 ### Release Notes
 
@@ -101,6 +98,6 @@
 
 None
 
-<!--
+
 Supported admonition types are: caution, note, important, tip, warning.
--->
+
diff --git a/docs/dta-details/api.md b/docs/dta-details/api.md
index f5fc86f..a8a62d8 100644
--- a/docs/dta-details/api.md
+++ b/docs/dta-details/api.md
@@ -3,13 +3,11 @@
 title: API
 sidebar_label: API
 ---
-
 Open-API specifications are provided for the core "vanilla" Milagro D-TA HTTP REST services and for both the shipped plugins: Bitcoin Wallet Security and Safeguard Secret.
 
-* [Standard API](https://raw.githubusercontent.com/apache/incubator-milagro-dta/develop/open-api.yaml) The [Swagger UI is available at this link.](/swagger/index.html)   
-* [Bitcoin Wallet Security Plugin API](https://raw.githubusercontent.com/apache/incubator-milagro-dta/develop/pkg/bitcoinplugin/open-api.yaml)   
-* [Safeguard Secret API](https://raw.githubusercontent.com/apache/incubator-milagro-dta/develop/pkg/safeguardsecret/open-api.yaml)   
-
+-   [Standard API](https://raw.githubusercontent.com/apache/incubator-milagro-dta/develop/open-api.yaml) The [Swagger UI is available at this link.](/swagger/index.html)   
+-   [Bitcoin Wallet Security Plugin API](https://raw.githubusercontent.com/apache/incubator-milagro-dta/develop/pkg/bitcoinplugin/open-api.yaml)   
+-   [Safeguard Secret API](https://raw.githubusercontent.com/apache/incubator-milagro-dta/develop/pkg/safeguardsecret/open-api.yaml)   
 
 ## Testing The API
 
@@ -20,19 +18,16 @@
 For example...
 
 ```
+
 docker pull swaggerapi/swagger-ui  
 
 docker run -p 80:8080 swaggerapi/swagger-ui
 
+
 ```
 
 In your browser hit http://localhost:80
 
 Paste the URL of one of the API docs above into the text box at the top of the screen. 
 
-Please let us know your comments by subscribing to dev@milagro.apache.org by sending an email to dev-subscribe@milagro.apache.org.
-
-
-
-
-
+Please let us know your comments by subscribing to [dev@milagro.apache.org](mailto:dev@milagro.apache.org) by sending an email to [dev-subscribe@milagro.apache.org](mailto:dev-subscribe@milagro.apache.org).
diff --git a/docs/dta-details/authentication.md b/docs/dta-details/authentication.md
index 48153c6..c9fd47a 100644
--- a/docs/dta-details/authentication.md
+++ b/docs/dta-details/authentication.md
@@ -6,19 +6,15 @@
 When you first install a Milagro D-TA, the API endpoints are not authenticated by default. In other words, any simple CURL command will elicit the expected response. Milagro D-TAs support the [oAuth bearer token authentication](https://tools.ietf.org/html/rfc6750) out of the box.
 
 :::caution
-We strong recommend that you ***do not*** run a Milagro D-TA instance without authentication.
+We strong recommend that you **_do not_** run a Milagro D-TA instance without authentication.
 :::
 
 To configure authentication all that is required is a standard OAuth 2.0 service. If you do not have an OAuth service currently running in your own infrastructure, we recommend any of these fine service providers who will be able to authenticate your API users.
-* [AWS Cognito](https://aws.amazon.com/cognito/)
-* [Azure Active Directory](https://azure.microsoft.com/en-gb/services/active-directory/)
-* [AuthO](https://auth0.com/)
+
+-   [AWS Cognito](https://aws.amazon.com/cognito/)
+-   [Azure Active Directory](https://azure.microsoft.com/en-gb/services/active-directory/)
+-   [AuthO](https://auth0.com/)
 
 ## Configuration
 
 Please see [Configuration](configuration.md) for details on how to configure config.yaml to support OAuth.
-
-
-
-
-
diff --git a/docs/dta-details/configuration.md b/docs/dta-details/configuration.md
index e300711..15e9b44 100644
--- a/docs/dta-details/configuration.md
+++ b/docs/dta-details/configuration.md
@@ -9,13 +9,16 @@
 :::
 
 ## Configuration File
+
 The config file is located in `~/.milagro/config.yaml`
 
 :::important this configuration method is not yet supported when running in Docker.  Please use the command line flags described below.
 :::
 
 The default values are shown below with some explanatory comments:
+
 ```json
+
 // http ports
 http:
   listenAddr: :5556
@@ -68,12 +71,15 @@
 // Define the plugin to be used.  Default is "milagro".  Currently available alternative plugins are "bitcoinwallet" and "safeguardsecret"
 plugins:
   service: milagro
+
 ```
+
 ## Command Line Flags
 
 To view available service commands:
 
 ```json
+
  ./milagro
 Milagro DTA
 USAGE
@@ -82,6 +88,7 @@
 COMMANDS
 	init	Initialize configuration
 	daemon	Starts the milagro daemon
+
 ```
 
 To view the available initialization option flags, use the `-help` flag:
@@ -89,6 +96,7 @@
 ### INIT
 
 ```json
+
 ./milagro init -help
 Usage of init:
   -interactive
@@ -99,32 +107,36 @@
     	Node name
   -service string
     	Service plugin (default "milagro")
-```  
 
-* **masterfiduciarynode** - if you want to use an external master fiduciary, use this flag to set its identity (nodeID) and endpoint separated with a comma. For example:
-```json
-QmR7JfvEwTbSkBZuRLdDcRTpZik2ZAuHnn9BA7giX7oJNK,http://123.456.789.1:5556
 ```
+
+-   **masterfiduciarynode** - if you want to use an external master fiduciary, use this flag to set its identity (nodeID) and endpoint separated with a comma. For example:
+
+```json
+
+QmR7JfvEwTbSkBZuRLdDcRTpZik2ZAuHnn9BA7giX7oJNK,http://123.456.789.1:5556
+
+```
+
 :::note By default a D-TA will be both a principal and master fiduciary. 
 :::  
-* **nodename** - set your DT-A node name (nodeName) here.  By default, a random name with be generated if none is specified.   
-* **service** - use this flag to set which plugin to use.  Default is "milagro".  Currently available plugins are "bitcoinwallet" and "safeguardsecret".
-* **interactive** - use this flag to prompt for values for the other flags.  For example, to set the name (nodeName) of this DT-A to "alice", the identity (nodeID) of the external fiduciary to "QmR7JfvEwTbSkBZuRLdDcRTpZik2ZAuHnn9BA7giX7oJNK", the endpoint of the master fiduciary to "http://123.456.789.1:5556" and to use the "bitcoinwallet" plugin: 
- 
+
+-   **nodename** - set your DT-A node name (nodeName) here.  By default, a random name with be generated if none is specified.   
+-   **service** - use this flag to set which plugin to use.  Default is "milagro".  Currently available plugins are "bitcoinwallet" and "safeguardsecret".
+-   **interactive** - use this flag to prompt for values for the other flags.  For example, to set the name (nodeName) of this DT-A to "alice", the identity (nodeID) of the external fiduciary to "QmR7JfvEwTbSkBZuRLdDcRTpZik2ZAuHnn9BA7giX7oJNK", the endpoint of the master fiduciary to "http: and to use the "bitcoinwallet" plugin: 
+
 ```json
-./milagro init -interactive
-What is your node name?. Leave blank to generate a random name: alice 
-What is your Master Fiduciary DTA’s node name? Leave blank to use this DTA as the Master Fiduciary: QmR7JfvEwTbSkBZuRLdDcRTpZik2ZAuHnn9BA7giX7oJNK   
-What is your Master Fiduciary DTA’s address?: http://123.456.789.1:5556   
-What plugin do you want to install? (B)itcoin wallet address generator or (S)afeguard secret. Leave blank for no plugin: B
+
+
+
 ```
 
 ### DAEMON
-```json
-./milagro daemon -help
-Usage of daemon:
-  -service string
-    	Service plugin (default "bitcoinwallet")
-```
-* **service** - use this flag to set which plugin to use.  Default is "milagro".  Currently available plugins are "bitcoinwallet" and "safeguardsecret".
 
+```json
+
+
+
+```
+
+-   **service** - use this flag to set which plugin to use.  Default is "milagro".  Currently available plugins are "bitcoinwallet" and "safeguardsecret".
diff --git a/docs/dta-details/d-ta-plugins.md b/docs/dta-details/d-ta-plugins.md
index a4d9091..36bf3b2 100644
--- a/docs/dta-details/d-ta-plugins.md
+++ b/docs/dta-details/d-ta-plugins.md
@@ -3,7 +3,6 @@
 title: D-TA Plugins Overview
 sidebar_label: Plugins Overview
 ---
-
 The out-of-the-box Milagro D-TA doesn't do much: a Principal's D-TA gets a public key from a Fiduciary's D-TA, and at a later date, can request the corresponding secret key. It is simple conceptually, but the core operation does this in a hard-to-hack, and fully auditable way. 
 
 However, this basic capability unlocks a huge range of potential uses cases. Some use cases relate to the Principal i.e. what the keys can be used for, and some relate to the Fiduciary i.e. how the secret key is kept safe (a.k.a. custody). 
@@ -11,57 +10,67 @@
 The open source "vanilla" Milagro is an attempt to engage a wider community to make the communication between these parties as robust as possible, and the plugin framework enables developers to extend the Milagro D-TA's core capability and apply it to solve real world problems.
 
 Out of the box the Milagro D-TA comes with two plugins:
-1. **Safeguard Secret** - allows the Principal to use a public key obtained from the Fiduciary's D-TA to encrypt a string using ECIES, then obtain the secret key back from the Fiduciary's D-TA to decrypt the same string.
 
-2. **Bitcoin Wallet Security** - uses the public key to generate a Bitcoin address and then constructs the corresponding secret key only when it is needed (this is a neat trick using elliptic curve magic).
+1.  **Safeguard Secret** - allows the Principal to use a public key obtained from the Fiduciary's D-TA to encrypt a string using ECIES, then obtain the secret key back from the Fiduciary's D-TA to decrypt the same string.
 
-***A Note About Security***
+2.  **Bitcoin Wallet Security** - uses the public key to generate a Bitcoin address and then constructs the corresponding secret key only when it is needed (this is a neat trick using elliptic curve magic).
+
+**_A Note About Security_**
 
 The point of these plugins is to show you how the framework works and encourage you to develop your own. They do not (out of the box) provide a secure way to store your secret keys. The key pair seed is stored only in the Fiduciary's onboard database - this is not how you should be doing it in production. Future releases will provide guidance on securing these seeds via PKCS#11 integrations and tie-ins to service providers.
 
 ## Approach
+
 The Milagro D-TA plugin framework has been designed with following assumptions:
 
-* **Compile-Time**
+-   **Compile-Time**
 
-    Milagro D-TA plugins are compiled into the Milagro D-TA - to include one you simply clone the plugin into to the pkg directory and pass a reference to the plugin as a build directive like this...
+      Milagro D-TA plugins are compiled into the Milagro D-TA - to include one you simply clone the plugin into to the pkg directory and pass a reference to the plugin as a build directive like this...
+
     ```
+
     go build -tags "plugin encryptAThing" -o target/service github.com/apache/incubator-milagro-dta/cmd/service
+
     ```
-    We considered run-time plugins using shared objects via the [Go Plugin Package](https://golang.org/pkg/plugin/) however this presented significant security challenges. We would very much like explore this idea further with the developer community.
 
-* **One-at-a-Time**
+      We considered run-time plugins using shared objects via the [Go Plugin Package](https://golang.org/pkg/plugin/) however this presented significant security challenges. We would very much like explore this idea further with the developer community.
 
-   Each Milagro D-TA server can only run one plugin at a time. We considered how to allow multiple plugins to interoperate but this produces significant operational and security concerns. Of course if you run a pair of servers, (example: as Principal and Fiduciary) then they can each run different plugins.
-* **No New Endpoints**
+-   **One-at-a-Time**
 
-    You can only write plugins to support the [Standard Endpoints](http://localhost:3000/swagger/). This probably seems quite restrictive but we think it is important that Milagro D-TA operates within a defined scope and in a predictable way. The Milagro D-TA is about the distributed management of key pairs, we are concerned that if the plugin framework allowed developers to add endpoints such as *GET fastfood/burger?orderby=mostTasty* then Milagro would just become a cool implementation of [Go kit](https://gokit.io/) and it would become impossible for users and integrators to predict what it will do. **However...**
-    * **Let's Talk**: As a community we're excited to add new features to the Milagro D-TA. Propose your new endpoint as a feature (or even submit a PR) and we'll collectively consider adding it.
-    * **Let's Fork**: Go ahead and fork the Milagro D-TA. (But remember that the Milagro D-TA is basically a communication protocol so keep it compatible with other Milagro users).
+     Each Milagro D-TA server can only run one plugin at a time. We considered how to allow multiple plugins to interoperate but this produces significant operational and security concerns. Of course if you run a pair of servers, (example: as Principal and Fiduciary) then they can each run different plugins.
 
-* **Extensions** 
+-   **No New Endpoints**
 
-   Although we restrict what endpoints Milagro provides we give you a highly flexible way to define what data each endpoint accepts and returns via the **extensions** JSON prop. For example the Safeguard Secret plugin extends the POST /order endpoint like this:
-   ```
-    POST /order
-    
-    Request    
-    {
-        "beneficiaryIDDocumentCID" : "IPFSAddress",
-        "extensions" : {
-            "plainText":"encryptme"
-            }
-    }
+      You can only write plugins to support the [Standard Endpoints](http://localhost:3000/swagger/). This probably seems quite restrictive but we think it is important that Milagro D-TA operates within a defined scope and in a predictable way. The Milagro D-TA is about the distributed management of key pairs, we are concerned that if the plugin framework allowed developers to add endpoints such as _GET fastfood/burger?orderby=mostTasty_ then Milagro would just become a cool implementation of [Go kit](https://gokit.io/) and it would become impossible for users and integrators to predict what it will do. **However...**
 
-    Response
-    {
-    	"orderPart1CID" : "IPFSAddress",
-	    "orderPart2CID" : "IPFSAddress",
-	    "commitment"    : "IPFSAddress",
-	    "createdAt"     : 1563982017,
-        "extensions" : {
-            "cypherText":"iAmEncrypted"
-        }	    
-    }
-   ```
+    -   **Let's Talk**: As a community we're excited to add new features to the Milagro D-TA. Propose your new endpoint as a feature (or even submit a PR) and we'll collectively consider adding it.
+    -   **Let's Fork**: Go ahead and fork the Milagro D-TA. (But remember that the Milagro D-TA is basically a communication protocol so keep it compatible with other Milagro users).
 
+-   **Extensions** 
+
+     Although we restrict what endpoints Milagro provides we give you a highly flexible way to define what data each endpoint accepts and returns via the **extensions** JSON prop. For example the Safeguard Secret plugin extends the POST /order endpoint like this:
+
+    ```
+
+     POST /order
+     
+     Request    
+     {
+         "beneficiaryIDDocumentCID" : "IPFSAddress",
+         "extensions" : {
+             "plainText":"encryptme"
+             }
+     }
+
+     Response
+     {
+     	"orderPart1CID" : "IPFSAddress",
+       "orderPart2CID" : "IPFSAddress",
+       "commitment"    : "IPFSAddress",
+       "createdAt"     : 1563982017,
+         "extensions" : {
+             "cypherText":"iAmEncrypted"
+         }	    
+     }
+
+    ```
diff --git a/docs/dta-details/encrypted-envelope.md b/docs/dta-details/encrypted-envelope.md
index e4d7dc6..1386912 100644
--- a/docs/dta-details/encrypted-envelope.md
+++ b/docs/dta-details/encrypted-envelope.md
@@ -3,7 +3,6 @@
 title: Encrypted Envelope
 sidebar_label: Encrypted Envelope
 ---
-
 The Milagro D-TA enables Principals (who require secrets to be safeguarded) to communicate with Fiduciaries who provide custodian services for those secrets. To facilitate these transactions communication between the parties must be secure i.e., must have privacy, authentication, non-repudiation and message integrity. The Milagro D-TA delivers this using its "Encrypted Envelope" messaging format.
 
 :::tip The Milagro D-TA Encrypted Envelope format is conceptually similar to S/MIME and its cryptographic message format.
@@ -12,31 +11,30 @@
 
 ## Overview
 
-1. The message consists of a header and body.
-2. The message body is encrypted with an AES key.
-3. The AES key for decrypting ciphertext is "encapsulated" i.e. encrypted using each recipient's public key.
-4. The sender signs the message.
-5. The message header contains a list of each recipient's encrypted version of the key.
-6. The message is pushed to IPFS and the IPFS address hash is sent to the recipients.
-7. The recipients verify the signature and then read the message.
-7. Only recipients with the matching secret keys can decrypt the AES key and use it to read the encrypted message bodies.
+1.  The message consists of a header and body.
+2.  The message body is encrypted with an AES key.
+3.  The AES key for decrypting ciphertext is "encapsulated" i.e. encrypted using each recipient's public key.
+4.  The sender signs the message.
+5.  The message header contains a list of each recipient's encrypted version of the key.
+6.  The message is pushed to IPFS and the IPFS address hash is sent to the recipients.
+7.  The recipients verify the signature and then read the message.
+8.  Only recipients with the matching secret keys can decrypt the AES key and use it to read the encrypted message bodies.
 
 ![Figure 3](/img/dta/Envelope.png)
 
 :::note Post Quantum Cryptography
 At the time of writing the Milagro D-TA implements cryptographic routines from the [NIST Post-Quantum Cryptography Standardization Project](https://csrc.nist.gov/Projects/Post-Quantum-Cryptography/Round-2-Submissions).
-* [SIKE](https://sike.org/) - key encapsulation
-This implementation is currently under review.
-:::
+
+-   [SIKE](https://sike.org/) - key encapsulation
+    This implementation is currently under review.
+    :::
 
 :::note digital signatures
 Milagro D-TAs use [BLS signatures](https://en.wikipedia.org/wiki/Boneh–Lynn–Shacham) to sign encrypted envelopes.
 :::
 
 ## Multipart Messages
+
 The Milagro D-TA's Encrypted Envelopes are designed to facilitate a dialogue between the Principal, Fiduciary and Beneficiaries. Requests and responses are appended to the original document and published back to IPFS which returns new HASH address. 
 
 In this way, an immutable copy of each transaction is maintained, but the intended recipients can view the entire history of the transaction if they have the required decryption keys. Each message can be seen within each update, providing additional assurance and verification and reducing round trips to IPFS. 
-
-
-
diff --git a/docs/dta-details/identity-documents.md b/docs/dta-details/identity-documents.md
index 181b904..dd3764a 100644
--- a/docs/dta-details/identity-documents.md
+++ b/docs/dta-details/identity-documents.md
@@ -14,7 +14,9 @@
 :::
 
 The definition of an identity document is:
+
 ```json
+
 message IDDocument {
     string IDDocumentCID			= 2 ;
     string AuthenticationReference  = 3 ;
@@ -24,13 +26,15 @@
     int64 Timestamp                 = 7 ;
 }
 
+
 ```
 
-* `AuthenticationReference` refers to Milagro's out of the box [oAuth integration](authentication.md).
+-   `AuthenticationReference` refers to Milagro's out of the box [oAuth integration](authentication.md).
 
 The node that is used to create an Identity Document will store the seed and secret keys associated with the Identity. In the RC1 release these will be stored as a JSON file in the key value store:
 
 ```json
+
 //IdentitySecrets - keys required for decryption and signing
 type IdentitySecrets struct {
 	Name            string `json:"name"`
@@ -38,4 +42,5 @@
 	SikeSecretKey   string `json:"sikeSecretKey"`
 	BlsSecretKey 	string `json:"BlsSecretKey"`
 }
-```
\ No newline at end of file
+
+```
diff --git a/docs/dta-details/ipfs.md b/docs/dta-details/ipfs.md
index 1e8d510..b7e9989 100644
--- a/docs/dta-details/ipfs.md
+++ b/docs/dta-details/ipfs.md
@@ -3,7 +3,6 @@
 title: IPFS
 sidebar_label: IPFS
 ---
-
 The Milagro D-TA aims to provide an auditable record of all interactions between actors in the system. It is vital that all the actors in the system can refer to an agreed record of these transactions in case of dispute or in response to requests from third parties such as law enforcement, audit or compliance organizations.  The Milagro D-TA creates immutable, secure and attributable records of every interaction that occurs in the lifecycle of entities and their dealings with secrets. We do this using the Inter Planetary File System - [IPFS](https://ipfs.io/).
 
 IPFS is a globally distributed peer-to-peer file system - think GitHub meets BitTorrent. When a file is written (SET) into your local IPFS node a hash of the document is returned, you can then GET the document using that address. If somebody else who is running an IPFS tries to GET the same hash address the file will be pulled from your node to theirs. If the document is changed in way the hash will change. In this way, an immutability and peer-to-peer consensus is achieved.
diff --git a/docs/dta-details/plugin-dev-guide.md b/docs/dta-details/plugin-dev-guide.md
index 83a6f69..98a8d6e 100644
--- a/docs/dta-details/plugin-dev-guide.md
+++ b/docs/dta-details/plugin-dev-guide.md
@@ -15,36 +15,50 @@
 
 To add a new endpoint to the goKit Microservices framework
 
-1. First define the contract in milagro/pkg/milagroservice/proto.go
+1.  First define the contract in milagro/pkg/milagroservice/proto.go
 
 Add structs for http transport
 Add responses to milagro/swagger/swagger.config,yaml
 
-2. Add and endpoint definition
+2.  Add and endpoint definition
 
 milagro/pkg/milagroendpoints/endpoints.go
 
-3. Create a handler factory
+3.  Create a handler factory
 
 **Thise instructions still aren't perfect**
 
-1. Clone the repo and make sure that it works by following the [Quick Start](/docs/dta-details/quickstart) instructions
-2. Copy the plugin template
+1.  Clone the repo and make sure that it works by following the [Quick Start](/docs/dta-details/quickstart) instructions
+2.  Copy the plugin template
+
 ```
+
 cp -r pkg/plugintemplate pkg/encryptastring
+
 ```
-3. Rename the package and service 
-on a mac you could do this...
+
+3.  Rename the package and service 
+    on a mac you could do this...
+
 ```
+
 sed -i "" "s/template/encryptastring/g" pkg/encryptastring/service.go
+
 ```
-4. Now create a plugin regsitration file
+
+4.  Now create a plugin regsitration file
+
 ```
+
 sed -i "" "s/plugintemplate/encryptastring/g" plugins/encryptastring.go
 sed -i "" "s/pluginTemplate/encryptAString/g" plugins/encryptastring.go
+
 ```
+
 5.  Update the Config File
+
 ```
+
 nano ~/.milagro/config.yaml
 
 update....
@@ -52,14 +66,19 @@
 plugins:
   service: encryptastring
 
+
 ```
-6. See your plugin in action!
+
+6.  See your plugin in action!
+
 ```
+
 go build -o target/service github.com/apache/incubator-milagro-dta/cmd/service
 target/service
+
 ```
+
 Point your browser at:
 http://localhost:5555/status
 
 you should see
-
diff --git a/docs/dta-details/quickstart.md b/docs/dta-details/quickstart.md
index e8ef3dd..c7c25d8 100644
--- a/docs/dta-details/quickstart.md
+++ b/docs/dta-details/quickstart.md
@@ -3,13 +3,14 @@
 title: Quick Start
 sidebar_label: Quick Start
 ---
-
 ## Docker
+
 The easiest way to see a D-TA in action is to run it in a Docker container. The default settings will run a single D-TA that acts as Principal, Fiduciary and Beneficiary. The default settings include an embedded IPFS node connected to a private IPFS network and an embedded "Bolt" database. This will get you up and running quickly but is **not for production use!**
 
 Please see the repo's [README](https://github.com/apache/incubator-milagro-dta) for alternative build instructions.
 
 ```
+
 git clone https://github.com/apache/incubator-milagro-dta.git
 
 cd incubator-milagro-dta
@@ -18,21 +19,16 @@
 
 docker run -it -p 5556:5556 milagrodta
 
+
 ```
 
-Now you can test if the D-TA is running by hitting [http://localhost:5556/v1/status](http://localhost:5556/v1/status)
+Now you can test if the D-TA is running by hitting http:
 
 You should see something like...
 
 ```
-{
-"application": "Milagro Distributed Trust",
-"timeStamp": "2019-08-29T11:11:15.9089824Z",
-"apiVersion": "v1",
-"nodeCID": "QmckgCeQRenUk7WHPcD5fxjLxScxyKp5QY1P7GW69NZnR1",
-"extensionVendor": "Milagro",
-"plugin": "milagro"
-}
+
+
 
 ```
 
@@ -45,19 +41,26 @@
 The Safeguard Secret plugin encrypts a string with the public key using [ECIES](https://medium.com/asecuritysite-when-bob-met-alice/generating-an-encryption-key-without-a-pass-phrase-meet-ecies-bbea1787d846) and decrypts it when the Fiduciary's D-TA returns the secret key.
 
 **To Run Safeguard Secret**
+
 ```
-docker run -it -p 5556:5556 milagrodta -service safeguardsecret
+
+
+
 ```
+
 ### Bitcoin Wallet Security
 
 A Bitcoin Wallet uses a public key (derived from a private key) to create a Bitcoin address. To spend funds from that address, the private key is needed. Insufficient security of private keys has let to billions of dollars in theft. The Principal's Bitcoin Wallet Security plugin receives one half of the public key from the Fiduciary to ultimately create the wallet address. To spend the funds, the Fiduciary D-TA returns a secret to the Beneficiary's D-TA. A process adds this secret to one that is resident within the Principal's D-TA to materialize the wallet's private key.
 
 **To Run Bitcoin Wallet Security**
-```
-docker run -it -p 5556:5556 milagrodta -service bitcoinwallet
+
 ```
 
-You can confirm that the plugins have loaded by hitting [http://localhost:5556/v1/status](http://localhost:5556/v1/status)
+
+
+```
+
+You can confirm that the plugins have loaded by hitting 
 
 ## D-TA API
 
@@ -67,22 +70,17 @@
 
 The API has three parts to it:
 
-1. **Identity Endpoints** - that support creation and retrieval of [identity documents](dta-details/identity-documents.md)
-2. **Order Endpoints** 
-    1. Creates orders for new public keys
-    2. Requests for secret keys to be transferred
-    3. Allows orders to be searched and listed
-3. **Fulfillment RPC** - these are the server-to-server remote procedure calls that enable a Principal D-TA to communicate with a Master Fiduciary D-TA
+1.  **Identity Endpoints** - that support creation and retrieval of [identity documents](dta-details/identity-documents.md)
+2.  **Order Endpoints** 
+    1.  Creates orders for new public keys
+    2.  Requests for secret keys to be transferred
+    3.  Allows orders to be searched and listed
+3.  **Fulfillment RPC** - these are the server-to-server remote procedure calls that enable a Principal D-TA to communicate with a Master Fiduciary D-TA
 
 ### Example - To create a new Identity
 
 ```
-curl -X POST "http://localhost:5556/v1/identity" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"name\":\"thisNode\"}"
+
+
+
 ```
-
-
-
-
-
-
-
diff --git a/docs/milagro-crypto.md b/docs/milagro-crypto.md
index 8c5a57c..a961020 100644
--- a/docs/milagro-crypto.md
+++ b/docs/milagro-crypto.md
@@ -1,98 +1,103 @@
----

-id: milagro-crypto

-title: Milagro Crypto

-sidebar_label: Milagro Crypto

----

-

-One of the critical points about information security is to give access to resources only to authorized entities and deny access to unauthorized ones.

-Preventing unauthorized access very often comes down to making it ___almost impossible___, i.e., tough, expensive, complicated, and time-consuming for the unauthorized entities to get access to resources.

-

-The same principles apply to cryptography. In most cases, a suitable encryption mechanism satisfies at least two basic requirements:

-1. It is possible to give easy access to encrypted, cryptographically protected content to authorized entities.

-2. It is possible to make it extremely challenging for unauthorized entities to access encrypted (ditto) content.

-

-Using the above, we can define an operation: Encryption that is tough to reverse without possessing a particular parameter, for example, a decryption key.