Token Fight Club Black Glove

/**
 *Submitted for verification at Etherscan.io on 2022-09-09
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Counters.sol


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

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

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // 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);
    }

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

// File: @openzeppelin/contracts/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


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

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` 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 tokenId
    ) 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.
     * - `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 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally checks to see if a
     * token-specific URI was set for the token, and if so, it deletes the token URI from
     * the storage mapping.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: contracts/BlackGlove.sol

//SPDX-License-Identifier:MIT
pragma solidity ^0.8.0;






///@title Fight Club's Black Glove

contract BlackGlove is ERC721URIStorage, Ownable{
    using Counters for Counters.Counter;
    using Strings for uint256;

    /// @notice To keep track of token ids
    Counters.Counter public _tokenIds;

    /// @notice discounted cost for NFT in MATIC//
    uint256 public discountedPrice;

    /// @notice regular cost for NFT in MATIC//
    uint256 public price;

    //URI to read metadata of images to be deployed
    string constant public TOKEN_URI = "ipfs://QmUxTFQbYQku3qtHKHapP8Ex4AKCi4j7fhh2YzNtwyNJgx";

    ///@notice Maximum supply of NFTs 
    uint16 constant public MAX_SUPPLY = 1000;

    ///@notice For managing "Pause" state //
    bool public paused = false;

    ///@notice For root hash of the merkle tree that stores whitelist address 
    bytes32 public root;

    ///@notice List of holders//
    mapping(address => uint256) public holders;

    ///@notice duration of discoount for whitelisted address//
    uint256 public discountDuration;
    
    ///@notice For timestamp at which discount period ends for whitelisted //
    uint256 public immutable end;

    ///@notice dev addresses for 1% commission //
    address[] public devs ;


    ///@notice Where funds from mint will go to //
    address public beneficiary;

    ///@notice Event will be triggered whenever a new NFT is minted with address and amount//
    event Minted(address indexed caller, uint256 amount);

    ///@notice Event will be triggered whenever funds were deployed//
    event Withdraw(address indexed caller, uint256 amount);

    ///@notice Event will be triggered when commission is paid to dev on a mint//
    event CommisionPaid(address indexed dev, uint256 amount);

    ///@notice Event will be triggered when beneficiary address is changed
    event BeneficiaryUpdated(address indexed newAddress);

    constructor(
        bytes32 _root,
        address[] memory _devs,
        uint256 _discountedPrice,
        uint256 _price,
        address _fcWallet,
        uint256 _discountDuration
    ) ERC721 ("Fight Club Black Glove", "FCBG") {
        root = _root;
        //set value for dev address to pay 1% commission on a mint //
        devs = _devs;
        //price and discountedPrice - helps a lot for testing //
        discountedPrice  = _discountedPrice ;
        price = _price;
        //fight club wallet address//
        beneficiary = _fcWallet;
        //set discountDuration//
        discountDuration = _discountDuration;
        // set timestamp to end discountDuration//
        end = block.timestamp + discountDuration;

    }


    ///@notice To get totalSupply
    function totalSupply() view public returns (uint256){
        return _tokenIds.current();
    }
    ///@notice A unitly function to convert address into bytes32 to verify merkle proof//
    function toBytes32(address addr) pure internal returns (bytes32) {
       return bytes32(uint256(uint160(addr))); 
    }

    ///@notice To get cost of a mint based on time and proof 
    function getCost(bytes32[] calldata proof) public view returns (uint256) {
        bool whitelisted = MerkleProof.verify(proof, root, toBytes32(msg.sender)) == true;
        // if the caller is a whitelisted address and under discoount duration, then set cost to 600 MATIC //
        // otherwise 650 MATIC //
        uint256 cost = whitelisted && block.timestamp < end ? discountedPrice : price;
        return cost;
    }
    ///@dev create tokens of token type `id` and assigns them to `to`
    /// `to` cannot be a zero address

    function mint(bytes32[] calldata proof) public payable {
        require(!paused, "Black Glove is paused");
        require(holders[msg.sender] == 0, "A wallet can not mint more than 1 Black Glove");
        holders[msg.sender] = 1;
        // if not, add addr to the holders list with token id//
        // the logic will be required for _safeMint too. Hence, performing it here is optimization
        _tokenIds.increment();
        uint256 id = _tokenIds.current();
        holders[msg.sender] == id;
        //check if totalSupply is reached//
        require ( _tokenIds.current() <= MAX_SUPPLY, "Max supply reached!");
        // check if the merkle proof is valid //
        bool whitelisted = MerkleProof.verify(proof, root, toBytes32(msg.sender)) == true;
        // if the caller is a whitelisted address and under discoount duration, then set cost to 600 MATIC //
        // otherwise 650 MATIC //
        uint256 cost = whitelisted && block.timestamp < end ? discountedPrice : price;
        // get funds //
        require(msg.value >= cost, "Insufficient funds!");
        _moveFunds(cost);
        // safemint and transfer//
        _safeMint(msg.sender, id);
        _setTokenURI(id, TOKEN_URI);
        //emit event//
        emit Minted(msg.sender, msg.value);
    }

    ///@notice Updating beneficiary address, FC's wallet address to receive funds in case the wallet is ever compromised
    function updateBeneficiaryAddress(address _newAddress) external onlyOwner{
        require(_newAddress != address(0), "The new address can not be a zero address");
        beneficiary = _newAddress;
        emit BeneficiaryUpdated(_newAddress);
    }
    
    ///@notice To pay each dev 1% on a mint
    function _moveFunds(uint256 _cost) internal {
        uint256 amount = _cost * 1/100;
        //send one parcent to each dev //
        for (uint16 i = 0; i < devs.length; i++){
            (bool success, ) = (devs[i]).call{value: amount}("");
            require(success, "Transaction Failed");
            emit CommisionPaid(devs[i], amount);
        }
        //send 97% to Fc wallet//
        uint256 fcAmount = _cost * 97/100;
        (bool success, ) = payable(beneficiary).call{value: fcAmount}("");
        require(success, "Transaction to benficiary failed!");
    }

    
    function pause() external onlyOwner {
        paused = true;
    }

    function unpause() external onlyOwner {
        paused =false;
    }

    function withdraw() external payable onlyOwner{
        uint256 balance = address(this).balance;
        require(balance > 0, "No funds left to withdraw");
        (bool success, ) = (msg.sender).call{value: balance}("");
        require(success, "Withdrawal Failed");
        emit Withdraw(msg.sender, balance);
    }

    receive() external payable {
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"},{"internalType":"address[]","name":"_devs","type":"address[]"},{"internalType":"uint256","name":"_discountedPrice","type":"uint256"},{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"address","name":"_fcWallet","type":"address"},{"internalType":"uint256","name":"_discountDuration","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"BeneficiaryUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"dev","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"CommisionPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_URI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_tokenIds","outputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"devs","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"discountDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"discountedPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"end","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"getCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"holders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","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":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newAddress","type":"address"}],"name":"updateBeneficiaryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0ae128341d7ac0e8d1e46eb892c4b949767fb8756b5bc05925c7f474073e956600000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000028a857425466f8000000000000000000000000000000000000000000000000002c73c937742c5000000000000000000000000000000abb12c338ee65160c96061051e38a71f49ca471000000000000000000000000000000000000000000000000000000000002a3000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000916134e688a4a866ff57f4f53f16703f9b8afa990000000000000000000000003eb231c0513ee1f07306c2919ff5f9ee9308407f00000000000000000000000013eef4ef8fca471f242ab0f8f49a3db6017ada33

-----Decoded View---------------
Arg [0] : _root (bytes32): 0x0ae128341d7ac0e8d1e46eb892c4b949767fb8756b5bc05925c7f474073e9566
Arg [1] : _devs (address[]): 0x916134e688a4a866ff57f4f53f16703f9b8afa99,0x3eb231c0513ee1f07306c2919ff5f9ee9308407f,0x13eef4ef8fca471f242ab0f8f49a3db6017ada33
Arg [2] : _discountedPrice (uint256): 750000000000000000000
Arg [3] : _price (uint256): 820000000000000000000
Arg [4] : _fcWallet (address): 0x0abb12c338ee65160c96061051e38a71f49ca471
Arg [5] : _discountDuration (uint256): 172800

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 0ae128341d7ac0e8d1e46eb892c4b949767fb8756b5bc05925c7f474073e9566
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000000000000000000000000028a857425466f80000
Arg [3] : 00000000000000000000000000000000000000000000002c73c937742c500000
Arg [4] : 0000000000000000000000000abb12c338ee65160c96061051e38a71f49ca471
Arg [5] : 000000000000000000000000000000000000000000000000000000000002a300
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 000000000000000000000000916134e688a4a866ff57f4f53f16703f9b8afa99
Arg [8] : 0000000000000000000000003eb231c0513ee1f07306c2919ff5f9ee9308407f
Arg [9] : 00000000000000000000000013eef4ef8fca471f242ab0f8f49a3db6017ada33

53092:6488:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37806:305;;;;;;;;;;-1:-1:-1;37806:305:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38733:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;40246:171::-;;;;;;;;;;-1:-1:-1;40246:171:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39763:417::-;;;;;;;;;;-1:-1:-1;39763:417:0;;;;;:::i;:::-;;:::i;:::-;;55772:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;53942:42::-;;;;;;;;;;-1:-1:-1;53942:42:0;;;;;:::i;:::-;;:::i;54057:31::-;;;;;;;;;;;;;:::i;40946:336::-;;;;;;;;;;-1:-1:-1;40946:336:0;;;;;:::i;:::-;;:::i;53670:40::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54353:26::-;;;;;;;;;;;;;:::i;59210:324::-;;;:::i;59132:70::-;;;;;;;;;;;;;:::i;41353:185::-;;;;;;;;;;-1:-1:-1;41353:185:0;;;;;:::i;:::-;;:::i;53765:26::-;;;;;;;;;;;;;:::i;54268:21::-;;;;;;;;;;-1:-1:-1;54268:21:0;;;;;:::i;:::-;;:::i;38444:222::-;;;;;;;;;;-1:-1:-1;38444:222:0;;;;;:::i;:::-;;:::i;38175:207::-;;;;;;;;;;-1:-1:-1;38175:207:0;;;;;:::i;:::-;;:::i;18342:103::-;;;;;;;;;;;;;:::i;56159:429::-;;;;;;;;;;-1:-1:-1;56159:429:0;;;;;:::i;:::-;;:::i;53531:90::-;;;;;;;;;;;;;:::i;59056:68::-;;;;;;;;;;;;;:::i;17694:87::-;;;;;;;;;;;;;:::i;38902:104::-;;;;;;;;;;;;;:::i;53449:20::-;;;;;;;;;;;;;:::i;40489:155::-;;;;;;;;;;-1:-1:-1;40489:155:0;;;;;:::i;:::-;;:::i;53267:33::-;;;;;;;;;;;;;:::i;56706:1308::-;;;;;;:::i;:::-;;:::i;41609:323::-;;;;;;;;;;-1:-1:-1;41609:323:0;;;;;:::i;:::-;;:::i;53361:30::-;;;;;;;;;;;;;:::i;51514:624::-;;;;;;;;;;-1:-1:-1;51514:624:0;;;;;:::i;:::-;;:::i;58144:254::-;;;;;;;;;;-1:-1:-1;58144:254:0;;;;;:::i;:::-;;:::i;40715:164::-;;;;;;;;;;-1:-1:-1;40715:164:0;;;;;:::i;:::-;;:::i;53880:19::-;;;;;;;;;;;;;:::i;54180:28::-;;;;;;;;;;;;;:::i;18600:201::-;;;;;;;;;;-1:-1:-1;18600:201:0;;;;;:::i;:::-;;:::i;37806:305::-;37908:4;-1:-1:-1;;;;;;37945:40:0;;-1:-1:-1;;;37945:40:0;;:105;;-1:-1:-1;;;;;;;38002:48:0;;-1:-1:-1;;;38002:48:0;37945:105;:158;;;;38067:36;38091:11;38067:23;:36::i;:::-;37925:178;;37806:305;;;;:::o;38733:100::-;38787:13;38820:5;38813:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38733:100;:::o;40246:171::-;40322:7;40342:23;40357:7;40342:14;:23::i;:::-;-1:-1:-1;40385:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;40385:24:0;;40246:171::o;39763:417::-;39844:13;39860:23;39875:7;39860:14;:23::i;:::-;39844:39;;39908:5;-1:-1:-1;;;;;39902:11:0;:2;-1:-1:-1;;;;;39902:11:0;;;39894:57;;;;-1:-1:-1;;;39894:57:0;;;;;;;:::i;:::-;;;;;;;;;40002:5;-1:-1:-1;;;;;39986:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;39986:21:0;;:62;;;;40011:37;40028:5;40035:12;:10;:12::i;40011:37::-;39964:174;;;;-1:-1:-1;;;39964:174:0;;;;;;;:::i;:::-;40151:21;40160:2;40164:7;40151:8;:21::i;:::-;39763:417;;;:::o;55772:97::-;55816:7;55842:19;:9;:17;:19::i;:::-;55835:26;;55772:97;:::o;53942:42::-;;;;;;;;;;;;;:::o;54057:31::-;;;;:::o;40946:336::-;41141:41;41160:12;:10;:12::i;:::-;41174:7;41141:18;:41::i;:::-;41133:100;;;;-1:-1:-1;;;41133:100:0;;;;;;;:::i;:::-;41246:28;41256:4;41262:2;41266:7;41246:9;:28::i;53670:40::-;53706:4;53670:40;:::o;54353:26::-;;;-1:-1:-1;;;;;54353:26:0;;:::o;59210:324::-;17580:13;:11;:13::i;:::-;59285:21:::1;59325:11:::0;59317:49:::1;;;;-1:-1:-1::0;;;59317:49:0::1;;;;;;;:::i;:::-;59378:12;59397:10;-1:-1:-1::0;;;;;59396:17:0::1;59421:7;59396:37;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59377:56;;;59452:7;59444:37;;;;-1:-1:-1::0;;;59444:37:0::1;;;;;;;:::i;:::-;59506:10;-1:-1:-1::0;;;;;59497:29:0::1;;59518:7;59497:29;;;;;;:::i;:::-;;;;;;;;17604:1;;59210:324::o:0;59132:70::-;17580:13;:11;:13::i;:::-;59181:6:::1;:13:::0;;-1:-1:-1;;59181:13:0::1;::::0;;59132:70::o;41353:185::-;41491:39;41508:4;41514:2;41518:7;41491:39;;;;;;;;;;;;:16;:39::i;53765:26::-;;;;;;:::o;54268:21::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54268:21:0;;-1:-1:-1;54268:21:0;:::o;38444:222::-;38516:7;38552:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38552:16:0;38587:19;38579:56;;;;-1:-1:-1;;;38579:56:0;;;;;;;:::i;38175:207::-;38247:7;-1:-1:-1;;;;;38275:19:0;;38267:73;;;;-1:-1:-1;;;38267:73:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;38358:16:0;;;;;:9;:16;;;;;;;38175:207::o;18342:103::-;17580:13;:11;:13::i;:::-;18407:30:::1;18434:1;18407:18;:30::i;:::-;18342:103::o:0;56159:429::-;56223:7;56243:16;56262:54;56281:5;;56262:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;56288:4:0;;;-1:-1:-1;56294:21:0;;-1:-1:-1;56304:10:0;56294:9;:21::i;:::-;56262:18;:54::i;:::-;:62;;56320:4;56262:62;;-1:-1:-1;56262:62:0;;56496:36;;;;;56529:3;56511:15;:21;56496:36;:62;;56553:5;;56496:62;;;56535:15;;56496:62;56481:77;56159:429;-1:-1:-1;;;;;56159:429:0:o;53531:90::-;;;;;;;;;;;;;;;;;;;:::o;59056:68::-;17580:13;:11;:13::i;:::-;59103:6:::1;:13:::0;;-1:-1:-1;;59103:13:0::1;59112:4;59103:13;::::0;;59056:68::o;17694:87::-;17767:6;;-1:-1:-1;;;;;17767:6:0;17694:87;:::o;38902:104::-;38958:13;38991:7;38984:14;;;;;:::i;53449:20::-;;;;:::o;40489:155::-;40584:52;40603:12;:10;:12::i;:::-;40617:8;40627;40584:18;:52::i;:::-;40489:155;;:::o;53267:33::-;;;;:::o;56706:1308::-;56781:6;;;;56780:7;56772:41;;;;-1:-1:-1;;;56772:41:0;;;;;;;:::i;:::-;56840:10;56832:19;;;;:7;:19;;;;;;:24;56824:82;;;;-1:-1:-1;;;56824:82:0;;;;;;;:::i;:::-;56925:10;56917:19;;;;:7;:19;;;;;56939:1;56917:23;;57116:21;:9;:19;:21::i;:::-;57148:10;57161:19;:9;:17;:19::i;:::-;57199:10;57191:19;;:7;:19;;57148:32;-1:-1:-1;53706:4:0;57282:19;:9;:17;:19::i;:::-;:33;;57272:67;;;;-1:-1:-1;;;57272:67:0;;;;;;;:::i;:::-;57400:16;57419:54;57438:5;;57419:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;57445:4:0;;;-1:-1:-1;57451:21:0;;-1:-1:-1;57461:10:0;57451:9;:21::i;57419:54::-;:62;;57477:4;57419:62;;-1:-1:-1;57419:62:0;;57653:36;;;;;57686:3;57668:15;:21;57653:36;:62;;57710:5;;57653:62;;;57692:15;;57653:62;57638:77;;57772:4;57759:9;:17;;57751:49;;;;-1:-1:-1;;;57751:49:0;;;;;;;:::i;:::-;57811:16;57822:4;57811:10;:16::i;:::-;57874:25;57884:10;57896:2;57874:9;:25::i;:::-;57910:27;57923:2;57927:9;;;;;;;;;;;;;;;;;57910:12;:27::i;:::-;57984:10;-1:-1:-1;;;;;57977:29:0;;57996:9;57977:29;;;;;;:::i;:::-;;;;;;;;56706:1308;;;;;:::o;41609:323::-;41783:41;41802:12;:10;:12::i;:::-;41816:7;41783:18;:41::i;:::-;41775:100;;;;-1:-1:-1;;;41775:100:0;;;;;;;:::i;:::-;41886:38;41900:4;41906:2;41910:7;41919:4;41886:13;:38::i;:::-;41609:323;;;;:::o;53361:30::-;;;;:::o;51514:624::-;51587:13;51613:23;51628:7;51613:14;:23::i;:::-;51649;51675:19;;;:10;:19;;;;;51649:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51705:18;51726:10;:8;:10::i;:::-;51705:31;;51818:4;51812:18;51834:1;51812:23;51808:72;;;-1:-1:-1;51859:9:0;-1:-1:-1;51852:16:0;;51808:72;51984:23;;:27;51980:108;;52059:4;52065:9;52042:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52028:48;;;;;;51980:108;52107:23;52122:7;52107:14;:23::i;:::-;52100:30;51514:624;-1:-1:-1;;;;51514:624:0:o;58144:254::-;17580:13;:11;:13::i;:::-;-1:-1:-1;;;;;58236:25:0;::::1;58228:79;;;;-1:-1:-1::0;;;58228:79:0::1;;;;;;;:::i;:::-;58318:11;:25:::0;;-1:-1:-1;;;;;;58318:25:0::1;-1:-1:-1::0;;;;;58318:25:0;::::1;::::0;;::::1;::::0;;;58359:31:::1;::::0;::::1;::::0;-1:-1:-1;;58359:31:0::1;58144:254:::0;:::o;40715:164::-;-1:-1:-1;;;;;40836:25:0;;;40812:4;40836:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;40715:164::o;53880:19::-;;;;:::o;54180:28::-;;;:::o;18600:201::-;17580:13;:11;:13::i;:::-;-1:-1:-1;;;;;18689:22:0;::::1;18681:73;;;;-1:-1:-1::0;;;18681:73:0::1;;;;;;;:::i;:::-;18765:28;18784:8;18765:18;:28::i;:::-;18600:201:::0;:::o;30548:157::-;-1:-1:-1;;;;;;30657:40:0;;-1:-1:-1;;;30657:40:0;30548:157;;;:::o;48221:135::-;48303:16;48311:7;48303;:16::i;:::-;48295:53;;;;-1:-1:-1;;;48295:53:0;;;;;;;:::i;16245:98::-;16325:10;16245:98;:::o;47500:174::-;47575:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;47575:29:0;-1:-1:-1;;;;;47575:29:0;;;;;;;;:24;;47629:23;47575:24;47629:14;:23::i;:::-;-1:-1:-1;;;;;47620:46:0;;;;;;;;;;;47500:174;;:::o;3751:114::-;3843:14;;3751:114::o;43733:264::-;43826:4;43843:13;43859:23;43874:7;43859:14;:23::i;:::-;43843:39;;43912:5;-1:-1:-1;;;;;43901:16:0;:7;-1:-1:-1;;;;;43901:16:0;;:52;;;;43921:32;43938:5;43945:7;43921:16;:32::i;:::-;43901:87;;;;43981:7;-1:-1:-1;;;;;43957:31:0;:20;43969:7;43957:11;:20::i;:::-;-1:-1:-1;;;;;43957:31:0;;43893:96;43733:264;-1:-1:-1;;;;43733:264:0:o;46756:625::-;46915:4;-1:-1:-1;;;;;46888:31:0;:23;46903:7;46888:14;:23::i;:::-;-1:-1:-1;;;;;46888:31:0;;46880:81;;;;-1:-1:-1;;;46880:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46980:16:0;;46972:65;;;;-1:-1:-1;;;46972:65:0;;;;;;;:::i;:::-;47050:39;47071:4;47077:2;47081:7;47050:20;:39::i;:::-;47154:29;47171:1;47175:7;47154:8;:29::i;:::-;-1:-1:-1;;;;;47196:15:0;;;;;;:9;:15;;;;;:20;;47215:1;;47196:15;:20;;47215:1;;47196:20;:::i;:::-;;;;-1:-1:-1;;;;;;;47227:13:0;;;;;;:9;:13;;;;;:18;;47244:1;;47227:13;:18;;47244:1;;47227:18;:::i;:::-;;;;-1:-1:-1;;47256:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;47256:21:0;-1:-1:-1;;;;;47256:21:0;;;;;;;;;47295:27;;47256:16;;47295:27;;;;;;;47335:38;47355:4;47361:2;47365:7;47335:19;:38::i;17859:132::-;17934:12;:10;:12::i;:::-;-1:-1:-1;;;;;17923:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;17923:23:0;;17915:68;;;;-1:-1:-1;;;17915:68:0;;;;;;;:::i;18961:191::-;19054:6;;;-1:-1:-1;;;;;19071:17:0;;;-1:-1:-1;;;;;;19071:17:0;;;;;;;19104:40;;19054:6;;;19071:17;19054:6;;19104:40;;19035:16;;19104:40;18961:191;;:::o;55966:122::-;-1:-1:-1;;;;;56056:22:0;;55966:122::o;5563:190::-;5688:4;5741;5712:25;5725:5;5732:4;5712:12;:25::i;:::-;:33;;5563:190;-1:-1:-1;;;;5563:190:0:o;47817:315::-;47972:8;-1:-1:-1;;;;;47963:17:0;:5;-1:-1:-1;;;;;47963:17:0;;;47955:55;;;;-1:-1:-1;;;47955:55:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48021:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;:46;;-1:-1:-1;;48021:46:0;;;;;;;48083:41;;;;;48021:46;;48083:41;:::i;:::-;;;;;;;;47817:315;;;:::o;3873:127::-;3962:19;;3980:1;3962:19;;;3873:127::o;58455:587::-;58510:14;58537:3;58527:9;:5;58535:1;58527:9;:::i;:::-;:13;;;;:::i;:::-;58510:30;;58599:8;58594:222;58617:4;:11;58613:15;;;;58594:222;;;58650:12;58669:4;58674:1;58669:7;;;;;;;;-1:-1:-1;;;58669:7:0;;;;;;;;;;;;;;;;;;;58668:33;;-1:-1:-1;;;;;58669:7:0;;;;58690:6;;58668:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58649:52;;;58724:7;58716:38;;;;-1:-1:-1;;;58716:38:0;;;;;;;:::i;:::-;58788:4;58793:1;58788:7;;;;;;;;-1:-1:-1;;;58788:7:0;;;;;;;;;;;;;;;;;;;58774:30;;-1:-1:-1;;;;;58788:7:0;;;;58774:30;;;;58797:6;;58774:30;:::i;:::-;;;;;;;;-1:-1:-1;58630:3:0;;;;:::i;:::-;;;;58594:222;;;-1:-1:-1;58861:16:0;58891:3;58880:10;:5;58888:2;58880:10;:::i;:::-;:14;;;;:::i;:::-;58932:11;;58924:46;;58861:33;;-1:-1:-1;58906:12:0;;-1:-1:-1;;;;;58932:11:0;;;;58861:33;;58924:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58905:65;;;58989:7;58981:53;;;;-1:-1:-1;;;58981:53:0;;;;;;;:::i;44339:110::-;44415:26;44425:2;44429:7;44415:26;;;;;;;;;;;;:9;:26::i;52294:217::-;52394:16;52402:7;52394;:16::i;:::-;52386:75;;;;-1:-1:-1;;;52386:75:0;;;;;;;:::i;:::-;52472:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;42813:313::-;42969:28;42979:4;42985:2;42989:7;42969:9;:28::i;:::-;43016:47;43039:4;43045:2;43049:7;43058:4;43016:22;:47::i;:::-;43008:110;;;;-1:-1:-1;;;43008:110:0;;;;;;;:::i;39607:94::-;39684:9;;;;;;;;;-1:-1:-1;39684:9:0;;39607:94;:::o;39077:281::-;39150:13;39176:23;39191:7;39176:14;:23::i;:::-;39212:21;39236:10;:8;:10::i;:::-;39212:34;;39288:1;39270:7;39264:21;:25;:86;;;;;;;;;;;;;;;;;39316:7;39325:18;:7;:16;:18::i;:::-;39299:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;39264:86;39257:93;39077:281;-1:-1:-1;;;39077:281:0:o;43439:127::-;43504:4;43528:16;;;:7;:16;;;;;;-1:-1:-1;;;;;43528:16:0;:30;;;43439:127::o;6430:296::-;6513:7;6556:4;6513:7;6571:118;6595:5;:12;6591:1;:16;6571:118;;;6644:33;6654:12;6668:5;6674:1;6668:8;;;;;;-1:-1:-1;;;6668:8:0;;;;;;;;;;;;;;;6644:9;:33::i;:::-;6629:48;-1:-1:-1;6609:3:0;;;;:::i;:::-;;;;6571:118;;;-1:-1:-1;6706:12:0;6430:296;-1:-1:-1;;;6430:296:0:o;44676:319::-;44805:18;44811:2;44815:7;44805:5;:18::i;:::-;44856:53;44887:1;44891:2;44895:7;44904:4;44856:22;:53::i;:::-;44834:153;;;;-1:-1:-1;;;44834:153:0;;;;;;;:::i;48920:853::-;49074:4;49095:15;:2;-1:-1:-1;;;;;49095:13:0;;:15::i;:::-;49091:675;;;49147:2;-1:-1:-1;;;;;49131:36:0;;49168:12;:10;:12::i;:::-;49182:4;49188:7;49197:4;49131:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49131:71:0;;;;;;;;-1:-1:-1;;49131:71:0;;;;;;;;;;;;:::i;:::-;;;49127:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49372:13:0;;49368:328;;49415:60;;-1:-1:-1;;;49415:60:0;;;;;;;:::i;49368:328::-;49646:6;49640:13;49631:6;49627:2;49623:15;49616:38;49127:584;-1:-1:-1;;;;;;49253:51:0;-1:-1:-1;;;49253:51:0;;-1:-1:-1;49246:58:0;;49091:675;-1:-1:-1;49750:4:0;48920:853;;;;;;:::o;13499:723::-;13555:13;13776:10;13772:53;;-1:-1:-1;13803:10:0;;;;;;;;;;;;-1:-1:-1;;;13803:10:0;;;;;;13772:53;13850:5;13835:12;13891:78;13898:9;;13891:78;;13924:8;;;;:::i;:::-;;-1:-1:-1;13947:10:0;;-1:-1:-1;13955:2:0;13947:10;;:::i;:::-;;;13891:78;;;13979:19;14011:6;14001:17;;;;;;-1:-1:-1;;;14001:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14001:17:0;;13979:39;;14029:154;14036:10;;14029:154;;14063:11;14073:1;14063:11;;:::i;:::-;;-1:-1:-1;14132:10:0;14140:2;14132:5;:10;:::i;:::-;14119:24;;:2;:24;:::i;:::-;14106:39;;14089:6;14096;14089:14;;;;;;-1:-1:-1;;;14089:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;14089:56:0;;;;;;;;-1:-1:-1;14160:11:0;14169:2;14160:11;;:::i;:::-;;;14029:154;;12637:149;12700:7;12731:1;12727;:5;:51;;12758:20;12773:1;12776;12758:14;:20::i;:::-;12727:51;;;12735:20;12750:1;12753;12735:14;:20::i;45331:439::-;-1:-1:-1;;;;;45411:16:0;;45403:61;;;;-1:-1:-1;;;45403:61:0;;;;;;;:::i;:::-;45484:16;45492:7;45484;:16::i;:::-;45483:17;45475:58;;;;-1:-1:-1;;;45475:58:0;;;;;;;:::i;:::-;45546:45;45575:1;45579:2;45583:7;45546:20;:45::i;:::-;-1:-1:-1;;;;;45604:13:0;;;;;;:9;:13;;;;;:18;;45621:1;;45604:13;:18;;45621:1;;45604:18;:::i;:::-;;;;-1:-1:-1;;45633:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;45633:21:0;-1:-1:-1;;;;;45633:21:0;;;;;;;;45672:33;;45633:16;;;45672:33;;45633:16;;45672:33;45718:44;45746:1;45750:2;45754:7;45718:19;:44::i;20392:326::-;-1:-1:-1;;;;;20687:19:0;;:23;;;20392:326::o;12794:268::-;12862:13;12956:15;;;12992:4;12985:15;13039:4;13023:21;;;12941:114::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:175:1;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:1187::-;;;;;1195:3;1183:9;1174:7;1170:23;1166:33;1163:2;;;1217:6;1209;1202:22;1163:2;1245:31;1266:9;1245:31;:::i;:::-;1235:41;;1295:40;1331:2;1320:9;1316:18;1295:40;:::i;:::-;1285:50;;1382:2;1371:9;1367:18;1354:32;1344:42;;1437:2;1426:9;1422:18;1409:32;1460:18;1501:2;1493:6;1490:14;1487:2;;;1522:6;1514;1507:22;1487:2;1565:6;1554:9;1550:22;1540:32;;1610:7;1603:4;1599:2;1595:13;1591:27;1581:2;;1637:6;1629;1622:22;1581:2;1678;1665:16;1700:2;1696;1693:10;1690:2;;;1706:18;;:::i;:::-;1781:2;1775:9;1749:2;1835:13;;-1:-1:-1;;1831:22:1;;;1855:2;1827:31;1823:40;1811:53;;;1879:18;;;1899:22;;;1876:46;1873:2;;;1925:18;;:::i;:::-;1965:10;1961:2;1954:22;2000:2;1992:6;1985:18;2040:7;2035:2;2030;2026;2022:11;2018:20;2015:33;2012:2;;;2066:6;2058;2051:22;2012:2;2127;2122;2118;2114:11;2109:2;2101:6;2097:15;2084:46;2150:15;;;2167:2;2146:24;2139:40;;;;1153:1057;;;;-1:-1:-1;1153:1057:1;;-1:-1:-1;;;;1153:1057:1:o;2215:369::-;;;2341:2;2329:9;2320:7;2316:23;2312:32;2309:2;;;2362:6;2354;2347:22;2309:2;2390:31;2411:9;2390:31;:::i;:::-;2380:41;;2471:2;2460:9;2456:18;2443:32;2518:5;2511:13;2504:21;2497:5;2494:32;2484:2;;2545:6;2537;2530:22;2484:2;2573:5;2563:15;;;2299:285;;;;;:::o;2589:266::-;;;2718:2;2706:9;2697:7;2693:23;2689:32;2686:2;;;2739:6;2731;2724:22;2686:2;2767:31;2788:9;2767:31;:::i;:::-;2757:41;2845:2;2830:18;;;;2817:32;;-1:-1:-1;;;2676:179:1:o;2860:666::-;;;3007:2;2995:9;2986:7;2982:23;2978:32;2975:2;;;3028:6;3020;3013:22;2975:2;3073:9;3060:23;3102:18;3143:2;3135:6;3132:14;3129:2;;;3164:6;3156;3149:22;3129:2;3207:6;3196:9;3192:22;3182:32;;3252:7;3245:4;3241:2;3237:13;3233:27;3223:2;;3279:6;3271;3264:22;3223:2;3324;3311:16;3350:2;3342:6;3339:14;3336:2;;;3371:6;3363;3356:22;3336:2;3430:7;3425:2;3419;3411:6;3407:15;3403:2;3399:24;3395:33;3392:46;3389:2;;;3456:6;3448;3441:22;3389:2;3492;3484:11;;;;;3514:6;;-1:-1:-1;2965:561:1;;-1:-1:-1;;;;2965:561:1:o;3531:257::-;;3642:2;3630:9;3621:7;3617:23;3613:32;3610:2;;;3663:6;3655;3648:22;3610:2;3707:9;3694:23;3726:32;3752:5;3726:32;:::i;3793:261::-;;3915:2;3903:9;3894:7;3890:23;3886:32;3883:2;;;3936:6;3928;3921:22;3883:2;3973:9;3967:16;3992:32;4018:5;3992:32;:::i;4059:190::-;;4171:2;4159:9;4150:7;4146:23;4142:32;4139:2;;;4192:6;4184;4177:22;4139:2;-1:-1:-1;4220:23:1;;4129:120;-1:-1:-1;4129:120:1:o;4254:259::-;;4335:5;4329:12;4362:6;4357:3;4350:19;4378:63;4434:6;4427:4;4422:3;4418:14;4411:4;4404:5;4400:16;4378:63;:::i;:::-;4495:2;4474:15;-1:-1:-1;;4470:29:1;4461:39;;;;4502:4;4457:50;;4305:208;-1:-1:-1;;4305:208:1:o;4518:470::-;;4735:6;4729:13;4751:53;4797:6;4792:3;4785:4;4777:6;4773:17;4751:53;:::i;:::-;4867:13;;4826:16;;;;4889:57;4867:13;4826:16;4923:4;4911:17;;4889:57;:::i;:::-;4962:20;;4705:283;-1:-1:-1;;;;4705:283:1:o;4993:205::-;5193:3;5184:14::o;5203:203::-;-1:-1:-1;;;;;5367:32:1;;;;5349:51;;5337:2;5322:18;;5304:102::o;5411:490::-;-1:-1:-1;;;;;5680:15:1;;;5662:34;;5732:15;;5727:2;5712:18;;5705:43;5779:2;5764:18;;5757:34;;;5827:3;5822:2;5807:18;;5800:31;;;5411:490;;5848:47;;5875:19;;5867:6;5848:47;:::i;:::-;5840:55;5614:287;-1:-1:-1;;;;;;5614:287:1:o;5906:187::-;6071:14;;6064:22;6046:41;;6034:2;6019:18;;6001:92::o;6098:177::-;6244:25;;;6232:2;6217:18;;6199:76::o;6280:221::-;;6429:2;6418:9;6411:21;6449:46;6491:2;6480:9;6476:18;6468:6;6449:46;:::i;6506:414::-;6708:2;6690:21;;;6747:2;6727:18;;;6720:30;6786:34;6781:2;6766:18;;6759:62;-1:-1:-1;;;6852:2:1;6837:18;;6830:48;6910:3;6895:19;;6680:240::o;6925:402::-;7127:2;7109:21;;;7166:2;7146:18;;;7139:30;7205:34;7200:2;7185:18;;7178:62;-1:-1:-1;;;7271:2:1;7256:18;;7249:36;7317:3;7302:19;;7099:228::o;7332:401::-;7534:2;7516:21;;;7573:2;7553:18;;;7546:30;7612:34;7607:2;7592:18;;7585:62;-1:-1:-1;;;7678:2:1;7663:18;;7656:35;7723:3;7708:19;;7506:227::o;7738:352::-;7940:2;7922:21;;;7979:2;7959:18;;;7952:30;8018;8013:2;7998:18;;7991:58;8081:2;8066:18;;7912:178::o;8095:400::-;8297:2;8279:21;;;8336:2;8316:18;;;8309:30;8375:34;8370:2;8355:18;;8348:62;-1:-1:-1;;;8441:2:1;8426:18;;8419:34;8485:3;8470:19;;8269:226::o;8500:349::-;8702:2;8684:21;;;8741:2;8721:18;;;8714:30;8780:27;8775:2;8760:18;;8753:55;8840:2;8825:18;;8674:175::o;8854:349::-;9056:2;9038:21;;;9095:2;9075:18;;;9068:30;9134:27;9129:2;9114:18;;9107:55;9194:2;9179:18;;9028:175::o;9208:405::-;9410:2;9392:21;;;9449:2;9429:18;;;9422:30;9488:34;9483:2;9468:18;;9461:62;-1:-1:-1;;;9554:2:1;9539:18;;9532:39;9603:3;9588:19;;9382:231::o;9618:410::-;9820:2;9802:21;;;9859:2;9839:18;;;9832:30;9898:34;9893:2;9878:18;;9871:62;-1:-1:-1;;;9964:2:1;9949:18;;9942:44;10018:3;10003:19;;9792:236::o;10033:426::-;10235:2;10217:21;;;10274:2;10254:18;;;10247:30;10313:34;10308:2;10293:18;;10286:62;10384:32;10379:2;10364:18;;10357:60;10449:3;10434:19;;10207:252::o;10464:356::-;10666:2;10648:21;;;10685:18;;;10678:30;10744:34;10739:2;10724:18;;10717:62;10811:2;10796:18;;10638:182::o;10825:341::-;11027:2;11009:21;;;11066:2;11046:18;;;11039:30;-1:-1:-1;;;11100:2:1;11085:18;;11078:47;11157:2;11142:18;;10999:167::o;11171:356::-;11373:2;11355:21;;;11392:18;;;11385:30;11451:34;11446:2;11431:18;;11424:62;11518:2;11503:18;;11345:182::o;11532:348::-;11734:2;11716:21;;;11773:2;11753:18;;;11746:30;11812:26;11807:2;11792:18;;11785:54;11871:2;11856:18;;11706:174::o;11885:409::-;12087:2;12069:21;;;12126:2;12106:18;;;12099:30;12165:34;12160:2;12145:18;;12138:62;-1:-1:-1;;;12231:2:1;12216:18;;12209:43;12284:3;12269:19;;12059:235::o;12299:397::-;12501:2;12483:21;;;12540:2;12520:18;;;12513:30;12579:34;12574:2;12559:18;;12552:62;-1:-1:-1;;;12645:2:1;12630:18;;12623:31;12686:3;12671:19;;12473:223::o;12701:343::-;12903:2;12885:21;;;12942:2;12922:18;;;12915:30;-1:-1:-1;;;12976:2:1;12961:18;;12954:49;13035:2;13020:18;;12875:169::o;13049:397::-;13251:2;13233:21;;;13290:2;13270:18;;;13263:30;13329:34;13324:2;13309:18;;13302:62;-1:-1:-1;;;13395:2:1;13380:18;;13373:31;13436:3;13421:19;;13223:223::o;13451:410::-;13653:2;13635:21;;;13692:2;13672:18;;;13665:30;13731:34;13726:2;13711:18;;13704:62;-1:-1:-1;;;13797:2:1;13782:18;;13775:44;13851:3;13836:19;;13625:236::o;13866:345::-;14068:2;14050:21;;;14107:2;14087:18;;;14080:30;-1:-1:-1;;;14141:2:1;14126:18;;14119:51;14202:2;14187:18;;14040:171::o;14216:342::-;14418:2;14400:21;;;14457:2;14437:18;;;14430:30;-1:-1:-1;;;14491:2:1;14476:18;;14469:48;14549:2;14534:18;;14390:168::o;14563:343::-;14765:2;14747:21;;;14804:2;14784:18;;;14777:30;-1:-1:-1;;;14838:2:1;14823:18;;14816:49;14897:2;14882:18;;14737:169::o;14911:405::-;15113:2;15095:21;;;15152:2;15132:18;;;15125:30;15191:34;15186:2;15171:18;;15164:62;-1:-1:-1;;;15257:2:1;15242:18;;15235:39;15306:3;15291:19;;15085:231::o;15321:188::-;15495:6;15483:19;;;;15465:38;;15453:2;15438:18;;15420:89::o;15696:128::-;;15767:1;15763:6;15760:1;15757:13;15754:2;;;15773:18;;:::i;:::-;-1:-1:-1;15809:9:1;;15744:80::o;15829:120::-;;15895:1;15885:2;;15900:18;;:::i;:::-;-1:-1:-1;15934:9:1;;15875:74::o;15954:168::-;;16060:1;16056;16052:6;16048:14;16045:1;16042:21;16037:1;16030:9;16023:17;16019:45;16016:2;;;16067:18;;:::i;:::-;-1:-1:-1;16107:9:1;;16006:116::o;16127:125::-;;16195:1;16192;16189:8;16186:2;;;16200:18;;:::i;:::-;-1:-1:-1;16237:9:1;;16176:76::o;16257:258::-;16329:1;16339:113;16353:6;16350:1;16347:13;16339:113;;;16429:11;;;16423:18;16410:11;;;16403:39;16375:2;16368:10;16339:113;;;16470:6;16467:1;16464:13;16461:2;;;-1:-1:-1;;16505:1:1;16487:16;;16480:27;16310:205::o;16520:380::-;16605:1;16595:12;;16652:1;16642:12;;;16663:2;;16717:4;16709:6;16705:17;16695:27;;16663:2;16770;16762:6;16759:14;16739:18;16736:38;16733:2;;;16816:10;16811:3;16807:20;16804:1;16797:31;16851:4;16848:1;16841:15;16879:4;16876:1;16869:15;16733:2;;16575:325;;;:::o;16905:197::-;;16971:6;17012:2;17005:5;17001:14;17039:2;17030:7;17027:15;17024:2;;;17045:18;;:::i;:::-;17094:1;17081:15;;16951:151;-1:-1:-1;;;16951:151:1:o;17107:135::-;;-1:-1:-1;;17167:17:1;;17164:2;;;17187:18;;:::i;:::-;-1:-1:-1;17234:1:1;17223:13;;17154:88::o;17247:112::-;;17305:1;17295:2;;17310:18;;:::i;:::-;-1:-1:-1;17344:9:1;;17285:74::o;17364:127::-;17425:10;17420:3;17416:20;17413:1;17406:31;17456:4;17453:1;17446:15;17480:4;17477:1;17470:15;17496:127;17557:10;17552:3;17548:20;17545:1;17538:31;17588:4;17585:1;17578:15;17612:4;17609:1;17602:15;17628:127;17689:10;17684:3;17680:20;17677:1;17670:31;17720:4;17717:1;17710:15;17744:4;17741:1;17734:15;17760:133;-1:-1:-1;;;;;;17836:32:1;;17826:43;;17816:2;;17883:1;17880;17873:12

ipfs://32fa04b9ef4188d1fa21c67cafbb899bfdebd4410cb40abee88f4bf42bcd9e8a