ETH Price: $3,294.74 (-1.10%)

Token

MAGAVPTRACKER (MVPTTRACKER)
 

Overview

Max Total Supply

41,962,366.437417139173217937 MVPTTRACKER

Holders

1,320

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-

Other Info

Token Contract (WITH 18 Decimals)

Balance
990,189.132334775645163493 MVPTTRACKER

Value
$0.00
0x1188a624abca42900C05DeB18e4baD8EAF12B106
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
MAGAVPDividendTracker

Compiler Version
v0.8.17+commit.8df45f5f

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2024-02-10
*/

// 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 MAGAVP 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;

    MAGAVPDividendTracker public dividendTracker;

    address payable public marketingWallet;
    address payable public buybackWallet;

    // Max tx, dividend threshold and tax variables
    uint256 public maxWallet;
    uint256 public swapTokensAtAmount;
    uint256 public sellRewardsFee;
    uint256 public sellMarketingFees;
    uint256 public buyMarketingFees;
    uint256 public buyRewardsFee;
    uint256 public buyBuyBackFee;
    uint256 public sellBuyBackFee;

    // 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 updatebuybackWallet(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 buyBuyBackFee,
        uint256 sellBuyBackFee
    );


    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("MAGA VP", "MVP") {
        marketingWallet = payable(0x2b486FE86f88EA5a29Ab9c53dD70Da38b043B137);
        buybackWallet = payable(0xD53cF51AF3280BEaa3eb95BE6Ba983B6B6982b5c);
        address router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

        buyMarketingFees = 50;
        sellMarketingFees = 50;
        buyRewardsFee = 100;
        sellRewardsFee = 100;
        buyBuyBackFee = 50;
        sellBuyBackFee = 50;

        totalBuyFees = buyRewardsFee
            .add(buyMarketingFees)
            .add(buyBuyBackFee);
        totalSellFees = sellRewardsFee
            .add(sellMarketingFees)
            .add(sellBuyBackFee);

        dividendTracker = new MAGAVPDividendTracker(
            payable(this),
            router,
            0x576e2BeD8F7b46D34016198911Cdf9886f78bea7,
            "MAGAVPTRACKER",
            "MVPTTRACKER"
        );

        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(buybackWallet)] = true;
        _isExcludedFromFees[msg.sender] = true;

        uint256 totalTokenSupply = (50_000_000) * (10**18);
        _mint(owner(), totalTokenSupply); // only time internal mint function is ever called is to create supply
        maxWallet = totalTokenSupply / 50; // 2%
        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 buyback wallet
    function setBuybackWallet(address wallet) external onlyOwner {
        _isExcludedFromFees[wallet] = true;
        buybackWallet = payable(wallet);
        emit updatebuybackWallet(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 value) external onlyOwner {
        value = value * (10**18);
        require(value >= _totalSupply / 1000, "max wallet cannot be set to less than 0.1%");
        maxWallet = value;
    }

    // rewards threshold
    function setSwapTriggerAmount(uint256 amount) public onlyOwner {
        swapTokensAtAmount = amount * (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 buybackBuy,
        uint256 buybackSell
    ) public onlyOwner {
        buyMarketingFees = marketingBuy;
        buyRewardsFee = RewardsBuy;
        sellMarketingFees = marketingSell;
        sellRewardsFee = RewardsSell;
        buyBuyBackFee = buybackBuy;
        sellBuyBackFee = buybackSell;

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

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

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

        emit UpdateFees(
            sellMarketingFees,
            sellRewardsFee,
            buyMarketingFees,
            buyRewardsFee,
            buyBuyBackFee,
            sellBuyBackFee
        );
    }

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

        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;
                buybackFee = sellBuyBackFee;

            } else if (isBuying) {
                RewardsFee = buyRewardsFee;
                marketingFees = buyMarketingFees;
                buybackFee = buyBuyBackFee;

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

            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 {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            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 + buyBuyBackFee);
        }
        if (sellRewardsFee > 0) {
            dividendsFromSell = address(this)
            .balance
            .mul(sellAmount)
            .div(totalAmount)
            .mul(sellRewardsFee)
            .div(sellRewardsFee + sellMarketingFees + sellBuyBackFee);
        }
        dividends = dividendsFromBuy.add(dividendsFromSell);

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

        uint256 feePortions;
        if (_completeFees > 0) {
            feePortions = address(this).balance.div(_completeFees);
        }
        uint256 marketingPayout = buyMarketingFees.add(sellMarketingFees) * feePortions;
        uint256 buybackPayout = buyBuyBackFee.add(sellBuyBackFee) * feePortions;

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

        emit SendDividends(
            dividends,
            marketingPayout + buybackPayout,
            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 MAGAVPDividendTracker 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;

    MAGAVP public MAGAVPContract;

    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;
        MAGAVPContract = MAGAVP(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, "MAGAVP_Dividend_Tracker: No transfers allowed");
    }

    function withdrawDividend() public pure override {
        require(
            false,
            "MAGAVP_Dividend_Tracker: withdrawDividend disabled. Use the 'claim' function on the main MAGAVP 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(MAGAVPContract);

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

            // make the swap
            try
                uniswapV2Router
                    .swapExactETHForTokensSupportingFeeOnTransferTokens{
                    value: _withdrawableDividend
                }(
                    0, // accept any amount of Tokens
                    path,
                    address(this),
                    block.timestamp
                )
            {
                uint256 received = MAGAVPContract
                    .balanceOf(address(this))
                    .sub(prevBalance);
                if (received > 0) {
                    success = true;
                    MAGAVPContract.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();
    }
}

Contract Security Audit

Contract ABI

[{"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":"MAGAVPContract","outputs":[{"internalType":"contract MAGAVP","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"}]

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

Deployed Bytecode

0x6080604052600436106103395760003560e01c806370a08231116101ab578063a9059cbb116100f7578063dd62ed3e11610095578063e7cb7f871161006f578063e7cb7f8714610a12578063f2fde38b14610a27578063fbcbc0f114610a47578063ffb2c47914610a6757600080fd5b8063dd62ed3e14610997578063e30443bc146109dd578063e7841ec0146109fd57600080fd5b8063ba079d49116100d1578063ba079d4914610922578063bc4c4b3714610942578063bdd4f29f14610962578063d8032ed31461097757600080fd5b8063a9059cbb146108ac578063aafd847a146108cc578063b22f8a041461090257600080fd5b806391b89fba116101645780639eec101e1161013e5780639eec101e1461082a578063a42340691461084b578063a457c2d71461086c578063a8b9d2401461088c57600080fd5b806391b89fba146107d557806395d89b41146107f55780639c3372ea1461080a57600080fd5b806370a0823114610716578063715018a61461074c57806374c13fda1461076157806385a6b3ae146107815780638bc1d639146107975780638da5cb5b146107b757600080fd5b8063313ce567116102855780635183d6fd1161022357806369aaae40116101fd57806369aaae40146106915780636a474002146106b15780636b69163b146106c65780636d48467b146106f657600080fd5b80635183d6fd146105fa5780635a84c5eb146106515780635ebf4db91461067157600080fd5b8063395093511161025f578063395093511461056957806340ffdd801461058957806341808904146105a95780634e7b827f146105ca57600080fd5b8063313ce5671461050d57806331e79db0146105295780633599bb171461054957600080fd5b806318160ddd116102f257806323b872dd116102cc57806323b872dd1461049957806325cd3598146104b957806327ce0147146104d75780633009a609146104f757600080fd5b806318160ddd146104275780631d4ff89a1461043c578063226cfa3d1461046c57600080fd5b806303c833021461034d57806306fdde03146103555780630928847114610380578063095ea7b3146103a057806309bbedde146103d05780631694505e146103ef57600080fd5b3661034857610346610aa2565b005b600080fd5b610346610aa2565b34801561036157600080fd5b5061036a610b35565b604051610377919061279c565b60405180910390f35b34801561038c57600080fd5b5061034661039b366004612802565b610bc7565b3480156103ac57600080fd5b506103c06103bb36600461281f565b610c1b565b6040519015158152602001610377565b3480156103dc57600080fd5b50600a545b604051908152602001610377565b3480156103fb57600080fd5b5060155461040f906001600160a01b031681565b6040516001600160a01b039091168152602001610377565b34801561043357600080fd5b506002546103e1565b34801561044857600080fd5b506103c0610457366004612802565b60116020526000908152604090205460ff1681565b34801561047857600080fd5b506103e1610487366004612802565b60176020526000908152604090205481565b3480156104a557600080fd5b506103c06104b436600461284b565b610c32565b3480156104c557600080fd5b506012546001600160a01b031661040f565b3480156104e357600080fd5b506103e16104f2366004612802565b610c9b565b34801561050357600080fd5b506103e1600e5481565b34801561051957600080fd5b5060405160128152602001610377565b34801561053557600080fd5b50610346610544366004612802565b610cf7565b34801561055557600080fd5b5061034661056436600461289a565b610d91565b34801561057557600080fd5b506103c061058436600461281f565b610e32565b34801561059557600080fd5b506103466105a436600461289a565b610e68565b3480156105b557600080fd5b506012546103c090600160a81b900460ff1681565b3480156105d657600080fd5b506103c06105e5366004612802565b600f6020526000908152604090205460ff1681565b34801561060657600080fd5b5061061a6106153660046128b7565b610efe565b604080516001600160a01b0390971687526020870195909552938501929092526060840152608083015260a082015260c001610377565b34801561065d57600080fd5b5061034661066c3660046128b7565b610f5e565b34801561067d57600080fd5b5061034661068c3660046128b7565b610fa0565b34801561069d57600080fd5b5060165461040f906001600160a01b031681565b3480156106bd57600080fd5b50610346610fe2565b3480156106d257600080fd5b506103c06106e1366004612802565b60106020526000908152604090205460ff1681565b34801561070257600080fd5b506103c0610711366004612802565b611088565b34801561072257600080fd5b506103e1610731366004612802565b6001600160a01b031660009081526020819052604090205490565b34801561075857600080fd5b506103466110d4565b34801561076d57600080fd5b5060125461040f906001600160a01b031681565b34801561078d57600080fd5b506103e160085481565b3480156107a357600080fd5b506103466107b23660046128d0565b611148565b3480156107c357600080fd5b506009546001600160a01b031661040f565b3480156107e157600080fd5b506103e16107f0366004612802565b61119d565b34801561080157600080fd5b5061036a6111a8565b34801561081657600080fd5b5061034661082536600461289a565b6111b7565b34801561083657600080fd5b506012546103c090600160a01b900460ff1681565b34801561085757600080fd5b506012546103c090600160b01b900460ff1681565b34801561087857600080fd5b506103c061088736600461281f565b61124d565b34801561089857600080fd5b506103e16108a7366004612802565b61129c565b3480156108b857600080fd5b506103c06108c736600461281f565b6112c8565b3480156108d857600080fd5b506103e16108e7366004612802565b6001600160a01b031660009081526007602052604090205490565b34801561090e57600080fd5b5061034661091d3660046128d0565b6112d5565b34801561092e57600080fd5b506103c061093d366004612802565b61132a565b34801561094e57600080fd5b506103c061095d3660046128d0565b611376565b34801561096e57600080fd5b506019546103e1565b34801561098357600080fd5b50610346610992366004612802565b6114f7565b3480156109a357600080fd5b506103e16109b2366004612909565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3480156109e957600080fd5b506103466109f836600461281f565b611543565b348015610a0957600080fd5b50600e546103e1565b348015610a1e57600080fd5b506018546103e1565b348015610a3357600080fd5b50610346610a42366004612802565b6115db565b348015610a5357600080fd5b5061061a610a62366004612802565b6116c6565b348015610a7357600080fd5b50610a87610a823660046128b7565b611775565b60408051938452602084019290925290820152606001610377565b6000610aad60025490565b11610ab757600080fd5b3415610b3357610aea610ac960025490565b610ad734600160801b61189b565b610ae1919061294d565b60055490611924565b60055560405134815233907fa493a9229478c3fcd73f66d2cdeb7f94fd0f341da924d1054236d784541165119060200160405180910390a2600854610b2f9034611924565b6008555b565b606060138054610b449061296f565b80601f0160208091040260200160405190810160405280929190818152602001828054610b709061296f565b8015610bbd5780601f10610b9257610100808354040283529160200191610bbd565b820191906000526020600020905b815481529060010190602001808311610ba057829003601f168201915b5050505050905090565b6009546001600160a01b03163314610bfa5760405162461bcd60e51b8152600401610bf1906129a9565b60405180910390fd5b6001600160a01b03166000908152600f60205260409020805460ff19169055565b6000610c28338484611983565b5060015b92915050565b6000610c3f848484611aa7565b610c918433610c8c85604051806060016040528060288152602001612b9e602891396001600160a01b038a1660009081526001602090815260408083203384529091529020549190611b0a565b611983565b5060019392505050565b6001600160a01b03811660009081526006602090815260408083205491839052822054600554600160801b92610ced92610ce892610ce291610cdd919061189b565b611b44565b90611b54565b611b92565b610c2c919061294d565b6009546001600160a01b03163314610d215760405162461bcd60e51b8152600401610bf1906129a9565b6001600160a01b0381166000908152600f60205260408120805460ff19166001179055610d4f908290611ba5565b610d5a600a82611c04565b6040516001600160a01b038216907fa878b31040b2e6d0a9a3d3361209db3908ba62014b0dca52adbaee451d128b2590600090a250565b6009546001600160a01b03163314610dbb5760405162461bcd60e51b8152600401610bf1906129a9565b801515601260169054906101000a900460ff16151503610dda57600080fd5b60128054821515600160b01b0260ff60b01b199091161790556040517f3da2593f2c4724acfbd754045321e852cad26f3974834b1890045530f89c21b390610e2790831515815260200190565b60405180910390a150565b3360008181526001602090815260408083206001600160a01b03871684529091528120549091610c28918590610c8c9086611924565b6009546001600160a01b03163314610e925760405162461bcd60e51b8152600401610bf1906129a9565b801515601260159054906101000a900460ff16151503610eb157600080fd5b60128054821515600160a81b0260ff60a81b199091161790556040517fc138a28750b971696f46ea59731c471ef1e08e4015404afdb139fd2e87dca1bb90610e2790831515815260200190565b600080600080600080610f10600a5490565b8710610f2f575060009450600019935083925084915081905080610f55565b6000610f3c600a89611d3f565b9050610f47816116c6565b965096509650965096509650505b91939550919395565b6009546001600160a01b03163314610f885760405162461bcd60e51b8152600401610bf1906129a9565b610f9a81670de0b6b3a76400006129de565b60185550565b6009546001600160a01b03163314610fca5760405162461bcd60e51b8152600401610bf1906129a9565b610fdc81670de0b6b3a76400006129de565b60195550565b60405162461bcd60e51b815260206004820152606960248201527f4d41474156505f4469766964656e645f547261636b65723a207769746864726160448201527f774469766964656e642064697361626c65642e20557365207468652027636c6160648201527f696d272066756e6374696f6e206f6e20746865206d61696e204d41474156502060848201526831b7b73a3930b1ba1760b91b60a482015260c401610bf1565b6009546000906001600160a01b031633146110b55760405162461bcd60e51b8152600401610bf1906129a9565b506001600160a01b031660009081526010602052604090205460ff1690565b6009546001600160a01b031633146110fe5760405162461bcd60e51b8152600401610bf1906129a9565b6009546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600980546001600160a01b0319169055565b6009546001600160a01b031633146111725760405162461bcd60e51b8152600401610bf1906129a9565b6001600160a01b03919091166000908152601060205260409020805460ff1916911515919091179055565b6000610c2c8261129c565b606060148054610b449061296f565b6009546001600160a01b031633146111e15760405162461bcd60e51b8152600401610bf1906129a9565b801515601260149054906101000a900460ff1615150361120057600080fd5b60128054821515600160a01b0260ff60a01b199091161790556040517f8d34c313963017194ed726d050e868657d0e2d2c6748d13e358cd4b89d4ee7c890610e2790831515815260200190565b6000610c283384610c8c85604051806060016040528060258152602001612bc6602591393360009081526001602090815260408083206001600160a01b038d1684529091529020549190611b0a565b6001600160a01b038116600090815260076020526040812054610c2c906112c284610c9b565b90611d72565b6000610c28338484611aa7565b6009546001600160a01b031633146112ff5760405162461bcd60e51b8152600401610bf1906129a9565b6001600160a01b03919091166000908152601160205260409020805460ff1916911515919091179055565b6009546000906001600160a01b031633146113575760405162461bcd60e51b8152600401610bf1906129a9565b506001600160a01b031660009081526011602052604090205460ff1690565b6009546000906001600160a01b031633146113a35760405162461bcd60e51b8152600401610bf1906129a9565b601254600160b01b900460ff16156113bd57506000610c2c565b6001600160a01b03831660009081526011602052604090205460ff168280156113e35750805b80156113f95750601254600160a81b900460ff16155b15611408576000915050610c2c565b60008161141d5761141885611db4565b611426565b6114268561206d565b905080156114ec576001600160a01b0385166000908152601760205260409020429055811561149a57831515856001600160a01b03167ffbd928dd3806a2bdf802f3a28a2cc55205f95dbcd2c3ed313abfca278366f80c8360405161148d91815260200190565b60405180910390a36114e1565b831515856001600160a01b03167fa2c38e2d2fb7e3e1912d937fd1ca11ed6d51864dee4cfa7a7bf02becd7acf092836040516114d891815260200190565b60405180910390a35b600192505050610c2c565b506000949350505050565b6009546001600160a01b031633146115215760405162461bcd60e51b8152600401610bf1906129a9565b601280546001600160a01b0319166001600160a01b0392909216919091179055565b6009546001600160a01b0316331461156d5760405162461bcd60e51b8152600401610bf1906129a9565b6001600160a01b0382166000908152600f602052604090205460ff166115ad576019548110156115b1576115a2600a83611c04565b6115ad826000611ba5565b5050565b6115bb8282611ba5565b60185481106115d0576115ad600a83836123e0565b6115ad600a83611c04565b6009546001600160a01b031633146116055760405162461bcd60e51b8152600401610bf1906129a9565b6001600160a01b03811661166a5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610bf1565b6009546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600980546001600160a01b0319166001600160a01b0392909216919091179055565b806000808080806116d8600a87612489565b945060001993506000851261173a57600e5485111561170657600e546116ff9086906124d4565b935061173a565b600e54600a546000911061171b57600061172a565b600e54600a5461172a91611d72565b90506117368682611b54565b9450505b6117438661129c565b925061174e86610c9b565b6001600160a01b038716600090815260176020526040902054969895975093959294915050565b600a54600090819081908015806117955750601254600160b01b900460ff165b156117ab575050600e5460009250829150611894565b600e546000805a90506000805b89841080156117c657508582105b1561188357846117d5816129f5565b9550508585106117e457600094505b6000600a60000186815481106117fc576117fc612a0e565b60009182526020808320909101546001600160a01b0316808352601090915260409091205490915060ff1661184957611836816001611376565b156118495781611845816129f5565b9250505b82611853816129f5565b93505060005a90508085111561187a576118776118708683611d72565b8790611924565b95505b93506117b89050565b600e85905590975095509193505050505b9193909250565b6000826000036118ad57506000610c2c565b60006118b983856129de565b9050826118c6858361294d565b1461191d5760405162461bcd60e51b815260206004820152602160248201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6044820152607760f81b6064820152608401610bf1565b9392505050565b6000806119318385612a24565b90508381101561191d5760405162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006044820152606401610bf1565b6001600160a01b0383166119e55760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610bf1565b6001600160a01b038216611a465760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610bf1565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b60405162461bcd60e51b815260206004820152602d60248201527f4d41474156505f4469766964656e645f547261636b65723a204e6f207472616e60448201526c1cd9995c9cc8185b1b1bddd959609a1b6064820152608401610bf1565b505050565b60008184841115611b2e5760405162461bcd60e51b8152600401610bf1919061279c565b506000611b3b8486612a37565b95945050505050565b60008181811215610c2c57600080fd5b600080611b618385612a4a565b905060008312158015611b745750838112155b80611b895750600083128015611b8957508381125b61191d57600080fd5b600080821215611ba157600080fd5b5090565b6001600160a01b03821660009081526020819052604090205480821115611be4576000611bd28383611d72565b9050611bde8482612511565b50505050565b80821015611b05576000611bf88284611d72565b9050611bde8482612575565b6001600160a01b038116600090815260038301602052604090205460ff16611c2a575050565b6001600160a01b03811660009081526003830160209081526040808320805460ff1916905560018086018352818420849055600286019092528220548454909291611c7491612a37565b90506000846000018281548110611c8d57611c8d612a0e565b60009182526020808320909101546001600160a01b03908116808452600289019092526040808420879055908716835282209190915585549091508190869085908110611cdc57611cdc612a0e565b600091825260209091200180546001600160a01b0319166001600160a01b03929092169190911790558454859080611d1657611d16612a72565b600082815260209020810160001990810180546001600160a01b03191690550190555050505050565b6000826000018281548110611d5657611d56612a0e565b6000918252602090912001546001600160a01b03169392505050565b600061191d83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611b0a565b600080611dc08361129c565b90508015612064576001600160a01b038316600090815260076020526040902054611deb9082611924565b6001600160a01b03808516600090815260076020526040812092909255601254169081611e70576040516001600160a01b03861690610bb89085906000818181858888f193505050503d8060008114611e60576040519150601f19603f3d011682016040523d82523d6000602084013e611e65565b606091505b505080915050611fca565b6040805160028082526060820183526000926020830190803683375050601554604080516315ab88c960e31b815290519394506001600160a01b039091169263ad5c4648925060048083019260209291908290030181865afa158015611eda573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611efe9190612a88565b81600081518110611f1157611f11612a0e565b60200260200101906001600160a01b031690816001600160a01b0316815250508281600181518110611f4557611f45612a0e565b6001600160a01b03928316602091820292909201015260155460405163b6f9de9560e01b815291169063b6f9de95908690611f8b9060009086908c904290600401612ae9565b6000604051808303818588803b158015611fa457600080fd5b505af193505050508015611fb6575060015b611fc35760009150611fc8565b600191505b505b80612018576001600160a01b038516600090815260076020526040902054611ff29084611d72565b6001600160a01b0390951660009081526007602052604081209590955550929392505050565b846001600160a01b03167fee503bee2bb6a87e57bc57db795f98137327401a0e7b7ce42e37926cc1a9ca4d8460405161205391815260200190565b60405180910390a250909392505050565b50600092915050565b6000806120798361129c565b90508015612064576001600160a01b0383166000908152600760205260408120546120a49083611924565b6001600160a01b03851660009081526007602052604080822092909255815160028082526060820190935290918160200160208202803683375050601554604080516315ab88c960e31b815290519394506001600160a01b039091169263ad5c4648925060048083019260209291908290030181865afa15801561212c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121509190612a88565b8160008151811061216357612163612a0e565b6001600160a01b03928316602091820292909201015260165482519116908290600190811061219457612194612a0e565b6001600160a01b0392831660209182029290920101526016546040516370a0823160e01b815230600482015260009291909116906370a0823190602401602060405180830381865afa1580156121ee573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122129190612b1e565b60155460405163b6f9de9560e01b81529192506001600160a01b03169063b6f9de9590869061224c90600090879030904290600401612ae9565b6000604051808303818588803b15801561226557600080fd5b505af193505050508015612277575060015b6122845760009250612387565b6016546040516370a0823160e01b81523060048201526000916122f79184916001600160a01b0316906370a0823190602401602060405180830381865afa1580156122d3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112c29190612b1e565b905080156123805760165460405163a9059cbb60e01b81526001600160a01b03898116600483015260248201849052600196509091169063a9059cbb906044016020604051808303816000875af1158015612356573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061237a9190612b37565b50612385565b600093505b505b826123d6576001600160a01b0386166000908152600760205260409020546123af9085611d72565b6001600160a01b039096166000908152600760205260408120969096555093949350505050565b5091949350505050565b6001600160a01b038216600090815260038401602052604090205460ff1615612425576001600160a01b03821660009081526001840160205260409020819055505050565b6001600160a01b03821660008181526003850160209081526040808320805460ff19166001908117909155878101835281842086905587546002890184529184208290558101875586835291200180546001600160a01b0319169091179055505050565b6001600160a01b038116600090815260038301602052604081205460ff166124b45750600019610c2c565b506001600160a01b03166000908152600291909101602052604090205490565b6000806124e18385612b54565b9050600083121580156124f45750838113155b80611b895750600083128015611b89575083811361191d57600080fd5b61251b82826125b9565b612555612536610cdd8360055461189b90919063ffffffff16565b6001600160a01b038416600090815260066020526040902054906124d4565b6001600160a01b0390921660009081526006602052604090209190915550565b61257f8282612698565b61255561259a610cdd8360055461189b90919063ffffffff16565b6001600160a01b03841660009081526006602052604090205490611b54565b6001600160a01b03821661260f5760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610bf1565b60025461261c9082611924565b6002556001600160a01b0382166000908152602081905260409020546126429082611924565b6001600160a01b038316600081815260208181526040808320949094559251848152919290917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91015b60405180910390a35050565b6001600160a01b0382166126f85760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610bf1565b61273581604051806060016040528060228152602001612b7c602291396001600160a01b0385166000908152602081905260409020549190611b0a565b6001600160a01b03831660009081526020819052604090205560025461275b9082611d72565b6002556040518181526000906001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9060200161268c565b600060208083528351808285015260005b818110156127c9578581018301518582016040015282016127ad565b506000604082860101526040601f19601f8301168501019250505092915050565b6001600160a01b03811681146127ff57600080fd5b50565b60006020828403121561281457600080fd5b813561191d816127ea565b6000806040838503121561283257600080fd5b823561283d816127ea565b946020939093013593505050565b60008060006060848603121561286057600080fd5b833561286b816127ea565b9250602084013561287b816127ea565b929592945050506040919091013590565b80151581146127ff57600080fd5b6000602082840312156128ac57600080fd5b813561191d8161288c565b6000602082840312156128c957600080fd5b5035919050565b600080604083850312156128e357600080fd5b82356128ee816127ea565b915060208301356128fe8161288c565b809150509250929050565b6000806040838503121561291c57600080fd5b8235612927816127ea565b915060208301356128fe816127ea565b634e487b7160e01b600052601160045260246000fd5b60008261296a57634e487b7160e01b600052601260045260246000fd5b500490565b600181811c9082168061298357607f821691505b6020821081036129a357634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b8082028115828204841417610c2c57610c2c612937565b600060018201612a0757612a07612937565b5060010190565b634e487b7160e01b600052603260045260246000fd5b80820180821115610c2c57610c2c612937565b81810381811115610c2c57610c2c612937565b8082018281126000831280158216821582161715612a6a57612a6a612937565b505092915050565b634e487b7160e01b600052603160045260246000fd5b600060208284031215612a9a57600080fd5b815161191d816127ea565b600081518084526020808501945080840160005b83811015612ade5781516001600160a01b031687529582019590820190600101612ab9565b509495945050505050565b848152608060208201526000612b026080830186612aa5565b6001600160a01b03949094166040830152506060015292915050565b600060208284031215612b3057600080fd5b5051919050565b600060208284031215612b4957600080fd5b815161191d8161288c565b8181036000831280158383131683831282161715612b7457612b74612937565b509291505056fe45524332303a206275726e20616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa2646970667358221220dc8ba06d694f13c3b73a01233220b58dd03cc55a385877431e46f702d1024d0464736f6c63430008110033

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000766d2fcece1e3eef32aae8711ab886ee95fd5b2a0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000576e2bed8f7b46d34016198911cdf9886f78bea700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000d4d4147415650545241434b455200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b4d565054545241434b4552000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : mainContract (address): 0x766d2fcECe1E3eeF32aae8711ab886eE95fd5B2A
Arg [1] : router (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [2] : token (address): 0x576e2BeD8F7b46D34016198911Cdf9886f78bea7
Arg [3] : _name (string): MAGAVPTRACKER
Arg [4] : _ticker (string): MVPTTRACKER

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 000000000000000000000000766d2fcece1e3eef32aae8711ab886ee95fd5b2a
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [2] : 000000000000000000000000576e2bed8f7b46d34016198911cdf9886f78bea7
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000d
Arg [6] : 4d4147415650545241434b455200000000000000000000000000000000000000
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [8] : 4d565054545241434b4552000000000000000000000000000000000000000000


Deployed Bytecode Sourcemap

45100:13851:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21328:21;:19;:21::i;:::-;45100:13851;;;;;21365:471;;;:::i;47274:106::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49013:123;;;;;;;;;;-1:-1:-1;49013:123:0;;;;;:::i;:::-;;:::i;6643:210::-;;;;;;;;;;-1:-1:-1;6643:210:0;;;;;:::i;:::-;;:::i;:::-;;;1440:14:1;;1433:22;1415:41;;1403:2;1388:18;6643:210:0;1275:187:1;50076:120:0;;;;;;;;;;-1:-1:-1;50161:15:0;:27;50076:120;;;1613:25:1;;;1601:2;1586:18;50076:120:0;1467:177:1;45776:41:0;;;;;;;;;;-1:-1:-1;45776:41:0;;;;-1:-1:-1;;;;;45776:41:0;;;;;;-1:-1:-1;;;;;1840:32:1;;;1822:51;;1810:2;1795:18;45776:41:0;1649:230:1;5909:108:0;;;;;;;;;;-1:-1:-1;5997:12:0;;5909:108;;45504:44;;;;;;;;;;-1:-1:-1;45504:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;45863:49;;;;;;;;;;-1:-1:-1;45863:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;6861:454;;;;;;;;;;-1:-1:-1;6861:454:0;;;;;:::i;:::-;;:::i;55040:94::-;;;;;;;;;;-1:-1:-1;55114:12:0;;-1:-1:-1;;;;;55114:12:0;55040:94;;23381:372;;;;;;;;;;-1:-1:-1;23381:372:0;;;;;:::i;:::-;;:::i;45342:33::-;;;;;;;;;;;;;;;;47173:93;;;;;;;;;;-1:-1:-1;47173:93:0;;47256:2;2695:36:1;;2683:2;2668:18;47173:93:0;2553:184:1;48705:300:0;;;;;;;;;;-1:-1:-1;48705:300:0;;;;;:::i;:::-;;:::i;49768:183::-;;;;;;;;;;-1:-1:-1;49768:183:0;;;;;:::i;:::-;;:::i;7323:300::-;;;;;;;;;;-1:-1:-1;7323:300:0;;;;;:::i;:::-;;:::i;48503:194::-;;;;;;;;;;-1:-1:-1;48503:194:0;;;;;:::i;:::-;;:::i;45626:29::-;;;;;;;;;;-1:-1:-1;45626:29:0;;;;-1:-1:-1;;;45626:29:0;;;;;;45384:53;;;;;;;;;;-1:-1:-1;45384:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;51461:609;;;;;;;;;;-1:-1:-1;51461: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;51461:609:0;3296:557:1;49404:178:0;;;;;;;;;;-1:-1:-1;49404:178:0;;;;;:::i;:::-;;:::i;49590:170::-;;;;;;;;;;-1:-1:-1;49590:170:0;;;;;:::i;:::-;;:::i;45826:28::-;;;;;;;;;;-1:-1:-1;45826:28:0;;;;-1:-1:-1;;;;;45826:28:0;;;47699:228;;;;;;;;;;;;;:::i;45444:53::-;;;;;;;;;;-1:-1:-1;45444:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;47935:186;;;;;;;;;;-1:-1:-1;47935:186:0;;;;;:::i;:::-;;:::i;6025:177::-;;;;;;;;;;-1:-1:-1;6025:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;6176:18:0;6144:7;6176:18;;;;;;;;;;;;6025:177;13002:148;;;;;;;;;;;;;:::i;45555:27::-;;;;;;;;;;-1:-1:-1;45555:27:0;;;;-1:-1:-1;;;;;45555:27:0;;;21139:40;;;;;;;;;;;;;;;;49144:127;;;;;;;;;;-1:-1:-1;49144:127:0;;;;;:::i;:::-;;:::i;12788:79::-;;;;;;;;;;-1:-1:-1;12853:6:0;;-1:-1:-1;;;;;12853:6:0;12788:79;;22833:131;;;;;;;;;;-1:-1:-1;22833:131:0;;;;;:::i;:::-;;:::i;47388:110::-;;;;;;;;;;;;;:::i;48301:194::-;;;;;;;;;;-1:-1:-1;48301:194:0;;;;;:::i;:::-;;:::i;45590:29::-;;;;;;;;;;-1:-1:-1;45590:29:0;;;;-1:-1:-1;;;45590:29:0;;;;;;45662:35;;;;;;;;;;-1:-1:-1;45662:35:0;;;;-1:-1:-1;;;45662:35:0;;;;;;7631:400;;;;;;;;;;-1:-1:-1;7631:400:0;;;;;:::i;:::-;;:::i;22972:216::-;;;;;;;;;;-1:-1:-1;22972:216:0;;;;;:::i;:::-;;:::i;6210:::-;;;;;;;;;;-1:-1:-1;6210:216:0;;;;;:::i;:::-;;:::i;23196:177::-;;;;;;;;;;-1:-1:-1;23196:177:0;;;;;:::i;:::-;-1:-1:-1;;;;;23339:26:0;23307:7;23339:26;;;:18;:26;;;;;;;23196:177;49279:117;;;;;;;;;;-1:-1:-1;49279:117:0;;;;;:::i;:::-;;:::i;48129:164::-;;;;;;;;;;-1:-1:-1;48129:164:0;;;;;:::i;:::-;;:::i;54095:831::-;;;;;;;;;;-1:-1:-1;54095:831:0;;;;;:::i;:::-;;:::i;55291:133::-;;;;;;;;;;-1:-1:-1;55385:31:0;;55291:133;;54934:98;;;;;;;;;;-1:-1:-1;54934:98:0;;;;;:::i;:::-;;:::i;6434:201::-;;;;;;;;;;-1:-1:-1;6434:201:0;;;;;:::i;:::-;-1:-1:-1;;;;;6600:18:0;;;6568:7;6600:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;6434:201;52078:610;;;;;;;;;;-1:-1:-1;52078:610:0;;;;;:::i;:::-;;:::i;49959:109::-;;;;;;;;;;-1:-1:-1;50042:18:0;;49959:109;;55142:141;;;;;;;;;;-1:-1:-1;55240:35:0;;55142:141;;13158:281;;;;;;;;;;-1:-1:-1;13158:281:0;;;;;:::i;:::-;;:::i;50204:1249::-;;;;;;;;;;-1:-1:-1;50204:1249:0;;;;;:::i;:::-;;:::i;52696:1391::-;;;;;;;;;;-1:-1:-1;52696:1391:0;;;;;:::i;:::-;;:::i;:::-;;;;5466:25:1;;;5522:2;5507:18;;5500:34;;;;5550:18;;;5543:34;5454:2;5439:18;52696:1391:0;5264:319:1;21365:471:0;21455:1;21439:13;5997:12;;;5909:108;21439:13;:17;21431:26;;;;;;21474:9;:13;21470:359;;21532:105;21609:13;5997:12;;;5909:108;21609:13;21580:26;21581:9;-1:-1:-1;;;21580:15:0;:26::i;:::-;:42;;;;:::i;:::-;21532:25;;;:29;:105::i;:::-;21504:25;:133;21657:43;;21690:9;1613:25:1;;21678:10:0;;21657:43;;1601:2:1;1586:18;21657:43:0;;;;;;;21745:25;;:72;;21793:9;21745:29;:72::i;:::-;21717:25;:100;21470:359;21365:471::o;47274:106::-;47328:13;47361:11;47354:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47274:106;:::o;49013:123::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;49090:30:0::1;49123:5;49090:30:::0;;;:21:::1;:30;::::0;;;;:38;;-1:-1:-1;;49090:38:0::1;::::0;;49013:123::o;6643:210::-;6762:4;6784:39;174:10;6807:7;6816:6;6784:8;:39::i;:::-;-1:-1:-1;6841:4:0;6643:210;;;;;:::o;6861:454::-;7001:4;7018:36;7028:6;7036:9;7047:6;7018:9;:36::i;:::-;7065:220;7088:6;174:10;7136:138;7192:6;7136:138;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7136:19:0;;;;;;:11;:19;;;;;;;;174:10;7136:33;;;;;;;;;;:37;:138::i;:::-;7065:8;:220::i;:::-;-1:-1:-1;7303:4:0;6861:454;;;;;:::o;23381:372::-;-1:-1:-1;;;;;23662:36:0;;23495:7;23662:36;;;:28;:36;;;;;;;;;6176:18;;;;;;;23540:25;;-1:-1:-1;;;20938:6:0;23540:193;;:159;;:99;;:66;;:25;:47;:66::i;:::-;:97;:99::i;:::-;:121;;:159::i;:::-;:191;:193::i;:::-;:205;;;;:::i;48705:300::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48835:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;-1:-1:-1;;48835:37:0::1;48868:4;48835:37;::::0;;48885:23:::1;::::0;48857:7;;48885:11:::1;:23::i;:::-;48919:31;:15;48942:7:::0;48919:22:::1;:31::i;:::-;48968:29;::::0;-1:-1:-1;;;;;48968:29:0;::::1;::::0;::::1;::::0;;;::::1;48705:300:::0;:::o;49768:183::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;49865:5:::1;49846:24;;:15;;;;;;;;;;;:24;;::::0;49838:33:::1;;;::::0;::::1;;49882:15;:23:::0;;;::::1;;-1:-1:-1::0;;;49882:23:0::1;-1:-1:-1::0;;;;49882:23:0;;::::1;;::::0;;49921:22:::1;::::0;::::1;::::0;::::1;::::0;49900:5;1440:14:1;1433:22;1415:41;;1403:2;1388:18;;1275:187;49921:22:0::1;;;;;;;;49768:183:::0;:::o;7323:300::-;174:10;7438:4;7532:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;7532:34:0;;;;;;;;;;7438:4;;7460:133;;7510:7;;7532:50;;7571:10;7532:38;:50::i;48503:194::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;48604:5:::1;48583:26;;:17;;;;;;;;;;;:26;;::::0;48575:35:::1;;;::::0;::::1;;48621:17;:25:::0;;;::::1;;-1:-1:-1::0;;;48621:25:0::1;-1:-1:-1::0;;;;48621:25:0;;::::1;;::::0;;48662:27:::1;::::0;::::1;::::0;::::1;::::0;48641:5;1440:14:1;1433:22;1415:41;;1403:2;1388:18;;1275:187;51461:609:0;51565:7;51587:6;51608;51629:7;51651;51673;51721:22;:15;59837;;59756:104;51721:22;51712:5;:31;51708:249;;-1:-1:-1;51786:42:0;;-1:-1:-1;;;51847:2:0;-1:-1:-1;51847:2:0;;-1:-1:-1;51786:42:0;;-1:-1:-1;51786:42:0;;-1:-1:-1;51786:42:0;51760:185;;51708:249;51969:15;51987:36;:15;52017:5;51987:29;:36::i;:::-;51969:54;;52043:19;52054:7;52043:10;:19::i;:::-;52036:26;;;;;;;;;;;;;51461:609;;;;;;;;:::o;49404:178::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;49558:16:::1;:5:::0;49567:6:::1;49558:16;:::i;:::-;49520:35;:54:::0;-1:-1:-1;49404:178:0:o;49590:170::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;49736:16:::1;:5:::0;49745:6:::1;49736:16;:::i;:::-;49702:31;:50:::0;-1:-1:-1;49590:170:0:o;47699:228::-;47759:160;;-1:-1:-1;;;47759:160:0;;7063:2:1;47759:160:0;;;7045:21:1;7102:3;7082:18;;;7075:31;7142:34;7122:18;;;7115:62;7213:34;7193:18;;;7186:62;7285:34;7264:19;;;7257:63;-1:-1:-1;;;7336:19:1;;;7329:40;7386:19;;47759:160:0;6861:550:1;47935:186:0;12915:6;;48054:4;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;48083:30:0::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;::::0;47935:186::o;13002:148::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;13093:6:::1;::::0;13072:40:::1;::::0;13109:1:::1;::::0;-1:-1:-1;;;;;13093:6:0::1;::::0;13072:40:::1;::::0;13109:1;;13072:40:::1;13123:6;:19:::0;;-1:-1:-1;;;;;;13123:19:0::1;::::0;;13002:148::o;49144:127::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49225:30:0;;;::::1;;::::0;;;:21:::1;:30;::::0;;;;:38;;-1:-1:-1;;49225:38:0::1;::::0;::::1;;::::0;;;::::1;::::0;;49144:127::o;22833:131::-;22899:7;22926:30;22949:6;22926:22;:30::i;47388:110::-;47444:13;47477;47470:20;;;;;:::i;48301:194::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;48402:5:::1;48381:26;;:17;;;;;;;;;;;:26;;::::0;48373:35:::1;;;::::0;::::1;;48419:17;:25:::0;;;::::1;;-1:-1:-1::0;;;48419:25:0::1;-1:-1:-1::0;;;;48419:25:0;;::::1;;::::0;;48460:27:::1;::::0;::::1;::::0;::::1;::::0;48439:5;1440:14:1;1433:22;1415:41;;1403:2;1388:18;;1275:187;7631:400:0;7751:4;7773:228;174:10;7823:7;7845:145;7902:15;7845:145;;;;;;;;;;;;;;;;;174:10;7845:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;7845:34:0;;;;;;;;;;;;:38;:145::i;22972:216::-;-1:-1:-1;;;;;23153:26:0;;23086:7;23153:26;;;:18;:26;;;;;;23118:62;;:30;23172:6;23118:22;:30::i;:::-;:34;;:62::i;6210:216::-;6332:4;6354:42;174:10;6378:9;6389:6;6354:9;:42::i;49279:117::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49359:21:0;;;::::1;;::::0;;;:12:::1;:21;::::0;;;;:29;;-1:-1:-1;;49359:29:0::1;::::0;::::1;;::::0;;;::::1;::::0;;49279:117::o;48129:164::-;12915:6;;48235:4;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;48264:21:0::1;;::::0;;;:12:::1;:21;::::0;;;;;::::1;;::::0;48129:164::o;54095:831::-;12915:6;;54213:4;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;54239:15:::1;::::0;-1:-1:-1;;;54239:15:0;::::1;;;54235:60;;;-1:-1:-1::0;54278:5:0::1;54271:12;;54235:60;-1:-1:-1::0;;;;;54323:21:0;::::1;54307:13;54323:21:::0;;;:12:::1;:21;::::0;;;;;::::1;;54361:9:::0;:21;::::1;;;;54374:8;54361:21;:43;;;;-1:-1:-1::0;54387:17:0::1;::::0;-1:-1:-1;;;54387:17:0;::::1;;;54386:18;54361:43;54357:88;;;54428:5;54421:12;;;;;54357:88;54457:14;54474:8;:104;;54546:32;54570:7;54546:23;:32::i;:::-;54474:104;;;54498:32;54522:7;54498:23;:32::i;:::-;54457:121:::0;-1:-1:-1;54595:10:0;;54591:303:::1;;-1:-1:-1::0;;;;;54622:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;54648:15:::1;54622:41:::0;;54678:179;::::1;;;54752:9;54716:46;;54735:7;-1:-1:-1::0;;;;;54716:46:0::1;;54744:6;54716:46;;;;1613:25:1::0;;1601:2;1586:18;;1467:177;54716:46:0::1;;;;;;;;54678:179;;;54831:9;54808:33;;54814:7;-1:-1:-1::0;;;;;54808:33:0::1;;54823:6;54808:33;;;;1613:25:1::0;;1601:2;1586:18;;1467:177;54808:33:0::1;;;;;;;;54678:179;54878:4;54871:11;;;;;;54591:303;-1:-1:-1::0;54913:5:0::1;::::0;54095:831;-1:-1:-1;;;;54095:831:0:o;54934:98::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;55004:12:::1;:20:::0;;-1:-1:-1;;;;;;55004:20:0::1;-1:-1:-1::0;;;;;55004:20:0;;;::::1;::::0;;;::::1;::::0;;54934:98::o;52078:610::-;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;52192:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;52239:7;52188:69;52286:31;;52273:10;:44;52269:169;;;52334:31;:15;52357:7:::0;52334:22:::1;:31::i;:::-;52380:23;52392:7;52401:1;52380:11;:23::i;:::-;52078:610:::0;;:::o;52269:169::-:1;52450:32;52462:7;52471:10;52450:11;:32::i;:::-;52513:35;;52499:10;:49;52495:186;;52565:40;:15;52585:7:::0;52594:10;52565:19:::1;:40::i;52495:186::-;52638:31;:15;52661:7:::0;52638:22:::1;:31::i;13158:281::-:0;12915:6;;-1:-1:-1;;;;;12915:6:0;174:10;12915:22;12907:67;;;;-1:-1:-1;;;12907:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13261:22:0;::::1;13239:110;;;::::0;-1:-1:-1;;;13239:110:0;;7618:2:1;13239:110:0::1;::::0;::::1;7600:21:1::0;7657:2;7637:18;;;7630:30;7696:34;7676:18;;;7669:62;-1:-1:-1;;;7747:18:1;;;7740:36;7793:19;;13239:110:0::1;7416:402:1::0;13239:110:0::1;13386:6;::::0;13365:38:::1;::::0;-1:-1:-1;;;;;13365:38:0;;::::1;::::0;13386:6:::1;::::0;13365:38:::1;::::0;13386:6:::1;::::0;13365:38:::1;13414:6;:17:::0;;-1:-1:-1;;;;;;13414:17:0::1;-1:-1:-1::0;;;;;13414:17:0;;;::::1;::::0;;;::::1;::::0;;13158:281::o;50204:1249::-;50547:8;50304:15;;;;;50576:38;:15;50547:8;50576:29;:38::i;:::-;50568:46;;-1:-1:-1;;50627:29:0;;50682:1;50673:5;:10;50669:598;;50721:18;;50712:5;50704:35;50700:556;;;50826:18;;50787:77;;:5;;:9;:77::i;:::-;50760:104;;50700:556;;;50991:18;;50940:15;:27;50905:32;;-1:-1:-1;50940:169:0;;51108:1;50940:169;;;51065:18;;51033:15;:27;:51;;:31;:51::i;:::-;50905:204;-1:-1:-1;51157:83:0;:5;50905:204;51157:9;:83::i;:::-;51130:110;;50886:370;50700:556;51303:31;51326:7;51303:22;:31::i;:::-;51279:55;;51362:31;51385:7;51362:22;:31::i;:::-;-1:-1:-1;;;;;51422:23:0;;;;;;:14;:23;;;;;;51437:7;;50204:1249;;-1:-1:-1;50204:1249:0;;;;;-1:-1:-1;;50204:1249:0:o;52696:1391::-;52884:15;:27;52774:7;;;;;;52928:25;;;:44;;-1:-1:-1;52957:15:0;;-1:-1:-1;;;52957:15:0;;;;52928:44;52924:110;;;-1:-1:-1;;53003:18:0;;52997:1;;-1:-1:-1;52997:1:0;;-1:-1:-1;52989:33:0;;52924:110;53076:18;;53046:27;;53157:9;53139:27;;53179:18;53212:14;53243:724;53260:3;53250:7;:13;:50;;;;;53280:20;53267:10;:33;53250:50;53243:724;;;53317:21;;;;:::i;:::-;;;;53382:20;53359:19;:43;53355:107;;53445:1;53423:23;;53355:107;53478:15;53496;:20;;53517:19;53496:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;53496:41:0;53559:30;;;:21;:30;;;;;;;;53496:41;;-1:-1:-1;53559:30:0;;53554:166;;53614:38;53637:7;53647:4;53614:14;:38::i;:::-;53610:95;;;53677:8;;;;:::i;:::-;;;;53610:95;53736:12;;;;:::i;:::-;;;;53765:18;53786:9;53765:30;;53826:10;53816:7;:20;53812:107;;;53867:36;53879:23;:7;53891:10;53879:11;:23::i;:::-;53867:7;;:11;:36::i;:::-;53857:46;;53812:107;53945:10;-1:-1:-1;53243:724:0;;-1:-1:-1;53243:724:0;;53979:18;:40;;;54040:10;;-1:-1:-1;54052:6:0;-1:-1:-1;54000:19:0;;-1:-1:-1;;;;52696:1391:0;;;;;;:::o;11381:250::-;11439:7;11463:1;11468;11463:6;11459:47;;-1:-1:-1;11493:1:0;11486:8;;11459:47;11518:9;11530:5;11534:1;11530;:5;:::i;:::-;11518:17;-1:-1:-1;11563:1:0;11554:5;11558:1;11518:17;11554:5;:::i;:::-;:10;11546:56;;;;-1:-1:-1;;;11546:56:0;;8297:2:1;11546:56:0;;;8279:21:1;8336:2;8316:18;;;8309:30;8375:34;8355:18;;;8348:62;-1:-1:-1;;;8426:18:1;;;8419:31;8467:19;;11546:56:0;8095:397:1;11546:56:0;11622:1;11381:250;-1:-1:-1;;;11381:250:0:o;10814:181::-;10872:7;;10904:5;10908:1;10904;:5;:::i;:::-;10892:17;;10933:1;10928;:6;;10920:46;;;;-1:-1:-1;;;10920:46:0;;8829:2:1;10920:46:0;;;8811:21:1;8868:2;8848:18;;;8841:30;8907:29;8887:18;;;8880:57;8954:18;;10920:46:0;8627:351:1;9506:380:0;-1:-1:-1;;;;;9642:19:0;;9634:68;;;;-1:-1:-1;;;9634:68:0;;9185:2:1;9634:68:0;;;9167:21:1;9224:2;9204:18;;;9197:30;9263:34;9243:18;;;9236:62;-1:-1:-1;;;9314:18:1;;;9307:34;9358:19;;9634:68:0;8983:400:1;9634:68:0;-1:-1:-1;;;;;9721:21:0;;9713:68;;;;-1:-1:-1;;;9713:68:0;;9590:2:1;9713:68:0;;;9572:21:1;9629:2;9609:18;;;9602:30;9668:34;9648:18;;;9641:62;-1:-1:-1;;;9719:18:1;;;9712:32;9761:19;;9713:68:0;9388:398:1;9713:68:0;-1:-1:-1;;;;;9794:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;9846:32;;1613:25:1;;;9846:32:0;;1586:18:1;9846:32:0;;;;;;;9506:380;;;:::o;47506:185::-;47620:63;;-1:-1:-1;;;47620:63:0;;9993:2:1;47620:63:0;;;9975:21:1;10032:2;10012:18;;;10005:30;10071:34;10051:18;;;10044:62;-1:-1:-1;;;10122:18:1;;;10115:43;10175:19;;47620:63:0;9791:409:1;47620:63:0;47506:185;;;:::o;11147:226::-;11267:7;11303:12;11295:6;;;;11287:29;;;;-1:-1:-1;;;11287:29:0;;;;;;;;:::i;:::-;-1:-1:-1;11327:9:0;11339:5;11343:1;11339;:5;:::i;:::-;11327:17;11147:226;-1:-1:-1;;;;;11147:226:0:o;14843:148::-;14899:6;14936:1;14957:6;;;;14949:15;;;;;14360:176;14416:6;;14446:5;14450:1;14446;:5;:::i;:::-;14435:16;;14476:1;14471;:6;;:16;;;;;14486:1;14481;:6;;14471:16;14470:38;;;;14497:1;14493;:5;:14;;;;;14506:1;14502;:5;14493:14;14462:47;;;;;14681:127;14737:7;14770:1;14765;:6;;14757:15;;;;;;-1:-1:-1;14798:1:0;14681:127::o;24860:451::-;-1:-1:-1;;;;;6176:18:0;;24938:22;6176:18;;;;;;;;;;;24998:27;;;24994:310;;;25042:18;25063:30;:10;25078:14;25063;:30::i;:::-;25042:51;;25108:26;25114:7;25123:10;25108:5;:26::i;:::-;25027:119;47506:185;;;:::o;24994:310::-;25169:14;25156:10;:27;25152:152;;;25200:18;25221:30;:14;25240:10;25221:18;:30::i;:::-;25200:51;;25266:26;25272:7;25281:10;25266:5;:26::i;60239:481::-;-1:-1:-1;;;;;60310:17:0;;;;;;:12;;;:17;;;;;;;;60305:57;;60239:481;;:::o;60305:57::-;-1:-1:-1;;;;;60381:17:0;;;;;;:12;;;:17;;;;;;;;60374:24;;-1:-1:-1;;60374:24:0;;;;60416:10;;;:15;;;;;60409:22;;;60460:11;;;:16;;;;;;60507:15;;60460:16;;60381:17;60507:19;;;:::i;:::-;60487:39;;60537:15;60555:3;:8;;60564:9;60555:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;60555:19:0;;;60587:20;;;:11;;;:20;;;;;;;:28;;;60633:16;;;;;;;60626:23;;;;60662:15;;60555:19;;-1:-1:-1;60555:19:0;;60587:3;;60610:5;;60662:15;;;;;;:::i;:::-;;;;;;;;;;:25;;-1:-1:-1;;;;;;60662:25:0;-1:-1:-1;;;;;60662:25:0;;;;;;;;;;60698:14;;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;60698:14:0;;;;;-1:-1:-1;;;;;;60698:14:0;;;;;;-1:-1:-1;;;;;60239:481:0:o;59588:160::-;59693:7;59725:3;:8;;59734:5;59725:15;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;59725:15:0;;59588:160;-1:-1:-1;;;59588:160:0:o;11003:136::-;11061:7;11088:43;11092:1;11095;11088:43;;;;;;;;;;;;;;;;;:3;:43::i;57201:1747::-;57310:7;57335:29;57367:28;57390:4;57367:22;:28::i;:::-;57335:60;-1:-1:-1;57410:25:0;;57406:1516;;-1:-1:-1;;;;;57479:24:0;;;;;;:18;:24;;;;;;:83;;57526:21;57479:28;:83::i;:::-;-1:-1:-1;;;;;57452:24:0;;;;;;;:18;:24;;;;;:110;;;;57602:12;;;;;57658:908;;57723:115;;-1:-1:-1;;;;;57723:9:0;;;57811:4;;57762:21;;57723:115;;;;57762:21;57723:9;57811:4;57723:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57709:129;;;;;57658:908;;;57903:16;;;57917:1;57903:16;;;;;;;;57879:21;;57903:16;;;;;;;;-1:-1:-1;;57948:15:0;;:22;;;-1:-1:-1;;;57948:22:0;;;;57879:40;;-1:-1:-1;;;;;;57948:15:0;;;;:20;;-1:-1:-1;57948:22:0;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57938:4;57943:1;57938:7;;;;;;;;:::i;:::-;;;;;;:32;-1:-1:-1;;;;;57938:32:0;;;-1:-1:-1;;;;;57938:32:0;;;;;57999:12;57989:4;57994:1;57989:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;57989:22:0;;;:7;;;;;;;;;:22;58055:15;;:356;;-1:-1:-1;;;58055:356:0;;:15;;;:92;;58181:21;;58055:356;;:15;;58311:4;;58342;;58373:15;;58055:356;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58030:521;;58526:5;58516:15;;58030:521;;;58462:4;58452:14;;58030:521;57860:706;57658:908;58587:7;58582:286;;-1:-1:-1;;;;;58642:24:0;;;;;;:18;:24;;;;;;:91;;58693:21;58642:28;:91::i;:::-;-1:-1:-1;;;;;58615:24:0;;;;;;;:18;:24;;;;;:118;;;;-1:-1:-1;58615:24:0;;57201:1747;-1:-1:-1;;;57201:1747:0:o;58582:286::-;58824:4;-1:-1:-1;;;;;58806:46:0;;58830:21;58806:46;;;;1613:25:1;;1601:2;1586:18;;1467:177;58806:46:0;;;;;;;;-1:-1:-1;58889:21:0;;57201:1747;-1:-1:-1;;;57201:1747:0:o;57406:1516::-;-1:-1:-1;58939:1:0;;57201:1747;-1:-1:-1;;57201:1747:0:o;55440:1753::-;55525:7;55550:29;55582:31;55605:7;55582:22;:31::i;:::-;55550:63;-1:-1:-1;55628:25:0;;55624:1541;;-1:-1:-1;;;;;55729:27:0;;55670:12;55729:27;;;:18;:27;;;;;;:86;;55779:21;55729:31;:86::i;:::-;-1:-1:-1;;;;;55699:27:0;;;;;;:18;:27;;;;;;:116;;;;55856:16;;55870:1;55856:16;;;;;;;;;55699:27;;55856:16;;;;;;;;;;-1:-1:-1;;55897:15:0;;:22;;;-1:-1:-1;;;55897:22:0;;;;55832:40;;-1:-1:-1;;;;;;55897:15:0;;;;:20;;-1:-1:-1;55897:22:0;;;;;;;;;;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55887:4;55892:1;55887:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;55887:32:0;;;:7;;;;;;;;;:32;55952:14;;55934:7;;55952:14;;;55934:4;;55952:14;;55934:7;;;;;;:::i;:::-;-1:-1:-1;;;;;55934:33:0;;;:7;;;;;;;;;:33;56006:14;;:39;;-1:-1:-1;;;56006:39:0;;56039:4;56006:39;;;1822:51:1;55984:19:0;;56006:14;;;;;:24;;1795:18:1;;56006:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56113:15;;:333;;-1:-1:-1;;;56113:333:0;;55984:61;;-1:-1:-1;;;;;;56113:15:0;;:88;;56231:21;;56113:333;;:15;;56349:4;;56384;;56412:15;;56113:333;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56092:801;;56872:5;56862:15;;56092:801;;;56498:14;;:61;;-1:-1:-1;;;56498:61:0;;56553:4;56498:61;;;1822:51:1;56479:16:0;;56498:100;;56586:11;;-1:-1:-1;;;;;56498:14:0;;:46;;1795:18:1;;56498:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:100::-;56479:119;-1:-1:-1;56621:12:0;;56617:204;;56695:14;;:42;;-1:-1:-1;;;56695:42:0;;-1:-1:-1;;;;;13174:32:1;;;56695:42:0;;;13156:51:1;13223:18;;;13216:34;;;56668:4:0;;-1:-1:-1;56695:14:0;;;;:23;;13129:18:1;;56695:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;56617:204;;;56796:5;56786:15;;56617:204;56460:376;56092:801;56914:7;56909:200;;-1:-1:-1;;;;;56972:27:0;;;;;;:18;:27;;;;;;:94;;57026:21;56972:31;:94::i;:::-;-1:-1:-1;;;;;56942:27:0;;;;;;;:18;:27;;;;;:124;;;;-1:-1:-1;56942:27:0;;55440:1753;-1:-1:-1;;;;55440:1753:0:o;56909:200::-;-1:-1:-1;57132:21:0;;55440:1753;-1:-1:-1;;;;55440:1753:0:o;59868:363::-;-1:-1:-1;;;;;59982:17:0;;;;;;:12;;;:17;;;;;;;;59978:246;;;-1:-1:-1;;;;;60016:15:0;;;;;;:10;;;:15;;;;;:21;;;47506:185;;;:::o;59978:246::-;-1:-1:-1;;;;;60070:17:0;;;;;;:12;;;:17;;;;;;;;:24;;-1:-1:-1;;60070:24:0;60090:4;60070:24;;;;;;60109:10;;;:15;;;;;:21;;;60164:15;;60145:11;;;:16;;;;;:34;;;60194:18;;;;;;;;;;;;-1:-1:-1;;;;;;60194:18:0;;;;;;59868:363;;;:::o;59344:236::-;-1:-1:-1;;;;;59476:17:0;;59447:6;59476:17;;;:12;;;:17;;;;;;;;59471:60;;-1:-1:-1;;;59510:9:0;;59471:60;-1:-1:-1;;;;;;59555:16:0;;;;;:11;;;;;:16;;;;;;;59344:236::o;14176:176::-;14232:6;;14262:5;14266:1;14262;:5;:::i;:::-;14251:16;;14292:1;14287;:6;;:16;;;;;14302:1;14297;:6;;14287:16;14286:38;;;;14313:1;14309;:5;:14;;;;;14322:1;14318;:5;14278:47;;;;;24276:284;24352:27;24364:7;24373:5;24352:11;:27::i;:::-;24432:120;24498:53;24499:36;24529:5;24499:25;;:29;;:36;;;;:::i;24498:53::-;-1:-1:-1;;;;;24432:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;:::-;-1:-1:-1;;;;;24392:37:0;;;;;;;:28;:37;;;;;:160;;;;-1:-1:-1;24276:284:0:o;24568:::-;24644:27;24656:7;24665:5;24644:11;:27::i;:::-;24724:120;24790:53;24791:36;24821:5;24791:25;;:29;;:36;;;;:::i;24790:53::-;-1:-1:-1;;;;;24724:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;8657:378::-;-1:-1:-1;;;;;8741:21:0;;8733:65;;;;-1:-1:-1;;;8733:65:0;;13918:2:1;8733:65:0;;;13900:21:1;13957:2;13937:18;;;13930:30;13996:33;13976:18;;;13969:61;14047:18;;8733:65:0;13716:355:1;8733:65:0;8888:12;;:24;;8905:6;8888:16;:24::i;:::-;8873:12;:39;-1:-1:-1;;;;;8944:18:0;;:9;:18;;;;;;;;;;;:30;;8967:6;8944:22;:30::i;:::-;-1:-1:-1;;;;;8923:18:0;;:9;:18;;;;;;;;;;;:51;;;;8990:37;;1613:25:1;;;8923:18:0;;:9;;8990:37;;1586:18:1;8990:37:0;;;;;;;;8657:378;;:::o;9043:455::-;-1:-1:-1;;;;;9127:21:0;;9119:67;;;;-1:-1:-1;;;9119:67:0;;14278:2:1;9119:67:0;;;14260:21:1;14317:2;14297:18;;;14290:30;14356:34;14336:18;;;14329:62;-1:-1:-1;;;14407:18:1;;;14400:31;14448:19;;9119:67:0;14076:397:1;9119:67:0;9282:105;9319:6;9282:105;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9282:18:0;;:9;:18;;;;;;;;;;;;:105;:22;:105::i;:::-;-1:-1:-1;;;;;9261:18:0;;:9;:18;;;;;;;;;;:126;9413:12;;:24;;9430:6;9413:16;:24::i;:::-;9398:12;:39;9453:37;;1613:25:1;;;9479:1:0;;-1:-1:-1;;;;;9453:37:0;;;;;1601:2:1;1586:18;9453: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;4089:382::-;4154:6;4162;4215:2;4203:9;4194:7;4190:23;4186:32;4183:52;;;4231:1;4228;4221:12;4183:52;4270:9;4257:23;4289:31;4314:5;4289:31;:::i;:::-;4339:5;-1:-1:-1;4396:2:1;4381:18;;4368:32;4409:30;4368:32;4409:30;:::i;:::-;4458:7;4448:17;;;4089:382;;;;;:::o;4871:388::-;4939:6;4947;5000:2;4988:9;4979:7;4975:23;4971:32;4968:52;;;5016:1;5013;5006:12;4968:52;5055:9;5042:23;5074:31;5099:5;5074:31;:::i;:::-;5124:5;-1:-1:-1;5181:2:1;5166:18;;5153:32;5194:33;5153:32;5194:33;:::i;5588:127::-;5649:10;5644:3;5640:20;5637:1;5630:31;5680:4;5677:1;5670:15;5704:4;5701:1;5694:15;5720:217;5760:1;5786;5776:132;;5830:10;5825:3;5821:20;5818:1;5811:31;5865:4;5862:1;5855:15;5893:4;5890:1;5883:15;5776:132;-1:-1:-1;5922:9:1;;5720:217::o;5942:380::-;6021:1;6017:12;;;;6064;;;6085:61;;6139:4;6131:6;6127:17;6117:27;;6085:61;6192:2;6184:6;6181:14;6161:18;6158:38;6155:161;;6238:10;6233:3;6229:20;6226:1;6219:31;6273:4;6270:1;6263:15;6301:4;6298:1;6291:15;6155:161;;5942:380;;;:::o;6327:356::-;6529:2;6511:21;;;6548:18;;;6541:30;6607:34;6602:2;6587:18;;6580:62;6674:2;6659:18;;6327:356::o;6688:168::-;6761:9;;;6792;;6809:15;;;6803:22;;6789:37;6779:71;;6830:18;;:::i;7823:135::-;7862:3;7883:17;;;7880:43;;7903:18;;:::i;:::-;-1:-1:-1;7950:1:1;7939:13;;7823:135::o;7963:127::-;8024:10;8019:3;8015:20;8012:1;8005:31;8055:4;8052:1;8045:15;8079:4;8076:1;8069:15;8497:125;8562:9;;;8583:10;;;8580:36;;;8596:18;;:::i;10205:128::-;10272:9;;;10293:11;;;10290:37;;;10307:18;;:::i;10338:216::-;10402:9;;;10430:11;;;10377:3;10460:9;;10488:10;;10484:19;;10513:10;;10505:19;;10481:44;10478:70;;;10528:18;;:::i;:::-;10478:70;;10338:216;;;;:::o;10559:127::-;10620:10;10615:3;10611:20;10608:1;10601:31;10651:4;10648:1;10641:15;10675:4;10672:1;10665:15;11033:251;11103:6;11156:2;11144:9;11135:7;11131:23;11127:32;11124:52;;;11172:1;11169;11162:12;11124:52;11204:9;11198:16;11223:31;11248:5;11223:31;:::i;11289:461::-;11342:3;11380:5;11374:12;11407:6;11402:3;11395:19;11433:4;11462:2;11457:3;11453:12;11446:19;;11499:2;11492:5;11488:14;11520:1;11530:195;11544:6;11541:1;11538:13;11530:195;;;11609:13;;-1:-1:-1;;;;;11605:39:1;11593:52;;11665:12;;;;11700:15;;;;11641:1;11559:9;11530:195;;;-1:-1:-1;11741:3:1;;11289:461;-1:-1:-1;;;;;11289:461:1:o;11755:518::-;12034:6;12023:9;12016:25;12077:3;12072:2;12061:9;12057:18;12050:31;11997:4;12098:57;12150:3;12139:9;12135:19;12127:6;12098:57;:::i;:::-;-1:-1:-1;;;;;12191:32:1;;;;12186:2;12171:18;;12164:60;-1:-1:-1;12255:2:1;12240:18;12233:34;12090:65;11755:518;-1:-1:-1;;11755:518:1:o;12278:184::-;12348:6;12401:2;12389:9;12380:7;12376:23;12372:32;12369:52;;;12417:1;12414;12407:12;12369:52;-1:-1:-1;12440:16:1;;12278:184;-1:-1:-1;12278:184:1:o;13261:245::-;13328:6;13381:2;13369:9;13360:7;13356:23;13352:32;13349:52;;;13397:1;13394;13387:12;13349:52;13429:9;13423:16;13448:28;13470:5;13448:28;:::i;13511:200::-;13577:9;;;13550:4;13605:9;;13633:10;;13645:12;;;13629:29;13668:12;;;13660:21;;13626:56;13623:82;;;13685:18;;:::i;:::-;13623:82;13511:200;;;;:::o

Swarm Source

ipfs://dc8ba06d694f13c3b73a01233220b58dd03cc55a385877431e46f702d1024d04
Loading...
Loading
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.