Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IAccessControl
•    - function hasRole(bytes32 role, addres ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _msgSender()
•    - function _msgData()
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• 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)
•    - function supportsInterface(bytes4 int ...
•    - function hasRole(bytes32 role, addres ...
•    - function _checkRole(bytes32 role)
•    - function _checkRole(bytes32 role, add ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _setupRole(bytes32 role, add ...
•    - function _setRoleAdmin(bytes32 role, ...
•    - function _grantRole(bytes32 role, add ...
•    - function _revokeRole(bytes32 role, ad ...
• 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(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _spendAllowance(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
•    - function setAdmin(address newAdmin)
•    - function acceptAdminRole()
•    - function renounceRole(bytes32 role, a ...
•    - function setMinter(address newMinter)
•    - function getAddressMinter()
•    - function _requireAdmin()
•  contract LvUSDToken is ERC20(& ... *
•    - function mint(uint256 amount)
•    - function setMintDestination(address m ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-02-03
*/

// Sources flattened with hardhat v2.12.6 https://hardhat.org

// File @openzeppelin/contracts/access/[email protected]

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


// File @openzeppelin/contracts/utils/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @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;
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


// File @openzeppelin/contracts/utils/introspection/[email protected]

// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @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);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @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);
    }
}


// File @openzeppelin/contracts/access/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;




/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @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);
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

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

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}


// File contracts/BasicAccessController.sol

pragma solidity 0.8.17;

abstract contract BasicAccessController is AccessControl {
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");

    address private _addressMinter;

    address private _nominatedAdmin;
    address private _oldAdmin;

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[44] private __gap;

    modifier onlyAdmin() {
        require(hasRole(ADMIN_ROLE, msg.sender), "Caller is not Admin");
        _;
    }

    modifier onlyMinter() {
        require(hasRole(MINTER_ROLE, msg.sender), "Caller is not Minter");
        _;
    }

    function setAdmin(address newAdmin) public onlyAdmin {
        if (newAdmin == _msgSender()) {
            revert("new admin must be different");
        }
        _nominatedAdmin = newAdmin;
        _oldAdmin = _msgSender();
    }

    function acceptAdminRole() external {
        if (_nominatedAdmin == address(0) || _oldAdmin == address(0)) {
            revert("no nominated admin");
        }
        if (_nominatedAdmin == _msgSender()) {
            _grantRole(ADMIN_ROLE, _msgSender());
            _revokeRole(ADMIN_ROLE, _oldAdmin);

            _nominatedAdmin = address(0);
            _oldAdmin = address(0);
        }
    }

    function renounceRole(bytes32 role, address account) public virtual override {
        if (hasRole(ADMIN_ROLE, msg.sender)) {
            revert("Admin cant use renounceRole");
        }
        require(account == _msgSender(), "can only renounce roles for self");

        _revokeRole(role, account);
    }

    function setMinter(address newMinter) public onlyAdmin {
        address oldMinter = _addressMinter;
        require(oldMinter != newMinter, "New minter must be different");
        _grantRole(MINTER_ROLE, newMinter);
        _revokeRole(MINTER_ROLE, oldMinter);
        _addressMinter = newMinter;
    }

    function getAddressMinter() public view returns (address) {
        return _addressMinter;
    }

    function _requireAdmin() internal view {
        require(hasRole(ADMIN_ROLE, msg.sender), "Caller is not admin");
    }
}


// File contracts/LvUSDToken.sol

pragma solidity 0.8.17;


/// @title lvUSD token
/// @dev This is the contract for the Archimedes lvUSD USD pegged stablecoin
contract LvUSDToken is ERC20("lvUSD", "lvUSD"), BasicAccessController, ERC20Burnable {
    address internal _mintingDestination = address(0);

    constructor() {
        _grantRole(ADMIN_ROLE, _msgSender());
        setMinter(_msgSender());
    }

    /// @dev Mints tokens to a recipient.
    ///
    /// This function reverts if the caller does not have the minter role.
    ///
    /// @param amount the amount of tokens to mint.
    function mint(uint256 amount) external onlyMinter {
        // Only minter can mint
        _mint(_mintingDestination, amount);
    }

    /// @dev change mint address
    /// @param mintDestination new mint destination
    function setMintDestination(address mintDestination) external onlyAdmin {
        _mintingDestination = mintDestination;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptAdminRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAddressMinter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"mintDestination","type":"address"}],"name":"setMintDestination","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMinter","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

50229:813:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23788:204;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;23788:204:0;;;;;;;;35229:100;;;:::i;:::-;;;;;;;:::i;37580:201::-;;;;;;:::i;:::-;;:::i;36349:108::-;36437:12;;36349:108;;;1736:25:1;;;1724:2;1709:18;36349:108:0;1590:177:1;38361:295:0;;;;;;:::i;:::-;;:::i;25611:131::-;;;;;;:::i;:::-;25685:7;25712:12;;;;;;;;;;:22;;;;25611:131;49826:98;49902:14;;49826:98;;-1:-1:-1;;;;;49902:14:0;;;2618:51:1;;2606:2;2591:18;49826:98:0;2472:203:1;26052:147:0;;;;;;:::i;:::-;;:::i;:::-;;36191:93;;;36274:2;3081:36:1;;3069:2;3054:18;36191:93:0;2939:184:1;49186:314:0;;;;;;:::i;:::-;;:::i;39065:238::-;;;;;;:::i;:::-;;:::i;47004:91::-;;;;;;:::i;:::-;;:::i;48521:237::-;;;;;;:::i;:::-;;:::i;36520:127::-;;;;;;:::i;:::-;-1:-1:-1;;;;;36621:18:0;36594:7;36621:18;;;:9;:18;;;;;;;36520:127;47725:60;;-1:-1:-1;;;;;;;;;;;47725:60:0;;47414:164;;;;;;:::i;:::-;;:::i;48766:412::-;;;:::i;24084:147::-;;;;;;:::i;:::-;;:::i;35448:104::-;;;:::i;50680:136::-;;;;;;:::i;:::-;;:::i;23189:49::-;;23234:4;23189:49;;39806:436;;;;;;:::i;:::-;;:::i;36853:193::-;;;;;;:::i;:::-;;:::i;50911:128::-;;;;;;:::i;:::-;;:::i;47792:62::-;;-1:-1:-1;;;;;;;;;;;47792:62:0;;26492:149;;;;;;:::i;:::-;;:::i;37109:151::-;;;;;;:::i;:::-;;:::i;49508:310::-;;;;;;:::i;:::-;;:::i;23788:204::-;23873:4;-1:-1:-1;;;;;;23897:47:0;;-1:-1:-1;;;23897:47:0;;:87;;-1:-1:-1;;;;;;;;;;5943:40:0;;;23948:36;23890:94;23788:204;-1:-1:-1;;23788:204:0:o;35229:100::-;35283:13;35316:5;35309:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35229:100;:::o;37580:201::-;37663:4;3908:10;37719:32;3908:10;37735:7;37744:6;37719:8;:32::i;:::-;-1:-1:-1;37769:4:0;;37580:201;-1:-1:-1;;;37580:201:0:o;38361:295::-;38492:4;3908:10;38550:38;38566:4;3908:10;38581:6;38550:15;:38::i;:::-;38599:27;38609:4;38615:2;38619:6;38599:9;:27::i;:::-;-1:-1:-1;38644:4:0;;38361:295;-1:-1:-1;;;;38361:295:0:o;26052:147::-;25685:7;25712:12;;;;;;;;;;:22;;;23680:16;23691:4;23680:10;:16::i;:::-;26166:25:::1;26177:4;26183:7;26166:10;:25::i;:::-;26052:147:::0;;;:::o;49186:314::-;49278:31;-1:-1:-1;;;;;;;;;;;49298:10:0;49278:7;:31::i;:::-;49274:101;;;49326:37;;-1:-1:-1;;;49326:37:0;;4356:2:1;49326:37:0;;;4338:21:1;4395:2;4375:18;;;4368:30;4434:29;4414:18;;;4407:57;4481:18;;49326:37:0;;;;;;;;49274:101;-1:-1:-1;;;;;49393:23:0;;3908:10;49393:23;49385:68;;;;-1:-1:-1;;;49385:68:0;;4712:2:1;49385:68:0;;;4694:21:1;;;4731:18;;;4724:30;4790:34;4770:18;;;4763:62;4842:18;;49385:68:0;4510:356:1;49385:68:0;49466:26;49478:4;49484:7;49466:11;:26::i;:::-;49186:314;;:::o;39065:238::-;39153:4;3908:10;39209:64;3908:10;39225:7;39262:10;39234:25;3908:10;39225:7;39234:9;:25::i;:::-;:38;;;;:::i;:::-;39209:8;:64::i;47004:91::-;47060:27;3908:10;47080:6;47060:5;:27::i;:::-;47004:91;:::o;48521:237::-;48312:31;-1:-1:-1;;;;;;;;;;;48332:10:0;48312:7;:31::i;:::-;48304:63;;;;-1:-1:-1;;;48304:63:0;;;;;;;:::i;:::-;3908:10;-1:-1:-1;;;;;48589:24:0;::::1;::::0;48585:94:::1;;48630:37;::::0;-1:-1:-1;;;48630:37:0;;5683:2:1;48630:37:0::1;::::0;::::1;5665:21:1::0;5722:2;5702:18;;;5695:30;5761:29;5741:18;;;5734:57;5808:18;;48630:37:0::1;5481:351:1::0;48585:94:0::1;48689:15;:26:::0;;-1:-1:-1;;;;;48689:26:0;;;::::1;-1:-1:-1::0;;;;;;48689:26:0;;::::1;;::::0;;48726:9:::1;:24:::0;;;;::::1;3908:10:::0;48726:24:::1;::::0;;48521:237::o;47414:164::-;47491:46;47507:7;3908:10;47530:6;47491:15;:46::i;:::-;47548:22;47554:7;47563:6;47548:5;:22::i;48766:412::-;48817:15;;-1:-1:-1;;;;;48817:15:0;:29;;:56;;-1:-1:-1;48850:9:0;;-1:-1:-1;;;;;48850:9:0;:23;48817:56;48813:117;;;48890:28;;-1:-1:-1;;;48890:28:0;;6039:2:1;48890:28:0;;;6021:21:1;6078:2;6058:18;;;6051:30;-1:-1:-1;;;6097:18:1;;;6090:48;6155:18;;48890:28:0;5837:342:1;48813:117:0;48944:15;;3908:10;-1:-1:-1;;;;;48944:15:0;;;:31;48940:231;;48992:36;-1:-1:-1;;;;;;;;;;;3908:10:0;48992;:36::i;:::-;49067:9;;49043:34;;-1:-1:-1;;;;;;;;;;;47762:23:0;-1:-1:-1;;;;;49067:9:0;49043:11;:34::i;:::-;49094:15;:28;;-1:-1:-1;;;;;;49094:28:0;;;;;;49137:9;:22;;;;;;;48940:231;48766:412::o;24084:147::-;24170:4;24194:12;;;;;;;;;;;-1:-1:-1;;;;;24194:29:0;;;;;;;;;;;;;;;24084:147::o;35448:104::-;35504:13;35537:7;35530:14;;;;;:::i;50680:136::-;48436:32;-1:-1:-1;;;;;;;;;;;48457:10:0;48436:7;:32::i;:::-;48428:65;;;;-1:-1:-1;;;48428:65:0;;6386:2:1;48428:65:0;;;6368:21:1;6425:2;6405:18;;;6398:30;-1:-1:-1;;;6444:18:1;;;6437:50;6504:18;;48428:65:0;6184:344:1;48428:65:0;50780:19:::1;::::0;50774:34:::1;::::0;-1:-1:-1;;;;;50780:19:0::1;50801:6:::0;50774:5:::1;:34::i;39806:436::-:0;39899:4;3908:10;39899:4;39982:25;3908:10;39999:7;39982:9;:25::i;:::-;39955:52;;40046:15;40026:16;:35;;40018:85;;;;-1:-1:-1;;;40018:85:0;;6735:2:1;40018:85:0;;;6717:21:1;6774:2;6754:18;;;6747:30;6813:34;6793:18;;;6786:62;-1:-1:-1;;;6864:18:1;;;6857:35;6909:19;;40018:85:0;6533:401:1;40018:85:0;40139:60;40148:5;40155:7;40183:15;40164:16;:34;40139:8;:60::i;36853:193::-;36932:4;3908:10;36988:28;3908:10;37005:2;37009:6;36988:9;:28::i;50911:128::-;48312:31;-1:-1:-1;;;;;;;;;;;48332:10:0;48312:7;:31::i;:::-;48304:63;;;;-1:-1:-1;;;48304:63:0;;;;;;;:::i;:::-;50994:19:::1;:37:::0;;-1:-1:-1;;;;;;50994:37:0::1;-1:-1:-1::0;;;;;50994:37:0;;;::::1;::::0;;;::::1;::::0;;50911:128::o;26492:149::-;25685:7;25712:12;;;;;;;;;;:22;;;23680:16;23691:4;23680:10;:16::i;:::-;26607:26:::1;26619:4;26625:7;26607:11;:26::i;37109:151::-:0;-1:-1:-1;;;;;37225:18:0;;;37198:7;37225:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;37109:151::o;49508:310::-;48312:31;-1:-1:-1;;;;;;;;;;;48332:10:0;48312:7;:31::i;:::-;48304:63;;;;-1:-1:-1;;;48304:63:0;;;;;;;:::i;:::-;49594:14:::1;::::0;-1:-1:-1;;;;;49594:14:0;;::::1;::::0;49627:22;::::1;::::0;;49619:63:::1;;;::::0;-1:-1:-1;;;49619:63:0;;7141:2:1;49619:63:0::1;::::0;::::1;7123:21:1::0;7180:2;7160:18;;;7153:30;7219;7199:18;;;7192:58;7267:18;;49619:63:0::1;6939:352:1::0;49619:63:0::1;49693:34;-1:-1:-1::0;;;;;;;;;;;49717:9:0::1;49693:10;:34::i;:::-;49738:35;-1:-1:-1::0;;;;;;;;;;;49763:9:0::1;49738:11;:35::i;:::-;-1:-1:-1::0;49784:14:0::1;:26:::0;;-1:-1:-1;;;;;;49784:26:0::1;-1:-1:-1::0;;;;;49784:26:0;;;::::1;::::0;;;::::1;::::0;;49508:310::o;43833:380::-;-1:-1:-1;;;;;43969:19:0;;43961:68;;;;-1:-1:-1;;;43961:68:0;;7498:2:1;43961:68:0;;;7480:21:1;7537:2;7517:18;;;7510:30;7576:34;7556:18;;;7549:62;-1:-1:-1;;;7627:18:1;;;7620:34;7671:19;;43961:68:0;7296:400:1;43961:68:0;-1:-1:-1;;;;;44048:21:0;;44040:68;;;;-1:-1:-1;;;44040:68:0;;7903:2:1;44040:68:0;;;7885:21:1;7942:2;7922:18;;;7915:30;7981:34;7961:18;;;7954:62;-1:-1:-1;;;8032:18:1;;;8025:32;8074:19;;44040:68:0;7701:398:1;44040:68:0;-1:-1:-1;;;;;44121:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;44173:32;;1736:25:1;;;44173:32:0;;1709:18:1;44173:32:0;;;;;;;43833:380;;;:::o;44504:453::-;44639:24;44666:25;44676:5;44683:7;44666:9;:25::i;:::-;44639:52;;-1:-1:-1;;44706:16:0;:37;44702:248;;44788:6;44768:16;:26;;44760:68;;;;-1:-1:-1;;;44760:68:0;;8306:2:1;44760:68:0;;;8288:21:1;8345:2;8325:18;;;8318:30;8384:31;8364:18;;;8357:59;8433:18;;44760:68:0;8104:353:1;44760:68:0;44872:51;44881:5;44888:7;44916:6;44897:16;:25;44872:8;:51::i;:::-;44628:329;44504:453;;;:::o;40712:840::-;-1:-1:-1;;;;;40843:18:0;;40835:68;;;;-1:-1:-1;;;40835:68:0;;8664:2:1;40835:68:0;;;8646:21:1;8703:2;8683:18;;;8676:30;8742:34;8722:18;;;8715:62;-1:-1:-1;;;8793:18:1;;;8786:35;8838:19;;40835:68:0;8462:401:1;40835:68:0;-1:-1:-1;;;;;40922:16:0;;40914:64;;;;-1:-1:-1;;;40914:64:0;;9070:2:1;40914:64:0;;;9052:21:1;9109:2;9089:18;;;9082:30;9148:34;9128:18;;;9121:62;-1:-1:-1;;;9199:18:1;;;9192:33;9242:19;;40914:64:0;8868:399:1;40914:64:0;-1:-1:-1;;;;;41064:15:0;;41042:19;41064:15;;;:9;:15;;;;;;41098:21;;;;41090:72;;;;-1:-1:-1;;;41090:72:0;;9474:2:1;41090:72:0;;;9456:21:1;9513:2;9493:18;;;9486:30;9552:34;9532:18;;;9525:62;-1:-1:-1;;;9603:18:1;;;9596:36;9649:19;;41090:72:0;9272:402:1;41090:72:0;-1:-1:-1;;;;;41198:15:0;;;;;;;:9;:15;;;;;;41216:20;;;41198:38;;41416:13;;;;;;;;;;:23;;;;;;41468:26;;;;;;41230:6;1736:25:1;;1724:2;1709:18;;1590:177;41468:26:0;;;;;;;;41507:37;26052:147;24535:105;24602:30;24613:4;3908:10;24602;:30::i;28793:238::-;28877:22;28885:4;28891:7;28877;:22::i;:::-;28872:152;;28916:6;:12;;;;;;;;;;;-1:-1:-1;;;;;28916:29:0;;;;;;;;;:36;;-1:-1:-1;;28916:36:0;28948:4;28916:36;;;28999:12;3908:10;;3828:98;28999:12;-1:-1:-1;;;;;28972:40:0;28990:7;-1:-1:-1;;;;;28972:40:0;28984:4;28972:40;;;;;;;;;;28793:238;;:::o;29211:239::-;29295:22;29303:4;29309:7;29295;:22::i;:::-;29291:152;;;29366:5;29334:12;;;;;;;;;;;-1:-1:-1;;;;;29334:29:0;;;;;;;;;;:37;;-1:-1:-1;;29334:37:0;;;29391:40;3908:10;;29334:12;;29391:40;;29366:5;29391:40;29211:239;;:::o;42720:675::-;-1:-1:-1;;;;;42804:21:0;;42796:67;;;;-1:-1:-1;;;42796:67:0;;9881:2:1;42796:67:0;;;9863:21:1;9920:2;9900:18;;;9893:30;9959:34;9939:18;;;9932:62;-1:-1:-1;;;10010:18:1;;;10003:31;10051:19;;42796:67:0;9679:397:1;42796:67:0;-1:-1:-1;;;;;42963:18:0;;42938:22;42963:18;;;:9;:18;;;;;;43000:24;;;;42992:71;;;;-1:-1:-1;;;42992:71:0;;10283:2:1;42992:71:0;;;10265:21:1;10322:2;10302:18;;;10295:30;10361:34;10341:18;;;10334:62;-1:-1:-1;;;10412:18:1;;;10405:32;10454:19;;42992:71:0;10081:398:1;42992:71:0;-1:-1:-1;;;;;43099:18:0;;;;;;:9;:18;;;;;;;;43120:23;;;43099:44;;43238:12;:22;;;;;;;43289:37;1736:25:1;;;43099:18:0;;;43289:37;;1709:18:1;43289:37:0;;;;;;;26052:147;;;:::o;41839:548::-;-1:-1:-1;;;;;41923:21:0;;41915:65;;;;-1:-1:-1;;;41915:65:0;;10686:2:1;41915:65:0;;;10668:21:1;10725:2;10705:18;;;10698:30;10764:33;10744:18;;;10737:61;10815:18;;41915:65:0;10484:355:1;41915:65:0;42071:6;42055:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;42226:18:0;;;;;;:9;:18;;;;;;;;:28;;;;;;42281:37;1736:25:1;;;42281:37:0;;1709:18:1;42281:37:0;;;;;;;49186:314;;:::o;24930:492::-;25019:22;25027:4;25033:7;25019;:22::i;:::-;25014:401;;25207:28;25227:7;25207:19;:28::i;:::-;25308:38;25336:4;25343:2;25308:19;:38::i;:::-;25112:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;25112:257:0;;;;;;;;;;-1:-1:-1;;;25058:345:0;;;;;;;:::i;21049:151::-;21107:13;21140:52;-1:-1:-1;;;;;21152:22:0;;19204:2;20445:447;20520:13;20546:19;20578:10;20582:6;20578:1;:10;:::i;:::-;:14;;20591:1;20578:14;:::i;:::-;20568:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20568:25:0;;20546:47;;-1:-1:-1;;;20604:6:0;20611:1;20604:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;20604:15:0;;;;;;;;;-1:-1:-1;;;20630:6:0;20637:1;20630:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;20630:15:0;;;;;;;;-1:-1:-1;20661:9:0;20673:10;20677:6;20673:1;:10;:::i;:::-;:14;;20686:1;20673:14;:::i;:::-;20661:26;;20656:131;20693:1;20689;:5;20656:131;;;-1:-1:-1;;;20737:5:0;20745:3;20737:11;20728:21;;;;;;;:::i;:::-;;;;20716:6;20723:1;20716:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;20716:33:0;;;;;;;;-1:-1:-1;20774:1:0;20764:11;;;;;20696:3;;;:::i;:::-;;;20656:131;;;-1:-1:-1;20805:10:0;;20797:55;;;;-1:-1:-1;;;20797:55:0;;12441:2:1;20797:55:0;;;12423:21:1;;;12460:18;;;12453:30;12519:34;12499:18;;;12492:62;12571:18;;20797:55:0;12239:356:1;20797:55:0;20877:6;20445:447;-1:-1:-1;;;20445:447:0:o;14:286:1:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;497:250;582:1;592:113;606:6;603:1;600:13;592:113;;;682:11;;;676:18;663:11;;;656:39;628:2;621:10;592:113;;;-1:-1:-1;;739:1:1;721:16;;714:27;497:250::o;752:396::-;901:2;890:9;883:21;864:4;933:6;927:13;976:6;971:2;960:9;956:18;949:34;992:79;1064:6;1059:2;1048:9;1044:18;1039:2;1031:6;1027:15;992:79;:::i;:::-;1132:2;1111:15;-1:-1:-1;;1107:29:1;1092:45;;;;1139:2;1088:54;;752:396;-1:-1:-1;;752:396:1:o;1153:173::-;1221:20;;-1:-1:-1;;;;;1270:31:1;;1260:42;;1250:70;;1316:1;1313;1306:12;1250:70;1153:173;;;:::o;1331:254::-;1399:6;1407;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;1499:29;1518:9;1499:29;:::i;:::-;1489:39;1575:2;1560:18;;;;1547:32;;-1:-1:-1;;;1331:254:1:o;1772:328::-;1849:6;1857;1865;1918:2;1906:9;1897:7;1893:23;1889:32;1886:52;;;1934:1;1931;1924:12;1886:52;1957:29;1976:9;1957:29;:::i;:::-;1947:39;;2005:38;2039:2;2028:9;2024:18;2005:38;:::i;:::-;1995:48;;2090:2;2079:9;2075:18;2062:32;2052:42;;1772:328;;;;;:::o;2105:180::-;2164:6;2217:2;2205:9;2196:7;2192:23;2188:32;2185:52;;;2233:1;2230;2223:12;2185:52;-1:-1:-1;2256:23:1;;2105:180;-1:-1:-1;2105:180:1:o;2680:254::-;2748:6;2756;2809:2;2797:9;2788:7;2784:23;2780:32;2777:52;;;2825:1;2822;2815:12;2777:52;2861:9;2848:23;2838:33;;2890:38;2924:2;2913:9;2909:18;2890:38;:::i;:::-;2880:48;;2680:254;;;;;:::o;3313:186::-;3372:6;3425:2;3413:9;3404:7;3400:23;3396:32;3393:52;;;3441:1;3438;3431:12;3393:52;3464:29;3483:9;3464:29;:::i;3504:260::-;3572:6;3580;3633:2;3621:9;3612:7;3608:23;3604:32;3601:52;;;3649:1;3646;3639:12;3601:52;3672:29;3691:9;3672:29;:::i;:::-;3662:39;;3720:38;3754:2;3743:9;3739:18;3720:38;:::i;3769:380::-;3848:1;3844:12;;;;3891;;;3912:61;;3966:4;3958:6;3954:17;3944:27;;3912:61;4019:2;4011:6;4008:14;3988:18;3985:38;3982:161;;4065:10;4060:3;4056:20;4053:1;4046:31;4100:4;4097:1;4090:15;4128:4;4125:1;4118:15;3982:161;;3769:380;;;:::o;4871:127::-;4932:10;4927:3;4923:20;4920:1;4913:31;4963:4;4960:1;4953:15;4987:4;4984:1;4977:15;5003:125;5068:9;;;5089:10;;;5086:36;;;5102:18;;:::i;5133:343::-;5335:2;5317:21;;;5374:2;5354:18;;;5347:30;-1:-1:-1;;;5408:2:1;5393:18;;5386:49;5467:2;5452:18;;5133:343::o;10844:812::-;11255:25;11250:3;11243:38;11225:3;11310:6;11304:13;11326:75;11394:6;11389:2;11384:3;11380:12;11373:4;11365:6;11361:17;11326:75;:::i;:::-;-1:-1:-1;;;11460:2:1;11420:16;;;11452:11;;;11445:40;11510:13;;11532:76;11510:13;11594:2;11586:11;;11579:4;11567:17;;11532:76;:::i;:::-;11628:17;11647:2;11624:26;;10844:812;-1:-1:-1;;;;10844:812:1:o;11661:168::-;11734:9;;;11765;;11782:15;;;11776:22;;11762:37;11752:71;;11803:18;;:::i;11834:127::-;11895:10;11890:3;11886:20;11883:1;11876:31;11926:4;11923:1;11916:15;11950:4;11947:1;11940:15;11966:127;12027:10;12022:3;12018:20;12015:1;12008:31;12058:4;12055:1;12048:15;12082:4;12079:1;12072:15;12098:136;12137:3;12165:5;12155:39;;12174:18;;:::i;:::-;-1:-1:-1;;;12210:18:1;;12098:136::o

ipfs://69d7ae8e23bff51cf1aa5df11d4ad5c2378858feab56ef8de86399692b987719