Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC20.sol";

contract XELS_ERC20_Token is ERC20 {
    constructor(uint256 initialSupply) ERC20("Xels Token", "XELS") {
        _maxTokenCountSet(initialSupply);
        _mint(msg.sender, initialSupply);

    }

    function BurnToken(address account, uint256 amount) public virtual returns (bool) {
        _burn(account, amount);
        return true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

/**
 * @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, _msgSender());
        _;
    }

    /**
     * @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 override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @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 {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " 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 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.
     */
    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.
     */
    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`.
     */
    // 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.
     *
     * [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.
     */
    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.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IAccessControlEnumerable.sol";
import "./AccessControl.sol";
import "./EnumerableSet.sol";

/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {grantRole} to track enumerable memberships
     */
    function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
        super.grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {revokeRole} to track enumerable memberships
     */
    function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
        require(account != _msgSender(), "ERC20: caller can not revoke own address.");
        super.revokeRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @dev Overload {renounceRole} to track enumerable memberships
     */
    // function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
    //     super.renounceRole(role, account);
    //     _roleMembers[role].remove(account);
    // }

    /**
     * @dev Overload {_setupRole} to track enumerable memberships
     */
    function _setupRole(bytes32 role, address account) internal virtual override {
        super._setupRole(role, account);
        _roleMembers[role].add(account);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
    
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./AccessControlEnumerable.sol";
import "./Context.sol";
import "./Pausable.sol";

/**
 * @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.zeppelin.solutions/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, AccessControlEnumerable, IERC20, IERC20Metadata, Pausable {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint256 public MAX_TOKEN_COUNT;

    /**
     * @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_;
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
    }

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

    function pausedOptions() public virtual returns (bool) {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ERC20: must have admin role");
        _pause();
        return true;
    }

    function unPausedOptions() public virtual returns (bool) {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ERC20: must have admin role");
        _unpause();
        return true;
    }
    /**
     * @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];
    }

    function _maxTokenCountSet(uint256  maxValue) internal virtual {
        MAX_TOKEN_COUNT = maxValue;
    }
    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        require(
            recipient != _msgSender(),
            "ERC20: caller and recipient must be different address."
        );
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        require(recipient != _msgSender(), "ERC20: caller and recipient must be different address.");

        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ERC20: must have admin role");
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ERC20: must have admin role");
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount 
    ) internal virtual {
        require(!paused(), "ERC20: transfer function is paused by admin.");
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ERC20: must have admin role");
        require(account != address(0), "ERC20: mint to the zero address");
        uint256 tokenCount = _totalSupply + amount;
        require (tokenCount <= MAX_TOKEN_COUNT,"TOKEN Max limit exist!");
        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _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");
        require(account == _msgSender(), "ERC20: caller and address must be same.");

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _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 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 {}

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";
import "./Context.sol";

/**
 * @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 {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";

/**
 * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
 */
abstract contract ERC20Capped is ERC20 {
    uint256 private immutable _cap;

    /**
     * @dev Sets the value of the `cap`. This value is immutable, it can only be
     * set once during construction.
     */
    constructor(uint256 cap_) {
        require(cap_ > 0, "ERC20Capped: cap is 0");
        _cap = cap_;
    }

    /**
     * @dev Returns the cap on the token's total supply.
     */
    function cap() public view virtual returns (uint256) {
        return _cap;
    }

    /**
     * @dev See {ERC20-_mint}.
     */
    function _mint(address account, uint256 amount) internal virtual override {
        require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
        super._mint(account, amount);
    }
}

// SPDX-License-Identifier: MIT

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;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IAccessControl.sol";

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);
    
    /**
     * @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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./Address.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));
        }
    }

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"}],"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"BurnToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKEN_COUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"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":[{"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":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pausedOptions","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unPausedOptions","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000775f05a074000

-----Decoded View---------------
Arg [0] : initialSupply (uint256): 2100000000000000

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000775f05a074000

85:357:19:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;553:214:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2317:100:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5145:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3846:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5796:597;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3996:123:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1911:196:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3279:92:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6802:307;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3379:196;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1034:84:16;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4017:127:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1366:145:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2881:139:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2536:104:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1972:49:0;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7612:505:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4471:315;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3583:200;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1685:134:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1725:30:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2200:289:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4847:151:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;294:145:19;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;553:214:1;638:4;677:42;662:57;;;:11;:57;;;;:97;;;;723:36;747:11;723:23;:36::i;:::-;662:97;655:104;;553:214;;;:::o;2317:100:6:-;2371:13;2404:5;2397:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2317:100;:::o;5145:169::-;5228:4;5245:39;5254:12;:10;:12::i;:::-;5268:7;5277:6;5245:8;:39::i;:::-;5302:4;5295:11;;5145:169;;;;:::o;3846:108::-;3907:7;3934:12;;3927:19;;3846:108;:::o;5796:597::-;5936:4;5974:12;:10;:12::i;:::-;5961:25;;:9;:25;;;;5953:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;6058:36;6068:6;6076:9;6087:6;6058:9;:36::i;:::-;6107:24;6134:11;:19;6146:6;6134:19;;;;;;;;;;;;;;;:33;6154:12;:10;:12::i;:::-;6134:33;;;;;;;;;;;;;;;;6107:60;;6206:6;6186:16;:26;;6178:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;6293:57;6302:6;6310:12;:10;:12::i;:::-;6343:6;6324:16;:25;6293:8;:57::i;:::-;6381:4;6374:11;;;5796:597;;;;;:::o;3996:123:0:-;4062:7;4089:6;:12;4096:4;4089:12;;;;;;;;;;;:22;;;4082:29;;3996:123;;;:::o;1911:196:1:-;2027:30;2043:4;2049:7;2027:15;:30::i;:::-;2068:31;2091:7;2068:12;:18;2081:4;2068:18;;;;;;;;;;;:22;;:31;;;;:::i;:::-;;1911:196;;:::o;3279:92:6:-;3337:5;3362:1;3355:8;;3279:92;:::o;6802:307::-;6890:4;6915:41;2017:4:0;6923:18:6;;6943:12;:10;:12::i;:::-;6915:7;:41::i;:::-;6907:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;6999:80;7008:12;:10;:12::i;:::-;7022:7;7068:10;7031:11;:25;7043:12;:10;:12::i;:::-;7031:25;;;;;;;;;;;;;;;:34;7057:7;7031:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;6999:8;:80::i;:::-;7097:4;7090:11;;6802:307;;;;:::o;3379:196::-;3428:4;3453:41;2017:4:0;3461:18:6;;3481:12;:10;:12::i;:::-;3453:7;:41::i;:::-;3445:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;3537:8;:6;:8::i;:::-;3563:4;3556:11;;3379:196;:::o;1034:84:16:-;1081:4;1104:7;;;;;;;;;;;1097:14;;1034:84;:::o;4017:127:6:-;4091:7;4118:9;:18;4128:7;4118:18;;;;;;;;;;;;;;;;4111:25;;4017:127;;;:::o;1366:145:1:-;1448:7;1475:28;1497:5;1475:12;:18;1488:4;1475:18;;;;;;;;;;;:21;;:28;;;;:::i;:::-;1468:35;;1366:145;;;;:::o;2881:139:0:-;2959:4;2983:6;:12;2990:4;2983:12;;;;;;;;;;;:20;;:29;3004:7;2983:29;;;;;;;;;;;;;;;;;;;;;;;;;2976:36;;2881:139;;;;:::o;2536:104:6:-;2592:13;2625:7;2618:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2536:104;:::o;1972:49:0:-;2017:4;1972:49;;;:::o;7612:505:6:-;7705:4;7730:41;2017:4:0;7738:18:6;;7758:12;:10;:12::i;:::-;7730:7;:41::i;:::-;7722:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;7814:24;7841:11;:25;7853:12;:10;:12::i;:::-;7841:25;;;;;;;;;;;;;;;:34;7867:7;7841:34;;;;;;;;;;;;;;;;7814:61;;7914:15;7894:16;:35;;7886:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;8007:67;8016:12;:10;:12::i;:::-;8030:7;8058:15;8039:16;:34;8007:8;:67::i;:::-;8105:4;8098:11;;;7612:505;;;;:::o;4471:315::-;4557:4;4609:12;:10;:12::i;:::-;4596:25;;:9;:25;;;;4574:129;;;;;;;;;;;;:::i;:::-;;;;;;;;;4714:42;4724:12;:10;:12::i;:::-;4738:9;4749:6;4714:9;:42::i;:::-;4774:4;4767:11;;4471:315;;;;:::o;3583:200::-;3634:4;3659:41;2017:4:0;3667:18:6;;3687:12;:10;:12::i;:::-;3659:7;:41::i;:::-;3651:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;3743:10;:8;:10::i;:::-;3771:4;3764:11;;3583:200;:::o;1685:134:1:-;1757:7;1784:27;:12;:18;1797:4;1784:18;;;;;;;;;;;:25;:27::i;:::-;1777:34;;1685:134;;;:::o;1725:30:6:-;;;;:::o;2200:289:1:-;2336:12;:10;:12::i;:::-;2325:23;;:7;:23;;;;2317:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;2405:31;2422:4;2428:7;2405:16;:31::i;:::-;2447:34;2473:7;2447:12;:18;2460:4;2447:18;;;;;;;;;;;:25;;:34;;;;:::i;:::-;;2200:289;;:::o;4847:151:6:-;4936:7;4963:11;:18;4975:5;4963:18;;;;;;;;;;;;;;;:27;4982:7;4963:27;;;;;;;;;;;;;;;;4956:34;;4847:151;;;;:::o;294:145:19:-;370:4;387:22;393:7;402:6;387:5;:22::i;:::-;427:4;420:11;;294:145;;;;:::o;6318:112:0:-;6397:25;6408:4;6414:7;6397:10;:25::i;:::-;6318:112;;:::o;7767:152:9:-;7837:4;7861:50;7866:3;:10;;7902:5;7886:23;;7878:32;;7861:4;:50::i;:::-;7854:57;;7767:152;;;;:::o;2585:204:0:-;2670:4;2709:32;2694:47;;;:11;:47;;;;:87;;;;2745:36;2769:11;2745:23;:36::i;:::-;2694:87;2687:94;;2585:204;;;:::o;602:98:3:-;655:7;682:10;675:17;;602:98;:::o;11768:380:6:-;11921:1;11904:19;;:5;:19;;;;11896:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12002:1;11983:21;;:7;:21;;;;11975:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12086:6;12056:11;:18;12068:5;12056:18;;;;;;;;;;;;;;;:27;12075:7;12056:27;;;;;;;;;;;;;;;:36;;;;12124:7;12108:32;;12117:5;12108:32;;;12133:6;12108:32;;;;;;:::i;:::-;;;;;;;;11768:380;;;:::o;8607:809::-;8749:8;:6;:8::i;:::-;8748:9;8740:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;8843:1;8825:20;;:6;:20;;;;8817:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;8927:1;8906:23;;:9;:23;;;;8898:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;8980:47;9001:6;9009:9;9020:6;8980:20;:47::i;:::-;9040:21;9064:9;:17;9074:6;9064:17;;;;;;;;;;;;;;;;9040:41;;9117:6;9100:13;:23;;9092:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;9238:6;9222:13;:22;9202:9;:17;9212:6;9202:17;;;;;;;;;;;;;;;:42;;;;9290:6;9266:9;:20;9276:9;9266:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;9331:9;9314:35;;9323:6;9314:35;;;9342:6;9314:35;;;;;;:::i;:::-;;;;;;;;9362:46;9382:6;9390:9;9401:6;9362:19;:46::i;:::-;8729:687;8607:809;;;:::o;4381:147:0:-;4464:18;4477:4;4464:12;:18::i;:::-;2463:30;2474:4;2480:12;:10;:12::i;:::-;2463:10;:30::i;:::-;4495:25:::1;4506:4;4512:7;4495:10;:25::i;:::-;4381:147:::0;;;:::o;1799:115:16:-;1348:8;:6;:8::i;:::-;1347:9;1339:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;1868:4:::1;1858:7;;:14;;;;;;;;;;;;;;;;;;1887:20;1894:12;:10;:12::i;:::-;1887:20;;;;;;:::i;:::-;;;;;;;;1799:115::o:0;9063:158:9:-;9137:7;9188:22;9192:3;:10;;9204:5;9188:3;:22::i;:::-;9180:31;;9157:56;;9063:158;;;;:::o;2046:117:16:-;1613:8;:6;:8::i;:::-;1605:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;2114:5:::1;2104:7;;:15;;;;;;;;;;;;;;;;;;2134:22;2143:12;:10;:12::i;:::-;2134:22;;;;;;:::i;:::-;;;;;;;;2046:117::o:0;8592::9:-;8655:7;8682:19;8690:3;:10;;8682:7;:19::i;:::-;8675:26;;8592:117;;;:::o;4773:149:0:-;4857:18;4870:4;4857:12;:18::i;:::-;2463:30;2474:4;2480:12;:10;:12::i;:::-;2463:10;:30::i;:::-;4888:26:::1;4900:4;4906:7;4888:11;:26::i;:::-;4773:149:::0;;;:::o;8095:158:9:-;8168:4;8192:53;8200:3;:10;;8236:5;8220:23;;8212:32;;8192:7;:53::i;:::-;8185:60;;8095:158;;;;:::o;10653:677:6:-;10756:1;10737:21;;:7;:21;;;;10729:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;10826:12;:10;:12::i;:::-;10815:23;;:7;:23;;;10807:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;10895:49;10916:7;10933:1;10937:6;10895:20;:49::i;:::-;10957:22;10982:9;:18;10992:7;10982:18;;;;;;;;;;;;;;;;10957:43;;11037:6;11019:14;:24;;11011:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;11156:6;11139:14;:23;11118:9;:18;11128:7;11118:18;;;;;;;;;;;;;;;:44;;;;11200:6;11184:12;;:22;;;;;;;:::i;:::-;;;;;;;;11250:1;11224:37;;11233:7;11224:37;;;11254:6;11224:37;;;;;;:::i;:::-;;;;;;;;11274:48;11294:7;11311:1;11315:6;11274:19;:48::i;:::-;10718:612;10653:677;;:::o;6942:238:0:-;7026:22;7034:4;7040:7;7026;:22::i;:::-;7021:152;;7097:4;7065:6;:12;7072:4;7065:12;;;;;;;;;;;:20;;:29;7086:7;7065:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;7148:12;:10;:12::i;:::-;7121:40;;7139:7;7121:40;;7133:4;7121:40;;;;;;;;;;7021:152;6942:238;;:::o;1682:414:9:-;1745:4;1767:21;1777:3;1782:5;1767:9;:21::i;:::-;1762:327;;1805:3;:11;;1822:5;1805:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1988:3;:11;;:18;;;;1966:3;:12;;:19;1979:5;1966:19;;;;;;;;;;;:40;;;;2028:4;2021:11;;;;1762:327;2072:5;2065:12;;1682:414;;;;;:::o;787:157:5:-;872:4;911:25;896:40;;;:11;:40;;;;889:47;;787:157;;;:::o;12748:125:6:-;;;;:::o;13477:124::-;;;;:::o;3310:497:0:-;3391:22;3399:4;3405:7;3391;:22::i;:::-;3386:414;;3579:41;3607:7;3579:41;;3617:2;3579:19;:41::i;:::-;3693:38;3721:4;3713:13;;3728:2;3693:19;:38::i;:::-;3484:270;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3430:358;;;;;;;;;;;:::i;:::-;;;;;;;;3386:414;3310:497;;:::o;4456:120:9:-;4523:7;4550:3;:11;;4562:5;4550:18;;;;;;;;:::i;:::-;;;;;;;;;;4543:25;;4456:120;;;;:::o;3993:109::-;4049:7;4076:3;:11;;:18;;;;4069:25;;3993:109;;;:::o;7312:239:0:-;7396:22;7404:4;7410:7;7396;:22::i;:::-;7392:152;;;7467:5;7435:6;:12;7442:4;7435:12;;;;;;;;;;;:20;;:29;7456:7;7435:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;7519:12;:10;:12::i;:::-;7492:40;;7510:7;7492:40;;7504:4;7492:40;;;;;;;;;;7392:152;7312:239;;:::o;2272:1420:9:-;2338:4;2456:18;2477:3;:12;;:19;2490:5;2477:19;;;;;;;;;;;;2456:40;;2527:1;2513:10;:15;2509:1176;;2888:21;2925:1;2912:10;:14;;;;:::i;:::-;2888:38;;2941:17;2982:1;2961:3;:11;;:18;;;;:22;;;;:::i;:::-;2941:42;;3017:13;3004:9;:26;3000:405;;3051:17;3071:3;:11;;3083:9;3071:22;;;;;;;;:::i;:::-;;;;;;;;;;3051:42;;3225:9;3196:3;:11;;3208:13;3196:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;3336:10;3310:3;:12;;:23;3323:9;3310:23;;;;;;;;;;;:36;;;;3032:373;3000:405;3486:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3581:3;:12;;:19;3594:5;3581:19;;;;;;;;;;;3574:26;;;3624:4;3617:11;;;;;;;2509:1176;3668:5;3661:12;;;2272:1420;;;;;:::o;3778:129::-;3851:4;3898:1;3875:3;:12;;:19;3888:5;3875:19;;;;;;;;;;;;:24;;3868:31;;3778:129;;;;:::o;1589:451:18:-;1664:13;1690:19;1735:1;1726:6;1722:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;1712:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1690:47;;1748:15;:6;1755:1;1748:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;1774;:6;1781:1;1774:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;1805:9;1830:1;1821:6;1817:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;1805:26;;1800:135;1837:1;1833;:5;1800:135;;;1872:12;1893:3;1885:5;:11;1872:25;;;;;;;:::i;:::-;;;;;1860:6;1867:1;1860:9;;;;;;;;:::i;:::-;;;;;:37;;;;;;;;;;;1922:1;1912:11;;;;;1840:3;;;;:::i;:::-;;;1800:135;;;;1962:1;1953:5;:10;1945:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;2025:6;2011:21;;;1589:451;;;;:::o;88:117:20:-;197:1;194;187:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:126::-;2945:7;2985:42;2978:5;2974:54;2963:65;;2908:126;;;:::o;3040:96::-;3077:7;3106:24;3124:5;3106:24;:::i;:::-;3095:35;;3040:96;;;:::o;3142:122::-;3215:24;3233:5;3215:24;:::i;:::-;3208:5;3205:35;3195:63;;3254:1;3251;3244:12;3195:63;3142:122;:::o;3270:139::-;3316:5;3354:6;3341:20;3332:29;;3370:33;3397:5;3370:33;:::i;:::-;3270:139;;;;:::o;3415:77::-;3452:7;3481:5;3470:16;;3415:77;;;:::o;3498:122::-;3571:24;3589:5;3571:24;:::i;:::-;3564:5;3561:35;3551:63;;3610:1;3607;3600:12;3551:63;3498:122;:::o;3626:139::-;3672:5;3710:6;3697:20;3688:29;;3726:33;3753:5;3726:33;:::i;:::-;3626:139;;;;:::o;3771:474::-;3839:6;3847;3896:2;3884:9;3875:7;3871:23;3867:32;3864:119;;;3902:79;;:::i;:::-;3864:119;4022:1;4047:53;4092:7;4083:6;4072:9;4068:22;4047:53;:::i;:::-;4037:63;;3993:117;4149:2;4175:53;4220:7;4211:6;4200:9;4196:22;4175:53;:::i;:::-;4165:63;;4120:118;3771:474;;;;;:::o;4251:118::-;4338:24;4356:5;4338:24;:::i;:::-;4333:3;4326:37;4251:118;;:::o;4375:222::-;4468:4;4506:2;4495:9;4491:18;4483:26;;4519:71;4587:1;4576:9;4572:17;4563:6;4519:71;:::i;:::-;4375:222;;;;:::o;4603:619::-;4680:6;4688;4696;4745:2;4733:9;4724:7;4720:23;4716:32;4713:119;;;4751:79;;:::i;:::-;4713:119;4871:1;4896:53;4941:7;4932:6;4921:9;4917:22;4896:53;:::i;:::-;4886:63;;4842:117;4998:2;5024:53;5069:7;5060:6;5049:9;5045:22;5024:53;:::i;:::-;5014:63;;4969:118;5126:2;5152:53;5197:7;5188:6;5177:9;5173:22;5152:53;:::i;:::-;5142:63;;5097:118;4603:619;;;;;:::o;5228:77::-;5265:7;5294:5;5283:16;;5228:77;;;:::o;5311:122::-;5384:24;5402:5;5384:24;:::i;:::-;5377:5;5374:35;5364:63;;5423:1;5420;5413:12;5364:63;5311:122;:::o;5439:139::-;5485:5;5523:6;5510:20;5501:29;;5539:33;5566:5;5539:33;:::i;:::-;5439:139;;;;:::o;5584:329::-;5643:6;5692:2;5680:9;5671:7;5667:23;5663:32;5660:119;;;5698:79;;:::i;:::-;5660:119;5818:1;5843:53;5888:7;5879:6;5868:9;5864:22;5843:53;:::i;:::-;5833:63;;5789:117;5584:329;;;;:::o;5919:118::-;6006:24;6024:5;6006:24;:::i;:::-;6001:3;5994:37;5919:118;;:::o;6043:222::-;6136:4;6174:2;6163:9;6159:18;6151:26;;6187:71;6255:1;6244:9;6240:17;6231:6;6187:71;:::i;:::-;6043:222;;;;:::o;6271:474::-;6339:6;6347;6396:2;6384:9;6375:7;6371:23;6367:32;6364:119;;;6402:79;;:::i;:::-;6364:119;6522:1;6547:53;6592:7;6583:6;6572:9;6568:22;6547:53;:::i;:::-;6537:63;;6493:117;6649:2;6675:53;6720:7;6711:6;6700:9;6696:22;6675:53;:::i;:::-;6665:63;;6620:118;6271:474;;;;;:::o;6751:86::-;6786:7;6826:4;6819:5;6815:16;6804:27;;6751:86;;;:::o;6843:112::-;6926:22;6942:5;6926:22;:::i;:::-;6921:3;6914:35;6843:112;;:::o;6961:214::-;7050:4;7088:2;7077:9;7073:18;7065:26;;7101:67;7165:1;7154:9;7150:17;7141:6;7101:67;:::i;:::-;6961:214;;;;:::o;7181:329::-;7240:6;7289:2;7277:9;7268:7;7264:23;7260:32;7257:119;;;7295:79;;:::i;:::-;7257:119;7415:1;7440:53;7485:7;7476:6;7465:9;7461:22;7440:53;:::i;:::-;7430:63;;7386:117;7181:329;;;;:::o;7516:474::-;7584:6;7592;7641:2;7629:9;7620:7;7616:23;7612:32;7609:119;;;7647:79;;:::i;:::-;7609:119;7767:1;7792:53;7837:7;7828:6;7817:9;7813:22;7792:53;:::i;:::-;7782:63;;7738:117;7894:2;7920:53;7965:7;7956:6;7945:9;7941:22;7920:53;:::i;:::-;7910:63;;7865:118;7516:474;;;;;:::o;7996:118::-;8083:24;8101:5;8083:24;:::i;:::-;8078:3;8071:37;7996:118;;:::o;8120:222::-;8213:4;8251:2;8240:9;8236:18;8228:26;;8264:71;8332:1;8321:9;8317:17;8308:6;8264:71;:::i;:::-;8120:222;;;;:::o;8348:474::-;8416:6;8424;8473:2;8461:9;8452:7;8448:23;8444:32;8441:119;;;8479:79;;:::i;:::-;8441:119;8599:1;8624:53;8669:7;8660:6;8649:9;8645:22;8624:53;:::i;:::-;8614:63;;8570:117;8726:2;8752:53;8797:7;8788:6;8777:9;8773:22;8752:53;:::i;:::-;8742:63;;8697:118;8348:474;;;;;:::o;8828:180::-;8876:77;8873:1;8866:88;8973:4;8970:1;8963:15;8997:4;8994:1;8987:15;9014:320;9058:6;9095:1;9089:4;9085:12;9075:22;;9142:1;9136:4;9132:12;9163:18;9153:81;;9219:4;9211:6;9207:17;9197:27;;9153:81;9281:2;9273:6;9270:14;9250:18;9247:38;9244:84;;;9300:18;;:::i;:::-;9244:84;9065:269;9014:320;;;:::o;9340:241::-;9480:34;9476:1;9468:6;9464:14;9457:58;9549:24;9544:2;9536:6;9532:15;9525:49;9340:241;:::o;9587:366::-;9729:3;9750:67;9814:2;9809:3;9750:67;:::i;:::-;9743:74;;9826:93;9915:3;9826:93;:::i;:::-;9944:2;9939:3;9935:12;9928:19;;9587:366;;;:::o;9959:419::-;10125:4;10163:2;10152:9;10148:18;10140:26;;10212:9;10206:4;10202:20;10198:1;10187:9;10183:17;10176:47;10240:131;10366:4;10240:131;:::i;:::-;10232:139;;9959:419;;;:::o;10384:227::-;10524:34;10520:1;10512:6;10508:14;10501:58;10593:10;10588:2;10580:6;10576:15;10569:35;10384:227;:::o;10617:366::-;10759:3;10780:67;10844:2;10839:3;10780:67;:::i;:::-;10773:74;;10856:93;10945:3;10856:93;:::i;:::-;10974:2;10969:3;10965:12;10958:19;;10617:366;;;:::o;10989:419::-;11155:4;11193:2;11182:9;11178:18;11170:26;;11242:9;11236:4;11232:20;11228:1;11217:9;11213:17;11206:47;11270:131;11396:4;11270:131;:::i;:::-;11262:139;;10989:419;;;:::o;11414:177::-;11554:29;11550:1;11542:6;11538:14;11531:53;11414:177;:::o;11597:366::-;11739:3;11760:67;11824:2;11819:3;11760:67;:::i;:::-;11753:74;;11836:93;11925:3;11836:93;:::i;:::-;11954:2;11949:3;11945:12;11938:19;;11597:366;;;:::o;11969:419::-;12135:4;12173:2;12162:9;12158:18;12150:26;;12222:9;12216:4;12212:20;12208:1;12197:9;12193:17;12186:47;12250:131;12376:4;12250:131;:::i;:::-;12242:139;;11969:419;;;:::o;12394:180::-;12442:77;12439:1;12432:88;12539:4;12536:1;12529:15;12563:4;12560:1;12553:15;12580:305;12620:3;12639:20;12657:1;12639:20;:::i;:::-;12634:25;;12673:20;12691:1;12673:20;:::i;:::-;12668:25;;12827:1;12759:66;12755:74;12752:1;12749:81;12746:107;;;12833:18;;:::i;:::-;12746:107;12877:1;12874;12870:9;12863:16;;12580:305;;;;:::o;12891:224::-;13031:34;13027:1;13019:6;13015:14;13008:58;13100:7;13095:2;13087:6;13083:15;13076:32;12891:224;:::o;13121:366::-;13263:3;13284:67;13348:2;13343:3;13284:67;:::i;:::-;13277:74;;13360:93;13449:3;13360:93;:::i;:::-;13478:2;13473:3;13469:12;13462:19;;13121:366;;;:::o;13493:419::-;13659:4;13697:2;13686:9;13682:18;13674:26;;13746:9;13740:4;13736:20;13732:1;13721:9;13717:17;13710:47;13774:131;13900:4;13774:131;:::i;:::-;13766:139;;13493:419;;;:::o;13918:228::-;14058:34;14054:1;14046:6;14042:14;14035:58;14127:11;14122:2;14114:6;14110:15;14103:36;13918:228;:::o;14152:366::-;14294:3;14315:67;14379:2;14374:3;14315:67;:::i;:::-;14308:74;;14391:93;14480:3;14391:93;:::i;:::-;14509:2;14504:3;14500:12;14493:19;;14152:366;;;:::o;14524:419::-;14690:4;14728:2;14717:9;14713:18;14705:26;;14777:9;14771:4;14767:20;14763:1;14752:9;14748:17;14741:47;14805:131;14931:4;14805:131;:::i;:::-;14797:139;;14524:419;;;:::o;14949:223::-;15089:34;15085:1;15077:6;15073:14;15066:58;15158:6;15153:2;15145:6;15141:15;15134:31;14949:223;:::o;15178:366::-;15320:3;15341:67;15405:2;15400:3;15341:67;:::i;:::-;15334:74;;15417:93;15506:3;15417:93;:::i;:::-;15535:2;15530:3;15526:12;15519:19;;15178:366;;;:::o;15550:419::-;15716:4;15754:2;15743:9;15739:18;15731:26;;15803:9;15797:4;15793:20;15789:1;15778:9;15774:17;15767:47;15831:131;15957:4;15831:131;:::i;:::-;15823:139;;15550:419;;;:::o;15975:221::-;16115:34;16111:1;16103:6;16099:14;16092:58;16184:4;16179:2;16171:6;16167:15;16160:29;15975:221;:::o;16202:366::-;16344:3;16365:67;16429:2;16424:3;16365:67;:::i;:::-;16358:74;;16441:93;16530:3;16441:93;:::i;:::-;16559:2;16554:3;16550:12;16543:19;;16202:366;;;:::o;16574:419::-;16740:4;16778:2;16767:9;16763:18;16755:26;;16827:9;16821:4;16817:20;16813:1;16802:9;16798:17;16791:47;16855:131;16981:4;16855:131;:::i;:::-;16847:139;;16574:419;;;:::o;16999:231::-;17139:34;17135:1;17127:6;17123:14;17116:58;17208:14;17203:2;17195:6;17191:15;17184:39;16999:231;:::o;17236:366::-;17378:3;17399:67;17463:2;17458:3;17399:67;:::i;:::-;17392:74;;17475:93;17564:3;17475:93;:::i;:::-;17593:2;17588:3;17584:12;17577:19;;17236:366;;;:::o;17608:419::-;17774:4;17812:2;17801:9;17797:18;17789:26;;17861:9;17855:4;17851:20;17847:1;17836:9;17832:17;17825:47;17889:131;18015:4;17889:131;:::i;:::-;17881:139;;17608:419;;;:::o;18033:224::-;18173:34;18169:1;18161:6;18157:14;18150:58;18242:7;18237:2;18229:6;18225:15;18218:32;18033:224;:::o;18263:366::-;18405:3;18426:67;18490:2;18485:3;18426:67;:::i;:::-;18419:74;;18502:93;18591:3;18502:93;:::i;:::-;18620:2;18615:3;18611:12;18604:19;;18263:366;;;:::o;18635:419::-;18801:4;18839:2;18828:9;18824:18;18816:26;;18888:9;18882:4;18878:20;18874:1;18863:9;18859:17;18852:47;18916:131;19042:4;18916:131;:::i;:::-;18908:139;;18635:419;;;:::o;19060:222::-;19200:34;19196:1;19188:6;19184:14;19177:58;19269:5;19264:2;19256:6;19252:15;19245:30;19060:222;:::o;19288:366::-;19430:3;19451:67;19515:2;19510:3;19451:67;:::i;:::-;19444:74;;19527:93;19616:3;19527:93;:::i;:::-;19645:2;19640:3;19636:12;19629:19;;19288:366;;;:::o;19660:419::-;19826:4;19864:2;19853:9;19849:18;19841:26;;19913:9;19907:4;19903:20;19899:1;19888:9;19884:17;19877:47;19941:131;20067:4;19941:131;:::i;:::-;19933:139;;19660:419;;;:::o;20085:225::-;20225:34;20221:1;20213:6;20209:14;20202:58;20294:8;20289:2;20281:6;20277:15;20270:33;20085:225;:::o;20316:366::-;20458:3;20479:67;20543:2;20538:3;20479:67;:::i;:::-;20472:74;;20555:93;20644:3;20555:93;:::i;:::-;20673:2;20668:3;20664:12;20657:19;;20316:366;;;:::o;20688:419::-;20854:4;20892:2;20881:9;20877:18;20869:26;;20941:9;20935:4;20931:20;20927:1;20916:9;20912:17;20905:47;20969:131;21095:4;20969:131;:::i;:::-;20961:139;;20688:419;;;:::o;21113:166::-;21253:18;21249:1;21241:6;21237:14;21230:42;21113:166;:::o;21285:366::-;21427:3;21448:67;21512:2;21507:3;21448:67;:::i;:::-;21441:74;;21524:93;21613:3;21524:93;:::i;:::-;21642:2;21637:3;21633:12;21626:19;;21285:366;;;:::o;21657:419::-;21823:4;21861:2;21850:9;21846:18;21838:26;;21910:9;21904:4;21900:20;21896:1;21885:9;21881:17;21874:47;21938:131;22064:4;21938:131;:::i;:::-;21930:139;;21657:419;;;:::o;22082:170::-;22222:22;22218:1;22210:6;22206:14;22199:46;22082:170;:::o;22258:366::-;22400:3;22421:67;22485:2;22480:3;22421:67;:::i;:::-;22414:74;;22497:93;22586:3;22497:93;:::i;:::-;22615:2;22610:3;22606:12;22599:19;;22258:366;;;:::o;22630:419::-;22796:4;22834:2;22823:9;22819:18;22811:26;;22883:9;22877:4;22873:20;22869:1;22858:9;22854:17;22847:47;22911:131;23037:4;22911:131;:::i;:::-;22903:139;;22630:419;;;:::o;23055:220::-;23195:34;23191:1;23183:6;23179:14;23172:58;23264:3;23259:2;23251:6;23247:15;23240:28;23055:220;:::o;23281:366::-;23423:3;23444:67;23508:2;23503:3;23444:67;:::i;:::-;23437:74;;23520:93;23609:3;23520:93;:::i;:::-;23638:2;23633:3;23629:12;23622:19;;23281:366;;;:::o;23653:419::-;23819:4;23857:2;23846:9;23842:18;23834:26;;23906:9;23900:4;23896:20;23892:1;23881:9;23877:17;23870:47;23934:131;24060:4;23934:131;:::i;:::-;23926:139;;23653:419;;;:::o;24078:226::-;24218:34;24214:1;24206:6;24202:14;24195:58;24287:9;24282:2;24274:6;24270:15;24263:34;24078:226;:::o;24310:366::-;24452:3;24473:67;24537:2;24532:3;24473:67;:::i;:::-;24466:74;;24549:93;24638:3;24549:93;:::i;:::-;24667:2;24662:3;24658:12;24651:19;;24310:366;;;:::o;24682:419::-;24848:4;24886:2;24875:9;24871:18;24863:26;;24935:9;24929:4;24925:20;24921:1;24910:9;24906:17;24899:47;24963:131;25089:4;24963:131;:::i;:::-;24955:139;;24682:419;;;:::o;25107:221::-;25247:34;25243:1;25235:6;25231:14;25224:58;25316:4;25311:2;25303:6;25299:15;25292:29;25107:221;:::o;25334:366::-;25476:3;25497:67;25561:2;25556:3;25497:67;:::i;:::-;25490:74;;25573:93;25662:3;25573:93;:::i;:::-;25691:2;25686:3;25682:12;25675:19;;25334:366;;;:::o;25706:419::-;25872:4;25910:2;25899:9;25895:18;25887:26;;25959:9;25953:4;25949:20;25945:1;25934:9;25930:17;25923:47;25987:131;26113:4;25987:131;:::i;:::-;25979:139;;25706:419;;;:::o;26131:191::-;26171:4;26191:20;26209:1;26191:20;:::i;:::-;26186:25;;26225:20;26243:1;26225:20;:::i;:::-;26220:25;;26264:1;26261;26258:8;26255:34;;;26269:18;;:::i;:::-;26255:34;26314:1;26311;26307:9;26299:17;;26131:191;;;;:::o;26328:148::-;26430:11;26467:3;26452:18;;26328:148;;;;:::o;26482:173::-;26622:25;26618:1;26610:6;26606:14;26599:49;26482:173;:::o;26661:402::-;26821:3;26842:85;26924:2;26919:3;26842:85;:::i;:::-;26835:92;;26936:93;27025:3;26936:93;:::i;:::-;27054:2;27049:3;27045:12;27038:19;;26661:402;;;:::o;27069:377::-;27175:3;27203:39;27236:5;27203:39;:::i;:::-;27258:89;27340:6;27335:3;27258:89;:::i;:::-;27251:96;;27356:52;27401:6;27396:3;27389:4;27382:5;27378:16;27356:52;:::i;:::-;27433:6;27428:3;27424:16;27417:23;;27179:267;27069:377;;;;:::o;27452:167::-;27592:19;27588:1;27580:6;27576:14;27569:43;27452:167;:::o;27625:402::-;27785:3;27806:85;27888:2;27883:3;27806:85;:::i;:::-;27799:92;;27900:93;27989:3;27900:93;:::i;:::-;28018:2;28013:3;28009:12;28002:19;;27625:402;;;:::o;28033:967::-;28415:3;28437:148;28581:3;28437:148;:::i;:::-;28430:155;;28602:95;28693:3;28684:6;28602:95;:::i;:::-;28595:102;;28714:148;28858:3;28714:148;:::i;:::-;28707:155;;28879:95;28970:3;28961:6;28879:95;:::i;:::-;28872:102;;28991:3;28984:10;;28033:967;;;;;:::o;29006:180::-;29054:77;29051:1;29044:88;29151:4;29148:1;29141:15;29175:4;29172:1;29165:15;29192:180;29240:77;29237:1;29230:88;29337:4;29334:1;29327:15;29361:4;29358:1;29351:15;29378:348;29418:7;29441:20;29459:1;29441:20;:::i;:::-;29436:25;;29475:20;29493:1;29475:20;:::i;:::-;29470:25;;29663:1;29595:66;29591:74;29588:1;29585:81;29580:1;29573:9;29566:17;29562:105;29559:131;;;29670:18;;:::i;:::-;29559:131;29718:1;29715;29711:9;29700:20;;29378:348;;;;:::o;29732:180::-;29780:77;29777:1;29770:88;29877:4;29874:1;29867:15;29901:4;29898:1;29891:15;29918:171;29957:3;29980:24;29998:5;29980:24;:::i;:::-;29971:33;;30026:4;30019:5;30016:15;30013:41;;;30034:18;;:::i;:::-;30013:41;30081:1;30074:5;30070:13;30063:20;;29918:171;;;:::o;30095:182::-;30235:34;30231:1;30223:6;30219:14;30212:58;30095:182;:::o;30283:366::-;30425:3;30446:67;30510:2;30505:3;30446:67;:::i;:::-;30439:74;;30522:93;30611:3;30522:93;:::i;:::-;30640:2;30635:3;30631:12;30624:19;;30283:366;;;:::o;30655:419::-;30821:4;30859:2;30848:9;30844:18;30836:26;;30908:9;30902:4;30898:20;30894:1;30883:9;30879:17;30872:47;30936:131;31062:4;30936:131;:::i;:::-;30928:139;;30655:419;;;:::o

ipfs://cd247def9b342220d42c52ddf5f60931ce24e563d8f6a0eb1e7bad4a5802642f