Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ... library Arrays    - function findUpperBound(uint256[] sto ...    - function _msgSender()    - function _msgData()    - function paused()    - function _requireNotPaused()    - function _requirePaused()    - function _pause()    - function _unpause()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _spendAllowance(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function _snapshot()    - function _getCurrentSnapshotId()    - function balanceOfAt(address account, ...    - function totalSupplyAt(uint256 snapsh ...    - function _beforeTokenTransfer(    - function _valueAt(uint256 snapshotId, ...    - function _updateAccountSnapshot(addre ...    - function _updateTotalSupplySnapshot()    - function _updateSnapshot(Snapshots st ...    - function _lastSnapshotId(uint256[] st ...    - function burn(uint256 amount)    - function burnFrom(address account, ui ... interface IERC165    - function supportsInterface(bytes4 int ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(address fro ...    - function transferFrom(address from, a ...    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function safeTransferFrom(address fro ... interface IERC721Enumerable is IERC72 ...    - function totalSupply()    - function tokenOfOwnerByIndex(address ...    - function tokenByIndex(uint256 index)  contract Elan is ERC20, ERC20Burna ... *    - function BAYC_Holders_Claim()    - function MAYC_Holders_Claim()    - function mint(address to, uint256 amo ...    - function snapshot()    - function pause()    - function unpause()    - function _beforeTokenTransfer(address ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// 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/math/Math.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`.
        // We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
        // This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
        // Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
        // good first aproximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1;
        uint256 x = a;
        if (x >> 128 > 0) {
            x >>= 128;
            result <<= 64;
        }
        if (x >> 64 > 0) {
            x >>= 64;
            result <<= 32;
        }
        if (x >> 32 > 0) {
            x >>= 32;
            result <<= 16;
        }
        if (x >> 16 > 0) {
            x >>= 16;
            result <<= 8;
        }
        if (x >> 8 > 0) {
            x >>= 8;
            result <<= 4;
        }
        if (x >> 4 > 0) {
            x >>= 4;
            result <<= 2;
        }
        if (x >> 2 > 0) {
            result <<= 1;
        }

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

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

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


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

pragma solidity ^0.8.0;


/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}

// 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/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @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 Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        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());
    }
}

// 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/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/token/ERC20/extensions/IERC20Metadata.sol


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

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.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, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/extensions/ERC20Snapshot.sol)

pragma solidity ^0.8.0;




/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * NOTE: Snapshot policy can be customized by overriding the {_getCurrentSnapshotId} method. For example, having it
 * return `block.number` will trigger the creation of snapshot at the beginning of each new block. When overriding this
 * function, be careful about the monotonicity of its result. Non-monotonic snapshot ids will break the contract.
 *
 * Implementing snapshots for every block using this method will incur significant gas costs. For a gas-efficient
 * alternative consider {ERC20Votes}.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */

abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minime/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping(address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _getCurrentSnapshotId();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Get the current snapshotId
     */
    function _getCurrentSnapshotId() internal view virtual returns (uint256) {
        return _currentSnapshotId.current();
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }

    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) {
            // mint
            _updateAccountSnapshot(to);
            _updateTotalSupplySnapshot();
        } else if (to == address(0)) {
            // burn
            _updateAccountSnapshot(from);
            _updateTotalSupplySnapshot();
        } else {
            // transfer
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);
        }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots) private view returns (bool, uint256) {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        require(snapshotId <= _getCurrentSnapshotId(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _getCurrentSnapshotId();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol


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

pragma solidity ^0.8.0;



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

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

// File: Elan.sol
                                                                                                   
pragma solidity ^0.8.4;






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);
}
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`, 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 be 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

    /**
      * @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;
}
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

/// @custom:security-contact [email protected]
contract Elan is ERC20, ERC20Burnable, ERC20Snapshot, Ownable, Pausable {
    uint constant public TOTAL_SUPPLY = 1000000000 * 10 ** 18; // 1B
    
    //BAYC
    address constant public BAYC_address = 0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D;
    uint constant public BAYC_claim_tokens = 2500;
    mapping(uint => bool) public BAYC_CLAIMED;

    //MAYC
    address constant public MAYC_address = 0x60E4d786628Fea6478F785A6d7e704777c86a7c6;
    uint constant public MAYC_claim_tokens = 1287133800000000000000; // 1287.1338 set in WEI unit to avoid fixed point conversion
    mapping(uint => bool) public MAYC_CLAIMED;

    uint public start_timestamp_60days;
    uint constant public timestamp_60days = 5184000;

    constructor() ERC20("Elan", "ELAN") {
	    _mint(0xa0d59DF2F3095678A5e271e7211F48355eF1ffAe, 5000000 * 10 ** decimals()); //5M minted to Elan Operational Fund 0xa0d59DF2F3095678A5e271e7211F48355eF1ffAe
        _mint(0xf9DfD78c53557D42eb8e7C5F5633A3Dde8D503B4, 5000000 * 10 ** decimals()); //5M minted to Elan Promotional Fund 0xf9DfD78c53557D42eb8e7C5F5633A3Dde8D503B4
        _mint(0xAFbF80d4CE9E048D4aec5639e10E5eC5356bA6c4, 25000000 * 10 ** decimals()); //25M minted to Elan Early Investor Fund 0xAFbF80d4CE9E048D4aec5639e10E5eC5356bA6c4
        start_timestamp_60days = block.timestamp;
    }

    function BAYC_Holders_Claim() public whenNotPaused {
        require(block.timestamp <= start_timestamp_60days + timestamp_60days, "60 days claim period is over!!");

        IERC721Enumerable BAYC = IERC721Enumerable(BAYC_address);
        uint b = BAYC.balanceOf(msg.sender);
        uint count = 0;
        for(uint i = 0; i < b; i++){
            if(!BAYC_CLAIMED[BAYC.tokenOfOwnerByIndex(msg.sender, i)]){
                BAYC_CLAIMED[BAYC.tokenOfOwnerByIndex(msg.sender, i)] = true;
                count += BAYC_claim_tokens;
            }
        }
        _mint(msg.sender, count * 10 ** decimals());
    }

    function MAYC_Holders_Claim() public whenNotPaused {
        require(block.timestamp <= start_timestamp_60days + timestamp_60days, "60 days claim period is over!!");

        IERC721Enumerable MAYC = IERC721Enumerable(MAYC_address);
        uint b = MAYC.balanceOf(msg.sender);
        uint count = 0;
        for(uint i = 0; i < b; i++){
            if(!MAYC_CLAIMED[MAYC.tokenOfOwnerByIndex(msg.sender, i)]){
                MAYC_CLAIMED[MAYC.tokenOfOwnerByIndex(msg.sender, i)] = true;
                count += MAYC_claim_tokens;
            }
        }
        _mint(msg.sender, count);
    }

    function mint(address to, uint256 amount_in_eth_1) public onlyOwner {
        require(totalSupply() + amount_in_eth_1 * 10 ** 18 <= TOTAL_SUPPLY, "Request exceeds 1B Cap!!");
        _mint(to, amount_in_eth_1 * 10 ** 18);
    }

    function snapshot() public onlyOwner {
        _snapshot();
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        whenNotPaused
        override(ERC20, ERC20Snapshot)
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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":"uint256","name":"","type":"uint256"}],"name":"BAYC_CLAIMED","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BAYC_Holders_Claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"BAYC_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BAYC_claim_tokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MAYC_CLAIMED","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAYC_Holders_Claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"MAYC_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAYC_claim_tokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_SUPPLY","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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount_in_eth_1","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","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":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"start_timestamp_60days","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timestamp_60days","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

50967:3276:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51555:41;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2326:14:1;;2319:22;2301:41;;2289:2;2274:18;51555:41:0;;;;;;;;24127:100;;;:::i;:::-;;;;;;;:::i;26478:201::-;;;;;;:::i;:::-;;:::i;52311:628::-;;;:::i;:::-;;51646:47;;51686:7;51646:47;;;;;9944:25:1;;;9932:2;9917:18;51646:47:0;9899:76:1;51222:45:0;;51263:4;51222:45;;25247:108;25335:12;;25247:108;;51424:63;;51465:22;51424:63;;27259:295;;;;;;:::i;:::-;;:::i;25089:93::-;;;25172:2;10122:36:1;;10110:2;10095:18;25089:93:0;10077:87:1;27963:238:0;;;;;;:::i;:::-;;:::i;53946:65::-;;;:::i;53564:230::-;;;;;;:::i;:::-;;:::i;44444:91::-;;;;;;:::i;:::-;;:::i;39966:266::-;;;;;;:::i;:::-;;:::i;14685:86::-;14756:7;;-1:-1:-1;;;14756:7:0;;;;14685:86;;51134:81;;51173:42;51134:81;;;;;-1:-1:-1;;;;;1838:32:1;;;1820:51;;1808:2;1793:18;51134:81:0;1775:102:1;25418:127:0;;;;;;:::i;:::-;-1:-1:-1;;;;;25519:18:0;25492:7;25519:18;;;;;;;;;;;;25418:127;17550:103;;;:::i;51336:81::-;;51375:42;51336:81;;44854:164;;;;;;:::i;:::-;;:::i;53877:61::-;;;:::i;16902:87::-;16975:6;;-1:-1:-1;;;;;16975:6:0;16902:87;;51046:57;;51082:21;51046:57;;24346:104;;;:::i;53802:67::-;;;:::i;40336:234::-;;;;;;:::i;:::-;;:::i;51605:34::-;;;;;;52947:609;;;:::i;51274:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;28704:436;;;;;;:::i;:::-;;:::i;25751:193::-;;;;;;:::i;:::-;;:::i;26007:151::-;;;;;;:::i;:::-;;:::i;17808:201::-;;;;;;:::i;:::-;;:::i;24127:100::-;24181:13;24214:5;24207:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24127:100;:::o;26478:201::-;26561:4;12878:10;26617:32;12878:10;26633:7;26642:6;26617:8;:32::i;:::-;26667:4;26660:11;;;26478:201;;;;;:::o;52311:628::-;14290:19;:17;:19::i;:::-;51686:7:::1;52400:22;;:41;;;;:::i;:::-;52381:15;:60;;52373:103;;;::::0;-1:-1:-1;;;52373:103:0;;6605:2:1;52373:103:0::1;::::0;::::1;6587:21:1::0;6644:2;6624:18;;;6617:30;6683:32;6663:18;;;6656:60;6733:18;;52373:103:0::1;;;;;;;;;52565:26;::::0;-1:-1:-1;;;52565:26:0;;52580:10:::1;52565:26;::::0;::::1;1820:51:1::0;51173:42:0::1;::::0;52489:22:::1;::::0;51173:42;;52565:14:::1;::::0;1793:18:1;;52565:26:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52556:35;;52602:10;52631:6:::0;52627:251:::1;52647:1;52643;:5;52627:251;;;52686:39;::::0;-1:-1:-1;;;52686:39:0;;52711:10:::1;52686:39;::::0;::::1;2056:51:1::0;2123:18;;;2116:34;;;52673:12:0::1;::::0;:53:::1;::::0;-1:-1:-1;;;;;52686:24:0;::::1;::::0;::::1;::::0;2029:18:1;;52686:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52673:53:::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;52673:53:0;;::::1;;52669:198;;52759:39;::::0;-1:-1:-1;;;52759:39:0;;52784:10:::1;52759:39;::::0;::::1;2056:51:1::0;2123:18;;;2116:34;;;52802:4:0::1;::::0;52746:12:::1;::::0;:53:::1;::::0;-1:-1:-1;;;;;52759:24:0;::::1;::::0;::::1;::::0;2029:18:1;;52759:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52746:53:::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;52746:53:0;:60;;-1:-1:-1;;52746:60:0::1;::::0;::::1;;::::0;;;::::1;::::0;;52825:26:::1;51263:4;52825:26:::0;::::1;:::i;:::-;;;52669:198;52650:3:::0;::::1;::::0;::::1;:::i;:::-;;;;52627:251;;;-1:-1:-1::0;52888:43:0::1;52894:10;52914:16;25172:2:::0;52914::::1;:16;:::i;:::-;52906:24;::::0;:5;:24:::1;:::i;:::-;52888:5;:43::i;:::-;14320:1;;;52311:628::o:0;27259:295::-;27390:4;12878:10;27448:38;27464:4;12878:10;27479:6;27448:15;:38::i;:::-;27497:27;27507:4;27513:2;27517:6;27497:9;:27::i;:::-;-1:-1:-1;27542:4:0;;27259:295;-1:-1:-1;;;;27259:295:0:o;27963:238::-;28051:4;12878:10;28107:64;12878:10;28123:7;28160:10;28132:25;12878:10;28123:7;28132:9;:25::i;:::-;:38;;;;:::i;:::-;28107:8;:64::i;53946:65::-;16788:13;:11;:13::i;:::-;53993:10:::1;:8;:10::i;:::-;53946:65::o:0;53564:230::-;16788:13;:11;:13::i;:::-;51082:21:::1;53667:26;:15:::0;53685:8:::1;53667:26;:::i;:::-;25335:12:::0;;53651:42:::1;;;;:::i;:::-;:58;;53643:95;;;::::0;-1:-1:-1;;;53643:95:0;;6252:2:1;53643:95:0::1;::::0;::::1;6234:21:1::0;6291:2;6271:18;;;6264:30;6330:26;6310:18;;;6303:54;6374:18;;53643:95:0::1;6224:174:1::0;53643:95:0::1;53749:37;53755:2:::0;53759:26:::1;:15:::0;53777:8:::1;53759:26;:::i;53749:37::-;53564:230:::0;;:::o;44444:91::-;44500:27;12878:10;44520:6;44500:5;:27::i;:::-;44444:91;:::o;39966:266::-;-1:-1:-1;;;;;40130:33:0;;40053:7;40130:33;;;:24;:33;;;;;40053:7;;;;40109:55;;40118:10;;40109:8;:55::i;:::-;40073:91;;;;40184:11;:40;;-1:-1:-1;;;;;25519:18:0;;25492:7;25519:18;;;;;;;;;;;40184:40;;;40198:5;40184:40;40177:47;39966:266;-1:-1:-1;;;;;39966:266:0:o;17550:103::-;16788:13;:11;:13::i;:::-;17615:30:::1;17642:1;17615:18;:30::i;44854:164::-:0;44931:46;44947:7;12878:10;44970:6;44931:15;:46::i;:::-;44988:22;44994:7;45003:6;44988:5;:22::i;53877:61::-;16788:13;:11;:13::i;:::-;53922:8:::1;:6;:8::i;24346:104::-:0;24402:13;24435:7;24428:14;;;;;:::i;53802:67::-;16788:13;:11;:13::i;:::-;53850:11:::1;:9;:11::i;40336:234::-:0;40408:7;40429:16;40447:13;40464:43;40473:10;40485:21;40464:8;:43::i;:::-;40428:79;;;;40527:11;:35;;25335:12;;40527:35;;;40541:5;40527:35;40520:42;40336:234;-1:-1:-1;;;;40336:234:0:o;52947:609::-;14290:19;:17;:19::i;:::-;51686:7:::1;53036:22;;:41;;;;:::i;:::-;53017:15;:60;;53009:103;;;::::0;-1:-1:-1;;;53009:103:0;;6605:2:1;53009:103:0::1;::::0;::::1;6587:21:1::0;6644:2;6624:18;;;6617:30;6683:32;6663:18;;;6656:60;6733:18;;53009:103:0::1;6577:180:1::0;53009:103:0::1;53201:26;::::0;-1:-1:-1;;;53201:26:0;;53216:10:::1;53201:26;::::0;::::1;1820:51:1::0;51375:42:0::1;::::0;53125:22:::1;::::0;51375:42;;53201:14:::1;::::0;1793:18:1;;53201:26:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53192:35;;53238:10;53267:6:::0;53263:251:::1;53283:1;53279;:5;53263:251;;;53322:39;::::0;-1:-1:-1;;;53322:39:0;;53347:10:::1;53322:39;::::0;::::1;2056:51:1::0;2123:18;;;2116:34;;;53309:12:0::1;::::0;:53:::1;::::0;-1:-1:-1;;;;;53322:24:0;::::1;::::0;::::1;::::0;2029:18:1;;53322:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53309:53:::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;53309:53:0;;::::1;;53305:198;;53395:39;::::0;-1:-1:-1;;;53395:39:0;;53420:10:::1;53395:39;::::0;::::1;2056:51:1::0;2123:18;;;2116:34;;;53438:4:0::1;::::0;53382:12:::1;::::0;:53:::1;::::0;-1:-1:-1;;;;;53395:24:0;::::1;::::0;::::1;::::0;2029:18:1;;53395:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53382:53:::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;53382:53:0;:60;;-1:-1:-1;;53382:60:0::1;::::0;::::1;;::::0;;;::::1;::::0;;53461:26:::1;51465:22;53461:26:::0;::::1;:::i;:::-;;;53305:198;53286:3:::0;::::1;::::0;::::1;:::i;:::-;;;;53263:251;;;;53524:24;53530:10;53542:5;53524;:24::i;28704:436::-:0;28797:4;12878:10;28797:4;28880:25;12878:10;28897:7;28880:9;:25::i;:::-;28853:52;;28944:15;28924:16;:35;;28916:85;;;;-1:-1:-1;;;28916:85:0;;9234:2:1;28916:85:0;;;9216:21:1;9273:2;9253:18;;;9246:30;9312:34;9292:18;;;9285:62;-1:-1:-1;;;9363:18:1;;;9356:35;9408:19;;28916:85:0;9206:227:1;28916:85:0;29037:60;29046:5;29053:7;29081:15;29062:16;:34;29037:8;:60::i;25751:193::-;25830:4;12878:10;25886:28;12878:10;25903:2;25907:6;25886:9;:28::i;26007:151::-;-1:-1:-1;;;;;26123:18:0;;;26096:7;26123:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;26007:151::o;17808:201::-;16788:13;:11;:13::i;:::-;-1:-1:-1;;;;;17897:22:0;::::1;17889:73;;;::::0;-1:-1:-1;;;17889:73:0;;4677:2:1;17889:73:0::1;::::0;::::1;4659:21:1::0;4716:2;4696:18;;;4689:30;4755:34;4735:18;;;4728:62;-1:-1:-1;;;4806:18:1;;;4799:36;4852:19;;17889:73:0::1;4649:228:1::0;17889:73:0::1;17973:28;17992:8;17973:18;:28::i;40787:622::-:0;-1:-1:-1;;;;;40991:18:0;;40987:415;;41047:26;41070:2;41047:22;:26::i;:::-;41088:28;:26;:28::i;40987:415::-;-1:-1:-1;;;;;41138:16:0;;41134:268;;41192:28;41215:4;41192:22;:28::i;41134:268::-;41321:28;41344:4;41321:22;:28::i;:::-;41364:26;41387:2;41364:22;:26::i;872:114::-;964:14;;872:114::o;32329:380::-;-1:-1:-1;;;;;32465:19:0;;32457:68;;;;-1:-1:-1;;;32457:68:0;;8478:2:1;32457:68:0;;;8460:21:1;8517:2;8497:18;;;8490:30;8556:34;8536:18;;;8529:62;-1:-1:-1;;;8607:18:1;;;8600:34;8651:19;;32457:68:0;8450:226:1;32457:68:0;-1:-1:-1;;;;;32544:21:0;;32536:68;;;;-1:-1:-1;;;32536:68:0;;5084:2:1;32536:68:0;;;5066:21:1;5123:2;5103:18;;;5096:30;5162:34;5142:18;;;5135:62;-1:-1:-1;;;5213:18:1;;;5206:32;5255:19;;32536:68:0;5056:224:1;32536:68:0;-1:-1:-1;;;;;32617:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;32669:32;;9944:25:1;;;32669:32:0;;9917:18:1;32669:32:0;;;;;;;32329:380;;;:::o;14844:108::-;14756:7;;-1:-1:-1;;;14756:7:0;;;;14914:9;14906:38;;;;-1:-1:-1;;;14906:38:0;;6964:2:1;14906:38:0;;;6946:21:1;7003:2;6983:18;;;6976:30;-1:-1:-1;;;7022:18:1;;;7015:46;7078:18;;14906:38:0;6936:166:1;30568:399:0;-1:-1:-1;;;;;30652:21:0;;30644:65;;;;-1:-1:-1;;;30644:65:0;;9640:2:1;30644:65:0;;;9622:21:1;9679:2;9659:18;;;9652:30;9718:33;9698:18;;;9691:61;9769:18;;30644:65:0;9612:181:1;30644:65:0;30722:49;30751:1;30755:7;30764:6;30722:20;:49::i;:::-;30800:6;30784:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;30817:18:0;;:9;:18;;;;;;;;;;:28;;30839:6;;30817:9;:28;;30839:6;;30817:28;:::i;:::-;;;;-1:-1:-1;;30861:37:0;;9944:25:1;;;-1:-1:-1;;;;;30861:37:0;;;30878:1;;30861:37;;9932:2:1;9917:18;30861:37:0;;;;;;;53564:230;;:::o;33000:453::-;33135:24;33162:25;33172:5;33179:7;33162:9;:25::i;:::-;33135:52;;-1:-1:-1;;33202:16:0;:37;33198:248;;33284:6;33264:16;:26;;33256:68;;;;-1:-1:-1;;;33256:68:0;;5487:2:1;33256:68:0;;;5469:21:1;5526:2;5506:18;;;5499:30;5565:31;5545:18;;;5538:59;5614:18;;33256:68:0;5459:179:1;33256:68:0;33368:51;33377:5;33384:7;33412:6;33393:16;:25;33368:8;:51::i;:::-;33000:453;;;;:::o;29610:671::-;-1:-1:-1;;;;;29741:18:0;;29733:68;;;;-1:-1:-1;;;29733:68:0;;8072:2:1;29733:68:0;;;8054:21:1;8111:2;8091:18;;;8084:30;8150:34;8130:18;;;8123:62;-1:-1:-1;;;8201:18:1;;;8194:35;8246:19;;29733:68:0;8044:227:1;29733:68:0;-1:-1:-1;;;;;29820:16:0;;29812:64;;;;-1:-1:-1;;;29812:64:0;;3521:2:1;29812:64:0;;;3503:21:1;3560:2;3540:18;;;3533:30;3599:34;3579:18;;;3572:62;-1:-1:-1;;;3650:18:1;;;3643:33;3693:19;;29812:64:0;3493:225:1;29812:64:0;29889:38;29910:4;29916:2;29920:6;29889:20;:38::i;:::-;-1:-1:-1;;;;;29962:15:0;;29940:19;29962:15;;;;;;;;;;;29996:21;;;;29988:72;;;;-1:-1:-1;;;29988:72:0;;5845:2:1;29988:72:0;;;5827:21:1;5884:2;5864:18;;;5857:30;5923:34;5903:18;;;5896:62;-1:-1:-1;;;5974:18:1;;;5967:36;6020:19;;29988:72:0;5817:228:1;29988:72:0;-1:-1:-1;;;;;30096:15:0;;;:9;:15;;;;;;;;;;;30114:20;;;30096:38;;30156:13;;;;;;;;:23;;30128:6;;30096:9;30156:23;;30128:6;;30156:23;:::i;:::-;;;;;;;;30212:2;-1:-1:-1;;;;;30197:26:0;30206:4;-1:-1:-1;;;;;30197:26:0;;30216:6;30197:26;;;;9944:25:1;;9932:2;9917:18;;9899:76;30197:26:0;;;;;;;;30236:37;52311:628;17067:132;16975:6;;-1:-1:-1;;;;;16975:6:0;12878:10;17131:23;17123:68;;;;-1:-1:-1;;;17123:68:0;;7309:2:1;17123:68:0;;;7291:21:1;;;7328:18;;;7321:30;7387:34;7367:18;;;7360:62;7439:18;;17123:68:0;7281:182:1;15540:120:0;14549:16;:14;:16::i;:::-;15599:7:::1;:15:::0;;-1:-1:-1;;;;15599:15:0::1;::::0;;15630:22:::1;12878:10:::0;15639:12:::1;15630:22;::::0;-1:-1:-1;;;;;1838:32:1;;;1820:51;;1808:2;1793:18;15630:22:0::1;;;;;;;15540:120::o:0;31300:591::-;-1:-1:-1;;;;;31384:21:0;;31376:67;;;;-1:-1:-1;;;31376:67:0;;7670:2:1;31376:67:0;;;7652:21:1;7709:2;7689:18;;;7682:30;7748:34;7728:18;;;7721:62;-1:-1:-1;;;7799:18:1;;;7792:31;7840:19;;31376:67:0;7642:223:1;31376:67:0;31456:49;31477:7;31494:1;31498:6;31456:20;:49::i;:::-;-1:-1:-1;;;;;31543:18:0;;31518:22;31543:18;;;;;;;;;;;31580:24;;;;31572:71;;;;-1:-1:-1;;;31572:71:0;;4274:2:1;31572:71:0;;;4256:21:1;4313:2;4293:18;;;4286:30;4352:34;4332:18;;;4325:62;-1:-1:-1;;;4403:18:1;;;4396:32;4445:19;;31572:71:0;4246:224:1;31572:71:0;-1:-1:-1;;;;;31679:18:0;;:9;:18;;;;;;;;;;31700:23;;;31679:44;;31745:12;:22;;31717:6;;31679:9;31745:22;;31717:6;;31745:22;:::i;:::-;;;;-1:-1:-1;;31785:37:0;;9944:25:1;;;31811:1:0;;-1:-1:-1;;;;;31785:37:0;;;;;9932:2:1;9917:18;31785:37:0;;;;;;;14320:1:::1;;;52311:628::o:0;41417:1619::-;41506:4;41512:7;41553:1;41540:10;:14;41532:49;;;;-1:-1:-1;;;41532:49:0;;8883:2:1;41532:49:0;;;8865:21:1;8922:2;8902:18;;;8895:30;-1:-1:-1;;;8941:18:1;;;8934:52;9003:18;;41532:49:0;8855:172:1;41532:49:0;41614:23;:21;:23::i;:::-;41600:10;:37;;41592:79;;;;-1:-1:-1;;;41592:79:0;;3163:2:1;41592:79:0;;;3145:21:1;3202:2;3182:18;;;3175:30;3241:31;3221:18;;;3214:59;3290:18;;41592:79:0;3135:179:1;41592:79:0;42810:13;42826:40;:9;42855:10;42826:28;:40::i;:::-;42892:20;;42810:56;;-1:-1:-1;42883:29:0;;42879:150;;;42937:5;42944:1;42929:17;;;;;;;42879:150;42987:4;42993:9;:16;;43010:5;42993:23;;;;;;-1:-1:-1;;;42993:23:0;;;;;;;;;;;;;;;;;42979:38;;;;;;;42879:150;41417:1619;;;;;;;:::o;18169:191::-;18262:6;;;-1:-1:-1;;;;;18279:17:0;;;-1:-1:-1;;;;;;18279:17:0;;;;;;;18312:40;;18262:6;;;18279:17;18262:6;;18312:40;;18243:16;;18312:40;18169:191;;:::o;15281:118::-;14290:19;:17;:19::i;:::-;15341:7:::1;:14:::0;;-1:-1:-1;;;;15341:14:0::1;-1:-1:-1::0;;;15341:14:0::1;::::0;;15371:20:::1;15378:12;12878:10:::0;;12798:98;39438:223;39485:7;39505:30;:18;1083:19;;1101:1;1083:19;;;994:127;39505:30;39548:17;39568:23;:21;:23::i;:::-;39548:43;;39607:19;39616:9;39607:19;;;;9944:25:1;;9932:2;9917:18;;9899:76;39607:19:0;;;;;;;;39644:9;39438:223;-1:-1:-1;39438:223:0:o;43044:146::-;-1:-1:-1;;;;;43128:33:0;;;;;;:24;:33;;;;;;;;25519:18;;;;;;;;43112:70;;43128:33;43112:15;:70::i;43163:18::-;43112:15;:70::i;43198:118::-;43255:53;43271:21;43294:13;25335:12;;;25247:108;54019:221;14290:19;:17;:19::i;:::-;54188:44:::1;54215:4;54221:2;54225:6;54188:26;:44::i;15029:108::-:0;14756:7;;-1:-1:-1;;;14756:7:0;;;;15088:41;;;;-1:-1:-1;;;15088:41:0;;3925:2:1;15088:41:0;;;3907:21:1;3964:2;3944:18;;;3937:30;-1:-1:-1;;;3983:18:1;;;3976:50;4043:18;;15088:41:0;3897:170:1;39727:127:0;39791:7;39818:28;:18;964:14;;872:114;39818:28;39811:35;;39727:127;:::o;11194:918::-;11307:12;;11283:7;;11303:58;;-1:-1:-1;11348:1:0;11341:8;;11303:58;11414:12;;11373:11;;11439:424;11452:4;11446:3;:10;11439:424;;;11473:11;11487:23;11500:3;11505:4;11487:12;:23::i;:::-;11473:37;;11744:7;11731:5;11737:3;11731:10;;;;;;-1:-1:-1;;;11731:10:0;;;;;;;;;;;;;;;;;:20;11727:125;;;11779:3;11772:10;;11727:125;;;11829:7;:3;11835:1;11829:7;:::i;:::-;11823:13;;11727:125;11439:424;;;;11989:1;11983:3;:7;:36;;;;-1:-1:-1;12012:7:0;11994:5;12000:7;12006:1;12000:3;:7;:::i;:::-;11994:14;;;;;;-1:-1:-1;;;11994:14:0;;;;;;;;;;;;;;;;;:25;11983:36;11979:126;;;12043:7;12049:1;12043:3;:7;:::i;:::-;12036:14;;;;;;11979:126;-1:-1:-1;12090:3:0;-1:-1:-1;12083:10:0;;43324:310;43419:17;43439:23;:21;:23::i;:::-;43419:43;-1:-1:-1;43419:43:0;43477:30;43493:9;43477:15;:30::i;:::-;:42;43473:154;;;43536:29;;;;;;;;-1:-1:-1;43536:29:0;;;;;;;;;;;;;;43580:16;;;:35;;;;;;;;;;;;;;;43324:310::o;2329:156::-;2391:7;2466:11;2476:1;2467:5;;;2466:11;:::i;:::-;2456:21;;2457:5;;;2456:21;:::i;:::-;2449:28;2329:156;-1:-1:-1;;;2329:156:0:o;43642:212::-;43736:10;;43712:7;;43732:115;;-1:-1:-1;43775:1:0;;43642:212;-1:-1:-1;43642:212:0:o;43732:115::-;43820:10;;43816:3;;43820:14;;43833:1;;43820:14;:::i;:::-;43816:19;;;;;;-1:-1:-1;;;43816:19:0;;;;;;;;;;;;;;;;;43809:26;;43642:212;;;:::o;43732:115::-;43642:212;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;192:196;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;325:6;317;310:22;272:2;353:29;372:9;353:29;:::i;393:270::-;461:6;469;522:2;510:9;501:7;497:23;493:32;490:2;;;543:6;535;528:22;490:2;571:29;590:9;571:29;:::i;:::-;561:39;;619:38;653:2;642:9;638:18;619:38;:::i;:::-;609:48;;480:183;;;;;:::o;668:338::-;745:6;753;761;814:2;802:9;793:7;789:23;785:32;782:2;;;835:6;827;820:22;782:2;863:29;882:9;863:29;:::i;:::-;853:39;;911:38;945:2;934:9;930:18;911:38;:::i;:::-;901:48;;996:2;985:9;981:18;968:32;958:42;;772:234;;;;;:::o;1011:264::-;1079:6;1087;1140:2;1128:9;1119:7;1115:23;1111:32;1108:2;;;1161:6;1153;1146:22;1108:2;1189:29;1208:9;1189:29;:::i;:::-;1179:39;1265:2;1250:18;;;;1237:32;;-1:-1:-1;;;1098:177:1:o;1280:190::-;1339:6;1392:2;1380:9;1371:7;1367:23;1363:32;1360:2;;;1413:6;1405;1398:22;1360:2;-1:-1:-1;1441:23:1;;1350:120;-1:-1:-1;1350:120:1:o;1475:194::-;1545:6;1598:2;1586:9;1577:7;1573:23;1569:32;1566:2;;;1619:6;1611;1604:22;1566:2;-1:-1:-1;1647:16:1;;1556:113;-1:-1:-1;1556:113:1:o;2353:603::-;2465:4;2494:2;2523;2512:9;2505:21;2555:6;2549:13;2598:6;2593:2;2582:9;2578:18;2571:34;2623:4;2636:140;2650:6;2647:1;2644:13;2636:140;;;2745:14;;;2741:23;;2735:30;2711:17;;;2730:2;2707:26;2700:66;2665:10;;2636:140;;;2794:6;2791:1;2788:13;2785:2;;;2864:4;2859:2;2850:6;2839:9;2835:22;2831:31;2824:45;2785:2;-1:-1:-1;2940:2:1;2919:15;-1:-1:-1;;2915:29:1;2900:45;;;;2947:2;2896:54;;2474:482;-1:-1:-1;;;2474:482:1:o;10169:128::-;10209:3;10240:1;10236:6;10233:1;10230:13;10227:2;;;10246:18;;:::i;:::-;-1:-1:-1;10282:9:1;;10217:80::o;10302:217::-;10342:1;10368;10358:2;;-1:-1:-1;;;10393:31:1;;10447:4;10444:1;10437:15;10475:4;10400:1;10465:15;10358:2;-1:-1:-1;10504:9:1;;10348:171::o;10524:422::-;10613:1;10656:5;10613:1;10670:270;10691:7;10681:8;10678:21;10670:270;;;10750:4;10746:1;10742:6;10738:17;10732:4;10729:27;10726:2;;;10759:18;;:::i;:::-;10809:7;10799:8;10795:22;10792:2;;;10829:16;;;;10792:2;10908:22;;;;10868:15;;;;10670:270;;10951:140;11009:5;11038:47;11079:4;11069:8;11065:19;11059:4;11145:5;11175:8;11165:2;;-1:-1:-1;11216:1:1;11230:5;;11165:2;11264:4;11254:2;;-1:-1:-1;11301:1:1;11315:5;;11254:2;11346:4;11364:1;11359:59;;;;11432:1;11427:130;;;;11339:218;;11359:59;11389:1;11380:10;;11403:5;;;11427:130;11464:3;11454:8;11451:17;11448:2;;;11471:18;;:::i;:::-;-1:-1:-1;;11527:1:1;11513:16;;11542:5;;11339:218;;11641:2;11631:8;11628:16;11622:3;11616:4;11613:13;11609:36;11603:2;11593:8;11590:16;11585:2;11579:4;11576:12;11572:35;11569:77;11566:2;;;-1:-1:-1;11678:19:1;;;11710:5;;11566:2;11757:34;11782:8;11776:4;11757:34;:::i;:::-;11827:6;11823:1;11819:6;11815:19;11806:7;11803:32;11800:2;;;11838:18;;:::i;:::-;11876:20;;11155:747;-1:-1:-1;;;11155:747:1:o;11907:168::-;11947:7;12013:1;12009;12005:6;12001:14;11998:1;11995:21;11990:1;11983:9;11976:17;11972:45;11969:2;;;12020:18;;:::i;:::-;-1:-1:-1;12060:9:1;;11959:116::o;12080:125::-;12120:4;12148:1;12145;12142:8;12139:2;;;12153:18;;:::i;:::-;-1:-1:-1;12190:9:1;;12129:76::o;12210:380::-;12289:1;12285:12;;;;12332;;;12353:2;;12407:4;12399:6;12395:17;12385:27;;12353:2;12460;12452:6;12449:14;12429:18;12426:38;12423:2;;;12506:10;12501:3;12497:20;12494:1;12487:31;12541:4;12538:1;12531:15;12569:4;12566:1;12559:15;12423:2;;12265:325;;;:::o;12595:135::-;12634:3;-1:-1:-1;;12655:17:1;;12652:2;;;12675:18;;:::i;:::-;-1:-1:-1;12722:1:1;12711:13;;12642:88::o;12735:127::-;12796:10;12791:3;12787:20;12784:1;12777:31;12827:4;12824:1;12817:15;12851:4;12848:1;12841:15

ipfs://c34c54cc90deee0f37016016a473b5af14e6e1e2869ca40e368bf52c3efd33fc