Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-03-07
*/

/**

        Melania Trump’s Butthole

            100M supply

    They hate us because they anus.

            T.me/MTButthole

           www.MTButthole.com

            X.com/MTButthole

*/

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

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

interface IUniswapV2Pair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

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

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

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

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

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

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

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to)
        external
        returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

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

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

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

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

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

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) 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 {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

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

    uint256 internal _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 18;
    }

    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 recipient, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

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

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].add(addedValue)
        );
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: transfer amount exceeds balance"
        );
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

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

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

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

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

        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: burn amount exceeds balance"
        );
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

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

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

interface DividendPayingTokenOptionalInterface {
    function withdrawableDividendOf(address _owner)
        external
        view
        returns (uint256);

    function withdrawnDividendOf(address _owner)
        external
        view
        returns (uint256);

    function accumulativeDividendOf(address _owner)
        external
        view
        returns (uint256);
}

interface DividendPayingTokenInterface {
    function dividendOf(address _owner) external view returns (uint256);

    function distributeDividends() external payable;

    function withdrawDividend() external;

    event DividendsDistributed(address indexed from, uint256 weiAmount);

    event DividendWithdrawn(address indexed to, uint256 weiAmount);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

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

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

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

contract Ownable is Context {
    address private _owner;

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

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

        // Detect overflow when multiplying MIN_INT256 with -1
        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256);

        // Solidity already throws when dividing by 0.
        return a / b;
    }

    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }

    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}

library SafeMathUint {
    function toInt256Safe(uint256 a) internal pure returns (int256) {
        int256 b = int256(a);
        require(b >= 0);
        return 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 DividendPayingToken is
    ERC20,
    DividendPayingTokenInterface,
    DividendPayingTokenOptionalInterface
{
    using SafeMath for uint256;
    using SafeMathUint for uint256;
    using SafeMathInt for int256;

    uint256 internal constant magnitude = 2**128;

    uint256 internal magnifiedDividendPerShare;

    mapping(address => int256) internal magnifiedDividendCorrections;
    mapping(address => uint256) internal withdrawnDividends;

    uint256 public totalDividendsDistributed;

    constructor(string memory _name, string memory _symbol)
        ERC20(_name, _symbol)
    {}

    receive() external payable {
        distributeDividends();
    }

    function distributeDividends() public payable override {
        require(totalSupply() > 0);

        if (msg.value > 0) {
            magnifiedDividendPerShare = magnifiedDividendPerShare.add(
                (msg.value).mul(magnitude) / totalSupply()
            );
            emit DividendsDistributed(msg.sender, msg.value);

            totalDividendsDistributed = totalDividendsDistributed.add(
                msg.value
            );
        }
    }

    function withdrawDividend() public virtual override {
        _withdrawDividendOfUser(payable(msg.sender));
    }

    function _withdrawDividendOfUser(address payable user)
        internal
        virtual
        returns (uint256)
    {
        uint256 _withdrawableDividend = withdrawableDividendOf(user);
        if (_withdrawableDividend > 0) {
            withdrawnDividends[user] = withdrawnDividends[user].add(
                _withdrawableDividend
            );
            emit DividendWithdrawn(user, _withdrawableDividend);
            (bool success, ) = user.call{
                value: _withdrawableDividend,
                gas: 3000
            }("");

            if (!success) {
                withdrawnDividends[user] = withdrawnDividends[user].sub(
                    _withdrawableDividend
                );
                return 0;
            }

            return _withdrawableDividend;
        }

        return 0;
    }

    function dividendOf(address _owner) public view override returns (uint256) {
        return withdrawableDividendOf(_owner);
    }

    function withdrawableDividendOf(address _owner)
        public
        view
        override
        returns (uint256)
    {
        return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]);
    }

    function withdrawnDividendOf(address _owner)
        public
        view
        override
        returns (uint256)
    {
        return withdrawnDividends[_owner];
    }

    function accumulativeDividendOf(address _owner)
        public
        view
        override
        returns (uint256)
    {
        return
            magnifiedDividendPerShare
                .mul(balanceOf(_owner))
                .toInt256Safe()
                .add(magnifiedDividendCorrections[_owner])
                .toUint256Safe() / magnitude;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal virtual override {
        require(false);

        int256 _magCorrection = magnifiedDividendPerShare
            .mul(value)
            .toInt256Safe();
        magnifiedDividendCorrections[from] = magnifiedDividendCorrections[from]
            .add(_magCorrection);
        magnifiedDividendCorrections[to] = magnifiedDividendCorrections[to].sub(
            _magCorrection
        );
    }

    function _mint(address account, uint256 value) internal override {
        super._mint(account, value);

        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
            account
        ].sub((magnifiedDividendPerShare.mul(value)).toInt256Safe());
    }

    function _burn(address account, uint256 value) internal override {
        super._burn(account, value);

        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
            account
        ].add((magnifiedDividendPerShare.mul(value)).toInt256Safe());
    }

    function _setBalance(address account, uint256 newBalance) internal {
        uint256 currentBalance = balanceOf(account);

        if (newBalance > currentBalance) {
            uint256 mintAmount = newBalance.sub(currentBalance);
            _mint(account, mintAmount);
        } else if (newBalance < currentBalance) {
            uint256 burnAmount = currentBalance.sub(newBalance);
            _burn(account, burnAmount);
        }
    }
}

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

    IUniswapV2Router02 public uniswapV2Router;

    address public uniswapV2Pair;
    address public DEAD = 0x000000000000000000000000000000000000dEaD;
    bool private swapping;
    bool public tradingEnabled = false;

    uint256 public sellAmount = 1;
    uint256 public buyAmount = 1;

    uint256 private totalSellFees;
    uint256 private totalBuyFees;

    BUTTHOLEDividendTracker public dividendTracker;

    address payable public marketingWallet;
    address payable public DevWallet;

    // Max tx, dividend threshold and tax variables
    uint256 public maxWallet;
    uint256 public swapThreshold;
    uint256 public swapTokensAtAmount;
    uint256 public sellRewardsFee;
    uint256 public sellMarketingFees;
    uint256 public buyMarketingFees;
    uint256 public buyRewardsFee;
    uint256 public buyDevFee;
    uint256 public sellDevFee;

    // gas for processing auto claim dividends 
    uint256 public gasForProcessing = 300000;

    // exlcude from fees and max transaction amount
    mapping(address => bool) private _isExcludedFromFees;

    mapping(address => bool) public automatedMarketMakerPairs;

    //for allowing specific address to trade while trading has not been enabled yet 
    mapping(address => bool) private canTransferBeforeTradingIsEnabled;  
    
    event updateMarketingWallet(address wallet);
    event updateDevWallet(address wallet);

    event UpdateDividendTracker(
        address indexed newAddress,
        address indexed oldAddress
    );

    event UpdateUniswapV2Router(
        address indexed newAddress,
        address indexed oldAddress
    );

    event TradingEnabled();

    event UpdateFees(
        uint256 sellMarketingFees,
        uint256 sellRewardsFee,
        uint256 buyMarketingFees,
        uint256 buyRewardsFee,
        uint256 buyDevFee,
        uint256 sellDevFee
    );


    event ExcludeFromFees(address indexed account, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    event GasForProcessingUpdated(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );

    event SendDividends(uint256 amount, uint256 opAmount, bool success);

    event ProcessedDividendTracker(
        uint256 iterations,
        uint256 claims,
        uint256 lastProcessedIndex,
        bool indexed automatic,
        uint256 gas,
        address indexed processor
    );

    event UpdatePayoutToken(address token);

    constructor() ERC20("Melania Trumps Butthole", "$BUTTHOLE") {
        marketingWallet = payable(0xe6c1e7b41d709730EA18fc309673e88166F591bf);
        DevWallet = payable(0xA93bC64A07976882A43bb87E111c14599f8CfdC0);
        address router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

        buyMarketingFees = 3600;
        sellMarketingFees = 3600;
        buyRewardsFee = 0;
        sellRewardsFee = 0;
        buyDevFee = 400;
        sellDevFee = 400;

        totalBuyFees = buyRewardsFee
            .add(buyMarketingFees)
            .add(buyDevFee);
        totalSellFees = sellRewardsFee
            .add(sellMarketingFees)
            .add(sellDevFee);

        dividendTracker = new BUTTHOLEDividendTracker(
            payable(this),
            router,
            0x576e2BeD8F7b46D34016198911Cdf9886f78bea7,
            "BUTTHOLETRACKER",
            "MTBTRACKER"
        );

        uniswapV2Router = IUniswapV2Router02(router);
        // Create a uniswap pair for this new token
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
                address(this),
                uniswapV2Router.WETH()
            );

        _setAutomatedMarketMakerPair(uniswapV2Pair, true);

        // exclude from receiving dividends
        dividendTracker.excludeFromDividends(address(dividendTracker));
        dividendTracker.excludeFromDividends(address(this));
        dividendTracker.excludeFromDividends(DEAD);
        dividendTracker.excludedFromDividends(address(0));
        dividendTracker.excludeFromDividends(router);
        dividendTracker.excludeFromDividends(marketingWallet);
        dividendTracker.excludeFromDividends(owner());

        // exclude from paying fees or having max transaction amount
        _isExcludedFromFees[address(this)] = true;
        _isExcludedFromFees[address(dividendTracker)] = true;
        _isExcludedFromFees[address(marketingWallet)] = true;
        _isExcludedFromFees[address(DevWallet)] = true;
        _isExcludedFromFees[msg.sender] = true;

        uint256 totalTokenSupply = (100_000_000) * (10**18);
        _mint(owner(), totalTokenSupply); // only time internal mint function is ever called is to create supply
        maxWallet = totalTokenSupply / 50; // 2%
        swapThreshold = totalTokenSupply / 200; // 0.5%
        swapTokensAtAmount = totalTokenSupply / 1000; // 0.1%
        canTransferBeforeTradingIsEnabled[owner()] = true;
        canTransferBeforeTradingIsEnabled[address(this)] = true; 
    }

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

    receive() external payable {}

    function enableTrading() external onlyOwner {
        require(!tradingEnabled);
        tradingEnabled = true;
        emit TradingEnabled();
    }
    
    // set new marketing wallet
    function setMarketingWallet(address wallet) external onlyOwner {
        _isExcludedFromFees[wallet] = true;
        marketingWallet = payable(wallet);
        emit updateMarketingWallet(wallet);
    }

    //set new Dev wallet
    function setDevWallet(address wallet) external onlyOwner {
        _isExcludedFromFees[wallet] = true;
        DevWallet = payable(wallet);
        emit updateDevWallet(wallet);
    }    
    
    // exclude a wallet from fees 
    function setExcludeFees(address account, bool excluded) public onlyOwner {
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }

    // exclude from dividends (rewards)
    function setExcludeDividends(address account) public onlyOwner {
        dividendTracker.excludeFromDividends(account);
    }

    // include in dividends 
    function setIncludeDividends(address account) public onlyOwner {
        dividendTracker.includeFromDividends(account);
        dividendTracker.setBalance(account, 0);
    }

    //allow a wallet to trade before trading enabled
    function setCanTransferBefore(address wallet, bool enable)
        external
        onlyOwner
    {
        canTransferBeforeTradingIsEnabled[wallet] = enable;
    }

    // set max wallet, can not be lower than 0.05% of supply
    function setmaxWallet(uint256 _maxwallet) external onlyOwner {
        require(_maxwallet >= 50000, "max wallet cannot be set to less than 0.05%");
        maxWallet = _maxwallet * (10 ** 18);
    }

    // tax threshold
    function setSwapTriggerAmount(uint256 amount) public onlyOwner {
        swapTokensAtAmount = amount * (10 ** 18);
    }

    function changeSwapthreshold(uint256 _swapThreshold) public onlyOwner {
        require(_swapThreshold > 0 && _swapThreshold <= 3000001, "Swap threshold must be greater than 0 and less than 3% of total supply");
        swapThreshold = _swapThreshold * (10 ** 18);
    }

    function setAutomatedMarketMakerPair(address pair, bool value)
        public
        onlyOwner
    {
        _setAutomatedMarketMakerPair(pair, value);
    }

    function setAllowCustomTokens(bool allow) public onlyOwner {
        dividendTracker.setAllowCustomTokens(allow);
    }

    function setAllowAutoReinvest(bool allow) public onlyOwner {
        dividendTracker.setAllowAutoReinvest(allow);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;

        if (value) {
            dividendTracker.excludeFromDividends(pair);
        }

        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function updateGasForProcessing(uint256 newValue) public onlyOwner {
        require(newValue >= 200000 && newValue <= 1000000);
        emit GasForProcessingUpdated(newValue, gasForProcessing);
        gasForProcessing = newValue;
    }

    function transferAdmin(address newOwner) public onlyOwner {
        dividendTracker.excludeFromDividends(newOwner);
        _isExcludedFromFees[newOwner] = true;
        transferOwnership(newOwner);
    }

    function updateFees(
        uint256 marketingBuy,
        uint256 marketingSell,
        uint256 RewardsBuy,
        uint256 RewardsSell,
        uint256 DevBuy,
        uint256 DevSell
    ) public onlyOwner {
        buyMarketingFees = marketingBuy;
        buyRewardsFee = RewardsBuy;
        sellMarketingFees = marketingSell;
        sellRewardsFee = RewardsSell;
        buyDevFee = DevBuy;
        sellDevFee = DevSell;

        totalSellFees = sellRewardsFee
            .add(sellMarketingFees)
            .add(sellDevFee);

        totalBuyFees = buyRewardsFee
            .add(buyMarketingFees)
            .add(buyDevFee);

        require(totalSellFees <= 500 && totalBuyFees <= 500, "total fees cannot exceed 8% sell or buy");

        emit UpdateFees(
            sellMarketingFees,
            sellRewardsFee,
            buyMarketingFees,
            buyRewardsFee,
            buyDevFee,
            sellDevFee
        );
    }

    function getTotalDividendsDistributed() external view returns (uint256) {
        return dividendTracker.totalDividendsDistributed();
    }

    function isExcludedFromFees(address account) public view returns (bool) {
        return _isExcludedFromFees[account];
    }

    function withdrawableDividendOf(address account)
        public
        view
        returns (uint256)
    {
        return dividendTracker.withdrawableDividendOf(account);
    }

    function dividendTokenBalanceOf(address account)
        public
        view
        returns (uint256)
    {
        return dividendTracker.balanceOf(account);
    }

    function getAccountDividendsInfo(address account)
        external
        view
        returns (
            address,
            int256,
            int256,
            uint256,
            uint256,
            uint256
        )
    {
        return dividendTracker.getAccount(account);
    }

    function getAccountDividendsInfoAtIndex(uint256 index)
        external
        view
        returns (
            address,
            int256,
            int256,
            uint256,
            uint256,
            uint256
        )
    {
        return dividendTracker.getAccountAtIndex(index);
    }

    function processDividendTracker(uint256 gas) external {
        (
            uint256 iterations,
            uint256 claims,
            uint256 lastProcessedIndex
        ) = dividendTracker.process(gas);
        emit ProcessedDividendTracker(
            iterations,
            claims,
            lastProcessedIndex,
            false,
            gas,
            tx.origin
        );
    }

    function claim() external {
        dividendTracker.processAccount(payable(msg.sender), false);
    }

    function getLastProcessedIndex() external view returns (uint256) {
        return dividendTracker.getLastProcessedIndex();
    }

    function getNumberOfDividendTokenHolders() external view returns (uint256) {
        return dividendTracker.getNumberOfTokenHolders();
    }

    function setAutoClaim(bool value) external {
        dividendTracker.setAutoClaim(msg.sender, value);
    }

    function setReinvest(bool value) external {
        dividendTracker.setReinvest(msg.sender, value);
    }

    function setDividendsPaused(bool value) external onlyOwner {
        dividendTracker.setDividendsPaused(value);
    }

    function isExcludedFromAutoClaim(address account)
        external
        view
        returns (bool)
    {
        return dividendTracker.isExcludedFromAutoClaim(account);
    }

    function isReinvest(address account) external view returns (bool) {
        return dividendTracker.isReinvest(account);
    }

    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");
        uint256 RewardsFee;
        uint256 marketingFees;
        uint256 DevFee;

        if (!canTransferBeforeTradingIsEnabled[from]) {
            require(tradingEnabled, "Trading has not yet been enabled");
        }        
        
        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        } 
        
        if (to == DEAD) {
            _burn(from, amount);
            return;
        }

        else if (
            !swapping && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]
        ) {
            bool isSelling = automatedMarketMakerPairs[to];
            bool isBuying = automatedMarketMakerPairs[from];
            
            if (!isBuying && !isSelling) {
                super._transfer(from, to, amount);
                dividendTracker.setBalance(from, balanceOf(from));
                dividendTracker.setBalance(to, balanceOf(to));
                return;
            }

            else if (isSelling) {
                RewardsFee = sellRewardsFee;
                marketingFees = sellMarketingFees;
                DevFee = sellDevFee;

            } else if (isBuying) {
                RewardsFee = buyRewardsFee;
                marketingFees = buyMarketingFees;
                DevFee = buyDevFee;

                uint256 contractBalanceRecipient = balanceOf(to);
                require(contractBalanceRecipient + amount <= maxWallet,"Exceeds maximum wallet token amount." );
            }
            uint256 totalFees = RewardsFee
                .add(marketingFees + DevFee);

            uint256 contractTokenBalance = balanceOf(address(this));

            bool canSwap = contractTokenBalance >= swapTokensAtAmount;

            if (canSwap && !automatedMarketMakerPairs[from]) {
                swapping = true;

                uint256 remainingBalance = balanceOf(address(this));
                swapAndSendDividends(remainingBalance);
                buyAmount = 1;
                sellAmount = 1;
                swapping = false;
            }

            uint256 fees = amount.mul(totalFees).div(10000);

            amount = amount.sub(fees);

            if (isSelling) {
                sellAmount = sellAmount.add(fees);
            } else {
                buyAmount = buyAmount.add(fees);
            }

            super._transfer(from, address(this), fees);

        }

        super._transfer(from, to, amount);
        dividendTracker.setBalance(from, balanceOf(from));
        dividendTracker.setBalance(to, balanceOf(to));
        
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        uint256 tokensToSwap = (tokenAmount > swapThreshold) ? swapThreshold : tokenAmount;
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokensToSwap );
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokensToSwap,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    function updatePayoutToken(address token) public onlyOwner {
        dividendTracker.updatePayoutToken(token);
        emit UpdatePayoutToken(token);
    }

    function getPayoutToken() public view returns (address) {
        return dividendTracker.getPayoutToken();
    }

    function getMinimumTokenBalanceForAutoDividends() public view returns (uint256) {
        return dividendTracker.getMinimumTokenBalanceForAutoDividends();
    }

    function getMinimumTokenBalanceForDividends() public view returns (uint256) {
        return dividendTracker.getMinimumTokenBalanceForDividends();
    }        

    function setMinimumTokenBalanceForAutoDividends(uint256 value)
        public
        onlyOwner
    {
        dividendTracker.setMinimumTokenBalanceForAutoDividends(value);
    }

    function setMinimumTokenBalanceForDividends(uint256 value)
        public
        onlyOwner
    {
        dividendTracker.setMinimumTokenBalanceForDividends(value);
    }

    function forceSwapAndSendDividends(uint256 tokens) public onlyOwner {
        tokens = tokens * (10**18);
        uint256 totalAmount = buyAmount.add(sellAmount);
        uint256 fromBuy = tokens.mul(buyAmount).div(totalAmount);
        uint256 fromSell = tokens.mul(sellAmount).div(totalAmount);

        swapAndSendDividends(tokens);

        buyAmount = buyAmount.sub(fromBuy);
        sellAmount = sellAmount.sub(fromSell);
    }

    function swapAndSendDividends(uint256 tokens) private {
        if (tokens == 0) {
            return;
        }
        swapTokensForEth(tokens);
        uint256 totalAmount = buyAmount.add(sellAmount);

        bool success = true;
        bool successOp1 = true;
        bool successOp2 = true;

        uint256 dividends;
        uint256 dividendsFromBuy;
        uint256 dividendsFromSell;

        if (buyRewardsFee > 0) {
            dividendsFromBuy = address(this)
            .balance
            .mul(buyAmount)
            .div(totalAmount)
            .mul(buyRewardsFee)
            .div(buyRewardsFee + buyMarketingFees + buyDevFee);
        }
        if (sellRewardsFee > 0) {
            dividendsFromSell = address(this)
            .balance
            .mul(sellAmount)
            .div(totalAmount)
            .mul(sellRewardsFee)
            .div(sellRewardsFee + sellMarketingFees + sellDevFee);
        }
        dividends = dividendsFromBuy.add(dividendsFromSell);

        if (dividends > 0) {
            (success, ) = address(dividendTracker).call{value: dividends}("");
        }
        
        uint256 _completeFees = sellMarketingFees.add(sellDevFee) +
            buyMarketingFees.add(buyDevFee);

        uint256 feePortions;
        if (_completeFees > 0) {
            feePortions = address(this).balance.div(_completeFees);
        }
        uint256 marketingPayout = buyMarketingFees.add(sellMarketingFees) * feePortions;
        uint256 DevPayout = buyDevFee.add(sellDevFee) * feePortions;

        if (marketingPayout > 0) {
            (successOp1, ) = address(marketingWallet).call{value: marketingPayout}("");
        }
        if (DevPayout > 0) {
            (successOp2, ) = address(DevWallet).call{value: DevPayout}("");
        }

        emit SendDividends(
            dividends,
            marketingPayout + DevPayout,
            success && successOp1 && successOp2
        );
    }

    function airdropToWallets(
        address[] memory airdropWallets,
        uint256[] memory amount
    ) external onlyOwner {
        require(airdropWallets.length == amount.length,"Arrays must be the same length");
        require(airdropWallets.length <= 200, "Wallets list length must be <= 200");
        for (uint256 i = 0; i < airdropWallets.length; i++) {
            address wallet = airdropWallets[i];
            uint256 airdropAmount = amount[i] * (10**18);
            super._transfer(msg.sender, wallet, airdropAmount);
            dividendTracker.setBalance(payable(wallet), balanceOf(wallet));
        }
    }
}

contract BUTTHOLEDividendTracker is DividendPayingToken, Ownable {
    using SafeMath for uint256;
    using SafeMathInt for int256;
    using IterableMapping for IterableMapping.Map;

    IterableMapping.Map private tokenHoldersMap;
    uint256 public lastProcessedIndex;

    mapping(address => bool) public excludedFromDividends;
    mapping(address => bool) public excludedFromAutoClaim;
    mapping(address => bool) public autoReinvest;
    address public defaultToken; 
    bool public allowCustomTokens;
    bool public allowAutoReinvest;
    bool public dividendsPaused = false;

    string private trackerName;
    string private trackerTicker;

    IUniswapV2Router02 public uniswapV2Router;

    BUTTHOLE public BUTTHOLEContract;

    mapping(address => uint256) public lastClaimTimes;

    uint256 private minimumTokenBalanceForAutoDividends;
    uint256 private minimumTokenBalanceForDividends;

    event ExcludeFromDividends(address indexed account);
    event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
    event DividendReinvested(
        address indexed acount,
        uint256 value,
        bool indexed automatic
    );
    event Claim(
        address indexed account,
        uint256 amount,
        bool indexed automatic
    );
    event DividendsPaused(bool paused);
    event SetAllowCustomTokens(bool allow);
    event SetAllowAutoReinvest(bool allow);

    constructor(
        address payable mainContract,
        address router,
        address token,
        string memory _name,
        string memory _ticker
    ) DividendPayingToken(_name, _ticker) {
        trackerName = _name;
        trackerTicker = _ticker;
        defaultToken = token;
        BUTTHOLEContract = BUTTHOLE(mainContract);
        minimumTokenBalanceForAutoDividends = 50_000_000 * (10**18);
        minimumTokenBalanceForDividends = 100 * (10**18);

        uniswapV2Router = IUniswapV2Router02(router);
        allowCustomTokens = true;
        allowAutoReinvest = false;
    }

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

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

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

    function _transfer(
        address,
        address,
        uint256
    ) internal pure override {
        require(false, "BUTTHOLE_Dividend_Tracker: No transfers allowed");
    }

    function withdrawDividend() public pure override {
        require(
            false,
            "BUTTHOLE_Dividend_Tracker: withdrawDividend disabled. Use the 'claim' function on the main BUTTHOLE contract."
        );
    }

    function isExcludedFromAutoClaim(address account)
        external
        view
        onlyOwner
        returns (bool)
    {
        return excludedFromAutoClaim[account];
    }

    function isReinvest(address account)
        external
        view
        onlyOwner
        returns (bool)
    {
        return autoReinvest[account];
    }

    function setAllowCustomTokens(bool allow) external onlyOwner {
        require(allowCustomTokens != allow);
        allowCustomTokens = allow;
        emit SetAllowCustomTokens(allow);
    }

    function setAllowAutoReinvest(bool allow) external onlyOwner {
        require(allowAutoReinvest != allow);
        allowAutoReinvest = allow;
        emit SetAllowAutoReinvest(allow);
    }

    function excludeFromDividends(address account) external onlyOwner {
        //require(!excludedFromDividends[account]);
        excludedFromDividends[account] = true;

        _setBalance(account, 0);
        tokenHoldersMap.remove(account);

        emit ExcludeFromDividends(account);
    }

    function includeFromDividends(address account) external onlyOwner {
        excludedFromDividends[account] = false;
    }

    function setAutoClaim(address account, bool value) external onlyOwner {
        excludedFromAutoClaim[account] = value;
    }

    function setReinvest(address account, bool value) external onlyOwner {
        autoReinvest[account] = value;
    }

    function setMinimumTokenBalanceForAutoDividends(uint256 value)
        external
        onlyOwner
    {
        minimumTokenBalanceForAutoDividends = value * (10**18);
    }

    function setMinimumTokenBalanceForDividends(uint256 value)
        external
        onlyOwner
    {
        minimumTokenBalanceForDividends = value * (10**18);
    }

    function setDividendsPaused(bool value) external onlyOwner {
        require(dividendsPaused != value);
        dividendsPaused = value;
        emit DividendsPaused(value);
    }

    function getLastProcessedIndex() external view returns (uint256) {
        return lastProcessedIndex;
    }

    function getNumberOfTokenHolders() external view returns (uint256) {
        return tokenHoldersMap.keys.length;
    }

    function getAccount(address _account)
        public
        view
        returns (
            address account,
            int256 index,
            int256 iterationsUntilProcessed,
            uint256 withdrawableDividends,
            uint256 totalDividends,
            uint256 lastClaimTime
        )
    {
        account = _account;

        index = tokenHoldersMap.getIndexOfKey(account);

        iterationsUntilProcessed = -1;

        if (index >= 0) {
            if (uint256(index) > lastProcessedIndex) {
                iterationsUntilProcessed = index.sub(
                    int256(lastProcessedIndex)
                );
            } else {
                uint256 processesUntilEndOfArray = tokenHoldersMap.keys.length >
                    lastProcessedIndex
                    ? tokenHoldersMap.keys.length.sub(lastProcessedIndex)
                    : 0;

                iterationsUntilProcessed = index.add(
                    int256(processesUntilEndOfArray)
                );
            }
        }

        withdrawableDividends = withdrawableDividendOf(account);
        totalDividends = accumulativeDividendOf(account);

        lastClaimTime = lastClaimTimes[account];
    }

    function getAccountAtIndex(uint256 index)
        public
        view
        returns (
            address,
            int256,
            int256,
            uint256,
            uint256,
            uint256
        )
    {
        if (index >= tokenHoldersMap.size()) {
            return (
                0x0000000000000000000000000000000000000000,
                -1,
                -1,
                0,
                0,
                0
            );
        }

        address account = tokenHoldersMap.getKeyAtIndex(index);

        return getAccount(account);
    }

    function setBalance(address account, uint256 newBalance)
        external
        onlyOwner
    {
        if (excludedFromDividends[account]) {
            return;
        }

        if (newBalance < minimumTokenBalanceForDividends) {
            tokenHoldersMap.remove(account);
            _setBalance(account, 0);

            return;
        }

        _setBalance(account, newBalance);

        if (newBalance >= minimumTokenBalanceForAutoDividends) {
            tokenHoldersMap.set(account, newBalance);
        } else {
            tokenHoldersMap.remove(account);
        }
    }

    function process(uint256 gas)
        public
        returns (
            uint256,
            uint256,
            uint256
        )
    {
        uint256 numberOfTokenHolders = tokenHoldersMap.keys.length;

        if (numberOfTokenHolders == 0 || dividendsPaused) {
            return (0, 0, lastProcessedIndex);
        }

        uint256 _lastProcessedIndex = lastProcessedIndex;

        uint256 gasUsed = 0;

        uint256 gasLeft = gasleft();

        uint256 iterations = 0;
        uint256 claims = 0;

        while (gasUsed < gas && iterations < numberOfTokenHolders) {
            _lastProcessedIndex++;

            if (_lastProcessedIndex >= numberOfTokenHolders) {
                _lastProcessedIndex = 0;
            }

            address account = tokenHoldersMap.keys[_lastProcessedIndex];

            if (!excludedFromAutoClaim[account]) {
                if (processAccount(payable(account), true)) {
                    claims++;
                }
            }

            iterations++;

            uint256 newGasLeft = gasleft();

            if (gasLeft > newGasLeft) {
                gasUsed = gasUsed.add(gasLeft.sub(newGasLeft));
            }

            gasLeft = newGasLeft;
        }

        lastProcessedIndex = _lastProcessedIndex;

        return (iterations, claims, lastProcessedIndex);
    }

    function processAccount(address payable account, bool automatic)
        public
        onlyOwner
        returns (bool)
    {
        if (dividendsPaused) {
            return false;
        }

        bool reinvest = autoReinvest[account];

        if (automatic && reinvest && !allowAutoReinvest) {
            return false;
        }

        uint256 amount = reinvest
            ? _reinvestDividendOfUser(account)
            : _withdrawDividendOfUser(account);

        if (amount > 0) {
            lastClaimTimes[account] = block.timestamp;
            if (reinvest) {
                emit DividendReinvested(account, amount, automatic);
            } else {
                emit Claim(account, amount, automatic);
            }
            return true;
        }

        return false;
    }

    function updatePayoutToken(address token) public onlyOwner {
        defaultToken = token;
    }

    function getPayoutToken() public view returns (address) {
        return defaultToken;
    }

    function getMinimumTokenBalanceForAutoDividends() public view returns (uint256) {
        return minimumTokenBalanceForAutoDividends;
    }

    function getMinimumTokenBalanceForDividends() public view returns (uint256) {
        return minimumTokenBalanceForDividends;
    }        

    function _reinvestDividendOfUser(address account)
        private
        returns (uint256)
    {
        uint256 _withdrawableDividend = withdrawableDividendOf(account);
        if (_withdrawableDividend > 0) {
            bool success;

            withdrawnDividends[account] = withdrawnDividends[account].add(
                _withdrawableDividend
            );

            address[] memory path = new address[](2);
            path[0] = uniswapV2Router.WETH();
            path[1] = address(BUTTHOLEContract);

            uint256 prevBalance = BUTTHOLEContract.balanceOf(address(this));

            // make the swap
            try
                uniswapV2Router
                    .swapExactETHForTokensSupportingFeeOnTransferTokens{
                    value: _withdrawableDividend
                }(
                    0, // accept any amount of Tokens
                    path,
                    address(this),
                    block.timestamp
                )
            {
                uint256 received = BUTTHOLEContract
                    .balanceOf(address(this))
                    .sub(prevBalance);
                if (received > 0) {
                    success = true;
                    BUTTHOLEContract.transfer(account, received);
                } else {
                    success = false;
                }
            } catch {
                success = false;
            }

            if (!success) {
                withdrawnDividends[account] = withdrawnDividends[account].sub(
                    _withdrawableDividend
                );
                return 0;
            }

            return _withdrawableDividend;
        }

        return 0;
    }

    function _withdrawDividendOfUser(address payable user)
        internal
        override
        returns (uint256)
    {
        uint256 _withdrawableDividend = withdrawableDividendOf(user);
        if (_withdrawableDividend > 0) {
            withdrawnDividends[user] = withdrawnDividends[user].add(
                _withdrawableDividend
            );

            address tokenAddress = defaultToken;
            bool success;

            if (tokenAddress == address(0)) {
                (success, ) = user.call{
                    value: _withdrawableDividend,
                    gas: 3000
                }("");
            } else {
                address[] memory path = new address[](2);
                path[0] = uniswapV2Router.WETH();
                path[1] = tokenAddress;
                try
                    uniswapV2Router
                        .swapExactETHForTokensSupportingFeeOnTransferTokens{
                        value: _withdrawableDividend
                    }(
                        0, // accept any amount of Tokens
                        path,
                        user,
                        block.timestamp
                    )
                {
                    success = true;
                } catch {
                    success = false;
                }
            }

            if (!success) {
                withdrawnDividends[user] = withdrawnDividends[user].sub(
                    _withdrawableDividend
                );
                return 0;
            } else {
                emit DividendWithdrawn(user, _withdrawableDividend);
            }
            return _withdrawableDividend;
        }
        return 0;
    }
}

library IterableMapping {
    // Iterable mapping from address to uint;
    struct Map {
        address[] keys;
        mapping(address => uint256) values;
        mapping(address => uint256) indexOf;
        mapping(address => bool) inserted;
    }

    function get(Map storage map, address key) internal view returns (uint256) {
        return map.values[key];
    }

    function getIndexOfKey(Map storage map, address key)
        internal
        view
        returns (int256)
    {
        if (!map.inserted[key]) {
            return -1;
        }
        return int256(map.indexOf[key]);
    }

    function getKeyAtIndex(Map storage map, uint256 index)
        internal
        view
        returns (address)
    {
        return map.keys[index];
    }

    function size(Map storage map) internal view returns (uint256) {
        return map.keys.length;
    }

    function set(
        Map storage map,
        address key,
        uint256 val
    ) internal {
        if (map.inserted[key]) {
            map.values[key] = val;
        } else {
            map.inserted[key] = true;
            map.values[key] = val;
            map.indexOf[key] = map.keys.length;
            map.keys.push(key);
        }
    }

    function remove(Map storage map, address key) internal {
        if (!map.inserted[key]) {
            return;
        }

        delete map.inserted[key];
        delete map.values[key];

        uint256 index = map.indexOf[key];
        uint256 lastIndex = map.keys.length - 1;
        address lastKey = map.keys[lastIndex];

        map.indexOf[lastKey] = index;
        delete map.indexOf[key];

        map.keys[index] = lastKey;
        map.keys.pop();
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address payable","name":"mainContract","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_ticker","type":"string"}],"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":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"bool","name":"automatic","type":"bool"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newValue","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"oldValue","type":"uint256"}],"name":"ClaimWaitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"acount","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":true,"internalType":"bool","name":"automatic","type":"bool"}],"name":"DividendReinvested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"DividendWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"DividendsDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"paused","type":"bool"}],"name":"DividendsPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"ExcludeFromDividends","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":"bool","name":"allow","type":"bool"}],"name":"SetAllowAutoReinvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"allow","type":"bool"}],"name":"SetAllowCustomTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BUTTHOLEContract","outputs":[{"internalType":"contract BUTTHOLE","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"accumulativeDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowAutoReinvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowCustomTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"","type":"address"}],"name":"autoReinvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"defaultToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributeDividends","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dividendsPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromAutoClaim","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromDividends","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getAccount","outputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"int256","name":"index","type":"int256"},{"internalType":"int256","name":"iterationsUntilProcessed","type":"int256"},{"internalType":"uint256","name":"withdrawableDividends","type":"uint256"},{"internalType":"uint256","name":"totalDividends","type":"uint256"},{"internalType":"uint256","name":"lastClaimTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getAccountAtIndex","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"int256","name":"","type":"int256"},{"internalType":"int256","name":"","type":"int256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinimumTokenBalanceForAutoDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinimumTokenBalanceForDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumberOfTokenHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPayoutToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"includeFromDividends","outputs":[],"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":"account","type":"address"}],"name":"isExcludedFromAutoClaim","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isReinvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastClaimTimes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"uint256","name":"gas","type":"uint256"}],"name":"process","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"bool","name":"automatic","type":"bool"}],"name":"processAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"allow","type":"bool"}],"name":"setAllowAutoReinvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"allow","type":"bool"}],"name":"setAllowCustomTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutoClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"setBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setDividendsPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setMinimumTokenBalanceForAutoDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setMinimumTokenBalanceForDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setReinvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividendsDistributed","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":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"updatePayoutToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawDividend","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

60806040526012805460ff60b01b191690553480156200001d575f80fd5b5060405162002f5c38038062002f5c833981016040819052620000409162000238565b81818181600362000052838262000369565b50600462000061828262000369565b50505050505f620000776200015e60201b60201c565b600980546001600160a01b0319166001600160a01b038316908117909155604051919250905f907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a3506013620000d2838262000369565b506014620000e1828262000369565b505060128054601680546001600160a01b03199081166001600160a01b03988916179091556a295be96e6406697200000060185568056bc75e2d631000006019556015805490911695871695909517909455600160a01b929094166001600160a81b0319909316929092171760ff60a81b19169091555062000431565b3390565b6001600160a01b038116811462000177575f80fd5b50565b634e487b7160e01b5f52604160045260245ffd5b5f82601f8301126200019e575f80fd5b81516001600160401b0380821115620001bb57620001bb6200017a565b604051601f8301601f19908116603f01168101908282118183101715620001e657620001e66200017a565b8160405283815260209250868385880101111562000202575f80fd5b5f91505b8382101562000225578582018301518183018401529082019062000206565b5f93810190920192909252949350505050565b5f805f805f60a086880312156200024d575f80fd5b85516200025a8162000162565b60208701519095506200026d8162000162565b6040870151909450620002808162000162565b60608701519093506001600160401b03808211156200029d575f80fd5b620002ab89838a016200018e565b93506080880151915080821115620002c1575f80fd5b50620002d0888289016200018e565b9150509295509295909350565b600181811c90821680620002f257607f821691505b6020821081036200031157634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111562000364575f81815260208120601f850160051c810160208610156200033f5750805b601f850160051c820191505b8181101562000360578281556001016200034b565b5050505b505050565b81516001600160401b038111156200038557620003856200017a565b6200039d81620003968454620002dd565b8462000317565b602080601f831160018114620003d3575f8415620003bb5750858301515b5f19600386901b1c1916600185901b17855562000360565b5f85815260208120601f198616915b828110156200040357888601518255948401946001909101908401620003e2565b50858210156200042157878501515f19600388901b60f8161c191681555b5050505050600190811b01905550565b612b1d806200043f5f395ff3fe60806040526004361061032a575f3560e01c8063715018a6116101a3578063a9059cbb116100f2578063dd62ed3e11610092578063e7cb7f871161006d578063e7cb7f87146109ca578063f2fde38b146109de578063fbcbc0f1146109fd578063ffb2c47914610a1c575f80fd5b8063dd62ed3e14610953578063e30443bc14610997578063e7841ec0146109b6575f80fd5b8063ba079d49116100cd578063ba079d49146108e2578063bc4c4b3714610901578063bdd4f29f14610920578063d8032ed314610934575f80fd5b8063a9059cbb14610870578063aafd847a1461088f578063b22f8a04146108c3575f80fd5b806394807f251161015d5780639eec101e116101385780639eec101e146107f2578063a423406914610812578063a457c2d714610832578063a8b9d24014610851575f80fd5b806394807f25146107a057806395d89b41146107bf5780639c3372ea146107d3575f80fd5b8063715018a6146106fd57806374c13fda1461071157806385a6b3ae146107305780638bc1d639146107455780638da5cb5b1461076457806391b89fba14610781575f80fd5b8063313ce567116102795780635183d6fd116102195780636a474002116101f45780636a474002146106685780636b69163b1461067c5780636d48467b146106aa57806370a08231146106c9575f80fd5b80635183d6fd146105d45780635a84c5eb1461062a5780635ebf4db914610649575f80fd5b80633950935111610254578063395093511461054857806340ffdd801461056757806341808904146105865780634e7b827f146105a6575f80fd5b8063313ce567146104ef57806331e79db01461050a5780633599bb1714610529575f80fd5b806318160ddd116102e457806323b872dd116102bf57806323b872dd1461047f57806325cd35981461049e57806327ce0147146104bb5780633009a609146104da575f80fd5b806318160ddd146104125780631d4ff89a14610426578063226cfa3d14610454575f80fd5b806303c833021461033d57806306fdde0314610345578063092884711461036f578063095ea7b31461038e57806309bbedde146103bd5780631694505e146103db575f80fd5b3661033957610337610a56565b005b5f80fd5b610337610a56565b348015610350575f80fd5b50610359610ae7565b60405161036691906126c4565b60405180910390f35b34801561037a575f80fd5b50610337610389366004612726565b610b77565b348015610399575f80fd5b506103ad6103a8366004612741565b610bca565b6040519015158152602001610366565b3480156103c8575f80fd5b50600a545b604051908152602001610366565b3480156103e6575f80fd5b506015546103fa906001600160a01b031681565b6040516001600160a01b039091168152602001610366565b34801561041d575f80fd5b506002546103cd565b348015610431575f80fd5b506103ad610440366004612726565b60116020525f908152604090205460ff1681565b34801561045f575f80fd5b506103cd61046e366004612726565b60176020525f908152604090205481565b34801561048a575f80fd5b506103ad61049936600461276b565b610be0565b3480156104a9575f80fd5b506012546001600160a01b03166103fa565b3480156104c6575f80fd5b506103cd6104d5366004612726565b610c47565b3480156104e5575f80fd5b506103cd600e5481565b3480156104fa575f80fd5b5060405160128152602001610366565b348015610515575f80fd5b50610337610524366004612726565b610ca2565b348015610534575f80fd5b506103376105433660046127b6565b610d3a565b348015610553575f80fd5b506103ad610562366004612741565b610dda565b348015610572575f80fd5b506103376105813660046127b6565b610e0f565b348015610591575f80fd5b506012546103ad90600160a81b900460ff1681565b3480156105b1575f80fd5b506103ad6105c0366004612726565b600f6020525f908152604090205460ff1681565b3480156105df575f80fd5b506105f36105ee3660046127d1565b610ea4565b604080516001600160a01b0390971687526020870195909552938501929092526060840152608083015260a082015260c001610366565b348015610635575f80fd5b506103376106443660046127d1565b610efe565b348015610654575f80fd5b506103376106633660046127d1565b610f40565b348015610673575f80fd5b50610337610f82565b348015610687575f80fd5b506103ad610696366004612726565b60106020525f908152604090205460ff1681565b3480156106b5575f80fd5b506103ad6106c4366004612726565b61102c565b3480156106d4575f80fd5b506103cd6106e3366004612726565b6001600160a01b03165f9081526020819052604090205490565b348015610708575f80fd5b50610337611076565b34801561071c575f80fd5b506012546103fa906001600160a01b031681565b34801561073b575f80fd5b506103cd60085481565b348015610750575f80fd5b5061033761075f3660046127e8565b6110e9565b34801561076f575f80fd5b506009546001600160a01b03166103fa565b34801561078c575f80fd5b506103cd61079b366004612726565b61113d565b3480156107ab575f80fd5b506016546103fa906001600160a01b031681565b3480156107ca575f80fd5b50610359611147565b3480156107de575f80fd5b506103376107ed3660046127b6565b611156565b3480156107fd575f80fd5b506012546103ad90600160a01b900460ff1681565b34801561081d575f80fd5b506012546103ad90600160b01b900460ff1681565b34801561083d575f80fd5b506103ad61084c366004612741565b6111eb565b34801561085c575f80fd5b506103cd61086b366004612726565b611238565b34801561087b575f80fd5b506103ad61088a366004612741565b611263565b34801561089a575f80fd5b506103cd6108a9366004612726565b6001600160a01b03165f9081526007602052604090205490565b3480156108ce575f80fd5b506103376108dd3660046127e8565b61126f565b3480156108ed575f80fd5b506103ad6108fc366004612726565b6112c3565b34801561090c575f80fd5b506103ad61091b3660046127e8565b61130d565b34801561092b575f80fd5b506019546103cd565b34801561093f575f80fd5b5061033761094e366004612726565b611487565b34801561095e575f80fd5b506103cd61096d36600461281f565b6001600160a01b039182165f90815260016020908152604080832093909416825291909152205490565b3480156109a2575f80fd5b506103376109b1366004612741565b6114d3565b3480156109c1575f80fd5b50600e546103cd565b3480156109d5575f80fd5b506018546103cd565b3480156109e9575f80fd5b506103376109f8366004612726565b611569565b348015610a08575f80fd5b506105f3610a17366004612726565b611653565b348015610a27575f80fd5b50610a3b610a363660046127d1565b6116fc565b60408051938452602084019290925290820152606001610366565b5f610a6060025490565b11610a69575f80fd5b3415610ae557610a9c610a7b60025490565b610a8934600160801b611819565b610a93919061285f565b6005549061189e565b60055560405134815233907fa493a9229478c3fcd73f66d2cdeb7f94fd0f341da924d1054236d784541165119060200160405180910390a2600854610ae1903461189e565b6008555b565b606060138054610af69061287e565b80601f0160208091040260200160405190810160405280929190818152602001828054610b229061287e565b8015610b6d5780601f10610b4457610100808354040283529160200191610b6d565b820191905f5260205f20905b815481529060010190602001808311610b5057829003601f168201915b5050505050905090565b6009546001600160a01b03163314610baa5760405162461bcd60e51b8152600401610ba1906128b6565b60405180910390fd5b6001600160a01b03165f908152600f60205260409020805460ff19169055565b5f610bd63384846118fc565b5060015b92915050565b5f610bec848484611a1f565b610c3d8433610c3885604051806060016040528060288152602001612a9b602891396001600160a01b038a165f9081526001602090815260408083203384529091529020549190611a84565b6118fc565b5060019392505050565b6001600160a01b0381165f9081526006602090815260408083205491839052822054600554600160801b92610c9892610c9392610c8d91610c889190611819565b611abc565b90611aca565b611b04565b610bda919061285f565b6009546001600160a01b03163314610ccc5760405162461bcd60e51b8152600401610ba1906128b6565b6001600160a01b0381165f908152600f60205260408120805460ff19166001179055610cf9908290611b15565b610d04600a82611b71565b6040516001600160a01b038216907fa878b31040b2e6d0a9a3d3361209db3908ba62014b0dca52adbaee451d128b25905f90a250565b6009546001600160a01b03163314610d645760405162461bcd60e51b8152600401610ba1906128b6565b801515601260169054906101000a900460ff16151503610d82575f80fd5b60128054821515600160b01b0260ff60b01b199091161790556040517f3da2593f2c4724acfbd754045321e852cad26f3974834b1890045530f89c21b390610dcf90831515815260200190565b60405180910390a150565b335f8181526001602090815260408083206001600160a01b03871684529091528120549091610bd6918590610c38908661189e565b6009546001600160a01b03163314610e395760405162461bcd60e51b8152600401610ba1906128b6565b801515601260159054906101000a900460ff16151503610e57575f80fd5b60128054821515600160a81b0260ff60a81b199091161790556040517fc138a28750b971696f46ea59731c471ef1e08e4015404afdb139fd2e87dca1bb90610dcf90831515815260200190565b5f805f805f80610eb3600a5490565b8710610ed057505f94505f19935083925084915081905080610ef5565b5f610edc600a89611ca4565b9050610ee781611653565b965096509650965096509650505b91939550919395565b6009546001600160a01b03163314610f285760405162461bcd60e51b8152600401610ba1906128b6565b610f3a81670de0b6b3a76400006128eb565b60185550565b6009546001600160a01b03163314610f6a5760405162461bcd60e51b8152600401610ba1906128b6565b610f7c81670de0b6b3a76400006128eb565b60195550565b60405162461bcd60e51b815260206004820152606d60248201527f42555454484f4c455f4469766964656e645f547261636b65723a20776974686460448201527f7261774469766964656e642064697361626c65642e205573652074686520276360648201527f6c61696d272066756e6374696f6e206f6e20746865206d61696e20425554544860848201526c27a6229031b7b73a3930b1ba1760991b60a482015260c401610ba1565b6009545f906001600160a01b031633146110585760405162461bcd60e51b8152600401610ba1906128b6565b506001600160a01b03165f9081526010602052604090205460ff1690565b6009546001600160a01b031633146110a05760405162461bcd60e51b8152600401610ba1906128b6565b6009546040515f916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600980546001600160a01b0319169055565b6009546001600160a01b031633146111135760405162461bcd60e51b8152600401610ba1906128b6565b6001600160a01b03919091165f908152601060205260409020805460ff1916911515919091179055565b5f610bda82611238565b606060148054610af69061287e565b6009546001600160a01b031633146111805760405162461bcd60e51b8152600401610ba1906128b6565b801515601260149054906101000a900460ff1615150361119e575f80fd5b60128054821515600160a01b0260ff60a01b199091161790556040517f8d34c313963017194ed726d050e868657d0e2d2c6748d13e358cd4b89d4ee7c890610dcf90831515815260200190565b5f610bd63384610c3885604051806060016040528060258152602001612ac360259139335f9081526001602090815260408083206001600160a01b038d1684529091529020549190611a84565b6001600160a01b0381165f90815260076020526040812054610bda9061125d84610c47565b90611cd4565b5f610bd6338484611a1f565b6009546001600160a01b031633146112995760405162461bcd60e51b8152600401610ba1906128b6565b6001600160a01b03919091165f908152601160205260409020805460ff1916911515919091179055565b6009545f906001600160a01b031633146112ef5760405162461bcd60e51b8152600401610ba1906128b6565b506001600160a01b03165f9081526011602052604090205460ff1690565b6009545f906001600160a01b031633146113395760405162461bcd60e51b8152600401610ba1906128b6565b601254600160b01b900460ff161561135257505f610bda565b6001600160a01b0383165f9081526011602052604090205460ff168280156113775750805b801561138d5750601254600160a81b900460ff16155b1561139b575f915050610bda565b5f816113af576113aa85611d15565b6113b8565b6113b885611fbd565b9050801561147d576001600160a01b0385165f908152601760205260409020429055811561142b57831515856001600160a01b03167ffbd928dd3806a2bdf802f3a28a2cc55205f95dbcd2c3ed313abfca278366f80c8360405161141e91815260200190565b60405180910390a3611472565b831515856001600160a01b03167fa2c38e2d2fb7e3e1912d937fd1ca11ed6d51864dee4cfa7a7bf02becd7acf0928360405161146991815260200190565b60405180910390a35b600192505050610bda565b505f949350505050565b6009546001600160a01b031633146114b15760405162461bcd60e51b8152600401610ba1906128b6565b601280546001600160a01b0319166001600160a01b0392909216919091179055565b6009546001600160a01b031633146114fd5760405162461bcd60e51b8152600401610ba1906128b6565b6001600160a01b0382165f908152600f602052604090205460ff1661153b5760195481101561153f57611531600a83611b71565b61153b825f611b15565b5050565b6115498282611b15565b601854811061155e5761153b600a838361231a565b61153b600a83611b71565b6009546001600160a01b031633146115935760405162461bcd60e51b8152600401610ba1906128b6565b6001600160a01b0381166115f85760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610ba1565b6009546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a3600980546001600160a01b0319166001600160a01b0392909216919091179055565b805f80808080611664600a876123c0565b94505f1993505f85126116c257600e5485111561169057600e54611689908690612408565b93506116c2565b600e54600a545f91106116a3575f6116b2565b600e54600a546116b291611cd4565b90506116be8682611aca565b9450505b6116cb86611238565b92506116d686610c47565b6001600160a01b0387165f90815260176020526040902054969895975093959294915050565b600a545f908190819080158061171b5750601254600160b01b900460ff165b15611730575050600e545f9250829150611812565b600e545f805a90505f805b898410801561174957508582105b15611801578461175881612902565b955050858510611766575f94505b5f600a5f01868154811061177c5761177c61291a565b5f9182526020808320909101546001600160a01b0316808352601090915260409091205490915060ff166117c8576117b581600161130d565b156117c857816117c481612902565b9250505b826117d281612902565b9350505f5a9050808511156117f8576117f56117ee8683611cd4565b879061189e565b95505b935061173b9050565b600e85905590975095509193505050505b9193909250565b5f825f0361182857505f610bda565b5f61183383856128eb565b905082611840858361285f565b146118975760405162461bcd60e51b815260206004820152602160248201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6044820152607760f81b6064820152608401610ba1565b9392505050565b5f806118aa838561292e565b9050838110156118975760405162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006044820152606401610ba1565b6001600160a01b03831661195e5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610ba1565b6001600160a01b0382166119bf5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610ba1565b6001600160a01b038381165f8181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b60405162461bcd60e51b815260206004820152602f60248201527f42555454484f4c455f4469766964656e645f547261636b65723a204e6f20747260448201526e185b9cd9995c9cc8185b1b1bddd959608a1b6064820152608401610ba1565b505050565b5f8184841115611aa75760405162461bcd60e51b8152600401610ba191906126c4565b505f611ab38486612941565b95945050505050565b5f8181811215610bda575f80fd5b5f80611ad68385612954565b90505f8312158015611ae85750838112155b80611afc57505f83128015611afc57508381125b611897575f80fd5b5f80821215611b11575f80fd5b5090565b6001600160a01b0382165f9081526020819052604090205480821115611b52575f611b408383611cd4565b9050611b4c8482612441565b50505050565b80821015611a7f575f611b658284611cd4565b9050611b4c84826124a3565b6001600160a01b0381165f90815260038301602052604090205460ff16611b96575050565b6001600160a01b0381165f9081526003830160209081526040808320805460ff1916905560018086018352818420849055600286019092528220548454909291611bdf91612941565b90505f845f018281548110611bf657611bf661291a565b5f9182526020808320909101546001600160a01b03908116808452600289019092526040808420879055908716835282209190915585549091508190869085908110611c4457611c4461291a565b5f91825260209091200180546001600160a01b0319166001600160a01b03929092169190911790558454859080611c7d57611c7d61297b565b5f8281526020902081015f1990810180546001600160a01b03191690550190555050505050565b5f825f018281548110611cb957611cb961291a565b5f918252602090912001546001600160a01b03169392505050565b5f61189783836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611a84565b5f80611d2083611238565b90508015611fb5576001600160a01b0383165f90815260076020526040902054611d4a908261189e565b6001600160a01b038085165f90815260076020526040812092909255601254169081611dcb576040516001600160a01b03861690610bb89085905f818181858888f193505050503d805f8114611dbb576040519150601f19603f3d011682016040523d82523d5f602084013e611dc0565b606091505b505080915050611f1d565b6040805160028082526060820183525f926020830190803683375050601554604080516315ab88c960e31b815290519394506001600160a01b039091169263ad5c4648925060048083019260209291908290030181865afa158015611e32573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611e56919061298f565b815f81518110611e6857611e6861291a565b60200260200101906001600160a01b031690816001600160a01b0316815250508281600181518110611e9c57611e9c61291a565b6001600160a01b03928316602091820292909201015260155460405163b6f9de9560e01b815291169063b6f9de95908690611ee1905f9086908c9042906004016129ec565b5f604051808303818588803b158015611ef8575f80fd5b505af193505050508015611f0a575060015b611f16575f9150611f1b565b600191505b505b80611f69576001600160a01b0385165f90815260076020526040902054611f449084611cd4565b6001600160a01b039095165f9081526007602052604081209590955550929392505050565b846001600160a01b03167fee503bee2bb6a87e57bc57db795f98137327401a0e7b7ce42e37926cc1a9ca4d84604051611fa491815260200190565b60405180910390a250909392505050565b505f92915050565b5f80611fc883611238565b90508015611fb5576001600160a01b0383165f90815260076020526040812054611ff2908361189e565b6001600160a01b0385165f9081526007602052604080822092909255815160028082526060820190935290918160200160208202803683375050601554604080516315ab88c960e31b815290519394506001600160a01b039091169263ad5c4648925060048083019260209291908290030181865afa158015612077573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061209b919061298f565b815f815181106120ad576120ad61291a565b6001600160a01b0392831660209182029290920101526016548251911690829060019081106120de576120de61291a565b6001600160a01b0392831660209182029290920101526016546040516370a0823160e01b81523060048201525f9291909116906370a0823190602401602060405180830381865afa158015612135573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906121599190612a20565b60155460405163b6f9de9560e01b81529192506001600160a01b03169063b6f9de95908690612192905f908790309042906004016129ec565b5f604051808303818588803b1580156121a9575f80fd5b505af1935050505080156121bb575060015b6121c7575f92506122c3565b6016546040516370a0823160e01b81523060048201525f916122379184916001600160a01b0316906370a0823190602401602060405180830381865afa158015612213573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061125d9190612a20565b905080156122bd5760165460405163a9059cbb60e01b81526001600160a01b03898116600483015260248201849052600196509091169063a9059cbb906044016020604051808303815f875af1158015612293573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906122b79190612a37565b506122c1565b5f93505b505b82612310576001600160a01b0386165f908152600760205260409020546122ea9085611cd4565b6001600160a01b039096165f908152600760205260408120969096555093949350505050565b5091949350505050565b6001600160a01b0382165f90815260038401602052604090205460ff161561235d576001600160a01b0382165f9081526001840160205260409020819055505050565b6001600160a01b0382165f8181526003850160209081526040808320805460ff19166001908117909155878101835281842086905587546002890184529184208290558101875586835291200180546001600160a01b0319169091179055505050565b6001600160a01b0381165f90815260038301602052604081205460ff166123e957505f19610bda565b506001600160a01b03165f908152600291909101602052604090205490565b5f806124148385612a52565b90505f83121580156124265750838113155b80611afc57505f83128015611afc5750838113611897575f80fd5b61244b82826124e6565b612484612466610c888360055461181990919063ffffffff16565b6001600160a01b0384165f9081526006602052604090205490612408565b6001600160a01b039092165f9081526006602052604090209190915550565b6124ad82826125c3565b6124846124c8610c888360055461181990919063ffffffff16565b6001600160a01b0384165f9081526006602052604090205490611aca565b6001600160a01b03821661253c5760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610ba1565b600254612549908261189e565b6002556001600160a01b0382165f9081526020819052604090205461256e908261189e565b6001600160a01b0383165f81815260208181526040808320949094559251848152919290917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91015b60405180910390a35050565b6001600160a01b0382166126235760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610ba1565b61265f81604051806060016040528060228152602001612a79602291396001600160a01b0385165f908152602081905260409020549190611a84565b6001600160a01b0383165f908152602081905260409020556002546126849082611cd4565b6002556040518181525f906001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906020016125b7565b5f6020808352835180828501525f5b818110156126ef578581018301518582016040015282016126d3565b505f604082860101526040601f19601f8301168501019250505092915050565b6001600160a01b0381168114612723575f80fd5b50565b5f60208284031215612736575f80fd5b81356118978161270f565b5f8060408385031215612752575f80fd5b823561275d8161270f565b946020939093013593505050565b5f805f6060848603121561277d575f80fd5b83356127888161270f565b925060208401356127988161270f565b929592945050506040919091013590565b8015158114612723575f80fd5b5f602082840312156127c6575f80fd5b8135611897816127a9565b5f602082840312156127e1575f80fd5b5035919050565b5f80604083850312156127f9575f80fd5b82356128048161270f565b91506020830135612814816127a9565b809150509250929050565b5f8060408385031215612830575f80fd5b823561283b8161270f565b915060208301356128148161270f565b634e487b7160e01b5f52601160045260245ffd5b5f8261287957634e487b7160e01b5f52601260045260245ffd5b500490565b600181811c9082168061289257607f821691505b6020821081036128b057634e487b7160e01b5f52602260045260245ffd5b50919050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b8082028115828204841417610bda57610bda61284b565b5f600182016129135761291361284b565b5060010190565b634e487b7160e01b5f52603260045260245ffd5b80820180821115610bda57610bda61284b565b81810381811115610bda57610bda61284b565b8082018281125f8312801582168215821617156129735761297361284b565b505092915050565b634e487b7160e01b5f52603160045260245ffd5b5f6020828403121561299f575f80fd5b81516118978161270f565b5f8151808452602080850194508084015f5b838110156129e15781516001600160a01b0316875295820195908201906001016129bc565b509495945050505050565b848152608060208201525f612a0460808301866129aa565b6001600160a01b03949094166040830152506060015292915050565b5f60208284031215612a30575f80fd5b5051919050565b5f60208284031215612a47575f80fd5b8151611897816127a9565b8181035f831280158383131683831282161715612a7157612a7161284b565b509291505056fe45524332303a206275726e20616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa26469706673582212207baa357f8585242405d15dbbefcf52dda31ac82a45ba2fc3641bcda8a0dd2a3264736f6c6343000814003300000000000000000000000096201329cb7a6a62cb85c0f37d636a8b785988f70000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000576e2bed8f7b46d34016198911cdf9886f78bea700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000f42555454484f4c45545241434b45520000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a4d5442545241434b455200000000000000000000000000000000000000000000

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

00000000000000000000000096201329cb7a6a62cb85c0f37d636a8b785988f70000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000576e2bed8f7b46d34016198911cdf9886f78bea700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000f42555454484f4c45545241434b45520000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a4d5442545241434b455200000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : mainContract (address): 0x96201329CB7a6a62cB85c0F37D636A8B785988F7
Arg [1] : router (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [2] : token (address): 0x576e2BeD8F7b46D34016198911Cdf9886f78bea7
Arg [3] : _name (string): BUTTHOLETRACKER
Arg [4] : _ticker (string): MTBTRACKER

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 00000000000000000000000096201329cb7a6a62cb85c0f37d636a8b785988f7
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [2] : 000000000000000000000000576e2bed8f7b46d34016198911cdf9886f78bea7
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000f
Arg [6] : 42555454484f4c45545241434b45520000000000000000000000000000000000
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [8] : 4d5442545241434b455200000000000000000000000000000000000000000000

45619:13875:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21541:21;:19;:21::i;:::-;45619:13875;;;;;21578:471;;;:::i;47803:106::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49548:123;;;;;;;;;;-1:-1:-1;49548:123:0;;;;;:::i;:::-;;:::i;6856:210::-;;;;;;;;;;-1:-1:-1;6856:210:0;;;;;:::i;:::-;;:::i;:::-;;;1440:14:1;;1433:22;1415:41;;1403:2;1388:18;6856:210:0;1275:187:1;50611:120:0;;;;;;;;;;-1:-1:-1;50696:15:0;:27;50611:120;;;1613:25:1;;;1601:2;1586:18;50611:120:0;1467:177:1;46297:41:0;;;;;;;;;;-1:-1:-1;46297:41:0;;;;-1:-1:-1;;;;;46297:41:0;;;;;;-1:-1:-1;;;;;1840:32:1;;;1822:51;;1810:2;1795:18;46297:41:0;1649:230:1;6122:108:0;;;;;;;;;;-1:-1:-1;6210:12:0;;6122:108;;46025:44;;;;;;;;;;-1:-1:-1;46025:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;46388:49;;;;;;;;;;-1:-1:-1;46388:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;7074:454;;;;;;;;;;-1:-1:-1;7074:454:0;;;;;:::i;:::-;;:::i;55575:94::-;;;;;;;;;;-1:-1:-1;55649:12:0;;-1:-1:-1;;;;;55649:12:0;55575:94;;23594:372;;;;;;;;;;-1:-1:-1;23594:372:0;;;;;:::i;:::-;;:::i;45863:33::-;;;;;;;;;;;;;;;;47702:93;;;;;;;;;;-1:-1:-1;47702:93:0;;47785:2;2695:36:1;;2683:2;2668:18;47702:93:0;2553:184:1;49240:300:0;;;;;;;;;;-1:-1:-1;49240:300:0;;;;;:::i;:::-;;:::i;50303:183::-;;;;;;;;;;-1:-1:-1;50303:183:0;;;;;:::i;:::-;;:::i;7536:300::-;;;;;;;;;;-1:-1:-1;7536:300:0;;;;;:::i;:::-;;:::i;49038:194::-;;;;;;;;;;-1:-1:-1;49038:194:0;;;;;:::i;:::-;;:::i;46147:29::-;;;;;;;;;;-1:-1:-1;46147:29:0;;;;-1:-1:-1;;;46147:29:0;;;;;;45905:53;;;;;;;;;;-1:-1:-1;45905:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;51996:609;;;;;;;;;;-1:-1:-1;51996:609:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3597:32:1;;;3579:51;;3661:2;3646:18;;3639:34;;;;3689:18;;;3682:34;;;;3747:2;3732:18;;3725:34;3790:3;3775:19;;3768:35;3617:3;3819:19;;3812:35;3566:3;3551:19;51996:609:0;3296:557:1;49939:178:0;;;;;;;;;;-1:-1:-1;49939:178:0;;;;;:::i;:::-;;:::i;50125:170::-;;;;;;;;;;-1:-1:-1;50125:170:0;;;;;:::i;:::-;;:::i;48230:232::-;;;;;;;;;;;;;:::i;45965:53::-;;;;;;;;;;-1:-1:-1;45965:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;48470:186;;;;;;;;;;-1:-1:-1;48470:186:0;;;;;:::i;:::-;;:::i;6238:177::-;;;;;;;;;;-1:-1:-1;6238:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;6389:18:0;6357:7;6389:18;;;;;;;;;;;;6238:177;13215:148;;;;;;;;;;;;;:::i;46076:27::-;;;;;;;;;;-1:-1:-1;46076:27:0;;;;-1:-1:-1;;;;;46076:27:0;;;21352:40;;;;;;;;;;;;;;;;49679:127;;;;;;;;;;-1:-1:-1;49679:127:0;;;;;:::i;:::-;;:::i;13001:79::-;;;;;;;;;;-1:-1:-1;13066:6:0;;-1:-1:-1;;;;;13066:6:0;13001:79;;23046:131;;;;;;;;;;-1:-1:-1;23046:131:0;;;;;:::i;:::-;;:::i;46347:32::-;;;;;;;;;;-1:-1:-1;46347:32:0;;;;-1:-1:-1;;;;;46347:32:0;;;47917:110;;;;;;;;;;;;;:::i;48836:194::-;;;;;;;;;;-1:-1:-1;48836:194:0;;;;;:::i;:::-;;:::i;46111:29::-;;;;;;;;;;-1:-1:-1;46111:29:0;;;;-1:-1:-1;;;46111:29:0;;;;;;46183:35;;;;;;;;;;-1:-1:-1;46183:35:0;;;;-1:-1:-1;;;46183:35:0;;;;;;7844:400;;;;;;;;;;-1:-1:-1;7844:400:0;;;;;:::i;:::-;;:::i;23185:216::-;;;;;;;;;;-1:-1:-1;23185:216:0;;;;;:::i;:::-;;:::i;6423:::-;;;;;;;;;;-1:-1:-1;6423:216:0;;;;;:::i;:::-;;:::i;23409:177::-;;;;;;;;;;-1:-1:-1;23409:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;23552:26:0;23520:7;23552:26;;;:18;:26;;;;;;;23409:177;49814:117;;;;;;;;;;-1:-1:-1;49814:117:0;;;;;:::i;:::-;;:::i;48664:164::-;;;;;;;;;;-1:-1:-1;48664:164:0;;;;;:::i;:::-;;:::i;54630:831::-;;;;;;;;;;-1:-1:-1;54630:831:0;;;;;:::i;:::-;;:::i;55826:133::-;;;;;;;;;;-1:-1:-1;55920:31:0;;55826:133;;55469:98;;;;;;;;;;-1:-1:-1;55469:98:0;;;;;:::i;:::-;;:::i;6647:201::-;;;;;;;;;;-1:-1:-1;6647:201:0;;;;;:::i;:::-;-1:-1:-1;;;;;6813:18:0;;;6781:7;6813:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;6647:201;52613:610;;;;;;;;;;-1:-1:-1;52613:610:0;;;;;:::i;:::-;;:::i;50494:109::-;;;;;;;;;;-1:-1:-1;50577:18:0;;50494:109;;55677:141;;;;;;;;;;-1:-1:-1;55775:35:0;;55677:141;;13371:281;;;;;;;;;;-1:-1:-1;13371:281:0;;;;;:::i;:::-;;:::i;50739:1249::-;;;;;;;;;;-1:-1:-1;50739:1249:0;;;;;:::i;:::-;;:::i;53231:1391::-;;;;;;;;;;-1:-1:-1;53231:1391:0;;;;;:::i;:::-;;:::i;:::-;;;;5468:25:1;;;5524:2;5509:18;;5502:34;;;;5552:18;;;5545:34;5456:2;5441:18;53231:1391:0;5266:319:1;21578:471:0;21668:1;21652:13;6210:12;;;6122:108;21652:13;:17;21644:26;;;;;;21687:9;:13;21683:359;;21745:105;21822:13;6210:12;;;6122:108;21822:13;21793:26;21794:9;-1:-1:-1;;;21793:15:0;:26::i;:::-;:42;;;;:::i;:::-;21745:25;;;:29;:105::i;:::-;21717:25;:133;21870:43;;21903:9;1613:25:1;;21891:10:0;;21870:43;;1601:2:1;1586:18;21870:43:0;;;;;;;21958:25;;:72;;22006:9;21958:29;:72::i;:::-;21930:25;:100;21683:359;21578:471::o;47803:106::-;47857:13;47890:11;47883:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47803:106;:::o;49548:123::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;49625:30:0::1;49658:5;49625:30:::0;;;:21:::1;:30;::::0;;;;:38;;-1:-1:-1;;49625:38:0::1;::::0;;49548:123::o;6856:210::-;6975:4;6997:39;387:10;7020:7;7029:6;6997:8;:39::i;:::-;-1:-1:-1;7054:4:0;6856:210;;;;;:::o;7074:454::-;7214:4;7231:36;7241:6;7249:9;7260:6;7231:9;:36::i;:::-;7278:220;7301:6;387:10;7349:138;7405:6;7349:138;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7349:19:0;;;;;;:11;:19;;;;;;;;387:10;7349:33;;;;;;;;;;:37;:138::i;:::-;7278:8;:220::i;:::-;-1:-1:-1;7516:4:0;7074:454;;;;;:::o;23594:372::-;-1:-1:-1;;;;;23875:36:0;;23708:7;23875:36;;;:28;:36;;;;;;;;;6389:18;;;;;;;23753:25;;-1:-1:-1;;;21151:6:0;23753:193;;:159;;:99;;:66;;:25;:47;:66::i;:::-;:97;:99::i;:::-;:121;;:159::i;:::-;:191;:193::i;:::-;:205;;;;:::i;49240:300::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49370:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;-1:-1:-1;;49370:37:0::1;49403:4;49370:37;::::0;;49420:23:::1;::::0;49392:7;;49420:11:::1;:23::i;:::-;49454:31;:15;49477:7:::0;49454:22:::1;:31::i;:::-;49503:29;::::0;-1:-1:-1;;;;;49503:29:0;::::1;::::0;::::1;::::0;;;::::1;49240:300:::0;:::o;50303:183::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;50400:5:::1;50381:24;;:15;;;;;;;;;;;:24;;::::0;50373:33:::1;;;::::0;::::1;;50417:15;:23:::0;;;::::1;;-1:-1:-1::0;;;50417:23:0::1;-1:-1:-1::0;;;;50417:23:0;;::::1;;::::0;;50456:22:::1;::::0;::::1;::::0;::::1;::::0;50435:5;1440:14:1;1433:22;1415:41;;1403:2;1388:18;;1275:187;50456:22:0::1;;;;;;;;50303:183:::0;:::o;7536:300::-;387:10;7651:4;7745:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;7745:34:0;;;;;;;;;;7651:4;;7673:133;;7723:7;;7745:50;;7784:10;7745:38;:50::i;49038:194::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;49139:5:::1;49118:26;;:17;;;;;;;;;;;:26;;::::0;49110:35:::1;;;::::0;::::1;;49156:17;:25:::0;;;::::1;;-1:-1:-1::0;;;49156:25:0::1;-1:-1:-1::0;;;;49156:25:0;;::::1;;::::0;;49197:27:::1;::::0;::::1;::::0;::::1;::::0;49176:5;1440:14:1;1433:22;1415:41;;1403:2;1388:18;;1275:187;51996:609:0;52100:7;52122:6;52143;52164:7;52186;52208;52256:22;:15;60380;;60299:104;52256:22;52247:5;:31;52243:249;;-1:-1:-1;52321:42:0;;-1:-1:-1;;;52382:2:0;-1:-1:-1;52382:2:0;;-1:-1:-1;52321:42:0;;-1:-1:-1;52321:42:0;;-1:-1:-1;52321:42:0;52295:185;;52243:249;52504:15;52522:36;:15;52552:5;52522:29;:36::i;:::-;52504:54;;52578:19;52589:7;52578:10;:19::i;:::-;52571:26;;;;;;;;;;;;;51996:609;;;;;;;;:::o;49939:178::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;50093:16:::1;:5:::0;50102:6:::1;50093:16;:::i;:::-;50055:35;:54:::0;-1:-1:-1;49939:178:0:o;50125:170::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;50271:16:::1;:5:::0;50280:6:::1;50271:16;:::i;:::-;50237:31;:50:::0;-1:-1:-1;50125:170:0:o;48230:232::-;48290:164;;-1:-1:-1;;;48290:164:0;;7065:2:1;48290:164:0;;;7047:21:1;7104:3;7084:18;;;7077:31;7144:34;7124:18;;;7117:62;7215:34;7195:18;;;7188:62;7287:34;7266:19;;;7259:63;-1:-1:-1;;;7338:19:1;;;7331:44;7392:19;;48290:164:0;6863:554:1;48470:186:0;13128:6;;48589:4;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;48618:30:0::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;::::0;48470:186::o;13215:148::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;13306:6:::1;::::0;13285:40:::1;::::0;13322:1:::1;::::0;-1:-1:-1;;;;;13306:6:0::1;::::0;13285:40:::1;::::0;13322:1;;13285:40:::1;13336:6;:19:::0;;-1:-1:-1;;;;;;13336:19:0::1;::::0;;13215:148::o;49679:127::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49760:30:0;;;::::1;;::::0;;;:21:::1;:30;::::0;;;;:38;;-1:-1:-1;;49760:38:0::1;::::0;::::1;;::::0;;;::::1;::::0;;49679:127::o;23046:131::-;23112:7;23139:30;23162:6;23139:22;:30::i;47917:110::-;47973:13;48006;47999:20;;;;;:::i;48836:194::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;48937:5:::1;48916:26;;:17;;;;;;;;;;;:26;;::::0;48908:35:::1;;;::::0;::::1;;48954:17;:25:::0;;;::::1;;-1:-1:-1::0;;;48954:25:0::1;-1:-1:-1::0;;;;48954:25:0;;::::1;;::::0;;48995:27:::1;::::0;::::1;::::0;::::1;::::0;48974:5;1440:14:1;1433:22;1415:41;;1403:2;1388:18;;1275:187;7844:400:0;7964:4;7986:228;387:10;8036:7;8058:145;8115:15;8058:145;;;;;;;;;;;;;;;;;387:10;8058:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;8058:34:0;;;;;;;;;;;;:38;:145::i;23185:216::-;-1:-1:-1;;;;;23366:26:0;;23299:7;23366:26;;;:18;:26;;;;;;23331:62;;:30;23385:6;23331:22;:30::i;:::-;:34;;:62::i;6423:216::-;6545:4;6567:42;387:10;6591:9;6602:6;6567:9;:42::i;49814:117::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49894:21:0;;;::::1;;::::0;;;:12:::1;:21;::::0;;;;:29;;-1:-1:-1;;49894:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;49814:117::o;48664:164::-;13128:6;;48770:4;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;48799:21:0::1;;::::0;;;:12:::1;:21;::::0;;;;;::::1;;::::0;48664:164::o;54630:831::-;13128:6;;54748:4;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;54774:15:::1;::::0;-1:-1:-1;;;54774:15:0;::::1;;;54770:60;;;-1:-1:-1::0;54813:5:0::1;54806:12;;54770:60;-1:-1:-1::0;;;;;54858:21:0;::::1;54842:13;54858:21:::0;;;:12:::1;:21;::::0;;;;;::::1;;54896:9:::0;:21;::::1;;;;54909:8;54896:21;:43;;;;-1:-1:-1::0;54922:17:0::1;::::0;-1:-1:-1;;;54922:17:0;::::1;;;54921:18;54896:43;54892:88;;;54963:5;54956:12;;;;;54892:88;54992:14;55009:8;:104;;55081:32;55105:7;55081:23;:32::i;:::-;55009:104;;;55033:32;55057:7;55033:23;:32::i;:::-;54992:121:::0;-1:-1:-1;55130:10:0;;55126:303:::1;;-1:-1:-1::0;;;;;55157:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;55183:15:::1;55157:41:::0;;55213:179;::::1;;;55287:9;55251:46;;55270:7;-1:-1:-1::0;;;;;55251:46:0::1;;55279:6;55251:46;;;;1613:25:1::0;;1601:2;1586:18;;1467:177;55251:46:0::1;;;;;;;;55213:179;;;55366:9;55343:33;;55349:7;-1:-1:-1::0;;;;;55343:33:0::1;;55358:6;55343:33;;;;1613:25:1::0;;1601:2;1586:18;;1467:177;55343:33:0::1;;;;;;;;55213:179;55413:4;55406:11;;;;;;55126:303;-1:-1:-1::0;55448:5:0::1;::::0;54630:831;-1:-1:-1;;;;54630:831:0:o;55469:98::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;55539:12:::1;:20:::0;;-1:-1:-1;;;;;;55539:20:0::1;-1:-1:-1::0;;;;;55539:20:0;;;::::1;::::0;;;::::1;::::0;;55469:98::o;52613:610::-;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;52727:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;52774:7;52723:69;52821:31;;52808:10;:44;52804:169;;;52869:31;:15;52892:7:::0;52869:22:::1;:31::i;:::-;52915:23;52927:7;52936:1;52915:11;:23::i;:::-;52613:610:::0;;:::o;52804:169::-:1;52985:32;52997:7;53006:10;52985:11;:32::i;:::-;53048:35;;53034:10;:49;53030:186;;53100:40;:15;53120:7:::0;53129:10;53100:19:::1;:40::i;53030:186::-;53173:31;:15;53196:7:::0;53173:22:::1;:31::i;13371:281::-:0;13128:6;;-1:-1:-1;;;;;13128:6:0;387:10;13128:22;13120:67;;;;-1:-1:-1;;;13120:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13474:22:0;::::1;13452:110;;;::::0;-1:-1:-1;;;13452:110:0;;7624:2:1;13452:110:0::1;::::0;::::1;7606:21:1::0;7663:2;7643:18;;;7636:30;7702:34;7682:18;;;7675:62;-1:-1:-1;;;7753:18:1;;;7746:36;7799:19;;13452:110:0::1;7422:402:1::0;13452:110:0::1;13599:6;::::0;13578:38:::1;::::0;-1:-1:-1;;;;;13578:38:0;;::::1;::::0;13599:6:::1;::::0;13578:38:::1;::::0;13599:6:::1;::::0;13578:38:::1;13627:6;:17:::0;;-1:-1:-1;;;;;;13627:17:0::1;-1:-1:-1::0;;;;;13627:17:0;;;::::1;::::0;;;::::1;::::0;;13371:281::o;50739:1249::-;51082:8;50839:15;;;;;51111:38;:15;51082:8;51111:29;:38::i;:::-;51103:46;;-1:-1:-1;;51162:29:0;;51217:1;51208:5;:10;51204:598;;51256:18;;51247:5;51239:35;51235:556;;;51361:18;;51322:77;;:5;;:9;:77::i;:::-;51295:104;;51235:556;;;51526:18;;51475:15;:27;51440:32;;-1:-1:-1;51475:169:0;;51643:1;51475:169;;;51600:18;;51568:15;:27;:51;;:31;:51::i;:::-;51440:204;-1:-1:-1;51692:83:0;:5;51440:204;51692:9;:83::i;:::-;51665:110;;51421:370;51235:556;51838:31;51861:7;51838:22;:31::i;:::-;51814:55;;51897:31;51920:7;51897:22;:31::i;:::-;-1:-1:-1;;;;;51957:23:0;;;;;;:14;:23;;;;;;51972:7;;50739:1249;;-1:-1:-1;50739:1249:0;;;;;-1:-1:-1;;50739:1249:0:o;53231:1391::-;53419:15;:27;53309:7;;;;;;53463:25;;;:44;;-1:-1:-1;53492:15:0;;-1:-1:-1;;;53492:15:0;;;;53463:44;53459:110;;;-1:-1:-1;;53538:18:0;;53532:1;;-1:-1:-1;53532:1:0;;-1:-1:-1;53524:33:0;;53459:110;53611:18;;53581:27;;53692:9;53674:27;;53714:18;53747:14;53778:724;53795:3;53785:7;:13;:50;;;;;53815:20;53802:10;:33;53785:50;53778:724;;;53852:21;;;;:::i;:::-;;;;53917:20;53894:19;:43;53890:107;;53980:1;53958:23;;53890:107;54013:15;54031;:20;;54052:19;54031:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;54031:41:0;54094:30;;;:21;:30;;;;;;;;54031:41;;-1:-1:-1;54094:30:0;;54089:166;;54149:38;54172:7;54182:4;54149:14;:38::i;:::-;54145:95;;;54212:8;;;;:::i;:::-;;;;54145:95;54271:12;;;;:::i;:::-;;;;54300:18;54321:9;54300:30;;54361:10;54351:7;:20;54347:107;;;54402:36;54414:23;:7;54426:10;54414:11;:23::i;:::-;54402:7;;:11;:36::i;:::-;54392:46;;54347:107;54480:10;-1:-1:-1;53778:724:0;;-1:-1:-1;53778:724:0;;54514:18;:40;;;54575:10;;-1:-1:-1;54587:6:0;-1:-1:-1;54535:19:0;;-1:-1:-1;;;;53231:1391:0;;;;;;:::o;11594:250::-;11652:7;11676:1;11681;11676:6;11672:47;;-1:-1:-1;11706:1:0;11699:8;;11672:47;11731:9;11743:5;11747:1;11743;:5;:::i;:::-;11731:17;-1:-1:-1;11776:1:0;11767:5;11771:1;11731:17;11767:5;:::i;:::-;:10;11759:56;;;;-1:-1:-1;;;11759:56:0;;8303:2:1;11759:56:0;;;8285:21:1;8342:2;8322:18;;;8315:30;8381:34;8361:18;;;8354:62;-1:-1:-1;;;8432:18:1;;;8425:31;8473:19;;11759:56:0;8101:397:1;11759:56:0;11835:1;11594:250;-1:-1:-1;;;11594:250:0:o;11027:181::-;11085:7;;11117:5;11121:1;11117;:5;:::i;:::-;11105:17;;11146:1;11141;:6;;11133:46;;;;-1:-1:-1;;;11133:46:0;;8835:2:1;11133:46:0;;;8817:21:1;8874:2;8854:18;;;8847:30;8913:29;8893:18;;;8886:57;8960:18;;11133:46:0;8633:351:1;9719:380:0;-1:-1:-1;;;;;9855:19:0;;9847:68;;;;-1:-1:-1;;;9847:68:0;;9191:2:1;9847:68:0;;;9173:21:1;9230:2;9210:18;;;9203:30;9269:34;9249:18;;;9242:62;-1:-1:-1;;;9320:18:1;;;9313:34;9364:19;;9847:68:0;8989:400:1;9847:68:0;-1:-1:-1;;;;;9934:21:0;;9926:68;;;;-1:-1:-1;;;9926:68:0;;9596:2:1;9926:68:0;;;9578:21:1;9635:2;9615:18;;;9608:30;9674:34;9654:18;;;9647:62;-1:-1:-1;;;9725:18:1;;;9718:32;9767:19;;9926:68:0;9394:398:1;9926:68:0;-1:-1:-1;;;;;10007:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10059:32;;1613:25:1;;;10059:32:0;;1586:18:1;10059:32:0;;;;;;;9719:380;;;:::o;48035:187::-;48149:65;;-1:-1:-1;;;48149:65:0;;9999:2:1;48149:65:0;;;9981:21:1;10038:2;10018:18;;;10011:30;10077:34;10057:18;;;10050:62;-1:-1:-1;;;10128:18:1;;;10121:45;10183:19;;48149:65:0;9797:411:1;48149:65:0;48035:187;;;:::o;11360:226::-;11480:7;11516:12;11508:6;;;;11500:29;;;;-1:-1:-1;;;11500:29:0;;;;;;;;:::i;:::-;-1:-1:-1;11540:9:0;11552:5;11556:1;11552;:5;:::i;:::-;11540:17;11360:226;-1:-1:-1;;;;;11360:226:0:o;15056:148::-;15112:6;15149:1;15170:6;;;;15162:15;;;;;14573:176;14629:6;;14659:5;14663:1;14659;:5;:::i;:::-;14648:16;;14689:1;14684;:6;;:16;;;;;14699:1;14694;:6;;14684:16;14683:38;;;;14710:1;14706;:5;:14;;;;;14719:1;14715;:5;14706:14;14675:47;;;;;14894:127;14950:7;14983:1;14978;:6;;14970:15;;;;;;-1:-1:-1;15011:1:0;14894:127::o;25073:451::-;-1:-1:-1;;;;;6389:18:0;;25151:22;6389:18;;;;;;;;;;;25211:27;;;25207:310;;;25255:18;25276:30;:10;25291:14;25276;:30::i;:::-;25255:51;;25321:26;25327:7;25336:10;25321:5;:26::i;:::-;25240:119;48035:187;;;:::o;25207:310::-;25382:14;25369:10;:27;25365:152;;;25413:18;25434:30;:14;25453:10;25434:18;:30::i;:::-;25413:51;;25479:26;25485:7;25494:10;25479:5;:26::i;60782:481::-;-1:-1:-1;;;;;60853:17:0;;;;;;:12;;;:17;;;;;;;;60848:57;;60782:481;;:::o;60848:57::-;-1:-1:-1;;;;;60924:17:0;;;;;;:12;;;:17;;;;;;;;60917:24;;-1:-1:-1;;60917:24:0;;;;60959:10;;;:15;;;;;60952:22;;;61003:11;;;:16;;;;;;61050:15;;61003:16;;60924:17;61050:19;;;:::i;:::-;61030:39;;61080:15;61098:3;:8;;61107:9;61098:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;61098:19:0;;;61130:20;;;:11;;;:20;;;;;;;:28;;;61176:16;;;;;;;61169:23;;;;61205:15;;61098:19;;-1:-1:-1;61098:19:0;;61130:3;;61153:5;;61205:15;;;;;;:::i;:::-;;;;;;;;;;:25;;-1:-1:-1;;;;;;61205:25:0;-1:-1:-1;;;;;61205:25:0;;;;;;;;;;61241:14;;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;61241:14:0;;;;;-1:-1:-1;;;;;;61241:14:0;;;;;;-1:-1:-1;;;;;60782:481:0:o;60131:160::-;60236:7;60268:3;:8;;60277:5;60268:15;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;60268:15:0;;60131:160;-1:-1:-1;;;60131:160:0:o;11216:136::-;11274:7;11301:43;11305:1;11308;11301:43;;;;;;;;;;;;;;;;;:3;:43::i;57744:1747::-;57853:7;57878:29;57910:28;57933:4;57910:22;:28::i;:::-;57878:60;-1:-1:-1;57953:25:0;;57949:1516;;-1:-1:-1;;;;;58022:24:0;;;;;;:18;:24;;;;;;:83;;58069:21;58022:28;:83::i;:::-;-1:-1:-1;;;;;57995:24:0;;;;;;;:18;:24;;;;;:110;;;;58145:12;;;;;58201:908;;58266:115;;-1:-1:-1;;;;;58266:9:0;;;58354:4;;58305:21;;58266:115;;;;58305:21;58266:9;58354:4;58266:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58252:129;;;;;58201:908;;;58446:16;;;58460:1;58446:16;;;;;;;;58422:21;;58446:16;;;;;;;;-1:-1:-1;;58491:15:0;;:22;;;-1:-1:-1;;;58491:22:0;;;;58422:40;;-1:-1:-1;;;;;;58491:15:0;;;;:20;;-1:-1:-1;58491:22:0;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58481:4;58486:1;58481:7;;;;;;;;:::i;:::-;;;;;;:32;-1:-1:-1;;;;;58481:32:0;;;-1:-1:-1;;;;;58481:32:0;;;;;58542:12;58532:4;58537:1;58532:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;58532:22:0;;;:7;;;;;;;;;:22;58598:15;;:356;;-1:-1:-1;;;58598:356:0;;:15;;;:92;;58724:21;;58598:356;;:15;;58854:4;;58885;;58916:15;;58598:356;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58573:521;;59069:5;59059:15;;58573:521;;;59005:4;58995:14;;58573:521;58403:706;58201:908;59130:7;59125:286;;-1:-1:-1;;;;;59185:24:0;;;;;;:18;:24;;;;;;:91;;59236:21;59185:28;:91::i;:::-;-1:-1:-1;;;;;59158:24:0;;;;;;;:18;:24;;;;;:118;;;;-1:-1:-1;59158:24:0;;57744:1747;-1:-1:-1;;;57744:1747:0:o;59125:286::-;59367:4;-1:-1:-1;;;;;59349:46:0;;59373:21;59349:46;;;;1613:25:1;;1601:2;1586:18;;1467:177;59349:46:0;;;;;;;;-1:-1:-1;59432:21:0;;57744:1747;-1:-1:-1;;;57744:1747:0:o;57949:1516::-;-1:-1:-1;59482:1:0;;57744:1747;-1:-1:-1;;57744:1747:0:o;55975:1761::-;56060:7;56085:29;56117:31;56140:7;56117:22;:31::i;:::-;56085:63;-1:-1:-1;56163:25:0;;56159:1549;;-1:-1:-1;;;;;56264:27:0;;56205:12;56264:27;;;:18;:27;;;;;;:86;;56314:21;56264:31;:86::i;:::-;-1:-1:-1;;;;;56234:27:0;;;;;;:18;:27;;;;;;:116;;;;56391:16;;56405:1;56391:16;;;;;;;;;56234:27;;56391:16;;;;;;;;;;-1:-1:-1;;56432:15:0;;:22;;;-1:-1:-1;;;56432:22:0;;;;56367:40;;-1:-1:-1;;;;;;56432:15:0;;;;:20;;-1:-1:-1;56432:22:0;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56422:4;56427:1;56422:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;56422:32:0;;;:7;;;;;;;;;:32;56487:16;;56469:7;;56487:16;;;56469:4;;56487:16;;56469:7;;;;;;:::i;:::-;-1:-1:-1;;;;;56469:35:0;;;:7;;;;;;;;;:35;56543:16;;:41;;-1:-1:-1;;;56543:41:0;;56578:4;56543:41;;;1822:51:1;56521:19:0;;56543:16;;;;;:26;;1795:18:1;;56543:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56652:15;;:333;;-1:-1:-1;;;56652:333:0;;56521:63;;-1:-1:-1;;;;;;56652:15:0;;:88;;56770:21;;56652:333;;:15;;56888:4;;56923;;56951:15;;56652:333;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56631:805;;57415:5;57405:15;;56631:805;;;57037:16;;:63;;-1:-1:-1;;;57037:63:0;;57094:4;57037:63;;;1822:51:1;57018:16:0;;57037:102;;57127:11;;-1:-1:-1;;;;;57037:16:0;;:48;;1795:18:1;;57037:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:102::-;57018:121;-1:-1:-1;57162:12:0;;57158:206;;57236:16;;:44;;-1:-1:-1;;;57236:44:0;;-1:-1:-1;;;;;13182:32:1;;;57236:44:0;;;13164:51:1;13231:18;;;13224:34;;;57209:4:0;;-1:-1:-1;57236:16:0;;;;:25;;13137:18:1;;57236:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57158:206;;;57339:5;57329:15;;57158:206;56999:380;56631:805;57457:7;57452:200;;-1:-1:-1;;;;;57515:27:0;;;;;;:18;:27;;;;;;:94;;57569:21;57515:31;:94::i;:::-;-1:-1:-1;;;;;57485:27:0;;;;;;;:18;:27;;;;;:124;;;;-1:-1:-1;57485:27:0;;55975:1761;-1:-1:-1;;;;55975:1761:0:o;57452:200::-;-1:-1:-1;57675:21:0;;55975:1761;-1:-1:-1;;;;55975:1761:0:o;60411:363::-;-1:-1:-1;;;;;60525:17:0;;;;;;:12;;;:17;;;;;;;;60521:246;;;-1:-1:-1;;;;;60559:15:0;;;;;;:10;;;:15;;;;;:21;;;48035:187;;;:::o;60521:246::-;-1:-1:-1;;;;;60613:17:0;;;;;;:12;;;:17;;;;;;;;:24;;-1:-1:-1;;60613:24:0;60633:4;60613:24;;;;;;60652:10;;;:15;;;;;:21;;;60707:15;;60688:11;;;:16;;;;;:34;;;60737:18;;;;;;;;;;;;-1:-1:-1;;;;;;60737:18:0;;;;;;60411:363;;;:::o;59887:236::-;-1:-1:-1;;;;;60019:17:0;;59990:6;60019:17;;;:12;;;:17;;;;;;;;60014:60;;-1:-1:-1;;;60053:9:0;;60014:60;-1:-1:-1;;;;;;60098:16:0;;;;;:11;;;;;:16;;;;;;;59887:236::o;14389:176::-;14445:6;;14475:5;14479:1;14475;:5;:::i;:::-;14464:16;;14505:1;14500;:6;;:16;;;;;14515:1;14510;:6;;14500:16;14499:38;;;;14526:1;14522;:5;:14;;;;;14535:1;14531;:5;14491:47;;;;;24489:284;24565:27;24577:7;24586:5;24565:11;:27::i;:::-;24645:120;24711:53;24712:36;24742:5;24712:25;;:29;;:36;;;;:::i;24711:53::-;-1:-1:-1;;;;;24645:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;:::-;-1:-1:-1;;;;;24605:37:0;;;;;;;:28;:37;;;;;:160;;;;-1:-1:-1;24489:284:0:o;24781:::-;24857:27;24869:7;24878:5;24857:11;:27::i;:::-;24937:120;25003:53;25004:36;25034:5;25004:25;;:29;;:36;;;;:::i;25003:53::-;-1:-1:-1;;;;;24937:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;8870:378::-;-1:-1:-1;;;;;8954:21:0;;8946:65;;;;-1:-1:-1;;;8946:65:0;;13926:2:1;8946:65:0;;;13908:21:1;13965:2;13945:18;;;13938:30;14004:33;13984:18;;;13977:61;14055:18;;8946:65:0;13724:355:1;8946:65:0;9101:12;;:24;;9118:6;9101:16;:24::i;:::-;9086:12;:39;-1:-1:-1;;;;;9157:18:0;;:9;:18;;;;;;;;;;;:30;;9180:6;9157:22;:30::i;:::-;-1:-1:-1;;;;;9136:18:0;;:9;:18;;;;;;;;;;;:51;;;;9203:37;;1613:25:1;;;9136:18:0;;:9;;9203:37;;1586:18:1;9203:37:0;;;;;;;;8870:378;;:::o;9256:455::-;-1:-1:-1;;;;;9340:21:0;;9332:67;;;;-1:-1:-1;;;9332:67:0;;14286:2:1;9332:67:0;;;14268:21:1;14325:2;14305:18;;;14298:30;14364:34;14344:18;;;14337:62;-1:-1:-1;;;14415:18:1;;;14408:31;14456:19;;9332:67:0;14084:397:1;9332:67:0;9495:105;9532:6;9495:105;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9495:18:0;;:9;:18;;;;;;;;;;;;:105;:22;:105::i;:::-;-1:-1:-1;;;;;9474:18:0;;:9;:18;;;;;;;;;;:126;9626:12;;:24;;9643:6;9626:16;:24::i;:::-;9611:12;:39;9666:37;;1613:25:1;;;9692:1:0;;-1:-1:-1;;;;;9666:37:0;;;;;1601:2:1;1586:18;9666:37:0;1467:177:1;14:548;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:131::-;-1:-1:-1;;;;;642:31:1;;632:42;;622:70;;688:1;685;678:12;622:70;567:131;:::o;703:247::-;762:6;815:2;803:9;794:7;790:23;786:32;783:52;;;831:1;828;821:12;783:52;870:9;857:23;889:31;914:5;889:31;:::i;955:315::-;1023:6;1031;1084:2;1072:9;1063:7;1059:23;1055:32;1052:52;;;1100:1;1097;1090:12;1052:52;1139:9;1126:23;1158:31;1183:5;1158:31;:::i;:::-;1208:5;1260:2;1245:18;;;;1232:32;;-1:-1:-1;;;955:315:1:o;1884:456::-;1961:6;1969;1977;2030:2;2018:9;2009:7;2005:23;2001:32;1998:52;;;2046:1;2043;2036:12;1998:52;2085:9;2072:23;2104:31;2129:5;2104:31;:::i;:::-;2154:5;-1:-1:-1;2211:2:1;2196:18;;2183:32;2224:33;2183:32;2224:33;:::i;:::-;1884:456;;2276:7;;-1:-1:-1;;;2330:2:1;2315:18;;;;2302:32;;1884:456::o;2742:118::-;2828:5;2821:13;2814:21;2807:5;2804:32;2794:60;;2850:1;2847;2840:12;2865:241;2921:6;2974:2;2962:9;2953:7;2949:23;2945:32;2942:52;;;2990:1;2987;2980:12;2942:52;3029:9;3016:23;3048:28;3070:5;3048:28;:::i;3111:180::-;3170:6;3223:2;3211:9;3202:7;3198:23;3194:32;3191:52;;;3239:1;3236;3229:12;3191:52;-1:-1:-1;3262:23:1;;3111:180;-1:-1:-1;3111:180:1:o;3858:382::-;3923:6;3931;3984:2;3972:9;3963:7;3959:23;3955:32;3952:52;;;4000:1;3997;3990:12;3952:52;4039:9;4026:23;4058:31;4083:5;4058:31;:::i;:::-;4108:5;-1:-1:-1;4165:2:1;4150:18;;4137:32;4178:30;4137:32;4178:30;:::i;:::-;4227:7;4217:17;;;3858:382;;;;;:::o;4873:388::-;4941:6;4949;5002:2;4990:9;4981:7;4977:23;4973:32;4970:52;;;5018:1;5015;5008:12;4970:52;5057:9;5044:23;5076:31;5101:5;5076:31;:::i;:::-;5126:5;-1:-1:-1;5183:2:1;5168:18;;5155:32;5196:33;5155:32;5196:33;:::i;5590:127::-;5651:10;5646:3;5642:20;5639:1;5632:31;5682:4;5679:1;5672:15;5706:4;5703:1;5696:15;5722:217;5762:1;5788;5778:132;;5832:10;5827:3;5823:20;5820:1;5813:31;5867:4;5864:1;5857:15;5895:4;5892:1;5885:15;5778:132;-1:-1:-1;5924:9:1;;5722:217::o;5944:380::-;6023:1;6019:12;;;;6066;;;6087:61;;6141:4;6133:6;6129:17;6119:27;;6087:61;6194:2;6186:6;6183:14;6163:18;6160:38;6157:161;;6240:10;6235:3;6231:20;6228:1;6221:31;6275:4;6272:1;6265:15;6303:4;6300:1;6293:15;6157:161;;5944:380;;;:::o;6329:356::-;6531:2;6513:21;;;6550:18;;;6543:30;6609:34;6604:2;6589:18;;6582:62;6676:2;6661:18;;6329:356::o;6690:168::-;6763:9;;;6794;;6811:15;;;6805:22;;6791:37;6781:71;;6832:18;;:::i;7829:135::-;7868:3;7889:17;;;7886:43;;7909:18;;:::i;:::-;-1:-1:-1;7956:1:1;7945:13;;7829:135::o;7969:127::-;8030:10;8025:3;8021:20;8018:1;8011:31;8061:4;8058:1;8051:15;8085:4;8082:1;8075:15;8503:125;8568:9;;;8589:10;;;8586:36;;;8602:18;;:::i;10213:128::-;10280:9;;;10301:11;;;10298:37;;;10315:18;;:::i;10346:216::-;10410:9;;;10438:11;;;10385:3;10468:9;;10496:10;;10492:19;;10521:10;;10513:19;;10489:44;10486:70;;;10536:18;;:::i;:::-;10486:70;;10346:216;;;;:::o;10567:127::-;10628:10;10623:3;10619:20;10616:1;10609:31;10659:4;10656:1;10649:15;10683:4;10680:1;10673:15;11041:251;11111:6;11164:2;11152:9;11143:7;11139:23;11135:32;11132:52;;;11180:1;11177;11170:12;11132:52;11212:9;11206:16;11231:31;11256:5;11231:31;:::i;11297:461::-;11350:3;11388:5;11382:12;11415:6;11410:3;11403:19;11441:4;11470:2;11465:3;11461:12;11454:19;;11507:2;11500:5;11496:14;11528:1;11538:195;11552:6;11549:1;11546:13;11538:195;;;11617:13;;-1:-1:-1;;;;;11613:39:1;11601:52;;11673:12;;;;11708:15;;;;11649:1;11567:9;11538:195;;;-1:-1:-1;11749:3:1;;11297:461;-1:-1:-1;;;;;11297:461:1:o;11763:518::-;12042:6;12031:9;12024:25;12085:3;12080:2;12069:9;12065:18;12058:31;12005:4;12106:57;12158:3;12147:9;12143:19;12135:6;12106:57;:::i;:::-;-1:-1:-1;;;;;12199:32:1;;;;12194:2;12179:18;;12172:60;-1:-1:-1;12263:2:1;12248:18;12241:34;12098:65;11763:518;-1:-1:-1;;11763:518:1:o;12286:184::-;12356:6;12409:2;12397:9;12388:7;12384:23;12380:32;12377:52;;;12425:1;12422;12415:12;12377:52;-1:-1:-1;12448:16:1;;12286:184;-1:-1:-1;12286:184:1:o;13269:245::-;13336:6;13389:2;13377:9;13368:7;13364:23;13360:32;13357:52;;;13405:1;13402;13395:12;13357:52;13437:9;13431:16;13456:28;13478:5;13456:28;:::i;13519:200::-;13585:9;;;13558:4;13613:9;;13641:10;;13653:12;;;13637:29;13676:12;;;13668:21;;13634:56;13631:82;;;13693:18;;:::i;:::-;13631:82;13519:200;;;;:::o

ipfs://7baa357f8585242405d15dbbefcf52dda31ac82a45ba2fc3641bcda8a0dd2a32