Contract 0x9a92BF2dE60AAE00EeD7F314aDee6F2537658Ec1

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

// File: masterchef_flat.sol


// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol




pragma solidity ^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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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



pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.8.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 Contracts guidelines: functions revert
 * instead 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, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

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

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

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        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] + 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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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:
     *
     * - `account` 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 += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

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

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

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol



pragma solidity ^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() {
        _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: @openzeppelin/contracts/utils/math/SafeMath.sol



pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
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) {
        unchecked {
            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) {
        unchecked {
            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) {
        unchecked {
            // 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) {
        unchecked {
            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) {
        unchecked {
            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) {
        return a + b;
    }

    /**
     * @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 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) {
        return a * b;
    }

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol



pragma solidity ^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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/utils/Address.sol



pragma solidity ^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;
        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");

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

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/Context.sol

// File: wave/masterchef.sol



pragma solidity ^0.8.0;









 
pragma solidity ^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 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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

interface IReferral {
    /**
     * @dev Record referral.
     */
    function recordReferral(address user, address referrer) external;

    /**
     * @dev Get the referrer address that referred the user.
     */
    function getReferrer(address user) external view returns (address);
}
contract IrisToken is ERC20("WAVE", "WAVE"), Ownable {
    
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }

}
// MasterChef is the master of WAVE. He can make WAVE and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once Wave is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
// European boys play fair, don't worry.

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.
        //
        // We do some fancy math here. Basically, any point in time, the amount of WAVE
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accIrisPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accIrisPerShare` (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. IRISes to distribute per block.
        uint256 lastRewardBlock;  // Last block number that IRISes distribution occurs.
        uint256 accIrisPerShare;   // Accumulated IRISes per share, times 1e18. See below.
        uint16 depositFeeBP;      // Deposit fee in basis points
	uint256 lpSupply;
    }

    // The IRIS TOKEN!
    IrisToken public iris;
    address public devAddress;
    address public feeAddress;
    uint256 constant max_iris_supply = 10500000 ether;

    // IRIS tokens created per block.
    uint256 public irisPerBlock = 0.2 ether;

    // 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 IRIS mining starts.
    uint256 public startBlock;

    // Iris referral contract address.
    IReferral public referral;
    // Referral commission rate in basis points.
    uint16 public referralCommissionRate = 200;
    // Max referral commission rate: 5%.
    uint16 public constant MAXIMUM_REFERRAL_COMMISSION_RATE = 500;
    uint256 public constant MAXIMUM_EMISSION_RATE = 1 ether;

    bool updateReferralAddress = false;

    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 newAddress);
    event SetDevAddress(address indexed user, address indexed newAddress);
    event SetReferralAddress(address indexed user, IReferral indexed newAddress);
    event UpdateEmissionRate(address indexed user, uint256 irisPerBlock);
    event ReferralCommissionPaid(address indexed user, address indexed referrer, uint256 commissionAmount);
    event PoolAdd(address indexed user, IERC20 lpToken, uint256 allocPoint, uint256 lastRewardBlock, uint16 depositFeeBP);
    event PoolSet(address indexed user, IERC20 lpToken, uint256 allocPoint, uint256 lastRewardBlock, uint16 depositFeeBP);
    event SetReferralCommissionRate(address indexed user, uint16 referralCommmissionRate);
    event UpdateStartBlock(address indexed user, uint256 startBlock);
    constructor(
        IrisToken _iris,
        uint256 _startBlock,
        address _devAddress,
        address _feeAddress

    ) public {
        iris = _iris;
        startBlock = _startBlock;

        devAddress = _devAddress;
        feeAddress = _feeAddress;

    }

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

    mapping(IERC20 => bool) public poolExistence;
    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) external onlyOwner nonDuplicated(_lpToken) {
	_lpToken.balanceOf(address(this));
        require(_depositFeeBP <= 500, "add: invalid deposit fee basis points");
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolExistence[_lpToken] = true;
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accIrisPerShare: 0,
            depositFeeBP: _depositFeeBP,
	    lpSupply: 0
        }));
	emit PoolAdd(msg.sender, _lpToken, _allocPoint,lastRewardBlock,_depositFeeBP);
    }

    // Update the given pool's IRIS allocation point and deposit fee. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP) external onlyOwner {
        require(_depositFeeBP <= 500, "set: invalid deposit fee basis points");
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        poolInfo[_pid].depositFeeBP = _depositFeeBP;
	emit PoolSet(msg.sender, poolInfo[_pid].lpToken, _allocPoint,poolInfo[_pid].lastRewardBlock,_depositFeeBP);
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        if (iris.totalSupply() >= max_iris_supply) return 0;

        return _to.sub(_from);
    }

    // View function to see pending IRISes on frontend.
    function pendingIris(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accIrisPerShare = pool.accIrisPerShare;
        if (block.number > pool.lastRewardBlock && pool.lpSupply != 0 && totalAllocPoint > 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 irisReward = multiplier.mul(irisPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accIrisPerShare = accIrisPerShare.add(irisReward.mul(1e18).div(pool.lpSupply));
        }
        return user.amount.mul(accIrisPerShare).div(1e18).sub(user.rewardDebt);
    }

    // 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;
        }
        if (pool.lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 irisReward = multiplier.mul(irisPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
	if(iris.totalSupply().add(irisReward.mul(105).div(100)) <= max_iris_supply){
	  iris.mint(devAddress, irisReward.div(20));
	  iris.mint(address(this), irisReward);
	}else if(iris.totalSupply() < max_iris_supply){
	  iris.mint(address(this), max_iris_supply.sub(iris.totalSupply()));
	}
        pool.accIrisPerShare = pool.accIrisPerShare.add(irisReward.mul(1e18).div(pool.lpSupply));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for IRIS allocation.
    function deposit(uint256 _pid, uint256 _amount, address _referrer) nonReentrant external {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (_amount > 0 && address(referral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {
            referral.recordReferral(msg.sender, _referrer);
        }
        if (user.amount > 0) {
            uint256 pending = user.amount.mul(pool.accIrisPerShare).div(1e18).sub(user.rewardDebt);
            if (pending > 0) {
                safeIrisTransfer(msg.sender, pending);
                payReferralCommission(msg.sender, pending);
            }
        }
        if (_amount > 0) {
	    uint256 balanceBefore = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
	    _amount = pool.lpToken.balanceOf(address(this)).sub(balanceBefore);
	    require(_amount > 0, "we dont accept deposits of 0");
            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(feeAddress, depositFee);
                user.amount = user.amount.add(_amount).sub(depositFee);
		pool.lpSupply = pool.lpSupply.add(_amount).sub(depositFee);
            } else {
                user.amount = user.amount.add(_amount);
		pool.lpSupply = pool.lpSupply.add(_amount);
            }
        }
        user.rewardDebt = user.amount.mul(pool.accIrisPerShare).div(1e18);
        emit Deposit(msg.sender, _pid, _amount);
    }

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

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

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

    // Update dev address by the previous dev.
    function setDevAddress(address _devAddress) external onlyOwner {
	require(_devAddress != address(0), "!nonzero");
        devAddress = _devAddress;
        emit SetDevAddress(msg.sender, _devAddress);
    }

    function setFeeAddress(address _feeAddress) external onlyOwner {
	require(_feeAddress != address(0), "!nonzero");
        feeAddress = _feeAddress;
        emit SetFeeAddress(msg.sender, _feeAddress);
    }

    function updateEmissionRate(uint256 _irisPerBlock) external onlyOwner {
        require(_irisPerBlock <= MAXIMUM_EMISSION_RATE, "Too High");
        massUpdatePools();
        irisPerBlock = _irisPerBlock;
        emit UpdateEmissionRate(msg.sender, _irisPerBlock);
    }

    // Update the referral contract address by the owner
    function setReferralAddress(IReferral _referral) external onlyOwner {
	require(updateReferralAddress == false, "The Referral contract address is changed already");
        referral = _referral;
	updateReferralAddress = true;
        emit SetReferralAddress(msg.sender, _referral);
    }

    // Update referral commission rate by the owner
    function setReferralCommissionRate(uint16 _referralCommissionRate) external onlyOwner {
        require(_referralCommissionRate <= MAXIMUM_REFERRAL_COMMISSION_RATE, "setReferralCommissionRate: invalid referral commission rate basis points");
        referralCommissionRate = _referralCommissionRate;
	emit SetReferralCommissionRate(msg.sender, _referralCommissionRate);
    }

    // Pay referral commission to the referrer who referred this user.
    function payReferralCommission(address _user, uint256 _pending) internal {
        if (address(referral) != address(0) && referralCommissionRate > 0) {
            address referrer = referral.getReferrer(_user);
            uint256 commissionAmount = _pending.mul(referralCommissionRate).div(10000);

            if (referrer != address(0) && commissionAmount > 0) {
		if(iris.totalSupply().add(commissionAmount) <= max_iris_supply){
		  iris.mint(referrer, commissionAmount);
		}else if(iris.totalSupply() < max_iris_supply) {
		  iris.mint(address(this), max_iris_supply.sub(iris.totalSupply()));
		}
                emit ReferralCommissionPaid(_user, referrer, commissionAmount);
            }
        }
    }

    // Only update before start of farm
    function updateStartBlock(uint256 _startBlock) onlyOwner external{
	require(startBlock > block.number, "Farm already started");
	uint256 length = poolInfo.length;
	for(uint256 pid = 0; pid < length; ++pid){
		PoolInfo storage pool = poolInfo[pid];
		pool.lastRewardBlock = _startBlock;
	}
        startBlock = _startBlock;
	emit UpdateStartBlock(msg.sender, _startBlock);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IrisToken","name":"_iris","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"address","name":"_feeAddress","type":"address"}],"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":"contract IERC20","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"depositFeeBP","type":"uint16"}],"name":"PoolAdd","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"contract IERC20","name":"lpToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"indexed":false,"internalType":"uint16","name":"depositFeeBP","type":"uint16"}],"name":"PoolSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"referrer","type":"address"},{"indexed":false,"internalType":"uint256","name":"commissionAmount","type":"uint256"}],"name":"ReferralCommissionPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"contract IReferral","name":"newAddress","type":"address"}],"name":"SetReferralAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint16","name":"referralCommmissionRate","type":"uint16"}],"name":"SetReferralCommissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"irisPerBlock","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"startBlock","type":"uint256"}],"name":"UpdateStartBlock","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":"MAXIMUM_EMISSION_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_REFERRAL_COMMISSION_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"add","outputs":[],"stateMutability":"nonpayable","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":[],"name":"devAddress","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":[{"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":[],"name":"iris","outputs":[{"internalType":"contract IrisToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"irisPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"pendingIris","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":"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":"accIrisPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"lpSupply","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referral","outputs":[{"internalType":"contract IReferral","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referralCommissionRate","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"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"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress","type":"address"}],"name":"setFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IReferral","name":"_referral","type":"address"}],"name":"setReferralAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_referralCommissionRate","type":"uint16"}],"name":"setReferralCommissionRate","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":"_irisPerBlock","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":"_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"}],"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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

000000000000000000000000df2e3acef7324b86c3d3e8fb2f96810964c80433000000000000000000000000000000000000000000000000000000000123d114000000000000000000000000c2057c9eaa6c5c3a18ab594023c5c067ffb40812000000000000000000000000c2057c9eaa6c5c3a18ab594023c5c067ffb40812

-----Decoded View---------------
Arg [0] : _iris (address): 0xdf2e3acef7324b86c3d3e8fb2f96810964c80433
Arg [1] : _startBlock (uint256): 19124500
Arg [2] : _devAddress (address): 0xc2057c9eaa6c5c3a18ab594023c5c067ffb40812
Arg [3] : _feeAddress (address): 0xc2057c9eaa6c5c3a18ab594023c5c067ffb40812

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000df2e3acef7324b86c3d3e8fb2f96810964c80433
Arg [1] : 000000000000000000000000000000000000000000000000000000000123d114
Arg [2] : 000000000000000000000000c2057c9eaa6c5c3a18ab594023c5c067ffb40812
Arg [3] : 000000000000000000000000c2057c9eaa6c5c3a18ab594023c5c067ffb40812

41234:14468:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45490:773;;;;;;:::i;:::-;;:::i;:::-;;45120:95;45192:8;:15;45120:95;;;14114:25:1;;;14102:2;14087:18;45120:95:0;;;;;;;;53385:276;;;;;;:::i;:::-;;:::i;43402:25::-;;;;;-1:-1:-1;;;;;43402:25:0;;;;;;-1:-1:-1;;;;;4200:32:1;;;4182:51;;4170:2;4155:18;43402:25:0;4036:203:1;42996:26:0;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;6166:32:1;;;6148:51;;6230:2;6215:18;;6208:34;;;;6258:18;;;6251:34;;;;6316:2;6301:18;;6294:34;6377:6;6365:19;6359:3;6344:19;;6337:48;6186:3;6401:19;;6394:35;6135:3;6120:19;42996:26:0;5850:585:1;43237:34:0;;;;;;46375:484;;;;;;:::i;:::-;;:::i;42760:25::-;;;;;-1:-1:-1;;;;;42760:25:0;;;42792;;;;;-1:-1:-1;;;;;42792:25:0;;;50971:864;;;;;;:::i;:::-;;:::i;43575:61::-;;43633:3;43575:61;;;;;13949:6:1;13937:19;;;13919:38;;13907:2;13892:18;43575:61:0;13775:188:1;43328:25:0;;;;;;48249:945;;;;;;:::i;:::-;;:::i;51906:449::-;;;;;;:::i;:::-;;:::i;54079:379::-;;;;;;:::i;:::-;;:::i;47993:180::-;;;:::i;43643:55::-;;43691:7;43643:55;;27639:94;;;:::i;53167:210::-;;;;;;:::i;:::-;;:::i;26988:87::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;26988:87;;46935:185;;;;;;:::i;:::-;;:::i;49263:1656::-;;;;;;:::i;:::-;;:::i;43078:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14324:25:1;;;14380:2;14365:18;;14358:34;;;;14297:18;43078:64:0;14150:248:1;53727:291:0;;;;;;:::i;:::-;;:::i;42921:39::-;;;;;;47185:725;;;;;;:::i;:::-;;:::i;42732:21::-;;;;;-1:-1:-1;;;;;42732:21:0;;;45223:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5377:14:1;;5370:22;5352:41;;5340:2;5325:18;45223:44:0;5212:187:1;52949:210:0;;;;;;:::i;:::-;;:::i;43484:42::-;;;;;-1:-1:-1;;;43484:42:0;;;;;;27888:192;;;;;;:::i;:::-;;:::i;55313:386::-;;;;;;:::i;:::-;;:::i;45490:773::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;45333:23:0;::::1;;::::0;;;:13:::1;:23;::::0;;;;;45596:8;;45333:23:::1;;:32;45325:70;;;::::0;-1:-1:-1;;;45325:70:0;;12852:2:1;45325:70:0::1;::::0;::::1;12834:21:1::0;12891:2;12871:18;;;12864:30;12930:27;12910:18;;;12903:55;12975:18;;45325:70:0::1;12650:349:1::0;45325:70:0::1;45610:33:::2;::::0;-1:-1:-1;;;45610:33:0;;45637:4:::2;45610:33;::::0;::::2;4182:51:1::0;-1:-1:-1;;;;;45610:18:0;::::2;::::0;::::2;::::0;4155::1;;45610:33:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;45679:3;45662:13;:20;;;;45654:70;;;::::0;-1:-1:-1;;;45654:70:0;;7482:2:1;45654:70:0::2;::::0;::::2;7464:21:1::0;7521:2;7501:18;;;7494:30;7560:34;7540:18;;;7533:62;-1:-1:-1;;;7611:18:1;;;7604:35;7656:19;;45654:70:0::2;7280:401:1::0;45654:70:0::2;45735:23;45776:10;;45761:12;:25;:53;;45804:10;;45761:53;;;45789:12;45761:53;45843:15;::::0;45735:79;;-1:-1:-1;45843:32:0::2;::::0;45863:11;45843:19:::2;:32::i;:::-;45825:15;:50:::0;-1:-1:-1;;;;;45886:23:0;;::::2;;::::0;;;:13:::2;:23;::::0;;;;;;;:30;;45912:4:::2;-1:-1:-1::0;;45886:30:0;;::::2;::::0;::::2;::::0;;;45941:232;;::::2;::::0;::::2;::::0;;;;;;;::::2;::::0;;;;;;;;;;;;;;;;::::2;::::0;;::::2;::::0;;;;;;;;;;;;;45927:8:::2;:247:::0;;;;::::2;::::0;;;;;;;;;;;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;;;;;45927:247:0::2;::::0;;;::::2;::::0;;;::::2;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45927:247:0::2;::::0;;;::::2;;::::0;;;;;;;;;;;;46183:72;;5646:51:1;;;5713:18;;;5706:34;;;5756:18;;5749:34;;;5799:18;;;5792:47;46191:10:0::2;::::0;46183:72:::2;::::0;5618:19:1;46183:72:0::2;;;;;;;45606:657;27279:1:::1;45490:773:::0;;;:::o;53385:276::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;43691:7:::1;53474:13;:38;;53466:59;;;::::0;-1:-1:-1;;;53466:59:0;;10225:2:1;53466:59:0::1;::::0;::::1;10207:21:1::0;10264:1;10244:18;;;10237:29;-1:-1:-1;;;10282:18:1;;;10275:38;10330:18;;53466:59:0::1;10023:331:1::0;53466:59:0::1;53536:17;:15;:17::i;:::-;53564:12;:28:::0;;;53608:45:::1;::::0;14114:25:1;;;53627:10:0::1;::::0;53608:45:::1;::::0;14102:2:1;14087:18;53608:45:0::1;;;;;;;;53385:276:::0;:::o;42996:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42996:26:0;;;;-1:-1:-1;42996:26:0;;;;;;;;;;:::o;46375:484::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;46500:3:::1;46483:13;:20;;;;46475:70;;;::::0;-1:-1:-1;;;46475:70:0;;10963:2:1;46475:70:0::1;::::0;::::1;10945:21:1::0;11002:2;10982:18;;;10975:30;11041:34;11021:18;;;11014:62;-1:-1:-1;;;11092:18:1;;;11085:35;11137:19;;46475:70:0::1;10761:401:1::0;46475:70:0::1;46574:63;46625:11;46574:46;46594:8;46603:4;46594:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;46574:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;46556:15;:81;;;;46676:11;46648:8;46657:4;46648:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;46728:13;46698:8;46707:4;46698:14;;;;;;;;:::i;:::-;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;46758:10;-1:-1:-1::0;;;;;46750:101:0::1;;46770:8;46779:4;46770:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:22:::0;46806:14;;-1:-1:-1;;;;;46770:22:0;;::::1;::::0;46794:11;;46815:4;;46806:14;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;:30:::1;:14;::::0;;::::1;;:30;::::0;46750:101:::1;::::0;;-1:-1:-1;;;;;5664:32:1;;;5646:51;;5713:18;;;5706:34;;;;5756:18;;5749:34;5831:6;5819:19;;5814:2;5799:18;;5792:47;5633:3;5618:19;46750:101:0::1;;;;;;;46375:484:::0;;;:::o;50971:864::-;18088:1;18684:7;;:19;;18676:63;;;;-1:-1:-1;;;18676:63:0;;;;;;;:::i;:::-;18088:1;18817:7;:18;;;;51053:21:::1;51077:8;51086:4;51077:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;51126;;;:8:::1;:14:::0;;;;;;51141:10:::1;51126:26:::0;;;;;;;51171:11;;51077:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;51171:22:0;-1:-1:-1;51171:22:0::1;51163:53;;;::::0;-1:-1:-1;;;51163:53:0;;12505:2:1;51163:53:0::1;::::0;::::1;12487:21:1::0;12544:2;12524:18;;;12517:30;-1:-1:-1;;;12563:18:1;;;12556:48;12621:18;;51163:53:0::1;12303:342:1::0;51163:53:0::1;51227:16;51238:4;51227:10;:16::i;:::-;51254:15;51272:68;51324:4;:15;;;51272:47;51314:4;51272:37;51288:4;:20;;;51272:4;:11;;;:15;;:37;;;;:::i;:::-;:41:::0;::::1;:47::i;:::-;:51:::0;::::1;:68::i;:::-;51254:86:::0;-1:-1:-1;51355:11:0;;51351:138:::1;;51383:37;51400:10;51412:7;51383:16;:37::i;:::-;51435:42;51457:10;51469:7;51435:21;:42::i;:::-;51503:11:::0;;51499:202:::1;;51545:11:::0;;:24:::1;::::0;51561:7;51545:15:::1;:24::i;:::-;51531:38:::0;;51584:12;;:55:::1;::::0;-1:-1:-1;;;;;51584:12:0::1;51618:10;51631:7:::0;51584:25:::1;:55::i;:::-;51663:13;::::0;::::1;::::0;:26:::1;::::0;51681:7;51663:17:::1;:26::i;:::-;51647:13;::::0;::::1;:42:::0;51499:202:::1;51745:20;::::0;::::1;::::0;51729:11;;:47:::1;::::0;51771:4:::1;::::0;51729:37:::1;::::0;:15:::1;:37::i;:47::-;51711:15;::::0;::::1;:65:::0;51792:35:::1;::::0;14114:25:1;;;51813:4:0;;51801:10:::1;::::0;51792:35:::1;::::0;14102:2:1;14087:18;51792:35:0::1;;;;;;;;-1:-1:-1::0;;18044:1:0;18996:22;;-1:-1:-1;;;50971:864:0:o;48249:945::-;48301:21;48325:8;48334:4;48325:14;;;;;;;;:::i;:::-;;;;;;;;;;;48301:38;;48370:4;:20;;;48354:12;:36;48350:75;;48407:7;48249:945;:::o;48350:75::-;48439:13;;;;:18;;:42;;-1:-1:-1;48461:15:0;;;;:20;48439:42;48435:131;;;48521:12;48498:20;;;;:35;-1:-1:-1;48249:945:0:o;48435:131::-;48576:18;48597:49;48611:4;:20;;;48633:12;48597:13;:49::i;:::-;48576:70;;48657:18;48678:70;48732:15;;48678:49;48711:4;:15;;;48678:28;48693:12;;48678:10;:14;;:28;;;;:::i;:::-;:32;;:49::i;:70::-;48657:91;-1:-1:-1;42859:14:0;48755:52;48778:28;48802:3;48778:19;48657:91;48793:3;48778:14;:19::i;:28::-;48755:4;;;;;;;;;-1:-1:-1;;;;;48755:4:0;-1:-1:-1;;;;;48755:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:52::-;:71;48752:290;;48833:4;;48843:10;;-1:-1:-1;;;;;48833:4:0;;;;:9;;48843:10;48855:18;:10;48870:2;48855:14;:18::i;:::-;48833:41;;-1:-1:-1;;;;;;48833:41:0;;;;;;;-1:-1:-1;;;;;5125:32:1;;;48833:41:0;;;5107:51:1;5174:18;;;5167:34;5080:18;;48833:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;48880:4:0;;:36;;-1:-1:-1;;;48880:36:0;;48898:4;48880:36;;;5107:51:1;5174:18;;;5167:34;;;-1:-1:-1;;;;;48880:4:0;;;;-1:-1:-1;48880:9:0;;-1:-1:-1;5080:18:1;;48880:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48752:290;;;48929:4;;:18;;;-1:-1:-1;;;48929:18:0;;;;42859:14;;-1:-1:-1;;;;;48929:4:0;;:16;;:18;;;;;;;;;;;;;;:4;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;48926:116;;;48972:4;;49017:18;;;-1:-1:-1;;;49017:18:0;;;;-1:-1:-1;;;;;48972:4:0;;;;:9;;48990:4;;48997:39;;48972:4;;49017:16;;:18;;;;;;;;;;;;;;;48972:4;49017:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42859:14;;48997:19;:39::i;:::-;48972:65;;-1:-1:-1;;;;;;48972:65:0;;;;;;;-1:-1:-1;;;;;5125:32:1;;;48972:65:0;;;5107:51:1;5174:18;;;5167:34;5080:18;;48972:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48926:116;49125:13;;;;49075:65;;49100:39;;:20;:10;49115:4;49100:14;:20::i;:39::-;49075:20;;;;;:24;:65::i;:::-;49052:20;;;:88;-1:-1:-1;;49174:12:0;49151:20;;;;:35;-1:-1:-1;48249:945:0:o;51906:449::-;18088:1;18684:7;;:19;;18676:63;;;;-1:-1:-1;;;18676:63:0;;;;;;;:::i;:::-;18088:1;18817:7;:18;;;;51979:21:::1;52003:8;52012:4;52003:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;52052;;;:8:::1;:14:::0;;;;;;52067:10:::1;52052:26:::0;;;;;;;52106:11;;52003:14:::1;::::0;;;::::1;::::0;;::::1;52137:13;::::0;::::1;::::0;52003:14;;-1:-1:-1;52137:30:0::1;::::0;52106:11;52137:17:::1;:30::i;:::-;52121:13;::::0;::::1;:46:::0;52192:1:::1;52178:15:::0;;;52204::::1;::::0;::::1;:19:::0;52234:12;;:54:::1;::::0;-1:-1:-1;;;;;52234:12:0::1;52268:10;52281:6:::0;52234:25:::1;:54::i;:::-;52304:43;::::0;14114:25:1;;;52334:4:0;;52322:10:::1;::::0;52304:43:::1;::::0;14102:2:1;14087:18;52304:43:0::1;;;;;;;-1:-1:-1::0;;18044:1:0;18996:22;;-1:-1:-1;;51906:449:0:o;54079:379::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;43633:3:::1;54184:59;::::0;::::1;;;54176:144;;;::::0;-1:-1:-1;;;54176:144:0;;7888:2:1;54176:144:0::1;::::0;::::1;7870:21:1::0;7927:2;7907:18;;;7900:30;7966:34;7946:18;;;7939:62;8037:34;8017:18;;;8010:62;-1:-1:-1;;;8088:19:1;;;8081:39;8137:19;;54176:144:0::1;7686:476:1::0;54176:144:0::1;54331:22;:48:::0;;-1:-1:-1;;;;54331:48:0::1;-1:-1:-1::0;;;54331:48:0::1;::::0;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;54388:62:::1;::::0;13919:38:1;;;54414:10:0::1;::::0;54388:62:::1;::::0;13907:2:1;13892:18;54388:62:0::1;13775:188:1::0;47993:180:0;48055:8;:15;48038:14;48081:85;48109:6;48103:3;:12;48081:85;;;48139:15;48150:3;48139:10;:15::i;:::-;48117:5;;;:::i;:::-;;;48081:85;;;;48027:146;47993:180::o;27639:94::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;27704:21:::1;27722:1;27704:9;:21::i;:::-;27639:94::o:0;53167:210::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;53242:25:0;::::1;53234:46;;;::::0;-1:-1:-1;;;53234:46:0;;9889:2:1;53234:46:0::1;::::0;::::1;9871:21:1::0;9928:1;9908:18;;;9901:29;-1:-1:-1;;;9946:18:1;;;9939:38;9994:18;;53234:46:0::1;9687:331:1::0;53234:46:0::1;53291:10;:24:::0;;-1:-1:-1;;;;;;53291:24:0::1;-1:-1:-1::0;;;;;53291:24:0;::::1;::::0;;::::1;::::0;;;53331:38:::1;::::0;53345:10:::1;::::0;53331:38:::1;::::0;-1:-1:-1;;53331:38:0::1;53167:210:::0;:::o;46935:185::-;47007:7;42859:14;47031:4;;;;;;;;;-1:-1:-1;;;;;47031:4:0;-1:-1:-1;;;;;47031:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:37;47027:51;;-1:-1:-1;47077:1:0;47070:8;;47027:51;47098:14;:3;47106:5;47098:7;:14::i;:::-;47091:21;;46935:185;;;;;:::o;49263:1656::-;18088:1;18684:7;;:19;;18676:63;;;;-1:-1:-1;;;18676:63:0;;;;;;;:::i;:::-;18088:1;18817:7;:18;;;;49363:21:::1;49387:8;49396:4;49387:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;49436;;;:8:::1;:14:::0;;;;;;49451:10:::1;49436:26:::0;;;;;;;49387:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;49473:16:0::1;49445:4:::0;49473:10:::1;:16::i;:::-;49514:1;49504:7;:11;:46;;;;-1:-1:-1::0;49527:8:0::1;::::0;-1:-1:-1;;;;;49527:8:0::1;49519:31:::0;::::1;49504:46;:73;;;;-1:-1:-1::0;;;;;;49554:23:0;::::1;::::0;::::1;49504:73;:100;;;;-1:-1:-1::0;;;;;;49581:23:0;::::1;49594:10;49581:23;;49504:100;49500:179;;;49621:8;::::0;:46:::1;::::0;-1:-1:-1;;;49621:46:0;;49645:10:::1;49621:46;::::0;::::1;4456:34:1::0;-1:-1:-1;;;;;4526:15:1;;;4506:18;;;4499:43;49621:8:0;;::::1;::::0;:23:::1;::::0;4391:18:1;;49621:46:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49500:179;49693:11:::0;;:15;49689:298:::1;;49725:15;49743:68;49795:4;:15;;;49743:47;49785:4;49743:37;49759:4;:20;;;49743:4;:11;;;:15;;:37;;;;:::i;:68::-;49725:86:::0;-1:-1:-1;49830:11:0;;49826:150:::1;;49862:37;49879:10;49891:7;49862:16;:37::i;:::-;49918:42;49940:10;49952:7;49918:21;:42::i;:::-;49710:277;49689:298;50001:11:::0;;49997:789:::1;;50046:12:::0;;:37:::1;::::0;-1:-1:-1;;;50046:37:0;;50077:4:::1;50046:37;::::0;::::1;4182:51:1::0;50022:21:0::1;::::0;-1:-1:-1;;;;;50046:12:0::1;::::0;:22:::1;::::0;4155:18:1;;50046:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50098:12:::0;;50022:61;;-1:-1:-1;50098:74:0::1;::::0;-1:-1:-1;;;;;50098:12:0::1;50136:10;50157:4;50164:7:::0;50098:29:::1;:74::i;:::-;50190:12:::0;;:37:::1;::::0;-1:-1:-1;;;50190:37:0;;50221:4:::1;50190:37;::::0;::::1;4182:51:1::0;50190:56:0::1;::::0;50232:13;;-1:-1:-1;;;;;50190:12:0;;::::1;::::0;:22:::1;::::0;4155:18:1;;50190:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:56::-;50180:66;;50272:1;50262:7;:11;50254:52;;;::::0;-1:-1:-1;;;50254:52:0;;9183:2:1;50254:52:0::1;::::0;::::1;9165:21:1::0;9222:2;9202:18;;;9195:30;9261;9241:18;;;9234:58;9309:18;;50254:52:0::1;8981:352:1::0;50254:52:0::1;50325:17;::::0;::::1;::::0;::::1;;:21:::0;50321:454:::1;;50400:17;::::0;::::1;::::0;50367:18:::1;::::0;50388:41:::1;::::0;50423:5:::1;::::0;50388:30:::1;::::0;:7;;50400:17:::1;;50388:11;:30::i;:41::-;50474:10;::::0;50448:12;;50367:62;;-1:-1:-1;50448:49:0::1;::::0;-1:-1:-1;;;;;50448:12:0;;::::1;::::0;50474:10:::1;50367:62:::0;50448:25:::1;:49::i;:::-;50530:11:::0;;:40:::1;::::0;50559:10;;50530:24:::1;::::0;50546:7;50530:15:::1;:24::i;:40::-;50516:54:::0;;50591:13:::1;::::0;::::1;::::0;:42:::1;::::0;50622:10;;50591:26:::1;::::0;50609:7;50591:17:::1;:26::i;:42::-;50575:13;::::0;::::1;:58:::0;-1:-1:-1;50321:454:0::1;;;50688:11:::0;;:24:::1;::::0;50704:7;50688:15:::1;:24::i;:::-;50674:38:::0;;50733:13:::1;::::0;::::1;::::0;:26:::1;::::0;50751:7;50733:17:::1;:26::i;:::-;50717:13;::::0;::::1;:42:::0;50321:454:::1;50014:772;49997:789;50830:20;::::0;::::1;::::0;50814:11;;:47:::1;::::0;50856:4:::1;::::0;50814:37:::1;::::0;:15:::1;:37::i;:47::-;50796:15;::::0;::::1;:65:::0;50877:34:::1;::::0;14114:25:1;;;50897:4:0;;50885:10:::1;::::0;50877:34:::1;::::0;14102:2:1;14087:18;50877:34:0::1;13968:177:1::0;53727:291:0;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;53807:21:::1;::::0;-1:-1:-1;;;53807:21:0;::::1;;;:30;53799:91;;;::::0;-1:-1:-1;;;53799:91:0;;11730:2:1;53799:91:0::1;::::0;::::1;11712:21:1::0;11769:2;11749:18;;;11742:30;11808:34;11788:18;;;11781:62;-1:-1:-1;;;11859:18:1;;;11852:46;11915:19;;53799:91:0::1;11528:412:1::0;53799:91:0::1;53901:8;:20:::0;;-1:-1:-1;;;;;;53925:28:0;-1:-1:-1;;;;;53901:20:0;::::1;53925:28:::0;;;-1:-1:-1;;;53925:28:0::1;::::0;;;53969:41:::1;::::0;53988:10:::1;::::0;53969:41:::1;::::0;53901:8:::1;::::0;53969:41:::1;53727:291:::0;:::o;47185:725::-;47258:7;47278:21;47302:8;47311:4;47302:14;;;;;;;;:::i;:::-;;;;;;;;;47351;;;:8;:14;;;;;;-1:-1:-1;;;;;47351:21:0;;;;;;;;;47409:20;47302:14;;;;;;;47409:20;;;;47459;;;;47302:14;;-1:-1:-1;47409:20:0;47444:12;:35;:57;;;;-1:-1:-1;47483:13:0;;;;:18;;47444:57;:80;;;;;47523:1;47505:15;;:19;47444:80;47440:382;;;47541:18;47562:49;47576:4;:20;;;47598:12;47562:13;:49::i;:::-;47541:70;;47626:18;47647:70;47701:15;;47647:49;47680:4;:15;;;47647:28;47662:12;;47647:10;:14;;:28;;;;:::i;:70::-;47626:91;;47750:60;47770:39;47795:4;:13;;;47770:20;47785:4;47770:10;:14;;:20;;;;:::i;:39::-;47750:15;;:19;:60::i;:::-;47732:78;;47526:296;;47440:382;47839:63;47886:4;:15;;;47839:42;47876:4;47839:32;47855:15;47839:4;:11;;;:15;;:32;;;;:::i;:63::-;47832:70;47185:725;-1:-1:-1;;;;;;47185:725:0:o;52949:210::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;53024:25:0;::::1;53016:46;;;::::0;-1:-1:-1;;;53016:46:0;;9889:2:1;53016:46:0::1;::::0;::::1;9871:21:1::0;9928:1;9908:18;;;9901:29;-1:-1:-1;;;9946:18:1;;;9939:38;9994:18;;53016:46:0::1;9687:331:1::0;53016:46:0::1;53073:10;:24:::0;;-1:-1:-1;;;;;;53073:24:0::1;-1:-1:-1::0;;;;;53073:24:0;::::1;::::0;;::::1;::::0;;;53113:38:::1;::::0;53127:10:::1;::::0;53113:38:::1;::::0;-1:-1:-1;;53113:38:0::1;52949:210:::0;:::o;27888:192::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27977:22:0;::::1;27969:73;;;::::0;-1:-1:-1;;;27969:73:0;;8369:2:1;27969:73:0::1;::::0;::::1;8351:21:1::0;8408:2;8388:18;;;8381:30;8447:34;8427:18;;;8420:62;-1:-1:-1;;;8498:18:1;;;8491:36;8544:19;;27969:73:0::1;8167:402:1::0;27969:73:0::1;28053:19;28063:8;28053:9;:19::i;:::-;27888:192:::0;:::o;55313:386::-;27034:7;27061:6;-1:-1:-1;;;;;27061:6:0;765:10;27208:23;27200:68;;;;-1:-1:-1;;;27200:68:0;;;;;;;:::i;:::-;55403:12:::1;55390:10;;:25;55382:58;;;::::0;-1:-1:-1;;;55382:58:0;;9540:2:1;55382:58:0::1;::::0;::::1;9522:21:1::0;9579:2;9559:18;;;9552:30;-1:-1:-1;;;9598:18:1;;;9591:50;9658:18;;55382:58:0::1;9338:344:1::0;55382:58:0::1;55461:8;:15:::0;55444:14:::1;55480:127;55507:6;55501:3;:12;55480:127;;;55526:21;55550:8;55559:3;55550:13;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;55568:20:::1;55550:13;::::0;;::::1;;55568:20;:34:::0;;;-1:-1:-1;55515:5:0::1;::::0;::::1;:::i;:::-;;;55480:127;;;-1:-1:-1::0;55617:10:0::1;:24:::0;;;55650:41:::1;::::0;14114:25:1;;;55667:10:0::1;::::0;55650:41:::1;::::0;14102:2:1;14087:18;55650:41:0::1;;;;;;;55378:321;55313:386:::0;:::o;21825:98::-;21883:7;21910:5;21914:1;21910;:5;:::i;22206:98::-;22264:7;22291:5;22295:1;22291;:5;:::i;22563:98::-;22621:7;22648:5;22652:1;22648;:5;:::i;22962:98::-;23020:7;23047:5;23051:1;23047;:5;:::i;52468:425::-;52562:4;;:29;;-1:-1:-1;;;52562:29:0;;52585:4;52562:29;;;4182:51:1;52544:15:0;;-1:-1:-1;;;;;52562:4:0;;:14;;4155:18:1;;52562:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52544:47;;52602:20;52655:7;52645;:17;52641:173;;;52697:4;;:27;;-1:-1:-1;;;52697:27:0;;-1:-1:-1;;;;;5125:32:1;;;52697:27:0;;;5107:51:1;5174:18;;;5167:34;;;52697:4:0;;;;:13;;5080:18:1;;52697:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52679:45;;52641:173;;;52775:4;;:27;;-1:-1:-1;;;52775:27:0;;-1:-1:-1;;;;;5125:32:1;;;52775:27:0;;;5107:51:1;5174:18;;;5167:34;;;52775:4:0;;;;:13;;5080:18:1;;52775:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52757:45;;52641:173;52832:15;52824:61;;;;-1:-1:-1;;;52824:61:0;;10561:2:1;52824:61:0;;;10543:21:1;10600:2;10580:18;;;10573:30;10639:34;10619:18;;;10612:62;-1:-1:-1;;;10690:18:1;;;10683:31;10731:19;;52824:61:0;10359:397:1;52824:61:0;52533:360;;52468:425;;:::o;54538:726::-;54634:8;;-1:-1:-1;;;;;54634:8:0;54626:31;;;;:61;;-1:-1:-1;54661:22:0;;-1:-1:-1;;;54661:22:0;;;;:26;;54626:61;54622:635;;;54723:8;;:27;;-1:-1:-1;;;54723:27:0;;-1:-1:-1;;;;;4200:32:1;;;54723:27:0;;;4182:51:1;54704:16:0;;54723:8;;:20;;4155:18:1;;54723:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54805:22;;54704:46;;-1:-1:-1;54765:24:0;;54792:47;;54833:5;;54792:36;;:8;;-1:-1:-1;;;54805:22:0;;;;54792:12;:36::i;:47::-;54765:74;-1:-1:-1;;;;;;54860:22:0;;;;;;:46;;;54905:1;54886:16;:20;54860:46;54856:390;;;42859:14;54916:40;54939:16;54916:4;;;;;;;;;-1:-1:-1;;;;;54916:4:0;-1:-1:-1;;;;;54916:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:40;:59;54913:237;;54983:4;;:37;;-1:-1:-1;;;54983:37:0;;-1:-1:-1;;;;;5125:32:1;;;54983:37:0;;;5107:51:1;5174:18;;;5167:34;;;54983:4:0;;;;:9;;5080:18:1;;54983:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54913:237;;;55034:4;;:18;;;-1:-1:-1;;;55034:18:0;;;;42859:14;;-1:-1:-1;;;;;55034:4:0;;:16;;:18;;;;;;;;;;;;;;:4;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;55031:119;;;55079:4;;55124:18;;;-1:-1:-1;;;55124:18:0;;;;-1:-1:-1;;;;;55079:4:0;;;;:9;;55097:4;;55104:39;;55079:4;;55124:16;;:18;;;;;;;;;;;;;;;55079:4;55124:18;;;;;;;;;;55104:39;55079:65;;-1:-1:-1;;;;;;55079:65:0;;;;;;;-1:-1:-1;;;;;5125:32:1;;;55079:65:0;;;5107:51:1;5174:18;;;5167:34;5080:18;;55079:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55031:119;55203:8;-1:-1:-1;;;;;55173:57:0;55196:5;-1:-1:-1;;;;;55173:57:0;;55213:16;55173:57;;;;14114:25:1;;14102:2;14087:18;;13968:177;55173:57:0;;;;;;;;54689:568;;54538:726;;:::o;37054:211::-;37198:58;;-1:-1:-1;;;;;5125:32:1;;37198:58:0;;;5107:51:1;5174:18;;;5167:34;;;37171:86:0;;37191:5;;-1:-1:-1;;;37221:23:0;5080:18:1;;37198:58:0;;;;-1:-1:-1;;37198:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;37198:58:0;-1:-1:-1;;;;;;37198:58:0;;;;;;;;;;37171:19;:86::i;:::-;37054:211;;;:::o;28088:173::-;28144:16;28163:6;;-1:-1:-1;;;;;28180:17:0;;;-1:-1:-1;;;;;;28180:17:0;;;;;;28213:40;;28163:6;;;;;;;28213:40;;28144:16;28213:40;28133:128;28088:173;:::o;37273:248::-;37444:68;;-1:-1:-1;;;;;4811:15:1;;;37444:68:0;;;4793:34:1;4863:15;;4843:18;;;4836:43;4895:18;;;4888:34;;;37417:96:0;;37437:5;;-1:-1:-1;;;37467:27:0;4728:18:1;;37444:68:0;4553:375:1;39627:716:0;40051:23;40077:69;40105:4;40077:69;;;;;;;;;;;;;;;;;40085:5;-1:-1:-1;;;;;40077:27:0;;;:69;;;;;:::i;:::-;40161:17;;40051:95;;-1:-1:-1;40161:21:0;40157:179;;40258:10;40247:30;;;;;;;;;;;;:::i;:::-;40239:85;;;;-1:-1:-1;;;40239:85:0;;13206:2:1;40239:85:0;;;13188:21:1;13245:2;13225:18;;;13218:30;13284:34;13264:18;;;13257:62;-1:-1:-1;;;13335:18:1;;;13328:40;13385:19;;40239:85:0;13004:406:1;31840:229:0;31977:12;32009:52;32031:6;32039:4;32045:1;32048:12;32009:21;:52::i;:::-;32002:59;;31840:229;;;;;;:::o;32960:510::-;33130:12;33188:5;33163:21;:30;;33155:81;;;;-1:-1:-1;;;33155:81:0;;8776:2:1;33155:81:0;;;8758:21:1;8815:2;8795:18;;;8788:30;8854:34;8834:18;;;8827:62;-1:-1:-1;;;8905:18:1;;;8898:36;8951:19;;33155:81:0;8574:402:1;33155:81:0;29357:20;;33247:60;;;;-1:-1:-1;;;33247:60:0;;12147:2:1;33247:60:0;;;12129:21:1;12186:2;12166:18;;;12159:30;12225:31;12205:18;;;12198:59;12274:18;;33247:60:0;11945:353:1;33247:60:0;33321:12;33335:23;33362:6;-1:-1:-1;;;;;33362:11:0;33381:5;33388:4;33362:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33320:73;;;;33411:51;33428:7;33437:10;33449:12;33411:16;:51::i;:::-;33404:58;32960:510;-1:-1:-1;;;;;;;32960:510:0:o;35646:712::-;35796:12;35825:7;35821:530;;;-1:-1:-1;35856:10:0;35849:17;;35821:530;35970:17;;:21;35966:374;;36168:10;36162:17;36229:15;36216:10;36212:2;36208:19;36201:44;35966:374;36311:12;36304:20;;-1:-1:-1;;;36304:20:0;;;;;;;;:::i;14:159:1:-;81:20;;141:6;130:18;;120:29;;110:57;;163:1;160;153:12;110:57;14:159;;;:::o;178:247::-;237:6;290:2;278:9;269:7;265:23;261:32;258:52;;;306:1;303;296:12;258:52;345:9;332:23;364:31;389:5;364:31;:::i;430:251::-;500:6;553:2;541:9;532:7;528:23;524:32;521:52;;;569:1;566;559:12;521:52;601:9;595:16;620:31;645:5;620:31;:::i;686:277::-;753:6;806:2;794:9;785:7;781:23;777:32;774:52;;;822:1;819;812:12;774:52;854:9;848:16;907:5;900:13;893:21;886:5;883:32;873:60;;929:1;926;919:12;1503:184;1561:6;1614:2;1602:9;1593:7;1589:23;1585:32;1582:52;;;1630:1;1627;1620:12;1582:52;1653:28;1671:9;1653:28;:::i;1692:180::-;1751:6;1804:2;1792:9;1783:7;1779:23;1775:32;1772:52;;;1820:1;1817;1810:12;1772:52;-1:-1:-1;1843:23:1;;1692:180;-1:-1:-1;1692:180:1:o;1877:184::-;1947:6;2000:2;1988:9;1979:7;1975:23;1971:32;1968:52;;;2016:1;2013;2006:12;1968:52;-1:-1:-1;2039:16:1;;1877:184;-1:-1:-1;1877:184:1:o;2066:315::-;2134:6;2142;2195:2;2183:9;2174:7;2170:23;2166:32;2163:52;;;2211:1;2208;2201:12;2163:52;2247:9;2234:23;2224:33;;2307:2;2296:9;2292:18;2279:32;2320:31;2345:5;2320:31;:::i;:::-;2370:5;2360:15;;;2066:315;;;;;:::o;2386:400::-;2475:6;2483;2491;2544:2;2532:9;2523:7;2519:23;2515:32;2512:52;;;2560:1;2557;2550:12;2512:52;2596:9;2583:23;2573:33;;2656:2;2645:9;2641:18;2628:32;2669:31;2694:5;2669:31;:::i;:::-;2719:5;-1:-1:-1;2743:37:1;2776:2;2761:18;;2743:37;:::i;:::-;2733:47;;2386:400;;;;;:::o;2791:248::-;2859:6;2867;2920:2;2908:9;2899:7;2895:23;2891:32;2888:52;;;2936:1;2933;2926:12;2888:52;-1:-1:-1;;2959:23:1;;;3029:2;3014:18;;;3001:32;;-1:-1:-1;2791:248:1:o;3044:383::-;3121:6;3129;3137;3190:2;3178:9;3169:7;3165:23;3161:32;3158:52;;;3206:1;3203;3196:12;3158:52;3242:9;3229:23;3219:33;;3299:2;3288:9;3284:18;3271:32;3261:42;;3353:2;3342:9;3338:18;3325:32;3366:31;3391:5;3366:31;:::i;:::-;3416:5;3406:15;;;3044:383;;;;;:::o;3432:320::-;3508:6;3516;3524;3577:2;3565:9;3556:7;3552:23;3548:32;3545:52;;;3593:1;3590;3583:12;3545:52;3629:9;3616:23;3606:33;;3686:2;3675:9;3671:18;3658:32;3648:42;;3709:37;3742:2;3731:9;3727:18;3709:37;:::i;3757:274::-;3886:3;3924:6;3918:13;3940:53;3986:6;3981:3;3974:4;3966:6;3962:17;3940:53;:::i;:::-;4009:16;;;;;3757:274;-1:-1:-1;;3757:274:1:o;6892:383::-;7041:2;7030:9;7023:21;7004:4;7073:6;7067:13;7116:6;7111:2;7100:9;7096:18;7089:34;7132:66;7191:6;7186:2;7175:9;7171:18;7166:2;7158:6;7154:15;7132:66;:::i;:::-;7259:2;7238:15;-1:-1:-1;;7234:29:1;7219:45;;;;7266:2;7215:54;;6892:383;-1:-1:-1;;6892:383:1:o;11167:356::-;11369:2;11351:21;;;11388:18;;;11381:30;11447:34;11442:2;11427:18;;11420:62;11514:2;11499:18;;11167:356::o;13415:355::-;13617:2;13599:21;;;13656:2;13636:18;;;13629:30;13695:33;13690:2;13675:18;;13668:61;13761:2;13746:18;;13415:355::o;14403:128::-;14443:3;14474:1;14470:6;14467:1;14464:13;14461:39;;;14480:18;;:::i;:::-;-1:-1:-1;14516:9:1;;14403:128::o;14536:217::-;14576:1;14602;14592:132;;14646:10;14641:3;14637:20;14634:1;14627:31;14681:4;14678:1;14671:15;14709:4;14706:1;14699:15;14592:132;-1:-1:-1;14738:9:1;;14536:217::o;14758:168::-;14798:7;14864:1;14860;14856:6;14852:14;14849:1;14846:21;14841:1;14834:9;14827:17;14823:45;14820:71;;;14871:18;;:::i;:::-;-1:-1:-1;14911:9:1;;14758:168::o;14931:125::-;14971:4;14999:1;14996;14993:8;14990:34;;;15004:18;;:::i;:::-;-1:-1:-1;15041:9:1;;14931:125::o;15061:258::-;15133:1;15143:113;15157:6;15154:1;15151:13;15143:113;;;15233:11;;;15227:18;15214:11;;;15207:39;15179:2;15172:10;15143:113;;;15274:6;15271:1;15268:13;15265:48;;;-1:-1:-1;;15309:1:1;15291:16;;15284:27;15061:258::o;15324:135::-;15363:3;-1:-1:-1;;15384:17:1;;15381:43;;;15404:18;;:::i;:::-;-1:-1:-1;15451:1:1;15440:13;;15324:135::o;15464:127::-;15525:10;15520:3;15516:20;15513:1;15506:31;15556:4;15553:1;15546:15;15580:4;15577:1;15570:15;15596:127;15657:10;15652:3;15648:20;15645:1;15638:31;15688:4;15685:1;15678:15;15712:4;15709:1;15702:15;15728:131;-1:-1:-1;;;;;15803:31:1;;15793:42;;15783:70;;15849:1;15846;15839:12

ipfs://926a0de4d93c981d4808723b37cd417c4c9f0c18bdf83222913596fd19bf787d