Token

fecore.finance (FECORE)

Feature Tip: Add private address tag to any address under My Name Tag !

Warning! There are reports that the Fecore team has deleted the website and social media accounts. Please exercise caution when interacting with this address.

ERC-20

Website Down

Overview

Max Total Supply

9,996.183330903826438101 FECORE

Holders

111 (0.00%)

Market

Price

$0.80 @ 0.000241 ETH

Onchain Market Cap

$8,038.61

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x6971fD17a3f82a7b9C957C82c6F4a5C8723Ba6C9

Filtered by Token Holder

0xB2856DE7CAc918ADf4bF19a349f795Ef366AB878

Balance

2.21002152368414841 FECORE

Value

$1.78 ( ~0.0005337046862479 Eth) [0.0221%]

0xb2856de7cac918adf4bf19a349f795ef366ab878

OVERVIEW

Fecore is a deflation token launched by YFFS with the aim of increasing liquidity and reaching out to new investors for YFFS.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

FECORE

Compiler Version

v0.6.12+commit.27d51765

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, Unlicense license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2020-11-22
*/

pragma solidity ^0.6.0;

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

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

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @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.
    */
    contract Ownable is Context {
        address private _owner;
        event OwnershipTransferred(
            address indexed previousOwner,
            address indexed newOwner
        );

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

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

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

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

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

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @dev Interface of the ERC20 standard as defined in the EIP.
    */

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

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

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

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

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

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

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

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

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @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, reverting on
        * overflow.
        *
        * Counterpart to Solidity's `+` operator.
        *
        * Requirements:
        *
        * - Addition cannot overflow.
        */
        function add(uint256 a, uint256 b) internal pure returns (uint256) {
            uint256 c = a + b;
            require(c >= a, "SafeMath: addition overflow");

            return c;
        }

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

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

            return c;
        }

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

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

            return c;
        }

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

        /**
        * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
        * division by zero. The result is rounded towards zero.
        *
        * Counterpart to Solidity's `/` operator. Note: this function uses a
        * `revert` opcode (which leaves remaining gas untouched) while Solidity
        * uses an invalid opcode to revert (consuming all remaining gas).
        *
        * Requirements:
        *
        * - The divisor cannot be zero.
        */
        function div(
            uint256 a,
            uint256 b,
            string memory errorMessage
        ) internal pure returns (uint256) {
            require(b > 0, errorMessage);
            uint256 c = a / b;
            // assert(a == b * c + a % b); // There is no case in which this doesn't hold

            return c;
        }

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

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

    /**
    * @dev Collection of functions related to the address type
    */
    library Address {
        /**
        * @dev Returns true if `account` is a contract.
        *
        * [IMPORTANT]
        * ====
        * It is unsafe to assume that an address for which this function returns
        * false is an externally-owned account (EOA) and not a contract.
        *
        * Among others, `isContract` will return false for the following
        * types of addresses:
        *
        *  - an externally-owned account
        *  - a contract in construction
        *  - an address where a contract will be created
        *  - an address where a contract lived, but was destroyed
        * ====
        */
        function isContract(address account) internal view returns (bool) {
            // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
            // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
            // for accounts without code, i.e. `keccak256('')`
            bytes32 codehash;


                bytes32 accountHash
            = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
            // solhint-disable-next-line no-inline-assembly
            assembly {
                codehash := extcodehash(account)
            }
            return (codehash != accountHash && codehash != 0x0);
        }

        /**
        * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
        * `recipient`, forwarding all available gas and reverting on errors.
        *
        * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
        * of certain opcodes, possibly making contracts go over the 2300 gas limit
        * imposed by `transfer`, making them unable to receive funds via
        * `transfer`. {sendValue} removes this limitation.
        *
        * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
        *
        * IMPORTANT: because control is transferred to `recipient`, care must be
        * taken to not create reentrancy vulnerabilities. Consider using
        * {ReentrancyGuard} or the
        * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
        */
        function sendValue(address payable recipient, uint256 amount) internal {
            require(
                address(this).balance >= amount,
                "Address: insufficient balance"
            );

            // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
            (bool success, ) = recipient.call{value: amount}("");
            require(
                success,
                "Address: unable to send value, recipient may have reverted"
            );
        }

        /**
        * @dev Performs a Solidity function call using a low level `call`. A
        * plain`call` is an unsafe replacement for a function call: use this
        * function instead.
        *
        * If `target` reverts with a revert reason, it is bubbled up by this
        * function (like regular Solidity function calls).
        *
        * Returns the raw returned data. To convert to the expected return value,
        * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
        *
        * Requirements:
        *
        * - `target` must be a contract.
        * - calling `target` with `data` must not revert.
        *
        * _Available since v3.1._
        */
        function functionCall(address target, bytes memory data)
            internal
            returns (bytes memory)
        {
            return functionCall(target, data, "Address: low-level call failed");
        }

        /**
        * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
        * `errorMessage` as a fallback revert reason when `target` reverts.
        *
        * _Available since v3.1._
        */
        function functionCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal returns (bytes memory) {
            return _functionCallWithValue(target, data, 0, errorMessage);
        }

        /**
        * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
        * but also transferring `value` wei to `target`.
        *
        * Requirements:
        *
        * - the calling contract must have an ETH balance of at least `value`.
        * - the called Solidity function must be `payable`.
        *
        * _Available since v3.1._
        */
        function functionCallWithValue(
            address target,
            bytes memory data,
            uint256 value
        ) internal returns (bytes memory) {
            return
                functionCallWithValue(
                    target,
                    data,
                    value,
                    "Address: low-level call with value failed"
                );
        }

        /**
        * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
        * with `errorMessage` as a fallback revert reason when `target` reverts.
        *
        * _Available since v3.1._
        */
        function functionCallWithValue(
            address target,
            bytes memory data,
            uint256 value,
            string memory errorMessage
        ) internal returns (bytes memory) {
            require(
                address(this).balance >= value,
                "Address: insufficient balance for call"
            );
            return _functionCallWithValue(target, data, value, errorMessage);
        }

        function _functionCallWithValue(
            address target,
            bytes memory data,
            uint256 weiValue,
            string memory errorMessage
        ) private returns (bytes memory) {
            require(isContract(target), "Address: call to non-contract");

            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory returndata) = target.call{value: weiValue}(
                data
            );
            if (success) {
                return returndata;
            } else {
                // Look for revert reason and bubble it up if present
                if (returndata.length > 0) {
                    // The easiest way to bubble the revert reason is using memory via assembly

                    // solhint-disable-next-line no-inline-assembly
                    assembly {
                        let returndata_size := mload(returndata)
                        revert(add(32, returndata), returndata_size)
                    }
                } else {
                    revert(errorMessage);
                }
            }
        }
    }

    pragma solidity ^0.6.0;

    contract ERC20 is Context, IERC20, Ownable {
        using SafeMath for uint256;
        using Address for address;

        mapping(address => uint256) private _balances;

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

        uint256 private _totalSupply;
        uint256 public _minimumSupply = 4000000000000000000000;
        uint256 public BURN_RATE = 1;
        uint256 public FEE_RATE = 9;
        uint256 public constant PERCENTS_DIVIDER = 10000;
        address public feeAddress = address(0xb22Aed36638f0Cf6B8d1092ab73A14580E6f8b99);

        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) public {
            _name = name;
            _symbol = symbol;
            _decimals = 18;
        }

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

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

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

        /**
        * @dev See {IERC20-minimumSupply}.
        */
        function minimumSupply() public view returns (uint256) {
            return _minimumSupply;
        }

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

        bool public synchronous = true;
        address[] public allPairs;
        mapping(address => uint256) totalSupplySnapshotOfLPTokens;

        function updateSynchronous(bool _synchronous) public onlyOwner {
            synchronous = _synchronous;
        }

        modifier pairNoExists(address _pairAddress) {
            for (uint8 i = 0; i < allPairs.length; i++) {
                require(allPairs[i] != _pairAddress);
            }
            _;
        }

        function addPair(address _pairAddress) public onlyOwner pairNoExists(_pairAddress) {
            require(_pairAddress.isContract());
            allPairs.push(_pairAddress);
        }

        function sync() public {
            if (synchronous) {
                for (uint8 index = 0; index < allPairs.length; index++) {
                    uint256 lpSupplyOfPair = IERC20(allPairs[index]).totalSupply();
                    require(
                        totalSupplySnapshotOfLPTokens[allPairs[index]] <=
                            lpSupplyOfPair
                    );
                    totalSupplySnapshotOfLPTokens[allPairs[index]] = lpSupplyOfPair;
                }
            }
        }

        /**
        * @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
            virtual
            override
            view
            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);

            uint256 remainingAmount = amount;
            uint256 feeAmount = 0;
            if (FEE_RATE > 0) {
                feeAmount = amount.mul(FEE_RATE).div(PERCENTS_DIVIDER);
                _fee(sender, feeAmount);
                remainingAmount = remainingAmount.sub(feeAmount);
            }
            if (_totalSupply > _minimumSupply) {
                if (BURN_RATE > 0) {
                    uint256 burnAmount = amount.mul(BURN_RATE).div(
                        PERCENTS_DIVIDER
                    );
                    _burn(sender, burnAmount);
                    remainingAmount = remainingAmount.sub(burnAmount);
                }
            }
            _balances[sender] = _balances[sender].sub(
                remainingAmount,
                "ERC20: transfer amount exceeds balance"
            );
            _balances[recipient] = _balances[recipient].add(remainingAmount);

            sync();
            emit Transfer(sender, recipient, remainingAmount);
        }

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

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

            _beforeTokenTransfer(account, feeAddress, amount);

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

        /**
        * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
        *
        * This is 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 {
            _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 {}
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @dev Extension of {ERC20} that allows token holders to destroy both their own
    * tokens and those that they have an allowance for, in a way that can be
    * recognized off-chain (via event analysis).
    */
    abstract contract ERC20Burnable is Context, ERC20 {
        /**
        * @dev Destroys `amount` tokens from the caller.
        *
        * See {ERC20-_burn}.
        */
        function burn(uint256 amount) public virtual {
            _burn(_msgSender(), amount);
        }

        /**
        * @dev Destroys `amount` tokens from `account`, deducting from the caller's
        * allowance.
        *
        * See {ERC20-_burn} and {ERC20-allowance}.
        *
        * Requirements:
        *
        * - the caller must have allowance for ``accounts``'s tokens of at least
        * `amount`.
        */
        function burnFrom(address account, uint256 amount) public virtual {
            uint256 decreasedAllowance = allowance(account, _msgSender()).sub(
                amount,
                "ERC20: burn amount exceeds allowance"
            );

            _approve(account, _msgSender(), decreasedAllowance);
            _burn(account, amount);
        }
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @dev Library for managing
    * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
    * types.
    *
    * Sets have the following properties:
    *
    * - Elements are added, removed, and checked for existence in constant time
    * (O(1)).
    * - Elements are enumerated in O(n). No guarantees are made on the ordering.
    *
    * ```
    * contract Example {
    *     // Add the library methods
    *     using EnumerableSet for EnumerableSet.AddressSet;
    *
    *     // Declare a set state variable
    *     EnumerableSet.AddressSet private mySet;
    * }
    * ```
    *
    * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
    * (`UintSet`) are supported.
    */
    library EnumerableSet {
        // To implement this library for multiple types with as little code
        // repetition as possible, we write it in terms of a generic Set type with
        // bytes32 values.
        // The Set implementation uses private functions, and user-facing
        // implementations (such as AddressSet) are just wrappers around the
        // underlying Set.
        // This means that we can only create new EnumerableSets for types that fit
        // in bytes32.

        struct Set {
            // Storage of set values
            bytes32[] _values;
            // Position of the value in the `values` array, plus 1 because index 0
            // means a value is not in the set.
            mapping(bytes32 => uint256) _indexes;
        }

        /**
        * @dev Add a value to a set. O(1).
        *
        * Returns true if the value was added to the set, that is if it was not
        * already present.
        */
        function _add(Set storage set, bytes32 value) private returns (bool) {
            if (!_contains(set, value)) {
                set._values.push(value);
                // The value is stored at length-1, but we add 1 to all indexes
                // and use 0 as a sentinel value
                set._indexes[value] = set._values.length;
                return true;
            } else {
                return false;
            }
        }

        /**
        * @dev Removes a value from a set. O(1).
        *
        * Returns true if the value was removed from the set, that is if it was
        * present.
        */
        function _remove(Set storage set, bytes32 value) private returns (bool) {
            // We read and store the value's index to prevent multiple reads from the same storage slot
            uint256 valueIndex = set._indexes[value];

            if (valueIndex != 0) {
                // Equivalent to contains(set, value)
                // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
                // the array, and then remove the last element (sometimes called as 'swap and pop').
                // This modifies the order of the array, as noted in {at}.

                uint256 toDeleteIndex = valueIndex - 1;
                uint256 lastIndex = set._values.length - 1;

                // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
                // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

                // Delete the slot where the moved value was stored
                set._values.pop();

                // Delete the index for the deleted slot
                delete set._indexes[value];

                return true;
            } else {
                return false;
            }
        }

        /**
        * @dev Returns true if the value is in the set. O(1).
        */
        function _contains(Set storage set, bytes32 value)
            private
            view
            returns (bool)
        {
            return set._indexes[value] != 0;
        }

        /**
        * @dev Returns the number of values on the set. O(1).
        */
        function _length(Set storage set) private view returns (uint256) {
            return set._values.length;
        }

        /**
        * @dev Returns the value stored at position `index` in the set. O(1).
        *
        * Note that there are no guarantees on the ordering of values inside the
        * array, and it may change when more values are added or removed.
        *
        * Requirements:
        *
        * - `index` must be strictly less than {length}.
        */
        function _at(Set storage set, uint256 index)
            private
            view
            returns (bytes32)
        {
            require(
                set._values.length > index,
                "EnumerableSet: index out of bounds"
            );
            return set._values[index];
        }

        // AddressSet

        struct AddressSet {
            Set _inner;
        }

        /**
        * @dev Add a value to a set. O(1).
        *
        * Returns true if the value was added to the set, that is if it was not
        * already present.
        */
        function add(AddressSet storage set, address value)
            internal
            returns (bool)
        {
            return _add(set._inner, bytes32(uint256(value)));
        }

        /**
        * @dev Removes a value from a set. O(1).
        *
        * Returns true if the value was removed from the set, that is if it was
        * present.
        */
        function remove(AddressSet storage set, address value)
            internal
            returns (bool)
        {
            return _remove(set._inner, bytes32(uint256(value)));
        }

        /**
        * @dev Returns true if the value is in the set. O(1).
        */
        function contains(AddressSet storage set, address value)
            internal
            view
            returns (bool)
        {
            return _contains(set._inner, bytes32(uint256(value)));
        }

        /**
        * @dev Returns the number of values in the set. O(1).
        */
        function length(AddressSet storage set) internal view returns (uint256) {
            return _length(set._inner);
        }

        /**
        * @dev Returns the value stored at position `index` in the set. O(1).
        *
        * Note that there are no guarantees on the ordering of values inside the
        * array, and it may change when more values are added or removed.
        *
        * Requirements:
        *
        * - `index` must be strictly less than {length}.
        */
        function at(AddressSet storage set, uint256 index)
            internal
            view
            returns (address)
        {
            return address(uint256(_at(set._inner, index)));
        }

        // UintSet

        struct UintSet {
            Set _inner;
        }

        /**
        * @dev Add a value to a set. O(1).
        *
        * Returns true if the value was added to the set, that is if it was not
        * already present.
        */
        function add(UintSet storage set, uint256 value) internal returns (bool) {
            return _add(set._inner, bytes32(value));
        }

        /**
        * @dev Removes a value from a set. O(1).
        *
        * Returns true if the value was removed from the set, that is if it was
        * present.
        */
        function remove(UintSet storage set, uint256 value)
            internal
            returns (bool)
        {
            return _remove(set._inner, bytes32(value));
        }

        /**
        * @dev Returns true if the value is in the set. O(1).
        */
        function contains(UintSet storage set, uint256 value)
            internal
            view
            returns (bool)
        {
            return _contains(set._inner, bytes32(value));
        }

        /**
        * @dev Returns the number of values on the set. O(1).
        */
        function length(UintSet storage set) internal view returns (uint256) {
            return _length(set._inner);
        }

        /**
        * @dev Returns the value stored at position `index` in the set. O(1).
        *
        * Note that there are no guarantees on the ordering of values inside the
        * array, and it may change when more values are added or removed.
        *
        * Requirements:
        *
        * - `index` must be strictly less than {length}.
        */
        function at(UintSet storage set, uint256 index)
            internal
            view
            returns (uint256)
        {
            return uint256(_at(set._inner, index));
        }
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @dev Contract module that allows children to implement role-based access
    * control mechanisms.
    *
    * Roles are referred to by their `bytes32` identifier. These should be exposed
    * in the external API and be unique. The best way to achieve this is by
    * using `public constant` hash digests:
    *
    * ```
    * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
    * ```
    *
    * Roles can be used to represent a set of permissions. To restrict access to a
    * function call, use {hasRole}:
    *
    * ```
    * function foo() public {
    *     require(hasRole(MY_ROLE, msg.sender));
    *     ...
    * }
    * ```
    *
    * Roles can be granted and revoked dynamically via the {grantRole} and
    * {revokeRole} functions. Each role has an associated admin role, and only
    * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
    *
    * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
    * that only accounts with this role will be able to grant or revoke other
    * roles. More complex role relationships can be created by using
    * {_setRoleAdmin}.
    *
    * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
    * grant and revoke this role. Extra precautions should be taken to secure
    * accounts that have been granted it.
    */
    abstract contract AccessControl is Context {
        using EnumerableSet for EnumerableSet.AddressSet;
        using Address for address;

        struct RoleData {
            EnumerableSet.AddressSet members;
            bytes32 adminRole;
        }

        mapping(bytes32 => RoleData) private _roles;

        bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

        /**
        * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
        *
        * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
        * {RoleAdminChanged} not being emitted signaling this.
        *
        * _Available since v3.1._
        */
        event RoleAdminChanged(
            bytes32 indexed role,
            bytes32 indexed previousAdminRole,
            bytes32 indexed newAdminRole
        );

        /**
        * @dev Emitted when `account` is granted `role`.
        *
        * `sender` is the account that originated the contract call, an admin role
        * bearer except when using {_setupRole}.
        */
        event RoleGranted(
            bytes32 indexed role,
            address indexed account,
            address indexed sender
        );

        /**
        * @dev Emitted when `account` is revoked `role`.
        *
        * `sender` is the account that originated the contract call:
        *   - if using `revokeRole`, it is the admin role bearer
        *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
        */
        event RoleRevoked(
            bytes32 indexed role,
            address indexed account,
            address indexed sender
        );

        /**
        * @dev Returns `true` if `account` has been granted `role`.
        */
        function hasRole(bytes32 role, address account) public view returns (bool) {
            return _roles[role].members.contains(account);
        }

        /**
        * @dev Returns the number of accounts that have `role`. Can be used
        * together with {getRoleMember} to enumerate all bearers of a role.
        */
        function getRoleMemberCount(bytes32 role) public view returns (uint256) {
            return _roles[role].members.length();
        }

        /**
        * @dev Returns one of the accounts that have `role`. `index` must be a
        * value between 0 and {getRoleMemberCount}, non-inclusive.
        *
        * Role bearers are not sorted in any particular way, and their ordering may
        * change at any point.
        *
        * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
        * you perform all queries on the same block. See the following
        * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
        * for more information.
        */
        function getRoleMember(bytes32 role, uint256 index)
            public
            view
            returns (address)
        {
            return _roles[role].members.at(index);
        }

        /**
        * @dev Returns the admin role that controls `role`. See {grantRole} and
        * {revokeRole}.
        *
        * To change a role's admin, use {_setRoleAdmin}.
        */
        function getRoleAdmin(bytes32 role) public view returns (bytes32) {
            return _roles[role].adminRole;
        }

        /**
        * @dev Grants `role` to `account`.
        *
        * If `account` had not been already granted `role`, emits a {RoleGranted}
        * event.
        *
        * Requirements:
        *
        * - the caller must have ``role``'s admin role.
        */
        function grantRole(bytes32 role, address account) public virtual {
            require(
                hasRole(_roles[role].adminRole, _msgSender()),
                "AccessControl: sender must be an admin to grant"
            );

            _grantRole(role, account);
        }

        /**
        * @dev Revokes `role` from `account`.
        *
        * If `account` had been granted `role`, emits a {RoleRevoked} event.
        *
        * Requirements:
        *
        * - the caller must have ``role``'s admin role.
        */
        function revokeRole(bytes32 role, address account) public virtual {
            require(
                hasRole(_roles[role].adminRole, _msgSender()),
                "AccessControl: sender must be an admin to revoke"
            );

            _revokeRole(role, account);
        }

        /**
        * @dev Revokes `role` from the calling account.
        *
        * Roles are often managed via {grantRole} and {revokeRole}: this function's
        * purpose is to provide a mechanism for accounts to lose their privileges
        * if they are compromised (such as when a trusted device is misplaced).
        *
        * If the calling account had been granted `role`, emits a {RoleRevoked}
        * event.
        *
        * Requirements:
        *
        * - the caller must be `account`.
        */
        function renounceRole(bytes32 role, address account) public virtual {
            require(
                account == _msgSender(),
                "AccessControl: can only renounce roles for self"
            );

            _revokeRole(role, account);
        }

        /**
        * @dev Grants `role` to `account`.
        *
        * If `account` had not been already granted `role`, emits a {RoleGranted}
        * event. Note that unlike {grantRole}, this function doesn't perform any
        * checks on the calling account.
        *
        * [WARNING]
        * ====
        * This function should only be called from the constructor when setting
        * up the initial roles for the system.
        *
        * Using this function in any other way is effectively circumventing the admin
        * system imposed by {AccessControl}.
        * ====
        */
        function _setupRole(bytes32 role, address account) internal virtual {
            _grantRole(role, account);
        }

        /**
        * @dev Sets `adminRole` as ``role``'s admin role.
        *
        * Emits a {RoleAdminChanged} event.
        */
        function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
            emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
            _roles[role].adminRole = adminRole;
        }

        function _grantRole(bytes32 role, address account) private {
            if (_roles[role].members.add(account)) {
                emit RoleGranted(role, account, _msgSender());
            }
        }

        function _revokeRole(bytes32 role, address account) private {
            if (_roles[role].members.remove(account)) {
                emit RoleRevoked(role, account, _msgSender());
            }
        }
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @dev Standard math utilities missing in the Solidity language.
    */
    library Math {
        /**
        * @dev Returns the largest of two numbers.
        */
        function max(uint256 a, uint256 b) internal pure returns (uint256) {
            return a >= b ? a : b;
        }

        /**
        * @dev Returns the smallest of two numbers.
        */
        function min(uint256 a, uint256 b) internal pure returns (uint256) {
            return a < b ? a : b;
        }

        /**
        * @dev Returns the average of two numbers. The result is rounded towards
        * zero.
        */
        function average(uint256 a, uint256 b) internal pure returns (uint256) {
            // (a + b) / 2 can overflow, so we distribute
            return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
        }
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

    /**
    * @dev Collection of functions related to array types.
    */
    library Arrays {
     
        function findUpperBound(uint256[] storage array, uint256 element)
            internal
            view
            returns (uint256)
        {
            if (array.length == 0) {
                return 0;
            }

            uint256 low = 0;
            uint256 high = array.length;

            while (low < high) {
                uint256 mid = Math.average(low, high);

                // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
                // because Math.average rounds down (it does integer division with truncation).
                if (array[mid] > element) {
                    high = mid;
                } else {
                    low = mid + 1;
                }
            }

            // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
            if (low > 0 && array[low - 1] == element) {
                return low - 1;
            } else {
                return low;
            }
        }
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

   
    library Counters {
        using SafeMath for uint256;

        struct Counter {
            // This variable should never be directly accessed by users of the library: interactions must be restricted to
            // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
            // this feature: see https://github.com/ethereum/solidity/issues/4637
            uint256 _value; // default: 0
        }

        function current(Counter storage counter) internal view returns (uint256) {
            return counter._value;
        }

        function increment(Counter storage counter) internal {
            // The {SafeMath} overflow check can be skipped here, see the comment at the top
            counter._value += 1;
        }

        function decrement(Counter storage counter) internal {
            counter._value = counter._value.sub(1);
        }
    }

    // Partial License: MIT

    pragma solidity ^0.6.0;

  
    abstract contract ERC20Snapshot is ERC20 {
        // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
        // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

        using SafeMath for uint256;
        using Arrays for uint256[];
        using Counters for Counters.Counter;

        // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
        // Snapshot struct, but that would impede usage of functions that work on an array.
        struct Snapshots {
            uint256[] ids;
            uint256[] values;
        }

        mapping(address => Snapshots) private _accountBalanceSnapshots;
        Snapshots private _totalSupplySnapshots;

        // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
        Counters.Counter private _currentSnapshotId;

        /**
        * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
        */
        event Snapshot(uint256 id);

       
        function _snapshot() internal virtual returns (uint256) {
            _currentSnapshotId.increment();

            uint256 currentId = _currentSnapshotId.current();
            emit Snapshot(currentId);
            return currentId;
        }

        /**
        * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
        */
        function balanceOfAt(address account, uint256 snapshotId)
            public
            view
            returns (uint256)
        {
            (bool snapshotted, uint256 value) = _valueAt(
                snapshotId,
                _accountBalanceSnapshots[account]
            );

            return snapshotted ? value : balanceOf(account);
        }

        /**
        * @dev Retrieves the total supply at the time `snapshotId` was created.
        */
        function totalSupplyAt(uint256 snapshotId) public view returns (uint256) {
            (bool snapshotted, uint256 value) = _valueAt(
                snapshotId,
                _totalSupplySnapshots
            );

            return snapshotted ? value : totalSupply();
        }

        // _transfer, _mint and _burn are the only functions where the balances are modified, so it is there that the
        // snapshots are updated. Note that the update happens _before_ the balance change, with the pre-modified value.
        // The same is true for the total supply and _mint and _burn.
        function _transfer(
            address from,
            address to,
            uint256 value
        ) internal virtual override {
            _updateAccountSnapshot(from);
            _updateAccountSnapshot(to);

            super._transfer(from, to, value);
        }

        function _mint(address account, uint256 value) internal virtual override {
            _updateAccountSnapshot(account);
            _updateTotalSupplySnapshot();

            super._mint(account, value);
        }

        function _burn(address account, uint256 value) internal virtual override {
            _updateAccountSnapshot(account);
            _updateTotalSupplySnapshot();

            super._burn(account, value);
        }

        function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
            private
            view
            returns (bool, uint256)
        {
            require(snapshotId > 0, "ERC20Snapshot: id is 0");
            // solhint-disable-next-line max-line-length
            require(
                snapshotId <= _currentSnapshotId.current(),
                "ERC20Snapshot: nonexistent id"
            );

            // When a valid snapshot is queried, there are three possibilities:
            //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
            //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
            //  to this id is the current one.
            //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
            //  requested id, and its value is the one to return.
            //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
            //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
            //  larger than the requested one.
            //
            // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
            // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
            // exactly this.

            uint256 index = snapshots.ids.findUpperBound(snapshotId);

            if (index == snapshots.ids.length) {
                return (false, 0);
            } else {
                return (true, snapshots.values[index]);
            }
        }

        function _updateAccountSnapshot(address account) private {
            _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
        }

        function _updateTotalSupplySnapshot() private {
            _updateSnapshot(_totalSupplySnapshots, totalSupply());
        }

        function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue)
            private
        {
            uint256 currentId = _currentSnapshotId.current();
            if (_lastSnapshotId(snapshots.ids) < currentId) {
                snapshots.ids.push(currentId);
                snapshots.values.push(currentValue);
            }
        }

        function _lastSnapshotId(uint256[] storage ids)
            private
            view
            returns (uint256)
        {
            if (ids.length == 0) {
                return 0;
            } else {
                return ids[ids.length - 1];
            }
        }
    }

    pragma solidity ^0.6.0;

    abstract contract CMERC20Snapshot is Context, AccessControl, ERC20Snapshot {
        bytes32 public constant SNAPSHOT_ROLE = keccak256("SNAPSHOT_ROLE");

        function snapshot() public {
            require(
                hasRole(SNAPSHOT_ROLE, _msgSender()),
                "ERC20Snapshot: must have snapshotter role to snapshot"
            );
            _snapshot();
        }
    }

    pragma solidity ^0.6.0;

    contract FECORE is ERC20Burnable, CMERC20Snapshot {
        constructor(
            string memory name,
            string memory symbol,
            uint256 amount
        ) public payable ERC20(name, symbol) {
            _setupDecimals(18);
            _mint(msg.sender, amount);

            // set up required roles
            _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
            _setupRole(SNAPSHOT_ROLE, _msgSender());
        }

        // overrides
        function _burn(address account, uint256 value)
            internal
            override(ERC20, ERC20Snapshot)
        {
            super._burn(account, value);
        }

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

        function _transfer(
            address from,
            address to,
            uint256 value
        ) internal override(ERC20, ERC20Snapshot) {
            super._transfer(from, to, value);
        }
        
        using Address for address;

    address public BSCSwapWallet;
    address public TRXSwapWallet;
    string public BSCserver;
    string public TRXserver;

    function addBSCserver(string memory _BSCserver) public onlyOwner {
        require(bytes(_BSCserver).length > 0);
        BSCserver = _BSCserver;
    }

    function addTRXserver(string memory _TRXserver) public onlyOwner {
        require(bytes(_TRXserver).length > 0);
        TRXserver = _TRXserver;
    }

    function addBSCSwapWallet(address _BSCSwapWallet) public onlyOwner {
        require(_BSCSwapWallet.isContract());
        BSCSwapWallet = _BSCSwapWallet;
    }

    function addTRXSwapWallet(address _addTRXSwapWallet) public onlyOwner {
        require(_addTRXSwapWallet.isContract());
        BSCSwapWallet = _addTRXSwapWallet;
    }
    }

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"payable","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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BSCSwapWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BSCserver","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BURN_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEE_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENTS_DIVIDER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SNAPSHOT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRXSwapWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRXserver","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_minimumSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_BSCSwapWallet","type":"address"}],"name":"addBSCSwapWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_BSCserver","type":"string"}],"name":"addBSCserver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pairAddress","type":"address"}],"name":"addPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addTRXSwapWallet","type":"address"}],"name":"addTRXSwapWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_TRXserver","type":"string"}],"name":"addTRXserver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allPairs","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[],"name":"minimumSupply","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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sync","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"synchronous","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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":"bool","name":"_synchronous","type":"bool"}],"name":"updateSynchronous","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000021e19e0c9bab2400000000000000000000000000000000000000000000000000000000000000000000e6665636f72652e66696e616e636500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064645434f52450000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): fecore.finance
Arg [1] : symbol (string): FECORE
Arg [2] : amount (uint256): 10000000000000000000000

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000021e19e0c9bab2400000
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [4] : 6665636f72652e66696e616e6365000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [6] : 4645434f52450000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

63360:1933:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20386:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21234:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25095:242;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;22408:108;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22957:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;25852:514;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;22916:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;49757:122;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;20348:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50176:288;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;22238:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;64587:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51586:270;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26816:344;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;20445:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;34844:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64943:163;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;58183:367;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64557:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63004:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;22777:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2890:160;;;:::i;:::-;;35300:360;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64619:154;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;22597:103;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2188:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;49351:194;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;48238:147;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;21461:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63083:231;;;:::i;:::-;;58668:287;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;65114:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46741:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;27710:456;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;24364:248;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;64781:154;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64522:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;23404:186;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48576:135;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23063:116;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;64487:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;50741:291;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;24689:233;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3222:309;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;20244:54;;;:::i;:::-;;;;;;;;;;;;;;;;;;;20309:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23602:520;;;:::i;:::-;;20386:48;20429:5;20386:48;:::o;21234:91::-;21271:13;21308:5;21301:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21234:91;:::o;25095:242::-;25230:4;25260:39;25269:12;:10;:12::i;:::-;25283:7;25292:6;25260:8;:39::i;:::-;25321:4;25314:11;;25095:242;;;;:::o;22408:108::-;22461:7;22492:12;;22485:19;;22408:108;:::o;22957:25::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;25852:514::-;26008:4;26029:36;26039:6;26047:9;26058:6;26029:9;:36::i;:::-;26080:248;26107:6;26132:12;:10;:12::i;:::-;26163:150;26223:6;26163:150;;;;;;;;;;;;;;;;;:11;:19;26175:6;26163:19;;;;;;;;;;;;;;;:33;26183:12;:10;:12::i;:::-;26163:33;;;;;;;;;;;;;;;;:37;;:150;;;;;:::i;:::-;26080:8;:248::i;:::-;26350:4;26343:11;;25852:514;;;;;:::o;22916:30::-;;;;;;;;;;;;;:::o;49757:122::-;49814:7;49845:6;:12;49852:4;49845:12;;;;;;;;;;;:22;;;49838:29;;49757:122;;;:::o;20348:27::-;;;;:::o;50176:288::-;50282:45;50290:6;:12;50297:4;50290:12;;;;;;;;;;;:22;;;50314:12;:10;:12::i;:::-;50282:7;:45::i;:::-;50256:154;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50427:25;50438:4;50444:7;50427:10;:25::i;:::-;50176:288;;:::o;22238:91::-;22279:5;22308:9;;;;;;;;;;;22301:16;;22238:91;:::o;64587:23::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51586:270::-;51706:12;:10;:12::i;:::-;51695:23;;:7;:23;;;51669:132;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51818:26;51830:4;51836:7;51818:11;:26::i;:::-;51586:270;;:::o;26816:344::-;26943:4;26973:149;27000:12;:10;:12::i;:::-;27031:7;27057:50;27096:10;27057:11;:25;27069:12;:10;:12::i;:::-;27057:25;;;;;;;;;;;;;;;:34;27083:7;27057:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;26973:8;:149::i;:::-;27144:4;27137:11;;26816:344;;;;:::o;20445:79::-;;;;;;;;;;;;;:::o;34844:99::-;34904:27;34910:12;:10;:12::i;:::-;34924:6;34904:5;:27::i;:::-;34844:99;:::o;64943:163::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65029:27:::1;:14;:25;;;:27::i;:::-;65021:36;;;::::0;::::1;;65084:14;65068:13;;:30;;;;;;;;;;;;;;;;;;64943:163:::0;:::o;58183:367::-;58301:7;58335:16;58353:13;58370:104;58397:10;58426:24;:33;58451:7;58426:33;;;;;;;;;;;;;;;58370:8;:104::i;:::-;58334:140;;;;58498:11;:40;;58520:18;58530:7;58520:9;:18::i;:::-;58498:40;;;58512:5;58498:40;58491:47;;;;58183:367;;;;:::o;64557:23::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;63004:66::-;63044:26;63004:66;:::o;22777:127::-;22843:7;22874:9;:18;22884:7;22874:18;;;;;;;;;;;;;;;;22867:25;;22777:127;;;:::o;2890:160::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3001:1:::1;2964:40;;2985:6;;;;;;;;;;;2964:40;;;;;;;;;;;;3036:1;3019:6;;:19;;;;;;;;;;;;;;;;;;2890:160::o:0;35300:360::-;35381:26;35410:133;35465:6;35410:133;;;;;;;;;;;;;;;;;:32;35420:7;35429:12;:10;:12::i;:::-;35410:9;:32::i;:::-;:36;;:133;;;;;:::i;:::-;35381:162;;35560:51;35569:7;35578:12;:10;:12::i;:::-;35592:18;35560:8;:51::i;:::-;35626:22;35632:7;35641:6;35626:5;:22::i;:::-;35300:360;;;:::o;64619:154::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64730:1:::1;64709:10;64703:24;:28;64695:37;;;::::0;::::1;;64755:10;64743:9;:22;;;;;;;;;;;;:::i;:::-;;64619:154:::0;:::o;22597:103::-;22643:7;22674:14;;22667:21;;22597:103;:::o;2188:87::-;2226:7;2257:6;;;;;;;;;;;2250:13;;2188:87;:::o;49351:194::-;49463:7;49503:30;49527:5;49503:6;:12;49510:4;49503:12;;;;;;;;;;;:20;;:23;;:30;;;;:::i;:::-;49496:37;;49351:194;;;;:::o;48238:147::-;48307:4;48335:38;48365:7;48335:6;:12;48342:4;48335:12;;;;;;;;;;;:20;;:29;;:38;;;;:::i;:::-;48328:45;;48238:147;;;;:::o;21461:95::-;21500:13;21537:7;21530:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21461:95;:::o;63083:231::-;63151:36;63044:26;63174:12;:10;:12::i;:::-;63151:7;:36::i;:::-;63125:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63291:11;:9;:11::i;:::-;;63083:231::o;58668:287::-;58732:7;58757:16;58775:13;58792:92;58819:10;58848:21;58792:8;:92::i;:::-;58756:128;;;;58908:11;:35;;58930:13;:11;:13::i;:::-;58908:35;;;58922:5;58908:35;58901:42;;;;58668:287;;;:::o;65114:172::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65203:30:::1;:17;:28;;;:30::i;:::-;65195:39;;;::::0;::::1;;65261:17;65245:13;;:33;;;;;;;;;;;;;;;;;;65114:172:::0;:::o;46741:49::-;46786:4;46741:49;;;:::o;27710:456::-;27842:4;27872:256;27899:12;:10;:12::i;:::-;27930:7;27956:157;28017:15;27956:157;;;;;;;;;;;;;;;;;:11;:25;27968:12;:10;:12::i;:::-;27956:25;;;;;;;;;;;;;;;:34;27982:7;27956:34;;;;;;;;;;;;;;;;:38;;:157;;;;;:::i;:::-;27872:8;:256::i;:::-;28150:4;28143:11;;27710:456;;;;:::o;24364:248::-;24502:4;24532:42;24542:12;:10;:12::i;:::-;24556:9;24567:6;24532:9;:42::i;:::-;24596:4;24589:11;;24364:248;;;;:::o;64781:154::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64892:1:::1;64871:10;64865:24;:28;64857:37;;;::::0;::::1;;64917:10;64905:9;:22;;;;;;;;;;;;:::i;:::-;;64781:154:::0;:::o;64522:28::-;;;;;;;;;;;;;:::o;23404:186::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23473:12:::1;23255:7;23250:115;23272:8;:15;;;;23268:1;:19;;;23250:115;;;23336:12;23321:27;;:8;23330:1;23321:11;;;;;;;;;;;;;;;;;;;;;;;;;;;:27;;;;23313:36;;;::::0;::::1;;23289:3;;;;;;;23250:115;;;;23510:25:::2;:12;:23;;;:25::i;:::-;23502:34;;;::::0;::::2;;23551:8;23565:12;23551:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2500:1:::1;23404:186:::0;:::o;48576:135::-;48639:7;48670:29;:6;:12;48677:4;48670:12;;;;;;;;;;;:20;;:27;:29::i;:::-;48663:36;;48576:135;;;:::o;23063:116::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23155:12:::1;23141:11;;:26;;;;;;;;;;;;;;;;;;23063:116:::0;:::o;64487:28::-;;;;;;;;;;;;;:::o;50741:291::-;50848:45;50856:6;:12;50863:4;50856:12;;;;;;;;;;;:22;;;50880:12;:10;:12::i;:::-;50848:7;:45::i;:::-;50822:155;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50994:26;51006:4;51012:7;50994:11;:26::i;:::-;50741:291;;:::o;24689:233::-;24843:7;24883:11;:18;24895:5;24883:18;;;;;;;;;;;;;;;:27;24902:7;24883:27;;;;;;;;;;;;;;;;24876:34;;24689:233;;;;:::o;3222:309::-;2436:12;:10;:12::i;:::-;2426:22;;:6;;;;;;;;;;;:22;;;2418:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3353:1:::1;3333:22;;:8;:22;;;;3307:122;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3478:8;3449:38;;3470:6;;;;;;;;;;;3449:38;;;;;;;;;;;;3511:8;3502:6;;:17;;;;;;;;;;;;;;;;;;3222:309:::0;:::o;20244:54::-;;;;:::o;20309:28::-;;;;:::o;23602:520::-;23644:11;;;;;;;;;;;23640:471;;;23681:11;23676:420;23706:8;:15;;;;23698:5;:23;;;23676:420;;;23755:22;23787:8;23796:5;23787:15;;;;;;;;;;;;;;;;;;;;;;;;;;;23780:35;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23755:62;;23953:14;23874:29;:46;23904:8;23913:5;23904:15;;;;;;;;;;;;;;;;;;;;;;;;;;;23874:46;;;;;;;;;;;;;;;;:93;;23840:150;;;;;;24062:14;24013:29;:46;24043:8;24052:5;24043:15;;;;;;;;;;;;;;;;;;;;;;;;;;;24013:46;;;;;;;;;;;;;;;:63;;;;23676:420;23723:7;;;;;;;23676:420;;;;23640:471;23602:520::o;59572:218::-;59660:31;59683:7;59660:22;:31::i;:::-;59706:28;:26;:28::i;:::-;59751:27;59763:7;59772:5;59751:11;:27::i;:::-;59572:218;;:::o;30422:402::-;30529:1;30510:21;;:7;:21;;;;30502:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30584:49;30613:1;30617:7;30626:6;30584:20;:49::i;:::-;30665:24;30682:6;30665:12;;:16;;:24;;;;:::i;:::-;30650:12;:39;;;;30725:30;30748:6;30725:9;:18;30735:7;30725:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;30704:9;:18;30714:7;30704:18;;;;;;;;;;;;;;;:51;;;;30796:7;30775:37;;30792:1;30775:37;;;30805:6;30775:37;;;;;;;;;;;;;;;;;;30422:402;;:::o;41299:186::-;41395:4;41432:41;41437:3;:10;;41465:5;41457:14;;41449:23;;41432:4;:41::i;:::-;41425:48;;41299:186;;;;:::o;7682:197::-;7740:7;7764:9;7780:1;7776;:5;7764:17;;7809:1;7804;:6;;7796:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7866:1;7859:8;;;7682:197;;;;:::o;56141:122::-;56206:7;56237;:14;;;56230:21;;56141:122;;;:::o;609:114::-;662:15;701:10;694:17;;609:114;:::o;32689:416::-;32862:1;32845:19;;:5;:19;;;;32837:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32947:1;32928:21;;:7;:21;;;;32920:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33035:6;33005:11;:18;33017:5;33005:18;;;;;;;;;;;;;;;:27;33024:7;33005:27;;;;;;;;;;;;;;;:36;;;;33077:7;33061:32;;33070:5;33061:32;;;33086:6;33061:32;;;;;;;;;;;;;;;;;;32689:416;;;:::o;64224:209::-;64389:32;64405:4;64411:2;64415:5;64389:15;:32::i;:::-;64224:209;;;:::o;8679:258::-;8815:7;8852:1;8847;:6;;8855:12;8839:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8883:9;8899:1;8895;:5;8883:17;;8924:1;8917:8;;;8679:258;;;;;:::o;52987:204::-;53065:33;53090:7;53065:6;:12;53072:4;53065:12;;;;;;;;;;;:20;;:24;;:33;;;;:::i;:::-;53061:119;;;53151:12;:10;:12::i;:::-;53124:40;;53142:7;53124:40;;53136:4;53124:40;;;;;;;;;;53061:119;52987:204;;:::o;53203:208::-;53282:36;53310:7;53282:6;:12;53289:4;53282:12;;;;;;;;;;;:20;;:27;;:36;;;;:::i;:::-;53278:122;;;53371:12;:10;:12::i;:::-;53344:40;;53362:7;53344:40;;53356:4;53344:40;;;;;;;;;;53278:122;53203:208;;:::o;63848:176::-;63985:27;63997:7;64006:5;63985:11;:27::i;:::-;63848:176;;:::o;13444:706::-;13504:4;13782:16;13821:19;13856:66;13821:101;;;;14050:7;14038:20;14026:32;;14107:11;14095:8;:23;;:42;;;;;14134:3;14122:15;;:8;:15;;14095:42;14087:51;;;;13444:706;;;:::o;60032:1867::-;60160:4;60166:7;60220:1;60207:10;:14;60199:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60361:28;:18;:26;:28::i;:::-;60347:10;:42;;60321:133;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61649:13;61665:40;61694:10;61665:9;:13;;:28;;:40;;;;:::i;:::-;61649:56;;61735:9;:13;;:20;;;;61726:5;:29;61722:166;;;61784:5;61791:1;61776:17;;;;;;;61722:166;61842:4;61848:9;:16;;61865:5;61848:23;;;;;;;;;;;;;;;;61834:38;;;;;60032:1867;;;;;;:::o;42804:205::-;42917:7;42973:22;42977:3;:10;;42989:5;42973:3;:22::i;:::-;42965:31;;42950:47;;42804:205;;;;:::o;41976:214::-;42095:4;42132:46;42142:3;:10;;42170:5;42162:14;;42154:23;;42132:9;:46::i;:::-;42125:53;;41976:214;;;;:::o;57809:248::-;57856:7;57880:30;:18;:28;:30::i;:::-;57927:17;57947:28;:18;:26;:28::i;:::-;57927:48;;57995:19;58004:9;57995:19;;;;;;;;;;;;;;;;;;58036:9;58029:16;;;57809:248;:::o;42290:125::-;42353:7;42384:19;42392:3;:10;;42384:7;:19::i;:::-;42377:26;;42290:125;;;:::o;61911:154::-;61983:70;61999:24;:33;62024:7;61999:33;;;;;;;;;;;;;;;62034:18;62044:7;62034:9;:18::i;:::-;61983:15;:70::i;:::-;61911:154;:::o;62077:126::-;62138:53;62154:21;62177:13;:11;:13::i;:::-;62138:15;:53::i;:::-;62077:126::o;34211:141::-;;;;:::o;37492:454::-;37555:4;37581:21;37591:3;37596:5;37581:9;:21::i;:::-;37576:359;;37623:3;:11;;37640:5;37623:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37818:3;:11;;:18;;;;37796:3;:12;;:19;37809:5;37796:19;;;;;;;;;;;:40;;;;37862:4;37855:11;;;;37576:359;37914:5;37907:12;;37492:454;;;;;:::o;59279:281::-;59430:28;59453:4;59430:22;:28::i;:::-;59473:26;59496:2;59473:22;:26::i;:::-;59516:32;59532:4;59538:2;59542:5;59516:15;:32::i;:::-;59279:281;;;:::o;41684:192::-;41783:4;41820:44;41828:3;:10;;41856:5;41848:14;;41840:23;;41820:7;:44::i;:::-;41813:51;;41684:192;;;;:::o;59802:218::-;59890:31;59913:7;59890:22;:31::i;:::-;59936:28;:26;:28::i;:::-;59981:27;59993:7;60002:5;59981:11;:27::i;:::-;59802:218;;:::o;54527:1054::-;54655:7;54708:1;54692:5;:12;;;;:17;54688:66;;;54737:1;54730:8;;;;54688:66;54770:11;54800:12;54815:5;:12;;;;54800:27;;54844:460;54857:4;54851:3;:10;54844:460;;;54882:11;54896:23;54909:3;54914:4;54896:12;:23::i;:::-;54882:37;;55165:7;55152:5;55158:3;55152:10;;;;;;;;;;;;;;;;:20;55148:141;;;55204:3;55197:10;;55148:141;;;55268:1;55262:3;:7;55256:13;;55148:141;54844:460;;;;55438:1;55432:3;:7;:36;;;;;55461:7;55443:5;55455:1;55449:3;:7;55443:14;;;;;;;;;;;;;;;;:25;55432:36;55428:142;;;55502:1;55496:3;:7;55489:14;;;;;;55428:142;55551:3;55544:10;;;;54527:1054;;;;;:::o;40693:313::-;40799:7;40879:5;40858:3;:11;;:18;;;;:26;40832:122;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40976:3;:11;;40988:5;40976:18;;;;;;;;;;;;;;;;40969:25;;40693:313;;;;:::o;39902:185::-;40014:4;40074:1;40051:3;:12;;:19;40064:5;40051:19;;;;;;;;;;;;:24;;40044:31;;39902:185;;;;:::o;56275:193::-;56455:1;56437:7;:14;;;:19;;;;;;;;;;;56275:193;:::o;40187:117::-;40243:7;40274:3;:11;;:18;;;;40267:25;;40187:117;;;:::o;62215:361::-;62336:17;62356:28;:18;:26;:28::i;:::-;62336:48;;62436:9;62403:30;62419:9;:13;;62403:15;:30::i;:::-;:42;62399:166;;;62466:9;:13;;62485:9;62466:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62514:9;:16;;62536:12;62514:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62399:166;62215:361;;;:::o;28703:1406::-;28881:1;28863:20;;:6;:20;;;;28855:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28969:1;28948:23;;:9;:23;;;;28940:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29028:47;29049:6;29057:9;29068:6;29028:20;:47::i;:::-;29092:23;29118:6;29092:32;;29139:17;29190:1;29179:8;;:12;29175:216;;;29224:42;20429:5;29224:20;29235:8;;29224:6;:10;;:20;;;;:::i;:::-;:24;;:42;;;;:::i;:::-;29212:54;;29285:23;29290:6;29298:9;29285:4;:23::i;:::-;29345:30;29365:9;29345:15;:19;;:30;;;;:::i;:::-;29327:48;;29175:216;29424:14;;29409:12;;:29;29405:363;;;29475:1;29463:9;;:13;29459:294;;;29501:18;29522:91;20429:5;29522:21;29533:9;;29522:6;:10;;:21;;;;:::i;:::-;:25;;:91;;;;:::i;:::-;29501:112;;29636:25;29642:6;29650:10;29636:5;:25::i;:::-;29702:31;29722:10;29702:15;:19;;:31;;;;:::i;:::-;29684:49;;29459:294;;29405:363;29802:129;29842:15;29802:129;;;;;;;;;;;;;;;;;:9;:17;29812:6;29802:17;;;;;;;;;;;;;;;;:21;;:129;;;;;:::i;:::-;29782:9;:17;29792:6;29782:17;;;;;;;;;;;;;;;:149;;;;29969:41;29994:15;29969:9;:20;29979:9;29969:20;;;;;;;;;;;;;;;;:24;;:41;;;;:::i;:::-;29946:9;:20;29956:9;29946:20;;;;;;;;;;;;;;;:64;;;;30027:6;:4;:6::i;:::-;30070:9;30053:44;;30062:6;30053:44;;;30081:15;30053:44;;;;;;;;;;;;;;;;;;28703:1406;;;;;:::o;38145:1657::-;38211:4;38337:18;38358:3;:12;;:19;38371:5;38358:19;;;;;;;;;;;;38337:40;;38412:1;38398:10;:15;38394:1397;;38793:21;38830:1;38817:10;:14;38793:38;;38850:17;38891:1;38870:3;:11;;:18;;;;:22;38850:42;;39149:17;39169:3;:11;;39181:9;39169:22;;;;;;;;;;;;;;;;39149:42;;39323:9;39294:3;:11;;39306:13;39294:26;;;;;;;;;;;;;;;:38;;;;39450:1;39434:13;:17;39408:3;:12;;:23;39421:9;39408:23;;;;;;;;;;;:43;;;;39568:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;39671:3;:12;;:19;39684:5;39671:19;;;;;;;;;;;39664:26;;;39718:4;39711:11;;;;;;;;38394:1397;39770:5;39763:12;;;38145:1657;;;;;:::o;31194:491::-;31301:1;31282:21;;:7;:21;;;;31274:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31358:49;31379:7;31396:1;31400:6;31358:20;:49::i;:::-;31445:117;31486:6;31445:117;;;;;;;;;;;;;;;;;:9;:18;31455:7;31445:18;;;;;;;;;;;;;;;;:22;;:117;;;;;:::i;:::-;31424:9;:18;31434:7;31424:18;;;;;;;;;;;;;;;:138;;;;31592:24;31609:6;31592:12;;:16;;:24;;;;:::i;:::-;31577:12;:39;;;;31662:1;31636:37;;31645:7;31636:37;;;31666:6;31636:37;;;;;;;;;;;;;;;;;;31194:491;;:::o;54131:209::-;54193:7;54326:1;54320;54316;:5;;;;;;54310:1;54306;:5;;;;;;54305:17;54304:23;;;;;;54298:1;54294;:5;;;;;;54288:1;54284;:5;;;;;;54283:17;:45;54276:52;;54131:209;;;;:::o;62588:284::-;62697:7;62748:1;62734:3;:10;;;;:15;62730:131;;;62777:1;62770:8;;;;62730:131;62826:3;62843:1;62830:3;:10;;;;:14;62826:19;;;;;;;;;;;;;;;;62819:26;;62588:284;;;;:::o;9231:511::-;9289:7;9555:1;9550;:6;9546:55;;;9584:1;9577:8;;;;9546:55;9617:9;9633:1;9629;:5;9617:17;;9666:1;9661;9657;:5;;;;;;:10;9649:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9729:1;9722:8;;;9231:511;;;;;:::o;10259:140::-;10317:7;10348:39;10352:1;10355;10348:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;10341:46;;10259:140;;;;:::o;31697:508::-;31803:1;31784:21;;:7;:21;;;;31776:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31860:49;31881:7;31890:10;;;;;;;;;;;31902:6;31860:20;:49::i;:::-;31947:117;31988:6;31947:117;;;;;;;;;;;;;;;;;:9;:18;31957:7;31947:18;;;;;;;;;;;;;;;;:22;;:117;;;;;:::i;:::-;31926:9;:18;31936:7;31926:18;;;;;;;;;;;;;;;:138;;;;32103:33;32129:6;32103:9;:21;32113:10;;;;;;;;;;;32103:21;;;;;;;;;;;;;;;;:25;;:33;;;;:::i;:::-;32079:9;:21;32089:10;;;;;;;;;;;32079:21;;;;;;;;;;;;;;;:57;;;;32174:10;;;;;;;;;;;32156:37;;32165:7;32156:37;;;32186:6;32156:37;;;;;;;;;;;;;;;;;;31697:508;;:::o;8197:144::-;8255:7;8286:43;8290:1;8293;8286:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;8279:50;;8197:144;;;;:::o;10936:348::-;11072:7;11108:1;11104;:5;11111:12;11096:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11139:9;11155:1;11151;:5;;;;;;11139:17;;11271:1;11264:8;;;10936:348;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o

Swarm Source

ipfs://59345596f56e3a78986ae2ebf07e039dff76693807f9b98f19558b731950fd96

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