Token

ERC20 ***

ERC-20

Overview

Max Total Supply

3,492,457.091458304 ERC20 ***

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 9 Decimals)

0xdd9ce127a7df935908c005c8f0e5eed66141e2a6

Filtered by Token Holder

0x07246A33632Fd3dBE3F0211857F950786c52e61F

Balance

104,650.854962152 ERC20 ***

Value

$0.00

0x07246a33632fd3dbe3f0211857f950786c52e61f

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

This contract contains unverified libraries: IterableMapping

This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:

USDT_DividendTracker

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-05
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;
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;
    }
}

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

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 {}
}

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

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

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

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

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 = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
  }

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

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

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 ElonMuskFineXTrump69Doge is ERC20, Ownable {
    using Address for address payable;
    IRouter public  router;
    address private  pair;
    bool private swapping;
    bool private  swapEnabled = true;
    bool public tradingEnabled = false;
    uint256 private  startTradingBlock;
    USDT_DividendTracker public dividendTracker;
    
    address public constant deadWallet = 0x000000000000000000000000000000000000dEaD;
    address public marketingWallet = 0xD3384c9Dc238Ea3716614cBDf9c17D1b02D2dE4B;
    uint256 private swapTokensAtAmount = 2e5 * 10**9;
    
    string private currentRewardToken;

    struct Taxes {
        uint256 rewards;
        uint256 marketing;
        uint256 liquidity;
    }

    Taxes public buyTaxes = Taxes(1, 29, 0);
    Taxes public sellTaxes = Taxes(1, 29, 0);

    uint256 public gasForProcessing = 300000;
    uint256 private antiBotBlocks = 2;
    uint256 private launchtax = 99;
    
    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) public automatedMarketMakerPairs;

    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 ProcessedDividendTracker(
        uint256 iterations,
        uint256 claims,
        uint256 lastProcessedIndex,
        bool indexed automatic,
        uint256 gas,
        address indexed processor
    );

    constructor() ERC20("ElonMuskFineXTrump69Doge", "USDT") {
        dividendTracker = new  USDT_DividendTracker();
        IRouter _router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        address _pair = IFactory(_router.factory()).createPair(address(this), _router.WETH());
        router = _router;
        pair = _pair;

        _setAutomatedMarketMakerPair(_pair, true);

        dividendTracker.excludeFromDividends(address(dividendTracker), true);
        dividendTracker.excludeFromDividends(address(this), true);
        dividendTracker.excludeFromDividends(owner(), true);
        dividendTracker.excludeFromDividends(deadWallet, true);
        dividendTracker.excludeFromDividends(address(_router), true);

        excludeFromFees(owner(), true);
        excludeFromFees(marketingWallet, true);
        excludeFromFees(address(this), true);

        _tokengeneration(owner(), 10000000 * (10**9));
    }

    receive() external payable {}

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

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

    function rescueERC20Tokens(address tokenAddress) external onlyOwner {
        require(tokenAddress != address(this), "Owner can't claim contract's balance of its own tokens");
        IERC20(tokenAddress).transfer(marketingWallet,IERC20(tokenAddress).balanceOf(address(this)));
    }

    function rescueETH() external {
        uint256 ETHbalance = address(this).balance;
        payable(marketingWallet).sendValue(ETHbalance);
    }

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        require(
            _isExcludedFromFees[account] != excluded,
            "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 setdevelopmentWallet(address newWallet) external onlyOwner {
        require(newWallet != address(this), "Fee Address cannot be Contract Address");
        require(newWallet != address(0),"Fee Address cannot be zero address");
        marketingWallet = newWallet;
       excludeFromFees(newWallet, true);
    }

    function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
        require(amount >= 1e2, "amount must be greater than or equal to 0.001%");
        swapTokensAtAmount = amount * 10**9;
    }

    function setBuyTaxes(uint256 _rewards, uint256 marketing, uint256 _liquidity) external onlyOwner{
        buyTaxes = Taxes(_rewards, marketing, _liquidity);
        require((_rewards + marketing +  _liquidity ) <= 40, "Must keep fees at 40% or less");
    }

    function setSellTaxes(uint256 _rewards, uint256 marketing, uint256 _liquidity) external onlyOwner{
        sellTaxes = Taxes(_rewards, marketing, _liquidity);
        require((_rewards + marketing +  _liquidity ) <= 40, "Must keep fees at 40% or less");
    }

    function setSwapEnabled(bool _enabled) external onlyOwner {
        swapEnabled = _enabled;
    }    

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

    function setBotBlocks(uint256 numberOfBlocks) external onlyOwner{
        require(!tradingEnabled, "Can't change when trading has started");
        require(numberOfBlocks < 3,"Deadline should be less than 3 Blocks");
        antiBotBlocks = numberOfBlocks;
    }

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

    function _setAutomatedMarketMakerPair(address newPair, bool value) private {
        require(automatedMarketMakerPairs[newPair] != value,"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,
           "GasForProcessing must be between 200,000 and 500,000"
        );
        require(newValue != gasForProcessing,
            "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);
    }

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

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

        if (!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
                require(tradingEnabled, "Trading no active");
        }
       
        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.liquidity ;

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

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

            swapping = false;
        }

        bool takeFee = !swapping;

        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }
            if (takeFee) {
            bool useLaunchFee = block.number <= startTradingBlock + antiBotBlocks;
            uint256 swapAmt;
            
            if (automatedMarketMakerPairs[to] && !useLaunchFee) {
                swapAmt = (amount * swapTax) / 100;
            
            } else if (automatedMarketMakerPairs[from] && !useLaunchFee) {
                swapAmt =
                    (amount *
                        (buyTaxes.rewards +
                            buyTaxes.marketing +
                            buyTaxes.liquidity )) / 100;
            
            } else if (useLaunchFee) {
                swapAmt = (amount * launchtax) / 100; 
            }
            
            amount = amount - (swapAmt);
            super._transfer(from, address(this), swapAmt);
        }
        
        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 {
        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) {
            addLiquidity(tokensToAddLiquidityWith, bnbToAddLiquidityWith);
        }
        uint256 marketingWalletAmt = unitBalance * 2 * sellTaxes.marketing;
        if (marketingWalletAmt > 0) {
            payable(marketingWallet).sendValue(marketingWalletAmt);
        }
        uint256 dividends = unitBalance * 2 * sellTaxes.rewards;
        if (dividends > 0) {
            (bool success, ) = address(dividendTracker).call{ value: dividends }("");
            if (success) emit SendDividends(tokens, dividends);
        }
    }

    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);
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(router), tokenAmount);
        router.addLiquidityETH{ value: ethAmount }(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            deadWallet,
            block.timestamp
        );
    }
}

contract USDT_DividendTracker 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("USDT_Dividen_Tracker", "USDT_Dividend_Tracker")
    {
        claimWait = 3600;
        minimumTokenBalanceForDividends = 1e3 * (10**decimals());
    }

    function _transfer(
        address,
        address,
        uint256
    ) internal pure override {
        require(false, "USDT_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,
            "USDT_Dividend_Tracker: claimWait must be updated to between 1 and 24 hours"
        );
        require(
            newClaimWait != claimWait,
            "USDT_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;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"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"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60806040523480156200001157600080fd5b506040518060400160405280601481526020017f555344545f4469766964656e5f547261636b65720000000000000000000000008152506040518060400160405280601581526020017f555344545f4469766964656e645f547261636b657200000000000000000000008152508181816003908162000091919062000229565b506004620000a0828262000229565b5050506000620000b56200018060201b60201c565b600580546001600160a01b0319166001600160a01b038316908117909155604051919250906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a35050600680546001600160a01b0319908116737a250d5630b4cf539739df2c5dacb4c659f2488d179091556007805490911673dac17f958d2ee523a2206206994597c13d831ec717905550610e106013556200015c600990565b6200016990600a6200040a565b62000177906103e862000422565b6014556200043c565b3390565b634e487b7160e01b600052604160045260246000fd5b600181811c90821680620001af57607f821691505b602082108103620001d057634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200022457600081815260208120601f850160051c81016020861015620001ff5750805b601f850160051c820191505b8181101562000220578281556001016200020b565b5050505b505050565b81516001600160401b0381111562000245576200024562000184565b6200025d816200025684546200019a565b84620001d6565b602080601f8311600181146200029557600084156200027c5750858301515b600019600386901b1c1916600185901b17855562000220565b600085815260208120601f198616915b82811015620002c657888601518255948401946001909101908401620002a5565b5085821015620002e55787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b600052601160045260246000fd5b600181815b808511156200034c578160001904821115620003305762000330620002f5565b808516156200033e57918102915b93841c939080029062000310565b509250929050565b600082620003655750600162000404565b81620003745750600062000404565b81600181146200038d57600281146200039857620003b8565b600191505062000404565b60ff841115620003ac57620003ac620002f5565b50506001821b62000404565b5060208310610133831016604e8410600b8410161715620003dd575081810a62000404565b620003e983836200030b565b8060001904821115620004005762000400620002f5565b0290505b92915050565b60006200041b60ff84168362000354565b9392505050565b8082028115828204841417620004045762000404620002f5565b6127e5806200044c6000396000f3fe6080604052600436106102345760003560e01c80638aee81271161012e578063be10b614116100ab578063f2fde38b1161006f578063f2fde38b146106ed578063f7c618c11461070d578063f887ea401461072d578063fbcbc0f11461074d578063ffb2c4791461076d57600080fd5b8063be10b6141461063c578063dd62ed3e14610652578063e30443bc14610698578063e7841ec0146106b8578063e98030c7146106cd57600080fd5b8063a457c2d7116100f2578063a457c2d714610586578063a8b9d240146105a6578063a9059cbb146105c6578063aafd847a146105e6578063bc4c4b371461061c57600080fd5b80638aee8127146104df5780638da5cb5b146104ff57806391b89fba1461053157806395d89b41146105515780639d7ceafb1461056657600080fd5b80633009a609116101bc5780636f2789ec116101805780636f2789ec1461045357806370a0823114610469578063715018a61461049f578063854c84dc146104b457806385a6b3ae146104c957600080fd5b80633009a6091461036c578063313ce56714610382578063395093511461039e5780634e7b827f146103be5780635183d6fd146103ee57600080fd5b806309bbedde1161020357806309bbedde146102cb57806318160ddd146102ea578063226cfa3d146102ff57806323b872dd1461032c57806327ce01471461034c57600080fd5b806303c83302146102485780630483f7a01461025057806306fdde0314610270578063095ea7b31461029b57600080fd5b36610243576102416107a8565b005b600080fd5b6102416107a8565b34801561025c57600080fd5b5061024161026b366004612169565b61083b565b34801561027c57600080fd5b50610285610a5d565b60405161029291906121c2565b60405180910390f35b3480156102a757600080fd5b506102bb6102b63660046121f5565b610aef565b6040519015158152602001610292565b3480156102d757600080fd5b50600c545b604051908152602001610292565b3480156102f657600080fd5b506002546102dc565b34801561030b57600080fd5b506102dc61031a366004612221565b60126020526000908152604090205481565b34801561033857600080fd5b506102bb61034736600461223e565b610b06565b34801561035857600080fd5b506102dc610367366004612221565b610b6f565b34801561037857600080fd5b506102dc60105481565b34801561038e57600080fd5b5060405160098152602001610292565b3480156103aa57600080fd5b506102bb6103b93660046121f5565b610bcb565b3480156103ca57600080fd5b506102bb6103d9366004612221565b60116020526000908152604090205460ff1681565b3480156103fa57600080fd5b5061040e61040936600461227f565b610c01565b604080516001600160a01b0390991689526020890197909752958701949094526060860192909252608085015260a084015260c083015260e082015261010001610292565b34801561045f57600080fd5b506102dc60135481565b34801561047557600080fd5b506102dc610484366004612221565b6001600160a01b031660009081526020819052604090205490565b3480156104ab57600080fd5b50610241610d55565b3480156104c057600080fd5b50610285610dc9565b3480156104d557600080fd5b506102dc600b5481565b3480156104eb57600080fd5b506102416104fa366004612221565b610e40565b34801561050b57600080fd5b506005546001600160a01b03165b6040516001600160a01b039091168152602001610292565b34801561053d57600080fd5b506102dc61054c366004612221565b610e8c565b34801561055d57600080fd5b50610285610e97565b34801561057257600080fd5b5061024161058136600461227f565b610ea6565b34801561059257600080fd5b506102bb6105a13660046121f5565b610eec565b3480156105b257600080fd5b506102dc6105c1366004612221565b610f3b565b3480156105d257600080fd5b506102bb6105e13660046121f5565b610f67565b3480156105f257600080fd5b506102dc610601366004612221565b6001600160a01b03166000908152600a602052604090205490565b34801561062857600080fd5b506102bb610637366004612169565b610f74565b34801561064857600080fd5b506102dc60145481565b34801561065e57600080fd5b506102dc61066d366004612298565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3480156106a457600080fd5b506102416106b33660046121f5565b611022565b3480156106c457600080fd5b506010546102dc565b3480156106d957600080fd5b506102416106e836600461227f565b61118c565b3480156106f957600080fd5b50610241610708366004612221565b6112fa565b34801561071957600080fd5b50600754610519906001600160a01b031681565b34801561073957600080fd5b50600654610519906001600160a01b031681565b34801561075957600080fd5b5061040e610768366004612221565b6113e5565b34801561077957600080fd5b5061078d61078836600461227f565b61154d565b60408051938452602084019290925290820152606001610292565b60006107b360025490565b116107bd57600080fd5b3415610839576107f06107cf60025490565b6107dd34600160801b61166a565b6107e791906122e7565b600854906116f3565b60085560405134815233907fa493a9229478c3fcd73f66d2cdeb7f94fd0f341da924d1054236d784541165119060200160405180910390a2600b5461083590346116f3565b600b555b565b6005546001600160a01b0316331461086e5760405162461bcd60e51b815260040161086590612309565b60405180910390fd5b6001600160a01b03821660009081526011602052604090205481151560ff90911615150361089b57600080fd5b6001600160a01b0382166000908152601160205260409020805460ff191682151590811790915560010361094b576108d4826000611752565b60405163131836e760e21b8152600c60048201526001600160a01b038316602482015273a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb3990634c60db9c9060440160006040518083038186803b15801561092e57600080fd5b505af4158015610942573d6000803e3d6000fd5b50505050610a14565b6109738261096e846001600160a01b031660009081526020819052604090205490565b611752565b73a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb3963bc2b405c600c846109af816001600160a01b031660009081526020819052604090205490565b6040516001600160e01b031960e086901b16815260048101939093526001600160a01b039091166024830152604482015260640160006040518083038186803b1580156109fb57600080fd5b505af4158015610a0f573d6000803e3d6000fd5b505050505b816001600160a01b03167fa3c7c11b2e12c4144b09a7813f3393ba646392788638998c97be8da908cf04be82604051610a51911515815260200190565b60405180910390a25050565b606060038054610a6c9061233e565b80601f0160208091040260200160405190810160405280929190818152602001828054610a989061233e565b8015610ae55780601f10610aba57610100808354040283529160200191610ae5565b820191906000526020600020905b815481529060010190602001808311610ac857829003601f168201915b5050505050905090565b6000610afc3384846117b7565b5060015b92915050565b6000610b138484846118db565b610b658433610b6085604051806060016040528060288152602001612763602891396001600160a01b038a1660009081526001602090815260408083203384529091529020549190611937565b6117b7565b5060019392505050565b6001600160a01b03811660009081526009602090815260408083205491839052822054600854600160801b92610bc192610bbc92610bb691610bb1919061166a565b611971565b90611981565b6119bf565b610b0091906122e7565b3360008181526001602090815260408083206001600160a01b03871684529091528120549091610afc918590610b6090866116f3565b600080600080600080600080600c73a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb3963deb3d89690916040518263ffffffff1660e01b8152600401610c4991815260200190565b602060405180830381865af4158015610c66573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c8a9190612378565b8910610caf575060009650600019955085945086935083925082915081905080610d4a565b6040516368d54f3f60e11b8152600c6004820152602481018a905260009073a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb399063d1aa9e7e90604401602060405180830381865af4158015610d09573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d2d9190612391565b9050610d38816113e5565b98509850985098509850985098509850505b919395975091939597565b6005546001600160a01b03163314610d7f5760405162461bcd60e51b815260040161086590612309565b6005546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600580546001600160a01b0319169055565b600754604080516306fdde0360e01b815290516060926001600160a01b0316916306fdde039160048083019260009291908290030181865afa158015610e13573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052610e3b91908101906123f5565b905090565b6005546001600160a01b03163314610e6a5760405162461bcd60e51b815260040161086590612309565b600780546001600160a01b0319166001600160a01b0392909216919091179055565b6000610b0082610f3b565b606060048054610a6c9061233e565b6005546001600160a01b03163314610ed05760405162461bcd60e51b815260040161086590612309565b610edc6009600a61256d565b610ee6908261257c565b60145550565b6000610afc3384610b608560405180606001604052806025815260200161278b602591393360009081526001602090815260408083206001600160a01b038d1684529091529020549190611937565b6001600160a01b0381166000908152600a6020526040812054610b0090610f6184610b6f565b906119d2565b6000610afc3384846118db565b6005546000906001600160a01b03163314610fa15760405162461bcd60e51b815260040161086590612309565b6000610fac84611a14565b90508015611018576001600160a01b038416600081815260126020526040908190204290555184151591907fa2c38e2d2fb7e3e1912d937fd1ca11ed6d51864dee4cfa7a7bf02becd7acf092906110069085815260200190565b60405180910390a36001915050610b00565b5060009392505050565b6005546001600160a01b0316331461104c5760405162461bcd60e51b815260040161086590612309565b6001600160a01b03821660009081526011602052604090205460ff166111885760145481106110fd5761107f8282611752565b604051632f0ad01760e21b8152600c60048201526001600160a01b03831660248201526044810182905273a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb399063bc2b405c9060640160006040518083038186803b1580156110e057600080fd5b505af41580156110f4573d6000803e3d6000fd5b5050505061117b565b611108826000611752565b60405163131836e760e21b8152600c60048201526001600160a01b038316602482015273a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb3990634c60db9c9060440160006040518083038186803b15801561116257600080fd5b505af4158015611176573d6000803e3d6000fd5b505050505b611186826001610f74565b505b5050565b6005546001600160a01b031633146111b65760405162461bcd60e51b815260040161086590612309565b610e1081101580156111cb5750620151808111155b6112505760405162461bcd60e51b815260206004820152604a60248201527f555344545f4469766964656e645f547261636b65723a20636c61696d5761697460448201527f206d757374206265207570646174656420746f206265747765656e203120616e6064820152696420323420686f75727360b01b608482015260a401610865565b60135481036112c75760405162461bcd60e51b815260206004820152603c60248201527f555344545f4469766964656e645f547261636b65723a2043616e6e6f7420757060448201527f6461746520636c61696d5761697420746f2073616d652076616c7565000000006064820152608401610865565b60135460405182907f474ea64804364a1e29a4487ddb63c3342a2dd826ccd8acf48825e680a0e6f20f90600090a3601355565b6005546001600160a01b031633146113245760405162461bcd60e51b815260040161086590612309565b6001600160a01b0381166113895760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610865565b6005546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600580546001600160a01b0319166001600160a01b0392909216919091179055565b6040516317e142d160e01b8152600c60048201526001600160a01b0382166024820152819060009081908190819081908190819073a3686b5fa3c5f6eb2da4a29a677d61a6ed62eb39906317e142d190604401602060405180830381865af4158015611455573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906114799190612378565b96506000199550600087126114db576010548711156114a7576010546114a0908890611caa565b95506114db565b601054600c54600091106114bc5760006114cb565b601054600c546114cb916119d2565b90506114d78189612593565b9650505b6114e488610f3b565b94506114ef88610b6f565b6001600160a01b038916600090815260126020526040902054909450925082611519576000611526565b60135461152690846125bb565b9150428211611536576000611540565b61154082426119d2565b9050919395975091939597565b600c546000908190819080820361156f57505060105460009250829150611663565b6010546000805a90506000805b898410801561158a57508582105b156116525784611599816125ce565b600c54909650861090506115ac57600094505b6000600c60000186815481106115c4576115c46125e7565b60009182526020808320909101546001600160a01b031680835260129091526040909120549091506115f590611ce7565b1561161857611605816001610f74565b156116185781611614816125ce565b9250505b82611622816125ce565b93505060005a9050808511156116495761163c85826119d2565b61164690876125bb565b95505b935061157c9050565b601085905590975095509193505050505b9193909250565b60008260000361167c57506000610b00565b6000611688838561257c565b90508261169585836122e7565b146116ec5760405162461bcd60e51b815260206004820152602160248201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6044820152607760f81b6064820152608401610865565b9392505050565b60008061170083856125bb565b9050838110156116ec5760405162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006044820152606401610865565b6001600160a01b0382166000908152602081905260409020548082111561179157600061177f83836119d2565b905061178b8482611d0e565b50611186565b808210156111865760006117a582846119d2565b90506117b18482611d72565b50505050565b6001600160a01b0383166118195760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b6064820152608401610865565b6001600160a01b03821661187a5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b6064820152608401610865565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b60405162461bcd60e51b815260206004820152602b60248201527f555344545f4469766964656e645f547261636b65723a204e6f207472616e736660448201526a195c9cc8185b1b1bddd95960aa1b6064820152608401610865565b6000818484111561195b5760405162461bcd60e51b815260040161086591906121c2565b50600061196884866125fd565b95945050505050565b60008181811215610b0057600080fd5b60008061198e8385612593565b9050600083121580156119a15750838112155b806119b657506000831280156119b657508381125b6116ec57600080fd5b6000808212156119ce57600080fd5b5090565b60006116ec83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611937565b600080611a2083610f3b565b90508015611ca1576001600160a01b0383166000908152600a6020526040902054611a4b90826116f3565b6001600160a01b0384166000818152600a6020526040908190209290925590517fee503bee2bb6a87e57bc57db795f98137327401a0e7b7ce42e37926cc1a9ca4d90611a9a9084815260200190565b60405180910390a2600660009054906101000a90046001600160a01b03166001600160a01b031663ad5c46486040518163ffffffff1660e01b8152600401602060405180830381865afa158015611af5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b199190612391565b6007546001600160a01b03908116911614611bf2576000611b3a8483611db6565b905080611bec576000846001600160a01b031683610bb890604051600060405180830381858888f193505050503d8060008114611b93576040519150601f19603f3d011682016040523d82523d6000602084013e611b98565b606091505b5050905080611bea576001600160a01b0385166000908152600a6020526040902054611bc490846119d2565b6001600160a01b039095166000908152600a602052604081209590955550929392505050565b505b50610b00565b6000836001600160a01b031682610bb890604051600060405180830381858888f193505050503d8060008114611c44576040519150601f19603f3d011682016040523d82523d6000602084013e611c49565b606091505b5050905080611c9a576001600160a01b0384166000908152600a6020526040902054611c7590836119d2565b6001600160a01b039094166000908152600a6020526040812094909455509192915050565b5092915050565b50600092915050565b600080611cb78385612610565b905060008312158015611cca5750838113155b806119b657506000831280156119b657508381136116ec57600080fd5b600042821115611cf957506000919050565b601354611d0642846119d2565b101592915050565b611d188282611f33565b611d52611d33610bb18360085461166a90919063ffffffff16565b6001600160a01b03841660009081526009602052604090205490611caa565b6001600160a01b0390921660009081526009602052604090209190915550565b611d7c828261202c565b611d52611d97610bb18360085461166a90919063ffffffff16565b6001600160a01b03841660009081526009602052604090205490611981565b604080516002808252606082018352600092839291906020830190803683375050600654604080516315ab88c960e31b815290519394506001600160a01b039091169263ad5c4648925060048083019260209291908290030181865afa158015611e24573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e489190612391565b81600081518110611e5b57611e5b6125e7565b6001600160a01b039283166020918202929092010152600754825191169082906001908110611e8c57611e8c6125e7565b6001600160a01b03928316602091820292909201015260065416637ff36ab58460008488611ebb4260026125bb565b6040518663ffffffff1660e01b8152600401611eda9493929190612630565b60006040518083038185885af193505050508015611f1a57506040513d6000823e601f3d908101601f19168201604052611f17919081019061269a565b60015b611f28576000915050610b00565b506001915050610b00565b6001600160a01b038216611f975760405162461bcd60e51b815260206004820152602560248201527f45524332303a206e657720746f6b656e7320746f20746865207a65726f206164604482015264647265737360d81b6064820152608401610865565b611fa360008383611186565b600254611fb090826116f3565b6002556001600160a01b038216600090815260208190526040902054611fd690826116f3565b6001600160a01b038316600081815260208181526040808320949094559251848152919290917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91015b60405180910390a35050565b6001600160a01b03821661208c5760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b6064820152608401610865565b61209882600083611186565b6120d581604051806060016040528060228152602001612741602291396001600160a01b0385166000908152602081905260409020549190611937565b6001600160a01b0383166000908152602081905260409020556002546120fb90826119d2565b6002556040518181526000906001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90602001612020565b6001600160a01b038116811461215157600080fd5b50565b8035801515811461216457600080fd5b919050565b6000806040838503121561217c57600080fd5b82356121878161213c565b915061219560208401612154565b90509250929050565b60005b838110156121b95781810151838201526020016121a1565b50506000910152565b60208152600082518060208401526121e181604085016020870161219e565b601f01601f19169190910160400192915050565b6000806040838503121561220857600080fd5b82356122138161213c565b946020939093013593505050565b60006020828403121561223357600080fd5b81356116ec8161213c565b60008060006060848603121561225357600080fd5b833561225e8161213c565b9250602084013561226e8161213c565b929592945050506040919091013590565b60006020828403121561229157600080fd5b5035919050565b600080604083850312156122ab57600080fd5b82356122b68161213c565b915060208301356122c68161213c565b809150509250929050565b634e487b7160e01b600052601160045260246000fd5b60008261230457634e487b7160e01b600052601260045260246000fd5b500490565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b600181811c9082168061235257607f821691505b60208210810361237257634e487b7160e01b600052602260045260246000fd5b50919050565b60006020828403121561238a57600080fd5b5051919050565b6000602082840312156123a357600080fd5b81516116ec8161213c565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff811182821017156123ed576123ed6123ae565b604052919050565b60006020828403121561240757600080fd5b815167ffffffffffffffff8082111561241f57600080fd5b818401915084601f83011261243357600080fd5b815181811115612445576124456123ae565b612458601f8201601f19166020016123c4565b915080825285602082850101111561246f57600080fd5b61248081602084016020860161219e565b50949350505050565b600181815b808511156124c45781600019048211156124aa576124aa6122d1565b808516156124b757918102915b93841c939080029061248e565b509250929050565b6000826124db57506001610b00565b816124e857506000610b00565b81600181146124fe576002811461250857612524565b6001915050610b00565b60ff841115612519576125196122d1565b50506001821b610b00565b5060208310610133831016604e8410600b8410161715612547575081810a610b00565b6125518383612489565b8060001904821115612565576125656122d1565b029392505050565b60006116ec60ff8416836124cc565b8082028115828204841417610b0057610b006122d1565b80820182811260008312801582168215821617156125b3576125b36122d1565b505092915050565b80820180821115610b0057610b006122d1565b6000600182016125e0576125e06122d1565b5060010190565b634e487b7160e01b600052603260045260246000fd5b81810381811115610b0057610b006122d1565b8181036000831280158383131683831282161715611c9a57611c9a6122d1565b600060808201868352602060808185015281875180845260a086019150828901935060005b8181101561267a5784516001600160a01b031683529383019391830191600101612655565b50506001600160a01b039690961660408501525050506060015292915050565b600060208083850312156126ad57600080fd5b825167ffffffffffffffff808211156126c557600080fd5b818501915085601f8301126126d957600080fd5b8151818111156126eb576126eb6123ae565b8060051b91506126fc8483016123c4565b818152918301840191848101908884111561271657600080fd5b938501935b838510156127345784518252938501939085019061271b565b9897505050505050505056fe45524332303a206275726e20616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa264697066735822122051b28a4c13c7255c8ea54ca334f72461e27e557ba878d517f4dc7abab70287f864736f6c63430008130033

Deployed Bytecode

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

Libraries Used

IterableMapping : 0xa3686b5fa3c5f6eb2da4a29a677d61a6ed62eb39Unverified

Deployed Bytecode Sourcemap

49465:7250:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26543:21;:19;:21::i;:::-;49465:7250;;;;;26581:411;;;:::i;50744:507::-;;;;;;;;;;-1:-1:-1;50744:507:0;;;;;:::i;:::-;;:::i;4550:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6716:169;;;;;;;;;;-1:-1:-1;6716:169:0;;;;;:::i;:::-;;:::i;:::-;;;1776:14:1;;1769:22;1751:41;;1739:2;1724:18;6716:169:0;1611:187:1;51876:120:0;;;;;;;;;;-1:-1:-1;51961:15:0;:27;51876:120;;;1949:25:1;;;1937:2;1922:18;51876:120:0;1803:177:1;5669:108:0;;;;;;;;;;-1:-1:-1;5757:12:0;;5669:108;;49810:49;;;;;;;;;;-1:-1:-1;49810:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;7367:355;;;;;;;;;;-1:-1:-1;7367:355:0;;;;;:::i;:::-;;:::i;30481:253::-;;;;;;;;;;-1:-1:-1;30481:253:0;;;;;:::i;:::-;;:::i;49706:33::-;;;;;;;;;;;;;;;;5512:92;;;;;;;;;;-1:-1:-1;5512:92:0;;5595:1;2840:36:1;;2828:2;2813:18;5512:92:0;2698:184:1;8131:218:0;;;;;;;;;;-1:-1:-1;8131:218:0;;;;;:::i;:::-;;:::i;49748:53::-;;;;;;;;;;-1:-1:-1;49748:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;53632:542;;;;;;;;;;-1:-1:-1;53632:542:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3429:32:1;;;3411:51;;3493:2;3478:18;;3471:34;;;;3521:18;;;3514:34;;;;3579:2;3564:18;;3557:34;;;;3622:3;3607:19;;3600:35;3449:3;3651:19;;3644:35;3710:3;3695:19;;3688:35;3754:3;3739:19;;3732:35;3398:3;3383:19;53632:542:0;3072:701:1;49868:24:0;;;;;;;;;;;;;;;;5840:127;;;;;;;;;;-1:-1:-1;5840:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;5941:18:0;5914:7;5941:18;;;;;;;;;;;;5840:127;20510:148;;;;;;;;;;;;;:::i;52004:131::-;;;;;;;;;;;;;:::i;26121:40::-;;;;;;;;;;;;;;;;28434:101;;;;;;;;;;-1:-1:-1;28434:101:0;;;;;:::i;:::-;;:::i;19868:79::-;;;;;;;;;;-1:-1:-1;19933:6:0;;-1:-1:-1;;;;;19933:6:0;19868:79;;;-1:-1:-1;;;;;3942:32:1;;;3924:51;;3912:2;3897:18;19868:79:0;3778:203:1;29155:128:0;;;;;;;;;;-1:-1:-1;29155:128:0;;;;;:::i;:::-;;:::i;4769:104::-;;;;;;;;;;;;;:::i;50590:146::-;;;;;;;;;;-1:-1:-1;50590:146:0;;;;;:::i;:::-;;:::i;8852:269::-;;;;;;;;;;-1:-1:-1;8852:269:0;;;;;:::i;:::-;;:::i;29502:172::-;;;;;;;;;;-1:-1:-1;29502:172:0;;;;;:::i;:::-;;:::i;6180:175::-;;;;;;;;;;-1:-1:-1;6180:175:0;;;;;:::i;:::-;;:::i;29895:133::-;;;;;;;;;;-1:-1:-1;29895:133:0;;;;;:::i;:::-;-1:-1:-1;;;;;29994:26:0;29969:7;29994:26;;;:18;:26;;;;;;;29895:133;56315:397;;;;;;;;;;-1:-1:-1;56315:397:0;;;;;:::i;:::-;;:::i;49899:46::-;;;;;;;;;;;;;;;;6418:151;;;;;;;;;;-1:-1:-1;6418:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;6534:18:0;;;6507:7;6534:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;6418:151;54424:491;;;;;;;;;;-1:-1:-1;54424:491:0;;;;;:::i;:::-;;:::i;51759:109::-;;;;;;;;;;-1:-1:-1;51842:18:0;;51759:109;;51259:492;;;;;;;;;;-1:-1:-1;51259:492:0;;;;;:::i;:::-;;:::i;20813:244::-;;;;;;;;;;-1:-1:-1;20813:244:0;;;;;:::i;:::-;;:::i;25004:26::-;;;;;;;;;;-1:-1:-1;25004:26:0;;;;-1:-1:-1;;;;;25004:26:0;;;24978:21;;;;;;;;;;-1:-1:-1;24978:21:0;;;;-1:-1:-1;;;;;24978:21:0;;;52143:1481;;;;;;;;;;-1:-1:-1;52143:1481:0;;;;;:::i;:::-;;:::i;54923:1384::-;;;;;;;;;;-1:-1:-1;54923:1384:0;;;;;:::i;:::-;;:::i;:::-;;;;5133:25:1;;;5189:2;5174:18;;5167:34;;;;5217:18;;;5210:34;5121:2;5106:18;54923:1384:0;4931:319:1;26581:411:0;26669:1;26653:13;5757:12;;;5669:108;26653:13;:17;26645:26;;;;;;26686:9;:13;26682:303;;26740:95;26811:13;5757:12;;;5669:108;26811:13;26782:26;26783:9;-1:-1:-1;;;26782:15:0;:26::i;:::-;:42;;;;:::i;:::-;26740:25;;;:29;:95::i;:::-;26712:25;:123;26851:43;;26884:9;1949:25:1;;26872:10:0;;26851:43;;1937:2:1;1922:18;26851:43:0;;;;;;;26935:25;;:40;;26965:9;26935:29;:40::i;:::-;26907:25;:68;26682:303;26581:411::o;50744:507::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;50841:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;:39;::::1;;:30;::::0;;::::1;:39;;::::0;50833:48:::1;;;::::0;::::1;;-1:-1:-1::0;;;;;50892:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:38;;-1:-1:-1;;50892:38:0::1;::::0;::::1;;::::0;;::::1;::::0;;;-1:-1:-1;50945:13:0;50941:251:::1;;50975:23;50987:7;50996:1;50975:11;:23::i;:::-;51013:31;::::0;-1:-1:-1;;;51013:31:0;;:15:::1;:31;::::0;::::1;6174:25:1::0;-1:-1:-1;;;;;6235:32:1;;6215:18;;;6208:60;51013:22:0::1;::::0;::::1;::::0;6147:18:1;;51013:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;50941:251;;;51077:40;51089:7;51098:18;51108:7;-1:-1:-1::0;;;;;5941:18:0;5914:7;5941:18;;;;;;;;;;;;5840:127;51098:18:::1;51077:11;:40::i;:::-;51132:19;;:15;51152:7:::0;51161:18:::1;51152:7:::0;-1:-1:-1;;;;;5941:18:0;5914:7;5941:18;;;;;;;;;;;;5840:127;51161:18:::1;51132:48;::::0;-1:-1:-1;;;;;;51132:48:0::1;::::0;;;;;;::::1;::::0;::::1;6511:25:1::0;;;;-1:-1:-1;;;;;6572:32:1;;;6552:18;;;6545:60;6621:18;;;6614:34;6484:18;;51132:48:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;50941:251;51228:7;-1:-1:-1::0;;;;;51207:36:0::1;;51237:5;51207:36;;;;1776:14:1::0;1769:22;1751:41;;1739:2;1724:18;;1611:187;51207:36:0::1;;;;;;;;50744:507:::0;;:::o;4550:100::-;4604:13;4637:5;4630:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4550:100;:::o;6716:169::-;6799:4;6816:39;174:10;6839:7;6848:6;6816:8;:39::i;:::-;-1:-1:-1;6873:4:0;6716:169;;;;;:::o;7367:355::-;7507:4;7524:36;7534:6;7542:9;7553:6;7524:9;:36::i;:::-;7571:121;7580:6;174:10;7602:89;7640:6;7602:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;7602:19:0;;;;;;:11;:19;;;;;;;;174:10;7602:33;;;;;;;;;;:37;:89::i;:::-;7571:8;:121::i;:::-;-1:-1:-1;7710:4:0;7367:355;;;;;:::o;30481:253::-;-1:-1:-1;;;;;30661:36:0;;30558:7;30661:36;;;:28;:36;;;;;;;;;5941:18;;;;;;;30583:25;;-1:-1:-1;;;24965:6:0;30583:131;;:115;;:63;;:48;;:25;:29;:48::i;:::-;:61;:63::i;:::-;:77;;:115::i;:::-;:129;:131::i;:::-;:143;;;;:::i;8131:218::-;174:10;8219:4;8268:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;8268:34:0;;;;;;;;;;8219:4;;8236:83;;8259:7;;8268:50;;8307:10;8268:38;:50::i;53632:542::-;53736:7;53758:6;53779;53800:7;53822;53844;53866;53888;53936:15;:20;;;;:22;;;;;;;;;;;;;1949:25:1;;1937:2;1922:18;;1803:177;53936:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53927:5;:31;53923:138;;-1:-1:-1;53983:42:0;;-1:-1:-1;;;54027:2:0;-1:-1:-1;54027:2:0;;-1:-1:-1;53983:42:0;;-1:-1:-1;53983:42:0;;-1:-1:-1;53983:42:0;;-1:-1:-1;53983:42:0;;-1:-1:-1;53983:42:0;53975:74;;53923:138;54091:36;;-1:-1:-1;;;54091:36:0;;:15;:36;;;7649:25:1;7690:18;;;7683:34;;;54073:15:0;;54091:29;;;;7622:18:1;;54091:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54073:54;;54147:19;54158:7;54147:10;:19::i;:::-;54140:26;;;;;;;;;;;;;;;;;53632:542;;;;;;;;;;:::o;20510:148::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;20601:6:::1;::::0;20580:40:::1;::::0;20617:1:::1;::::0;-1:-1:-1;;;;;20601:6:0::1;::::0;20580:40:::1;::::0;20617:1;;20580:40:::1;20631:6;:19:::0;;-1:-1:-1;;;;;;20631:19:0::1;::::0;;20510:148::o;52004:131::-;52108:11;;52093:34;;;-1:-1:-1;;;52093:34:0;;;;52060:13;;-1:-1:-1;;;;;52108:11:0;;52093:32;;:34;;;;;52108:11;;52093:34;;;;;;;52108:11;52093:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52093:34:0;;;;;;;;;;;;:::i;:::-;52086:41;;52004:131;:::o;28434:101::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;28505:11:::1;:22:::0;;-1:-1:-1;;;;;;28505:22:0::1;-1:-1:-1::0;;;;;28505:22:0;;;::::1;::::0;;;::::1;::::0;;28434:101::o;29155:128::-;29220:7;29245:30;29268:6;29245:22;:30::i;4769:104::-;4825:13;4858:7;4851:14;;;;;:::i;50590:146::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;50714:14:::1;5595:1:::0;50714:2:::1;:14;:::i;:::-;50705:23;::::0;:6;:23:::1;:::i;:::-;50671:31;:57:::0;-1:-1:-1;50590:146:0:o;8852:269::-;8945:4;8962:129;174:10;8985:7;8994:96;9033:15;8994:96;;;;;;;;;;;;;;;;;174:10;8994:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;8994:34:0;;;;;;;;;;;;:38;:96::i;29502:172::-;-1:-1:-1;;;;;29639:26:0;;29579:7;29639:26;;;:18;:26;;;;;;29604:62;;:30;29658:6;29604:22;:30::i;:::-;:34;;:62::i;6180:175::-;6266:4;6283:42;174:10;6307:9;6318:6;6283:9;:42::i;56315:397::-;20080:6;;56433:4;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;56455:14:::1;56472:32;56496:7;56472:23;:32::i;:::-;56455:49:::0;-1:-1:-1;56521:10:0;;56517:163:::1;;-1:-1:-1::0;;;;;56548:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;56574:15:::1;56548:41:::0;;56609:33;;::::1;;::::0;56548:23;56609:33:::1;::::0;::::1;::::0;56624:6;1949:25:1;;1937:2;1922:18;;1803:177;56609:33:0::1;;;;;;;;56664:4;56657:11;;;;;56517:163;-1:-1:-1::0;56699:5:0::1;::::0;56315:397;-1:-1:-1;;;56315:397:0:o;54424:491::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;54513:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;54560:7;54509:69;54608:31;;54594:10;:45;54590:267;;54656:32;54668:7;54677:10;54656:11;:32::i;:::-;54703:40;::::0;-1:-1:-1;;;54703:40:0;;:15:::1;:40;::::0;::::1;6511:25:1::0;-1:-1:-1;;;;;6572:32:1;;6552:18;;;6545:60;6621:18;;;6614:34;;;54703:19:0::1;::::0;::::1;::::0;6484:18:1;;54703:40:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;54590:267;;;54776:23;54788:7;54797:1;54776:11;:23::i;:::-;54814:31;::::0;-1:-1:-1;;;54814:31:0;;:15:::1;:31;::::0;::::1;6174:25:1::0;-1:-1:-1;;;;;6235:32:1;;6215:18;;;6208:60;54814:22:0::1;::::0;::::1;::::0;6147:18:1;;54814:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;54590:267;54869:38;54892:7;54902:4;54869:14;:38::i;:::-;;20150:1;54424:491:::0;;:::o;51259:492::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;51374:4:::1;51358:12;:20;;:45;;;;;51398:5;51382:12;:21;;51358:45;51336:169;;;::::0;-1:-1:-1;;;51336:169:0;;10878:2:1;51336:169:0::1;::::0;::::1;10860:21:1::0;10917:2;10897:18;;;10890:30;10956:34;10936:18;;;10929:62;11027:34;11007:18;;;11000:62;-1:-1:-1;;;11078:19:1;;;11071:41;11129:19;;51336:169:0::1;10676:478:1::0;51336:169:0::1;51554:9;;51538:12;:25:::0;51516:135:::1;;;::::0;-1:-1:-1;;;51516:135:0;;11361:2:1;51516:135:0::1;::::0;::::1;11343:21:1::0;11400:2;11380:18;;;11373:30;11439:34;11419:18;;;11412:62;11510:30;11490:18;;;11483:58;11558:19;;51516:135:0::1;11159:424:1::0;51516:135:0::1;51698:9;::::0;51667:41:::1;::::0;51684:12;;51667:41:::1;::::0;;;::::1;51719:9;:24:::0;51259:492::o;20813:244::-;20080:6;;-1:-1:-1;;;;;20080:6:0;174:10;20080:22;20072:67;;;;-1:-1:-1;;;20072:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20902:22:0;::::1;20894:73;;;::::0;-1:-1:-1;;;20894:73:0;;11790:2:1;20894:73:0::1;::::0;::::1;11772:21:1::0;11829:2;11809:18;;;11802:30;11868:34;11848:18;;;11841:62;-1:-1:-1;;;11919:18:1;;;11912:36;11965:19;;20894:73:0::1;11588:402:1::0;20894:73:0::1;21004:6;::::0;20983:38:::1;::::0;-1:-1:-1;;;;;20983:38:0;;::::1;::::0;21004:6:::1;::::0;20983:38:::1;::::0;21004:6:::1;::::0;20983:38:::1;21032:6;:17:::0;;-1:-1:-1;;;;;;21032:17:0::1;-1:-1:-1::0;;;;;21032:17:0;;;::::1;::::0;;;::::1;::::0;;20813:244::o;52143:1481::-;52604:38;;-1:-1:-1;;;52604:38:0;;:15;:38;;;6174:25:1;-1:-1:-1;;;;;6235:32:1;;6215:18;;;6208:60;52575:8:0;;52243:15;;;;;;;;;;;;;;52604:29;;;;6147:18:1;;52604:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52596:46;;-1:-1:-1;;52655:29:0;;52710:1;52701:5;:10;52697:517;;52749:18;;52740:5;52732:35;52728:475;;;52832:18;;52815:37;;:5;;:9;:37::i;:::-;52788:64;;52728:475;;;52979:18;;52928:15;:27;52893:32;;-1:-1:-1;52928:169:0;;53096:1;52928:169;;;53053:18;;53021:15;:27;:51;;:31;:51::i;:::-;52893:204;-1:-1:-1;53145:42:0;52893:204;53145:5;:42;:::i;:::-;53118:69;;52874:329;52728:475;53250:31;53273:7;53250:22;:31::i;:::-;53226:55;;53309:31;53332:7;53309:22;:31::i;:::-;-1:-1:-1;;;;;53369:23:0;;;;;;:14;:23;;;;;;53292:48;;-1:-1:-1;53369:23:0;-1:-1:-1;53421:17:0;:51;;53471:1;53421:51;;;53458:9;;53441:27;;:13;:27;:::i;:::-;53405:67;;53534:15;53518:13;:31;:98;;53615:1;53518:98;;;53565:34;:13;53583:15;53565:17;:34::i;:::-;53485:131;;52143:1481;;;;;;;;;:::o;54923:1384::-;55111:15;:27;55001:7;;;;;;55155:25;;;55151:91;;-1:-1:-1;;55211:18:0;;55205:1;;-1:-1:-1;55205:1:0;;-1:-1:-1;55197:33:0;;55151:91;55284:18;;55254:27;;55365:9;55347:27;;55387:18;55420:14;55451:736;55468:3;55458:7;:13;:50;;;;;55488:20;55475:10;:33;55458:50;55451:736;;;55525:21;;;;:::i;:::-;55590:15;:27;55525:21;;-1:-1:-1;55567:50:0;;;-1:-1:-1;55563:114:0;;55660:1;55638:23;;55563:114;55693:15;55711;:20;;55732:19;55711:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;55711:41:0;55786:23;;;:14;:23;;;;;;;;55711:41;;-1:-1:-1;55773:37:0;;:12;:37::i;:::-;55769:172;;;55835:38;55858:7;55868:4;55835:14;:38::i;:::-;55831:95;;;55898:8;;;;:::i;:::-;;;;55831:95;55957:12;;;;:::i;:::-;;;;55986:18;56007:9;55986:30;;56047:10;56037:7;:20;56033:106;;;56099:23;:7;56111:10;56099:11;:23::i;:::-;56088:35;;:7;:35;:::i;:::-;56078:45;;56033:106;56165:10;-1:-1:-1;55451:736:0;;-1:-1:-1;55451:736:0;;56199:18;:40;;;56260:10;;-1:-1:-1;56272:6:0;-1:-1:-1;56220:19:0;;-1:-1:-1;;;;54923:1384:0;;;;;;:::o;14115:471::-;14173:7;14418:1;14423;14418:6;14414:47;;-1:-1:-1;14448:1:0;14441:8;;14414:47;14473:9;14485:5;14489:1;14485;:5;:::i;:::-;14473:17;-1:-1:-1;14518:1:0;14509:5;14513:1;14473:17;14509:5;:::i;:::-;:10;14501:56;;;;-1:-1:-1;;;14501:56:0;;13008:2:1;14501:56:0;;;12990:21:1;13047:2;13027:18;;;13020:30;13086:34;13066:18;;;13059:62;-1:-1:-1;;;13137:18:1;;;13130:31;13178:19;;14501:56:0;12806:397:1;14501:56:0;14577:1;14115:471;-1:-1:-1;;;14115:471:0:o;12761:181::-;12819:7;;12851:5;12855:1;12851;:5;:::i;:::-;12839:17;;12880:1;12875;:6;;12867:46;;;;-1:-1:-1;;;12867:46:0;;13410:2:1;12867:46:0;;;13392:21:1;13449:2;13429:18;;;13422:30;13488:29;13468:18;;;13461:57;13535:18;;12867:46:0;13208:351:1;32509:452:0;-1:-1:-1;;;;;5941:18:0;;32585:22;5941:18;;;;;;;;;;;32642:27;;;32639:315;;;32682:26;32711:30;:10;32726:14;32711;:30::i;:::-;32682:59;;32752:45;32769:7;32778:18;32752:16;:45::i;:::-;32671:136;32639:315;;;32829:14;32816:10;:27;32813:141;;;32856:18;32877:30;:14;32896:10;32877:18;:30::i;:::-;32856:51;;32918:26;32924:7;32933:10;32918:5;:26::i;:::-;32845:109;32576:385;32509:452;;:::o;11978:380::-;-1:-1:-1;;;;;12114:19:0;;12106:68;;;;-1:-1:-1;;;12106:68:0;;13766:2:1;12106:68:0;;;13748:21:1;13805:2;13785:18;;;13778:30;13844:34;13824:18;;;13817:62;-1:-1:-1;;;13895:18:1;;;13888:34;13939:19;;12106:68:0;13564:400:1;12106:68:0;-1:-1:-1;;;;;12193:21:0;;12185:68;;;;-1:-1:-1;;;12185:68:0;;14171:2:1;12185:68:0;;;14153:21:1;14210:2;14190:18;;;14183:30;14249:34;14229:18;;;14222:62;-1:-1:-1;;;14300:18:1;;;14293:32;14342:19;;12185:68:0;13969:398:1;12185:68:0;-1:-1:-1;;;;;12266:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;12318:32;;1949:25:1;;;12318:32:0;;1922:18:1;12318:32:0;;;;;;;11978:380;;;:::o;50399:183::-;50513:61;;-1:-1:-1;;;50513:61:0;;14574:2:1;50513:61:0;;;14556:21:1;14613:2;14593:18;;;14586:30;14652:34;14632:18;;;14625:62;-1:-1:-1;;;14703:18:1;;;14696:41;14754:19;;50513:61:0;14372:407:1;13664:192:0;13750:7;13786:12;13778:6;;;;13770:29;;;;-1:-1:-1;;;13770:29:0;;;;;;;;:::i;:::-;-1:-1:-1;13810:9:0;13822:5;13826:1;13822;:5;:::i;:::-;13810:17;13664:192;-1:-1:-1;;;;;13664:192:0:o;19235:134::-;19291:6;19324:1;19341:6;;;;19333:15;;;;;18571:176;18627:6;;18657:5;18661:1;18657;:5;:::i;:::-;18646:16;;18687:1;18682;:6;;:16;;;;;18697:1;18692;:6;;18682:16;18681:38;;;;18708:1;18704;:5;:14;;;;;18717:1;18713;:5;18704:14;18673:47;;;;;18976:127;19032:7;19065:1;19060;:6;;19052:15;;;;;;-1:-1:-1;19093:1:0;18976:127::o;13225:136::-;13283:7;13310:43;13314:1;13317;13310:43;;;;;;;;;;;;;;;;;:3;:43::i;27167:1255::-;27240:7;27260:29;27292:28;27315:4;27292:22;:28::i;:::-;27260:60;-1:-1:-1;27335:25:0;;27331:1065;;-1:-1:-1;;;;;27404:24:0;;;;;;:18;:24;;;;;;:51;;27433:21;27404:28;:51::i;:::-;-1:-1:-1;;;;;27377:24:0;;;;;;:18;:24;;;;;;;:78;;;;27475:46;;;;;;27499:21;1949:25:1;;1937:2;1922:18;;1803:177;27475:46:0;;;;;;;;27554:6;;;;;;;;;-1:-1:-1;;;;;27554:6:0;-1:-1:-1;;;;;27554:11:0;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27539:11;;-1:-1:-1;;;;;27539:11:0;;;:28;;;27536:806;;27588:12;27604:50;27626:4;27632:21;27604;:50::i;:::-;27587:67;;27677:7;27673:346;;27710:18;27733:4;-1:-1:-1;;;;;27733:9:0;27750:21;27778:4;27733:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27709:78;;;27814:13;27810:183;;-1:-1:-1;;;;;27883:24:0;;;;;;:18;:24;;;;;;:51;;27912:21;27883:28;:51::i;:::-;-1:-1:-1;;;;;27856:24:0;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;27856:24:0;;27167:1255;-1:-1:-1;;;27167:1255:0:o;27810:183::-;27686:333;27673:346;27568:466;27536:806;;;28072:12;28089:4;-1:-1:-1;;;;;28089:9:0;28106:21;28134:4;28089:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28071:72;;;28166:7;28162:165;;-1:-1:-1;;;;;28225:24:0;;;;;;:18;:24;;;;;;:51;;28254:21;28225:28;:51::i;:::-;-1:-1:-1;;;;;28198:24:0;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;28198:24:0;;27167:1255;-1:-1:-1;;27167:1255:0:o;28162:165::-;28052:290;28363:21;27167:1255;-1:-1:-1;;27167:1255:0:o;27331:1065::-;-1:-1:-1;28413:1:0;;27167:1255;-1:-1:-1;;27167:1255:0:o;18307:176::-;18363:6;;18393:5;18397:1;18393;:5;:::i;:::-;18382:16;;18423:1;18418;:6;;:16;;;;;18433:1;18428;:6;;18418:16;18417:38;;;;18444:1;18440;:5;:14;;;;;18453:1;18449;:5;18409:47;;;;;54182:234;54249:4;54286:15;54270:13;:31;54266:76;;;-1:-1:-1;54325:5:0;;54182:234;-1:-1:-1;54182:234:0:o;54266:76::-;54399:9;;54361:34;:15;54381:13;54361:19;:34::i;:::-;:47;;;54182:234;-1:-1:-1;;54182:234:0:o;31658:290::-;31743:38;31766:7;31775:5;31743:22;:38::i;:::-;31832:108;31885:53;31886:36;31916:5;31886:25;;:29;;:36;;;;:::i;31885:53::-;-1:-1:-1;;;;;31832:37:0;;;;;;:28;:37;;;;;;;:51;:108::i;:::-;-1:-1:-1;;;;;31792:37:0;;;;;;;:28;:37;;;;;:148;;;;-1:-1:-1;31658:290:0:o;32233:268::-;32307:27;32319:7;32328:5;32307:11;:27::i;:::-;32385:108;32438:53;32439:36;32469:5;32439:25;;:29;;:36;;;;:::i;32438:53::-;-1:-1:-1;;;;;32385:37:0;;;;;;:28;:37;;;;;;;:51;:108::i;28545:391::-;28664:16;;;28678:1;28664:16;;;;;;;;28621:4;;;;28664:16;28678:1;28664:16;;;;;;;;-1:-1:-1;;28703:6:0;;:13;;;-1:-1:-1;;;28703:13:0;;;;28640:40;;-1:-1:-1;;;;;;28703:6:0;;;;:11;;-1:-1:-1;28703:13:0;;;;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;28693:4;28698:1;28693:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;28693:23:0;;;:7;;;;;;;;;:23;28739:11;;28729:7;;28739:11;;;28729:4;;28739:11;;28729:7;;;;;;:::i;:::-;-1:-1:-1;;;;;28729:21:0;;;:7;;;;;;;;;:21;28769:6;;;:28;28805:3;28769:6;28813:4;28819;28825:19;:15;28843:1;28825:19;:::i;:::-;28769:76;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;28769:76:0;;;;;;;;;;;;:::i;:::-;;;28765:164;;28912:5;28905:12;;;;;28765:164;;28867:4;28860:11;;;;;10394:395;-1:-1:-1;;;;;10489:21:0;;10481:71;;;;-1:-1:-1;;;10481:71:0;;17388:2:1;10481:71:0;;;17370:21:1;17427:2;17407:18;;;17400:30;17466:34;17446:18;;;17439:62;-1:-1:-1;;;17517:18:1;;;17510:35;17562:19;;10481:71:0;17186:401:1;10481:71:0;10565:49;10594:1;10598:7;10607:6;10565:20;:49::i;:::-;10642:12;;:24;;10659:6;10642:16;:24::i;:::-;10627:12;:39;-1:-1:-1;;;;;10698:18:0;;:9;:18;;;;;;;;;;;:30;;10721:6;10698:22;:30::i;:::-;-1:-1:-1;;;;;10677:18:0;;:9;:18;;;;;;;;;;;:51;;;;10744:37;;1949:25:1;;;10677:18:0;;:9;;10744:37;;1922:18:1;10744:37:0;;;;;;;;10394:395;;:::o;11122:418::-;-1:-1:-1;;;;;11206:21:0;;11198:67;;;;-1:-1:-1;;;11198:67:0;;17794:2:1;11198:67:0;;;17776:21:1;17833:2;17813:18;;;17806:30;17872:34;17852:18;;;17845:62;-1:-1:-1;;;17923:18:1;;;17916:31;17964:19;;11198:67:0;17592:397:1;11198:67:0;11278:49;11299:7;11316:1;11320:6;11278:20;:49::i;:::-;11361:68;11384:6;11361:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11361:18:0;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;11340:18:0;;:9;:18;;;;;;;;;;:89;11455:12;;:24;;11472:6;11455:16;:24::i;:::-;11440:12;:39;11495:37;;1949:25:1;;;11521:1:0;;-1:-1:-1;;;;;11495:37:0;;;;;1937:2:1;1922:18;11495:37:0;1803:177:1;14:131;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:160::-;215:20;;271:13;;264:21;254:32;;244:60;;300:1;297;290:12;244:60;150:160;;;:::o;315:315::-;380:6;388;441:2;429:9;420:7;416:23;412:32;409:52;;;457:1;454;447:12;409:52;496:9;483:23;515:31;540:5;515:31;:::i;:::-;565:5;-1:-1:-1;589:35:1;620:2;605:18;;589:35;:::i;:::-;579:45;;315:315;;;;;:::o;635:250::-;720:1;730:113;744:6;741:1;738:13;730:113;;;820:11;;;814:18;801:11;;;794:39;766:2;759:10;730:113;;;-1:-1:-1;;877:1:1;859:16;;852:27;635:250::o;890:396::-;1039:2;1028:9;1021:21;1002:4;1071:6;1065:13;1114:6;1109:2;1098:9;1094:18;1087:34;1130:79;1202:6;1197:2;1186:9;1182:18;1177:2;1169:6;1165:15;1130:79;:::i;:::-;1270:2;1249:15;-1:-1:-1;;1245:29:1;1230:45;;;;1277:2;1226:54;;890:396;-1:-1:-1;;890:396:1:o;1291:315::-;1359:6;1367;1420:2;1408:9;1399:7;1395:23;1391:32;1388:52;;;1436:1;1433;1426:12;1388:52;1475:9;1462:23;1494:31;1519:5;1494:31;:::i;:::-;1544:5;1596:2;1581:18;;;;1568:32;;-1:-1:-1;;;1291:315:1:o;1985:247::-;2044:6;2097:2;2085:9;2076:7;2072:23;2068:32;2065:52;;;2113:1;2110;2103:12;2065:52;2152:9;2139:23;2171:31;2196:5;2171:31;:::i;2237:456::-;2314:6;2322;2330;2383:2;2371:9;2362:7;2358:23;2354:32;2351:52;;;2399:1;2396;2389:12;2351:52;2438:9;2425:23;2457:31;2482:5;2457:31;:::i;:::-;2507:5;-1:-1:-1;2564:2:1;2549:18;;2536:32;2577:33;2536:32;2577:33;:::i;:::-;2237:456;;2629:7;;-1:-1:-1;;;2683:2:1;2668:18;;;;2655:32;;2237:456::o;2887:180::-;2946:6;2999:2;2987:9;2978:7;2974:23;2970:32;2967:52;;;3015:1;3012;3005:12;2967:52;-1:-1:-1;3038:23:1;;2887:180;-1:-1:-1;2887:180:1:o;4314:388::-;4382:6;4390;4443:2;4431:9;4422:7;4418:23;4414:32;4411:52;;;4459:1;4456;4449:12;4411:52;4498:9;4485:23;4517:31;4542:5;4517:31;:::i;:::-;4567:5;-1:-1:-1;4624:2:1;4609:18;;4596:32;4637:33;4596:32;4637:33;:::i;:::-;4689:7;4679:17;;;4314:388;;;;;:::o;5255:127::-;5316:10;5311:3;5307:20;5304:1;5297:31;5347:4;5344:1;5337:15;5371:4;5368:1;5361:15;5387:217;5427:1;5453;5443:132;;5497:10;5492:3;5488:20;5485:1;5478:31;5532:4;5529:1;5522:15;5560:4;5557:1;5550:15;5443:132;-1:-1:-1;5589:9:1;;5387:217::o;5609:356::-;5811:2;5793:21;;;5830:18;;;5823:30;5889:34;5884:2;5869:18;;5862:62;5956:2;5941:18;;5609:356::o;6659:380::-;6738:1;6734:12;;;;6781;;;6802:61;;6856:4;6848:6;6844:17;6834:27;;6802:61;6909:2;6901:6;6898:14;6878:18;6875:38;6872:161;;6955:10;6950:3;6946:20;6943:1;6936:31;6990:4;6987:1;6980:15;7018:4;7015:1;7008:15;6872:161;;6659:380;;;:::o;7256:184::-;7326:6;7379:2;7367:9;7358:7;7354:23;7350:32;7347:52;;;7395:1;7392;7385:12;7347:52;-1:-1:-1;7418:16:1;;7256:184;-1:-1:-1;7256:184:1:o;7728:251::-;7798:6;7851:2;7839:9;7830:7;7826:23;7822:32;7819:52;;;7867:1;7864;7857:12;7819:52;7899:9;7893:16;7918:31;7943:5;7918:31;:::i;7984:127::-;8045:10;8040:3;8036:20;8033:1;8026:31;8076:4;8073:1;8066:15;8100:4;8097:1;8090:15;8116:275;8187:2;8181:9;8252:2;8233:13;;-1:-1:-1;;8229:27:1;8217:40;;8287:18;8272:34;;8308:22;;;8269:62;8266:88;;;8334:18;;:::i;:::-;8370:2;8363:22;8116:275;;-1:-1:-1;8116:275:1:o;8396:719::-;8476:6;8529:2;8517:9;8508:7;8504:23;8500:32;8497:52;;;8545:1;8542;8535:12;8497:52;8578:9;8572:16;8607:18;8648:2;8640:6;8637:14;8634:34;;;8664:1;8661;8654:12;8634:34;8702:6;8691:9;8687:22;8677:32;;8747:7;8740:4;8736:2;8732:13;8728:27;8718:55;;8769:1;8766;8759:12;8718:55;8798:2;8792:9;8820:2;8816;8813:10;8810:36;;;8826:18;;:::i;:::-;8868:53;8911:2;8892:13;;-1:-1:-1;;8888:27:1;8917:2;8884:36;8868:53;:::i;:::-;8855:66;;8944:2;8937:5;8930:17;8984:7;8979:2;8974;8970;8966:11;8962:20;8959:33;8956:53;;;9005:1;9002;8995:12;8956:53;9018:67;9082:2;9077;9070:5;9066:14;9061:2;9057;9053:11;9018:67;:::i;:::-;-1:-1:-1;9104:5:1;8396:719;-1:-1:-1;;;;8396:719:1:o;9120:422::-;9209:1;9252:5;9209:1;9266:270;9287:7;9277:8;9274:21;9266:270;;;9346:4;9342:1;9338:6;9334:17;9328:4;9325:27;9322:53;;;9355:18;;:::i;:::-;9405:7;9395:8;9391:22;9388:55;;;9425:16;;;;9388:55;9504:22;;;;9464:15;;;;9266:270;;;9270:3;9120:422;;;;;:::o;9547:806::-;9596:5;9626:8;9616:80;;-1:-1:-1;9667:1:1;9681:5;;9616:80;9715:4;9705:76;;-1:-1:-1;9752:1:1;9766:5;;9705:76;9797:4;9815:1;9810:59;;;;9883:1;9878:130;;;;9790:218;;9810:59;9840:1;9831:10;;9854:5;;;9878:130;9915:3;9905:8;9902:17;9899:43;;;9922:18;;:::i;:::-;-1:-1:-1;;9978:1:1;9964:16;;9993:5;;9790:218;;10092:2;10082:8;10079:16;10073:3;10067:4;10064:13;10060:36;10054:2;10044:8;10041:16;10036:2;10030:4;10027:12;10023:35;10020:77;10017:159;;;-1:-1:-1;10129:19:1;;;10161:5;;10017:159;10208:34;10233:8;10227:4;10208:34;:::i;:::-;10278:6;10274:1;10270:6;10266:19;10257:7;10254:32;10251:58;;;10289:18;;:::i;:::-;10327:20;;9547:806;-1:-1:-1;;;9547:806:1:o;10358:140::-;10416:5;10445:47;10486:4;10476:8;10472:19;10466:4;10445:47;:::i;10503:168::-;10576:9;;;10607;;10624:15;;;10618:22;;10604:37;10594:71;;10645:18;;:::i;12183:216::-;12247:9;;;12275:11;;;12222:3;12305:9;;12333:10;;12329:19;;12358:10;;12350:19;;12326:44;12323:70;;;12373:18;;:::i;:::-;12323:70;;12183:216;;;;:::o;12404:125::-;12469:9;;;12490:10;;;12487:36;;;12503:18;;:::i;12534:135::-;12573:3;12594:17;;;12591:43;;12614:18;;:::i;:::-;-1:-1:-1;12661:1:1;12650:13;;12534:135::o;12674:127::-;12735:10;12730:3;12726:20;12723:1;12716:31;12766:4;12763:1;12756:15;12790:4;12787:1;12780:15;14784:128;14851:9;;;14872:11;;;14869:37;;;14886:18;;:::i;15127:200::-;15193:9;;;15166:4;15221:9;;15249:10;;15261:12;;;15245:29;15284:12;;;15276:21;;15242:56;15239:82;;;15301:18;;:::i;15332:908::-;15566:4;15614:3;15603:9;15599:19;15645:6;15634:9;15627:25;15671:2;15709:3;15704:2;15693:9;15689:18;15682:31;15733:6;15768;15762:13;15799:6;15791;15784:22;15837:3;15826:9;15822:19;15815:26;;15876:2;15868:6;15864:15;15850:29;;15897:1;15907:195;15921:6;15918:1;15915:13;15907:195;;;15986:13;;-1:-1:-1;;;;;15982:39:1;15970:52;;16077:15;;;;16042:12;;;;16018:1;15936:9;15907:195;;;-1:-1:-1;;;;;;;16158:32:1;;;;16153:2;16138:18;;16131:60;-1:-1:-1;;;16222:2:1;16207:18;16200:34;16119:3;15332:908;-1:-1:-1;;15332:908:1:o;16245:936::-;16340:6;16371:2;16414;16402:9;16393:7;16389:23;16385:32;16382:52;;;16430:1;16427;16420:12;16382:52;16463:9;16457:16;16492:18;16533:2;16525:6;16522:14;16519:34;;;16549:1;16546;16539:12;16519:34;16587:6;16576:9;16572:22;16562:32;;16632:7;16625:4;16621:2;16617:13;16613:27;16603:55;;16654:1;16651;16644:12;16603:55;16683:2;16677:9;16705:2;16701;16698:10;16695:36;;;16711:18;;:::i;:::-;16757:2;16754:1;16750:10;16740:20;;16780:28;16804:2;16800;16796:11;16780:28;:::i;:::-;16842:15;;;16912:11;;;16908:20;;;16873:12;;;;16940:19;;;16937:39;;;16972:1;16969;16962:12;16937:39;16996:11;;;;17016:135;17032:6;17027:3;17024:15;17016:135;;;17098:10;;17086:23;;17049:12;;;;17129;;;;17016:135;;;17170:5;16245:936;-1:-1:-1;;;;;;;;16245:936:1:o

Swarm Source

ipfs://51b28a4c13c7255c8ea54ca334f72461e27e557ba878d517f4dc7abab70287f8

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

Tools & Services