Contract 0x044C53F5fB9b534eE128609C67bf3017F583a805

/**
 *Submitted for verification at polygonscan.com on 2021-10-10
*/

// File: Context.sol



pragma solidity >=0.6.0 <0.8.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 view virtual returns (address payable) {
        return msg.sender;
    }

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


// File: Ownable.sol



pragma solidity >=0.6.0 <0.8.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.
 */
abstract 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 virtual returns (address) {
        return _owner;
    }

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

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

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


// File: IERC20.sol



pragma solidity >=0.6.4;

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

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

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

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

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



// File: ERC20.sol



pragma solidity >=0.4.0;






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

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

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

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

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

    /**
    * @dev Returns the number of decimals used to get its user representation.
    */
    function decimals() public override view returns (uint8) {
        return _decimals;
    }

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

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

    /**
     * @dev See {ERC20-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 override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

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

    /**
     * @dev See {ERC20-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 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 {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public 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 {ERC20-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 returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'ERC20: decreased allowance below zero'));
        return true;
    }

    /**
     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
     * the total supply.
     *
     * Requirements
     *
     * - `msg.sender` must be the token owner
     */
    function mint(uint256 amount) public onlyOwner returns (bool) {
        _mint(_msgSender(), amount);
        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');

        _balances[sender] = _balances[sender].sub(amount, 'ERC20: transfer amount exceeds balance');
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

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

        _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 {
        require(account != address(0), 'ERC20: burn from the zero address');

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This 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 {
        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 Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'ERC20: burn amount exceeds allowance'));
    }
}



// File: Flerovium.sol



pragma solidity 0.6.12;


// Flerovium Token with Governance.
contract Flerovium is ERC20 {

    using SafeMath for uint;
    /// @dev Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }

    // Burn address
    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
    // Addresses that excluded from antiWhale
    mapping(address => bool) private _excludedFromAntiWhale;
    // Max transfer amount rate in basis points. Eg: 50 - 0.5% of total supply (default the anti whale feature is turned off - set to 10000.)
    uint256 public maxTransferAmountRate = 150000 ether;
    // The operator can only update the Anti Whale Settings
    address public _operator;

    // Events
    event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
    event MaxTransferAmountRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate);

    /**
     * @notice Constructs the Flerovium contract.
     */
    constructor() public ERC20('Flerovium', 'FLEROVIUM') {
        _operator = _msgSender();
        emit OperatorTransferred(address(0), _operator);

        _excludedFromAntiWhale[msg.sender] = true;
        _excludedFromAntiWhale[address(0)] = true;
        _excludedFromAntiWhale[address(this)] = true;
        _excludedFromAntiWhale[BURN_ADDRESS] = true;
    }

    modifier onlyOperator() {
        require(_operator == msg.sender, "operator: caller is not the operator");
        _;
    }

    modifier antiWhale(address sender, address recipient, uint256 amount) {
        if (maxTransferAmount() > 0) {
            if (
                _excludedFromAntiWhale[sender] == false
            ) {
                require(amount <= maxTransferAmount(), "Flerovium::antiWhale: Transfer amount exceeds the maxTransferAmount");
            }
        }
        _;
    }

    /**
     * @dev Returns the max transfer amount.
     */
    function maxTransferAmount() public view returns (uint256) {
        return totalSupply();
    }

    /**
     * @dev Update the max transfer amount rate.
     * Can only be called by the current operator.
     */
    function updateMaxTransferAmountRate(uint256 _maxTransferAmountRate) public onlyOperator {
        require(_maxTransferAmountRate <= 100000 ether, "Flerovium::updateMaxTransferAmountRate: Max transfer amount rate must not exceed the maximum rate.");
        emit MaxTransferAmountRateUpdated(msg.sender, maxTransferAmountRate, _maxTransferAmountRate);
        maxTransferAmountRate = _maxTransferAmountRate;
    }

    /**
     * @dev Returns the address is excluded from antiWhale or not.
     */
    function isExcludedFromAntiWhale(address _account) public view returns (bool) {
        return _excludedFromAntiWhale[_account];
    }

    /**
     * @dev Exclude or include an address from antiWhale.
     * Can only be called by the current operator.
     */
    function setExcludedFromAntiWhale(address _account, bool _excluded) public onlyOperator {
        _excludedFromAntiWhale[_account] = _excluded;
    }

    /// @dev overrides transfer function to meet tokenomics of Flerovium
    function _transfer(address sender, address recipient, uint256 amount) internal virtual override antiWhale(sender, recipient, amount) {
        super._transfer(sender, recipient, amount);
    }

    /**
     * @dev Transfers operator of the contract to a new account (`newOperator`).
     * Can only be called by the current operator.
     */
    function transferOperator(address newOperator) public onlyOperator {
        require(newOperator != address(0), "PolyZapToken::transferOperator: new operator is the zero address");
        emit OperatorTransferred(_operator, newOperator);
        _operator = newOperator;
    }

    // Copied and modified from YAM code:
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
    // Which is copied and modified from COMPOUND:
    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol

    /// @dev A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @dev A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @dev A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @dev The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @dev The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @dev The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @dev A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

      /// @dev An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @dev An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @dev Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @dev Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "TNDR::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "TNDR::delegateBySig: invalid nonce");
        require(block.timestamp <= expiry, "TNDR::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @dev Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @dev Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "TNDR::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying TNDRs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld.sub(amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "TNDR::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}


// File: ReentrancyGuard.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}




// File: Address.sol



pragma solidity >=0.6.2 <0.8.0;

/**
 * @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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @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");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        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);
            }
        }
    }
}

// File: SafeERC20.sol



pragma solidity >=0.6.0 <0.8.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}



// File: SafeMath.sol



pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

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

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

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

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

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: MasterChef.sol



pragma solidity  0.6.12;







// MasterChef is the master of Flerovium Token (Flerovium). He can make Flerovium and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. Initially the ownership is
// transferred to TimeLock contract and Later the ownership will be transferred to a governance smart
// contract once $FLEROVIUM is sufficiently distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 rewardLockedUp;  // Reward locked up.
        uint256 nextHarvestUntil; // When can the user harvest again.
        //
        // We do some fancy math here. Basically, any point in time, the amount of Fleroviums
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accFleroviumPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accFleroviumPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. Fleroviums to distribute per block.
        uint256 lastRewardBlock; // Last block number that Fleroviums distribution occurs.
        uint256 accFleroviumPerShare; // Accumulated Fleroviums per share, times 1e18. See below.
        uint16 depositFeeBP; // Deposit fee in basis points
        uint256 harvestInterval;  // Harvest interval in seconds
    }

    // The Flerovium Token!
    Flerovium public flerovium;
    // Dev address.
    address public devAddr;
    // Deposit Fee address
    address public feeAddress;
    // flerovium tokens created per block.
    uint256 public FleroviumPerBlock;
    // Max harvest interval: 14 days.
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 14 days;
    // Total locked up rewards
    uint256 public totalLockedUpRewards;
    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block number when Flerovium mining starts.
    uint256 public startBlock;
    // Referral Bonus in basis points. Initially set to 5%
    uint256 public refBonusBP = 500;
    // Max deposit fee: 5%.
    uint16 public constant MAXIMUM_DEPOSIT_FEE_BP = 500;
    // Max referral commission rate: 10%.
    uint16 public constant MAXIMUM_REFERRAL_BP = 1000;
    // Referral Mapping
    mapping(address => address) public referrers; // account_address -> referrer_address
    mapping(address => uint256) public referredCount; // referrer_address -> num_of_referred
    // Pool Exists Mapper
    mapping(IERC20 => bool) public poolExistence;
    // Pool ID Tracker Mapper
    mapping(IERC20 => uint256) public poolIdForLpAddress;

    // Initial emission rate: 0.2 Flerovium per block.
    uint256 public constant INITIAL_EMISSION_RATE = 0.2 ether;
    // Max Flerovium Supply
    uint256 public constant MAX_SUPPLY_CAP =  2000000 ether;


    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(
        address indexed user,
        uint256 indexed pid,
        uint256 amount
    );
    event SetFeeAddress(address indexed user, address indexed _devAddress);
    event SetDevAddress(address indexed user, address indexed _feeAddress);
    event Referral(address indexed _referrer, address indexed _user);
    event ReferralPaid(address indexed _user, address indexed _userTo, uint256 _reward);
    event ReferralBonusBpChanged(uint256 _oldBp, uint256 _newBp);
    event UpdateEmissionRate(address indexed user, uint256 indexed __FleroviumPerBlock);
    event RewardLockedUp(address indexed user, uint256 indexed pid, uint256 amountLockedUp);

    constructor(
        Flerovium _Flerovium,
        address _devAddr,
        address _feeAddress,
        uint256 _startBlock
    ) public {
        flerovium = _Flerovium;
        devAddr = _devAddr;
        feeAddress = _feeAddress;
        FleroviumPerBlock = INITIAL_EMISSION_RATE;
        startBlock = _startBlock;
    }

    // Get number of pools added.
    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    function getPoolIdForLpToken(IERC20 _lpToken) external view returns (uint256) {
        require(poolExistence[_lpToken] != false, "getPoolIdForLpToken: do not exist");
        return poolIdForLpAddress[_lpToken];
    }

    // Modifier to check Duplicate pools
    modifier nonDuplicated(IERC20 _lpToken) {
        require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated");
        _;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        bool _withUpdate
    ) public onlyOwner nonDuplicated(_lpToken) {
        require(_depositFeeBP <= MAXIMUM_DEPOSIT_FEE_BP, "add: invalid deposit fee basis points");
        require(_harvestInterval <= MAXIMUM_HARVEST_INTERVAL, "add: invalid harvest interval");
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolExistence[_lpToken] = true;
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accFleroviumPerShare: 0,
                depositFeeBP: _depositFeeBP,
                harvestInterval: _harvestInterval
            })
        );
        poolIdForLpAddress[_lpToken] = poolInfo.length - 1;
    }

    // Update the given pool's Flerovium allocation point and deposit fee. Can only be called by the owner.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        bool _withUpdate
    ) public onlyOwner {
        require(_depositFeeBP <= MAXIMUM_DEPOSIT_FEE_BP, "set: invalid deposit fee basis points");
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(
            _allocPoint
        );
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
        poolInfo[_pid].harvestInterval = _harvestInterval;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to)
        public
        view
        returns (uint256)
    {
        if (IERC20(flerovium).totalSupply() + totalLockedUpRewards  >= MAX_SUPPLY_CAP) {
            return 0;
        }
        return _to.sub(_from);
    }

    // View function to see pending Fleroviums on frontend.
    function pendingFlerovium(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accFleroviumPerShare = pool.accFleroviumPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier =
                getMultiplier(pool.lastRewardBlock, block.number);
            uint256 FleroviumReward =
                multiplier.mul(FleroviumPerBlock).mul(pool.allocPoint).div(
                    totalAllocPoint
                );
            accFleroviumPerShare = accFleroviumPerShare.add(
                FleroviumReward.mul(1e18).div(lpSupply)
            );
        }
        uint256 pending =  user.amount.mul(accFleroviumPerShare).div(1e18).sub(user.rewardDebt);
        return pending.add(user.rewardLockedUp);
    }

    // View function to see if user can harvest Flerovium's.
    function canHarvest(uint256 _pid, address _user) public view returns (bool) {
        UserInfo storage user = userInfo[_pid][_user];
        return block.timestamp >= user.nextHarvestUntil;
    }

    // View function to see if user harvest until time.
    function getHarvestUntil(uint256 _pid, address _user) public view returns (uint256) {
        UserInfo storage user = userInfo[_pid][_user];
        return user.nextHarvestUntil;
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 FleroviumReward =
            multiplier.mul(FleroviumPerBlock).mul(pool.allocPoint).div(
                totalAllocPoint
            );
        flerovium.mint(devAddr, FleroviumReward.div(10));
        flerovium.mint(address(this), FleroviumReward);
        pool.accFleroviumPerShare = pool.accFleroviumPerShare.add(
            FleroviumReward.mul(1e18).div(lpSupply)
        );
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for flerovium allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        payOrLockupPendingFlerovium(_pid);
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                user.amount = user.amount.add(_amount).sub(depositFee);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
            } else {
                user.amount = user.amount.add(_amount);
            }
            user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);
        }
        user.rewardDebt = user.amount.mul(pool.accFleroviumPerShare).div(1e18);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Deposit LP tokens to MasterChef for flerovium allocation with referral.
    function deposit(uint256 _pid, uint256 _amount, address _referrer) public nonReentrant {
        require(_referrer == address(_referrer),"deposit: Invalid referrer address");
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        payOrLockupPendingFlerovium(_pid);
        if (_amount > 0) {
            setReferral(msg.sender, _referrer);
            pool.lpToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                user.amount = user.amount.add(_amount).sub(depositFee);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
            } else {
                user.amount = user.amount.add(_amount);
            }
            user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);
        }
        user.rewardDebt = user.amount.mul(pool.accFleroviumPerShare).div(1e18);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        payOrLockupPendingFlerovium(_pid);
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accFleroviumPerShare).div(1e18);
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Pay or lockup pending flerovium.
    function payOrLockupPendingFlerovium(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        if (user.nextHarvestUntil == 0) {
            user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);
        }

        uint256 pending = user.amount.mul(pool.accFleroviumPerShare).div(1e18).sub(user.rewardDebt);
        if (canHarvest(_pid, msg.sender)) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 totalRewards = pending.add(user.rewardLockedUp);

                // reset lockup
                totalLockedUpRewards = totalLockedUpRewards.sub(user.rewardLockedUp);
                user.rewardLockedUp = 0;
                user.nextHarvestUntil = block.timestamp.add(pool.harvestInterval);

                // send rewards
                safeFleroviumTransfer(msg.sender, totalRewards);
                payReferralCommission(msg.sender, totalRewards);
            }
        } else if (pending > 0) {
            user.rewardLockedUp = user.rewardLockedUp.add(pending);
            totalLockedUpRewards = totalLockedUpRewards.add(pending);
            emit RewardLockedUp(msg.sender, _pid, pending);
        }
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        pool.lpToken.safeTransfer(address(msg.sender), user.amount);
        emit EmergencyWithdraw(msg.sender, _pid, user.amount);
        user.amount = 0;
        user.rewardDebt = 0;
        user.rewardLockedUp = 0;
        user.nextHarvestUntil = 0;
    }

    // Safe flerovium transfer function, just in case if rounding error causes pool to not have enough fleroviums.
    function safeFleroviumTransfer(address _to, uint256 _amount) internal {
        uint256 FleroviumBal = flerovium.balanceOf(address(this));
        bool transferSuccess = false;
        if (_amount > FleroviumBal) {
            transferSuccess = flerovium.transfer(_to, FleroviumBal);
        } else {
            transferSuccess = flerovium.transfer(_to, _amount);
        }
        require(transferSuccess, "safeFleroviumTransfer: transfer failed.");
    }

    // Update dev address by the previous dev.
    function setDevAddress(address _devaddr) public {
        require(_devaddr != address(0), "dev: invalid address");
        require(msg.sender == devAddr, "dev: wut?");
        devAddr = _devaddr;
        emit SetDevAddress(msg.sender, _devaddr);
    }

    // Update fee address by the previous fee address.
    function setFeeAddress(address _feeAddress) public {
        require(_feeAddress != address(0), "setFeeAddress: invalid address");
        require(msg.sender == feeAddress, "setFeeAddress: FORBIDDEN");
        feeAddress = _feeAddress;
        emit SetFeeAddress(msg.sender, _feeAddress);
    }

    // Update Emission Rate to control the emission per block (TimeLocked).
    function updateEmissionRate(uint256 _FleroviumPerBlock) public onlyOwner {
        massUpdatePools();
        FleroviumPerBlock = _FleroviumPerBlock;
        emit UpdateEmissionRate(msg.sender, _FleroviumPerBlock);
    }

    // Set Referral Address for a user
    function setReferral(address _user, address _referrer) internal {
        if (_referrer == address(_referrer) && referrers[_user] == address(0) && _referrer != address(0) && _referrer != _user) {
            referrers[_user] = _referrer;
            referredCount[_referrer] += 1;
            emit Referral(_user, _referrer);
        }
    }

    // Get Referral Address for a Account
    function getReferral(address _user) public view returns (address) {
        return referrers[_user];
    }

    // Pay referral commission to the referrer who referred this user.
    function payReferralCommission(address _user, uint256 _pending) internal {
        address referrer = getReferral(_user);
        if (referrer != address(0) && referrer != _user && refBonusBP > 0) {
            uint256 refBonusEarned = _pending.mul(refBonusBP).div(10000);
            flerovium.mint(referrer, refBonusEarned);
            emit ReferralPaid(_user, referrer, refBonusEarned);
        }
    }

    // Referral Bonus in basis points.
    // Initially set to 2%, this this the ability to increase or decrease the Bonus percentage based on
    // community voting and feedback.
    function updateReferralBonusBp(uint256 _newRefBonusBp) public onlyOwner {
        require(_newRefBonusBp <= MAXIMUM_REFERRAL_BP, "updateRefBonusPercent: invalid referral bonus basis points");
        require(_newRefBonusBp != refBonusBP, "updateRefBonusPercent: same bonus bp set");
        uint256 previousRefBonusBP = refBonusBP;
        refBonusBP = _newRefBonusBp;
        emit ReferralBonusBpChanged(previousRefBonusBP, _newRefBonusBp);
    }

    //Only update before start of farm
    function updateStartBlock(uint256 _startBlock) public onlyOwner {
        startBlock = _startBlock;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract Flerovium","name":"_Flerovium","type":"address"},{"internalType":"address","name":"_devAddr","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_referrer","type":"address"},{"indexed":true,"internalType":"address","name":"_user","type":"address"}],"name":"Referral","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_oldBp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_newBp","type":"uint256"}],"name":"ReferralBonusBpChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_user","type":"address"},{"indexed":true,"internalType":"address","name":"_userTo","type":"address"},{"indexed":false,"internalType":"uint256","name":"_reward","type":"uint256"}],"name":"ReferralPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLockedUp","type":"uint256"}],"name":"RewardLockedUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"_feeAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"_devAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"__FleroviumPerBlock","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"FleroviumPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"INITIAL_EMISSION_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_DEPOSIT_FEE_BP","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_HARVEST_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_REFERRAL_BP","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY_CAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"canHarvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_referrer","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flerovium","outputs":[{"internalType":"contract Flerovium","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"getHarvestUntil","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_lpToken","type":"address"}],"name":"getPoolIdForLpToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getReferral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingFlerovium","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolIdForLpAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accFleroviumPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"harvestInterval","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refBonusBP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"referredCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"referrers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devaddr","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedUpRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_FleroviumPerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newRefBonusBp","type":"uint256"}],"name":"updateReferralBonusBp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"name":"updateStartBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLockedUp","type":"uint256"},{"internalType":"uint256","name":"nextHarvestUntil","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d9d50718152c650b120372276ba08d3c17abbc5600000000000000000000000000d5cc33db4bafdc928e4da18382bc0502d25aae000000000000000000000000fc0c7ce07d0c317eac994f21a7cd245ec366ef72000000000000000000000000000000000000000000000000000000000136f578

-----Decoded View---------------
Arg [0] : _Flerovium (address): 0xd9d50718152c650b120372276ba08d3c17abbc56
Arg [1] : _devAddr (address): 0x00d5cc33db4bafdc928e4da18382bc0502d25aae
Arg [2] : _feeAddress (address): 0xfc0c7ce07d0c317eac994f21a7cd245ec366ef72
Arg [3] : _startBlock (uint256): 20379000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000d9d50718152c650b120372276ba08d3c17abbc56
Arg [1] : 00000000000000000000000000d5cc33db4bafdc928e4da18382bc0502d25aae
Arg [2] : 000000000000000000000000fc0c7ce07d0c317eac994f21a7cd245ec366ef72
Arg [3] : 000000000000000000000000000000000000000000000000000000000136f578

51196:18496:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55775:95;;;:::i;:::-;;;;;;;;;;;;;;;;67618:224;;;;;;;;;;;;;;;;-1:-1:-1;67618:224:0;;:::i;:::-;;53299:26;;;;;;;;;;;;;;;;-1:-1:-1;53299:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;53299:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53540:34;;;:::i;55878:221::-;;;;;;;;;;;;;;;;-1:-1:-1;55878:221:0;-1:-1:-1;;;;;55878:221:0;;:::i;57565:642::-;;;;;;;;;;;;;;;;-1:-1:-1;57565:642:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;53055:32::-;;;:::i;59703:198::-;;;;;;;;;;;;;;;;-1:-1:-1;59703:198:0;;;;;;-1:-1:-1;;;;;59703:198:0;;:::i;:::-;;;;;;;;;;;;;;;;;;58629:1004;;;;;;;;;;;;;;;;-1:-1:-1;58629:1004:0;;;;;;-1:-1:-1;;;;;58629:1004:0;;:::i;53896:49::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;68288:108;;;;;;;;;;;;;;;;-1:-1:-1;68288:108:0;-1:-1:-1;;;;;68288:108:0;;:::i;:::-;;;;-1:-1:-1;;;;;68288:108:0;;;;;;;;;;;;;;54067:48;;;;;;;;;;;;;;;;-1:-1:-1;54067:48:0;-1:-1:-1;;;;;54067:48:0;;:::i;52979:25::-;;;:::i;63820:616::-;;;;;;;;;;;;;;;;-1:-1:-1;63820:616:0;;;;;;;:::i;53230:35::-;;;:::i;53636:25::-;;;:::i;53977:44::-;;;;;;;;;;;;;;;;-1:-1:-1;53977:44:0;-1:-1:-1;;;;;53977:44:0;;:::i;60492:919::-;;;;;;;;;;;;;;;;-1:-1:-1;60492:919:0;;:::i;65829:439::-;;;;;;;;;;;;;;;;-1:-1:-1;65829:439:0;;:::i;54480:55::-;;;:::i;60236:180::-;;;:::i;69081:453::-;;;;;;;;;;;;;;;;-1:-1:-1;69081:453:0;;:::i;53728:31::-;;;:::i;59966:187::-;;;;;;;;;;;;;;;;-1:-1:-1;59966:187:0;;;;;;-1:-1:-1;;;;;59966:187:0;;:::i;2693:148::-;;;:::i;67234:299::-;;;;;;;;;;;;;;;;-1:-1:-1;67234:299:0;-1:-1:-1;;;;;67234:299:0;;:::i;2042:87::-;;;:::i;58283:277::-;;;;;;;;;;;;;;;;-1:-1:-1;58283:277:0;;;;;;;:::i;62593:1175::-;;;;;;;;;;;;;;;;-1:-1:-1;62593:1175:0;;;;;;;;;;;-1:-1:-1;;;;;62593:1175:0;;:::i;54387:57::-;;;:::i;53381:64::-;;;;;;;;;;;;;;;;-1:-1:-1;53381:64:0;;;;;;-1:-1:-1;;;;;53381:64:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53795:51;;;:::i;54270:52::-;;;;;;;;;;;;;;;;-1:-1:-1;54270:52:0;-1:-1:-1;;;;;54270:52:0;;:::i;56365:1083::-;;;;;;;;;;;;;;;;-1:-1:-1;56365:1083:0;;;-1:-1:-1;;;;;56365:1083:0;;;;;;;;;;;;;;;;;;;;;;;;:::i;54188:44::-;;;;;;;;;;;;;;;;-1:-1:-1;54188:44:0;-1:-1:-1;;;;;54188:44:0;;:::i;66914:256::-;;;;;;;;;;;;;;;;-1:-1:-1;66914:256:0;-1:-1:-1;;;;;66914:256:0;;:::i;52922:22::-;;;:::i;53133:58::-;;;:::i;61485:1020::-;;;;;;;;;;;;;;;;-1:-1:-1;61485:1020:0;;;;;;;:::i;52868:26::-;;;:::i;2996:244::-;;;;;;;;;;;;;;;;-1:-1:-1;2996:244:0;-1:-1:-1;;;;;2996:244:0;;:::i;69582:107::-;;;;;;;;;;;;;;;;-1:-1:-1;69582:107:0;;:::i;55775:95::-;55847:8;:15;55775:95;:::o;67618:224::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;67702:17:::1;:15;:17::i;:::-;67730;:38:::0;;;67784:50:::1;::::0;67750:18;;67803:10:::1;::::0;67784:50:::1;::::0;;;::::1;67618:224:::0;:::o;53299:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53299:26:0;;;;-1:-1:-1;53299:26:0;;;;;;;;;;:::o;53540:34::-;;;;:::o;55878:221::-;-1:-1:-1;;;;;55975:23:0;;55947:7;55975:23;;;:13;:23;;;;;;;;55967:78;;;;-1:-1:-1;;;55967:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56063:28:0;;;;;:18;:28;;;;;;;55878:221::o;57565:642::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;53843:3:::1;57767:39;::::0;::::1;;;57759:89;;;;-1:-1:-1::0;;;57759:89:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57863:11;57859:61;;;57891:17;:15;:17::i;:::-;57948:87;58013:11;57948:46;57968:8;57977:4;57968:14;;;;;;;;;;;;;;;;;;:25;;;57948:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:87::i;:::-;57930:15;:105;;;;58074:11;58046:8;58055:4;58046:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;58126:13;58096:8;58105:4;58096:14;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;58183:16;58150:8;58159:4;58150:14;;;;;;;;;;;;;;;;;;:30;;:49;;;;57565:642:::0;;;;;:::o;53055:32::-;;;;:::o;59703:198::-;59773:4;59814:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;59814:21:0;;;;;;;;;59872;;;59853:15;:40;;59703:198;;;;;:::o;58629:1004::-;58734:7;58759:21;58783:8;58792:4;58783:14;;;;;;;;;;;;;;;;58832;;;:8;:14;;;;;;-1:-1:-1;;;;;58832:21:0;;;;;;;;;;;58783:14;;;;;;;;58895:25;;;;58950:12;;:37;;-1:-1:-1;;;58950:37:0;;58981:4;58950:37;;;;;;58783:14;;-1:-1:-1;58832:21:0;;58895:25;;58783:14;;58950:12;;;:22;;:37;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58950:37:0;59017:20;;;;58950:37;;-1:-1:-1;59002:12:0;:35;:52;;;;-1:-1:-1;59041:13:0;;;59002:52;58998:480;;;59071:18;59109:49;59123:4;:20;;;59145:12;59109:13;:49::i;:::-;59071:87;;59173:23;59216:115;59297:15;;59216:54;59254:4;:15;;;59216:33;59231:17;;59216:10;:14;;:33;;;;:::i;:::-;:37;;:54::i;:::-;:58;;:115::i;:::-;59173:158;-1:-1:-1;59369:97:0;59412:39;59442:8;59412:25;59173:158;59432:4;59412:19;:25::i;:39::-;59369:20;;:24;:97::i;:::-;59346:120;;58998:480;;;59488:15;59507:68;59559:4;:15;;;59507:47;59549:4;59507:37;59523:20;59507:4;:11;;;:15;;:37;;;;:::i;:47::-;:51;;:68::i;:::-;59488:87;;59593:32;59605:4;:19;;;59593:7;:11;;:32;;;;:::i;:::-;59586:39;58629:1004;-1:-1:-1;;;;;;;;58629:1004:0:o;53896:49::-;53941:4;53896:49;:::o;68288:108::-;-1:-1:-1;;;;;68372:16:0;;;68345:7;68372:16;;;:9;:16;;;;;;;;68288:108::o;54067:48::-;;;;;;;;;;;;;:::o;52979:25::-;;;-1:-1:-1;;;;;52979:25:0;;:::o;63820:616::-;30547:1;31153:7;;:19;;31145:63;;;;;-1:-1:-1;;;31145:63:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;31145:63:0;;;;;;;;;;;;;;;30547:1;31286:7;:18;;;;63900:21:::1;63924:8;63933:4;63924:14;;;;;;;;;::::0;;;::::1;::::0;;;63973;;;:8:::1;:14:::0;;;;;;63988:10:::1;63973:26:::0;;;;;;;64018:11;;63924:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;64018:22:0;-1:-1:-1;64018:22:0::1;64010:53;;;::::0;;-1:-1:-1;;;64010:53:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;64010:53:0;;;;;;;;;;;;;::::1;;64074:16;64085:4;64074:10;:16::i;:::-;64101:33;64129:4;64101:27;:33::i;:::-;64149:11:::0;;64145:152:::1;;64191:11:::0;;:24:::1;::::0;64207:7;64191:15:::1;:24::i;:::-;64177:38:::0;;64230:12;;:55:::1;::::0;-1:-1:-1;;;;;64230:12:0::1;64264:10;64277:7:::0;64230:25:::1;:55::i;:::-;64341:25;::::0;::::1;::::0;64325:11;;:52:::1;::::0;64372:4:::1;::::0;64325:42:::1;::::0;:15:::1;:42::i;:52::-;64307:15;::::0;::::1;:70:::0;64393:35:::1;::::0;;;;;;;64414:4;;64402:10:::1;::::0;64393:35:::1;::::0;;;;::::1;::::0;;::::1;-1:-1:-1::0;;30503:1:0;31465:22;;-1:-1:-1;;63820:616:0:o;53230:35::-;;;;:::o;53636:25::-;;;;:::o;53977:44::-;;;;;;;;;;;;-1:-1:-1;;;;;53977:44:0;;:::o;60492:919::-;60544:21;60568:8;60577:4;60568:14;;;;;;;;;;;;;;;;;;60544:38;;60613:4;:20;;;60597:12;:36;60593:75;;60650:7;;;60593:75;60697:12;;:37;;;-1:-1:-1;;;60697:37:0;;60728:4;60697:37;;;;;;60678:16;;-1:-1:-1;;;;;60697:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60697:37:0;;-1:-1:-1;60749:13:0;;;:37;;-1:-1:-1;60766:15:0;;;;:20;60749:37;60745:126;;;-1:-1:-1;60826:12:0;60803:20;;;;:35;60853:7;;60745:126;60881:18;60902:49;60916:4;:20;;;60938:12;60902:13;:49::i;:::-;60881:70;;60962:23;61001:107;61078:15;;61001:54;61039:4;:15;;;61001:33;61016:17;;61001:10;:14;;:33;;;;:::i;:107::-;61119:9;;61134:7;;60962:146;;-1:-1:-1;;;;;;61119:9:0;;;;:14;;61134:7;61143:23;60962:146;61163:2;61143:19;:23::i;:::-;61119:48;;;;;;;;;;;;;-1:-1:-1;;;;;61119:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;61178:9:0;;:46;;;-1:-1:-1;;;61178:46:0;;61201:4;61178:46;;;;;;;;;;;;-1:-1:-1;;;;;61178:9:0;;;;-1:-1:-1;61178:14:0;;-1:-1:-1;61178:46:0;;;;;:9;;:46;;;;;;;;:9;;:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61263:94;61307:39;61337:8;61307:25;61327:4;61307:15;:19;;:25;;;;:::i;:39::-;61263:25;;;;;:29;:94::i;:::-;61235:25;;;:122;-1:-1:-1;;61391:12:0;61368:20;;;;:35;;;;-1:-1:-1;60492:919:0;;:::o;65829:439::-;30547:1;31153:7;;:19;;31145:63;;;;;-1:-1:-1;;;31145:63:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;31145:63:0;;;;;;;;;;;;;;;30547:1;31286:7;:18;;;;65901:21:::1;65925:8;65934:4;65925:14;;;;;;;;;::::0;;;::::1;::::0;;;65974;;;:8:::1;:14:::0;;;;;;65989:10:::1;65974:26:::0;;;;;;;;66058:11;;65925:14:::1;::::0;;::::1;::::0;;::::1;66011:12:::0;;65925:14;;-1:-1:-1;66011:59:0::1;::::0;-1:-1:-1;;;;;66011:12:0;;;::::1;::::0;65989:10;66011:25:::1;:59::i;:::-;66122:11:::0;;66086:48:::1;::::0;;;;;;66116:4;;66104:10:::1;::::0;66086:48:::1;::::0;;;;::::1;::::0;;::::1;66159:1;66145:15:::0;;;66171::::1;::::0;;::::1;:19:::0;;;66201::::1;::::0;::::1;:23:::0;;;66235:21:::1;::::0;;::::1;:25:::0;31465:22;;-1:-1:-1;;65829:439:0:o;54480:55::-;54522:13;54480:55;:::o;60236:180::-;60298:8;:15;60281:14;60324:85;60352:6;60346:3;:12;60324:85;;;60382:15;60393:3;60382:10;:15::i;:::-;60360:5;;60324:85;;;;60236:180;:::o;69081:453::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;53941:4:::1;69172:37:::0;::::1;;69164:108;;;;-1:-1:-1::0;;;69164:108:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69309:10;;69291:14;:28;;69283:81;;;;-1:-1:-1::0;;;69283:81:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69404:10;::::0;;69425:27;;;;69468:58:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;2333:1;69081:453:::0;:::o;53728:31::-;;;;:::o;59966:187::-;60041:7;60085:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;60085:21:0;;;;;;;;;;;60124;;;;59966:187::o;2693:148::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;2800:1:::1;2784:6:::0;;2763:40:::1;::::0;-1:-1:-1;;;;;2784:6:0;;::::1;::::0;2763:40:::1;::::0;2800:1;;2763:40:::1;2831:1;2814:19:::0;;-1:-1:-1;;;;;;2814:19:0::1;::::0;;2693:148::o;67234:299::-;-1:-1:-1;;;;;67304:25:0;;67296:68;;;;;-1:-1:-1;;;67296:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67397:10;;-1:-1:-1;;;;;67397:10:0;67383;:24;67375:61;;;;;-1:-1:-1;;;67375:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67447:10;:24;;-1:-1:-1;;;;;;67447:24:0;-1:-1:-1;;;;;67447:24:0;;;;;;;;67487:38;;67501:10;;67487:38;;-1:-1:-1;;67487:38:0;67234:299;:::o;2042:87::-;2088:7;2115:6;-1:-1:-1;;;;;2115:6:0;2042:87;:::o;58283:277::-;58382:7;54522:13;58445:20;;58418:9;;;;;;;;;-1:-1:-1;;;;;58418:9:0;-1:-1:-1;;;;;58411:29:0;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58411:31:0;:54;:73;58407:114;;-1:-1:-1;58508:1:0;58501:8;;58407:114;58538:14;:3;58546:5;58538:7;:14::i;:::-;58531:21;58283:277;-1:-1:-1;;;58283:277:0:o;62593:1175::-;30547:1;31153:7;;:19;;31145:63;;;;;-1:-1:-1;;;31145:63:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;31145:63:0;;;;;;;;;;;;;;;30547:1;31286:7;:18;62778:21:::1;62802:8;62811:4;62802:14;;;;;;;;;::::0;;;::::1;::::0;;;62851;;;:8:::1;:14:::0;;;;;;62866:10:::1;62851:26:::0;;;;;;;62802:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;62888:16:0::1;62860:4:::0;62888:10:::1;:16::i;:::-;62915:33;62943:4;62915:27;:33::i;:::-;62963:11:::0;;62959:671:::1;;62991:34;63003:10;63015:9;62991:11;:34::i;:::-;63040:12:::0;;:140:::1;::::0;-1:-1:-1;;;;;63040:12:0::1;63096:10;63134:4;63158:7:::0;63040:29:::1;:140::i;:::-;63199:17;::::0;::::1;::::0;::::1;;:21:::0;63195:344:::1;;63274:17;::::0;::::1;::::0;63241:18:::1;::::0;63262:41:::1;::::0;63297:5:::1;::::0;63262:30:::1;::::0;:7;;63274:17:::1;;63262:11;:30::i;:41::-;63336:11:::0;;63241:62;;-1:-1:-1;63336:40:0::1;::::0;63241:62;;63336:24:::1;::::0;63352:7;63336:15:::1;:24::i;:40::-;63322:54:::0;;63421:10:::1;::::0;63395:12;;:49:::1;::::0;-1:-1:-1;;;;;63395:12:0;;::::1;::::0;63421:10:::1;63433::::0;63395:25:::1;:49::i;:::-;63195:344;;;;63499:11:::0;;:24:::1;::::0;63515:7;63499:15:::1;:24::i;:::-;63485:38:::0;;63195:344:::1;63597:20;::::0;::::1;::::0;63577:41:::1;::::0;:15:::1;::::0;:19:::1;:41::i;:::-;63553:21;::::0;::::1;:65:::0;62959:671:::1;63674:25;::::0;::::1;::::0;63658:11;;:52:::1;::::0;63705:4:::1;::::0;63658:42:::1;::::0;:15:::1;:42::i;:52::-;63640:15;::::0;::::1;:70:::0;63726:34:::1;::::0;;;;;;;63746:4;;63734:10:::1;::::0;63726:34:::1;::::0;;;;::::1;::::0;;::::1;-1:-1:-1::0;;30503:1:0;31465:22;;-1:-1:-1;;;62593:1175:0:o;54387:57::-;54435:9;54387:57;:::o;53381:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;53795:51::-;53843:3;53795:51;:::o;54270:52::-;;;;;;;;;;;;;:::o;56365:1083::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;56208:23:0;::::1;;::::0;;;:13:::1;:23;::::0;;;;;56565:8;;56208:23:::1;;:32;56200:70;;;::::0;;-1:-1:-1;;;56200:70:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;53843:3:::2;56594:39;::::0;::::2;;;56586:89;;;;-1:-1:-1::0;;;56586:89:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53184:7;56694:16;:44;;56686:86;;;::::0;;-1:-1:-1;;;56686:86:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;56787:11;56783:61;;;56815:17;:15;:17::i;:::-;56854:23;56895:10;;56880:12;:25;:53;;56923:10;;56880:53;;;56908:12;56880:53;56962:15;::::0;56854:79;;-1:-1:-1;56962:32:0::2;::::0;56982:11;56962:19:::2;:32::i;:::-;56944:15;:50:::0;-1:-1:-1;;;;;57005:23:0;;::::2;;::::0;;;:13:::2;:23;::::0;;;;;;;:30;;57031:4:::2;-1:-1:-1::0;;57005:30:0;;::::2;::::0;::::2;::::0;;;57074:294;;::::2;::::0;::::2;::::0;;;;;;;::::2;::::0;;;;;;;;;;;;;;;::::2;::::0;;::::2;::::0;;;;;;;;;;;;57046:8:::2;:333:::0;;;;::::2;::::0;;;;;;;;::::2;::::0;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;;;;;57046:333:0::2;::::0;;;::::2;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;57046:333:0::2;::::0;;;::::2;;::::0;;;;;;;;;;;;;57421:15;57390:28;;;-1:-1:-1;;57390:18:0::2;:28:::0;;;;-1:-1:-1;;57421:19:0;;;;57390:50;;56365:1083::o;54188:44::-;;;;;;;;;;;;;;;:::o;66914:256::-;-1:-1:-1;;;;;66981:22:0;;66973:55;;;;;-1:-1:-1;;;66973:55:0;;;;;;;;;;;;-1:-1:-1;;;66973:55:0;;;;;;;;;;;;;;;67061:7;;-1:-1:-1;;;;;67061:7:0;67047:10;:21;67039:43;;;;;-1:-1:-1;;;67039:43:0;;;;;;;;;;;;-1:-1:-1;;;67039:43:0;;;;;;;;;;;;;;;67093:7;:18;;-1:-1:-1;;;;;;67093:18:0;-1:-1:-1;;;;;67093:18:0;;;;;;;;67127:35;;67141:10;;67127:35;;-1:-1:-1;;67127:35:0;66914:256;:::o;52922:22::-;;;-1:-1:-1;;;;;52922:22:0;;:::o;53133:58::-;53184:7;53133:58;:::o;61485:1020::-;30547:1;31153:7;;:19;;31145:63;;;;;-1:-1:-1;;;31145:63:0;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;31145:63:0;;;;;;;;;;;;;;;30547:1;31286:7;:18;;;;61564:21:::1;61588:8;61597:4;61588:14;;;;;;;;;::::0;;;::::1;::::0;;;61637;;;:8:::1;:14:::0;;;;;;61652:10:::1;61637:26:::0;;;;;;;61588:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;61674:16:0::1;61646:4:::0;61674:10:::1;:16::i;:::-;61701:33;61729:4;61701:27;:33::i;:::-;61749:11:::0;;61745:622:::1;;61777:12:::0;;:140:::1;::::0;-1:-1:-1;;;;;61777:12:0::1;61833:10;61871:4;61895:7:::0;61777:29:::1;:140::i;:::-;61936:17;::::0;::::1;::::0;::::1;;:21:::0;61932:344:::1;;62011:17;::::0;::::1;::::0;61978:18:::1;::::0;61999:41:::1;::::0;62034:5:::1;::::0;61999:30:::1;::::0;:7;;62011:17:::1;;61999:11;:30::i;:41::-;62073:11:::0;;61978:62;;-1:-1:-1;62073:40:0::1;::::0;61978:62;;62073:24:::1;::::0;62089:7;62073:15:::1;:24::i;:40::-;62059:54:::0;;62158:10:::1;::::0;62132:12;;:49:::1;::::0;-1:-1:-1;;;;;62132:12:0;;::::1;::::0;62158:10:::1;62170::::0;62132:25:::1;:49::i;:::-;61932:344;;;;62236:11:::0;;:24:::1;::::0;62252:7;62236:15:::1;:24::i;:::-;62222:38:::0;;61932:344:::1;62334:20;::::0;::::1;::::0;62314:41:::1;::::0;:15:::1;::::0;:19:::1;:41::i;:::-;62290:21;::::0;::::1;:65:::0;61745:622:::1;62411:25;::::0;::::1;::::0;62395:11;;:52:::1;::::0;62442:4:::1;::::0;62395:42:::1;::::0;:15:::1;:42::i;:52::-;62377:15;::::0;::::1;:70:::0;62463:34:::1;::::0;;;;;;;62483:4;;62471:10:::1;::::0;62463:34:::1;::::0;;;;::::1;::::0;;::::1;-1:-1:-1::0;;30503:1:0;31465:22;;-1:-1:-1;;61485:1020:0:o;52868:26::-;;;-1:-1:-1;;;;;52868:26:0;;:::o;2996:244::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;3085:22:0;::::1;3077:73;;;;-1:-1:-1::0;;;3077:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3187:6;::::0;;3166:38:::1;::::0;-1:-1:-1;;;;;3166:38:0;;::::1;::::0;3187:6;::::1;::::0;3166:38:::1;::::0;::::1;3215:6;:17:::0;;-1:-1:-1;;;;;;3215:17:0::1;-1:-1:-1::0;;;;;3215:17:0;;;::::1;::::0;;;::::1;::::0;;2996:244::o;69582:107::-;2273:12;:10;:12::i;:::-;-1:-1:-1;;;;;2262:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2262:23:0;;2254:68;;;;;-1:-1:-1;;;2254:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2254:68:0;;;;;;;;;;;;;;;69657:10:::1;:24:::0;69582:107::o;606:106::-;694:10;606:106;:::o;46448:158::-;46506:7;46539:1;46534;:6;;46526:49;;;;;-1:-1:-1;;;46526:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46593:5:0;;;46448:158::o;45986:179::-;46044:7;46076:5;;;46100:6;;;;46092:46;;;;;-1:-1:-1;;;46092:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;46865:220;46923:7;46947:6;46943:20;;-1:-1:-1;46962:1:0;46955:8;;46943:20;46986:5;;;46990:1;46986;:5;:1;47010:5;;;;;:10;47002:56;;;;-1:-1:-1;;;47002:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47563:153;47621:7;47653:1;47649;:5;47641:44;;;;;-1:-1:-1;;;47641:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47707:1;47703;:5;;;;;;;47563:153;-1:-1:-1;;;47563:153:0:o;64485:1273::-;64556:21;64580:8;64589:4;64580:14;;;;;;;;;;;;;;;;64629;;;:8;:14;;;;;;64644:10;64629:26;;;;;;;64672:21;;;;64580:14;;;;;;;;-1:-1:-1;64668:124:0;;64759:20;;;;64739:41;;:15;;:19;:41::i;:::-;64715:21;;;:65;64668:124;64804:15;64822:73;64879:4;:15;;;64822:52;64869:4;64822:42;64838:4;:25;;;64822:4;:11;;;:15;;:42;;;;:::i;:73::-;64804:91;;64910:28;64921:4;64927:10;64910;:28::i;:::-;64906:845;;;64969:1;64959:7;:11;:38;;;;64996:1;64974:4;:19;;;:23;64959:38;64955:549;;;65018:20;65041:32;65053:4;:19;;;65041:7;:11;;:32;;;;:::i;:::-;65018:55;;65150:45;65175:4;:19;;;65150:20;;:24;;:45;;;;:::i;:::-;65127:20;:68;65236:1;65214:19;;;:23;65300:20;;;;65280:41;;:15;;:19;:41::i;:::-;65256:21;;;:65;65375:47;65397:10;65409:12;65375:21;:47::i;:::-;65441;65463:10;65475:12;65441:21;:47::i;:::-;64955:549;;64906:845;;;65525:11;;65521:230;;65575:19;;;;:32;;65599:7;65575:23;:32::i;:::-;65553:19;;;:54;65645:20;;:33;;65670:7;65645:24;:33::i;:::-;65622:20;:56;65698:41;;;;;;;;65725:4;;65713:10;;65698:41;;;;;;;;;65521:230;64485:1273;;;;:::o;40141:177::-;40251:58;;;-1:-1:-1;;;;;40251:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40251:58:0;-1:-1:-1;;;40251:58:0;;;40224:86;;40244:5;;40224:19;:86::i;:::-;40141:177;;;:::o;67890:347::-;-1:-1:-1;;;;;68004:16:0;;;68032:1;68004:16;;;:9;:16;;;;;;;:30;67969:92;;;;-1:-1:-1;;;;;;68038:23:0;;;;67969:92;:114;;;;;68078:5;-1:-1:-1;;;;;68065:18:0;:9;-1:-1:-1;;;;;68065:18:0;;;67969:114;67965:265;;;-1:-1:-1;;;;;68100:16:0;;;;;;;:9;:16;;;;;;;;:28;;-1:-1:-1;;;;;;68100:28:0;;;;;;;;;68143:24;;;:13;:24;;;;;;:29;;-1:-1:-1;68143:29:0;;;68192:26;;;68100:16;68192:26;67890:347;;:::o;40326:205::-;40454:68;;;-1:-1:-1;;;;;40454:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40454:68:0;-1:-1:-1;;;40454:68:0;;;40427:96;;40447:5;;40427:19;:96::i;66392:466::-;66496:9;;:34;;;-1:-1:-1;;;66496:34:0;;66524:4;66496:34;;;;;;66473:20;;-1:-1:-1;;;;;66496:9:0;;:19;;:34;;;;;;;;;;;;;;:9;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66496:34:0;;-1:-1:-1;66541:20:0;66584:22;;;66580:193;;;66641:9;;:37;;;-1:-1:-1;;;66641:37:0;;-1:-1:-1;;;;;66641:37:0;;;;;;;;;;;;;;;:9;;;;;:18;;:37;;;;;;;;;;;;;;:9;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66641:37:0;;-1:-1:-1;66580:193:0;;;66729:9;;:32;;;-1:-1:-1;;;66729:32:0;;-1:-1:-1;;;;;66729:32:0;;;;;;;;;;;;;;;:9;;;;;:18;;:32;;;;;;;;;;;;;;:9;;:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66729:32:0;;-1:-1:-1;66580:193:0;66791:15;66783:67;;;;-1:-1:-1;;;66783:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68476:413;68560:16;68579:18;68591:5;68579:11;:18::i;:::-;68560:37;-1:-1:-1;;;;;;68612:22:0;;;;;;:43;;;68650:5;-1:-1:-1;;;;;68638:17:0;:8;-1:-1:-1;;;;;68638:17:0;;;68612:43;:61;;;;;68672:1;68659:10;;:14;68612:61;68608:274;;;68690:22;68715:35;68744:5;68715:24;68728:10;;68715:8;:12;;:24;;;;:::i;:35::-;68765:9;;:40;;;-1:-1:-1;;;68765:40:0;;-1:-1:-1;;;;;68765:40:0;;;;;;;;;;;;;;;68690:60;;-1:-1:-1;68765:9:0;;;:14;;:40;;;;;:9;;:40;;;;;;;;:9;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68825:45:0;;;;;;;;-1:-1:-1;;;;;68825:45:0;;;;-1:-1:-1;68825:45:0;;;-1:-1:-1;68825:45:0;;;;;;;;;68608:274;68476:413;;;:::o;42446:761::-;42870:23;42896:69;42924:4;42896:69;;;;;;;;;;;;;;;;;42904:5;-1:-1:-1;;;;;42896:27:0;;;:69;;;;;:::i;:::-;42980:17;;42870:95;;-1:-1:-1;42980:21:0;42976:224;;43122:10;43111:30;;;;;;;;;;;;;;;-1:-1:-1;43111:30:0;43103:85;;;;-1:-1:-1;;;43103:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35170:195;35273:12;35305:52;35327:6;35335:4;35341:1;35344:12;35305:21;:52::i;:::-;35298:59;35170:195;-1:-1:-1;;;;35170:195:0:o;36222:530::-;36349:12;36407:5;36382:21;:30;;36374:81;;;;-1:-1:-1;;;36374:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36474:18;36485:6;36474:10;:18::i;:::-;36466:60;;;;;-1:-1:-1;;;36466:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;36600:12;36614:23;36641:6;-1:-1:-1;;;;;36641:11:0;36661:5;36669:4;36641:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;36641:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36599:75;;;;36692:52;36710:7;36719:10;36731:12;36692:17;:52::i;:::-;36685:59;36222:530;-1:-1:-1;;;;;;;36222:530:0:o;32252:422::-;32619:20;32658:8;;;32252:422::o;38762:742::-;38877:12;38906:7;38902:595;;;-1:-1:-1;38937:10:0;38930:17;;38902:595;39051:17;;:21;39047:439;;39314:10;39308:17;39375:15;39362:10;39358:2;39354:19;39347:44;39262:148;39457:12;39450:20;;-1:-1:-1;;;39450:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://afe72df1ae5b4164a2c40e3c4a773b4ce87b71081365ddfc96f538466fe79a5c