Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• library ECDSA
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(
•    - function recover(
•    - function tryRecover(
•    - function recover(
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
• interface IToken
•    - function mint(address,uint256)
•    - function burn(uint256)
•  contract Bridge is Context *
•    - function isHalted()
•    - function redeem(address to, address t ...
•    - function unwrap(address token, uint25 ...
•    - function timeChallenge(string memory ...
•    - function setTokenInfo(address token, ...
•    - function halt(bytes memory signature)
•    - function unhalt()
•    - function revokeRedeems(uint256[] memo ...
•    - function setAdministrator(address new ...
•    - function setTss(address newTss, bytes ...
•    - function emergency()
•    - function nominateGuardians(address[] ...
•    - function proposeAdministrator(address ...
•    - function setAdministratorDelay(uint25 ...
•    - function setSoftDelay(uint256 delay)
•    - function setUnhaltDuration(uint256 du ...
•    - function setEstimatedBlockTime(uint64 ...
•    - function setAllowKeyGen(bool value)
•    - function setConfirmationsToFinality(u ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-05-10
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


struct TokenInfo {
    uint256 minAmount;
    uint256 redeemDelay;
    bool bridgeable;
    bool redeemable;
    bool owned; // whether or not the bridge has mint rights on the token
}

struct RedeemInfo {
    uint256 blockNumber;
    bytes32 paramsHash;
}

// When calling mint / burn, we assume that the token is a representation of a wrapped asset and is deployed and / or audited by the admin
interface IToken {
    function mint(address,uint256) external;
    function burn(uint256) external;
}

contract Bridge is Context {
    using ECDSA for bytes32;
    using SafeERC20 for IERC20;

    event RegisteredRedeem(uint256 indexed nonce, address indexed to, address indexed token, uint256 amount);
    event Redeemed(uint256 indexed nonce, address indexed to, address indexed token, uint256 amount);
    event Unwrapped(address indexed from, address indexed token, string to, uint256 amount);
    event Halted();
    event Unhalted();
    event PendingTokenInfo(address indexed token);
    event SetTokenInfo(address indexed token);
    event RevokedRedeem(uint256 indexed nonce);
    event PendingAdministrator(address indexed newAdministrator);
    event SetAdministrator(address indexed newAdministrator, address oldAdministrator);
    event PendingTss(address indexed newTss);
    event SetTss(address indexed newTss, address oldTss);
    event PendingGuardians();
    event SetGuardians();
    event SetAdministratorDelay(uint256);
    event SetSoftDelay(uint256);
    event SetUnhaltDuration(uint256);
    event SetEstimatedBlockTime(uint64);
    event SetAllowKeyGen(bool);
    event SetConfirmationsToFinality(uint64);

    uint256 private constant uint256max = type(uint256).max;
    uint32 private constant networkClass = 2;
    uint8 private constant  minNominatedGuardians = 5;

    uint64 public estimatedBlockTime;
    uint64 public confirmationsToFinality;
    bool public halted;
    bool public allowKeyGen;

    address public administrator;
    // Should be set greater than 72h
    uint256 public administratorDelay;
    uint256 public immutable minAdministratorDelay;

    address public tss;
    // Should be set greater than 72h
    uint256 public softDelay;
    uint256 public immutable minSoftDelay;

    address[] public guardians;
    address[] public guardiansVotes;
    mapping(address => uint) public votesCount;
    // same delay as set administrator

    uint256 public unhaltedAt;
    uint256 public unhaltDuration;
    uint256 public immutable minUnhaltDuration;
    uint256 public actionsNonce;
    uint256 public immutable contractDeploymentHeight;

    mapping(uint256 => RedeemInfo) public redeemsInfo;
    mapping(address => TokenInfo) public tokensInfo;
    mapping(string => RedeemInfo) public timeChallengesInfo;

    modifier isNotHalted() {
        require(!isHalted(), "bridge: Is halted");
        _;
    }

    modifier onlyAdministrator() {
        require(_msgSender() == administrator, "bridge: Caller not administrator");
        _;
    }

    constructor(uint256 unhaltDurationParam, uint256 administratorDelayParam, uint256 softDelayParam, uint64 blockTime, uint64 confirmations, address[] memory initialGuardians) {
        require(blockTime > 0, "BlockTime is less than minimum");
        require(confirmations > 1, "Confirmations is less than minimum");

        administrator = _msgSender();
        emit SetAdministrator(administrator, address(0));

        minUnhaltDuration = unhaltDurationParam;
        unhaltDuration = unhaltDurationParam;

        minAdministratorDelay = administratorDelayParam;
        administratorDelay = administratorDelayParam;

        minSoftDelay = softDelayParam;
        softDelay = softDelayParam;

        for(uint i = 0; i < initialGuardians.length; i++) {
            for(uint j = i + 1; j < initialGuardians.length; j++) {
                if(initialGuardians[i] == initialGuardians[j]) {
                    revert("Found duplicated guardian");
                }
            }
            guardians.push(initialGuardians[i]);
            guardiansVotes.push(address(0));
        }

        estimatedBlockTime = blockTime;
        confirmationsToFinality = confirmations;
        contractDeploymentHeight = block.number;
    }

    function isHalted() public view returns (bool) {
        return halted || (unhaltedAt + unhaltDuration >= block.number);
    }

    // implement restrictions for amount
    function redeem(address to, address token, uint256 amount, uint256 nonce, bytes memory signature) external isNotHalted {
        // We use local variables for gas optimisation and also we don't use the redeemInfo variable anymore after updating the mapping entry
        RedeemInfo memory redeemInfo = redeemsInfo[nonce];
        TokenInfo memory tokenInfo = tokensInfo[token];
        require(tokenInfo.redeemable, "redeem: Token not redeemable");
        require(redeemInfo.blockNumber != uint256max, "redeem: Nonce already redeemed");
        require((redeemInfo.blockNumber + tokenInfo.redeemDelay) < block.number, "redeem: Not redeemable yet");

        if (redeemInfo.blockNumber == 0) {
            // We only check the signature at the first redeem, on the second one we have only a check for the same parameters
            // In case the tss key is changed, we don't need to resign the transaction for the second redeem
            bytes32 messageHash = keccak256(abi.encode(networkClass, block.chainid, address(this), nonce, to, token, amount));
            messageHash = messageHash.toEthSignedMessageHash();
            address signer = messageHash.recover(signature);
            require(signer == tss, "redeem: Wrong signature");

            redeemsInfo[nonce].blockNumber = block.number;
            redeemsInfo[nonce].paramsHash = keccak256(abi.encode(to, token, amount));
            emit RegisteredRedeem(nonce, to, token, amount);
        } else {
            require(redeemsInfo[nonce].paramsHash == keccak256(abi.encode(to, token, amount)), "redeem: Second redeem has different params than the first one");

            // it cannot be uint256max or in delay
            redeemsInfo[nonce].blockNumber = uint256max;
            // if the bridge has ownership of the token then it means that this token is wrapped and it should have mint rights on it
            if (tokenInfo.owned) {
                // bridge should have 0 balance of this wrapped token unless someone sent to this contract
                // mint the needed amount
                IToken(token).mint(to, amount);
            } else {
                // if we do not own the token it means it is probably originating from this network so we should have locked tokens here
                IERC20(token).safeTransfer(to, amount);
            }
            emit Redeemed(nonce, to, token, amount);
        }
    }

    function unwrap(address token, uint256 amount, string memory to) external isNotHalted {
        require(tokensInfo[token].bridgeable, "unwrap: Token not bridgeable");
        require(amount >= tokensInfo[token].minAmount, "unwrap: Amount has to be greater then the token minAmount");

        uint256 oldBalance = IERC20(token).balanceOf(address(this));
        IERC20(token).safeTransferFrom(_msgSender(), address(this), amount);
        uint256 newBalance = IERC20(token).balanceOf(address(this));
        require(amount <= newBalance, "unwrap: Amount bigger than the new balance");
        require(newBalance - amount == oldBalance, "unwrap: Tokens not sent");

        // if we have ownership to this token, we will burn because we can mint on redeem, otherwise we just keep the tokens
        if (tokensInfo[token].owned) {
            IToken(token).burn(amount);
        }
        emit Unwrapped(_msgSender(), token, to, amount);
    }

    function timeChallenge(string memory methodName, bytes32 paramsHash, uint256 challengeDelay) internal {
        if (timeChallengesInfo[methodName].paramsHash == paramsHash) {
            if (timeChallengesInfo[methodName].blockNumber + challengeDelay >= block.number) {
                revert("challenge not due");
            }
            // otherwise the challenge is due and we reset it
            delete timeChallengesInfo[methodName].paramsHash;
        } else {
            // we start a new challenge
            timeChallengesInfo[methodName].paramsHash = paramsHash;
            timeChallengesInfo[methodName].blockNumber = block.number;
        }
    }

    function setTokenInfo(address token, uint256 minAmount, uint256 redeemDelay, bool bridgeable, bool redeemable, bool isOwned) external onlyAdministrator {
        require(redeemDelay > 2, "setTokenInfo: RedeemDelay is less than minimum");

        bytes32 paramsHash = keccak256(abi.encode(token, minAmount, redeemDelay, bridgeable, redeemable, isOwned));
        timeChallenge("setTokenInfo", paramsHash, softDelay);
        // early return for when we have a new challenge
        if (timeChallengesInfo["setTokenInfo"].paramsHash != bytes32(0)) {
            emit PendingTokenInfo(token);
            return;
        }

        tokensInfo[token].minAmount = minAmount;
        tokensInfo[token].redeemDelay = redeemDelay;
        tokensInfo[token].bridgeable = bridgeable;
        tokensInfo[token].redeemable = redeemable;
        tokensInfo[token].owned = isOwned;
        emit SetTokenInfo(token);
    }

    function halt(bytes memory signature) external {
        if (_msgSender() != administrator) {
            bytes32 messageHash = keccak256(abi.encode("halt", networkClass, block.chainid, address(this), actionsNonce));
            messageHash = messageHash.toEthSignedMessageHash();
            address signer = messageHash.recover(signature);
            require(signer == tss, "halt: Wrong signature");
            actionsNonce += 1;
        }

        halted = true;
        emit Halted();
    }

    function unhalt() external onlyAdministrator {
        require(halted, "unhalt: halted is false");

        halted = false;
        unhaltedAt = block.number;
        emit Unhalted();
    }

    // This method would be called if we detect a redeem transaction that did not originated from a user embedded bridge call on the znn network
    function revokeRedeems(uint256[] memory nonces) external onlyAdministrator {
        for(uint i = 0; i < nonces.length; i++) {
            redeemsInfo[nonces[i]].blockNumber = uint256max;
            emit RevokedRedeem(nonces[i]);
        }
    }

    function setAdministrator(address newAdministrator) external onlyAdministrator {
        require(newAdministrator != address(0), "setAdministrator: Invalid administrator address");

        bytes32 paramsHash = keccak256(abi.encode(newAdministrator));
        timeChallenge("setAdministrator", paramsHash, administratorDelay);
        // early return for when we have a new challenge
        if (timeChallengesInfo["setAdministrator"].paramsHash != bytes32(0)) {
            emit PendingAdministrator(newAdministrator);
            return;
        }

        emit SetAdministrator(newAdministrator, administrator);
        administrator = newAdministrator;
    }

    function setTss(address newTss, bytes memory oldSignature, bytes memory newSignature) external  {
        require(newTss != address(0), "setTss: Invalid newTss");

        if (_msgSender() != administrator) {
            // this only applies for non administrator calls
            require(allowKeyGen, "setTss: KeyGen is not allowed");
            require(!isHalted(), "setTss: Bridge halted");
            allowKeyGen = false;

            bytes32 messageHash = keccak256(abi.encode("setTss", networkClass, block.chainid, address(this), actionsNonce, newTss));
            messageHash = messageHash.toEthSignedMessageHash();
            address signer = messageHash.recover(oldSignature);
            require(signer == tss, "setTss: Wrong old signature");

            signer = messageHash.recover(newSignature);
            require(signer == newTss, "setTss: Wrong new signature");

            actionsNonce += 1;
        } else {
            bytes32 paramsHash = keccak256(abi.encode(newTss));
            timeChallenge("setTss", paramsHash, softDelay);
            // early return for when we have a new challenge
            if (timeChallengesInfo["setTss"].paramsHash != bytes32(0)) {
                emit PendingTss(newTss);
                return;
            }
        }

        emit SetTss(newTss, tss);
        tss = newTss;
    }

    function emergency() external onlyAdministrator {
        emit SetAdministrator(address(0), administrator);
        administrator = address(0);

        emit SetTss(address(0), tss);
        tss = address(0);

        halted = true;
        emit Halted();
    }

    function nominateGuardians(address[] memory newGuardians) external onlyAdministrator {
        require(newGuardians.length >= minNominatedGuardians, "nominateGuardians: Length less than minimum");
        require(newGuardians.length < 30, "nominateGuardians: Length bigger than maximum");

        bytes32 paramsHash = keccak256(abi.encode(newGuardians));
        timeChallenge("nominateGuardians", paramsHash, administratorDelay);
        // early return for when we have a new challenge
        if (timeChallengesInfo["nominateGuardians"].paramsHash != bytes32(0)) {
            // we check for duplicates only on new challenges
            for (uint i = 0; i < newGuardians.length; i++) {
                if(newGuardians[i] == address(0)) {
                    revert("nominateGuardians: Found zero address");
                }
                for(uint j = i + 1; j < newGuardians.length; j++) {
                    if(newGuardians[i] == newGuardians[j]) {
                        revert("nominateGuardians: Found duplicated guardian");
                    }
                }
            }
            emit PendingGuardians();
            return;
        }

        for (uint i = 0; i < guardians.length; i++) {
            delete votesCount[guardiansVotes[i]];
        }
        delete guardiansVotes;
        delete guardians;
        for (uint i = 0; i < newGuardians.length; i++) {
            guardians.push(newGuardians[i]);
            guardiansVotes.push(address(0));
        }
        emit SetGuardians();
    }

    function proposeAdministrator(address newAdministrator) external {
        require(administrator == address(0), "proposeAdministrator: Bridge not in emergency");
        require(newAdministrator != address(0), "proposeAdministrator: Invalid new address");

        for(uint i = 0; i < guardians.length; i++) {
            if (guardians[i] == _msgSender()) {
                if (guardiansVotes[i] != address(0)) {
                    votesCount[guardiansVotes[i]] -= 1;
                }
                guardiansVotes[i] = newAdministrator;
                votesCount[newAdministrator] += 1;
                uint threshold = guardians.length / 2;
                if (votesCount[newAdministrator] > threshold) {
                    for(uint j = 0; j < guardiansVotes.length; j++) {
                        delete votesCount[guardiansVotes[j]];
                        guardiansVotes[j] = address(0);
                    }
                    administrator = newAdministrator;
                    emit SetAdministrator(newAdministrator, address(0));
                }
                break;
            }
        }
    }

    function setAdministratorDelay(uint256 delay) external onlyAdministrator {
        require(delay >= minAdministratorDelay, "setAdministratorDelay: Delay is less than minimum");
        administratorDelay = delay;
        emit SetAdministratorDelay(delay);
    }

    function setSoftDelay(uint256 delay) external onlyAdministrator {
        require(delay >= minSoftDelay, "setSoftDelay: Delay is less than minimum");
        softDelay = delay;
        emit SetSoftDelay(delay);
    }

    function setUnhaltDuration(uint256 duration) external onlyAdministrator {
        require(duration >= minUnhaltDuration, "setUnhaltDuration: Duration is less than minimum");
        unhaltDuration = duration;
        emit SetUnhaltDuration(duration);
    }

    function setEstimatedBlockTime(uint64 blockTime) external onlyAdministrator {
        require(blockTime > 0, "setEstimatedBlockTime: BlockTime is less than minimum");
        estimatedBlockTime = blockTime;
        emit SetEstimatedBlockTime(blockTime);
    }

    function setAllowKeyGen(bool value) external onlyAdministrator {
        allowKeyGen = value;
        emit SetAllowKeyGen(value);
    }

    function setConfirmationsToFinality(uint64 confirmations) external onlyAdministrator {
        require(confirmations > 1, "setConfirmationsToFinality: Confirmations is less than minimum");
        confirmationsToFinality = confirmations;
        emit SetConfirmationsToFinality(confirmations);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"unhaltDurationParam","type":"uint256"},{"internalType":"uint256","name":"administratorDelayParam","type":"uint256"},{"internalType":"uint256","name":"softDelayParam","type":"uint256"},{"internalType":"uint64","name":"blockTime","type":"uint64"},{"internalType":"uint64","name":"confirmations","type":"uint64"},{"internalType":"address[]","name":"initialGuardians","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[],"name":"Halted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAdministrator","type":"address"}],"name":"PendingAdministrator","type":"event"},{"anonymous":false,"inputs":[],"name":"PendingGuardians","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"PendingTokenInfo","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newTss","type":"address"}],"name":"PendingTss","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Redeemed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RegisteredRedeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"RevokedRedeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAdministrator","type":"address"},{"indexed":false,"internalType":"address","name":"oldAdministrator","type":"address"}],"name":"SetAdministrator","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"SetAdministratorDelay","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"","type":"bool"}],"name":"SetAllowKeyGen","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"","type":"uint64"}],"name":"SetConfirmationsToFinality","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"","type":"uint64"}],"name":"SetEstimatedBlockTime","type":"event"},{"anonymous":false,"inputs":[],"name":"SetGuardians","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"SetSoftDelay","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"SetTokenInfo","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newTss","type":"address"},{"indexed":false,"internalType":"address","name":"oldTss","type":"address"}],"name":"SetTss","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"SetUnhaltDuration","type":"event"},{"anonymous":false,"inputs":[],"name":"Unhalted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"string","name":"to","type":"string"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unwrapped","type":"event"},{"inputs":[],"name":"actionsNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"administrator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"administratorDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowKeyGen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"confirmationsToFinality","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractDeploymentHeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergency","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"estimatedBlockTime","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"guardians","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"guardiansVotes","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"halt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"halted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isHalted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minAdministratorDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minSoftDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minUnhaltDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"newGuardians","type":"address[]"}],"name":"nominateGuardians","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdministrator","type":"address"}],"name":"proposeAdministrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"redeemsInfo","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes32","name":"paramsHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"nonces","type":"uint256[]"}],"name":"revokeRedeems","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdministrator","type":"address"}],"name":"setAdministrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"delay","type":"uint256"}],"name":"setAdministratorDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setAllowKeyGen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"confirmations","type":"uint64"}],"name":"setConfirmationsToFinality","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"blockTime","type":"uint64"}],"name":"setEstimatedBlockTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"delay","type":"uint256"}],"name":"setSoftDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"uint256","name":"redeemDelay","type":"uint256"},{"internalType":"bool","name":"bridgeable","type":"bool"},{"internalType":"bool","name":"redeemable","type":"bool"},{"internalType":"bool","name":"isOwned","type":"bool"}],"name":"setTokenInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTss","type":"address"},{"internalType":"bytes","name":"oldSignature","type":"bytes"},{"internalType":"bytes","name":"newSignature","type":"bytes"}],"name":"setTss","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"setUnhaltDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"softDelay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"timeChallengesInfo","outputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"bytes32","name":"paramsHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokensInfo","outputs":[{"internalType":"uint256","name":"minAmount","type":"uint256"},{"internalType":"uint256","name":"redeemDelay","type":"uint256"},{"internalType":"bool","name":"bridgeable","type":"bool"},{"internalType":"bool","name":"redeemable","type":"bool"},{"internalType":"bool","name":"owned","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tss","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unhalt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unhaltDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unhaltedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"to","type":"string"}],"name":"unwrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"votesCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

46502:16705:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48202:24;;;;;;;;;160:25:1;;;148:2;133:18;48202:24:0;;;;;;;;60566:1141;;;;;;:::i;:::-;;:::i;:::-;;48509:42;;;;;47937:23;;;;;;;;;;;;;;;753:14:1;;746:22;728:41;;716:2;701:18;47937:23:0;588:187:1;48312:31:0;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1129:55:1;;;1111:74;;1099:2;1084:18;48312:31:0;965:226:1;54603:925:0;;;;;;:::i;:::-;;:::i;48083:46::-;;;;;62901:303;;;;;;:::i;:::-;;:::i;47868:37::-;;;;;;;;;;;;;;;2511:18:1;2499:31;;;2481:50;;2469:2;2454:18;47868:37:0;2337:200:1;61988:220:0;;;;;;:::i;:::-;;:::i;59001:1557::-;;;;;;:::i;:::-;;:::i;56400:251::-;;;;;;:::i;:::-;;:::i;48441:25::-;;;;;;48138:18;;;;;-1:-1:-1;;;;;48138:18:0;;;57342:1373;;;;;;:::i;:::-;;:::i;52955:956::-;;;;;;:::i;:::-;;:::i;48043:33::-;;;;;;55536:507;;;;;;:::i;:::-;;:::i;62755:138::-;;;;;;:::i;:::-;;:::i;48558:27::-;;;;;;48760:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7807:25:1;;;7863:2;7848:18;;7841:34;;;;7780:18;48760:55:0;7633:248:1;48650:49:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;61715:265;;;;;;:::i;:::-;;:::i;48233:37::-;;;;;62484:263;;;;;;:::i;:::-;;:::i;47912:18::-;;;;;;;;;;;;48706:47;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8127:25:1;;;8183:2;8168:18;;8161:34;;;;8238:14;;8231:22;8211:18;;;8204:50;;;;8297:14;;8290:22;8285:2;8270:18;;8263:50;8357:14;8350:22;8344:3;8329:19;;8322:51;8114:3;8099:19;48706:47:0;7886:493:1;62216:260:0;;;;;;:::i;:::-;;:::i;50333:128::-;;;:::i;58723:270::-;;;:::i;56051:195::-;;;:::i;48350:42::-;;;;;;:::i;:::-;;;;;;;;;;;;;;48473:29;;;;;;48592:49;;;;;56659:675;;;;;;:::i;:::-;;:::i;47829:32::-;;;;;;;;;47969:28;;;;;-1:-1:-1;;;;;47969:28:0;;;48279:26;;;;;;:::i;:::-;;:::i;50511:2436::-;;;;;;:::i;:::-;;:::i;60566:1141::-;60650:13;;-1:-1:-1;;;;;60650:13:0;:27;60642:85;;;;-1:-1:-1;;;60642:85:0;;9197:2:1;60642:85:0;;;9179:21:1;9236:2;9216:18;;;9209:30;9275:34;9255:18;;;9248:62;9346:15;9326:18;;;9319:43;9379:19;;60642:85:0;;;;;;;;;-1:-1:-1;;;;;60746:30:0;;60738:84;;;;-1:-1:-1;;;60738:84:0;;9611:2:1;60738:84:0;;;9593:21:1;9650:2;9630:18;;;9623:30;9689:34;9669:18;;;9662:62;9760:11;9740:18;;;9733:39;9789:19;;60738:84:0;9409:405:1;60738:84:0;60839:6;60835:865;60855:9;:16;60851:20;;60835:865;;;739:10;-1:-1:-1;;;;;60897:28:0;:9;60907:1;60897:12;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;60897:12:0;:28;60893:796;;60979:1;-1:-1:-1;;;;;60950:31:0;:14;60965:1;60950:17;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;60950:17:0;:31;60946:114;;61039:1;61006:10;:29;61017:14;61032:1;61017:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;61017:17:0;61006:29;;;;;;;;;;;;:34;;:29;;61017:17;61006:34;;;;;:::i;:::-;;;;-1:-1:-1;;60946:114:0;61098:16;61078:14;61093:1;61078:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;:36;;;;-1:-1:-1;;;;;61078:36:0;;;;;;61133:28;;;;;:10;:28;;;;;;:33;;-1:-1:-1;;61078:17:0;61133:33;;-1:-1:-1;;61133:33:0;:::i;:::-;;;;-1:-1:-1;;61202:9:0;:16;61185:14;;61202:20;;61221:1;;61202:20;:::i;:::-;-1:-1:-1;;;;;61245:28:0;;;;;;:10;:28;;;;;;61185:37;;-1:-1:-1;61245:40:0;-1:-1:-1;61241:409:0;;;61314:6;61310:192;61330:14;:21;61326:25;;61310:192;;;61392:10;:29;61403:14;61418:1;61403:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;61403:17:0;61392:29;;;;;;;;;;;;61385:36;;;61448:14;:17;;61463:1;;61448:17;;;;;;:::i;:::-;;;;;;;;;;:30;;;;-1:-1:-1;;;;;61448:30:0;;;;;;;;;;61353:3;;;;:::i;:::-;;;;61310:192;;;-1:-1:-1;61524:13:0;:32;;;;-1:-1:-1;;;;;61524:32:0;;;;;;;;61584:46;;-1:-1:-1;1111:74:1;;61584:46:0;;1099:2:1;1084:18;61584:46:0;;;;;;;61241:409;61668:5;60835:865;60566:1141;:::o;60893:796::-;60873:3;;;;:::i;:::-;;;;60835:865;;;;60566:1141;:::o;48312:31::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48312:31:0;;-1:-1:-1;48312:31:0;:::o;54603:925::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;54788:1:::1;54774:11;:15;54766:74;;;::::0;-1:-1:-1;;;54766:74:0;;11502:2:1;54766:74:0::1;::::0;::::1;11484:21:1::0;11541:2;11521:18;;;11514:30;11580:34;11560:18;;;11553:62;11651:16;11631:18;;;11624:44;11685:19;;54766:74:0::1;11300:410:1::0;54766:74:0::1;54884;::::0;;-1:-1:-1;;;;;12002:55:1;;54884:74:0::1;::::0;::::1;11984::1::0;12074:18;;;12067:34;;;12117:18;;;12110:34;;;12187:14;;12180:22;12160:18;;;12153:50;12247:14;;12240:22;12219:19;;;12212:51;12307:14;;12300:22;12279:19;;;12272:51;54853:18:0::1;::::0;11956:19:1;;54884:74:0::1;;;;;;;;;;;;54874:85;;;;;;54853:106;;54970:52;;;;;;;;;;;;;;;;;::::0;55000:10:::1;55012:9;;54970:13;:52::i;:::-;55095:34;::::0;;12548:14:1;12536:27;;55095:18:0::1;12588:2:1::0;12579:12;;55095:34:0;;;;;;;;;;;:45:::1;;::::0;:59;55091:141:::1;;55176:23;::::0;-1:-1:-1;;;;;55176:23:0;::::1;::::0;::::1;::::0;;;::::1;55214:7;;;55091:141;-1:-1:-1::0;;;;;55244:17:0;::::1;;::::0;;;:10:::1;:17;::::0;;;;;:39;;;55294:29:::1;::::0;::::1;:43:::0;;;55348:28:::1;;:41:::0;;55400;;55348;::::1;;55400::::0;;;55348::::1;55400::::0;::::1;;;;55452:33:::0;::::1;::::0;;::::1;;;;::::0;;55501:19;::::1;::::0;55244:17;55501:19:::1;54755:773;49052:1;54603:925:::0;;;;;;:::o;62901:303::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;63021:1:::1;63005:13;:17;;;62997:92;;;::::0;-1:-1:-1;;;62997:92:0;;12804:2:1;62997:92:0::1;::::0;::::1;12786:21:1::0;12843:2;12823:18;;;12816:30;12882:34;12862:18;;;12855:62;12953:32;12933:18;;;12926:60;13003:19;;62997:92:0::1;12602:426:1::0;62997:92:0::1;63100:23;:39:::0;;;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;63155:41:::1;::::0;2481:50:1;;;63155:41:0::1;::::0;2469:2:1;2454:18;63155:41:0::1;;;;;;;;62901:303:::0;:::o;61988:220::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;62080:12:::1;62071:5;:21;;62063:74;;;::::0;-1:-1:-1;;;62063:74:0;;13235:2:1;62063:74:0::1;::::0;::::1;13217:21:1::0;13274:2;13254:18;;;13247:30;13313:34;13293:18;;;13286:62;13384:10;13364:18;;;13357:38;13412:19;;62063:74:0::1;13033:404:1::0;62063:74:0::1;62148:9;:17:::0;;;62181:19:::1;::::0;160:25:1;;;62181:19:0::1;::::0;148:2:1;133:18;62181:19:0::1;14:177:1::0;59001:1557:0;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;59105:19;;47819:1:::1;-1:-1:-1::0;59105:44:0::1;59097:100;;;::::0;-1:-1:-1;;;59097:100:0;;13644:2:1;59097:100:0::1;::::0;::::1;13626:21:1::0;13683:2;13663:18;;;13656:30;13722:34;13702:18;;;13695:62;13793:13;13773:18;;;13766:41;13824:19;;59097:100:0::1;13442:407:1::0;59097:100:0::1;59238:2;59216:12;:19;:24;59208:82;;;::::0;-1:-1:-1;;;59208:82:0;;14056:2:1;59208:82:0::1;::::0;::::1;14038:21:1::0;14095:2;14075:18;;;14068:30;14134:34;14114:18;;;14107:62;14205:15;14185:18;;;14178:43;14238:19;;59208:82:0::1;13854:409:1::0;59208:82:0::1;59303:18;59345:12;59334:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;59324:35;;;;;;59303:56;;59370:66;;;;;;;;;;;;;;;;;::::0;59405:10:::1;59417:18;;59370:13;:66::i;:::-;59509:39;::::0;;15168:19:1;15156:32;;59509:18:0::1;15213:2:1::0;15204:12;;59509:39:0;;;;;;;;;;;:50:::1;;::::0;:64;59505:677:::1;;59658:6;59653:459;59674:12;:19;59670:1;:23;59653:459;;;59749:1;-1:-1:-1::0;;;;;59722:29:0::1;:12;59735:1;59722:15;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;59722:29:0::1;::::0;59719:124:::1;;59776:47;::::0;-1:-1:-1;;;59776:47:0;;15429:2:1;59776:47:0::1;::::0;::::1;15411:21:1::0;15468:2;15448:18;;;15441:30;15507:34;15487:18;;;15480:62;15578:7;15558:18;;;15551:35;15603:19;;59776:47:0::1;15227:401:1::0;59719:124:0::1;59865:6;59874:5;:1:::0;59878::::1;59874:5;:::i;:::-;59865:14;;59861:236;59885:12;:19;59881:1;:23;59861:236;;;59956:12;59969:1;59956:15;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;59937:34:0::1;:12;59950:1;59937:15;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;59937:34:0::1;::::0;59934:144:::1;;60000:54;::::0;-1:-1:-1;;;60000:54:0;;15835:2:1;60000:54:0::1;::::0;::::1;15817:21:1::0;15874:2;15854:18;;;15847:30;15913:34;15893:18;;;15886:62;15984:14;15964:18;;;15957:42;16016:19;;60000:54:0::1;15633:408:1::0;59934:144:0::1;59906:3:::0;::::1;::::0;::::1;:::i;:::-;;;;59861:236;;;-1:-1:-1::0;59695:3:0;::::1;::::0;::::1;:::i;:::-;;;;59653:459;;;-1:-1:-1::0;60131:18:0::1;::::0;::::1;::::0;;;::::1;60164:7;59001:1557:::0;:::o;59505:677::-:1;60199:6;60194:107;60215:9;:16:::0;60211:20;::::1;60194:107;;;60260:10;:29;60271:14;60286:1;60271:17;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;;::::1;::::0;-1:-1:-1;;;;;60271:17:0::1;60260:29:::0;;;::::1;::::0;;;;;;;;60253:36;60233:3;::::1;::::0;::::1;:::i;:::-;;;;60194:107;;;-1:-1:-1::0;60311:21:0::1;60318:14;;60311:21;:::i;:::-;60343:16;60350:9;;60343:16;:::i;:::-;60375:6;60370:151;60391:12;:19;60387:1;:23;60370:151;;;60432:9;60447:12;60460:1;60447:15;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;60432:31;;::::1;::::0;;::::1;::::0;;-1:-1:-1;60432:31:0;;;;;;::::1;::::0;;-1:-1:-1;;;;;60432:31:0;;::::1;::::0;;;::::1;;::::0;;60478:14:::1;:31:::0;;;;::::1;::::0;;;;;;::::1;::::0;;;;::::1;::::0;;60412:3;::::1;::::0;::::1;:::i;:::-;;;;60370:151;;;-1:-1:-1::0;60536:14:0::1;::::0;::::1;::::0;;;::::1;59086:1472;49052:1;59001:1557:::0;:::o;56400:251::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;56490:6:::1;56486:158;56506:6;:13;56502:1;:17;56486:158;;;47700:17;56541:11;:22;56553:6;56560:1;56553:9;;;;;;;;:::i;:::-;;;;;;;56541:22;;;;;;;;;;;:34;;:47;;;;56622:6;56629:1;56622:9;;;;;;;;:::i;:::-;;;;;;;56608:24;;;;;;;;;;56521:3:::0;::::1;::::0;::::1;:::i;:::-;;;;56486:158;;57342:1373:::0;-1:-1:-1;;;;;57457:20:0;;57449:55;;;;-1:-1:-1;;;57449:55:0;;16248:2:1;57449:55:0;;;16230:21:1;16287:2;16267:18;;;16260:30;16326:24;16306:18;;;16299:52;16368:18;;57449:55:0;16046:346:1;57449:55:0;57537:13;;-1:-1:-1;;;;;57537:13:0;739:10;-1:-1:-1;;;;;57521:29:0;;57517:1131;;57637:11;;;;;;;57629:53;;;;-1:-1:-1;;;57629:53:0;;16599:2:1;57629:53:0;;;16581:21:1;16638:2;16618:18;;;16611:30;16677:31;16657:18;;;16650:59;16726:18;;57629:53:0;16397:353:1;57629:53:0;57706:10;:8;:10::i;:::-;57705:11;57697:45;;;;-1:-1:-1;;;57697:45:0;;16957:2:1;57697:45:0;;;16939:21:1;16996:2;16976:18;;;16969:30;17035:23;17015:18;;;17008:51;17076:18;;57697:45:0;16755:345:1;57697:45:0;57771:5;57757:19;;;;;;57890:12;;57825:86;;;17445:3:1;57825:86:0;;;17427:22:1;;;17486:1;17465:19;;;17458:30;17525:8;17504:19;;;17497:37;47763:1:0;17586:20:1;;;17579:53;;;;57860:13:0;17648:18:1;;;17641:34;57883:4:0;-1:-1:-1;17752:18:1;;17745:43;-1:-1:-1;17804:19:1;;17797:35;;;;-1:-1:-1;;;;;17869:15:1;;17848:19;;;17841:44;17551:19;;57825:86:0;;;;;;;;;;;;57815:97;;;;;;57793:119;;57941:36;:11;44867:58;;29325:66:1;44867:58:0;;;29313:79:1;29408:12;;;29401:28;;;44734:7:0;;29445:12:1;;44867:58:0;;;;;;;;;;;;44857:69;;;;;;44850:76;;44665:269;;;;57941:36;57927:50;-1:-1:-1;57992:14:0;58009:33;57927:50;58029:12;58009:19;:33::i;:::-;58075:3;;57992:50;;-1:-1:-1;;;;;;58065:13:0;;;58075:3;;58065:13;58057:53;;;;-1:-1:-1;;;58057:53:0;;18098:2:1;58057:53:0;;;18080:21:1;18137:2;18117:18;;;18110:30;18176:29;18156:18;;;18149:57;18223:18;;58057:53:0;17896:351:1;58057:53:0;58136:33;:11;58156:12;58136:19;:33::i;:::-;58127:42;;58202:6;-1:-1:-1;;;;;58192:16:0;:6;-1:-1:-1;;;;;58192:16:0;;58184:56;;;;-1:-1:-1;;;58184:56:0;;18454:2:1;58184:56:0;;;18436:21:1;18493:2;18473:18;;;18466:30;18532:29;18512:18;;;18505:57;18579:18;;58184:56:0;18252:351:1;58184:56:0;58273:1;58257:12;;:17;;;;;;;:::i;:::-;;;;-1:-1:-1;57517:1131:0;;-1:-1:-1;;;57517:1131:0;;58338:18;;;-1:-1:-1;;;;;1129:55:1;;58338:18:0;;;1111:74:1;58307:18:0;;1084::1;58338::0;;;;;;;;;;;;58328:29;;;;;;58307:50;;58372:46;;;;;;;;;;;;;;;;;;58396:10;58408:9;;58372:13;:46::i;:::-;58499:28;;;18822:8:1;18810:21;;58499:18:0;18856:1:1;18847:11;;58499:28:0;;;;;;;;;;;:39;;;:53;58495:142;;58578:18;;-1:-1:-1;;;;;58578:18:0;;;;;;;;58615:7;57342:1373;;;:::o;58495:142::-;58292:356;57517:1131;58680:3;;58665:19;;-1:-1:-1;;;;;58680:3:0;;;1111:74:1;;58665:19:0;;;;;;1099:2:1;1084:18;58665:19:0;;;;;;;-1:-1:-1;;58695:3:0;:12;;;;-1:-1:-1;;;;;58695:12:0;;;;;;;;;;57342:1373::o;52955:956::-;48867:10;:8;:10::i;:::-;48866:11;48858:41;;;;-1:-1:-1;;;48858:41:0;;19071:2:1;48858:41:0;;;19053:21:1;19110:2;19090:18;;;19083:30;19149:19;19129:18;;;19122:47;19186:18;;48858:41:0;18869:341:1;48858:41:0;-1:-1:-1;;;;;53060:17:0;::::1;;::::0;;;:10:::1;:17;::::0;;;;:28:::1;;::::0;::::1;;53052:69;;;::::0;-1:-1:-1;;;53052:69:0;;19417:2:1;53052:69:0::1;::::0;::::1;19399:21:1::0;19456:2;19436:18;;;19429:30;19495;19475:18;;;19468:58;19543:18;;53052:69:0::1;19215:352:1::0;53052:69:0::1;-1:-1:-1::0;;;;;53150:17:0;::::1;;::::0;;;:10:::1;:17;::::0;;;;:27;53140:37;::::1;;53132:107;;;::::0;-1:-1:-1;;;53132:107:0;;19774:2:1;53132:107:0::1;::::0;::::1;19756:21:1::0;19813:2;19793:18;;;19786:30;19852:34;19832:18;;;19825:62;19923:27;19903:18;;;19896:55;19968:19;;53132:107:0::1;19572:421:1::0;53132:107:0::1;53273:38;::::0;;;;53305:4:::1;53273:38;::::0;::::1;1111:74:1::0;53252:18:0::1;::::0;-1:-1:-1;;;;;53273:23:0;::::1;::::0;::::1;::::0;1084:18:1;;53273:38:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53252:59:::0;-1:-1:-1;53322:67:0::1;-1:-1:-1::0;;;;;53322:30:0;::::1;739:10:::0;53375:4:::1;53382:6:::0;53322:30:::1;:67::i;:::-;53421:38;::::0;;;;53453:4:::1;53421:38;::::0;::::1;1111:74:1::0;53400:18:0::1;::::0;-1:-1:-1;;;;;53421:23:0;::::1;::::0;::::1;::::0;1084:18:1;;53421:38:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53400:59;;53488:10;53478:6;:20;;53470:75;;;::::0;-1:-1:-1;;;53470:75:0;;20389:2:1;53470:75:0::1;::::0;::::1;20371:21:1::0;20428:2;20408:18;;;20401:30;20467:34;20447:18;;;20440:62;20538:12;20518:18;;;20511:40;20568:19;;53470:75:0::1;20187:406:1::0;53470:75:0::1;53587:10:::0;53564:19:::1;53577:6:::0;53564:10;:19:::1;:::i;:::-;:33;53556:69;;;::::0;-1:-1:-1;;;53556:69:0;;20800:2:1;53556:69:0::1;::::0;::::1;20782:21:1::0;20839:2;20819:18;;;20812:30;20878:25;20858:18;;;20851:53;20921:18;;53556:69:0::1;20598:347:1::0;53556:69:0::1;-1:-1:-1::0;;;;;53768:17:0;::::1;;::::0;;;:10:::1;:17;::::0;;;;:23:::1;;::::0;;;::::1;;;53764:82;;;53808:26;::::0;;;;::::1;::::0;::::1;160:25:1::0;;;-1:-1:-1;;;;;53808:18:0;::::1;::::0;::::1;::::0;133::1;;53808:26:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;53764:82;-1:-1:-1::0;;;;;53861:42:0;::::1;739:10:::0;-1:-1:-1;;;;;53861:42:0::1;;53892:2;53896:6;53861:42;;;;;;;:::i;:::-;;;;;;;;53041:870;;52955:956:::0;;;:::o;55536:507::-;55614:13;;-1:-1:-1;;;;;55614:13:0;739:10;-1:-1:-1;;;;;55598:29:0;;55594:392;;55739:12;;55676:76;;;22148:3:1;55676:76:0;;;;22130:22:1;;;22189:1;22168:19;;;22161:30;22228:6;22207:19;;;;22200:35;;;;47763:1:0;22287:20:1;;;22280:53;55709:13:0;22349:18:1;;;22342:34;55732:4:0;-1:-1:-1;22392:18:1;;22385:83;22484:19;;;22477:35;;;;55676:76:0;;;;;;;;;;22252:19:1;;;55676:76:0;;55666:87;;;;;;29325:66:1;44867:58:0;;;29313:79:1;29408:12;;;;29401:28;;;;44867:58:0;;;;;;;;;;29445:12:1;;;;44867:58:0;;;44857:69;;;;;-1:-1:-1;55850:30:0;44857:69;55870:9;55850:19;:30::i;:::-;55913:3;;55833:47;;-1:-1:-1;;;;;;55903:13:0;;;55913:3;;55903:13;55895:47;;;;-1:-1:-1;;;55895:47:0;;22725:2:1;55895:47:0;;;22707:21:1;22764:2;22744:18;;;22737:30;22803:23;22783:18;;;22776:51;22844:18;;55895:47:0;22523:345:1;55895:47:0;55973:1;55957:12;;:17;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;55594:392:0;55998:6;:13;;;;;;;;56027:8;;;;55998:6;56027:8;55536:507;:::o;62755:138::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;62829:11:::1;:19:::0;;;::::1;;::::0;::::1;::::0;;;::::1;;::::0;;62864:21:::1;::::0;::::1;::::0;::::1;::::0;62843:5;753:14:1;746:22;728:41;;716:2;701:18;;588:187;61715:265:0;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;61816:21:::1;61807:5;:30;;61799:92;;;::::0;-1:-1:-1;;;61799:92:0;;23075:2:1;61799:92:0::1;::::0;::::1;23057:21:1::0;23114:2;23094:18;;;23087:30;23153:34;23133:18;;;23126:62;23224:19;23204:18;;;23197:47;23261:19;;61799:92:0::1;22873:413:1::0;61799:92:0::1;61902:18;:26:::0;;;61944:28:::1;::::0;160:25:1;;;61944:28:0::1;::::0;148:2:1;133:18;61944:28:0::1;14:177:1::0;62484:263:0;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;62591:1:::1;62579:9;:13;;;62571:79;;;::::0;-1:-1:-1;;;62571:79:0;;23493:2:1;62571:79:0::1;::::0;::::1;23475:21:1::0;23532:2;23512:18;;;23505:30;23571:34;23551:18;;;23544:62;23642:23;23622:18;;;23615:51;23683:19;;62571:79:0::1;23291:417:1::0;62571:79:0::1;62661:18;:30:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;62707:32:::1;::::0;2481:50:1;;;62707:32:0::1;::::0;2469:2:1;2454:18;62707:32:0::1;2337:200:1::0;62216:260:0;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;62319:17:::1;62307:8;:29;;62299:90;;;::::0;-1:-1:-1;;;62299:90:0;;23915:2:1;62299:90:0::1;::::0;::::1;23897:21:1::0;23954:2;23934:18;;;23927:30;23993:34;23973:18;;;23966:62;24064:18;24044;;;24037:46;24100:19;;62299:90:0::1;23713:412:1::0;62299:90:0::1;62400:14;:25:::0;;;62441:27:::1;::::0;160:25:1;;;62441:27:0::1;::::0;148:2:1;133:18;62441:27:0::1;14:177:1::0;50333:128:0;50374:4;50398:6;;;;;;;;:55;;;50440:12;50422:14;;50409:10;;:27;;;;:::i;:::-;:43;;50398:55;50391:62;;50333:128;:::o;58723:270::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;58816:13:::1;::::0;58787:43:::1;::::0;-1:-1:-1;;;;;58816:13:0;;::::1;1111:74:1::0;;58812:1:0::1;::::0;58787:43:::1;::::0;1099:2:1;1084:18;58787:43:0::1;;;;;;;58841:13;:26:::0;;;::::1;::::0;;58904:3:::1;::::0;58885:23:::1;::::0;-1:-1:-1;;;;;58904:3:0;;::::1;1111:74:1::0;;-1:-1:-1;;58885:23:0::1;::::0;1099:2:1;1084:18;58885:23:0::1;;;;;;;58919:3;:16:::0;;;::::1;::::0;;58933:1:::1;58948:13:::0;;;::::1;::::0;::::1;::::0;;58977:8:::1;::::0;::::1;::::0;58933:1;58977:8:::1;58723:270::o:0;56051:195::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;56115:6:::1;::::0;;;::::1;;;56107:42;;;::::0;-1:-1:-1;;;56107:42:0;;24332:2:1;56107:42:0::1;::::0;::::1;24314:21:1::0;24371:2;24351:18;;;24344:30;24410:25;24390:18;;;24383:53;24453:18;;56107:42:0::1;24130:347:1::0;56107:42:0::1;56171:5;56162:14:::0;;;::::1;::::0;;56200:12:::1;56187:10;:25:::0;56228:10:::1;::::0;::::1;::::0;56171:5;56228:10:::1;56051:195::o:0;56659:675::-;48991:13;;-1:-1:-1;;;;;48991:13:0;739:10;-1:-1:-1;;;;;48975:29:0;;48967:74;;;;-1:-1:-1;;;48967:74:0;;11141:2:1;48967:74:0;;;11123:21:1;;;11160:18;;;11153:30;11219:34;11199:18;;;11192:62;11271:18;;48967:74:0;10939:356:1;48967:74:0;-1:-1:-1;;;;;56757:30:0;::::1;56749:90;;;::::0;-1:-1:-1;;;56749:90:0;;24684:2:1;56749:90:0::1;::::0;::::1;24666:21:1::0;24723:2;24703:18;;;24696:30;24762:34;24742:18;;;24735:62;24833:17;24813:18;;;24806:45;24868:19;;56749:90:0::1;24482:411:1::0;56749:90:0::1;56883:28;::::0;;-1:-1:-1;;;;;1129:55:1;;56883:28:0::1;::::0;::::1;1111:74:1::0;56852:18:0::1;::::0;1084::1;56883:28:0::1;;;;;;;;;;;;56873:39;;;;;;56852:60;;56923:65;;;;;;;;;;;;;;;;;::::0;56957:10:::1;56969:18;;56923:13;:65::i;:::-;57061:38;::::0;;25112:18:1;25100:31;;57061:18:0::1;25156:2:1::0;25147:12;;57061:38:0;;;;;;;;;;;:49:::1;;::::0;:63;57057:160:::1;;57146:38;::::0;-1:-1:-1;;;;;57146:38:0;::::1;::::0;::::1;::::0;;;::::1;57199:7;59001:1557:::0;:::o;57057:160::-:1;57269:13;::::0;57234:49:::1;::::0;-1:-1:-1;;;;;57269:13:0;;::::1;1111:74:1::0;;57234:49:0;;::::1;::::0;::::1;::::0;1099:2:1;1084:18;57234:49:0::1;;;;;;;-1:-1:-1::0;57294:13:0::1;:32:::0;;-1:-1:-1;;;;;57294:32:0;::::1;::::0;;;::::1;;::::0;;56659:675;:::o;48279:26::-;;;;;;;;;;;;50511:2436;48867:10;:8;:10::i;:::-;48866:11;48858:41;;;;-1:-1:-1;;;48858:41:0;;19071:2:1;48858:41:0;;;19053:21:1;19110:2;19090:18;;;19083:30;19149:19;19129:18;;;19122:47;19186:18;;48858:41:0;18869:341:1;48858:41:0;50784:28:::1;50815:18:::0;;;:11:::1;:18;::::0;;;;;;;50784:49;;;;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;50873:17:0;::::1;::::0;;:10:::1;:17:::0;;;;;;50844:46;;::::1;::::0;::::1;::::0;;;;;;;;::::1;::::0;;;::::1;::::0;;;;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;;;::::0;;;;;;;::::1;::::0;::::1;::::0;::::1;;;::::0;;;;;;;;;::::1;::::0;;::::1;;;::::0;;;;50901:61:::1;;;::::0;-1:-1:-1;;;50901:61:0;;25372:2:1;50901:61:0::1;::::0;::::1;25354:21:1::0;25411:2;25391:18;;;25384:30;25450;25430:18;;;25423:58;25498:18;;50901:61:0::1;25170:352:1::0;50901:61:0::1;50981:22:::0;;:36;;50973:79:::1;;;::::0;-1:-1:-1;;;50973:79:0;;25729:2:1;50973:79:0::1;::::0;::::1;25711:21:1::0;25768:2;25748:18;;;25741:30;25807:32;25787:18;;;25780:60;25857:18;;50973:79:0::1;25527:354:1::0;50973:79:0::1;51097:21;::::0;::::1;::::0;51072:22;;51122:12:::1;::::0;51072:46:::1;::::0;::::1;:::i;:::-;51071:63;51063:102;;;::::0;-1:-1:-1;;;51063:102:0;;26088:2:1;51063:102:0::1;::::0;::::1;26070:21:1::0;26127:2;26107:18;;;26100:30;26166:28;26146:18;;;26139:56;26212:18;;51063:102:0::1;25886:350:1::0;51063:102:0::1;51182:22:::0;;::::1;:27:::0;51178:1762:::1;;51496:80;::::0;;47763:1:::1;51496:80;::::0;;::::1;26554:42:1::0;;;;51521:13:0::1;26612:18:1::0;;;26605:34;51544:4:0::1;26716:18:1::0;;;26709:43;26768:18;;;26761:34;;;-1:-1:-1;;;;;26832:15:1;;;26811:19;;;26804:44;26885:15;;26864:19;;;26857:44;26917:19;;;;26910:35;;;51496:80:0;;;;;;;;;;26526:19:1;;;51496:80:0;;51486:91;;;;::::1;::::0;29325:66:1;44867:58:0;;;29313:79:1;29408:12;;;;29401:28;;;;44867:58:0;;;;;;;;;;29445:12:1;;;;44867:58:0;;;44857:69;;;;;-1:-1:-1;51674:30:0::1;44857:69:::0;51694:9;51674:19:::1;:30::i;:::-;51737:3;::::0;51657:47;;-1:-1:-1;;;;;;51727:13:0;;::::1;51737:3:::0;::::1;51727:13;51719:49;;;::::0;-1:-1:-1;;;51719:49:0;;27158:2:1;51719:49:0::1;::::0;::::1;27140:21:1::0;27197:2;27177:18;;;27170:30;27236:25;27216:18;;;27209:53;27279:18;;51719:49:0::1;26956:347:1::0;51719:49:0::1;51785:18;::::0;;;:11:::1;:18;::::0;;;;;;;;51818:12:::1;51785:45:::0;;51887:29;;-1:-1:-1;;;;;27589:15:1;;;51887:29:0;;::::1;27571:34:1::0;;;;27641:15;;;27621:18;;;27614:43;;;;27673:18;;;27666:34;;;27483:18;;51887:29:0::1;::::0;;-1:-1:-1;;51887:29:0;;::::1;::::0;;;;;;51877:40;;51887:29:::1;51877:40:::0;;::::1;::::0;51845:18:::1;::::0;;;:11:::1;:18:::0;;;;;;:29:::1;;:72:::0;-1:-1:-1;;;;;51937:42:0;;::::1;::::0;;;::::1;::::0;51857:5;;51937:42:::1;::::0;::::1;::::0;51972:6;160:25:1;;148:2;133:18;;14:177;51937:42:0::1;;;;;;;;51211:780;;51178:1762;;;52063:29;::::0;;-1:-1:-1;;;;;27589:15:1;;;52063:29:0::1;::::0;::::1;27571:34:1::0;27641:15;;27621:18;;;27614:43;;;;27673:18;;;27666:34;;;27483:18;;52063:29:0::1;::::0;;-1:-1:-1;;52063:29:0;;::::1;::::0;;;;;;52053:40;;52063:29:::1;52053:40:::0;;::::1;::::0;52020:18:::1;::::0;;;:11:::1;:18:::0;;;;;:29:::1;;::::0;:73:::1;52012:147;;;::::0;-1:-1:-1;;;52012:147:0;;27913:2:1;52012:147:0::1;::::0;::::1;27895:21:1::0;27952:2;27932:18;;;27925:30;27991:34;27971:18;;;27964:62;28062:31;28042:18;;;28035:59;28111:19;;52012:147:0::1;27711:425:1::0;52012:147:0::1;52228:18;::::0;;;:11:::1;:18;::::0;;;;47700:17:::1;52228:43:::0;;52425:15:::1;::::0;::::1;::::0;52421:454:::1;;;52612:30;::::0;;;;-1:-1:-1;;;;;28333:55:1;;;52612:30:0::1;::::0;::::1;28315:74:1::0;28405:18;;;28398:34;;;52612:18:0;::::1;::::0;::::1;::::0;28288::1;;52612:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;52421:454;;;52821:38;-1:-1:-1::0;;;;;52821:26:0;::::1;52848:2:::0;52852:6;52821:26:::1;:38::i;:::-;52914:5;-1:-1:-1::0;;;;;52894:34:0::1;52910:2;-1:-1:-1::0;;;;;52894:34:0::1;52903:5;52894:34;52921:6;52894:34;;;;160:25:1::0;;148:2;133:18;;14:177;52894:34:0::1;;;;;;;;51178:1762;50630:2317;;50511:2436:::0;;;;;:::o;53919:676::-;54081:10;54036:18;54055:10;54036:30;;;;;;:::i;:::-;;;;;;;;;;;;;:41;;;:55;54032:556;;54175:12;54157:14;54112:18;54131:10;54112:30;;;;;;:::i;:::-;;;;;;;;;;;;;;:42;:59;;;;:::i;:::-;:75;54108:143;;54208:27;;-1:-1:-1;;;54208:27:0;;28939:2:1;54208:27:0;;;28921:21:1;28978:2;28958:18;;;28951:30;29017:19;28997:18;;;28990:47;29054:18;;54208:27:0;28737:341:1;54108:143:0;54335:18;54354:10;54335:30;;;;;;:::i;:::-;;;;;;;;;;;;;:41;;54328:48;;;53919:676;;;:::o;54032:556::-;54494:10;54450:18;54469:10;54450:30;;;;;;:::i;:::-;;;;;;;;;;;;;:41;;:54;;;;54564:12;54519:18;54538:10;54519:30;;;;;;:::i;:::-;;;;;;;;;;;;;;:57;53919:676;;;:::o;40975:231::-;41053:7;41074:17;41093:18;41115:27;41126:4;41132:9;41115:10;:27::i;:::-;41073:69;;;;41153:18;41165:5;41153:11;:18::i;:::-;-1:-1:-1;41189:9:0;-1:-1:-1;40975:231:0;;;;;:::o;18707:248::-;18878:68;;-1:-1:-1;;;;;27589:15:1;;;18878:68:0;;;27571:34:1;27641:15;;27621:18;;;27614:43;27673:18;;;27666:34;;;18851:96:0;;18871:5;;18901:27;;27483:18:1;;18878:68:0;;;;-1:-1:-1;;18878:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;18851:19;:96::i;:::-;18707:248;;;;:::o;18488:211::-;18632:58;;-1:-1:-1;;;;;28333:55:1;;18632:58:0;;;28315:74:1;28405:18;;;28398:34;;;18605:86:0;;18625:5;;18655:23;;28288:18:1;;18632:58:0;28141:297:1;39426:747:0;39507:7;39516:12;39545:9;:16;39565:2;39545:22;39541:625;;39889:4;39874:20;;39868:27;39939:4;39924:20;;39918:27;39997:4;39982:20;;39976:27;39584:9;39968:36;40040:25;40051:4;39968:36;39868:27;39918;40040:10;:25::i;:::-;40033:32;;;;;;;;;39541:625;-1:-1:-1;40114:1:0;;-1:-1:-1;40118:35:0;39541:625;39426:747;;;;;:::o;37819:521::-;37897:20;37888:5;:29;;;;;;;;:::i;:::-;;37884:449;;37819:521;:::o;37884:449::-;37995:29;37986:5;:38;;;;;;;;:::i;:::-;;37982:351;;38041:34;;-1:-1:-1;;;38041:34:0;;29859:2:1;38041:34:0;;;29841:21:1;29898:2;29878:18;;;29871:30;29937:26;29917:18;;;29910:54;29981:18;;38041:34:0;29657:348:1;37982:351:0;38106:35;38097:5;:44;;;;;;;;:::i;:::-;;38093:240;;38158:41;;-1:-1:-1;;;38158:41:0;;30212:2:1;38158:41:0;;;30194:21:1;30251:2;30231:18;;;30224:30;30290:33;30270:18;;;30263:61;30341:18;;38158:41:0;30010:355:1;38093:240:0;38230:30;38221:5;:39;;;;;;;;:::i;:::-;;38217:116;;38277:44;;-1:-1:-1;;;38277:44:0;;30572:2:1;38277:44:0;;;30554:21:1;30611:2;30591:18;;;30584:30;30650:34;30630:18;;;30623:62;30721:4;30701:18;;;30694:32;30743:19;;38277:44:0;30370:398:1;21555:716:0;21979:23;22005:69;22033:4;22005:69;;;;;;;;;;;;;;;;;22013:5;-1:-1:-1;;;;;22005:27:0;;;:69;;;;;:::i;:::-;22089:17;;21979:95;;-1:-1:-1;22089:21:0;22085:179;;22186:10;22175:30;;;;;;;;;;;;:::i;:::-;22167:85;;;;-1:-1:-1;;;22167:85:0;;31225:2:1;22167:85:0;;;31207:21:1;31264:2;31244:18;;;31237:30;31303:34;31283:18;;;31276:62;31374:12;31354:18;;;31347:40;31404:19;;22167:85:0;31023:406:1;42427:1520:0;42558:7;;43492:66;43479:79;;43475:163;;;-1:-1:-1;43591:1:0;;-1:-1:-1;43595:30:0;43575:51;;43475:163;43752:24;;;43735:14;43752:24;;;;;;;;;31661:25:1;;;31734:4;31722:17;;31702:18;;;31695:45;;;;31756:18;;;31749:34;;;31799:18;;;31792:34;;;43752:24:0;;31633:19:1;;43752:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43752:24:0;;-1:-1:-1;;43752:24:0;;;-1:-1:-1;;;;;;;43791:20:0;;43787:103;;43844:1;43848:29;43828:50;;;;;;;43787:103;43910:6;-1:-1:-1;43918:20:0;;-1:-1:-1;42427:1520:0;;;;;;;;:::o;10185:229::-;10322:12;10354:52;10376:6;10384:4;10390:1;10393:12;10354:21;:52::i;:::-;10347:59;10185:229;-1:-1:-1;;;;10185:229:0:o;11305:455::-;11475:12;11533:5;11508:21;:30;;11500:81;;;;-1:-1:-1;;;11500:81:0;;32039:2:1;11500:81:0;;;32021:21:1;32078:2;32058:18;;;32051:30;32117:34;32097:18;;;32090:62;32188:8;32168:18;;;32161:36;32214:19;;11500:81:0;31837:402:1;11500:81:0;11593:12;11607:23;11634:6;-1:-1:-1;;;;;11634:11:0;11653:5;11660:4;11634:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11592:73;;;;11683:69;11710:6;11718:7;11727:10;11739:12;11683:26;:69::i;:::-;11676:76;11305:455;-1:-1:-1;;;;;;;11305:455:0:o;13878:644::-;14063:12;14092:7;14088:427;;;14120:10;:17;14141:1;14120:22;14116:290;;-1:-1:-1;;;;;7723:19:0;;;14330:60;;;;-1:-1:-1;;;14330:60:0;;32738:2:1;14330:60:0;;;32720:21:1;32777:2;32757:18;;;32750:30;32816:31;32796:18;;;32789:59;32865:18;;14330:60:0;32536:353:1;14330:60:0;-1:-1:-1;14427:10:0;14420:17;;14088:427;14470:33;14478:10;14490:12;15225:17;;:21;15221:388;;15457:10;15451:17;15514:15;15501:10;15497:2;15493:19;15486:44;15221:388;15584:12;15577:20;;-1:-1:-1;;;15577:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;196:196:1:-;264:20;;-1:-1:-1;;;;;313:54:1;;303:65;;293:93;;382:1;379;372:12;293:93;196:196;;;:::o;397:186::-;456:6;509:2;497:9;488:7;484:23;480:32;477:52;;;525:1;522;515:12;477:52;548:29;567:9;548:29;:::i;:::-;538:39;397:186;-1:-1:-1;;;397:186:1:o;780:180::-;839:6;892:2;880:9;871:7;867:23;863:32;860:52;;;908:1;905;898:12;860:52;-1:-1:-1;931:23:1;;780:180;-1:-1:-1;780:180:1:o;1196:118::-;1282:5;1275:13;1268:21;1261:5;1258:32;1248:60;;1304:1;1301;1294:12;1319:724;1414:6;1422;1430;1438;1446;1454;1507:3;1495:9;1486:7;1482:23;1478:33;1475:53;;;1524:1;1521;1514:12;1475:53;1547:29;1566:9;1547:29;:::i;:::-;1537:39;;1623:2;1612:9;1608:18;1595:32;1585:42;;1674:2;1663:9;1659:18;1646:32;1636:42;;1728:2;1717:9;1713:18;1700:32;1741:28;1763:5;1741:28;:::i;:::-;1788:5;-1:-1:-1;1845:3:1;1830:19;;1817:33;1859:30;1817:33;1859:30;:::i;:::-;1908:7;-1:-1:-1;1967:3:1;1952:19;;1939:33;1981:30;1939:33;1981:30;:::i;:::-;2030:7;2020:17;;;1319:724;;;;;;;;:::o;2048:284::-;2106:6;2159:2;2147:9;2138:7;2134:23;2130:32;2127:52;;;2175:1;2172;2165:12;2127:52;2214:9;2201:23;2264:18;2257:5;2253:30;2246:5;2243:41;2233:69;;2298:1;2295;2288:12;2542:184;2594:77;2591:1;2584:88;2691:4;2688:1;2681:15;2715:4;2712:1;2705:15;2731:334;2802:2;2796:9;2858:2;2848:13;;-1:-1:-1;;2844:86:1;2832:99;;2961:18;2946:34;;2982:22;;;2943:62;2940:88;;;3008:18;;:::i;:::-;3044:2;3037:22;2731:334;;-1:-1:-1;2731:334:1:o;3070:183::-;3130:4;3163:18;3155:6;3152:30;3149:56;;;3185:18;;:::i;:::-;-1:-1:-1;3230:1:1;3226:14;3242:4;3222:25;;3070:183::o;3258:897::-;3342:6;3373:2;3416;3404:9;3395:7;3391:23;3387:32;3384:52;;;3432:1;3429;3422:12;3384:52;3472:9;3459:23;3505:18;3497:6;3494:30;3491:50;;;3537:1;3534;3527:12;3491:50;3560:22;;3613:4;3605:13;;3601:27;-1:-1:-1;3591:55:1;;3642:1;3639;3632:12;3591:55;3678:2;3665:16;3701:60;3717:43;3757:2;3717:43;:::i;:::-;3701:60;:::i;:::-;3795:15;;;3877:1;3873:10;;;;3865:19;;3861:28;;;3826:12;;;;3901:19;;;3898:39;;;3933:1;3930;3923:12;3898:39;3957:11;;;;3977:148;3993:6;3988:3;3985:15;3977:148;;;4059:23;4078:3;4059:23;:::i;:::-;4047:36;;4010:12;;;;4103;;;;3977:148;;4160:891;4244:6;4275:2;4318;4306:9;4297:7;4293:23;4289:32;4286:52;;;4334:1;4331;4324:12;4286:52;4374:9;4361:23;4407:18;4399:6;4396:30;4393:50;;;4439:1;4436;4429:12;4393:50;4462:22;;4515:4;4507:13;;4503:27;-1:-1:-1;4493:55:1;;4544:1;4541;4534:12;4493:55;4580:2;4567:16;4603:60;4619:43;4659:2;4619:43;:::i;4603:60::-;4697:15;;;4779:1;4775:10;;;;4767:19;;4763:28;;;4728:12;;;;4803:19;;;4800:39;;;4835:1;4832;4825:12;4800:39;4859:11;;;;4879:142;4895:6;4890:3;4887:15;4879:142;;;4961:17;;4949:30;;4912:12;;;;4999;;;;4879:142;;5056:589;5098:5;5151:3;5144:4;5136:6;5132:17;5128:27;5118:55;;5169:1;5166;5159:12;5118:55;5205:6;5192:20;5231:18;5227:2;5224:26;5221:52;;;5253:18;;:::i;:::-;5297:114;5405:4;-1:-1:-1;;5329:4:1;5325:2;5321:13;5317:86;5313:97;5297:114;:::i;:::-;5436:2;5427:7;5420:19;5482:3;5475:4;5470:2;5462:6;5458:15;5454:26;5451:35;5448:55;;;5499:1;5496;5489:12;5448:55;5564:2;5557:4;5549:6;5545:17;5538:4;5529:7;5525:18;5512:55;5612:1;5587:16;;;5605:4;5583:27;5576:38;;;;5591:7;5056:589;-1:-1:-1;;;5056:589:1:o;5650:613::-;5745:6;5753;5761;5814:2;5802:9;5793:7;5789:23;5785:32;5782:52;;;5830:1;5827;5820:12;5782:52;5853:29;5872:9;5853:29;:::i;:::-;5843:39;;5933:2;5922:9;5918:18;5905:32;5956:18;5997:2;5989:6;5986:14;5983:34;;;6013:1;6010;6003:12;5983:34;6036:49;6077:7;6068:6;6057:9;6053:22;6036:49;:::i;:::-;6026:59;;6138:2;6127:9;6123:18;6110:32;6094:48;;6167:2;6157:8;6154:16;6151:36;;;6183:1;6180;6173:12;6151:36;;6206:51;6249:7;6238:8;6227:9;6223:24;6206:51;:::i;:::-;6196:61;;;5650:613;;;;;:::o;6268:463::-;6355:6;6363;6371;6424:2;6412:9;6403:7;6399:23;6395:32;6392:52;;;6440:1;6437;6430:12;6392:52;6463:29;6482:9;6463:29;:::i;:::-;6453:39;;6539:2;6528:9;6524:18;6511:32;6501:42;;6594:2;6583:9;6579:18;6566:32;6621:18;6613:6;6610:30;6607:50;;;6653:1;6650;6643:12;6607:50;6676:49;6717:7;6708:6;6697:9;6693:22;6676:49;:::i;6736:320::-;6804:6;6857:2;6845:9;6836:7;6832:23;6828:32;6825:52;;;6873:1;6870;6863:12;6825:52;6913:9;6900:23;6946:18;6938:6;6935:30;6932:50;;;6978:1;6975;6968:12;6932:50;7001:49;7042:7;7033:6;7022:9;7018:22;7001:49;:::i;7061:241::-;7117:6;7170:2;7158:9;7149:7;7145:23;7141:32;7138:52;;;7186:1;7183;7176:12;7138:52;7225:9;7212:23;7244:28;7266:5;7244:28;:::i;8384:606::-;8488:6;8496;8504;8512;8520;8573:3;8561:9;8552:7;8548:23;8544:33;8541:53;;;8590:1;8587;8580:12;8541:53;8613:29;8632:9;8613:29;:::i;:::-;8603:39;;8661:38;8695:2;8684:9;8680:18;8661:38;:::i;:::-;8651:48;;8746:2;8735:9;8731:18;8718:32;8708:42;;8797:2;8786:9;8782:18;8769:32;8759:42;;8852:3;8841:9;8837:19;8824:33;8880:18;8872:6;8869:30;8866:50;;;8912:1;8909;8902:12;8866:50;8935:49;8976:7;8967:6;8956:9;8952:22;8935:49;:::i;:::-;8925:59;;;8384:606;;;;;;;;:::o;9819:184::-;9871:77;9868:1;9861:88;9968:4;9965:1;9958:15;9992:4;9989:1;9982:15;10008:184;10060:77;10057:1;10050:88;10157:4;10154:1;10147:15;10181:4;10178:1;10171:15;10197:128;10264:9;;;10285:11;;;10282:37;;;10299:18;;:::i;10330:125::-;10395:9;;;10416:10;;;10413:36;;;10429:18;;:::i;10460:274::-;10500:1;10526;10516:189;;10561:77;10558:1;10551:88;10662:4;10659:1;10652:15;10690:4;10687:1;10680:15;10516:189;-1:-1:-1;10719:9:1;;10460:274::o;10739:195::-;10778:3;10809:66;10802:5;10799:77;10796:103;;10879:18;;:::i;:::-;-1:-1:-1;10926:1:1;10915:13;;10739:195::o;14268:681::-;14439:2;14491:21;;;14561:13;;14464:18;;;14583:22;;;14410:4;;14439:2;14662:15;;;;14636:2;14621:18;;;14410:4;14705:218;14719:6;14716:1;14713:13;14705:218;;;14784:13;;-1:-1:-1;;;;;14780:62:1;14768:75;;14898:15;;;;14863:12;;;;14741:1;14734:9;14705:218;;;-1:-1:-1;14940:3:1;;14268:681;-1:-1:-1;;;;;;14268:681:1:o;19998:184::-;20068:6;20121:2;20109:9;20100:7;20096:23;20092:32;20089:52;;;20137:1;20134;20127:12;20089:52;-1:-1:-1;20160:16:1;;19998:184;-1:-1:-1;19998:184:1:o;20950:250::-;21035:1;21045:113;21059:6;21056:1;21053:13;21045:113;;;21135:11;;;21129:18;21116:11;;;21109:39;21081:2;21074:10;21045:113;;;-1:-1:-1;;21192:1:1;21174:16;;21167:27;20950:250::o;21205:330::-;21247:3;21285:5;21279:12;21312:6;21307:3;21300:19;21328:76;21397:6;21390:4;21385:3;21381:14;21374:4;21367:5;21363:16;21328:76;:::i;:::-;21449:2;21437:15;-1:-1:-1;;21433:88:1;21424:98;;;;21524:4;21420:109;;21205:330;-1:-1:-1;;21205:330:1:o;21540:291::-;21717:2;21706:9;21699:21;21680:4;21737:45;21778:2;21767:9;21763:18;21755:6;21737:45;:::i;:::-;21729:53;;21818:6;21813:2;21802:9;21798:18;21791:34;21540:291;;;;;:::o;28443:289::-;28574:3;28612:6;28606:13;28628:66;28687:6;28682:3;28675:4;28667:6;28663:17;28628:66;:::i;:::-;28710:16;;;;;28443:289;-1:-1:-1;;28443:289:1:o;29468:184::-;29520:77;29517:1;29510:88;29617:4;29614:1;29607:15;29641:4;29638:1;29631:15;30773:245;30840:6;30893:2;30881:9;30872:7;30868:23;30864:32;30861:52;;;30909:1;30906;30899:12;30861:52;30941:9;30935:16;30960:28;30982:5;30960:28;:::i;32894:220::-;33043:2;33032:9;33025:21;33006:4;33063:45;33104:2;33093:9;33089:18;33081:6;33063:45;:::i

ipfs://adf7ca0ad956628485efd92157899d23a62ce77fa950eccb996a764700c394bc