<h2>Edit File - php72compat.php</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/home/u548619843/domains/wis.parts/public_html/wp-includes/sodium_compat/lib/php72compat.php">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&lt;?php

require_once dirname(dirname(__FILE__)) . &#039;/autoload.php&#039;;

/**
 * This file will monkey patch the pure-PHP implementation in place of the
 * PECL functions and constants, but only if they do not already exist.
 *
 * Thus, the functions or constants just proxy to the appropriate
 * ParagonIE_Sodium_Compat method or class constant, respectively.
 */
foreach (array(
    &#039;BASE64_VARIANT_ORIGINAL&#039;,
    &#039;BASE64_VARIANT_ORIGINAL_NO_PADDING&#039;,
    &#039;BASE64_VARIANT_URLSAFE&#039;,
    &#039;BASE64_VARIANT_URLSAFE_NO_PADDING&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_ABYTES&#039;,
    &#039;CRYPTO_AEAD_AES256GCM_KEYBYTES&#039;,
    &#039;CRYPTO_AEAD_AES256GCM_NSECBYTES&#039;,
    &#039;CRYPTO_AEAD_AES256GCM_NPUBBYTES&#039;,
    &#039;CRYPTO_AEAD_AES256GCM_ABYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES&#039;,
    &#039;CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES&#039;,
    &#039;CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES&#039;,
    &#039;CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES&#039;,
    &#039;CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES&#039;,
    &#039;CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES&#039;,
    &#039;CRYPTO_AUTH_BYTES&#039;,
    &#039;CRYPTO_AUTH_KEYBYTES&#039;,
    &#039;CRYPTO_BOX_SEALBYTES&#039;,
    &#039;CRYPTO_BOX_SECRETKEYBYTES&#039;,
    &#039;CRYPTO_BOX_PUBLICKEYBYTES&#039;,
    &#039;CRYPTO_BOX_KEYPAIRBYTES&#039;,
    &#039;CRYPTO_BOX_MACBYTES&#039;,
    &#039;CRYPTO_BOX_NONCEBYTES&#039;,
    &#039;CRYPTO_BOX_SEEDBYTES&#039;,
    &#039;CRYPTO_KDF_BYTES_MIN&#039;,
    &#039;CRYPTO_KDF_BYTES_MAX&#039;,
    &#039;CRYPTO_KDF_CONTEXTBYTES&#039;,
    &#039;CRYPTO_KDF_KEYBYTES&#039;,
    &#039;CRYPTO_KX_BYTES&#039;,
    &#039;CRYPTO_KX_KEYPAIRBYTES&#039;,
    &#039;CRYPTO_KX_PRIMITIVE&#039;,
    &#039;CRYPTO_KX_SEEDBYTES&#039;,
    &#039;CRYPTO_KX_PUBLICKEYBYTES&#039;,
    &#039;CRYPTO_KX_SECRETKEYBYTES&#039;,
    &#039;CRYPTO_KX_SESSIONKEYBYTES&#039;,
    &#039;CRYPTO_GENERICHASH_BYTES&#039;,
    &#039;CRYPTO_GENERICHASH_BYTES_MIN&#039;,
    &#039;CRYPTO_GENERICHASH_BYTES_MAX&#039;,
    &#039;CRYPTO_GENERICHASH_KEYBYTES&#039;,
    &#039;CRYPTO_GENERICHASH_KEYBYTES_MIN&#039;,
    &#039;CRYPTO_GENERICHASH_KEYBYTES_MAX&#039;,
    &#039;CRYPTO_PWHASH_SALTBYTES&#039;,
    &#039;CRYPTO_PWHASH_STRPREFIX&#039;,
    &#039;CRYPTO_PWHASH_ALG_ARGON2I13&#039;,
    &#039;CRYPTO_PWHASH_ALG_ARGON2ID13&#039;,
    &#039;CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE&#039;,
    &#039;CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE&#039;,
    &#039;CRYPTO_PWHASH_MEMLIMIT_MODERATE&#039;,
    &#039;CRYPTO_PWHASH_OPSLIMIT_MODERATE&#039;,
    &#039;CRYPTO_PWHASH_MEMLIMIT_SENSITIVE&#039;,
    &#039;CRYPTO_PWHASH_OPSLIMIT_SENSITIVE&#039;,
    &#039;CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES&#039;,
    &#039;CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX&#039;,
    &#039;CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE&#039;,
    &#039;CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE&#039;,
    &#039;CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE&#039;,
    &#039;CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE&#039;,
    &#039;CRYPTO_SCALARMULT_BYTES&#039;,
    &#039;CRYPTO_SCALARMULT_SCALARBYTES&#039;,
    &#039;CRYPTO_SHORTHASH_BYTES&#039;,
    &#039;CRYPTO_SHORTHASH_KEYBYTES&#039;,
    &#039;CRYPTO_SECRETBOX_KEYBYTES&#039;,
    &#039;CRYPTO_SECRETBOX_MACBYTES&#039;,
    &#039;CRYPTO_SECRETBOX_NONCEBYTES&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL&#039;,
    &#039;CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX&#039;,
    &#039;CRYPTO_SIGN_BYTES&#039;,
    &#039;CRYPTO_SIGN_SEEDBYTES&#039;,
    &#039;CRYPTO_SIGN_PUBLICKEYBYTES&#039;,
    &#039;CRYPTO_SIGN_SECRETKEYBYTES&#039;,
    &#039;CRYPTO_SIGN_KEYPAIRBYTES&#039;,
    &#039;CRYPTO_STREAM_KEYBYTES&#039;,
    &#039;CRYPTO_STREAM_NONCEBYTES&#039;,
    &#039;CRYPTO_STREAM_XCHACHA20_KEYBYTES&#039;,
    &#039;CRYPTO_STREAM_XCHACHA20_NONCEBYTES&#039;,
    &#039;LIBRARY_MAJOR_VERSION&#039;,
    &#039;LIBRARY_MINOR_VERSION&#039;,
    &#039;LIBRARY_VERSION_MAJOR&#039;,
    &#039;LIBRARY_VERSION_MINOR&#039;,
    &#039;VERSION_STRING&#039;
    ) as $constant
) {
    if (!defined(&quot;SODIUM_$constant&quot;) &amp;&amp; defined(&quot;ParagonIE_Sodium_Compat::$constant&quot;)) {
        define(&quot;SODIUM_$constant&quot;, constant(&quot;ParagonIE_Sodium_Compat::$constant&quot;));
    }
}
if (!is_callable(&#039;sodium_add&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::add()
     * @param string $string1
     * @param string $string2
     * @return void
     * @throws SodiumException
     */
    function sodium_add(&amp;$string1, $string2)
    {
        ParagonIE_Sodium_Compat::add($string1, $string2);
    }
}
if (!is_callable(&#039;sodium_base642bin&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::bin2base64()
     * @param string $string
     * @param int $variant
     * @param string $ignore
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_base642bin($string, $variant, $ignore =&#039;&#039;)
    {
        return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
    }
}
if (!is_callable(&#039;sodium_bin2base64&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::bin2base64()
     * @param string $string
     * @param int $variant
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_bin2base64($string, $variant)
    {
        return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
    }
}
if (!is_callable(&#039;sodium_bin2hex&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::hex2bin()
     * @param string $string
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_bin2hex($string)
    {
        return ParagonIE_Sodium_Compat::bin2hex($string);
    }
}
if (!is_callable(&#039;sodium_compare&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::compare()
     * @param string $string1
     * @param string $string2
     * @return int
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_compare($string1, $string2)
    {
        return ParagonIE_Sodium_Compat::compare($string1, $string2);
    }
}
if (!is_callable(&#039;sodium_crypto_aead_aes256gcm_decrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
     * @param string $ciphertext
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string|bool
     */
    function sodium_crypto_aead_aes256gcm_decrypt($ciphertext, $additional_data, $nonce, $key)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt(
                $ciphertext,
                $additional_data,
                $nonce,
                $key
            );
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            if (($ex instanceof SodiumException) &amp;&amp; ($ex-&gt;getMessage() === &#039;AES-256-GCM is not available&#039;)) {
                throw $ex;
            }
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_aead_aes256gcm_encrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
     * @param string $message
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $additional_data, $nonce, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_aead_aes256gcm_is_available&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
     * @return bool
     */
    function sodium_crypto_aead_aes256gcm_is_available()
    {
        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
    }
}
if (!is_callable(&#039;sodium_crypto_aead_chacha20poly1305_decrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
     * @param string $ciphertext
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string|bool
     */
    function sodium_crypto_aead_chacha20poly1305_decrypt($ciphertext, $additional_data, $nonce, $key)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt(
                $ciphertext,
                $additional_data,
                $nonce,
                $key
            );
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_aead_chacha20poly1305_encrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
     * @param string $message
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_aead_chacha20poly1305_encrypt($message, $additional_data, $nonce, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt(
            $message,
            $additional_data,
            $nonce,
            $key
        );
    }
}
if (!is_callable(&#039;sodium_crypto_aead_chacha20poly1305_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_aead_chacha20poly1305_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_aead_chacha20poly1305_ietf_decrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
     * @param string $message
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string|bool
     */
    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $additional_data, $nonce, $key)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt(
                $message,
                $additional_data,
                $nonce,
                $key
            );
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_aead_chacha20poly1305_ietf_encrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
     * @param string $message
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $additional_data, $nonce, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt(
            $message,
            $additional_data,
            $nonce,
            $key
        );
    }
}
if (!is_callable(&#039;sodium_crypto_aead_chacha20poly1305_ietf_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_aead_xchacha20poly1305_ietf_decrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
     * @param string $ciphertext
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string|bool
     */
    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($ciphertext, $additional_data, $nonce, $key)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt(
                $ciphertext,
                $additional_data,
                $nonce,
                $key,
                true
            );
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_aead_xchacha20poly1305_ietf_encrypt&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
     * @param string $message
     * @param string $additional_data
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
        $message,
        $additional_data,
        $nonce,
        $key
    ) {
        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt(
            $message,
            $additional_data,
            $nonce,
            $key,
            true
        );
    }
}
if (!is_callable(&#039;sodium_crypto_aead_xchacha20poly1305_ietf_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_auth&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_auth()
     * @param string $message
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_auth($message, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_auth_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_auth_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_auth_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_auth_verify&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
     * @param string $mac
     * @param string $message
     * @param string $key
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_auth_verify($mac, $message, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_box&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box()
     * @param string $message
     * @param string $nonce
     * @param string $key_pair
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box($message, $nonce, $key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_box_keypair&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_keypair()
    {
        return ParagonIE_Sodium_Compat::crypto_box_keypair();
    }
}
if (!is_callable(&#039;sodium_crypto_box_keypair_from_secretkey_and_publickey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
     * @param string $secret_key
     * @param string $public_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key)
    {
        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($secret_key, $public_key);
    }
}
if (!is_callable(&#039;sodium_crypto_box_open&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_open()
     * @param string $ciphertext
     * @param string $nonce
     * @param string $key_pair
     * @return string|bool
     */
    function sodium_crypto_box_open($ciphertext, $nonce, $key_pair)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_box_open($ciphertext, $nonce, $key_pair);
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_box_publickey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
     * @param string $key_pair
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_publickey($key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_box_publickey($key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_box_publickey_from_secretkey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
     * @param string $secret_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_publickey_from_secretkey($secret_key)
    {
        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($secret_key);
    }
}
if (!is_callable(&#039;sodium_crypto_box_seal&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_seal()
     * @param string $message
     * @param string $public_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_seal($message, $public_key)
    {
        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $public_key);
    }
}
if (!is_callable(&#039;sodium_crypto_box_seal_open&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
     * @param string $message
     * @param string $key_pair
     * @return string|bool
     * @throws SodiumException
     */
    function sodium_crypto_box_seal_open($message, $key_pair)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $key_pair);
        } catch (SodiumException $ex) {
            if ($ex-&gt;getMessage() === &#039;Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.&#039;) {
                throw $ex;
            }
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_box_secretkey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
     * @param string $key_pair
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_secretkey($key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_box_secretkey($key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_box_seed_keypair&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
     * @param string $seed
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_box_seed_keypair($seed)
    {
        return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
    }
}
if (!is_callable(&#039;sodium_crypto_generichash&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_generichash()
     * @param string $message
     * @param string|null $key
     * @param int $length
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_generichash($message, $key = null, $length = 32)
    {
        return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $length);
    }
}
if (!is_callable(&#039;sodium_crypto_generichash_final&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
     * @param string|null $state
     * @param int $outputLength
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_generichash_final(&amp;$state, $outputLength = 32)
    {
        return ParagonIE_Sodium_Compat::crypto_generichash_final($state, $outputLength);
    }
}
if (!is_callable(&#039;sodium_crypto_generichash_init&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
     * @param string|null $key
     * @param int $length
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_generichash_init($key = null, $length = 32)
    {
        return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $length);
    }
}
if (!is_callable(&#039;sodium_crypto_generichash_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_generichash_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_generichash_update&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
     * @param string|null $state
     * @param string $message
     * @return void
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_generichash_update(&amp;$state, $message = &#039;&#039;)
    {
        ParagonIE_Sodium_Compat::crypto_generichash_update($state, $message);
    }
}
if (!is_callable(&#039;sodium_crypto_kdf_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_kdf_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_kdf_derive_from_key&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
     * @param int $subkey_length
     * @param int $subkey_id
     * @param string $context
     * @param string $key
     * @return string
     * @throws Exception
     */
    function sodium_crypto_kdf_derive_from_key($subkey_length, $subkey_id, $context, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
            $subkey_length,
            $subkey_id,
            $context,
            $key
        );
    }
}
if (!is_callable(&#039;sodium_crypto_kx&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_kx()
     * @param string $my_secret
     * @param string $their_public
     * @param string $client_public
     * @param string $server_public
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
    {
        return ParagonIE_Sodium_Compat::crypto_kx(
            $my_secret,
            $their_public,
            $client_public,
            $server_public
        );
    }
}
if (!is_callable(&#039;sodium_crypto_kx_seed_keypair&#039;)) {
    /**
     * @param string $seed
     * @return string
     * @throws Exception
     */
    function sodium_crypto_kx_seed_keypair($seed)
    {
        return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
    }
}
if (!is_callable(&#039;sodium_crypto_kx_keypair&#039;)) {
    /**
     * @return string
     * @throws Exception
     */
    function sodium_crypto_kx_keypair()
    {
        return ParagonIE_Sodium_Compat::crypto_kx_keypair();
    }
}
if (!is_callable(&#039;sodium_crypto_kx_client_session_keys&#039;)) {
    /**
     * @param string $client_key_pair
     * @param string $server_key
     * @return array{0: string, 1: string}
     * @throws SodiumException
     */
    function sodium_crypto_kx_client_session_keys($client_key_pair, $server_key)
    {
        return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($client_key_pair, $server_key);
    }
}
if (!is_callable(&#039;sodium_crypto_kx_server_session_keys&#039;)) {
    /**
     * @param string $server_key_pair
     * @param string $client_key
     * @return array{0: string, 1: string}
     * @throws SodiumException
     */
    function sodium_crypto_kx_server_session_keys($server_key_pair, $client_key)
    {
        return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($server_key_pair, $client_key);
    }
}
if (!is_callable(&#039;sodium_crypto_kx_secretkey&#039;)) {
    /**
     * @param string $key_pair
     * @return string
     * @throws Exception
     */
    function sodium_crypto_kx_secretkey($key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_kx_secretkey($key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_kx_publickey&#039;)) {
    /**
     * @param string $key_pair
     * @return string
     * @throws Exception
     */
    function sodium_crypto_kx_publickey($key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_kx_publickey($key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash()
     * @param int $length
     * @param string $passwd
     * @param string $salt
     * @param int $opslimit
     * @param int $memlimit
     * @param int|null $algo
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo = null)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash($length, $passwd, $salt, $opslimit, $memlimit, $algo);
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash_str&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
     * @param string $passwd
     * @param int $opslimit
     * @param int $memlimit
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash_str_needs_rehash&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash()
     * @param string $hash
     * @param int $opslimit
     * @param int $memlimit
     * @return bool
     *
     * @throws SodiumException
     */
    function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash_str_verify&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
     * @param string $passwd
     * @param string $hash
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_pwhash_str_verify($passwd, $hash)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash_scryptsalsa208sha256&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
     * @param int $length
     * @param string $passwd
     * @param string $salt
     * @param int $opslimit
     * @param int $memlimit
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_pwhash_scryptsalsa208sha256($length, $passwd, $salt, $opslimit, $memlimit)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256(
            $length,
            $passwd,
            $salt,
            $opslimit,
            $memlimit
        );
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash_scryptsalsa208sha256_str&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
     * @param string $passwd
     * @param int $opslimit
     * @param int $memlimit
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
    }
}
if (!is_callable(&#039;sodium_crypto_pwhash_scryptsalsa208sha256_str_verify&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
     * @param string $passwd
     * @param string $hash
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
    {
        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
    }
}
if (!is_callable(&#039;sodium_crypto_scalarmult&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
     * @param string $n
     * @param string $p
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_scalarmult($n, $p)
    {
        return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
    }
}
if (!is_callable(&#039;sodium_crypto_scalarmult_base&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
     * @param string $n
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_scalarmult_base($n)
    {
        return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
    }
}
if (!is_callable(&#039;sodium_crypto_secretbox&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_secretbox()
     * @param string $message
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_secretbox($message, $nonce, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_secretbox_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_secretbox_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_secretbox_open&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
     * @param string $ciphertext
     * @param string $nonce
     * @param string $key
     * @return string|bool
     */
    function sodium_crypto_secretbox_open($ciphertext, $nonce, $key)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_secretbox_open($ciphertext, $nonce, $key);
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_secretstream_xchacha20poly1305_init_push&#039;)) {
    /**
     * @param string $key
     * @return array&lt;int, string&gt;
     * @throws SodiumException
     */
    function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
    {
        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
    }
}
if (!is_callable(&#039;sodium_crypto_secretstream_xchacha20poly1305_push&#039;)) {
    /**
     * @param string $state
     * @param string $message
     * @param string $additional_data
     * @param int $tag
     * @return string
     * @throws SodiumException
     */
    function sodium_crypto_secretstream_xchacha20poly1305_push(
        &amp;$state,
        $message,
        $additional_data = &#039;&#039;,
        $tag = 0
    ) {
        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push(
            $state,
            $message,
            $additional_data,
            $tag
        );
    }
}
if (!is_callable(&#039;sodium_crypto_secretstream_xchacha20poly1305_init_pull&#039;)) {
    /**
     * @param string $header
     * @param string $key
     * @return string
     * @throws Exception
     */
    function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_secretstream_xchacha20poly1305_pull&#039;)) {
    /**
     * @param string $state
     * @param string $ciphertext
     * @param string $additional_data
     * @return bool|array{0: string, 1: int}
     * @throws SodiumException
     */
    function sodium_crypto_secretstream_xchacha20poly1305_pull(&amp;$state, $ciphertext, $additional_data = &#039;&#039;)
    {
        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull(
            $state,
            $ciphertext,
            $additional_data
        );
    }
}
if (!is_callable(&#039;sodium_crypto_secretstream_xchacha20poly1305_rekey&#039;)) {
    /**
     * @param string $state
     * @return void
     * @throws SodiumException
     */
    function sodium_crypto_secretstream_xchacha20poly1305_rekey(&amp;$state)
    {
        ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
    }
}
if (!is_callable(&#039;sodium_crypto_secretstream_xchacha20poly1305_keygen&#039;)) {
    /**
     * @return string
     * @throws Exception
     */
    function sodium_crypto_secretstream_xchacha20poly1305_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_shorthash&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_shorthash()
     * @param string $message
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_shorthash($message, $key = &#039;&#039;)
    {
        return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_shorthash_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_shorthash_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_sign&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign()
     * @param string $message
     * @param string $secret_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign($message, $secret_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign($message, $secret_key);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_detached&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
     * @param string $message
     * @param string $secret_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_detached($message, $secret_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $secret_key);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_keypair_from_secretkey_and_publickey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
     * @param string $secret_key
     * @param string $public_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($secret_key, $public_key);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_keypair&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_keypair()
    {
        return ParagonIE_Sodium_Compat::crypto_sign_keypair();
    }
}
if (!is_callable(&#039;sodium_crypto_sign_open&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_open()
     * @param string $signedMessage
     * @param string $public_key
     * @return string|bool
     */
    function sodium_crypto_sign_open($signedMessage, $public_key)
    {
        try {
            return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $public_key);
        } catch (Error $ex) {
            return false;
        } catch (Exception $ex) {
            return false;
        }
    }
}
if (!is_callable(&#039;sodium_crypto_sign_publickey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
     * @param string $key_pair
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_publickey($key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_publickey($key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_publickey_from_secretkey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
     * @param string $secret_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_publickey_from_secretkey($secret_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($secret_key);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_secretkey&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
     * @param string $key_pair
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_secretkey($key_pair)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_secretkey($key_pair);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_seed_keypair&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
     * @param string $seed
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_seed_keypair($seed)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_verify_detached&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
     * @param string $signature
     * @param string $message
     * @param string $public_key
     * @return bool
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_verify_detached($signature, $message, $public_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $public_key);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_ed25519_pk_to_curve25519&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
     * @param string $public_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_ed25519_pk_to_curve25519($public_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($public_key);
    }
}
if (!is_callable(&#039;sodium_crypto_sign_ed25519_sk_to_curve25519&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
     * @param string $secret_key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_sign_ed25519_sk_to_curve25519($secret_key)
    {
        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($secret_key);
    }
}
if (!is_callable(&#039;sodium_crypto_stream&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_stream()
     * @param int $length
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_stream($length, $nonce, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_stream($length, $nonce, $key);
    }
}
if (!is_callable(&#039;sodium_crypto_stream_keygen&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
     * @return string
     * @throws Exception
     */
    function sodium_crypto_stream_keygen()
    {
        return ParagonIE_Sodium_Compat::crypto_stream_keygen();
    }
}
if (!is_callable(&#039;sodium_crypto_stream_xor&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
     * @param string $message
     * @param string $nonce
     * @param string $key
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_crypto_stream_xor($message, $nonce, $key)
    {
        return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
    }
}
require_once dirname(__FILE__) . &#039;/stream-xchacha20.php&#039;;
if (!is_callable(&#039;sodium_hex2bin&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::hex2bin()
     * @param string $string
     * @param string $ignore
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_hex2bin($string, $ignore = &#039;&#039;)
    {
        return ParagonIE_Sodium_Compat::hex2bin($string, $ignore);
    }
}
if (!is_callable(&#039;sodium_increment&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::increment()
     * @param string $string
     * @return void
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_increment(&amp;$string)
    {
        ParagonIE_Sodium_Compat::increment($string);
    }
}
if (!is_callable(&#039;sodium_library_version_major&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::library_version_major()
     * @return int
     */
    function sodium_library_version_major()
    {
        return ParagonIE_Sodium_Compat::library_version_major();
    }
}
if (!is_callable(&#039;sodium_library_version_minor&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::library_version_minor()
     * @return int
     */
    function sodium_library_version_minor()
    {
        return ParagonIE_Sodium_Compat::library_version_minor();
    }
}
if (!is_callable(&#039;sodium_version_string&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::version_string()
     * @return string
     */
    function sodium_version_string()
    {
        return ParagonIE_Sodium_Compat::version_string();
    }
}
if (!is_callable(&#039;sodium_memcmp&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::memcmp()
     * @param string $string1
     * @param string $string2
     * @return int
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_memcmp($string1, $string2)
    {
        return ParagonIE_Sodium_Compat::memcmp($string1, $string2);
    }
}
if (!is_callable(&#039;sodium_memzero&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::memzero()
     * @param string $string
     * @return void
     * @throws SodiumException
     * @throws TypeError
     *
     * @psalm-suppress ReferenceConstraintViolation
     */
    function sodium_memzero(&amp;$string)
    {
        ParagonIE_Sodium_Compat::memzero($string);
    }
}
if (!is_callable(&#039;sodium_pad&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::pad()
     * @param string $unpadded
     * @param int $block_size
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_pad($unpadded, $block_size)
    {
        return ParagonIE_Sodium_Compat::pad($unpadded, $block_size, true);
    }
}
if (!is_callable(&#039;sodium_unpad&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::pad()
     * @param string $padded
     * @param int $block_size
     * @return string
     * @throws SodiumException
     * @throws TypeError
     */
    function sodium_unpad($padded, $block_size)
    {
        return ParagonIE_Sodium_Compat::unpad($padded, $block_size, true);
    }
}
if (!is_callable(&#039;sodium_randombytes_buf&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::randombytes_buf()
     * @param int $amount
     * @return string
     * @throws Exception
     */
    function sodium_randombytes_buf($amount)
    {
        return ParagonIE_Sodium_Compat::randombytes_buf($amount);
    }
}

if (!is_callable(&#039;sodium_randombytes_uniform&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::randombytes_uniform()
     * @param int $upperLimit
     * @return int
     * @throws Exception
     */
    function sodium_randombytes_uniform($upperLimit)
    {
        return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
    }
}

if (!is_callable(&#039;sodium_randombytes_random16&#039;)) {
    /**
     * @see ParagonIE_Sodium_Compat::randombytes_random16()
     * @return int
     * @throws Exception
     */
    function sodium_randombytes_random16()
    {
        return ParagonIE_Sodium_Compat::randombytes_random16();
    }
}
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>