Token

REU_Dividen_Tracker (REU_Dividen_Tracker)

ERC-20

Overview

Max Total Supply

61,182,189.234960255628624121 REU_Dividen_Tracker

Holders

203

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x4be4a340ef0ce3cff90bb27fdb520e3261e5617f

Filtered by Token Holder

0xd157B7004B30c3F1e0c51216b987Fc37c5cB3624

Balance

63,596.32644 REU_Dividen_Tracker

Value

$0.00

0xd157B7004B30c3F1e0c51216b987Fc37c5cB3624

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:

BTCDividendTracker

Compiler Version

v0.8.14+commit.80d49f37

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-05-26
*/

// SPDX-License-Identifier: Unlicensed

pragma solidity 0.8.14;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. 
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;
    address private _previousOwner;
    uint256 private _lockTime;

    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 virtual 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;
    }
    
    //Locks the contract for owner for the amount of time provided

    function lock(uint256 time) public virtual onlyOwner {
        _previousOwner = _owner;
        _owner = address(0);
        _lockTime = block.timestamp + time;
        emit OwnershipTransferred(_owner, address(0));
    }
}

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

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

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

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

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

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

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

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}


/*
@title Dividend-Paying Token Interface
@author Roger Wu (https://github.com/roger-wu)
@dev An interface for a dividend-paying token contract.
*/
interface IDividendPayingToken {
  /// @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);

  /// @notice Distributes ether to token holders as dividends.
  /// @dev SHOULD distribute the paid ether to token holders as dividends.
  ///  SHOULD NOT directly transfer ether to token holders in this function.
  ///  MUST emit a `DividendsDistributed` event when the amount of distributed ether is greater than 0.
  function distributeDividends() external payable;

  /// @notice Withdraws the ether distributed to the sender.
  /// @dev SHOULD transfer `dividendOf(msg.sender)` wei to `msg.sender`, and `dividendOf(msg.sender)` SHOULD be 0 after the transfer.
  ///  MUST emit a `DividendWithdrawn` event if the amount of ether transferred is greater than 0.
  function withdrawDividend() external;

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

pragma solidity 0.8.14;


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


  /// @notice Withdraws the ether distributed to the sender.
  /// @dev SHOULD transfer `dividendOf(msg.sender)` wei to `msg.sender`, and `dividendOf(msg.sender)` SHOULD be 0 after the transfer.
  ///  MUST emit a `DividendWithdrawn` event if the amount of ether transferred is greater than 0.
  function withdrawDividend() external;

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

pragma solidity 0.8.14;

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

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

  address public rewardToken = address(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599); // WBTC
  
  uint256 constant internal magnitude = 2**128;

  uint256 internal magnifiedDividendPerShare;

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

  uint256 public totalDividendsDistributed;

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

  }


  function distributeDividends(uint256 amount) public onlyOwner{
    require(totalSupply() > 0);

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

      totalDividendsDistributed = totalDividendsDistributed.add(amount);
    }
  }

  /// @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 withdrawDividend() public virtual override {
    _withdrawDividendOfUser(payable(msg.sender));
  }

  /// @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);
      bool success = IERC20(rewardToken).transfer(user, _withdrawableDividend);

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

      return _withdrawableDividend;
    }

    return 0;
  }


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

  /// @dev Internal function that mints tokens to an account.
  /// 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 _mint(address account, uint256 value) internal override {
    super._mint(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 mintAmount = newBalance.sub(currentBalance);
      _mint(account, mintAmount);
    } else if(newBalance < currentBalance) {
      uint256 burnAmount = currentBalance.sub(newBalance);
      _burn(account, burnAmount);
    }
  }
}

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

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

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

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

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

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

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

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

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

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

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

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

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


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

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * 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);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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 with safety checks that revert on error
 * @dev SafeMath adapted for int256
 * Based on code of  https://github.com/RequestNetwork/requestNetwork/blob/master/packages/requestNetworkSmartContracts/contracts/base/math/SafeMathInt.sol
 */
library SafeMathInt {
  function mul(int256 a, int256 b) internal pure returns (int256) {
    // Prevent overflow when multiplying INT256_MIN with -1
    // https://github.com/RequestNetwork/requestNetwork/issues/43
    require(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1));

    int256 c = a * b;
    require((b == 0) || (c / b == a));
    return c;
  }

  function div(int256 a, int256 b) internal pure returns (int256) {
    // Prevent overflow when dividing INT256_MIN by -1
    // https://github.com/RequestNetwork/requestNetwork/issues/43
    require(!(a == - 2**255 && b == -1) && (b > 0));

    return a / b;
  }

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

    return a - b;
  }

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

  function 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 LockToken is Ownable {
    bool public isOpen = false;
    mapping(address => bool) private _whiteList;
    modifier open(address from, address to) {
        require(isOpen || _whiteList[from] || _whiteList[to], "Not Open");
        _;
    }

    constructor() {
        _whiteList[msg.sender] = true;
        _whiteList[address(this)] = true;
    }

    function openTrade() external onlyOwner {
        isOpen = true;
    }

    function includeToWhiteList(address[] memory _users) external onlyOwner {
        for(uint8 i = 0; i < _users.length; i++) {
            _whiteList[_users[i]] = true;
        }
    }
}


contract REU is ERC20, Ownable, LockToken {
    using SafeMath for uint256;

    IUniswapV2Router02 public uniswapV2Router;
    address public  uniswapV2Pair;

    bool private swapping;

    BTCDividendTracker public dividendTracker;

    address public deadWallet = 0x000000000000000000000000000000000000dEaD;

    address public rewardToken = address(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599); // WBTC

    uint256 public maxBuyTransactionAmount = 77000000 * (10**18);
    uint256 public maxSellTransactionAmount = 77000000 * (10**18);
    uint256 public swapTokensAtAmount = 1000000 * (10**18);

    uint256 public rewardFee = 1; 
    uint256 public liquidityFee = 1; 
    uint256 public marketingFee = 4; 
    uint256 public buybackFee = 2; 
    uint256 public totalFees = rewardFee.add(liquidityFee).add(marketingFee).add(buybackFee);

    address payable public _marketingWalletAddress = payable(0x1c66e2ebfbB889cAf31BA29F1A20842813374da7);
    address payable public _buybackWalletAddress = payable(0x5D41234b36D82f5A39AC5BC0FC8Ed83bd2B5dFc0);


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

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


    // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
    // could be subject to a maximum transfer amount
    mapping (address => bool) public automatedMarketMakerPairs;

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

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

    event ExcludeFromFees(address indexed account, bool isExcluded);

    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

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

    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 REUeceived,
        uint256 tokensIntoLiqudity
    );

    event SendDividends(
    	uint256 tokensSwapped,
    	uint256 amount
    );

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

    constructor() ERC20("REU", "REU") {

    	dividendTracker = new BTCDividendTracker();


    	IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D );
         // Create a uniswap pair for this new token
        address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());

        uniswapV2Router = _uniswapV2Router;
        uniswapV2Pair = _uniswapV2Pair;

        _setAutomatedMarketMakerPair(_uniswapV2Pair, true);

        // exclude from receiving dividends
        dividendTracker.excludeFromDividends(address(dividendTracker));
        dividendTracker.excludeFromDividends(address(this));
        dividendTracker.excludeFromDividends(owner());
        dividendTracker.excludeFromDividends(deadWallet);
        dividendTracker.excludeFromDividends(address(_uniswapV2Router));

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

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

    receive() external payable {

  	}

    function updateDividendTracker(address newAddress) public onlyOwner {
        require(newAddress != address(dividendTracker), "REU: The dividend tracker already has that address");

        BTCDividendTracker newDividendTracker = BTCDividendTracker(payable(newAddress));

        require(newDividendTracker.owner() == address(this), "REU: The new dividend tracker must be owned by the  token contract");

        newDividendTracker.excludeFromDividends(address(newDividendTracker));
        newDividendTracker.excludeFromDividends(address(this));
        newDividendTracker.excludeFromDividends(owner());
        newDividendTracker.excludeFromDividends(address(uniswapV2Router));

        emit UpdateDividendTracker(newAddress, address(dividendTracker));

        dividendTracker = newDividendTracker;
    }

    function updateUniswapV2Router(address newAddress) public onlyOwner {
        require(newAddress != address(uniswapV2Router), "REU: The router already has that address");
        emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));
        uniswapV2Router = IUniswapV2Router02(newAddress);
        address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
            .createPair(address(this), uniswapV2Router.WETH());
        uniswapV2Pair = _uniswapV2Pair;
    }

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

        emit ExcludeFromFees(account, excluded);
    }

    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
        require(pair != uniswapV2Pair, "REU: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs");

        _setAutomatedMarketMakerPair(pair, value);
    }

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

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

        emit SetAutomatedMarketMakerPair(pair, value);
    }


    function updateGasForProcessing(uint256 newValue) public onlyOwner {
        require(newValue >= 200000 && newValue <= 500000, "REU: gasForProcessing must be between 200,000 and 500,000");
        require(newValue != gasForProcessing, "REU: Cannot update gasForProcessing to same value");
        emit GasForProcessingUpdated(newValue, gasForProcessing);
        gasForProcessing = newValue;
    }

    function updateClaimWait(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 dividendTokenBalanceOf(address account) public view returns (uint256) {
		return dividendTracker.balanceOf(account);
	}

	function excludeFromDividends(address account) external onlyOwner{
	    dividendTracker.excludeFromDividends(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 processDividendTracker(uint256 gas) external {
		(uint256 iterations, uint256 claims, uint256 lastProcessedIndex) = dividendTracker.process(gas);
		emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, false, gas, tx.origin);
    }

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

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

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


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

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

        bool excludedAccount = (_isExcludedFromFees[from] || _isExcludedFromFees[to]);

        if(automatedMarketMakerPairs[from] && !excludedAccount){
            require(amount <= maxBuyTransactionAmount, "buy transfer amount exceeds the maxBuyTransactionAmount.");
        }

        if(automatedMarketMakerPairs[to] && !excludedAccount){
            require(amount <= maxSellTransactionAmount, "Sell transfer amount exceeds the maxSellTransactionAmount.");
        }

		uint256 contractTokenBalance = balanceOf(address(this));

        bool canSwap = contractTokenBalance >= swapTokensAtAmount;

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

            contractTokenBalance = swapTokensAtAmount;

            // marketing, buyback and liquidity tokens
            uint256 swapTokens = contractTokenBalance.mul(totalFees.sub(rewardFee)).div(100);
            swapAndLiquify(swapTokens);

            // tokens for redistribution
            uint256 rewardTokens = contractTokenBalance.sub(swapTokens);
            swapAndSendDividends(rewardTokens);

            swapping = false;
        }


        bool takeFee = !swapping;

        // if any account belongs to _isExcludedFromFee account then remove the fee
        if(excludedAccount) {
            takeFee = false;
        }

        if(takeFee) {
        	uint256 fees;

             if(automatedMarketMakerPairs[from] || automatedMarketMakerPairs[to]) {
        	    fees = amount.mul(totalFees).div(100);
        	}

        	amount = amount.sub(fees);

            if(fees>0) {
                super._transfer(from, address(this), fees);
            }
            
        }

        super._transfer(from, to, amount);

        try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}
        try dividendTracker.setBalance(payable(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) private {
        uint256 liquidityTokens = tokens.mul(liquidityFee).div(totalFees.sub(rewardFee));
       // split the contract balance into halves
        uint256 half = liquidityTokens.div(2);
        uint256 otherHalf = liquidityTokens.sub(half);

        // capture the contract's current ETH balance.
        // this is so that we can capture exactly the amount of ETH that the
        // swap creates, and not make the liquidity event include any ETH that
        // has been manually sent to the contract
        uint256 initialBalance = address(this).balance;

        // swap tokens for ETH
        swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered

        // how much ETH did we just swap into?
        uint256 newBalance = address(this).balance.sub(initialBalance);

        // add liquidity to uniswap
        addLiquidity(otherHalf, newBalance);

        // swap and send to marketing and buyback wallet
        swapTokensForEth(tokens.sub(liquidityTokens));
        _buybackWalletAddress.transfer(address(this).balance.mul(buybackFee).div(buybackFee.add(marketingFee)));
        _marketingWalletAddress.transfer(address(this).balance);

        emit SwapAndLiquify(half, newBalance, otherHalf);
    }


    function swapTokensForEth(uint256 tokenAmount) private {
        // generate the uniswap pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

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

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

    }

    function swapTokensForBTC(uint256 tokenAmount) private {
        address[] memory path = new address[](3);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        path[2] = rewardToken;

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

        // make the swap
        uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {

        // approve token transfer to cover all possible scenarios
        _approve(address(this), address(uniswapV2Router), tokenAmount);

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

    }

    function swapAndSendDividends(uint256 tokens) private{
        swapTokensForBTC(tokens);
        uint256 dividends = IERC20(rewardToken).balanceOf(address(this));
        bool success = IERC20(rewardToken).transfer(address(dividendTracker), dividends);

        if (success) {
            dividendTracker.distributeDividends(dividends);
            emit SendDividends(tokens, dividends);
        }
    }

    function setMaxBuyTransactionLimit(uint256 _newLimit) external onlyOwner{
        maxBuyTransactionAmount  = _newLimit;
        require(maxBuyTransactionAmount > totalSupply().div(400), "max transaction limit must be greator than 0.1% of total supply");
    }

    function setMaxSellTransactionLimit(uint256 _newLimit) external onlyOwner{
        maxSellTransactionAmount  = _newLimit;
        require(maxSellTransactionAmount > totalSupply().div(400), "max transaction limit must be greator than 0.1% of total supply");
    }

    function setSwapTokensAtAmount(uint256 _newLimit) external onlyOwner{
        swapTokensAtAmount = _newLimit;
    }

    function setMarketingWallet(address payable wallet) external onlyOwner{
        _marketingWalletAddress = wallet;
    }

    function setBuybackWallet(address payable wallet) external onlyOwner{
        _buybackWalletAddress = wallet;
    }
        
    function setFees(uint256 _rewardFee, uint256 _marketingFee, uint256 _liquidityFee, uint256 _buybackFee) external onlyOwner{
        rewardFee = _rewardFee;
        marketingFee = _marketingFee;
        liquidityFee = _liquidityFee;
        buybackFee = _buybackFee;
        totalFees = rewardFee.add(liquidityFee).add(marketingFee).add(buybackFee);
        require(totalFees <= 20, "total tax must be less than or equal to 20%");
    }


}

contract BTCDividendTracker 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);
    event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);

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

    constructor() DividendPayingToken("REU_Dividen_Tracker", "REU_Dividen_Tracker") {
    	claimWait = 3600;
        minimumTokenBalanceForDividends = 10000 * (10**18); //must hold 10000+ tokens
    }

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

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

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

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

    	emit ExcludeFromDividends(account);
    }

    function updateClaimWait(uint256 newClaimWait) external onlyOwner {
        require(newClaimWait >= 3600 && newClaimWait <= 86400, "REU_Dividend_Tracker: claimWait must be updated to between 1 and 24 hours");
        require(newClaimWait != claimWait, "REU_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 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.add(int256(processesUntilEndOfArray));
            }
        }


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

        lastClaimTime = lastClaimTimes[account];

        nextClaimTime = lastClaimTime > 0 ?
                                    lastClaimTime.add(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 payable account, uint256 newBalance) external onlyOwner {
    	if(excludedFromDividends[account]) {
    		return;
    	}

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

    	processAccount(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.add(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"}],"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"distributeDividends","outputs":[],"stateMutability":"nonpayable","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"}],"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":"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":[{"internalType":"uint256","name":"time","type":"uint256"}],"name":"lock","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"setBalance","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":[],"name":"withdrawDividend","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Libraries Used

IterableMapping : 0x714316ffe26969f1d6657e11588360d03776dca5Unverified

Deployed Bytecode Sourcemap

62838:6620:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7968:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10114:169;;;;;;:::i;:::-;;:::i;:::-;;;1237:14:1;;1230:22;1212:41;;1200:2;1185:18;10114:169:0;1072:187:1;64937:119:0;65021:15;:27;64937:119;;;1410:25:1;;;1398:2;1383:18;64937:119:0;1264:177:1;9067:108:0;9155:12;;9067:108;;63182:50;;;;;;:::i;:::-;;;;;;;;;;;;;;10765:321;;;;;;:::i;:::-;;:::i;24773:247::-;;;;;;:::i;:::-;;:::i;63077:33::-;;;;;;8911:91;8985:9;;8911:91;;8985:9;;;;2301:36:1;;2289:2;2274:18;8911:91:0;2159:184:1;64109:283:0;;;;;;:::i;:::-;;:::i;:::-;;21816:387;;;;;;:::i;:::-;;:::i;11495:218::-;;;;;;:::i;:::-;;:::i;63119:54::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;66746:505;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2890:32:1;;;2872:51;;2954:2;2939:18;;2932:34;;;;2982:18;;;2975:34;;;;3040:2;3025:18;;3018:34;;;;3083:3;3068:19;;3061:35;2910:3;3112:19;;3105:35;3171:3;3156:19;;3149:35;3215:3;3200:19;;3193:35;2859:3;2844:19;66746:505:0;2533:701:1;63916:185:0;;;:::i;63241:24::-;;;;;;9238:127;;;;;;:::i;:::-;-1:-1:-1;;;;;9339:18:0;9312:7;9339:18;;;;;;;;;;;;9238:127;2409:148;;;:::i;21675:40::-;;;;;;1758:87;1831:6;;;;;-1:-1:-1;;;;;1831:6:0;1758:87;;;-1:-1:-1;;;;;3403:32:1;;;3385:51;;3373:2;3358:18;1758:87:0;3239:203:1;23487:124:0;;;;;;:::i;:::-;;:::i;8178:95::-;;;:::i;12216:269::-;;;;;;:::i;:::-;;:::i;23822:168::-;;;;;;:::i;:::-;;:::i;9578:175::-;;;;;;:::i;:::-;;:::i;24203:129::-;;;;;;:::i;:::-;-1:-1:-1;;;;;24300:26:0;24277:7;24300:26;;;:18;:26;;;;;;;24203:129;69112:343;;;;;;:::i;:::-;;:::i;63272:46::-;;;;;;3038:226;;;;;;:::i;:::-;;:::i;9816:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;9932:18:0;;;9905:7;9932:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;9816:151;67486:460;;;;;;:::i;:::-;;:::i;64824:105::-;64903:18;;64824:105;;64400:416;;;;;;:::i;:::-;;:::i;2712:244::-;;;;;;:::i;:::-;;:::i;21347:80::-;;;;;-1:-1:-1;;;;;21347:80:0;;;65068:1670;;;;;;:::i;:::-;;:::i;67954:1150::-;;;;;;:::i;:::-;;:::i;:::-;;;;4888:25:1;;;4944:2;4929:18;;4922:34;;;;4972:18;;;4965:34;4876:2;4861:18;67954:1150:0;4686:319:1;7968:91:0;8013:13;8046:5;8039:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7968:91;:::o;10114:169::-;10197:4;10214:39;414:10;10237:7;10246:6;10214:8;:39::i;:::-;-1:-1:-1;10271:4:0;10114:169;;;;;:::o;10765:321::-;10871:4;10888:36;10898:6;10906:9;10917:6;10888:9;:36::i;:::-;10935:121;10944:6;414:10;10966:89;11004:6;10966:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10966:19:0;;;;;;:11;:19;;;;;;;;414:10;10966:33;;;;;;;;;;:37;:89::i;:::-;10935:8;:121::i;:::-;-1:-1:-1;11074:4:0;10765:321;;;;;:::o;24773:247::-;-1:-1:-1;;;;;24949:36:0;;24850:7;24949:36;;;:28;:36;;;;;;;;;9339:18;;;;;;;24873:25;;-1:-1:-1;;;21482:6:0;24873:129;;:113;;:63;;:48;;:25;:29;:48::i;:::-;:61;:63::i;:::-;:75;;:113::i;:::-;:127;:129::i;:::-;:141;;;;:::i;64109:283::-;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;64192:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;64191:31;64183:40;;;::::0;::::1;;-1:-1:-1::0;;;;;64231:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;-1:-1:-1;;64231:37:0::1;64264:4;64231:37;::::0;;64278:23:::1;::::0;64253:7;;64278:11:::1;:23::i;:::-;64309:31;::::0;-1:-1:-1;;;64309:31:0;;:15:::1;:31;::::0;::::1;6314:25:1::0;-1:-1:-1;;;;;6375:32:1;;6355:18;;;6348:60;64309:22:0::1;::::0;::::1;::::0;6287:18:1;;64309:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;64355:29:0::1;::::0;-1:-1:-1;;;;;64355:29:0;::::1;::::0;-1:-1:-1;64355:29:0::1;::::0;-1:-1:-1;64355:29:0;;::::1;64109:283:::0;:::o;21816:387::-;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;21908:1:::1;21892:13;9155:12:::0;;;9067:108;21892:13:::1;:17;21884:26;;;::::0;::::1;;21923:10:::0;;21919:279:::1;;21972:88;22038:13;9155:12:::0;;;9067:108;22038:13:::1;22012:23;22013:6:::0;-1:-1:-1;;;22012:12:0::1;:23::i;:::-;:39;;;;:::i;:::-;21972:25;::::0;;:29:::1;:88::i;:::-;21944:25;:116:::0;22074:40:::1;::::0;1410:25:1;;;22095:10:0::1;::::0;22074:40:::1;::::0;1398:2:1;1383:18;22074:40:0::1;;;;;;;22153:25;::::0;:37:::1;::::0;22183:6;22153:29:::1;:37::i;:::-;22125:25;:65:::0;21919:279:::1;21816:387:::0;:::o;11495:218::-;414:10;11583:4;11632:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;11632:34:0;;;;;;;;;;11583:4;;11600:83;;11623:7;;11632:50;;11671:10;11632:38;:50::i;66746:505::-;66832:7;66854:6;66875;66896:7;66918;66940;66962;66984;67013:15;:20;;;;:22;;;;;;;;;;;;;1410:25:1;;1398:2;1383:18;;1264:177;67013:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67004:5;:31;67001:137;;-1:-1:-1;67060:42:0;;-1:-1:-1;;;67104:2:0;-1:-1:-1;67104:2:0;;-1:-1:-1;67060:42:0;;-1:-1:-1;67060:42:0;;-1:-1:-1;67060:42:0;;-1:-1:-1;67060:42:0;;-1:-1:-1;67060:42:0;67052:74;;67001:137;67168:36;;-1:-1:-1;;;67168:36:0;;:15;:36;;;7024:25:1;7065:18;;;7058:34;;;67150:15:0;;67168:29;;;;6997:18:1;;67168:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67150:54;;67224:19;67235:7;67224:10;:19::i;:::-;67217:26;;;;;;;;;;;;;;;;;66746:505;;;;;;;;;;:::o;63916:185::-;63976:117;;-1:-1:-1;;;63976:117:0;;7561:2:1;63976:117:0;;;7543:21:1;7600:2;7580:18;;;7573:30;7639:34;7619:18;;;7612:62;7710:34;7690:18;;;7683:62;7782:34;7761:19;;;7754:63;-1:-1:-1;;;7833:19:1;;;7826:34;7877:19;;63976:117:0;7359:543:1;2409:148:0;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;2500:6:::1;::::0;2479:40:::1;::::0;2516:1:::1;::::0;2500:6:::1;::::0;::::1;-1:-1:-1::0;;;;;2500:6:0::1;::::0;2479:40:::1;::::0;2516:1;;2479:40:::1;2530:6;:19:::0;;-1:-1:-1;;;;;;2530:19:0::1;::::0;;2409:148::o;23487:124::-;23552:7;23575:30;23598:6;23575:22;:30::i;8178:95::-;8225:13;8258:7;8251:14;;;;;:::i;12216:269::-;12309:4;12326:129;414:10;12349:7;12358:96;12397:15;12358:96;;;;;;;;;;;;;;;;;414:10;12358:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;12358:34:0;;;;;;;;;;;;:38;:96::i;23822:168::-;-1:-1:-1;;;;;23957:26:0;;23899:7;23957:26;;;:18;:26;;;;;;23922:62;;:30;23976:6;23922:22;:30::i;:::-;:34;;:62::i;9578:175::-;9664:4;9681:42;414:10;9705:9;9716:6;9681:9;:42::i;69112:343::-;1831:6;;69203:4;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;69220:14:::1;69237:32;69261:7;69237:23;:32::i;:::-;69220:49:::0;-1:-1:-1;69282:10:0;;69279:147:::1;;-1:-1:-1::0;;;;;69303:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;69329:15:::1;69303:41:::0;;69364:33;;::::1;;::::0;69303:23;69364:33:::1;::::0;::::1;::::0;69379:6;1410:25:1;;1398:2;1383:18;;1264:177;69364:33:0::1;;;;;;;;69413:4;69406:11;;;;;69279:147;-1:-1:-1::0;69442:5:0::1;::::0;69112:343;-1:-1:-1;;;69112:343:0:o;3038:226::-;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;3119:6:::1;::::0;;3102:14:::1;:23:::0;;-1:-1:-1;;;;;;3102:23:0::1;-1:-1:-1::0;;;;;3119:6:0::1;::::0;::::1;;3102:23;::::0;;-1:-1:-1;;;;;;3136:19:0::1;::::0;;3178:22:::1;3196:4:::0;3178:15:::1;:22;:::i;:::-;3166:9;:34:::0;3237:6:::1;::::0;3216:40:::1;::::0;3253:1:::1;::::0;3237:6:::1;::::0;::::1;-1:-1:-1::0;;;;;3237:6:0::1;::::0;3216:40:::1;::::0;3253:1;;3216:40:::1;3038:226:::0;:::o;67486:460::-;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67581:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;67622:7;67578:59;67663:31;;67649:10;:45;67646:254;;67711:32;67723:7;67732:10;67711:11;:32::i;:::-;67752:40;::::0;-1:-1:-1;;;67752:40:0;;:15:::1;:40;::::0;::::1;8280:25:1::0;-1:-1:-1;;;;;8341:32:1;;8321:18;;;8314:60;8390:18;;;8383:34;;;67752:19:0::1;::::0;::::1;::::0;8253:18:1;;67752:40:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;67646:254;;;67828:23;67840:7;67849:1;67828:11;:23::i;:::-;67860:31;::::0;-1:-1:-1;;;67860:31:0;;:15:::1;:31;::::0;::::1;6314:25:1::0;-1:-1:-1;;;;;6375:32:1;;6355:18;;;6348:60;67860:22:0::1;::::0;::::1;::::0;6287:18:1;;67860:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;67646:254;67909:29;67924:7;67933:4;67909:14;:29::i;:::-;;2049:1;67486:460:::0;;:::o;64400:416::-;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;64501:4:::1;64485:12;:20;;:45;;;;;64525:5;64509:12;:21;;64485:45;64477:131;;;::::0;-1:-1:-1;;;64477:131:0;;8947:2:1;64477:131:0::1;::::0;::::1;8929:21:1::0;8986:2;8966:18;;;8959:30;9025:34;9005:18;;;8998:62;9096:34;9076:18;;;9069:62;-1:-1:-1;;;9147:19:1;;;9140:40;9197:19;;64477:131:0::1;8745:477:1::0;64477:131:0::1;64643:9;;64627:12;:25:::0;64619:97:::1;;;::::0;-1:-1:-1;;;64619:97:0;;9429:2:1;64619:97:0::1;::::0;::::1;9411:21:1::0;9468:2;9448:18;;;9441:30;9507:34;9487:18;;;9480:62;9578:29;9558:18;;;9551:57;9625:19;;64619:97:0::1;9227:423:1::0;64619:97:0::1;64763:9;::::0;64732:41:::1;::::0;64749:12;;64732:41:::1;::::0;;;::::1;64784:9;:24:::0;64400:416::o;2712:244::-;1831:6;;-1:-1:-1;;;;;1831:6:0;;;;;414:10;1978:23;1970:68;;;;-1:-1:-1;;;1970:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2801:22:0;::::1;2793:73;;;::::0;-1:-1:-1;;;2793:73:0;;9857:2:1;2793:73:0::1;::::0;::::1;9839:21:1::0;9896:2;9876:18;;;9869:30;9935:34;9915:18;;;9908:62;-1:-1:-1;;;9986:18:1;;;9979:36;10032:19;;2793:73:0::1;9655:402:1::0;2793:73:0::1;2903:6;::::0;2882:38:::1;::::0;-1:-1:-1;;;;;2882:38:0;;::::1;::::0;2903:6:::1;::::0;::::1;;::::0;2882:38:::1;::::0;;;::::1;2931:6;:17:::0;;-1:-1:-1;;;;;2931:17:0;;::::1;;;-1:-1:-1::0;;;;;;2931:17:0;;::::1;::::0;;;::::1;::::0;;2712:244::o;65068:1670::-;65496:38;;-1:-1:-1;;;65496:38:0;;:15;:38;;;6314:25:1;-1:-1:-1;;;;;6375:32:1;;6355:18;;;6348:60;65467:8:0;;65150:15;;;;;;;;;;;;;;65496:29;;;;6287:18:1;;65496:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65488:46;;-1:-1:-1;;65547:29:0;;65601:1;65592:5;:10;65589:582;;65639:18;;65630:5;65622:35;65619:541;;;65722:18;;65705:37;;:5;;:9;:37::i;:::-;65678:64;;65619:541;;;65861:18;;65831:15;:27;65796:32;;-1:-1:-1;65831:220:0;;66050:1;65831:220;;;65971:18;;65939:15;:27;:51;;:31;:51::i;:::-;65796:255;-1:-1:-1;66101:43:0;:5;65796:255;66101:9;:43::i;:::-;66074:70;;65777:383;65619:541;66209:31;66232:7;66209:22;:31::i;:::-;66185:55;;66268:31;66291:7;66268:22;:31::i;:::-;-1:-1:-1;;;;;66328:23:0;;;;;;:14;:23;;;;;;66251:48;;-1:-1:-1;66328:23:0;-1:-1:-1;66380:17:0;:126;;66505:1;66380:126;;;66455:9;;66437:28;;:13;;:17;:28::i;:::-;66364:142;;66568:15;66552:13;:31;:178;;66729:1;66552:178;;;66639:34;:13;66657:15;66639:17;:34::i;:::-;66519:211;;65068:1670;;;;;;;;;:::o;67954:1150::-;68066:15;:27;68000:7;;;;;;68106:25;;;68103:81;;-1:-1:-1;;68156:18:0;;68150:1;;-1:-1:-1;68150:1:0;;-1:-1:-1;68142:33:0;;68103:81;68223:18;;68193:27;;68298:9;68280:27;;68317:18;68347:14;68375:615;68391:3;68381:7;:13;:50;;;;;68411:20;68398:10;:33;68381:50;68375:615;;;68442:21;;;;:::i;:::-;68500:15;:27;68442:21;;-1:-1:-1;68477:50:0;;;-1:-1:-1;68474:98:0;;68561:1;68539:23;;68474:98;68582:15;68600;:20;;68621:19;68600:41;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;68600:41:0;68668:23;;;:14;:23;;;;;;;;68600:41;;-1:-1:-1;68655:37:0;;:12;:37::i;:::-;68652:134;;;68707:38;68730:7;68740:4;68707:14;:38::i;:::-;68704:73;;;68758:8;;;;:::i;:::-;;;;68704:73;68796:12;;;;:::i;:::-;;;;68819:18;68840:9;68819:30;;68873:10;68863:7;:20;68860:91;;;68905:36;68917:23;:7;68929:10;68917:11;:23::i;:::-;68905:7;;:11;:36::i;:::-;68895:46;;68860:91;68971:10;-1:-1:-1;68375:615:0;;-1:-1:-1;68375:615:0;;68999:18;:40;;;69057:10;;-1:-1:-1;69069:6:0;-1:-1:-1;69020:19:0;;-1:-1:-1;;;;67954:1150:0;;;;;;:::o;15363:346::-;-1:-1:-1;;;;;15465:19:0;;15457:68;;;;-1:-1:-1;;;15457:68:0;;10724:2:1;15457:68:0;;;10706:21:1;10763:2;10743:18;;;10736:30;10802:34;10782:18;;;10775:62;-1:-1:-1;;;10853:18:1;;;10846:34;10897:19;;15457:68:0;10522:400:1;15457:68:0;-1:-1:-1;;;;;15544:21:0;;15536:68;;;;-1:-1:-1;;;15536:68:0;;11129:2:1;15536:68:0;;;11111:21:1;11168:2;11148:18;;;11141:30;11207:34;11187:18;;;11180:62;-1:-1:-1;;;11258:18:1;;;11251:32;11300:19;;15536:68:0;10927:398:1;15536:68:0;-1:-1:-1;;;;;15617:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;15669:32;;1410:25:1;;;15669:32:0;;1383:18:1;15669:32:0;;;;;;;15363:346;;;:::o;63760:148::-;63840:60;;-1:-1:-1;;;63840:60:0;;11532:2:1;63840:60:0;;;11514:21:1;11571:2;11551:18;;;11544:30;11610:34;11590:18;;;11583:62;-1:-1:-1;;;11661:18:1;;;11654:40;11711:19;;63840:60:0;11330:406:1;42323:166:0;42409:7;42445:12;42437:6;;;;42429:29;;;;-1:-1:-1;;;42429:29:0;;;;;;;;:::i;:::-;-1:-1:-1;42476:5:0;42480:1;42476;:5;:::i;:::-;42469:12;42323:166;-1:-1:-1;;;;42323:166:0:o;40375:220::-;40433:7;40457:1;40462;40457:6;40453:20;;-1:-1:-1;40472:1:0;40465:8;;40453:20;40484:9;40496:5;40500:1;40496;:5;:::i;:::-;40484:17;-1:-1:-1;40529:1:0;40520:5;40524:1;40484:17;40520:5;:::i;:::-;:10;40512:56;;;;-1:-1:-1;;;40512:56:0;;12246:2:1;40512:56:0;;;12228:21:1;12285:2;12265:18;;;12258:30;12324:34;12304:18;;;12297:62;-1:-1:-1;;;12375:18:1;;;12368:31;12416:19;;40512:56:0;12044:397:1;40512:56:0;40586:1;40375:220;-1:-1:-1;;;40375:220:0:o;45688:134::-;45744:6;45777:1;45794:6;;;;45786:15;;;;;45271:162;45327:6;;45353:5;45357:1;45353;:5;:::i;:::-;45342:16;;45379:1;45374;:6;;:16;;;;;45389:1;45384;:6;;45374:16;45373:38;;;;45400:1;45396;:5;:14;;;;;45409:1;45405;:5;45396:14;45365:47;;;;;45439:117;45495:7;45524:1;45519;:6;;45511:15;;;;;;-1:-1:-1;45548:1:0;45439:117::o;26778:407::-;-1:-1:-1;;;;;9339:18:0;;26852:22;9339:18;;;;;;;;;;;26907:27;;;26904:276;;;26945:18;26966:30;:10;26981:14;26966;:30::i;:::-;26945:51;;27005:26;27011:7;27020:10;27005:5;:26::i;:::-;26936:103;26904:276;;;27061:14;27048:10;:27;27045:135;;;27086:18;27107:30;:14;27126:10;27107:18;:30::i;:::-;27086:51;;27146:26;27152:7;27161:10;27146:5;:26::i;:::-;27077:103;26845:340;26778:407;;:::o;39496:179::-;39554:7;;39586:5;39590:1;39586;:5;:::i;:::-;39574:17;;39615:1;39610;:6;;39602:46;;;;-1:-1:-1;;;39602:46:0;;12918:2:1;39602:46:0;;;12900:21:1;12957:2;12937:18;;;12930:30;12996:29;12976:18;;;12969:57;13043:18;;39602:46:0;12716:351:1;39958:158:0;40016:7;40049:1;40044;:6;;40036:49;;;;-1:-1:-1;;;40036:49:0;;13274:2:1;40036:49:0;;;13256:21:1;13313:2;13293:18;;;13286:30;13352:32;13332:18;;;13325:60;13402:18;;40036:49:0;13072:354:1;40036:49:0;40103:5;40107:1;40103;:5;:::i;22649:625::-;22722:7;22738:29;22770:28;22793:4;22770:22;:28::i;:::-;22738:60;-1:-1:-1;22809:25:0;;22805:447;;-1:-1:-1;;;;;22872:24:0;;;;;;:18;:24;;;;;;:51;;22901:21;22872:28;:51::i;:::-;-1:-1:-1;;;;;22845:24:0;;;;;;:18;:24;;;;;;;:78;;;;22937:46;;;;;;22961:21;1410:25:1;;1398:2;1383:18;;1264:177;22937:46:0;;;;;;;;23014:11;;23007:57;;-1:-1:-1;;;23007:57:0;;-1:-1:-1;;;;;13631:32:1;;;23007:57:0;;;13613:51:1;13680:18;;;13673:34;;;22992:12:0;;23014:11;;23007:28;;13586:18:1;;23007:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22992:72;;23079:7;23075:131;;-1:-1:-1;;;;;23126:24:0;;;;;;:18;:24;;;;;;:51;;23155:21;23126:28;:51::i;:::-;-1:-1:-1;;;;;23099:24:0;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;23099:24:0;;22649:625;-1:-1:-1;;22649:625:0:o;23075:131::-;-1:-1:-1;23223:21:0;22649:625;-1:-1:-1;;22649:625:0:o;22805:447::-;-1:-1:-1;23267:1:0;;22649:625;-1:-1:-1;;22649:625:0:o;45112:153::-;45168:6;45197:1;45192;:6;;:20;;;;-1:-1:-1;45211:1:0;45202:5;45206:1;45211;45202:5;:::i;:::-;:10;;45192:20;45191:46;;;;45222:1;45218;:5;:18;;;;-1:-1:-1;45235:1:0;45227:5;45231:1;45235;45227:5;:::i;:::-;:9;45218:18;45183:55;;;;;;45254:5;45258:1;45254;:5;:::i;67259:219::-;67326:4;67359:15;67343:13;:31;67340:67;;;-1:-1:-1;67393:5:0;;67259:219;-1:-1:-1;67259:219:0:o;67340:67::-;67461:9;;67423:34;:15;67443:13;67423:19;:34::i;:::-;:47;;;67259:219;-1:-1:-1;;67259:219:0:o;25977:260::-;26049:27;26061:7;26070:5;26049:11;:27::i;:::-;26125:106;26176:53;26177:36;26207:5;26177:25;;:29;;:36;;;;:::i;26176:53::-;-1:-1:-1;;;;;26125:37:0;;;;;;:28;:37;;;;;;;:49;:106::i;:::-;-1:-1:-1;;;;;26085:37:0;;;;;;;:28;:37;;;;;:146;;;;-1:-1:-1;25977:260:0:o;26512:::-;26584:27;26596:7;26605:5;26584:11;:27::i;:::-;26660:106;26711:53;26712:36;26742:5;26712:25;;:29;;:36;;;;:::i;26711:53::-;-1:-1:-1;;;;;26660:37:0;;;;;;:28;:37;;;;;;;:49;:106::i;13796:378::-;-1:-1:-1;;;;;13880:21:0;;13872:65;;;;-1:-1:-1;;;13872:65:0;;14442:2:1;13872:65:0;;;14424:21:1;14481:2;14461:18;;;14454:30;14520:33;14500:18;;;14493:61;14571:18;;13872:65:0;14240:355:1;13872:65:0;13950:49;13979:1;13983:7;13992:6;13950:20;:49::i;:::-;14027:12;;:24;;14044:6;14027:16;:24::i;:::-;14012:12;:39;-1:-1:-1;;;;;14083:18:0;;:9;:18;;;;;;;;;;;:30;;14106:6;14083:22;:30::i;:::-;-1:-1:-1;;;;;14062:18:0;;:9;:18;;;;;;;;;;;:51;;;;14129:37;;1410:25:1;;;14062:18:0;;:9;;14129:37;;1383:18:1;14129:37:0;;;;;;;;13796:378;;:::o;14507:418::-;-1:-1:-1;;;;;14591:21:0;;14583:67;;;;-1:-1:-1;;;14583:67:0;;14802:2:1;14583:67:0;;;14784:21:1;14841:2;14821:18;;;14814:30;14880:34;14860:18;;;14853:62;-1:-1:-1;;;14931:18:1;;;14924:31;14972:19;;14583:67:0;14600:397:1;14583:67:0;14663:49;14684:7;14701:1;14705:6;14663:20;:49::i;:::-;14746:68;14769:6;14746:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;14746:18:0;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;14725:18:0;;:9;:18;;;;;;;;;;:89;14840:12;;:24;;14857:6;14840:16;:24::i;:::-;14825:12;:39;14880:37;;1410:25:1;;;14906:1:0;;-1:-1:-1;;;;;14880:37:0;;;;;1398:2:1;1383:18;14880:37:0;1264:177:1;14:597;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;616:131::-;-1:-1:-1;;;;;691:31:1;;681:42;;671:70;;737:1;734;727:12;752:315;820:6;828;881:2;869:9;860:7;856:23;852:32;849:52;;;897:1;894;887:12;849:52;936:9;923:23;955:31;980:5;955:31;:::i;:::-;1005:5;1057:2;1042:18;;;;1029:32;;-1:-1:-1;;;752:315:1:o;1446:247::-;1505:6;1558:2;1546:9;1537:7;1533:23;1529:32;1526:52;;;1574:1;1571;1564:12;1526:52;1613:9;1600:23;1632:31;1657:5;1632:31;:::i;1698:456::-;1775:6;1783;1791;1844:2;1832:9;1823:7;1819:23;1815:32;1812:52;;;1860:1;1857;1850:12;1812:52;1899:9;1886:23;1918:31;1943:5;1918:31;:::i;:::-;1968:5;-1:-1:-1;2025:2:1;2010:18;;1997:32;2038:33;1997:32;2038:33;:::i;:::-;1698:456;;2090:7;;-1:-1:-1;;;2144:2:1;2129:18;;;;2116:32;;1698:456::o;2348:180::-;2407:6;2460:2;2448:9;2439:7;2435:23;2431:32;2428:52;;;2476:1;2473;2466:12;2428:52;-1:-1:-1;2499:23:1;;2348:180;-1:-1:-1;2348:180:1:o;3447:118::-;3533:5;3526:13;3519:21;3512:5;3509:32;3499:60;;3555:1;3552;3545:12;3570:390;3643:6;3651;3704:2;3692:9;3683:7;3679:23;3675:32;3672:52;;;3720:1;3717;3710:12;3672:52;3759:9;3746:23;3778:31;3803:5;3778:31;:::i;:::-;3828:5;-1:-1:-1;3885:2:1;3870:18;;3857:32;3898:30;3857:32;3898:30;:::i;:::-;3947:7;3937:17;;;3570:390;;;;;:::o;3965:388::-;4033:6;4041;4094:2;4082:9;4073:7;4069:23;4065:32;4062:52;;;4110:1;4107;4100:12;4062:52;4149:9;4136:23;4168:31;4193:5;4168:31;:::i;:::-;4218:5;-1:-1:-1;4275:2:1;4260:18;;4247:32;4288:33;4247:32;4288:33;:::i;5010:380::-;5089:1;5085:12;;;;5132;;;5153:61;;5207:4;5199:6;5195:17;5185:27;;5153:61;5260:2;5252:6;5249:14;5229:18;5226:38;5223:161;;5306:10;5301:3;5297:20;5294:1;5287:31;5341:4;5338:1;5331:15;5369:4;5366:1;5359:15;5223:161;;5010:380;;;:::o;5395:127::-;5456:10;5451:3;5447:20;5444:1;5437:31;5487:4;5484:1;5477:15;5511:4;5508:1;5501:15;5527:217;5567:1;5593;5583:132;;5637:10;5632:3;5628:20;5625:1;5618:31;5672:4;5669:1;5662:15;5700:4;5697:1;5690:15;5583:132;-1:-1:-1;5729:9:1;;5527:217::o;5749:356::-;5951:2;5933:21;;;5970:18;;;5963:30;6029:34;6024:2;6009:18;;6002:62;6096:2;6081:18;;5749:356::o;6631:184::-;6701:6;6754:2;6742:9;6733:7;6729:23;6725:32;6722:52;;;6770:1;6767;6760:12;6722:52;-1:-1:-1;6793:16:1;;6631:184;-1:-1:-1;6631:184:1:o;7103:251::-;7173:6;7226:2;7214:9;7205:7;7201:23;7197:32;7194:52;;;7242:1;7239;7232:12;7194:52;7274:9;7268:16;7293:31;7318:5;7293:31;:::i;7907:128::-;7947:3;7978:1;7974:6;7971:1;7968:13;7965:39;;;7984:18;;:::i;:::-;-1:-1:-1;8020:9:1;;7907:128::o;10250:135::-;10289:3;10310:17;;;10307:43;;10330:18;;:::i;:::-;-1:-1:-1;10377:1:1;10366:13;;10250:135::o;10390:127::-;10451:10;10446:3;10442:20;10439:1;10432:31;10482:4;10479:1;10472:15;10506:4;10503:1;10496:15;11741:125;11781:4;11809:1;11806;11803:8;11800:34;;;11814:18;;:::i;:::-;-1:-1:-1;11851:9:1;;11741:125::o;11871:168::-;11911:7;11977:1;11973;11969:6;11965:14;11962:1;11959:21;11954:1;11947:9;11940:17;11936:45;11933:71;;;11984:18;;:::i;:::-;-1:-1:-1;12024:9:1;;11871:168::o;12446:265::-;12485:3;12513:9;;;12538:10;;-1:-1:-1;;;;;12557:27:1;;;12550:35;;12534:52;12531:78;;;12589:18;;:::i;:::-;-1:-1:-1;;;12636:19:1;;;12629:27;;12621:36;;12618:62;;;12660:18;;:::i;:::-;-1:-1:-1;;12696:9:1;;12446:265::o;13718:245::-;13785:6;13838:2;13826:9;13817:7;13813:23;13809:32;13806:52;;;13854:1;13851;13844:12;13806:52;13886:9;13880:16;13905:28;13927:5;13905:28;:::i;13968:267::-;14007:4;14036:9;;;14061:10;;-1:-1:-1;;;14080:19:1;;14073:27;;14057:44;14054:70;;;14104:18;;:::i;:::-;-1:-1:-1;;;;;14151:27:1;;14144:35;;14136:44;;14133:70;;;14183:18;;:::i;:::-;-1:-1:-1;;14220:9:1;;13968:267::o

Swarm Source

ipfs://2e7923a0cb7e90fb602775f070e99569e62d12917ef741600005692c3e9f8d34

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