Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•  contract Initializable
•    - function isConstructor()
•  contract ContextUpgradeSafe is Ini ...
•    - function __Context_init()
•    - function __Context_init_unchained()
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•  contract ERC20UpgradeSafe is Initi ...
•    - function __ERC20_init(string memory n ...
•    - function __ERC20_init_unchained(strin ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(address ...
•  contract ERC20WithPermit is Initia ...
•    - function initialize(
•    - function permit(
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
•  contract Claimable is Initializabl ...
•    - function initialize(address _nextOwne ...
•    - function owner()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•    - function claimOwnership()
•  contract CanReclaimTokens is Claim ...
•    - function initialize(address _nextOwne ...
•    - function blacklistRecoverableToken(ad ...
•    - function recoverTokens(address _token ...
•  contract BearnTokenERC20 is
•    - function initialize(
•    - function mint(address _to, uint _amou ...
•    - function burn(uint _amount)
•    - function transfer(address recipient, ...
•    - function transferFrom(address sender, ...
•    - function _beforeTokenTransfer(address ...
•  contract BearnTokenERC20Chef is Ow ... *
•    - function poolLength()
•    - function setBfiePerBlock(uint _bfiePe ...
•    - function add(uint _allocPoint, IERC20 ...
•    - function set(uint _pid, uint _allocPo ...
•    - function pendingBearn(uint _pid, addr ...
•    - function massUpdatePools()
•    - function updatePool(uint _pid)
•    - function deposit(uint _pid, uint _amo ...
•    - function withdraw(uint _pid, uint _am ...
•    - function emergencyWithdraw(uint _pid)
•    - function safeBfieTransfer(address _to ...
•    - function governanceRecoverUnsupported ...

More Options

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

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

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

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

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

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

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

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

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

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

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

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

/*
 * @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.
 */
contract ContextUpgradeSafe is Initializable {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {


    }


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

    uint256[50] private __gap;
}

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

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

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

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

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

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

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

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

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

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

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

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

/**
 * @dev 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 {ERC20MinterPauser}.
 *
 * 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 ERC20UpgradeSafe is Initializable, ContextUpgradeSafe, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    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.
     */

    function __ERC20_init(string memory name, string memory symbol) internal initializer {
        __Context_init_unchained();
        __ERC20_init_unchained(name, symbol);
    }

    function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {


        _name = name;
        _symbol = symbol;
        _decimals = 18;

    }


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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

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

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

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

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

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

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

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

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

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

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

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

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

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

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

    uint256[44] private __gap;
}

contract ERC20WithPermit is Initializable, ERC20UpgradeSafe {
    using SafeMath for uint;

    mapping(address => uint) public nonces;

    // If the token is redeployed, the version is increased to prevent a permit
    // signature being used on both token instances.
    string public version;

    // --- EIP712 niceties ---
    bytes32 public DOMAIN_SEPARATOR;
    // PERMIT_TYPEHASH is the value returned from
    // keccak256("Permit(address holder,address spender,uint nonce,uint expiry,bool allowed)")
    bytes32 public constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;

    function initialize(
        uint _chainId,
        string memory _version,
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) public initializer {
        __ERC20_init(_name, _symbol);
        _setupDecimals(_decimals);
        version = _version;
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint chainId,address verifyingContract)"
                ),
                keccak256(bytes(name())),
                keccak256(bytes(version)),
                _chainId,
                address(this)
            )
        );
    }

    // --- Approve by signature ---
    function permit(
        address holder,
        address spender,
        uint nonce,
        uint expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                keccak256(
                    abi.encode(
                        PERMIT_TYPEHASH,
                        holder,
                        spender,
                        nonce,
                        expiry,
                        allowed
                    )
                )
            )
        );

        require(holder != address(0), "ERC20WithRate: address must not be 0x0");
        require(
            holder == ecrecover(digest, v, r, s),
            "ERC20WithRate: invalid signature"
        );
        require(
            expiry == 0 || now <= expiry,
            "ERC20WithRate: permit has expired"
        );
        require(nonce == nonces[holder]++, "ERC20WithRate: invalid nonce");
        uint amount = allowed ? uint(-1) : 0;
        _approve(holder, spender, amount);
    }
}

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

    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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "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");
        }
    }
}

/**
 * @title Claimable
 * @dev Extension for the Ownable contract, where the ownership needs to be claimed.
 * This allows the new owner to accept the transfer.
 */
contract Claimable is Initializable {
    address private _owner;
    address public pendingOwner;

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

    function initialize(address _nextOwner) public virtual initializer {
        _owner = _nextOwner;
    }

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

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

    modifier onlyPendingOwner() {
        require(
            msg.sender == pendingOwner,
            "Claimable: caller is not the pending owner"
        );
        _;
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        require(
            newOwner != pendingOwner,
            "Claimable: invalid new owner"
        );
        pendingOwner = newOwner;
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function _transferOwnership(address newOwner) internal {
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    function claimOwnership() public onlyPendingOwner {
        _transferOwnership(pendingOwner);
        delete pendingOwner;
    }
}

contract CanReclaimTokens is Claimable {
    using SafeERC20 for ERC20UpgradeSafe;

    mapping(address => bool) private recoverableTokensBlacklist;

    function initialize(address _nextOwner) public override initializer {
        Claimable.initialize(_nextOwner);
    }

    function blacklistRecoverableToken(address _token) public onlyOwner {
        recoverableTokensBlacklist[_token] = true;
    }

    /// @notice Allow the owner of the contract to recover funds accidentally
    /// sent to the contract. To withdraw ETH, the token should be set to `0x0`.
    function recoverTokens(address _token) external onlyOwner {
        require(
            !recoverableTokensBlacklist[_token],
            "CanReclaimTokens: token is not recoverable"
        );

        if (_token == address(0x0)) {
            msg.sender.transfer(address(this).balance);
        } else {
            ERC20UpgradeSafe(_token).safeTransfer(
                msg.sender, ERC20UpgradeSafe(_token).balanceOf(address(this))
            );
        }
    }
}

/**
 * @dev Wrapped BFI on Ethereum
 *
 * Read more about its tokenomic here: https://bearn-defi.medium.com/bearn-fi-introduction-9e65f6395dfc
 *
 * Total 12,500 BFI issued (minted) on Ethereum:
 * - 500 BFIE for initial supply (Uniswap and Value Liquid)
 * - 3000 BFIE for UNIv2 BFIE-ETH (50/50) mining incentive (4 months)
 * - 7000 BFIE for ValueLiquid VLP BFIE-VALUE (70/30) mining incentive (18 months)
 * - 2000 BFIE reserve for public mint (from BFI Bsc)
 */
contract BearnTokenERC20 is
    ERC20WithPermit,
    CanReclaimTokens {

    uint public cap = 12500 ether;

    function initialize(
        uint _chainId,
        address _nextOwner,
        string memory _version,
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) public initializer {
        __ERC20_init(_name, _symbol);
        _setupDecimals(_decimals);
        ERC20WithPermit.initialize(
            _chainId,
            _version,
            _name,
            _symbol,
            _decimals
        );
        CanReclaimTokens.initialize(_nextOwner);
        _mint(msg.sender, cap.sub(2000 ether)); // first mint to setup liquidity
    }

    // Can be called by only Gateway
    function mint(address _to, uint _amount) external onlyOwner {
        _mint(_to, _amount);
    }

    // Can be called by only Gateway
    function burn(uint _amount) external onlyOwner {
        _burn(msg.sender, _amount);
    }

    function transfer(address recipient, uint amount) public override returns (bool) {
        require(
            recipient != address(this),
            "BEARN ERC20UpgradeSafe: can't transfer to token address"
        );
        return super.transfer(recipient, amount);
    }

    function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
        require(
            recipient != address(this),
            "BEARN ERC20UpgradeSafe: can't transfer to stoken address"
        );
        return super.transferFrom(sender, recipient, amount);
    }

    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - minted tokens must not cause the total supply to go over the cap.
     */
    function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        if (from == address(0)) { // When minting tokens
            require(totalSupply().add(amount) <= cap, "ERC20Capped: cap exceeded");
        }
    }
}

// BearnTokenERC20Chef is the master of BFIE and he is a fair guy.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
//
// Note that this pool has no minter key as the original MasterChef of Sushi.
// Instead, the governance will mint BFIE and forward to this pool at the beginning.
contract BearnTokenERC20Chef is Ownable {
    using SafeMath for uint;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint amount;     // How many LP tokens the user has provided.
        uint rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of BFIs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accBfiePerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accBfiePerShare` (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.
        uint accumulatedStakingPower; // will accumulate every time user harvest
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint allocPoint;       // How many allocation points assigned to this pool. BFIs to distribute per block.
        uint lastRewardBlock;  // Last block number that BFIs distribution occurs.
        uint accBfiePerShare; // Accumulated BFIs per share, times 1e18. See below.
        bool isStarted; // if lastRewardBlock has passed
    }

    // The BFIE TOKEN!
    BearnTokenERC20 public bfie;

    // BFIE tokens created per block.
    uint public bfiePerBlock;

    // Info of each pool.
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping (uint => mapping (address => UserInfo)) public userInfo;

    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint public totalAllocPoint = 0;

    // The block number when BFIE mining starts.
    uint public startBlock;

    uint public constant BLOCKS_PER_WEEK = 46500;

    address public rewardReferral;

    event Deposit(address indexed user, uint indexed pid, uint amount);
    event Withdraw(address indexed user, uint indexed pid, uint amount);
    event EmergencyWithdraw(address indexed user, uint indexed pid, uint amount);
    event RewardPaid(address indexed user, uint amount);

    constructor(
        BearnTokenERC20 _bfie,
        uint _bfiePerBlock,
        uint _startBlock
    ) public {
        bfie = _bfie;
        bfiePerBlock = _bfiePerBlock; // supposed to be 0.004 (4e16 wei) [set 0.01 at the first 2 weeks for bonus]
        startBlock = _startBlock; // supposed to be 11,360,000 (Mon Nov 30 2020 12:00:00 GMT+0) (https://etherscan.io/block/countdown/11360000)
    }

    function poolLength() external view returns (uint) {
        return poolInfo.length;
    }

    function setBfiePerBlock(uint _bfiePerBlock) public onlyOwner {
        massUpdatePools();
        bfiePerBlock = _bfiePerBlock;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(uint _allocPoint, IERC20 _lpToken, bool _withUpdate, uint _lastRewardBlock) public onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        if (block.number < startBlock) {
            // chef is sleeping
            if (_lastRewardBlock == 0) {
                _lastRewardBlock = startBlock;
            } else {
                if (_lastRewardBlock < startBlock) {
                    _lastRewardBlock = startBlock;
                }
            }
        } else {
            // chef is cooking
            if (_lastRewardBlock == 0 || _lastRewardBlock < block.number) {
                _lastRewardBlock = block.number;
            }
        }
        bool _isStarted = (_lastRewardBlock <= startBlock) || (_lastRewardBlock <= block.number);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: _lastRewardBlock,
            accBfiePerShare: 0,
            isStarted: _isStarted
        }));
        if (_isStarted) {
            totalAllocPoint = totalAllocPoint.add(_allocPoint);
        }
    }

    // Update the given pool's BFIE allocation point. Can only be called by the owner.
    function set(uint _pid, uint _allocPoint) public onlyOwner {
        massUpdatePools();
        PoolInfo storage pool = poolInfo[_pid];
        if (pool.isStarted) {
            totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
        }
        pool.allocPoint = _allocPoint;
    }

    // View function to see pending BFIs on frontend.
    function pendingBearn(uint _pid, address _user) external view returns (uint) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint accBfiePerShare = pool.accBfiePerShare;
        uint lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint _numBlocks = block.number.sub(pool.lastRewardBlock);
            if (totalAllocPoint > 0) {
                uint _bfieReward = _numBlocks.mul(bfiePerBlock).mul(pool.allocPoint).div(totalAllocPoint);
                accBfiePerShare = accBfiePerShare.add(_bfieReward.mul(1e18).div(lpSupply));
            }
        }
        return user.amount.mul(accBfiePerShare).div(1e18).sub(user.rewardDebt);
    }

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint lpSupply = pool.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        if (!pool.isStarted) {
            pool.isStarted = true;
            totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
        }
        if (totalAllocPoint > 0) {
            uint _numBlocks = block.number.sub(pool.lastRewardBlock);
            uint _bfieReward = _numBlocks.mul(bfiePerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            pool.accBfiePerShare = pool.accBfiePerShare.add(_bfieReward.mul(1e18).div(lpSupply));
        }
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to BearnChef for BFIE allocation.
    function deposit(uint _pid, uint _amount) public {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint _pending = user.amount.mul(pool.accBfiePerShare).div(1e18).sub(user.rewardDebt);
            if (_pending > 0) {
                safeBfieTransfer(_sender, _pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(_sender, address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accBfiePerShare).div(1e18);
        emit Deposit(_sender, _pid, _amount);
    }

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

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint _pid) public {
        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;
    }

    // Safe bfie transfer function, just in case if rounding error causes pool to not have enough BFIs.
    function safeBfieTransfer(address _to, uint _amount) internal {
        uint _bfieBal = bfie.balanceOf(address(this));
        if (_bfieBal > 0) {
            if (_amount > _bfieBal) {
                bfie.transfer(_to, _bfieBal);
            } else {
                bfie.transfer(_to, _amount);
            }
        }
    }

    // This function allows governance to take unsupported tokens out of the contract. This is in an effort to make someone whole, should they seriously mess up.
    // There is no guarantee governance will vote to return these. It also allows for removal of airdropped tokens.
    function governanceRecoverUnsupported(IERC20 _token, uint amount, address to) external onlyOwner {
        if (block.number < startBlock + BLOCKS_PER_WEEK * 24) {// do not allow to drain lpToken if less than 6 months (end of farming period)
            uint length = poolInfo.length;
            for (uint pid = 0; pid < length; ++pid) {
                PoolInfo storage pool = poolInfo[pid];
                // cant take staked asset
                require(_token != pool.lpToken, "!pool.lpToken");
            }
        }
        _token.safeTransfer(to, amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract BearnTokenERC20","name":"_bfie","type":"address"},{"internalType":"uint256","name":"_bfiePerBlock","type":"uint256"},{"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":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardPaid","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":"BLOCKS_PER_WEEK","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":"bool","name":"_withUpdate","type":"bool"},{"internalType":"uint256","name":"_lastRewardBlock","type":"uint256"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bfie","outputs":[{"internalType":"contract BearnTokenERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bfiePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"governanceRecoverUnsupported","outputs":[],"stateMutability":"nonpayable","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":"pendingBearn","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":"accBfiePerShare","type":"uint256"},{"internalType":"bool","name":"isStarted","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardReferral","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_bfiePerBlock","type":"uint256"}],"name":"setBfiePerBlock","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","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":"accumulatedStakingPower","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"}]

6080604052600060055534801561001557600080fd5b50604051611eb0380380611eb08339818101604052606081101561003857600080fd5b508051602082015160409092015190919060006100536100c9565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600180546001600160a01b0319166001600160a01b0394909416939093179092556002556006556100cd565b3390565b611dd4806100dc6000396000f3fe608060405234801561001057600080fd5b50600436106101825760003560e01c806354575af4116100d857806393f1a40b1161008c578063e2bbb15811610066578063e2bbb15814610424578063f2fde38b14610447578063fc47e2091461047a57610182565b806393f1a40b1461037e57806396805e54146103d5578063ae075bb01461041c57610182565b8063715018a6116100bd578063715018a614610366578063744d51531461036e5780638da5cb5b1461037657610182565b806354575af41461031b578063630b5ba11461035e57610182565b8063363868191161013a57806348cd4cb11161011457806348cd4cb1146102d957806351eb05a6146102e15780635312ea8e146102fe57610182565b80633638681914610260578063441a3e701461027d57806346e25bfd146102a057610182565b80631526fe271161016b5780631526fe27146101d257806317caf6f1146102335780631ab06ee51461023b57610182565b8063081e3eda146101875780630cdb43c4146101a1575b600080fd5b61018f610482565b60408051918252519081900360200190f35b6101a9610488565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b6101ef600480360360208110156101e857600080fd5b50356104a4565b6040805173ffffffffffffffffffffffffffffffffffffffff9096168652602086019490945284840192909252606084015215156080830152519081900360a00190f35b61018f6104fc565b61025e6004803603604081101561025157600080fd5b5080359060200135610502565b005b61025e6004803603602081101561027657600080fd5b50356105f8565b61025e6004803603604081101561029357600080fd5b5080359060200135610696565b61018f600480360360408110156102b657600080fd5b508035906020013573ffffffffffffffffffffffffffffffffffffffff1661085f565b61018f610a07565b61025e600480360360208110156102f757600080fd5b5035610a0d565b61025e6004803603602081101561031457600080fd5b5035610bbe565b61025e6004803603606081101561033157600080fd5b5073ffffffffffffffffffffffffffffffffffffffff813581169160208101359160409091013516610c66565b61025e610df1565b61025e610e14565b61018f610f14565b6101a9610f1a565b6103b76004803603604081101561039457600080fd5b508035906020013573ffffffffffffffffffffffffffffffffffffffff16610f36565b60408051938452602084019290925282820152519081900360600190f35b61025e600480360360808110156103eb57600080fd5b5080359073ffffffffffffffffffffffffffffffffffffffff60208201351690604081013515159060600135610f62565b6101a96111e1565b61025e6004803603604081101561043a57600080fd5b50803590602001356111fd565b61025e6004803603602081101561045d57600080fd5b503573ffffffffffffffffffffffffffffffffffffffff16611354565b61018f6114de565b60035490565b60075473ffffffffffffffffffffffffffffffffffffffff1681565b600381815481106104b157fe5b60009182526020909120600590910201805460018201546002830154600384015460049094015473ffffffffffffffffffffffffffffffffffffffff90931694509092909160ff1685565b60055481565b61050a6114e4565b60005473ffffffffffffffffffffffffffffffffffffffff90811691161461059357604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b61059b610df1565b6000600383815481106105aa57fe5b60009182526020909120600590910201600481015490915060ff16156105f1576105ed826105e783600101546005546114e890919063ffffffff16565b90611531565b6005555b6001015550565b6106006114e4565b60005473ffffffffffffffffffffffffffffffffffffffff90811691161461068957604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b610691610df1565b600255565b60003390506000600384815481106106aa57fe5b6000918252602080832087845260048252604080852073ffffffffffffffffffffffffffffffffffffffff88168652909252922080546005909202909201925084111561075857604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f77697468647261773a206e6f7420676f6f640000000000000000000000000000604482015290519081900360640190fd5b61076185610a0d565b600061079e8260010154610798670de0b6b3a7640000610792876003015487600001546115a590919063ffffffff16565b90611618565b906114e8565b905080156107b0576107b0848261165a565b84156107e75781546107c290866114e8565b825582546107e79073ffffffffffffffffffffffffffffffffffffffff16858761185b565b6003830154825461080591670de0b6b3a764000091610792916115a5565b6001830155604080518681529051879173ffffffffffffffffffffffffffffffffffffffff8716917ff279e6a1f5e320cca91135676d9cb6e44ca8a08c0b88342bcdb1144f6511b5689181900360200190a3505050505050565b6000806003848154811061086f57fe5b600091825260208083208784526004808352604080862073ffffffffffffffffffffffffffffffffffffffff8a811688529085528187206005969096029093016003810154815483517f70a082310000000000000000000000000000000000000000000000000000000081523095810195909552925191985095969491909316926370a08231926024808201939291829003018186803b15801561091257600080fd5b505afa158015610926573d6000803e3d6000fd5b505050506040513d602081101561093c57600080fd5b505160028501549091504311801561095357508015155b156109cf5760006109718560020154436114e890919063ffffffff16565b600554909150156109cd5760006109a760055461079288600101546109a1600254876115a590919063ffffffff16565b906115a5565b90506109c96109c28461079284670de0b6b3a76400006115a5565b8590611531565b9350505b505b6109fa8360010154610798670de0b6b3a76400006107928688600001546115a590919063ffffffff16565b9450505050505b92915050565b60065481565b600060038281548110610a1c57fe5b9060005260206000209060050201905080600201544311610a3d5750610bbb565b8054604080517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152905160009273ffffffffffffffffffffffffffffffffffffffff16916370a08231916024808301926020929190829003018186803b158015610aad57600080fd5b505afa158015610ac1573d6000803e3d6000fd5b505050506040513d6020811015610ad757600080fd5b5051905080610aed575043600290910155610bbb565b600482015460ff16610b3c576004820180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001908117909155820154600554610b3891611531565b6005555b60055415610bb2576000610b5d8360020154436114e890919063ffffffff16565b90506000610b8460055461079286600101546109a1600254876115a590919063ffffffff16565b9050610baa610b9f8461079284670de0b6b3a76400006115a5565b600386015490611531565b600385015550505b50436002909101555b50565b600060038281548110610bcd57fe5b60009182526020808320858452600482526040808520338087529352909320805460059093029093018054909450610c1f9273ffffffffffffffffffffffffffffffffffffffff91909116919061185b565b80546040805191825251849133917fbb757047c2b5f3974fe26b7c10f732e7bce710b0952a71082702781e62ae05959181900360200190a360008082556001909101555050565b610c6e6114e4565b60005473ffffffffffffffffffffffffffffffffffffffff908116911614610cf757604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6006546211076001431015610dcb5760035460005b81811015610dc857600060038281548110610d2357fe5b60009182526020909120600590910201805490915073ffffffffffffffffffffffffffffffffffffffff87811691161415610dbf57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600d60248201527f21706f6f6c2e6c70546f6b656e00000000000000000000000000000000000000604482015290519081900360640190fd5b50600101610d0c565b50505b610dec73ffffffffffffffffffffffffffffffffffffffff8416828461185b565b505050565b60035460005b81811015610e1057610e0881610a0d565b600101610df7565b5050565b610e1c6114e4565b60005473ffffffffffffffffffffffffffffffffffffffff908116911614610ea557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6000805460405173ffffffffffffffffffffffffffffffffffffffff909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080547fffffffffffffffffffffffff0000000000000000000000000000000000000000169055565b60025481565b60005473ffffffffffffffffffffffffffffffffffffffff1690565b600460209081526000928352604080842090915290825290208054600182015460029092015490919083565b610f6a6114e4565b60005473ffffffffffffffffffffffffffffffffffffffff908116911614610ff357604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b811561100157611001610df1565b60065443101561102d57806110195750600654611028565b60065481101561102857506006545b611041565b80158061103957504381105b156110415750435b6000600654821115806110545750438211155b6040805160a08101825273ffffffffffffffffffffffffffffffffffffffff878116825260208201898152928201868152600060608401818152861580156080870190815260038054600181018255945295517fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b600590940293840180547fffffffffffffffffffffffff000000000000000000000000000000000000000016919096161790945594517fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85c82015590517fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85d82015592517fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85e84015590517fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85f90920180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016921515929092179091559091506111da576005546111d69086611531565b6005555b5050505050565b60015473ffffffffffffffffffffffffffffffffffffffff1681565b600033905060006003848154811061121157fe5b6000918252602080832087845260048252604080852073ffffffffffffffffffffffffffffffffffffffff8816865290925292206005909102909101915061125885610a0d565b8054156112a45760006112908260010154610798670de0b6b3a7640000610792876003015487600001546115a590919063ffffffff16565b905080156112a2576112a2848261165a565b505b83156112dd5781546112ce9073ffffffffffffffffffffffffffffffffffffffff168430876118e8565b80546112da9085611531565b81555b600382015481546112fb91670de0b6b3a764000091610792916115a5565b6001820155604080518581529051869173ffffffffffffffffffffffffffffffffffffffff8616917f90890809c654f11d6e72a28fa60149770a0d11ec6c92319d6ceb2bb0a4ea1a159181900360200190a35050505050565b61135c6114e4565b60005473ffffffffffffffffffffffffffffffffffffffff9081169116146113e557604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b73ffffffffffffffffffffffffffffffffffffffff8116611451576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526026815260200180611d2e6026913960400191505060405180910390fd5b6000805460405173ffffffffffffffffffffffffffffffffffffffff808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b61b5a481565b3390565b600061152a83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611983565b9392505050565b60008282018381101561152a57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b6000826115b457506000610a01565b828202828482816115c157fe5b041461152a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526021815260200180611d546021913960400191505060405180910390fd5b600061152a83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250611a34565b600154604080517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152905160009273ffffffffffffffffffffffffffffffffffffffff16916370a08231916024808301926020929190829003018186803b1580156116cb57600080fd5b505afa1580156116df573d6000803e3d6000fd5b505050506040513d60208110156116f557600080fd5b505190508015610dec57808211156117b557600154604080517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8681166004830152602482018590529151919092169163a9059cbb9160448083019260209291908290030181600087803b15801561178357600080fd5b505af1158015611797573d6000803e3d6000fd5b505050506040513d60208110156117ad57600080fd5b50610dec9050565b600154604080517fa9059cbb00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8681166004830152602482018690529151919092169163a9059cbb9160448083019260209291908290030181600087803b15801561183157600080fd5b505af1158015611845573d6000803e3d6000fd5b505050506040513d60208110156111da57600080fd5b6040805173ffffffffffffffffffffffffffffffffffffffff8416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052610dec908490611ab3565b6040805173ffffffffffffffffffffffffffffffffffffffff80861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f23b872dd0000000000000000000000000000000000000000000000000000000017905261197d908590611ab3565b50505050565b60008184841115611a2c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b838110156119f15781810151838201526020016119d9565b50505050905090810190601f168015611a1e5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b60008183611a9d576040517f08c379a00000000000000000000000000000000000000000000000000000000081526020600482018181528351602484015283519092839260449091019190850190808383600083156119f15781810151838201526020016119d9565b506000838581611aa957fe5b0495945050505050565b611ad28273ffffffffffffffffffffffffffffffffffffffff16611cf1565b611b3d57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f5361666545524332303a2063616c6c20746f206e6f6e2d636f6e747261637400604482015290519081900360640190fd5b600060608373ffffffffffffffffffffffffffffffffffffffff16836040518082805190602001908083835b60208310611ba657805182527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101611b69565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114611c08576040519150601f19603f3d011682016040523d82523d6000602084013e611c0d565b606091505b509150915081611c7e57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564604482015290519081900360640190fd5b80511561197d57808060200190516020811015611c9a57600080fd5b505161197d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602a815260200180611d75602a913960400191505060405180910390fd5b6000813f7fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470818114801590611d2557508115155b94935050505056fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f775361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a26469706673582212205023359bcf9b3032173a5ab849d95f4f337ffb98768717df34aa7ffd3fb17fea64736f6c634300060c003300000000000000000000000081859801b01764d4f0fa5e64729f5a6c3b91435b000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000000000000000000000000000000000000000ad5700

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

00000000000000000000000081859801b01764d4f0fa5e64729f5a6c3b91435b000000000000000000000000000000000000000000000000002386f26fc100000000000000000000000000000000000000000000000000000000000000ad5700

-----Decoded View---------------
Arg [0] : _bfie (address): 0x81859801b01764D4f0Fa5E64729f5a6C3b91435b
Arg [1] : _bfiePerBlock (uint256): 10000000000000000
Arg [2] : _startBlock (uint256): 11360000

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000081859801b01764d4f0fa5e64729f5a6c3b91435b
Arg [1] : 000000000000000000000000000000000000000000000000002386f26fc10000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000ad5700

40460:10122:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43265:92;;;:::i;:::-;;;;;;;;;;;;;;;;42523:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;42105:26;;;;;;;;;;;;;;;;-1:-1:-1;42105:26:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42349:31;;;:::i;44824:312::-;;;;;;;;;;;;;;;;-1:-1:-1;44824:312:0;;;;;;;:::i;:::-;;43365:137;;;;;;;;;;;;;;;;-1:-1:-1;43365:137:0;;:::i;48084:754::-;;;;;;;;;;;;;;;;-1:-1:-1;48084:754:0;;;;;;;:::i;45199:796::-;;;;;;;;;;;;;;;;-1:-1:-1;45199:796:0;;;;;;;;;:::i;42439:22::-;;;:::i;46328:871::-;;;;;;;;;;;;;;;;-1:-1:-1;46328:871:0;;:::i;48909:353::-;;;;;;;;;;;;;;;;-1:-1:-1;48909:353:0;;:::i;49998:581::-;;;;;;;;;;;;;;;;-1:-1:-1;49998:581:0;;;;;;;;;;;;;;;;;;:::i;46078:174::-;;;:::i;2609:148::-;;;:::i;42045:24::-;;;:::i;1967:79::-;;;:::i;42189:63::-;;;;;;;;;;;;;;;;-1:-1:-1;42189:63:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;43577:1151;;;;;;;;;;;;;;;;-1:-1:-1;43577:1151:0;;;;;;;;;;;;;;;;;;;;;:::i;41970:27::-;;;:::i;47267:766::-;;;;;;;;;;;;;;;;-1:-1:-1;47267:766:0;;;;;;;:::i;2912:244::-;;;;;;;;;;;;;;;;-1:-1:-1;2912:244:0;;;;:::i;42470:44::-;;;:::i;43265:92::-;43334:8;:15;43265:92;:::o;42523:29::-;;;;;;:::o;42105:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42105:26:0;;;;;;;:::o;42349:31::-;;;;:::o;44824:312::-;2189:12;:10;:12::i;:::-;2179:6;;:22;:6;;;:22;;;2171:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44894:17:::1;:15;:17::i;:::-;44922:21;44946:8;44955:4;44946:14;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;44975;::::0;::::1;::::0;44946;;-1:-1:-1;44975:14:0::1;;44971:118;;;45024:53;45065:11;45024:36;45044:4;:15;;;45024;;:19;;:36;;;;:::i;:::-;:40:::0;::::1;:53::i;:::-;45006:15;:71:::0;44971:118:::1;45099:15;;:29:::0;-1:-1:-1;44824:312:0:o;43365:137::-;2189:12;:10;:12::i;:::-;2179:6;;:22;:6;;;:22;;;2171:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43438:17:::1;:15;:17::i;:::-;43466:12;:28:::0;43365:137::o;48084:754::-;48145:15;48163:10;48145:28;;48184:21;48208:8;48217:4;48208:14;;;;;;;;;;;;;;;;48257;;;:8;:14;;;;;;:23;;;;;;;;;;48299:11;;48208:14;;;;;;;;-1:-1:-1;48299:22:0;-1:-1:-1;48299:22:0;48291:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48355:16;48366:4;48355:10;:16::i;:::-;48382:13;48398:68;48450:4;:15;;;48398:47;48440:4;48398:37;48414:4;:20;;;48398:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47::i;:::-;:51;;:68::i;:::-;48382:84;-1:-1:-1;48481:12:0;;48477:80;;48510:35;48527:7;48536:8;48510:16;:35::i;:::-;48571:11;;48567:140;;48613:11;;:24;;48629:7;48613:15;:24::i;:::-;48599:38;;48652:12;;:43;;:12;;48678:7;48687;48652:25;:43::i;:::-;48751:20;;;;48735:11;;:47;;48777:4;;48735:37;;:15;:37::i;:47::-;48717:15;;;:65;48798:32;;;;;;;;48816:4;;48798:32;;;;;;;;;;;;;48084:754;;;;;;:::o;45199:796::-;45270:4;45287:21;45311:8;45320:4;45311:14;;;;;;;;;;;;;;;;45360;;;:8;:14;;;;;;;:21;;;;;;;;;;;;45311:14;;;;;;;;45415:20;;;;45462:12;;:37;;;;;45493:4;45462:37;;;;;;;;;45311:14;;-1:-1:-1;45360:21:0;;45311:14;45462:12;;;;;:22;;:37;;;;;45311:14;45462:37;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45462:37:0;45529:20;;;;45462:37;;-1:-1:-1;45514:12:0;:35;:52;;;;-1:-1:-1;45553:13:0;;;45514:52;45510:397;;;45583:15;45601:38;45618:4;:20;;;45601:12;:16;;:38;;;;:::i;:::-;45658:15;;45583:56;;-1:-1:-1;45658:19:0;45654:242;;45698:16;45717:70;45771:15;;45717:49;45750:4;:15;;;45717:28;45732:12;;45717:10;:14;;:28;;;;:::i;:::-;:32;;:49::i;:70::-;45698:89;-1:-1:-1;45824:56:0;45844:35;45870:8;45844:21;45698:89;45860:4;45844:15;:21::i;:35::-;45824:15;;:19;:56::i;:::-;45806:74;;45654:242;;45510:397;;45924:63;45971:4;:15;;;45924:42;45961:4;45924:32;45940:15;45924:4;:11;;;:15;;:32;;;;:::i;:63::-;45917:70;;;;;;45199:796;;;;;:::o;42439:22::-;;;;:::o;46328:871::-;46377:21;46401:8;46410:4;46401:14;;;;;;;;;;;;;;;;;;46377:38;;46446:4;:20;;;46430:12;:36;46426:75;;46483:7;;;46426:75;46527:12;;:37;;;;;;46558:4;46527:37;;;;;;46511:13;;46527:12;;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46527:37:0;;-1:-1:-1;46579:13:0;46575:102;;-1:-1:-1;46632:12:0;46609:20;;;;:35;46659:7;;46575:102;46692:14;;;;;;46687:138;;46723:14;;;:21;;;;46740:4;46723:21;;;;;;46797:15;;;46777;;:36;;:19;:36::i;:::-;46759:15;:54;46687:138;46839:15;;:19;46835:311;;46875:15;46893:38;46910:4;:20;;;46893:12;:16;;:38;;;;:::i;:::-;46875:56;;46946:16;46965:70;47019:15;;46965:49;46998:4;:15;;;46965:28;46980:12;;46965:10;:14;;:28;;;;:::i;:70::-;46946:89;-1:-1:-1;47073:61:0;47098:35;47124:8;47098:21;46946:89;47114:4;47098:15;:21::i;:35::-;47073:20;;;;;:24;:61::i;:::-;47050:20;;;:84;-1:-1:-1;;46835:311:0;-1:-1:-1;47179:12:0;47156:20;;;;:35;46328:871;;:::o;48909:353::-;48965:21;48989:8;48998:4;48989:14;;;;;;;;;;;;;;;;49038;;;:8;:14;;;;;;49053:10;49038:26;;;;;;;;49122:11;;48989:14;;;;;;;49075:12;;48989:14;;-1:-1:-1;49075:59:0;;49038:26;49075:12;;;;;49053:10;49075:25;:59::i;:::-;49186:11;;49150:48;;;;;;;49180:4;;49168:10;;49150:48;;;;;;;;;49223:1;49209:15;;;49235;;;;:19;-1:-1:-1;;48909:353:0:o;49998:581::-;2189:12;:10;:12::i;:::-;2179:6;;:22;:6;;;:22;;;2171:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50125:10:::1;::::0;50138:20;50125:33:::1;50110:12;:48;50106:424;;;50267:8;:15:::0;50253:11:::1;50297:222;50322:6;50316:3;:12;50297:222;;;50356:21;50380:8;50389:3;50380:13;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;50473:12:::0;;50380:13;;-1:-1:-1;50473:12:0::1;50463:22:::0;;::::1;50473:12:::0;::::1;50463:22;;50455:48;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;50330:5:0::1;;50297:222;;;;50106:424;;50540:31;:19;::::0;::::1;50560:2:::0;50564:6;50540:19:::1;:31::i;:::-;49998:581:::0;;;:::o;46078:174::-;46137:8;:15;46123:11;46163:82;46188:6;46182:3;:12;46163:82;;;46218:15;46229:3;46218:10;:15::i;:::-;46196:5;;46163:82;;;;46078:174;:::o;2609:148::-;2189:12;:10;:12::i;:::-;2179:6;;:22;:6;;;:22;;;2171:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2716:1:::1;2700:6:::0;;2679:40:::1;::::0;::::1;2700:6:::0;;::::1;::::0;2679:40:::1;::::0;2716:1;;2679:40:::1;2747:1;2730:19:::0;;;::::1;::::0;;2609:148::o;42045:24::-;;;;:::o;1967:79::-;2005:7;2032:6;;;1967:79;:::o;42189:63::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43577:1151::-;2189:12;:10;:12::i;:::-;2179:6;;:22;:6;;;:22;;;2171:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43698:11:::1;43694:61;;;43726:17;:15;:17::i;:::-;43784:10;;43769:12;:25;43765:520;;;43848:21:::0;43844:238:::1;;-1:-1:-1::0;43909:10:0::1;::::0;43844:238:::1;;;43983:10;;43964:16;:29;43960:107;;;-1:-1:-1::0;44037:10:0::1;::::0;43960:107:::1;43765:520;;;44150:21:::0;;;:56:::1;;;44194:12;44175:16;:31;44150:56;44146:128;;;-1:-1:-1::0;44246:12:0::1;44146:128;44295:15;44334:10;;44314:16;:30;;44313:70;;;;44370:12;44350:16;:32;;44313:70;44408:208;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;44408:208:0;;;;;;;::::1;::::0;::::1;::::0;;;;;;44394:8:::1;:223:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;;44408:208;;-1:-1:-1;44628:93:0::1;;44677:15;::::0;:32:::1;::::0;44697:11;44677:19:::1;:32::i;:::-;44659:15;:50:::0;44628:93:::1;2249:1;43577:1151:::0;;;;:::o;41970:27::-;;;;;;:::o;47267:766::-;47327:15;47345:10;47327:28;;47366:21;47390:8;47399:4;47390:14;;;;;;;;;;;;;;;;47439;;;:8;:14;;;;;;:23;;;;;;;;;;47390:14;;;;;;;;-1:-1:-1;47473:16:0;47448:4;47473:10;:16::i;:::-;47504:11;;:15;47500:234;;47536:13;47552:68;47604:4;:15;;;47552:47;47594:4;47552:37;47568:4;:20;;;47552:4;:11;;;:15;;:37;;;;:::i;:68::-;47536:84;-1:-1:-1;47639:12:0;;47635:88;;47672:35;47689:7;47698:8;47672:16;:35::i;:::-;47500:234;;47748:11;;47744:159;;47776:12;;:62;;:12;;47806:7;47823:4;47830:7;47776:29;:62::i;:::-;47867:11;;:24;;47883:7;47867:15;:24::i;:::-;47853:38;;47744:159;47947:20;;;;47931:11;;:47;;47973:4;;47931:37;;:15;:37::i;:47::-;47913:15;;;:65;47994:31;;;;;;;;48011:4;;47994:31;;;;;;;;;;;;;47267:766;;;;;:::o;2912:244::-;2189:12;:10;:12::i;:::-;2179:6;;:22;:6;;;:22;;;2171:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3001:22:::1;::::0;::::1;2993:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3103:6;::::0;;3082:38:::1;::::0;::::1;::::0;;::::1;::::0;3103:6;::::1;::::0;3082:38:::1;::::0;::::1;3131:6;:17:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;2912:244::o;42470:44::-;42509:5;42470:44;:::o;605:106::-;693:10;605:106;:::o;10492:136::-;10550:7;10577:43;10581:1;10584;10577:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;10570:50;10492:136;-1:-1:-1;;;10492:136:0:o;10036:181::-;10094:7;10126:5;;;10150:6;;;;10142:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11366:471;11424:7;11669:6;11665:47;;-1:-1:-1;11699:1:0;11692:8;;11665:47;11736:5;;;11740:1;11736;:5;:1;11760:5;;;;;:10;11752:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12305:132;12363:7;12390:39;12394:1;12397;12390:39;;;;;;;;;;;;;;;;;:3;:39::i;49375:335::-;49464:4;;:29;;;;;;49487:4;49464:29;;;;;;49448:13;;49464:4;;;:14;;:29;;;;;;;;;;;;;;:4;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49464:29:0;;-1:-1:-1;49508:12:0;;49504:199;;49551:8;49541:7;:18;49537:155;;;49580:4;;:28;;;;;;:4;:28;;;;;;;;;;;;;;;:4;;;;;:13;;:28;;;;;;;;;;;;;;:4;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49537:155:0;;-1:-1:-1;49537:155:0;;49649:4;;:27;;;;;;:4;:27;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31481:177;31591:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31614:23;31591:58;;;31564:86;;31584:5;;31564:19;:86::i;31666:205::-;31794:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31817:27;31794:68;;;31767:96;;31787:5;;31767:19;:96::i;:::-;31666:205;;;;:::o;10923:192::-;11009:7;11045:12;11037:6;;;;11029:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11081:5:0;;;10923:192::o;12925:345::-;13011:7;13113:12;13106:5;13098:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13137:9;13153:1;13149;:5;;;;;;;12925:345;-1:-1:-1;;;;;12925:345:0:o;33525:1115::-;34130:27;34138:5;34130:25;;;:27::i;:::-;34122:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34267:12;34281:23;34316:5;34308:19;;34328:4;34308:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34266:67;;;;34352:7;34344:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34413:17;;:21;34409:224;;34555:10;34544:30;;;;;;;;;;;;;;;-1:-1:-1;34544:30:0;34536:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15188:619;15248:4;15716:20;;15559:66;15756:23;;;;;;:42;;-1:-1:-1;15783:15:0;;;15756:42;15748:51;15188:619;-1:-1:-1;;;;15188:619:0:o

ipfs://5023359bcf9b3032173a5ab849d95f4f337ffb98768717df34aa7ffd3fb17fea