Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

import "./DividendPayingToken.sol";
import "./IterableMapping.sol";
import "./Ownable.sol";
import "./IDex.sol";

library Address {
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

contract ShibaburnProtocol is ERC20, Ownable {
    using Address for address payable;

    IRouter public router;
    address public pair;

    bool private swapping;
    bool public swapEnabled = true;
    bool public tradingEnabled;
    uint256 public startTradingBlock;

    ShibaburnDividendTracker public dividendTracker;

    address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
    address public marketingWallet = 0x053df45FD629d5D0d1605D9F3B50df212c8a7DAf;
    address public devWallet = 0xD1827596065bE66909aBe2C3d8dECd1C3BdC7DF3;
    address public ShibaInuCA = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
    address public ShinaInuBurnAddress = 0xdEAD000000000000000042069420694206942069;

    uint8 private constant _decimals = 9;
    uint256 public constant _tTotal = 1e10 * 10**_decimals;

    uint256 public swapTokensAtAmount = (_tTotal*2/1e3);
    uint256 public maxWalletBalance = (_tTotal/1e2);
    uint256 public maxBuyAmount = (_tTotal/1e2);
    uint256 public maxSellAmount = (_tTotal/1e2);

    string private currentRewardToken;
    uint256 public shibaBurned;

    ///////////////
    //   Fees    //
    ///////////////

    struct Taxes {
        uint256 rewards;
        uint256 marketing;       
        uint256 dev;
        uint256 liquidity;
        uint256 burn;
        uint256 shibaburn;
    }

    Taxes public buyTaxes = Taxes(2, 3, 1, 1, 1, 2);
    Taxes public sellTaxes = Taxes(2, 3, 1, 1, 1, 2);

    // use by default 300,000 gas to process auto-claiming dividends
    uint256 public gasForProcessing = 300000;

    ////////////////
    //  Anti Bot  //
    ////////////////

    mapping(address => bool) public _isBot;
    mapping(address => uint256) public lastSell;
    uint256 private antiBotBlocks = 1;
    uint256 public coolDownTime = 60;
    uint256 private launchtax = 99;
    uint256 public coolDownBalance = (_tTotal/1e3);

    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) public automatedMarketMakerPairs;

    ///////////////
    //   Events  //
    ///////////////

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
    event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);
    event SendDividends(uint256 tokensSwapped, uint256 amount);
    event BuyAndBurnShibaInu(uint256 shibaburn);
    event ProcessedDividendTracker(
        uint256 iterations,
        uint256 claims,
        uint256 lastProcessedIndex,
        bool indexed automatic,
        uint256 gas,
        address indexed processor
    );

    constructor() ERC20("Shiba Burn Protocol", "SBP") {
        dividendTracker = new ShibaburnDividendTracker();

        IRouter _router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        // Create a pair for this new token
        address _pair = IFactory(_router.factory()).createPair(address(this), _router.WETH());

        router = _router;
        pair = _pair;

        _setAutomatedMarketMakerPair(_pair, true);

        // exclude from receiving dividends
        dividendTracker.excludeFromDividends(address(dividendTracker), true);
        dividendTracker.excludeFromDividends(address(this), true);
        dividendTracker.excludeFromDividends(owner(), true);
        dividendTracker.excludeFromDividends(deadWallet, true);
        dividendTracker.excludeFromDividends(address(_router), true);

        // exclude from paying fees or having max transaction amount
        excludeFromFees(owner(), true);
        excludeFromFees(address(this), true);
        excludeFromFees(marketingWallet, true);
        excludeFromFees(devWallet, true);
        excludeFromFees(deadWallet, true);

        /*
            _tokengeneration is an internal function in ERC20.sol that is only called here,
            and CANNOT be called ever again
        */
        _tokengeneration(owner(), _tTotal); 
    }

    receive() external payable {}

    function updateDividendTracker(address newAddress) public onlyOwner {
        ShibaburnDividendTracker newDividendTracker = ShibaburnDividendTracker(
            payable(newAddress)
        );

        newDividendTracker.excludeFromDividends(address(newDividendTracker), true);
        newDividendTracker.excludeFromDividends(address(this), true);
        newDividendTracker.excludeFromDividends(owner(), true);
        newDividendTracker.excludeFromDividends(address(router), true);
        dividendTracker = newDividendTracker;
    }

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

    /// @notice Manual claim the dividends after claimWait is passed
    ///    This can be useful during low volume days.
    function claim() external {
        dividendTracker.processAccount(payable(msg.sender), false);
    }

    /// @notice Withdraw tokens sent by mistake.
    /// @param tokenAddress The address of the token to withdraw
    function rescueBEP20Tokens(address tokenAddress) external onlyOwner {
        IERC20(tokenAddress).transfer(
            msg.sender,
            IERC20(tokenAddress).balanceOf(address(this))
        );
    }

    function forceSend() external {
        uint256 BNBbalance = address(this).balance;
        payable(owner()).sendValue(BNBbalance);
    }

    function updateRouter(address newRouter) external onlyOwner {
        router = IRouter(newRouter);
    }

    /////////////////////////////////
    // Exclude / Include functions //
    /////////////////////////////////

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        require(
            _isExcludedFromFees[account] != excluded,
            "Shibaburn: Account is already the value of 'excluded'"
        );
        _isExcludedFromFees[account] = excluded;

        emit ExcludeFromFees(account, excluded);
    }

    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded)
        public
        onlyOwner
    {
        for (uint256 i = 0; i < accounts.length; i++) {
            _isExcludedFromFees[accounts[i]] = excluded;
        }
        emit ExcludeMultipleAccountsFromFees(accounts, excluded);
    }

    /// @dev "true" to exlcude, "false" to include
    function excludeFromDividends(address account, bool value) external onlyOwner {
        dividendTracker.excludeFromDividends(account, value);
    }

    function excludeMultipleAccountsFromDividends(address[] calldata accounts, bool value)
        public
        onlyOwner
    {
        for (uint256 i = 0; i < accounts.length; i++) {
            dividendTracker.excludeFromDividends(accounts[i], value);
        }
    }

    ///////////////////////
    //  Setter Functions //
    ///////////////////////

    function setMarketingWallet(address newWallet) external onlyOwner {
        marketingWallet = newWallet;
    }

    function setDevWallet(address newWallet) external {
        require(msg.sender == devWallet, "Can only be called by Dev");
        devWallet = newWallet;
    }

    /// @notice Update the threshold to swap tokens for liquidity,
    ///   marketing and dividends.
    function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
        swapTokensAtAmount = amount * 10**9;
    }

    function setBuyTaxes(uint256 _rewards, uint256 _marketing, uint256 _dev, uint256 _liquidity, uint256 _burn, uint256 _shibaburn) external onlyOwner{
        require((_rewards + _marketing + _dev +_liquidity + _burn + _shibaburn ) <= 10, "Must keep fees at 10% or less");
        buyTaxes = Taxes(_rewards, _marketing, _dev, _liquidity, _burn, _shibaburn);
    }

    function setSellTaxes(uint256 _rewards, uint256 _marketing, uint256 _dev, uint256 _liquidity, uint256 _burn, uint256 _shibaburn) external onlyOwner{
        require((_rewards + _marketing + _dev + _liquidity  + _burn + _shibaburn) <= 20, "Must keep fees at 20% or less");
        require(_dev > 0, "Dev tax should be greater than 0");
        sellTaxes = Taxes(_rewards, _marketing, _dev, _liquidity, _burn, _shibaburn);
    }

    function setMaxBuyLimits(uint256 maxBuy) external onlyOwner{
        require(maxBuy >= 1e7, "Cannot set max buy amount lower than 0.1%");
        maxBuyAmount = maxBuy * 10**decimals();
    }

    function setMaxSellLimits(uint256 maxSell) external onlyOwner{
        require(maxSell >= 1e7, "Cannot set max sell amount lower than 0.1%");
        maxSellAmount = maxSell * 10**decimals();
        
    }

    function setMaxWallet(uint256 maxWallet) external onlyOwner {
        require(maxWallet >= 1e7, "Cannot set max wallet amount lower than 0.1%");
        maxWalletBalance = maxWallet * 10**9;        
    }

    function SetMaxTxLimit(uint256 maxBuy, uint256 maxSell, uint256 maxWallet) external onlyOwner {
        require(maxBuy >= 1e7, "Cannot set max buy amount lower than 0.1%");
        require(maxSell >= 1e7, "Cannot set max sell amount lower than 0.1%");
        require(maxWallet >= 1e7, "Cannot set max wallet amount lower than 0.1%");
        maxBuyAmount = maxBuy * 10**decimals();
        maxSellAmount = maxSell * 10**decimals();
        maxWalletBalance = maxWallet * 10**9;        
    }

    /// @notice Enable or disable internal swaps
    /// @dev Set "true" to enable internal swaps for liquidity, marketing and dividends
    function setSwapEnabled(bool _enabled) external onlyOwner {
        swapEnabled = _enabled;
    }

    function setCooldownTime(uint256 timeInSeconds, uint256 balance) external onlyOwner {
        coolDownTime = timeInSeconds;
        coolDownBalance = balance * 10**decimals();
        require(timeInSeconds <= 60, "cooldown timer cannot exceed 1 minutes");
    }

    function enableTradingEnabled() external onlyOwner {
        require(!tradingEnabled, "Trading is already enabled");
        tradingEnabled = true;
        startTradingBlock = block.number;
    }

    function setAntiBotBlocks(uint256 numberOfBlocks) external onlyOwner{
        require(!tradingEnabled, "Can't change when trading has started");
        antiBotBlocks = numberOfBlocks;
    }

    /// @param bot The bot address
    /// @param value "true" to blacklist, "false" to unblacklist
    function setBot(address bot, bool value) external onlyOwner {
        require(_isBot[bot] != value);
        _isBot[bot] = value;
    }

    function setBulkBot(address[] memory bots, bool value) external onlyOwner {
        for (uint256 i; i < bots.length; i++) {
            _isBot[bots[i]] = value;
        }
    }

    /// @dev Set new pairs created due to listing in new DEX
    function setAutomatedMarketMakerPair(address newPair, bool value) external onlyOwner {
        _setAutomatedMarketMakerPair(newPair, value);
    }

    function setMinBalanceForDividends(uint256 amount) external onlyOwner {
        dividendTracker.setMinBalanceForDividends(amount);
    }

    function _setAutomatedMarketMakerPair(address newPair, bool value) private {
        require(
            automatedMarketMakerPairs[newPair] != value,
            "Shibaburn: Automated market maker pair is already set to that value"
        );
        automatedMarketMakerPairs[newPair] = value;

        if (value) {
            dividendTracker.excludeFromDividends(newPair, true);
        }

        emit SetAutomatedMarketMakerPair(newPair, value);
    }

    /// @notice Update the gasForProcessing needed to auto-distribute rewards
    /// @param newValue The new amount of gas needed
    /// @dev The amount should not be greater than 500k to avoid expensive transactions
    function setGasForProcessing(uint256 newValue) external onlyOwner {
        require(
            newValue >= 200000 && newValue <= 500000,
            "Shibaburn: gasForProcessing must be between 200,000 and 500,000"
        );
        require(
            newValue != gasForProcessing,
            "Shibaburn: Cannot update gasForProcessing to same value"
        );
        emit GasForProcessingUpdated(newValue, gasForProcessing);
        gasForProcessing = newValue;
    }

    /// @dev Update the dividendTracker claimWait
    function setClaimWait(uint256 claimWait) external onlyOwner {
        dividendTracker.updateClaimWait(claimWait);
    }

    //////////////////////
    // Getter Functions //
    //////////////////////

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

    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 getCurrentRewardToken() external view returns (string memory) {
        return dividendTracker.getCurrentRewardToken();
    }

    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,
            uint256,
            uint256
        )
    {
        return dividendTracker.getAccount(account);
    }

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

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

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

    ////////////////////////
    // Transfer Functions //
    ////////////////////////

    function airdropTokens(address[] memory accounts, uint256[] memory amounts) external onlyOwner{
        require(accounts.length == amounts.length, "Arrays must have same size");
        for(uint256 i; i< accounts.length; i++){
            super._transfer(msg.sender, accounts[i], amounts[i]);
        }
    }

    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");
        require(!_isBot[from] && !_isBot[to], "C:\\<windows95\\system32> kill bot");
        if (!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
            require(tradingEnabled, "Trading no active");
            if (!automatedMarketMakerPairs[to]) {
                require(
                    balanceOf(to) + (amount) <= maxWalletBalance,
                    "Balance is exceeding maxWalletBalance"
                );
            }
            if (!automatedMarketMakerPairs[from] && balanceOf(from) >= coolDownBalance) {
                uint256 timePassed = block.timestamp - lastSell[from];
                require(timePassed > coolDownTime, "Cooldown is active. Please wait");
                lastSell[from] = block.timestamp;
            }
            if (automatedMarketMakerPairs[from]) {
                require(amount <= maxBuyAmount, "You are exceeding maxBuyAmount");
            }
            if (!automatedMarketMakerPairs[from]) {
                require(amount <= maxSellAmount, "You are exceeding maxSellAmount");
            }
        }

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;
        uint256 swapTax = sellTaxes.rewards +
            sellTaxes.marketing +
            sellTaxes.dev +
            sellTaxes.liquidity +
            sellTaxes.shibaburn;

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

            if (swapTax > 0) {
                swapAndLiquify(swapTokensAtAmount, swapTax);
            }

            swapping = false;
        }

        bool takeFee = !swapping;

        // if any account belongs to _isExcludedFromFee account then remove the fee
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }

        if (takeFee) {
            bool beforeTradingFee = block.number <= startTradingBlock + antiBotBlocks;
            uint256 swapAmt;
            uint256 burnAmt;
            if (automatedMarketMakerPairs[to] && !beforeTradingFee) {
                swapAmt = (amount * swapTax) / 100;
                burnAmt = amount * sellTaxes.burn / 100;
            } else if (automatedMarketMakerPairs[from] && !beforeTradingFee) {
                swapAmt = (amount * (buyTaxes.rewards + buyTaxes.marketing + buyTaxes.dev + buyTaxes.liquidity + buyTaxes.shibaburn )) /100;
                burnAmt = amount * buyTaxes.burn / 100;
            } else if (beforeTradingFee) {
                swapAmt = (amount * launchtax) / 100; 
            }

            amount = amount - (swapAmt + burnAmt);
            super._transfer(from, address(this), swapAmt);
            if (burnAmt > 0){
            super._transfer(from, deadWallet, burnAmt);
            }
        }
        super._transfer(from, to, amount);

        try dividendTracker.setBalance(from, balanceOf(from)) {} catch {}
        try dividendTracker.setBalance(to, balanceOf(to)) {} catch {}

        if (!swapping) {
            uint256 gas = gasForProcessing;

            try dividendTracker.process(gas) returns (
                uint256 iterations,
                uint256 claims,
                uint256 lastProcessedIndex
            ) {
                emit ProcessedDividendTracker(
                    iterations,
                    claims,
                    lastProcessedIndex,
                    true,
                    gas,
                    tx.origin
                );
            } catch {}
        }
    }

    function swapAndLiquify(uint256 tokens, uint256 swapTax) private {
        // Split the contract balance into halves
        uint256 denominator = swapTax * 2;
        uint256 tokensToAddLiquidityWith = (tokens * sellTaxes.liquidity) / denominator;
        uint256 toSwap = tokens - tokensToAddLiquidityWith;

        uint256 initialBalance = address(this).balance;

        swapTokensForBNB(toSwap);

        uint256 deltaBalance = address(this).balance - initialBalance;
        uint256 unitBalance = deltaBalance / (denominator - sellTaxes.liquidity);
        uint256 bnbToAddLiquidityWith = unitBalance * sellTaxes.liquidity;

        if (bnbToAddLiquidityWith > 0) {
            // Add liquidity to pancake
            addLiquidity(tokensToAddLiquidityWith, bnbToAddLiquidityWith);
        }

        // Send BNB to marketingWallet
        uint256 marketingWalletAmt = unitBalance * 2 * sellTaxes.marketing;
        if (marketingWalletAmt > 0) {
            payable(marketingWallet).sendValue(marketingWalletAmt);
        }

        // Send BNB to devWallet
        uint256 devWalletAmt = unitBalance * 2 * sellTaxes.dev;
        if (devWalletAmt > 0) {
            payable(devWallet).sendValue(devWalletAmt);
        }

        // Send BNB to rewardsContract
        uint256 dividends = unitBalance * 2 * sellTaxes.rewards;
        if (dividends > 0) {
            (bool success, ) = address(dividendTracker).call{ value: dividends }("");
            if (success) emit SendDividends(tokens, dividends);
        }

        uint256 shibaburnAmt = unitBalance * 2 * sellTaxes.shibaburn;
        if (shibaburnAmt > 0) {
            swapAndBurnShiba(shibaburnAmt);
        }
    }

    function swapAndBurnShiba(uint256 ethAmount) private {
        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = ShibaInuCA;

        uint256 balBefore = IERC20(ShibaInuCA).balanceOf(ShinaInuBurnAddress);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{
            value: ethAmount
        }(
            0, // accept any amount of Tokens
            path,
            ShinaInuBurnAddress, // Burn address
            block.timestamp
        );

        uint256 burned = IERC20(ShibaInuCA).balanceOf(ShinaInuBurnAddress) - balBefore;
        shibaBurned += burned;
        emit BuyAndBurnShibaInu(burned);
    }

    function swapTokensForBNB(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

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

        // make the swap
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        // approve token transfer to cover all possible scenarios
        _approve(address(this), address(router), tokenAmount);

        // add the liquidity
        router.addLiquidityETH{ value: ethAmount }(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            owner(),
            block.timestamp
        );
    }
}

contract ShibaburnDividendTracker is Ownable, DividendPayingToken {
    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 => uint256) public lastClaimTimes;

    uint256 public claimWait;
    uint256 public minimumTokenBalanceForDividends;

    event ExcludeFromDividends(address indexed account, bool value);
    event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);

    event Claim(address indexed account, uint256 amount, bool indexed automatic);

    constructor()
        DividendPayingToken("Shibaburn_Dividen_Tracker", "Shibaburn_Dividend_Tracker")
    {
        claimWait = 3600;
        minimumTokenBalanceForDividends = 1e7 * (10**decimals()); 
    }

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

    function setMinBalanceForDividends(uint256 amount) external onlyOwner {
        minimumTokenBalanceForDividends = amount * 10**decimals();
    }

    function excludeFromDividends(address account, bool value) external onlyOwner {
        require(excludedFromDividends[account] != value);
        excludedFromDividends[account] = value;
        if (value == true) {
            _setBalance(account, 0);
            tokenHoldersMap.remove(account);
        } else {
            _setBalance(account, balanceOf(account));
            tokenHoldersMap.set(account, balanceOf(account));
        }
        emit ExcludeFromDividends(account, value);
    }

    function updateClaimWait(uint256 newClaimWait) external onlyOwner {
        require(
            newClaimWait >= 3600 && newClaimWait <= 86400,
            "Shibaburn_Dividend_Tracker: claimWait must be updated to between 1 and 24 hours"
        );
        require(
            newClaimWait != claimWait,
            "Shibaburn_Dividend_Tracker: Cannot update claimWait to same value"
        );
        emit ClaimWaitUpdated(newClaimWait, claimWait);
        claimWait = newClaimWait;
    }

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

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

    function getCurrentRewardToken() external view returns (string memory) {
        return IERC20Metadata(rewardToken).name();
    }

    function getAccount(address _account)
        public
        view
        returns (
            address account,
            int256 index,
            int256 iterationsUntilProcessed,
            uint256 withdrawableDividends,
            uint256 totalDividends,
            uint256 lastClaimTime,
            uint256 nextClaimTime,
            uint256 secondsUntilAutoClaimAvailable
        )
    {
        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 + (int256(processesUntilEndOfArray));
            }
        }

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

        lastClaimTime = lastClaimTimes[account];

        nextClaimTime = lastClaimTime > 0 ? lastClaimTime + (claimWait) : 0;

        secondsUntilAutoClaimAvailable = nextClaimTime > block.timestamp
            ? nextClaimTime.sub(block.timestamp)
            : 0;
    }

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

        address account = tokenHoldersMap.getKeyAtIndex(index);

        return getAccount(account);
    }

    function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
        if (lastClaimTime > block.timestamp) {
            return false;
        }

        return block.timestamp.sub(lastClaimTime) >= claimWait;
    }

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

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

        processAccount(payable(account), true);
    }

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

        if (numberOfTokenHolders == 0) {
            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 >= tokenHoldersMap.keys.length) {
                _lastProcessedIndex = 0;
            }

            address account = tokenHoldersMap.keys[_lastProcessedIndex];

            if (canAutoClaim(lastClaimTimes[account])) {
                if (processAccount(payable(account), true)) {
                    claims++;
                }
            }

            iterations++;

            uint256 newGasLeft = gasleft();

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

            gasLeft = newGasLeft;
        }

        lastProcessedIndex = _lastProcessedIndex;

        return (iterations, claims, lastProcessedIndex);
    }

    function processAccount(address payable account, bool automatic)
        public
        onlyOwner
        returns (bool)
    {
        uint256 amount = _withdrawDividendOfUser(account);

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

        return false;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

import "./ERC20.sol";
import "./IERC20.sol";
import "./SafeMath.sol";
import "./DividendPayingTokenInterface.sol";
import "./Ownable.sol";
import "./IDex.sol";

contract DividendPayingToken is ERC20, DividendPayingTokenInterface, Ownable {
  using SafeMath for uint256;
  using SafeMathUint for uint256;
  using SafeMathInt for int256;

  // With `magnitude`, we can properly distribute dividends even if the amount of received ether is small.
  // For more discussion about choosing the value of `magnitude`,
  //  see https://github.com/ethereum/EIPs/issues/1726#issuecomment-472352728
  uint256 constant internal magnitude = 2**128;

  IRouter public router;
  address public rewardToken;

  uint256 internal magnifiedDividendPerShare;

  // About dividendCorrection:
  // If the token balance of a `_user` is never changed, the dividend of `_user` can be computed with:
  //   `dividendOf(_user) = dividendPerShare * balanceOf(_user)`.
  // When `balanceOf(_user)` is changed (via new tokens/burning/transferring tokens),
  //   `dividendOf(_user)` should not be changed,
  //   but the computed value of `dividendPerShare * balanceOf(_user)` is changed.
  // To keep the `dividendOf(_user)` unchanged, we add a correction term:
  //   `dividendOf(_user) = dividendPerShare * balanceOf(_user) + dividendCorrectionOf(_user)`,
  //   where `dividendCorrectionOf(_user)` is updated whenever `balanceOf(_user)` is changed:
  //   `dividendCorrectionOf(_user) = dividendPerShare * (old balanceOf(_user)) - (new balanceOf(_user))`.
  // So now `dividendOf(_user)` returns the same value before and after `balanceOf(_user)` is changed.
  mapping(address => int256) internal magnifiedDividendCorrections;
  mapping(address => uint256) internal withdrawnDividends;

  uint256 public totalDividendsDistributed;

  constructor(string memory _name, string memory _symbol)  ERC20(_name, _symbol) {
      IRouter _router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
      router = _router;
      rewardToken = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
  }

    /// @dev Distributes dividends whenever ether is paid to this contract.
    receive() external payable{
        distributeDividends();
    }

     function distributeDividends() public override payable {
      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);
      }
    }

    /// @notice Withdraws the ether distributed to the sender.
    /// @dev It emits a `DividendWithdrawn` event if the amount of withdrawn ether is greater than 0.
    function _withdrawDividendOfUser(address payable user) internal returns (uint256) {
        uint256 _withdrawableDividend = withdrawableDividendOf(user);
        if (_withdrawableDividend > 0) {
            withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend);
            emit DividendWithdrawn(user, _withdrawableDividend);
            if(rewardToken != router.WETH()){
                (bool success) = swapBnbForCustomToken(user, _withdrawableDividend);
                if(!success) {
                    (bool secondSuccess,) = user.call{value: _withdrawableDividend, gas: 3000}("");
                    if(!secondSuccess) {
                        withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend);
                        return 0;
                    }       
                }
            }
            else{
                (bool success,) = user.call{value: _withdrawableDividend, gas: 3000}("");
                if(!success) {
                    withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend);
                    return 0;
                }
            }
            return _withdrawableDividend;
        }
        return 0;
    }
    
    function setRewardToken(address newToken) external onlyOwner{
        rewardToken = newToken;
    }
  
    function swapBnbForCustomToken(address user, uint256 amt) internal returns (bool) {
          address[] memory path = new address[](2);
          path[0] = router.WETH();
          path[1] = rewardToken;

          try router.swapExactETHForTokens{value: amt}(0, path, user, block.timestamp + 2){
            return true;
        } catch {
            return false;
        }
    }

    /// @notice View the amount of dividend in wei that an address can withdraw.
    /// @param _owner The address of a token holder.
    /// @return The amount of dividend in wei that `_owner` can withdraw.
    function dividendOf(address _owner) public view override returns(uint256) {
      return withdrawableDividendOf(_owner);
    }

    /// @notice View the amount of dividend in wei that an address can withdraw.
    /// @param _owner The address of a token holder.
    /// @return The amount of dividend in wei that `_owner` can withdraw.
    function withdrawableDividendOf(address _owner) public view override returns(uint256) {
      return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]);
    }

    /// @notice View the amount of dividend in wei that an address has withdrawn.
    /// @param _owner The address of a token holder.
    /// @return The amount of dividend in wei that `_owner` has withdrawn.
    function withdrawnDividendOf(address _owner) public view override returns(uint256) {
      return withdrawnDividends[_owner];
    }


    /// @notice View the amount of dividend in wei that an address has earned in total.
    /// @dev accumulativeDividendOf(_owner) = withdrawableDividendOf(_owner) + withdrawnDividendOf(_owner)
    /// = (magnifiedDividendPerShare * balanceOf(_owner) + magnifiedDividendCorrections[_owner]) / magnitude
    /// @param _owner The address of a token holder.
    /// @return The amount of dividend in wei that `_owner` has earned in total.
    function accumulativeDividendOf(address _owner) public view override returns(uint256) {
      return magnifiedDividendPerShare.mul(balanceOf(_owner)).toInt256Safe()
        .add(magnifiedDividendCorrections[_owner]).toUint256Safe() / magnitude;
    }

    /// @dev Internal function that transfer tokens from one address to another.
    /// Update magnifiedDividendCorrections to keep dividends unchanged.
    /// @param from The address to transfer from.
    /// @param to The address to transfer to.
    /// @param value The amount to be transferred.
    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);
    }

    /// Update magnifiedDividendCorrections to keep dividends unchanged.
    /// @param account The account that will receive the created tokens.
    /// @param value The amount that will be created.
    function _tokengeneration(address account, uint256 value) internal override {
      super._tokengeneration(account, value);

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

    /// @dev Internal function that burns an amount of the token of a given account.
    /// Update magnifiedDividendCorrections to keep dividends unchanged.
    /// @param account The account whose tokens will be burnt.
    /// @param value The amount that will be burnt.
    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 rewardtokensAmount = newBalance.sub(currentBalance);
        _tokengeneration(account, rewardtokensAmount);
      } else if(newBalance < currentBalance) {
        uint256 burnAmount = currentBalance.sub(newBalance);
        _burn(account, burnAmount);
      }
    }
  }

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;


/// @title Dividend-Paying Token Interface
/// @author Roger Wu (https://github.com/roger-wu)
/// @dev An interface for a dividend-paying token contract.
interface DividendPayingTokenInterface {
  /// @notice View the amount of dividend in wei that an address can withdraw.
  /// @param _owner The address of a token holder.
  /// @return The amount of dividend in wei that `_owner` can withdraw.
  function dividendOf(address _owner) external view returns(uint256);
  
  function distributeDividends() external payable;
  
  /// @notice View the amount of dividend in wei that an address can withdraw.
  /// @param _owner The address of a token holder.
  /// @return The amount of dividend in wei that `_owner` can withdraw.
  function withdrawableDividendOf(address _owner) external view returns(uint256);

  /// @notice View the amount of dividend in wei that an address has withdrawn.
  /// @param _owner The address of a token holder.
  /// @return The amount of dividend in wei that `_owner` has withdrawn.
  function withdrawnDividendOf(address _owner) external view returns(uint256);

  /// @notice View the amount of dividend in wei that an address has earned in total.
  /// @dev accumulativeDividendOf(_owner) = withdrawableDividendOf(_owner) + withdrawnDividendOf(_owner)
  /// @param _owner The address of a token holder.
  /// @return The amount of dividend in wei that `_owner` has earned in total.
  function accumulativeDividendOf(address _owner) external view returns(uint256);


  /// @dev This event MUST emit when ether is distributed to token holders.
  /// @param from The address which sends ether to this contract.
  /// @param weiAmount The amount of distributed ether in wei.
  event DividendsDistributed(
    address indexed from,
    uint256 weiAmount
  );

  /// @dev This event MUST emit when an address withdraws their dividend.
  /// @param to The address which withdraws ether from this contract.
  /// @param weiAmount The amount of withdrawn ether in wei.
  event DividendWithdrawn(
    address indexed to,
    uint256 weiAmount
  );
  
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

import "./IERC20.sol";
import "./Context.sol";
import "./SafeMath.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_tokengeneration}.
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    using SafeMath for uint256;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    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;
    }

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

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

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    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);
    }

        /*
            _tokengeneration is an internal function in ERC20.sol that is only called here to generate the total supply first time,
            and CANNOT be called ever again
        */
    function _tokengeneration(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: new tokens 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);
    }

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

interface IPair {
    function sync() external;
}

interface IFactory{
        function createPair(address tokenA, address tokenB) external returns (address pair);
        function getPair(address tokenA, address tokenB) external view returns (address pair);
}

interface IRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

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

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

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

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

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

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

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



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

    function set(Map storage map, address key, uint val) public {
        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) public {
        if (!map.inserted[key]) {
            return;
        }

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

        uint index = map.indexOf[key];
        uint 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();
    }
}

pragma solidity ^0.8.6;

// SPDX-License-Identifier: MIT License

import "./Context.sol";

contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.6;

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be 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;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

/**
 * @title SafeMathInt
 * @dev Math operations for int256 with overflow safety checks.
 */
library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    /**
     * @dev Multiplies two int256 variables and fails on overflow.
     */
    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;
    }

    /**
     * @dev Division of two int256 variables and fails on overflow.
     */
    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;
    }

    /**
     * @dev Subtracts two int256 variables and fails on overflow.
     */
    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;
    }

    /**
     * @dev Adds two int256 variables and fails on overflow.
     */
    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;
    }

    /**
     * @dev Converts to absolute value, and fails on overflow.
     */
    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);
    }
}

/**
 * @title SafeMathUint
 * @dev Math operations with safety checks that revert on error
 */
library SafeMathUint {
  function toInt256Safe(uint256 a) internal pure returns (int256) {
    int256 b = int256(a);
    require(b >= 0);
    return b;
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":"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":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"value","type":"bool"}],"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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"accumulativeDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimWait","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":"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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","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"},{"internalType":"uint256","name":"nextClaimTime","type":"uint256"},{"internalType":"uint256","name":"secondsUntilAutoClaimAvailable","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"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentRewardToken","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumberOfTokenHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"","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":"minimumTokenBalanceForDividends","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":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"setBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setMinBalanceForDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newToken","type":"address"}],"name":"setRewardToken","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":[{"internalType":"uint256","name":"newClaimWait","type":"uint256"}],"name":"updateClaimWait","outputs":[],"stateMutability":"nonpayable","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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

IterableMapping : 0xd55e710df53b0aa4f8edf4d856e563d1f46cafd2Unverified

22801:7042:9:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2283:21:1;:19;:21::i;:::-;22801:7042:9;;;;;2321:411:1;;;:::i;24061:496:9:-;;;;;;;;;;-1:-1:-1;24061:496:9;;;;;:::i;:::-;;:::i;2089:100:3:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4255:169;;;;;;;;;;-1:-1:-1;4255:169:3;;;;;:::i;:::-;;:::i;:::-;;;6023:14:10;;6016:22;5998:41;;5986:2;5971:18;4255:169:3;5953:92:10;25173:118:9;;;;;;;;;;-1:-1:-1;25257:15:9;:27;25173:118;;;12272:25:10;;;12260:2;12245:18;25173:118:9;12227:76:10;3208:108:3;;;;;;;;;;-1:-1:-1;3296:12:3;;3208:108;;23140:49:9;;;;;;;;;;-1:-1:-1;23140:49:9;;;;;:::i;:::-;;;;;;;;;;;;;;4906:355:3;;;;;;;;;;-1:-1:-1;4906:355:3;;;;;:::i;:::-;;:::i;6221:253:1:-;;;;;;;;;;-1:-1:-1;6221:253:1;;;;;:::i;:::-;;:::i;23040:33:9:-;;;;;;;;;;;;;;;;3051:92:3;;;;;;;;;;-1:-1:-1;3051:92:3;;3134:1;13928:36:10;;13916:2;13901:18;3051:92:3;13883:87:10;5670:218:3;;;;;;;;;;-1:-1:-1;5670:218:3;;;;;:::i;:::-;;:::i;23080:53:9:-;;;;;;;;;;-1:-1:-1;23080:53:9;;;;;:::i;:::-;;;;;;;;;;;;;;;;26876:521;;;;;;;;;;-1:-1:-1;26876:521:9;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5509:32:10;;;;5491:51;;5573:2;5558:18;;5551:34;;;;5601:18;;;5594:34;;;;5659:2;5644:18;;5637:34;;;;5702:3;5687:19;;5680:35;-1:-1:-1;5731:19:10;;5724:35;5790:3;5775:19;;5768:35;5834:3;5819:19;;5812:35;5478:3;5463:19;26876:521:9;5445:408:10;23196:24:9;;;;;;;;;;;;;;;;3379:127:3;;;;;;;;;;-1:-1:-1;3379:127:3;;;;;:::i;:::-;-1:-1:-1;;;;;3480:18:3;3453:7;3480:18;;;;;;;;;;;;3379:127;1231:148:7;;;;;;;;;;;;;:::i;25297:129:9:-;;;;;;;;;;;;;:::i;1861:40:1:-;;;;;;;;;;;;;;;;4174:101;;;;;;;;;;-1:-1:-1;4174:101:1;;;;;:::i;:::-;;:::i;589:79:7:-;;;;;;;;;;-1:-1:-1;654:6:7;;-1:-1:-1;;;;;654:6:7;589:79;;;-1:-1:-1;;;;;5108:32:10;;;;5090:51;;5078:2;5063:18;589:79:7;5045:102:10;4895:128:1;;;;;;;;;;-1:-1:-1;4895:128:1;;;;;:::i;:::-;;:::i;2308:104:3:-;;;;;;;;;;;;;:::i;23911:144:9:-;;;;;;;;;;-1:-1:-1;23911:144:9;;;;;:::i;:::-;;:::i;6391:269:3:-;;;;;;;;;;-1:-1:-1;6391:269:3;;;;;:::i;:::-;;:::i;5242:172:1:-;;;;;;;;;;-1:-1:-1;5242:172:1;;;;;:::i;:::-;;:::i;3719:175:3:-;;;;;;;;;;-1:-1:-1;3719:175:3;;;;;:::i;:::-;;:::i;5635:133:1:-;;;;;;;;;;-1:-1:-1;5635:133:1;;;;;:::i;:::-;-1:-1:-1;;;;;5734:26:1;5709:7;5734:26;;;:18;:26;;;;;;;5635:133;29458:383:9;;;;;;;;;;-1:-1:-1;29458:383:9;;;;;:::i;:::-;;:::i;23226:46::-;;;;;;;;;;;;;;;;3957:151:3;;;;;;;;;;-1:-1:-1;3957:151:3;;;;;:::i;:::-;-1:-1:-1;;;;;4073:18:3;;;4046:7;4073:18;;;-1:-1:-1;4073:18:3;;;;;;;;:27;;;;;;;;;;;;;3957:151;27637:477:9;;;;;;;;;;-1:-1:-1;27637:477:9;;;;;:::i;:::-;;:::i;25060:107::-;;;;;;;;;;-1:-1:-1;25142:18:9;;25060:107;;24563:491;;;;;;;;;;-1:-1:-1;24563:491:9;;;;;:::i;:::-;;:::i;1534:244:7:-;;;;;;;;;;-1:-1:-1;1534:244:7;;;;;:::i;:::-;;:::i;744:26:1:-;;;;;;;;;;-1:-1:-1;744:26:1;;;;-1:-1:-1;;;;;744:26:1;;;718:21;;;;;;;;;;-1:-1:-1;718:21:1;;;;-1:-1:-1;;;;;718:21:1;;;25432:1438:9;;;;;;;;;;-1:-1:-1;25432:1438:9;;;;;:::i;:::-;;:::i;28120:1332::-;;;;;;;;;;-1:-1:-1;28120:1332:9;;;;;:::i;:::-;;:::i;:::-;;;;13664:25:10;;;13720:2;13705:18;;13698:34;;;;13748:18;;;13741:34;13652:2;13637:18;28120:1332:9;13619:162:10;2321:411:1;2409:1;2393:13;3296:12:3;;;3208:108;2393:13:1;:17;2385:26;;;;;;2426:9;:13;2422:303;;2480:95;2551:13;3296:12:3;;;3208:108;2551:13:1;2522:26;2523:9;-1:-1:-1;;;2522:15:1;:26::i;:::-;:42;;;;:::i;:::-;2480:25;;;:29;:95::i;:::-;2452:25;:123;2591:43;;2624:9;12272:25:10;;2612:10:1;;2591:43;;12260:2:10;12245:18;2591:43:1;;;;;;;2675:25;;:40;;2705:9;2675:29;:40::i;:::-;2647:25;:68;2422:303;2321:411::o;24061:496:9:-;801:6:7;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;24157:30:9;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;:39;;::::0;::::1;;;;24149:48;;;::::0;::::1;;-1:-1:-1::0;;;;;24207:30:9;::::1;;::::0;;;:21:::1;:30;::::0;;;;:38;;-1:-1:-1;;24207:38:9::1;::::0;::::1;;::::0;;::::1;::::0;;;-1:-1:-1;24259:13:9::1;24255:245;;;24288:23;24300:7;24309:1;24288:11;:23::i;:::-;24325:31;::::0;-1:-1:-1;;;24325:31:9;;:15:::1;:31;::::0;::::1;12512:25:10::0;-1:-1:-1;;;;;12573:32:10;;12553:18;;;12546:60;24325:22:9::1;::::0;::::1;::::0;12485:18:10;;24325:31:9::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;24255:245;;;-1:-1:-1::0;;;;;3480:18:3;;3453:7;3480:18;;;;;;;;;;;24387:40:9::1;::::0;24399:7;;24387:11:::1;:40::i;:::-;-1:-1:-1::0;;;;;3480:18:3;;3453:7;3480:18;;;;;;;;;;;;24441:48:9;;-1:-1:-1;;;24441:48:9;;:15:::1;:48;::::0;::::1;12849:25:10::0;12890:18;;;12883:60;;;;12959:18;;;12952:34;24441:48:9;:19:::1;::::0;::::1;::::0;12822:18:10;;;;;3453:7:3;;24441:48:9;;;;;:19;:48;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;24255:245;24514:36;::::0;6023:14:10;;6016:22;5998:41;;-1:-1:-1;;;;;24514:36:9;::::1;::::0;::::1;::::0;5986:2:10;5971:18;24514:36:9::1;;;;;;;24061:496:::0;;:::o;2089:100:3:-;2143:13;2176:5;2169:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2089:100;:::o;4255:169::-;4338:4;4355:39;681:10:0;4378:7:3;4387:6;4355:8;:39::i;:::-;-1:-1:-1;4412:4:3;4255:169;;;;;:::o;4906:355::-;5046:4;5063:36;5073:6;5081:9;5092:6;5063:9;:36::i;:::-;5110:121;5119:6;681:10:0;5141:89:3;5179:6;5141:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5141:19:3;;;;;;-1:-1:-1;5141:19:3;;;;;;;;681:10:0;5141:33:3;;;;;;;;;;:37;:89::i;:::-;5110:8;:121::i;:::-;-1:-1:-1;5249:4:3;4906:355;;;;;:::o;6221:253:1:-;-1:-1:-1;;;;;6401:36:1;;6298:7;6401:36;;;:28;:36;;;;;;;;;3480:18:3;;;;;;;6323:25:1;;-1:-1:-1;;;;6323:131:1;;:115;;:63;;:48;;:25;:29;:48::i;:::-;:61;:63::i;:::-;:77;;:115::i;:::-;:129;:131::i;:::-;:143;;;;:::i;5670:218:3:-;681:10:0;5758:4:3;5807:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;5807:34:3;;;;;;;;;;5758:4;;5775:83;;5807:34;;:50;;5846:10;5807:38;:50::i;26876:521:9:-;26976:7;26997:6;27017;27037:7;27058;27079;27100;27121;27166:15;:20;;;;:22;;;;;;;;;;;;;12272:25:10;;12260:2;12245:18;;12227:76;27166:22:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27157:5;:31;27153:136;;-1:-1:-1;27212:42:9;;-1:-1:-1;;;;;;;;27212:42:9;;-1:-1:-1;27212:42:9;;-1:-1:-1;27212:42:9;;-1:-1:-1;27212:42:9;;-1:-1:-1;27212:42:9;27204:74;;27153:136;27317:36;;-1:-1:-1;;;27317:36:9;;:15;:36;;;13201:25:10;13242:18;;;13235:34;;;27299:15:9;;27317:29;;;;13174:18:10;;27317:36:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27299:54;;27371:19;27382:7;27371:10;:19::i;:::-;27364:26;;;;;;;;;;;;;;;;;26876:521;;;;;;;;;;:::o;1231:148:7:-;801:6;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;1322:6:::1;::::0;1301:40:::1;::::0;1338:1:::1;::::0;-1:-1:-1;;;;;1322:6:7::1;::::0;1301:40:::1;::::0;1338:1;;1301:40:::1;1352:6;:19:::0;;-1:-1:-1;;;;;;1352:19:7::1;::::0;;1231:148::o;25297:129:9:-;25400:11;;25385:34;;;-1:-1:-1;;;25385:34:9;;;;25353:13;;-1:-1:-1;;;;;25400:11:9;;-1:-1:-1;;25385:34:9;;;;;25400:11;;25385:34;;;;;;;25400:11;25385:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;25385:34:9;;;;;;;;;;;;:::i;:::-;25378:41;;25297:129;:::o;4174:101:1:-;801:6:7;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;4245:11:1::1;:22:::0;;-1:-1:-1;;;;;;4245:22:1::1;-1:-1:-1::0;;;;;4245:22:1;;;::::1;::::0;;;::::1;::::0;;4174:101::o;4895:128::-;4960:7;4985:30;5008:6;4985:22;:30::i;2308:104:3:-;2364:13;2397:7;2390:14;;;;;:::i;23911:144:9:-;801:6:7;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;24034:14:9::1;3134:1:3::0;24034:2:9::1;:14;:::i;:::-;24025:23;::::0;:6;:23:::1;:::i;:::-;23991:31;:57:::0;-1:-1:-1;23911:144:9:o;6391:269:3:-;6484:4;6501:129;681:10:0;6524:7:3;6533:96;6572:15;6533:96;;;;;;;;;;;;;;;;;681:10:0;6533:25:3;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;6533:34:3;;;;;;;;;;;;:38;:96::i;5242:172:1:-;-1:-1:-1;;;;;5379:26:1;;5319:7;5379:26;;;:18;:26;;;;;;5344:62;;:30;5379:26;5344:22;:30::i;:::-;:34;;:62::i;3719:175:3:-;3805:4;3822:42;681:10:0;3846:9:3;3857:6;3822:9;:42::i;29458:383:9:-;801:6:7;;29573:4:9;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;29593:14:9::1;29610:32;29634:7;29610:23;:32::i;:::-;29593:49:::0;-1:-1:-1;29657:10:9;;29653:159:::1;;-1:-1:-1::0;;;;;29683:23:9;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;;;29709:15:::1;29683:41:::0;;29743:33;;12272:25:10;;;29743:33:9;::::1;;::::0;29683:23;29743:33:::1;::::0;12245:18:10;29743:33:9::1;;;;;;;29797:4;29790:11;;;;;29653:159;-1:-1:-1::0;29829:5:9::1;::::0;29458:383;-1:-1:-1;;;29458:383:9:o;27637:477::-;801:6:7;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;-1:-1:-1;;;;;27725:30:9;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;27721:67;;;27637:477:::0;;:::o;27721:67::-:1;27816:31;;27802:10;:45;27798:261;;27863:32;27875:7;27884:10;27863:11;:32::i;:::-;27909:40;::::0;-1:-1:-1;;;27909:40:9;;:15:::1;:40;::::0;::::1;12849:25:10::0;-1:-1:-1;;;;;12910:32:10;;12890:18;;;12883:60;12959:18;;;12952:34;;;27909:19:9::1;::::0;::::1;::::0;12822:18:10;;27909:40:9::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;27798:261;;;27980:23;27992:7;28001:1;27980:11;:23::i;:::-;28017:31;::::0;-1:-1:-1;;;28017:31:9;;:15:::1;:31;::::0;::::1;12512:25:10::0;-1:-1:-1;;;;;12573:32:10;;12553:18;;;12546:60;28017:22:9::1;::::0;::::1;::::0;12485:18:10;;28017:31:9::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;27798:261;28069:38;28092:7;28102:4;28069:14;:38::i;:::-;;27637:477:::0;;:::o;24563:491::-;801:6:7;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;24676:4:9::1;24660:12;:20;;:45;;;;;24700:5;24684:12;:21;;24660:45;24639:171;;;::::0;-1:-1:-1;;;24639:171:9;;7777:2:10;24639:171:9::1;::::0;::::1;7759:21:10::0;7816:2;7796:18;;;7789:30;7855:34;7835:18;;;7828:62;7926:34;7906:18;;;7899:62;-1:-1:-1;;;7977:19:10;;;7970:46;8033:19;;24639:171:9::1;7749:309:10::0;24639:171:9::1;24857:9;;24841:12;:25;;24820:137;;;::::0;-1:-1:-1;;;24820:137:9;;8265:2:10;24820:137:9::1;::::0;::::1;8247:21:10::0;8304:2;8284:18;;;8277:30;8343:34;8323:18;;;8316:62;8414:34;8394:18;;;8387:62;-1:-1:-1;;;8465:19:10;;;8458:32;8507:19;;24820:137:9::1;8237:295:10::0;24820:137:9::1;25003:9;::::0;24972:41:::1;::::0;24989:12;;24972:41:::1;::::0;;;::::1;25023:9;:24:::0;24563:491::o;1534:244:7:-;801:6;;-1:-1:-1;;;;;801:6:7;681:10:0;801:22:7;793:67;;;;-1:-1:-1;;;793:67:7;;;;;;;:::i;:::-;-1:-1:-1;;;;;1623:22:7;::::1;1615:73;;;::::0;-1:-1:-1;;;1615:73:7;;8739:2:10;1615:73:7::1;::::0;::::1;8721:21:10::0;8778:2;8758:18;;;8751:30;8817:34;8797:18;;;8790:62;-1:-1:-1;;;8868:18:10;;;8861:36;8914:19;;1615:73:7::1;8711:228:10::0;1615:73:7::1;1725:6;::::0;1704:38:::1;::::0;-1:-1:-1;;;;;1704:38:7;;::::1;::::0;1725:6:::1;::::0;1704:38:::1;::::0;1725:6:::1;::::0;1704:38:::1;1753:6;:17:::0;;-1:-1:-1;;;;;;1753:17:7::1;-1:-1:-1::0;;;;;1753:17:7;;;::::1;::::0;;;::::1;::::0;;1534:244::o;25432:1438:9:-;25877:38;;-1:-1:-1;;;25877:38:9;;:15;:38;;;12512:25:10;-1:-1:-1;;;;;12573:32:10;;12553:18;;;12546:60;25850:8:9;;25528:15;;;;;;;;;;;;;;25877:29;;;;12485:18:10;;25877:38:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;25869:46;-1:-1:-1;;;;;;25970:10:9;;25966:506;;26017:18;;26008:5;26000:35;25996:466;;;26099:18;;26082:37;;:5;;:9;:37::i;:::-;26055:64;;25996:466;;;26243:18;;26193:15;:27;26158:32;;-1:-1:-1;26193:166:9;;26358:1;26193:166;;;26316:18;;26284:15;:27;:51;;:31;:51::i;:::-;26158:201;-1:-1:-1;26405:42:9;26158:201;26405:5;:42;:::i;:::-;26378:69;;26140:322;25996:466;26506:31;26529:7;26506:22;:31::i;:::-;26482:55;;26564:31;26587:7;26564:22;:31::i;:::-;-1:-1:-1;;;;;26622:23:9;;;;;;:14;:23;;;;;;26547:48;;-1:-1:-1;26622:23:9;-1:-1:-1;26622:23:9;26672:51;;26722:1;26672:51;;;26709:9;;26692:27;;:13;:27;:::i;:::-;26656:67;;26783:15;26767:13;:31;:96;;26862:1;26767:96;;;26813:34;:13;26831:15;26813:17;:34::i;:::-;26734:129;;25432:1438;;;;;;;;;:::o;28120:1332::-;28300:15;:27;28195:7;;;;;;28342:25;28338:89;;-1:-1:-1;;28397:18:9;;28391:1;;-1:-1:-1;28391:1:9;;-1:-1:-1;28383:33:9;;28338:89;28467:18;;28437:27;;28544:9;28526:27;;28564:18;28596:14;28625:712;28642:3;28632:7;:13;:50;;;;;28662:20;28649:10;:33;28632:50;28625:712;;;28698:21;;;;:::i;:::-;28761:15;:27;28698:21;;-1:-1:-1;28738:50:9;;;-1:-1:-1;28734:112:9;;28830:1;28808:23;;28734:112;28860:15;28878;:20;;28899:19;28878:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;28878:41:9;28951:23;;;:14;:23;;;;;;;;28878:41;;-1:-1:-1;28938:37:9;;:12;:37::i;:::-;28934:168;;;28999:38;29022:7;29032:4;28999:14;:38::i;:::-;28995:93;;;29061:8;;;;:::i;:::-;;;;28995:93;29116:12;;;;:::i;:::-;;;;29143:18;29164:9;29143:30;;29202:10;29192:7;:20;29188:104;;;29253:23;:7;29265:10;29253:11;:23::i;:::-;29242:35;;:7;:35;:::i;:::-;29232:45;;29188:104;29316:10;-1:-1:-1;28625:712:9;;-1:-1:-1;28625:712:9;;29347:18;:40;;;29406:10;;-1:-1:-1;29418:6:9;-1:-1:-1;29368:19:9;;-1:-1:-1;;;;28120:1332:9;;;;;;:::o;1679:471:8:-;1737:7;1982:6;1978:47;;-1:-1:-1;2012:1:8;2005:8;;1978:47;2037:9;2049:5;2053:1;2049;:5;:::i;:::-;2037:17;-1:-1:-1;2082:1:8;2073:5;2077:1;2037:17;2073:5;:::i;:::-;:10;2065:56;;;;-1:-1:-1;;;2065:56:8;;10728:2:10;2065:56:8;;;10710:21:10;10767:2;10747:18;;;10740:30;10806:34;10786:18;;;10779:62;-1:-1:-1;;;10857:18:10;;;10850:31;10898:19;;2065:56:8;10700:223:10;2065:56:8;2141:1;1679:471;-1:-1:-1;;;1679:471:8:o;325:181::-;383:7;;415:5;419:1;415;:5;:::i;:::-;403:17;;444:1;439;:6;;431:46;;;;-1:-1:-1;;;431:46:8;;9549:2:10;431:46:8;;;9531:21:10;9588:2;9568:18;;;9561:30;9627:29;9607:18;;;9600:57;9674:18;;431:46:8;9521:177:10;8249:452:1;-1:-1:-1;;;;;3480:18:3;;8325:22:1;3480:18:3;;;;;;;;;;;8382:27:1;;;8379:315;;;8422:26;8451:30;:10;8466:14;8451;:30::i;:::-;8422:59;;8492:45;8509:7;8518:18;8492:16;:45::i;:::-;8411:136;28069:38:9::1;27637:477:::0;;:::o;8379:315:1:-;8569:14;8556:10;:27;8553:141;;;8596:18;8617:30;:14;8636:10;8617:18;:30::i;:::-;8596:51;;8658:26;8664:7;8673:10;8658:5;:26::i;9517:380:3:-;-1:-1:-1;;;;;9653:19:3;;9645:68;;;;-1:-1:-1;;;9645:68:3;;11893:2:10;9645:68:3;;;11875:21:10;11932:2;11912:18;;;11905:30;11971:34;11951:18;;;11944:62;-1:-1:-1;;;12022:18:10;;;12015:34;12066:19;;9645:68:3;11865:226:10;9645:68:3;-1:-1:-1;;;;;9732:21:3;;9724:68;;;;-1:-1:-1;;;9724:68:3;;9146:2:10;9724:68:3;;;9128:21:10;9185:2;9165:18;;;9158:30;9224:34;9204:18;;;9197:62;-1:-1:-1;;;9275:18:10;;;9268:32;9317:19;;9724:68:3;9118:224:10;9724:68:3;-1:-1:-1;;;;;9805:18:3;;;;;;;-1:-1:-1;9805:18:3;;;;;;;;:27;;;;;;;;;;;;;:36;;;9857:32;;12272:25:10;;;9857:32:3;;;;;;;;;;;;9517:380;;;:::o;23723:182:9:-;23832:66;;-1:-1:-1;;;23832:66:9;;9905:2:10;23832:66:9;;;9887:21:10;9944:2;9924:18;;;9917:30;9983:34;9963:18;;;9956:62;-1:-1:-1;;;10034:18:10;;;10027:46;10090:19;;23832:66:9;9877:238:10;1228:192:8;1314:7;1350:12;1342:6;;;;1334:29;;;;-1:-1:-1;;;1334:29:8;;;;;;;;:::i;:::-;-1:-1:-1;1374:9:8;1386:5;1390:1;1386;:5;:::i;:::-;1374:17;1228:192;-1:-1:-1;;;;;1228:192:8:o;6799:134::-;6855:6;6888:1;6905:6;;;;6897:15;;;;;6135:176;6191:6;;6221:5;6225:1;6221;:5;:::i;:::-;6210:16;;6251:1;6246;:6;;:16;;;;;6261:1;6256;:6;;6246:16;6245:38;;;;6272:1;6268;:5;:14;;;;;6281:1;6277;:5;6268:14;6237:47;;;;;6540:127;6596:7;6629:1;6624;:6;;6616:15;;;;;;-1:-1:-1;6657:1:8;6540:127::o;789:136::-;847:7;874:43;878:1;881;874:43;;;;;;;;;;;;;;;;;:3;:43::i;2907:1255:1:-;2980:7;3000:29;3032:28;3055:4;3032:22;:28::i;:::-;3000:60;-1:-1:-1;3075:25:1;;3071:1065;;-1:-1:-1;;;;;3144:24:1;;;;;;:18;:24;;;;;;:51;;3173:21;3144:28;:51::i;:::-;-1:-1:-1;;;;;3117:24:1;;;;;;:18;:24;;;;;;;;;:78;;;;3215:46;12272:25:10;;;3117:24:1;;3215:46;;12245:18:10;3215:46:1;;;;;;;3294:6;;:13;;;-1:-1:-1;;;3294:13:1;;;;-1:-1:-1;;;;;3294:6:1;;;;:11;;:13;;;;;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3279:11;;-1:-1:-1;;;;;3279:28:1;;;:11;;:28;3276:806;;3328:12;3344:50;3366:4;3372:21;3344;:50::i;:::-;3327:67;;3417:7;3413:346;;3473:54;;3450:18;;-1:-1:-1;;;;;3473:9:1;;;3518:4;;3490:21;;3450:18;3473:54;3450:18;3473:54;3490:21;3473:9;3518:4;3473:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3449:78;;;3554:13;3550:183;;-1:-1:-1;;;;;3623:24:1;;;;;;:18;:24;;;;;;:51;;3652:21;3623:28;:51::i;:::-;-1:-1:-1;;;;;3596:24:1;;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;3596:24:1;;;-1:-1:-1;;;2907:1255:1:o;3550:183::-;3426:333;3413:346;3308:466;3276:806;;;3829:54;;3812:12;;-1:-1:-1;;;;;3829:9:1;;;3874:4;;3846:21;;3812:12;3829:54;3812:12;3829:54;3846:21;3829:9;3874:4;3829:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3811:72;;;3906:7;3902:165;;-1:-1:-1;;;;;3965:24:1;;;;;;:18;:24;;;;;;:51;;3994:21;3965:28;:51::i;:::-;-1:-1:-1;;;;;3938:24:1;;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;3938:24:1;;;-1:-1:-1;;2907:1255:1:o;3902:165::-;3792:290;4103:21;2907:1255;-1:-1:-1;;2907:1255:1:o;3071:1065::-;-1:-1:-1;4153:1:1;;2907:1255;-1:-1:-1;;2907:1255:1:o;5871:176:8:-;5927:6;;5957:5;5961:1;5957;:5;:::i;:::-;5946:16;;5987:1;5982;:6;;:16;;;;;5997:1;5992;:6;;5982:16;5981:38;;;;6008:1;6004;:5;:14;;;;;6017:1;6013;:5;5973:47;;;;;27403:228:9;27470:4;27506:15;27490:13;:31;27486:74;;;-1:-1:-1;27544:5:9;;27403:228;-1:-1:-1;27403:228:9:o;27486:74::-;27615:9;;27577:34;:15;27597:13;27577:19;:34::i;:::-;:47;;;27403:228;-1:-1:-1;;27403:228:9:o;7398:290:1:-;7483:38;7506:7;7515:5;7483:22;:38::i;:::-;7572:108;7625:53;7626:36;7656:5;7626:25;;:29;;:36;;;;:::i;7625:53::-;-1:-1:-1;;;;;7572:37:1;;;;;;:28;:37;;;;;;;:51;:108::i;:::-;-1:-1:-1;;;;;7532:37:1;;;;;;;;:28;:37;;;;;:148;;;;-1:-1:-1;7398:290:1:o;7973:268::-;8047:27;8059:7;8068:5;8047:11;:27::i;:::-;8125:108;8178:53;8179:36;8209:5;8179:25;;:29;;:36;;;;:::i;8178:53::-;-1:-1:-1;;;;;8125:37:1;;;;;;:28;:37;;;;;;;:51;:108::i;4285:391::-;4404:16;;;4418:1;4404:16;;;;;;;;4361:4;;;;4404:16;4418:1;4404:16;;;;;;;;-1:-1:-1;;4443:6:1;;:13;;;-1:-1:-1;;;4443:13:1;;;;4380:40;;-1:-1:-1;;;;;;4443:6:1;;;;:11;;-1:-1:-1;4443:13:1;;;;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4433:4;4438:1;4433:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4433:23:1;;;:7;;;;;;;;;:23;4479:11;;4469:7;;4479:11;;;4469:7;;-1:-1:-1;;4469:7:1;;;;;;:::i;:::-;-1:-1:-1;;;;;4469:21:1;;;:7;;;;;;;;;:21;4509:6;;;:28;4545:3;4509:6;4553:4;4559;4565:19;:15;4583:1;4565:19;:::i;:::-;4509:76;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4509:76:1;;;;;;;;;;;;:::i;:::-;;;4505:164;;4652:5;4645:12;;;;;4505:164;;4607:4;4600:11;;;;;7933:395:3;-1:-1:-1;;;;;8028:21:3;;8020:71;;;;-1:-1:-1;;;8020:71:3;;10322:2:10;8020:71:3;;;10304:21:10;10361:2;10341:18;;;10334:30;10400:34;10380:18;;;10373:62;-1:-1:-1;;;10451:18:10;;;10444:35;10496:19;;8020:71:3;10294:227:10;8020:71:3;8181:12;;:24;;8198:6;8181:16;:24::i;:::-;8166:12;:39;-1:-1:-1;;;;;8237:18:3;;:9;:18;;;;;;;;;;;:30;;8260:6;8237:22;:30::i;:::-;-1:-1:-1;;;;;8216:18:3;;:9;:18;;;;;;;;;;;:51;;;;8283:37;;12272:25:10;;;8216:18:3;;:9;;8283:37;;12245:18:10;8283:37:3;;;;;;;;7933:395;;:::o;8661:418::-;-1:-1:-1;;;;;8745:21:3;;8737:67;;;;-1:-1:-1;;;8737:67:3;;11491:2:10;8737:67:3;;;11473:21:10;11530:2;11510:18;;;11503:30;11569:34;11549:18;;;11542:62;-1:-1:-1;;;11620:18:10;;;11613:31;11661:19;;8737:67:3;11463:223:10;8737:67:3;8900:68;8923:6;8900:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8900:18:3;;:9;:18;;;;;;;;;;;;;:22;:68::i;:::-;-1:-1:-1;;;;;8879:18:3;;:9;:18;;;;;;;;;;:89;8994:12;;:24;;9011:6;8994:16;:24::i;:::-;8979:12;:39;9034:37;;12272:25:10;;;9060:1:3;;-1:-1:-1;;;;;9034:37:3;;;;;12260:2:10;12245:18;9034:37:3;12227:76:10;14:160;79:20;;135:13;;128:21;118:32;;108:2;;164:1;161;154:12;108:2;60:114;;;:::o;179:247::-;238:6;291:2;279:9;270:7;266:23;262:32;259:2;;;307:1;304;297:12;259:2;346:9;333:23;365:31;390:5;365:31;:::i;431:251::-;501:6;554:2;542:9;533:7;529:23;525:32;522:2;;;570:1;567;560:12;522:2;602:9;596:16;621:31;646:5;621:31;:::i;687:323::-;760:6;768;821:2;809:9;800:7;796:23;792:32;789:2;;;837:1;834;827:12;789:2;876:9;863:23;895:31;920:5;895:31;:::i;:::-;945:5;-1:-1:-1;969:35:10;1000:2;985:18;;969:35;:::i;:::-;959:45;;779:231;;;;;:::o;1015:388::-;1083:6;1091;1144:2;1132:9;1123:7;1119:23;1115:32;1112:2;;;1160:1;1157;1150:12;1112:2;1199:9;1186:23;1218:31;1243:5;1218:31;:::i;:::-;1268:5;-1:-1:-1;1325:2:10;1310:18;;1297:32;1338:33;1297:32;1338:33;:::i;:::-;1390:7;1380:17;;;1102:301;;;;;:::o;1408:456::-;1485:6;1493;1501;1554:2;1542:9;1533:7;1529:23;1525:32;1522:2;;;1570:1;1567;1560:12;1522:2;1609:9;1596:23;1628:31;1653:5;1628:31;:::i;:::-;1678:5;-1:-1:-1;1735:2:10;1720:18;;1707:32;1748:33;1707:32;1748:33;:::i;:::-;1512:352;;1800:7;;-1:-1:-1;;;1854:2:10;1839:18;;;;1826:32;;1512:352::o;2189:315::-;2257:6;2265;2318:2;2306:9;2297:7;2293:23;2289:32;2286:2;;;2334:1;2331;2324:12;2286:2;2373:9;2360:23;2392:31;2417:5;2392:31;:::i;:::-;2442:5;2494:2;2479:18;;;;2466:32;;-1:-1:-1;;;2276:228:10:o;2509:947::-;2604:6;2635:2;2678;2666:9;2657:7;2653:23;2649:32;2646:2;;;2694:1;2691;2684:12;2646:2;2727:9;2721:16;2756:18;2797:2;2789:6;2786:14;2783:2;;;2813:1;2810;2803:12;2783:2;2851:6;2840:9;2836:22;2826:32;;2896:7;2889:4;2885:2;2881:13;2877:27;2867:2;;2918:1;2915;2908:12;2867:2;2947;2941:9;2969:2;2965;2962:10;2959:2;;;2975:18;;:::i;:::-;3021:2;3018:1;3014:10;3004:20;;3044:28;3068:2;3064;3060:11;3044:28;:::i;:::-;3106:15;;;3137:12;;;;3169:11;;;3199;;;3195:20;;3192:33;-1:-1:-1;3189:2:10;;;3238:1;3235;3228:12;3189:2;3260:1;3251:10;;3270:156;3284:2;3281:1;3278:9;3270:156;;;3341:10;;3329:23;;3302:1;3295:9;;;;;3372:12;;;;3404;;3270:156;;;-1:-1:-1;3445:5:10;2615:841;-1:-1:-1;;;;;;;;2615:841:10:o;3461:183::-;3530:6;3583:2;3571:9;3562:7;3558:23;3554:32;3551:2;;;3599:1;3596;3589:12;3551:2;-1:-1:-1;3622:16:10;;3541:103;-1:-1:-1;3541:103:10:o;3649:706::-;3729:6;3782:2;3770:9;3761:7;3757:23;3753:32;3750:2;;;3798:1;3795;3788:12;3750:2;3831:9;3825:16;3860:18;3901:2;3893:6;3890:14;3887:2;;;3917:1;3914;3907:12;3887:2;3955:6;3944:9;3940:22;3930:32;;4000:7;3993:4;3989:2;3985:13;3981:27;3971:2;;4022:1;4019;4012:12;3971:2;4051;4045:9;4073:2;4069;4066:10;4063:2;;;4079:18;;:::i;:::-;4121:53;4170:2;-1:-1:-1;;4164:2:10;4145:13;;4141:27;4137:36;4121:53;:::i;:::-;4108:66;;4197:2;4190:5;4183:17;4237:7;4232:2;4227;4223;4219:11;4215:20;4212:33;4209:2;;;4258:1;4255;4248:12;4209:2;4271:54;4322:2;4317;4310:5;4306:14;4301:2;4297;4293:11;4271:54;:::i;:::-;-1:-1:-1;4344:5:10;3740:615;-1:-1:-1;;;;3740:615:10:o;4360:180::-;4419:6;4472:2;4460:9;4451:7;4447:23;4443:32;4440:2;;;4488:1;4485;4478:12;4440:2;-1:-1:-1;4511:23:10;;4430:110;-1:-1:-1;4430:110:10:o;6274:908::-;6508:4;6556:3;6545:9;6541:19;6587:6;6576:9;6569:25;6613:2;6651:3;6646:2;6635:9;6631:18;6624:31;6675:6;6710;6704:13;6741:6;6733;6726:22;6779:3;6768:9;6764:19;6757:26;;6818:2;6810:6;6806:15;6792:29;;6839:1;6849:195;6863:6;6860:1;6857:13;6849:195;;;6928:13;;-1:-1:-1;;;;;6924:39:10;6912:52;;7019:15;;;;6984:12;;;;-1:-1:-1;6878:9:10;6849:195;;;-1:-1:-1;;;;;;;7100:32:10;;;;7095:2;7080:18;;7073:60;-1:-1:-1;;;7164:2:10;7149:18;7142:34;7100:32;7061:3;-1:-1:-1;;6517:665:10:o;7187:383::-;7336:2;7325:9;7318:21;7299:4;7368:6;7362:13;7411:6;7406:2;7395:9;7391:18;7384:34;7427:66;7486:6;7481:2;7470:9;7466:18;7461:2;7453:6;7449:15;7427:66;:::i;:::-;7554:2;7533:15;-1:-1:-1;;7529:29:10;7514:45;;;;7561:2;7510:54;;7308:262;-1:-1:-1;;7308:262:10:o;10928:356::-;11130:2;11112:21;;;11149:18;;;11142:30;11208:34;11203:2;11188:18;;11181:62;11275:2;11260:18;;11102:182::o;13975:275::-;14046:2;14040:9;-1:-1:-1;;14111:2:10;14092:13;;14088:27;14076:40;;14167:22;;;14146:18;14131:34;;14128:62;14125:2;;;14193:18;;:::i;:::-;14229:2;14222:22;14020:230;;-1:-1:-1;14020:230:10:o;14255:265::-;14294:3;14322:9;;;-1:-1:-1;;;;;14366:27:10;;;14359:35;;14347:10;;14343:52;14340:2;;;14398:18;;:::i;:::-;-1:-1:-1;;;14445:19:10;;;14438:27;;14430:36;;14427:2;;;14469:18;;:::i;:::-;-1:-1:-1;;14505:9:10;;14302:218::o;14525:128::-;14565:3;14596:1;14592:6;14589:1;14586:13;14583:2;;;14602:18;;:::i;:::-;-1:-1:-1;14638:9:10;;14573:80::o;14658:217::-;14698:1;14724;14714:2;;14768:10;14763:3;14759:20;14756:1;14749:31;14803:4;14800:1;14793:15;14831:4;14828:1;14821:15;14714:2;-1:-1:-1;14860:9:10;;14704:171::o;14880:422::-;14969:1;15012:5;14969:1;15026:270;15047:7;15037:8;15034:21;15026:270;;;15106:4;15102:1;15098:6;15094:17;15088:4;15085:27;15082:2;;;15115:18;;:::i;:::-;15165:7;15155:8;15151:22;15148:2;;;15185:16;;;;15148:2;15264:22;;;;15224:15;;;;15026:270;;;15030:3;14944:358;;;;;:::o;15307:140::-;15365:5;15394:47;15435:4;15425:8;15421:19;15415:4;15501:5;15531:8;15521:2;;-1:-1:-1;15572:1:10;15586:5;;15521:2;15620:4;15610:2;;-1:-1:-1;15657:1:10;15671:5;;15610:2;15702:4;15720:1;15715:59;;;;15788:1;15783:130;;;;15695:218;;15715:59;15745:1;15736:10;;15759:5;;;15783:130;15820:3;15810:8;15807:17;15804:2;;;15827:18;;:::i;:::-;-1:-1:-1;;15883:1:10;15869:16;;15898:5;;15695:218;;15997:2;15987:8;15984:16;15978:3;15972:4;15969:13;15965:36;15959:2;15949:8;15946:16;15941:2;15935:4;15932:12;15928:35;15925:77;15922:2;;;-1:-1:-1;16034:19:10;;;16066:5;;15922:2;16113:34;16138:8;16132:4;16113:34;:::i;:::-;16183:6;16179:1;16175:6;16171:19;16162:7;16159:32;16156:2;;;16194:18;;:::i;:::-;16232:20;;15511:747;-1:-1:-1;;;15511:747:10:o;16263:168::-;16303:7;16369:1;16365;16361:6;16357:14;16354:1;16351:21;16346:1;16339:9;16332:17;16328:45;16325:2;;;16376:18;;:::i;:::-;-1:-1:-1;16416:9:10;;16315:116::o;16436:267::-;16475:4;16504:9;;;-1:-1:-1;;;16548:19:10;;16541:27;;16529:10;;16525:44;16522:2;;;16572:18;;:::i;:::-;-1:-1:-1;;;;;16619:27:10;;16612:35;;16604:44;;16601:2;;;16651:18;;:::i;:::-;-1:-1:-1;;16688:9:10;;16484:219::o;16708:125::-;16748:4;16776:1;16773;16770:8;16767:2;;;16781:18;;:::i;:::-;-1:-1:-1;16818:9:10;;16757:76::o;16838:258::-;16910:1;16920:113;16934:6;16931:1;16928:13;16920:113;;;17010:11;;;17004:18;16991:11;;;16984:39;16956:2;16949:10;16920:113;;;17051:6;17048:1;17045:13;17042:2;;;-1:-1:-1;;17086:1:10;17068:16;;17061:27;16891:205::o;17101:380::-;17180:1;17176:12;;;;17223;;;17244:2;;17298:4;17290:6;17286:17;17276:27;;17244:2;17351;17343:6;17340:14;17320:18;17317:38;17314:2;;;17397:10;17392:3;17388:20;17385:1;17378:31;17432:4;17429:1;17422:15;17460:4;17457:1;17450:15;17314:2;;17156:325;;;:::o;17486:135::-;17525:3;-1:-1:-1;;17546:17:10;;17543:2;;;17566:18;;:::i;:::-;-1:-1:-1;17613:1:10;17602:13;;17533:88::o;17626:127::-;17687:10;17682:3;17678:20;17675:1;17668:31;17718:4;17715:1;17708:15;17742:4;17739:1;17732:15;17758:127;17819:10;17814:3;17810:20;17807:1;17800:31;17850:4;17847:1;17840:15;17874:4;17871:1;17864:15;17890:127;17951:10;17946:3;17942:20;17939:1;17932:31;17982:4;17979:1;17972:15;18006:4;18003:1;17996:15;18022:131;-1:-1:-1;;;;;18097:31:10;;18087:42;;18077:2;;18143:1;18140;18133:12;18077:2;18067:86;:::o

ipfs://4443675675b8dee144ce298a9e14211c6cb273fb3a2f035c5d7bea0e8c67d7e3