Contract 0xedfb330f5fa216c9d2039b99c8ce9da85ea91c1e 2

/**
 *Submitted for verification at moonbeam.moonscan.io on 2022-01-19
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/[email protected]



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/token/ERC20/utils/[email protected]



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


// File @openzeppelin/contracts/utils/[email protected]



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


// File @openzeppelin/contracts/access/[email protected]



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/security/[email protected]



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/[email protected]



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 contracts/utils/IStellaERC20.sol


pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IStellaERC20 is IERC20 {
    function mint(address to, uint256 amount) external;
}


// File contracts/farms/StellaDistributor.sol


pragma solidity ^0.8.0;






contract StellaDistributor is Ownable, ReentrancyGuard {
    // remember to change for mainnet deploy
    address constant _trustedForwarder =
        0x24eE59Fe03Cbc71e71bb05F6E66ffd49D6800363; //TRUSTED FORWARDER

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 rewardLockedUp; // Reward locked up.
        uint256 nextHarvestUntil; // When can the user harvest again.
    }

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

    IStellaERC20 public stella;

    // The operator can only update EmissionRate and AllocPoint to protect tokenomics
    //i.e some wrong setting and a pools get too much allocation accidentally
    address private _operator;


    // Stella tokens created per block
    uint256 public stellaPerBlock;

    // Max harvest interval: 90 days
    uint256 public constant MAXIMUM_HARVEST_INTERVAL = 90 days;

    // Maximum deposit fee rate: 10%
    uint16 public constant MAXIMUM_DEPOSIT_FEE_RATE = 1000;

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

    // Total locked up rewards
    uint256 public totalLockedUpRewards;

    // Total Stella in Stella Pools (can be multiple pools)
    uint256 public totalStellaInPools = 0;

    // Control support for EIP-2771 Meta Transactions
    bool public metaTxnsEnabled = false;

    // Team address.
    address public teamAddress;

    // Treasury address.
    address public treasuryAddress;

    // Investor address.
    address public investorAddress;

    // Percentage of pool rewards that goto the team.
    uint256 public teamPercent;

    // Percentage of pool rewards that goes to the treasury.
    uint256 public treasuryPercent;

    // Percentage of pool rewards that goes to the investor.
    uint256 public investorPercent;

    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 EmissionRateUpdated(
        address indexed caller,
        uint256 previousAmount,
        uint256 newAmount
    );
    event RewardLockedUp(
        address indexed user,
        uint256 indexed pid,
        uint256 amountLockedUp
    );
    event OperatorTransferred(
        address indexed previousOperator,
        address indexed newOperator
    );
    
    event AllocPointsUpdated(
        address indexed caller,
        uint256 previousAmount,
        uint256 newAmount
    );
    event MetaTxnsEnabled(address indexed caller);
    event MetaTxnsDisabled(address indexed caller);

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

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

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

    event SetTeamPercent(uint256 oldPercent, uint256 newPercent);

    event SetTreasuryPercent(uint256 oldPercent, uint256 newPercent);

    event SetInvestorPercent(uint256 oldPercent, uint256 newPercent);

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

    constructor(
        IStellaERC20 _stella,
        uint256 _stellaPerBlock,
        address _teamAddress,
        address _treasuryAddress,
        address _investorAddress,
        uint256 _teamPercent,
        uint256 _treasuryPercent,
        uint256 _investorPercent
        ) {

        require(
            0 <= _teamPercent && _teamPercent <= 1000,
            "constructor: invalid team percent value"
        );
        require(
            0 <= _treasuryPercent && _treasuryPercent <= 1000,
            "constructor: invalid treasury percent value"
        );
        require(
            0 <= _investorPercent && _investorPercent <= 1000,
            "constructor: invalid investor percent value"
        );
        require(
            _teamPercent + _treasuryPercent + _investorPercent <= 1000,
            "constructor: total percent over max"
        );

        //StartBlock always many years later from contract construct, will be set later in StartFarming function
        startBlock = block.number + (10 * 365 * 24 * 60 * 60);

        stella = _stella;
        stellaPerBlock = _stellaPerBlock;

        teamAddress = _teamAddress;
        treasuryAddress = _treasuryAddress;
        investorAddress = _investorAddress;

        teamPercent = _teamPercent;
        treasuryPercent = _treasuryPercent;
        investorPercent = _investorPercent;

        _operator = msg.sender;
        emit OperatorTransferred(address(0), _operator);
    }

    function isTrustedForwarder(address forwarder)
        public
        view
        virtual
        returns (bool)
    {
        return metaTxnsEnabled && forwarder == _trustedForwarder;
    }

    function _msgSender()
        internal
        view
        virtual
        override
        returns (address sender)
    {
        if (isTrustedForwarder(msg.sender)) {
            // The assembly code is more direct than the Solidity version using `abi.decode`.
            assembly {
                sender := shr(96, calldataload(sub(calldatasize(), 20)))
            }
        } else {
            return super._msgSender();
        }
    }

    function _msgData()
        internal
        view
        virtual
        override
        returns (bytes calldata)
    {
        if (isTrustedForwarder(msg.sender)) {
            return msg.data[:msg.data.length - 20];
        } else {
            return super._msgData();
        }
    }

    function operator() public view returns (address) {
        return _operator;
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to)
        public
        pure
        returns (uint256)
    {
        return _to.sub(_from);
    }

    function transferOperator(address newOperator) public onlyOperator {
        require(
            newOperator != address(0),
            "TransferOperator: new operator is the zero address"
        );
        emit OperatorTransferred(_operator, newOperator);
        _operator = newOperator;
    }

    // Set farming start, can call only once
    function startFarming() public onlyOwner {
        require(block.number < startBlock, "Error::Farm started already");

        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            PoolInfo storage pool = poolInfo[pid];
            pool.lastRewardBlock = block.number;
        }

        startBlock = block.number;
    }

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

    // Add a new lp to the pool. Can only be called by the owner.
    // Can add multiple pool with same lp token without messing up rewards, because each pool's balance is tracked using its own totalLp
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        uint16 _depositFeeBP,
        uint256 _harvestInterval,
        bool _withUpdate
    ) public onlyOwner {
        require(
            _depositFeeBP <= MAXIMUM_DEPOSIT_FEE_RATE,
            "add: deposit fee too high"
        );
        require(
            _harvestInterval <= MAXIMUM_HARVEST_INTERVAL,
            "add: invalid harvest interval"
        );
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardBlock = block.number > startBlock
            ? block.number
            : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardBlock: lastRewardBlock,
                accStellaPerShare: 0,
                depositFeeBP: _depositFeeBP,
                harvestInterval: _harvestInterval,
                totalLp: 0
            })
        );
    }

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

    // View function to see pending Stella on frontend.
    function pendingStella(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accStellaPerShare = pool.accStellaPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));

        if (block.number > pool.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(
                pool.lastRewardBlock,
                block.number
            );
            uint256 stellaReward = multiplier
                .mul(stellaPerBlock)
                .mul(pool.allocPoint)
                .div(totalAllocPoint);
            accStellaPerShare = accStellaPerShare.add(
                stellaReward.mul(1e12).div(lpSupply)
            );
        }

        uint256 pending = user.amount.mul(accStellaPerShare).div(1e12).sub(
            user.rewardDebt
        );
        return pending.add(user.rewardLockedUp);
    }

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

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

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }

        uint256 lpSupply = pool.totalLp;
        if (lpSupply == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }

        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 stellaReward = multiplier
            .mul(stellaPerBlock)
            .mul(pool.allocPoint)
            .div(totalAllocPoint);

        uint256 lpPercent = 1000 -
        teamPercent -
        treasuryPercent -
        investorPercent;

        stella.mint(teamAddress, (stellaReward * teamPercent) / 1000);
        stella.mint(treasuryAddress, (stellaReward * treasuryPercent) / 1000);
        stella.mint(investorAddress, (stellaReward * investorPercent) / 1000);
        stella.mint(address(this), (stellaReward * lpPercent) / 1000);

        pool.accStellaPerShare =
            pool.accStellaPerShare +
            (((stellaReward * 1e12) / pool.totalLp) * lpPercent) /
            1000;
        
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for Stella allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {
        require(
            block.number >= startBlock,
            "StellaDistributor: Can not deposit before start"
        );

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        updatePool(_pid);

        payOrLockupPendingStella(_pid);

        if (_amount > 0) {
            uint256 beforeDeposit = pool.lpToken.balanceOf(address(this));
            pool.lpToken.safeTransferFrom(_msgSender(), address(this), _amount);
            uint256 afterDeposit = pool.lpToken.balanceOf(address(this));

            _amount = afterDeposit.sub(beforeDeposit);

            if (pool.depositFeeBP > 0) {
                uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000);
                pool.lpToken.safeTransfer(treasuryAddress, depositFee);

                _amount = _amount.sub(depositFee);
            }

            user.amount = user.amount.add(_amount);
            pool.totalLp = pool.totalLp.add(_amount);

            if (address(pool.lpToken) == address(stella)) {
                totalStellaInPools = totalStellaInPools.add(_amount);
            }

        }
        user.rewardDebt = user.amount.mul(pool.accStellaPerShare).div(1e12);
        emit Deposit(_msgSender(), _pid, _amount);
    }

    // Withdraw tokens
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

        //this will make sure that user can only withdraw from his pool
        require(user.amount >= _amount, "Withdraw: User amount not enough");

        //Cannot withdraw more than pool's balance
        require(pool.totalLp >= _amount, "Withdraw: Pool total not enough");


        updatePool(_pid);

        payOrLockupPendingStella(_pid);

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalLp = pool.totalLp.sub(_amount);
            if (address(pool.lpToken) == address(stella)) {
                totalStellaInPools = totalStellaInPools.sub(_amount);
            }
            pool.lpToken.safeTransfer(_msgSender(), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accStellaPerShare).div(1e12);
        emit Withdraw(_msgSender(), _pid, _amount);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];
        uint256 amount = user.amount;

        //Cannot withdraw more than pool's balance
        require(
            pool.totalLp >= amount,
            "EmergencyWithdraw: Pool total not enough"
        );

        user.amount = 0;
        user.rewardDebt = 0;
        user.rewardLockedUp = 0;
        user.nextHarvestUntil = 0;
        pool.totalLp = pool.totalLp.sub(amount);

        if (address(pool.lpToken) == address(stella)) {
            totalStellaInPools = totalStellaInPools.sub(amount);
        }
        pool.lpToken.safeTransfer(_msgSender(), amount);

        emit EmergencyWithdraw(_msgSender(), _pid, amount);
    }

    // Pay or lockup pending Stella.
    function payOrLockupPendingStella(uint256 _pid) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_msgSender()];

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

        uint256 pending = user.amount.mul(pool.accStellaPerShare).div(1e12).sub(
            user.rewardDebt
        );
        if (canHarvest(_pid, _msgSender())) {
            if (pending > 0 || user.rewardLockedUp > 0) {
                uint256 totalRewards = pending.add(user.rewardLockedUp);

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

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

    // Safe Stella transfer function, just in case if rounding error causes pool do not have enough Stella.
    function safeStellaTransfer(address _to, uint256 _amount) internal {
        if (stella.balanceOf(address(this)) > totalStellaInPools) {
            //StellaBal = total Stella in StellaDistributor - total Stella in Stella pools, this will make sure that StellaDistributor never transfer rewards from deposited Stella pools
            uint256 StellaBal = stella.balanceOf(address(this)).sub(
                totalStellaInPools
            );
            if (_amount >= StellaBal) {
                stella.transfer(_to, StellaBal);
            } else if (_amount > 0) {
                stella.transfer(_to, _amount);
            }
        }
    }


    // Pancake has to add hidden dummy pools in order to alter the emission, here we make it simple and transparent to all.
    function updateEmissionRate(uint256 _stellaPerBlock) public onlyOperator {
        massUpdatePools();

        emit EmissionRateUpdated(msg.sender, stellaPerBlock, _stellaPerBlock);
        stellaPerBlock = _stellaPerBlock;
    }

    function updateAllocPoint(
        uint256 _pid,
        uint256 _allocPoint,
        bool _withUpdate
    ) public onlyOperator {
        if (_withUpdate) {
            massUpdatePools();
        }

        emit AllocPointsUpdated(
            _msgSender(),
            poolInfo[_pid].allocPoint,
            _allocPoint
        );

        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(
            _allocPoint
        );
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Enable support for meta transactions
    function enableMetaTxns() public onlyOperator {
        require(!metaTxnsEnabled, "Meta transactions are already enabled");

        metaTxnsEnabled = true;
        emit MetaTxnsEnabled(_msgSender());
    }

    // Disable support for meta transactions
    function disableMetaTxns() public onlyOperator {
        require(metaTxnsEnabled, "Meta transactions are already disabled");

        metaTxnsEnabled = false;
        emit MetaTxnsDisabled(_msgSender());
    }

    // Function to harvest many pools in a single transaction
    function harvestMany(uint256[] calldata _pids) public {
        for (uint256 index = 0; index < _pids.length; ++index) {
            deposit(_pids[index], 0);
        }
    }

    // Update team address by the previous team address.
    function setTeamAddress(address _teamAddress) public {
        require(
            msg.sender == teamAddress,
            "set team address: only previous team address can call this method"
        );
        teamAddress = _teamAddress;
        emit SetTeamAddress(msg.sender, _teamAddress);
    }

    function setTeamPercent(uint256 _newTeamPercent) public onlyOwner {
        require(
            0 <= _newTeamPercent && _newTeamPercent <= 1000,
            "set team percent: invalid percent value"
        );
        require(
            treasuryPercent + _newTeamPercent + investorPercent <= 1000,
            "set team percent: total percent over max"
        );
        emit SetTeamPercent(teamPercent, _newTeamPercent);
        teamPercent = _newTeamPercent;
    }

    // Update treasury address by the previous treasury.
    function setTreasuryAddr(address _treasuryAddress) public {
        require(msg.sender == treasuryAddress, "set treasury address: wut?");
        treasuryAddress = _treasuryAddress;
        emit SetTreasuryAddress(msg.sender, _treasuryAddress);
    }

    function setTreasuryPercent(uint256 _newTreasuryPercent) public onlyOwner {
        require(
            0 <= _newTreasuryPercent && _newTreasuryPercent <= 1000,
            "set treasury percent: invalid percent value"
        );
        require(
            teamPercent + _newTreasuryPercent + investorPercent <= 1000,
            "set treasury percent: total percent over max"
        );
        emit SetTeamPercent(treasuryPercent, _newTreasuryPercent);
        treasuryPercent = _newTreasuryPercent;
    }

    // Update the investor address by the previous investor.
    function setInvestorAddress(address _investorAddress) public {
        require(
            msg.sender == investorAddress,
            "set investor address: only previous investor can call this method"
        );
        investorAddress = _investorAddress;
        emit SetInvestorAddress(msg.sender, _investorAddress);
    }

    function setInvestorPercent(uint256 _newInvestorPercent) public onlyOwner {
        require(
            0 <= _newInvestorPercent && _newInvestorPercent <= 1000,
            "set investor percent: invalid percent value"
        );
        require(
            teamPercent + _newInvestorPercent + treasuryPercent <= 1000,
            "set investor percent: total percent over max"
        );
        emit SetTeamPercent(investorPercent, _newInvestorPercent);
        investorPercent = _newInvestorPercent;
    }
}

[{"inputs":[{"internalType":"contract IStellaERC20","name":"_stella","type":"address"},{"internalType":"uint256","name":"_stellaPerBlock","type":"uint256"},{"internalType":"address","name":"_teamAddress","type":"address"},{"internalType":"address","name":"_treasuryAddress","type":"address"},{"internalType":"address","name":"_investorAddress","type":"address"},{"internalType":"uint256","name":"_teamPercent","type":"uint256"},{"internalType":"uint256","name":"_treasuryPercent","type":"uint256"},{"internalType":"uint256","name":"_investorPercent","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"AllocPointsUpdated","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":"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":"caller","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newAmount","type":"uint256"}],"name":"EmissionRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"}],"name":"MetaTxnsDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"}],"name":"MetaTxnsEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOperator","type":"address"},{"indexed":true,"internalType":"address","name":"newOperator","type":"address"}],"name":"OperatorTransferred","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":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLockedUp","type":"uint256"}],"name":"RewardLockedUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetInvestorAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPercent","type":"uint256"}],"name":"SetInvestorPercent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetTeamAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPercent","type":"uint256"}],"name":"SetTeamPercent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetTreasuryAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPercent","type":"uint256"}],"name":"SetTreasuryPercent","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_DEPOSIT_FEE_RATE","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_HARVEST_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"canHarvest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"disableMetaTxns","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enableMetaTxns","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pids","type":"uint256[]"}],"name":"harvestMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"investorAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"investorPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"metaTxnsEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"pendingStella","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accStellaPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"harvestInterval","type":"uint256"},{"internalType":"uint256","name":"totalLp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"},{"internalType":"uint256","name":"_harvestInterval","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_investorAddress","type":"address"}],"name":"setInvestorAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newInvestorPercent","type":"uint256"}],"name":"setInvestorPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_teamAddress","type":"address"}],"name":"setTeamAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTeamPercent","type":"uint256"}],"name":"setTeamPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasuryAddress","type":"address"}],"name":"setTreasuryAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newTreasuryPercent","type":"uint256"}],"name":"setTreasuryPercent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startFarming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stella","outputs":[{"internalType":"contract IStellaERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stellaPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedUpRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStellaInPools","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOperator","type":"address"}],"name":"transferOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"treasuryPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"updateAllocPoint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_stellaPerBlock","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":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"rewardLockedUp","type":"uint256"},{"internalType":"uint256","name":"nextHarvestUntil","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000e358838ce72d5e61e0018a2ffac4bec5f4c88d200000000000000000000000000000000000000000000000003782dace9d900000000000000000000000000008401b6068e61fc252e1a9959ab764ef5da0ca541000000000000000000000000ce86f05a3568fc973c51c3cf76850df456391f14000000000000000000000000d3252671f1eaa4dcd28eb12d64cdd762511ea32c000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000000640000000000000000000000000000000000000000000000000000000000000064

-----Decoded View---------------
Arg [0] : _stella (address): 0x0e358838ce72d5e61e0018a2ffac4bec5f4c88d2
Arg [1] : _stellaPerBlock (uint256): 250000000000000000
Arg [2] : _teamAddress (address): 0x8401b6068e61fc252e1a9959ab764ef5da0ca541
Arg [3] : _treasuryAddress (address): 0xce86f05a3568fc973c51c3cf76850df456391f14
Arg [4] : _investorAddress (address): 0xd3252671f1eaa4dcd28eb12d64cdd762511ea32c
Arg [5] : _teamPercent (uint256): 100
Arg [6] : _treasuryPercent (uint256): 100
Arg [7] : _investorPercent (uint256): 100

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000e358838ce72d5e61e0018a2ffac4bec5f4c88d2
Arg [1] : 00000000000000000000000000000000000000000000000003782dace9d90000
Arg [2] : 0000000000000000000000008401b6068e61fc252e1a9959ab764ef5da0ca541
Arg [3] : 000000000000000000000000ce86f05a3568fc973c51c3cf76850df456391f14
Arg [4] : 000000000000000000000000d3252671f1eaa4dcd28eb12d64cdd762511ea32c
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000064
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000064
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000064

27978:23303:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30721:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30822;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36052:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48174:214;;;:::i;:::-;;47094:234;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30530:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29726:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;29971:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30404:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37547:803;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35311:304;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39513:286;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50416:333;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42858:1038;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30132:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30066:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40138:1231;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43967:832;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34989:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34006:198;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47909:211;;;:::i;:::-;;29179:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39882:180;;;:::i;:::-;;48703:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17347:94;;;:::i;:::-;;29637:54;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50757:521;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49825;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;16696:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35150:153;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29810:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;49016:481;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49563:254;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30338:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36360:1073;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35669:375;;;:::i;:::-;;47336:520;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30465:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30237:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48459:178;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29532:58;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30624:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41440:1386;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17596:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29456:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38415:1033;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30721:30;;;;:::o;30822:::-;;;;:::o;36052:95::-;36097:7;36124:8;:15;;;;36117:22;;36052:95;:::o;48174:214::-;32392:10;32379:23;;:9;;;;;;;;;;;:23;;;32357:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;48240:15:::1;;;;;;;;;;;48232:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;48329:5;48311:15;;:23;;;;;;;;;;;;;;;;;;48367:12;:10;:12::i;:::-;48350:30;;;;;;;;;;;;48174:214::o:0;47094:234::-;32392:10;32379:23;;:9;;;;;;;;;;;:23;;;32357:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;47178:17:::1;:15;:17::i;:::-;47233:10;47213:64;;;47245:14;;47261:15;47213:64;;;;;;;:::i;:::-;;;;;;;;47305:15;47288:14;:32;;;;47094:234:::0;:::o;30530:30::-;;;;;;;;;;;;;:::o;29726:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;29971:34::-;;;;:::o;30404:26::-;;;;;;;;;;;;;:::o;37547:803::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29687:4:::1;37763:41;;:13;:41;;;;37741:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;29583:7;37890:16;:44;;37868:123;;;;;;;;;;;;:::i;:::-;;;;;;;;;38006:11;38002:61;;;38034:17;:15;:17::i;:::-;38002:61;38091:87;38156:11;38091:46;38111:8;38120:4;38111:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;38091:15;;:19;;:46;;;;:::i;:::-;:50;;:87;;;;:::i;:::-;38073:15;:105;;;;38217:11;38189:8;38198:4;38189:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;:39;;;;38269:13;38239:8;38248:4;38239:14;;;;;;;;;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;38326:16;38293:8;38302:4;38293:14;;;;;;;;;;;;;;;;;;;;;;;;;;:30;;:49;;;;37547:803:::0;;;;;:::o;35311:304::-;32392:10;32379:23;;:9;;;;;;;;;;;:23;;;32357:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;35434:1:::1;35411:25;;:11;:25;;;;35389:125;;;;;;;;;;;;:::i;:::-;;;;;;;;;35561:11;35530:43;;35550:9;;;;;;;;;;;35530:43;;;;;;;;;;;;35596:11;35584:9;;:23;;;;;;;;;;;;;;;;;;35311:304:::0;:::o;39513:286::-;39610:4;39632:21;39656:8;:14;39665:4;39656:14;;;;;;;;;;;:21;39671:5;39656:21;;;;;;;;;;;;;;;39632:45;;39724:10;;39708:12;:26;;:83;;;;;39770:4;:21;;;39751:15;:40;;39708:83;39688:103;;;39513:286;;;;:::o;50416:333::-;50524:15;;;;;;;;;;;50510:29;;:10;:29;;;50488:144;;;;;;;;;;;;:::i;:::-;;;;;;;;;50661:16;50643:15;;:34;;;;;;;;;;;;;;;;;;50724:16;50693:48;;50712:10;50693:48;;;;;;;;;;;;50416:333;:::o;42858:1038::-;19731:1;20327:7;;:19;;20319:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19731:1;20460:7;:18;;;;42938:21:::1;42962:8;42971:4;42962:14;;;;;;;;;;;;;;;;;;;;;;;;;;42938:38;;42987:21;43011:8;:14;43020:4;43011:14;;;;;;;;;;;:28;43026:12;:10;:12::i;:::-;43011:28;;;;;;;;;;;;;;;42987:52;;43148:7;43133:4;:11;;;:22;;43125:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43281:7;43265:4;:12;;;:23;;43257:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43339:16;43350:4;43339:10;:16::i;:::-;43368:30;43393:4;43368:24;:30::i;:::-;43425:1;43415:7;:11;43411:347;;;43457:24;43473:7;43457:4;:11;;;:15;;:24;;;;:::i;:::-;43443:4;:11;;:38;;;;43511:25;43528:7;43511:4;:12;;;:16;;:25;;;;:::i;:::-;43496:4;:12;;:40;;;;43588:6;;;;;;;;;;;43555:40;;43563:4;:12;;;;;;;;;;;;43555:40;;;43551:133;;;43637:31;43660:7;43637:18;;:22;;:31;;;;:::i;:::-;43616:18;:52;;;;43551:133;43698:48;43724:12;:10;:12::i;:::-;43738:7;43698:4;:12;;;;;;;;;;;;:25;;;;:48;;;;;:::i;:::-;43411:347;43786:49;43830:4;43786:39;43802:4;:22;;;43786:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;43768:4;:15;;:67;;;;43874:4;43860:12;:10;:12::i;:::-;43851:37;;;43880:7;43851:37;;;;;;:::i;:::-;;;;;;;;20491:1;;19687::::0;20639:7;:22;;;;42858:1038;;:::o;30132:35::-;;;;:::o;30066:25::-;;;;:::o;40138:1231::-;40190:21;40214:8;40223:4;40214:14;;;;;;;;;;;;;;;;;;;;;;;;;;40190:38;;40259:4;:20;;;40243:12;:36;40239:75;;40296:7;;;40239:75;40326:16;40345:4;:12;;;40326:31;;40384:1;40372:8;:13;:37;;;;40408:1;40389:4;:15;;;:20;40372:37;40368:126;;;40449:12;40426:4;:20;;:35;;;;40476:7;;;;40368:126;40506:18;40527:49;40541:4;:20;;;40563:12;40527:13;:49::i;:::-;40506:70;;40587:20;40610:114;40708:15;;40610:79;40673:4;:15;;;40610:44;40639:14;;40610:10;:28;;:44;;;;:::i;:::-;:62;;:79;;;;:::i;:::-;:97;;:114;;;;:::i;:::-;40587:137;;40737:17;40823:15;;40796;;40773:11;;40757:4;:27;;;;:::i;:::-;:54;;;;:::i;:::-;:81;;;;:::i;:::-;40737:101;;40851:6;;;;;;;;;;;:11;;;40863;;;;;;;;;;;40907:4;40892:11;;40877:12;:26;;;;:::i;:::-;40876:35;;;;:::i;:::-;40851:61;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40923:6;;;;;;;;;;;:11;;;40935:15;;;;;;;;;;;40987:4;40968:15;;40953:12;:30;;;;:::i;:::-;40952:39;;;;:::i;:::-;40923:69;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41003:6;;;;;;;;;;;:11;;;41015:15;;;;;;;;;;;41067:4;41048:15;;41033:12;:30;;;;:::i;:::-;41032:39;;;;:::i;:::-;41003:69;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41083:6;;;;;;;;;;;:11;;;41103:4;41139;41126:9;41111:12;:24;;;;:::i;:::-;41110:33;;;;:::i;:::-;41083:61;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41301:4;41275:9;41259:4;:12;;;41251:4;41236:12;:19;;;;:::i;:::-;41235:36;;;;:::i;:::-;41234:50;;;;:::i;:::-;41233:72;;;;:::i;:::-;41195:4;:22;;;:110;;;;:::i;:::-;41157:4;:22;;:148;;;;41349:12;41326:4;:20;;:35;;;;40138:1231;;;;;;;:::o;43967:832::-;19731:1;20327:7;;:19;;20319:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19731:1;20460:7;:18;;;;44039:21:::1;44063:8;44072:4;44063:14;;;;;;;;;;;;;;;;;;;;;;;;;;44039:38;;44088:21;44112:8;:14;44121:4;44112:14;;;;;;;;;;;:28;44127:12;:10;:12::i;:::-;44112:28;;;;;;;;;;;;;;;44088:52;;44151:14;44168:4;:11;;;44151:28;;44282:6;44266:4;:12;;;:22;;44244:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;44383:1;44369:4;:11;;:15;;;;44413:1;44395:4;:15;;:19;;;;44447:1;44425:4;:19;;:23;;;;44483:1;44459:4;:21;;:25;;;;44510:24;44527:6;44510:4;:12;;;:16;;:24;;;;:::i;:::-;44495:4;:12;;:39;;;;44584:6;;;;;;;;;;;44551:40;;44559:4;:12;;;;;;;;;;;;44551:40;;;44547:124;;;44629:30;44652:6;44629:18;;:22;;:30;;;;:::i;:::-;44608:18;:51;;;;44547:124;44681:47;44707:12;:10;:12::i;:::-;44721:6;44681:4;:12;;;;;;;;;;;;:25;;;;:47;;;;;:::i;:::-;44778:4;44764:12;:10;:12::i;:::-;44746:45;;;44784:6;44746:45;;;;;;:::i;:::-;;;;;;;;20491:1;;;19687::::0;20639:7;:22;;;;43967:832;:::o;34989:85::-;35030:7;35057:9;;;;;;;;;;;35050:16;;34989:85;:::o;34006:198::-;34118:4;34147:15;;;;;;;;;;;:49;;;;;28132:42;34166:30;;:9;:30;;;34147:49;34140:56;;34006:198;;;:::o;47909:211::-;32392:10;32379:23;;:9;;;;;;;;;;;:23;;;32357:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;47975:15:::1;;;;;;;;;;;47974:16;47966:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;48063:4;48045:15;;:22;;;;;;;;;;;;;;;;;;48099:12;:10;:12::i;:::-;48083:29;;;;;;;;;;;;47909:211::o:0;29179:26::-;;;;;;;;;;;;;:::o;39882:180::-;39927:14;39944:8;:15;;;;39927:32;;39975:11;39970:85;39998:6;39992:3;:12;39970:85;;;40028:15;40039:3;40028:10;:15::i;:::-;40006:5;;;;:::i;:::-;;;39970:85;;;;39882:180;:::o;48703:305::-;48803:11;;;;;;;;;;;48789:25;;:10;:25;;;48767:140;;;;;;;;;;;;:::i;:::-;;;;;;;;;48932:12;48918:11;;:26;;;;;;;;;;;;;;;;;;48987:12;48960:40;;48975:10;48960:40;;;;;;;;;;;;48703:305;:::o;17347:94::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;17412:21:::1;17430:1;17412:9;:21::i;:::-;17347:94::o:0;29637:54::-;29687:4;29637:54;:::o;50757:521::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;50869:19:::1;50864:1;:24;;:55;;;;;50915:4;50892:19;:27;;50864:55;50842:148;;;;;;;;;;;;:::i;:::-;;;;;;;;;51078:4;51059:15;;51037:19;51023:11;;:33;;;;:::i;:::-;:51;;;;:::i;:::-;:59;;51001:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;51170:52;51185:15;;51202:19;51170:52;;;;;;;:::i;:::-;;;;;;;;51251:19;51233:15;:37;;;;50757:521:::0;:::o;49825:::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49937:19:::1;49932:1;:24;;:55;;;;;49983:4;49960:19;:27;;49932:55;49910:148;;;;;;;;;;;;:::i;:::-;;;;;;;;;50146:4;50127:15;;50105:19;50091:11;;:33;;;;:::i;:::-;:51;;;;:::i;:::-;:59;;50069:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;50238:52;50253:15;;50270:19;50238:52;;;;;;;:::i;:::-;;;;;;;;50319:19;50301:15;:37;;;;49825:521:::0;:::o;16696:87::-;16742:7;16769:6;;;;;;;;;;;16762:13;;16696:87;:::o;35150:153::-;35249:7;35281:14;35289:5;35281:3;:7;;:14;;;;:::i;:::-;35274:21;;35150:153;;;;:::o;29810:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49016:481::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49120:15:::1;49115:1;:20;;:47;;;;;49158:4;49139:15;:23;;49115:47;49093:136;;;;;;;;;;;;:::i;:::-;;;;;;;;;49317:4;49298:15;;49280;49262;;:33;;;;:::i;:::-;:51;;;;:::i;:::-;:59;;49240:149;;;;;;;;;;;;:::i;:::-;;;;;;;;;49405:44;49420:11;;49433:15;49405:44;;;;;;;:::i;:::-;;;;;;;;49474:15;49460:11;:29;;;;49016:481:::0;:::o;49563:254::-;49654:15;;;;;;;;;;;49640:29;;:10;:29;;;49632:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49729:16;49711:15;;:34;;;;;;;;;;;;;;;;;;49792:16;49761:48;;49780:10;49761:48;;;;;;;;;;;;49563:254;:::o;30338:35::-;;;;;;;;;;;;;:::o;36360:1073::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29687:4:::1;36579:41;;:13;:41;;;;36557:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;29583:7;36706:16;:44;;36684:123;;;;;;;;;;;;:::i;:::-;;;;;;;;;36822:11;36818:61;;;36850:17;:15;:17::i;:::-;36818:61;36889:23;36930:10;;36915:12;:25;:79;;36984:10;;36915:79;;;36956:12;36915:79;36889:105;;37023:32;37043:11;37023:15;;:19;;:32;;;;:::i;:::-;37005:15;:50;;;;37066:8;37094:320;;;;;;;;37131:8;37094:320;;;;;;37170:11;37094:320;;;;37217:15;37094:320;;;;37270:1;37094:320;;;;37304:13;37094:320;;;;;;37353:16;37094:320;;;;37397:1;37094:320;;::::0;37066:359:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16987:1;36360:1073:::0;;;;;:::o;35669:375::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;35744:10:::1;;35729:12;:25;35721:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;35799:14;35816:8;:15;;;;35799:32;;35847:11;35842:157;35870:6;35864:3;:12;35842:157;;;35900:21;35924:8;35933:3;35924:13;;;;;;;;;;;;;;;;;;;;;;;;;;35900:37;;35975:12;35952:4;:20;;:35;;;;35842:157;35878:5;;;;:::i;:::-;;;35842:157;;;;36024:12;36011:10;:25;;;;16987:1;35669:375::o:0;47336:520::-;32392:10;32379:23;;:9;;;;;;;;;;;:23;;;32357:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;47484:11:::1;47480:61;;;47512:17;:15;:17::i;:::-;47480:61;47591:12;:10;:12::i;:::-;47558:122;;;47618:8;47627:4;47618:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;47658:11;47558:122;;;;;;;:::i;:::-;;;;;;;;47711:87;47776:11;47711:46;47731:8;47740:4;47731:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;47711:15;;:19;;:46;;;;:::i;:::-;:50;;:87;;;;:::i;:::-;47693:15;:105;;;;47837:11;47809:8;47818:4;47809:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;:39;;;;47336:520:::0;;;:::o;30465:30::-;;;;;;;;;;;;;:::o;30237:37::-;;;;:::o;48459:178::-;48529:13;48524:106;48556:5;;:12;;48548:5;:20;48524:106;;;48594:24;48602:5;;48608;48602:12;;;;;;;;;;;;;;;;;;;;;48616:1;48594:7;:24::i;:::-;48570:7;;;;:::i;:::-;;;48524:106;;;;48459:178;;:::o;29532:58::-;29583:7;29532:58;:::o;30624:26::-;;;;:::o;41440:1386::-;19731:1;20327:7;;:19;;20319:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19731:1;20460:7;:18;;;;41557:10:::1;;41541:12;:26;;41519:123;;;;;;;;;;;;:::i;:::-;;;;;;;;;41655:21;41679:8;41688:4;41679:14;;;;;;;;;;;;;;;;;;;;;;;;;;41655:38;;41704:21;41728:8;:14;41737:4;41728:14;;;;;;;;;;;:28;41743:12;:10;:12::i;:::-;41728:28;;;;;;;;;;;;;;;41704:52;;41769:16;41780:4;41769:10;:16::i;:::-;41798:30;41823:4;41798:24;:30::i;:::-;41855:1;41845:7;:11;41841:848;;;41873:21;41897:4;:12;;;;;;;;;;;;:22;;;41928:4;41897:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41873:61;;41949:67;41979:12;:10;:12::i;:::-;42001:4;42008:7;41949:4;:12;;;;;;;;;;;;:29;;;;:67;;;;;;:::i;:::-;42031:20;42054:4;:12;;;;;;;;;;;;:22;;;42085:4;42054:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42031:60;;42118:31;42135:13;42118:12;:16;;:31;;;;:::i;:::-;42108:41;;42190:1;42170:4;:17;;;;;;;;;;;;:21;;;42166:251;;;42212:18;42233:41;42268:5;42233:30;42245:4;:17;;;;;;;;;;;;42233:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;42212:62;;42293:54;42319:15;;;;;;;;;;;42336:10;42293:4;:12;;;;;;;;;;;;:25;;;;:54;;;;;:::i;:::-;42378:23;42390:10;42378:7;:11;;:23;;;;:::i;:::-;42368:33;;42166:251;;42447:24;42463:7;42447:4;:11;;;:15;;:24;;;;:::i;:::-;42433:4;:11;;:38;;;;42501:25;42518:7;42501:4;:12;;;:16;;:25;;;;:::i;:::-;42486:4;:12;;:40;;;;42580:6;;;;;;;;;;;42547:40;;42555:4;:12;;;;;;;;;;;;42547:40;;;42543:133;;;42629:31;42652:7;42629:18;;:22;;:31;;;;:::i;:::-;42608:18;:52;;;;42543:133;41841:848;;;42717:49;42761:4;42717:39;42733:4;:22;;;42717:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;42699:4;:15;;:67;;;;42804:4;42790:12;:10;:12::i;:::-;42782:36;;;42810:7;42782:36;;;;;;:::i;:::-;;;;;;;;20491:1;;19687::::0;20639:7;:22;;;;41440:1386;;:::o;17596:192::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;17705:1:::1;17685:22;;:8;:22;;;;17677:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;17761:19;17771:8;17761:9;:19::i;:::-;17596:192:::0;:::o;29456:29::-;;;;:::o;38415:1033::-;38517:7;38542:21;38566:8;38575:4;38566:14;;;;;;;;;;;;;;;;;;;;;;;;;;38542:38;;38591:21;38615:8;:14;38624:4;38615:14;;;;;;;;;;;:21;38630:5;38615:21;;;;;;;;;;;;;;;38591:45;;38647:25;38675:4;:22;;;38647:50;;38708:16;38727:4;:12;;;;;;;;;;;;:22;;;38758:4;38727:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38708:56;;38796:4;:20;;;38781:12;:35;:52;;;;;38832:1;38820:8;:13;;38781:52;38777:494;;;38850:18;38871:98;38903:4;:20;;;38942:12;38871:13;:98::i;:::-;38850:119;;38984:20;39007:126;39117:15;;39007:87;39078:4;:15;;;39007:48;39040:14;;39007:10;:32;;:48;;;;:::i;:::-;:70;;:87;;;;:::i;:::-;:109;;:126;;;;:::i;:::-;38984:149;;39168:91;39208:36;39235:8;39208:22;39225:4;39208:12;:16;;:22;;;;:::i;:::-;:26;;:36;;;;:::i;:::-;39168:17;:21;;:91;;;;:::i;:::-;39148:111;;38777:494;;;39283:15;39301:89;39364:4;:15;;;39301:44;39340:4;39301:34;39317:17;39301:4;:11;;;:15;;:34;;;;:::i;:::-;:38;;:44;;;;:::i;:::-;:48;;:89;;;;:::i;:::-;39283:107;;39408:32;39420:4;:19;;;39408:7;:11;;:32;;;;:::i;:::-;39401:39;;;;;;;38415:1033;;;;:::o;15478:98::-;15531:7;15558:10;15551:17;;15478:98;:::o;34212:460::-;34319:14;34355:30;34374:10;34355:18;:30::i;:::-;34351:314;;;34576:2;34560:14;34556:23;34543:37;34539:2;34535:46;34525:56;;34506:90;;;34635:18;:16;:18::i;:::-;34628:25;;;;34351:314;34212:460;;:::o;23857:98::-;23915:7;23946:1;23942;:5;;;;:::i;:::-;23935:12;;23857:98;;;;:::o;23476:::-;23534:7;23565:1;23561;:5;;;;:::i;:::-;23554:12;;23476:98;;;;:::o;44845:1340::-;44913:21;44937:8;44946:4;44937:14;;;;;;;;;;;;;;;;;;;;;;;;;;44913:38;;44962:21;44986:8;:14;44995:4;44986:14;;;;;;;;;;;:28;45001:12;:10;:12::i;:::-;44986:28;;;;;;;;;;;;;;;44962:52;;45056:1;45031:4;:21;;;:26;:56;;;;;45077:10;;45061:12;:26;;45031:56;45027:154;;;45128:41;45148:4;:20;;;45128:15;:19;;:41;;;;:::i;:::-;45104:4;:21;;:65;;;;45027:154;45193:15;45211:94;45279:4;:15;;;45211:49;45255:4;45211:39;45227:4;:22;;;45211:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:94;;;;:::i;:::-;45193:112;;45320:30;45331:4;45337:12;:10;:12::i;:::-;45320:10;:30::i;:::-;45316:862;;;45381:1;45371:7;:11;:38;;;;45408:1;45386:4;:19;;;:23;45371:38;45367:562;;;45430:20;45453:32;45465:4;:19;;;45453:7;:11;;:32;;;;:::i;:::-;45430:55;;45562:85;45609:4;:19;;;45562:20;;:24;;:85;;;;:::i;:::-;45539:20;:108;;;;45688:1;45666:4;:19;;:23;;;;45732:81;45774:4;:20;;;45732:15;:19;;:81;;;;:::i;:::-;45708:4;:21;;:105;;;;45867:46;45886:12;:10;:12::i;:::-;45900;45867:18;:46::i;:::-;45367:562;;45316:862;;;45960:1;45950:7;:11;45946:232;;;46000:32;46024:7;46000:4;:19;;;:23;;:32;;;;:::i;:::-;45978:4;:19;;:54;;;;46070:33;46095:7;46070:20;;:24;;:33;;;;:::i;:::-;46047:20;:56;;;;46152:4;46138:12;:10;:12::i;:::-;46123:43;;;46158:7;46123:43;;;;;;:::i;:::-;;;;;;;;45946:232;45316:862;44845:1340;;;;:::o;11549:211::-;11666:86;11686:5;11716:23;;;11741:2;11745:5;11693:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11666:19;:86::i;:::-;11549:211;;;:::o;24214:98::-;24272:7;24303:1;24299;:5;;;;:::i;:::-;24292:12;;24214:98;;;;:::o;24613:::-;24671:7;24702:1;24698;:5;;;;:::i;:::-;24691:12;;24613:98;;;;:::o;17796:173::-;17852:16;17871:6;;;;;;;;;;;17852:25;;17897:8;17888:6;;:17;;;;;;;;;;;;;;;;;;17952:8;17921:40;;17942:8;17921:40;;;;;;;;;;;;17796:173;;:::o;11768:248::-;11912:96;11932:5;11962:27;;;11991:4;11997:2;12001:5;11939:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11912:19;:96::i;:::-;11768:248;;;;:::o;46302:657::-;46418:18;;46384:6;;;;;;;;;;;:16;;;46409:4;46384:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;46380:572;;;46640:17;46660:87;46714:18;;46660:6;;;;;;;;;;;:16;;;46685:4;46660:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;;:87;;;;:::i;:::-;46640:107;;46777:9;46766:7;:20;46762:179;;46807:6;;;;;;;;;;;:15;;;46823:3;46828:9;46807:31;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46762:179;;;46874:1;46864:7;:11;46860:81;;;46896:6;;;;;;;;;;;:15;;;46912:3;46917:7;46896:29;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46860:81;46762:179;46380:572;;46302:657;;:::o;14122:716::-;14546:23;14572:69;14600:4;14572:69;;;;;;;;;;;;;;;;;14580:5;14572:27;;;;:69;;;;;:::i;:::-;14546:95;;14676:1;14656:10;:17;:21;14652:179;;;14753:10;14742:30;;;;;;;;;;;;:::i;:::-;14734:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;14652:179;14122:716;;;:::o;6389:229::-;6526:12;6558:52;6580:6;6588:4;6594:1;6597:12;6558:21;:52::i;:::-;6551:59;;6389:229;;;;;:::o;7509:510::-;7679:12;7737:5;7712:21;:30;;7704:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;7804:18;7815:6;7804:10;:18::i;:::-;7796:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;7870:12;7884:23;7911:6;:11;;7930:5;7937:4;7911:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7869:73;;;;7960:51;7977:7;7986:10;7998:12;7960:16;:51::i;:::-;7953:58;;;;7509:510;;;;;;:::o;3583:387::-;3643:4;3851:12;3918:7;3906:20;3898:28;;3961:1;3954:4;:8;3947:15;;;3583:387;;;:::o;10195:712::-;10345:12;10374:7;10370:530;;;10405:10;10398:17;;;;10370:530;10539:1;10519:10;:17;:21;10515:374;;;10717:10;10711:17;10778:15;10765:10;10761:2;10757:19;10750:44;10665:148;10860:12;10853:20;;;;;;;;;;;:::i;:::-;;;;;;;;10195:712;;;;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;169:367::-;;;302:3;295:4;287:6;283:17;279:27;269:2;;320:1;317;310:12;269:2;356:6;343:20;333:30;;386:18;378:6;375:30;372:2;;;418:1;415;408:12;372:2;455:4;447:6;443:17;431:29;;509:3;501:4;493:6;489:17;479:8;475:32;472:41;469:2;;;526:1;523;516:12;469:2;259:277;;;;;:::o;542:133::-;;623:6;610:20;601:29;;639:30;663:5;639:30;:::i;:::-;591:84;;;;:::o;681:137::-;;766:6;760:13;751:22;;782:30;806:5;782:30;:::i;:::-;741:77;;;;:::o;824:165::-;;921:6;908:20;899:29;;937:46;977:5;937:46;:::i;:::-;889:100;;;;:::o;995:137::-;;1078:6;1065:20;1056:29;;1094:32;1120:5;1094:32;:::i;:::-;1046:86;;;;:::o;1138:139::-;;1222:6;1209:20;1200:29;;1238:33;1265:5;1238:33;:::i;:::-;1190:87;;;;:::o;1283:143::-;;1371:6;1365:13;1356:22;;1387:33;1414:5;1387:33;:::i;:::-;1346:80;;;;:::o;1432:262::-;;1540:2;1528:9;1519:7;1515:23;1511:32;1508:2;;;1556:1;1553;1546:12;1508:2;1599:1;1624:53;1669:7;1660:6;1649:9;1645:22;1624:53;:::i;:::-;1614:63;;1570:117;1498:196;;;;:::o;1700:425::-;;;1843:2;1831:9;1822:7;1818:23;1814:32;1811:2;;;1859:1;1856;1849:12;1811:2;1930:1;1919:9;1915:17;1902:31;1960:18;1952:6;1949:30;1946:2;;;1992:1;1989;1982:12;1946:2;2028:80;2100:7;2091:6;2080:9;2076:22;2028:80;:::i;:::-;2010:98;;;;1873:245;1801:324;;;;;:::o;2131:278::-;;2247:2;2235:9;2226:7;2222:23;2218:32;2215:2;;;2263:1;2260;2253:12;2215:2;2306:1;2331:61;2384:7;2375:6;2364:9;2360:22;2331:61;:::i;:::-;2321:71;;2277:125;2205:204;;;;:::o;2415:262::-;;2523:2;2511:9;2502:7;2498:23;2494:32;2491:2;;;2539:1;2536;2529:12;2491:2;2582:1;2607:53;2652:7;2643:6;2632:9;2628:22;2607:53;:::i;:::-;2597:63;;2553:117;2481:196;;;;:::o;2683:284::-;;2802:2;2790:9;2781:7;2777:23;2773:32;2770:2;;;2818:1;2815;2808:12;2770:2;2861:1;2886:64;2942:7;2933:6;2922:9;2918:22;2886:64;:::i;:::-;2876:74;;2832:128;2760:207;;;;:::o;2973:407::-;;;3098:2;3086:9;3077:7;3073:23;3069:32;3066:2;;;3114:1;3111;3104:12;3066:2;3157:1;3182:53;3227:7;3218:6;3207:9;3203:22;3182:53;:::i;:::-;3172:63;;3128:117;3284:2;3310:53;3355:7;3346:6;3335:9;3331:22;3310:53;:::i;:::-;3300:63;;3255:118;3056:324;;;;;:::o;3386:862::-;;;;;;3571:3;3559:9;3550:7;3546:23;3542:33;3539:2;;;3588:1;3585;3578:12;3539:2;3631:1;3656:53;3701:7;3692:6;3681:9;3677:22;3656:53;:::i;:::-;3646:63;;3602:117;3758:2;3784:66;3842:7;3833:6;3822:9;3818:22;3784:66;:::i;:::-;3774:76;;3729:131;3899:2;3925:52;3969:7;3960:6;3949:9;3945:22;3925:52;:::i;:::-;3915:62;;3870:117;4026:2;4052:53;4097:7;4088:6;4077:9;4073:22;4052:53;:::i;:::-;4042:63;;3997:118;4154:3;4181:50;4223:7;4214:6;4203:9;4199:22;4181:50;:::i;:::-;4171:60;;4125:116;3529:719;;;;;;;;:::o;4254:407::-;;;4379:2;4367:9;4358:7;4354:23;4350:32;4347:2;;;4395:1;4392;4385:12;4347:2;4438:1;4463:53;4508:7;4499:6;4488:9;4484:22;4463:53;:::i;:::-;4453:63;;4409:117;4565:2;4591:53;4636:7;4627:6;4616:9;4612:22;4591:53;:::i;:::-;4581:63;;4536:118;4337:324;;;;;:::o;4667:546::-;;;;4806:2;4794:9;4785:7;4781:23;4777:32;4774:2;;;4822:1;4819;4812:12;4774:2;4865:1;4890:53;4935:7;4926:6;4915:9;4911:22;4890:53;:::i;:::-;4880:63;;4836:117;4992:2;5018:53;5063:7;5054:6;5043:9;5039:22;5018:53;:::i;:::-;5008:63;;4963:118;5120:2;5146:50;5188:7;5179:6;5168:9;5164:22;5146:50;:::i;:::-;5136:60;;5091:115;4764:449;;;;;:::o;5219:836::-;;;;;;5391:3;5379:9;5370:7;5366:23;5362:33;5359:2;;;5408:1;5405;5398:12;5359:2;5451:1;5476:53;5521:7;5512:6;5501:9;5497:22;5476:53;:::i;:::-;5466:63;;5422:117;5578:2;5604:53;5649:7;5640:6;5629:9;5625:22;5604:53;:::i;:::-;5594:63;;5549:118;5706:2;5732:52;5776:7;5767:6;5756:9;5752:22;5732:52;:::i;:::-;5722:62;;5677:117;5833:2;5859:53;5904:7;5895:6;5884:9;5880:22;5859:53;:::i;:::-;5849:63;;5804:118;5961:3;5988:50;6030:7;6021:6;6010:9;6006:22;5988:50;:::i;:::-;5978:60;;5932:116;5349:706;;;;;;;;:::o;6061:118::-;6148:24;6166:5;6148:24;:::i;:::-;6143:3;6136:37;6126:53;;:::o;6185:109::-;6266:21;6281:5;6266:21;:::i;:::-;6261:3;6254:34;6244:50;;:::o;6300:373::-;;6432:38;6464:5;6432:38;:::i;:::-;6486:88;6567:6;6562:3;6486:88;:::i;:::-;6479:95;;6583:52;6628:6;6623:3;6616:4;6609:5;6605:16;6583:52;:::i;:::-;6660:6;6655:3;6651:16;6644:23;;6408:265;;;;;:::o;6679:157::-;6779:50;6823:5;6779:50;:::i;:::-;6774:3;6767:63;6757:79;;:::o;6842:173::-;6950:58;7002:5;6950:58;:::i;:::-;6945:3;6938:71;6928:87;;:::o;7021:364::-;;7137:39;7170:5;7137:39;:::i;:::-;7192:71;7256:6;7251:3;7192:71;:::i;:::-;7185:78;;7272:52;7317:6;7312:3;7305:4;7298:5;7294:16;7272:52;:::i;:::-;7349:29;7371:6;7349:29;:::i;:::-;7344:3;7340:39;7333:46;;7113:272;;;;;:::o;7391:323::-;;7554:67;7618:2;7613:3;7554:67;:::i;:::-;7547:74;;7651:27;7647:1;7642:3;7638:11;7631:48;7705:2;7700:3;7696:12;7689:19;;7537:177;;;:::o;7720:379::-;;7883:67;7947:2;7942:3;7883:67;:::i;:::-;7876:74;;7980:34;7976:1;7971:3;7967:11;7960:55;8046:17;8041:2;8036:3;8032:12;8025:39;8090:2;8085:3;8081:12;8074:19;;7866:233;;;:::o;8105:330::-;;8268:67;8332:2;8327:3;8268:67;:::i;:::-;8261:74;;8365:34;8361:1;8356:3;8352:11;8345:55;8426:2;8421:3;8417:12;8410:19;;8251:184;;;:::o;8441:370::-;;8604:67;8668:2;8663:3;8604:67;:::i;:::-;8597:74;;8701:34;8697:1;8692:3;8688:11;8681:55;8767:8;8762:2;8757:3;8753:12;8746:30;8802:2;8797:3;8793:12;8786:19;;8587:224;;;:::o;8817:325::-;;8980:67;9044:2;9039:3;8980:67;:::i;:::-;8973:74;;9077:29;9073:1;9068:3;9064:11;9057:50;9133:2;9128:3;9124:12;9117:19;;8963:179;;;:::o;9148:329::-;;9311:67;9375:2;9370:3;9311:67;:::i;:::-;9304:74;;9408:33;9404:1;9399:3;9395:11;9388:54;9468:2;9463:3;9459:12;9452:19;;9294:183;;;:::o;9483:370::-;;9646:67;9710:2;9705:3;9646:67;:::i;:::-;9639:74;;9743:34;9739:1;9734:3;9730:11;9723:55;9809:8;9804:2;9799:3;9795:12;9788:30;9844:2;9839:3;9835:12;9828:19;;9629:224;;;:::o;9859:327::-;;10022:67;10086:2;10081:3;10022:67;:::i;:::-;10015:74;;10119:31;10115:1;10110:3;10106:11;10099:52;10177:2;10172:3;10168:12;10161:19;;10005:181;;;:::o;10192:370::-;;10355:67;10419:2;10414:3;10355:67;:::i;:::-;10348:74;;10452:34;10448:1;10443:3;10439:11;10432:55;10518:8;10513:2;10508:3;10504:12;10497:30;10553:2;10548:3;10544:12;10537:19;;10338:224;;;:::o;10568:376::-;;10731:67;10795:2;10790:3;10731:67;:::i;:::-;10724:74;;10828:34;10824:1;10819:3;10815:11;10808:55;10894:14;10889:2;10884:3;10880:12;10873:36;10935:2;10930:3;10926:12;10919:19;;10714:230;;;:::o;10950:431::-;;11113:67;11177:2;11172:3;11113:67;:::i;:::-;11106:74;;11210:34;11206:1;11201:3;11197:11;11190:55;11276:34;11271:2;11266:3;11262:12;11255:56;11342:3;11337:2;11332:3;11328:12;11321:25;11372:2;11367:3;11363:12;11356:19;;11096:285;;;:::o;11387:375::-;;11550:67;11614:2;11609:3;11550:67;:::i;:::-;11543:74;;11647:34;11643:1;11638:3;11634:11;11627:55;11713:13;11708:2;11703:3;11699:12;11692:35;11753:2;11748:3;11744:12;11737:19;;11533:229;;;:::o;11768:431::-;;11931:67;11995:2;11990:3;11931:67;:::i;:::-;11924:74;;12028:34;12024:1;12019:3;12015:11;12008:55;12094:34;12089:2;12084:3;12080:12;12073:56;12160:3;12155:2;12150:3;12146:12;12139:25;12190:2;12185:3;12181:12;12174:19;;11914:285;;;:::o;12205:371::-;;12368:67;12432:2;12427:3;12368:67;:::i;:::-;12361:74;;12465:34;12461:1;12456:3;12452:11;12445:55;12531:9;12526:2;12521:3;12517:12;12510:31;12567:2;12562:3;12558:12;12551:19;;12351:225;;;:::o;12582:330::-;;12745:67;12809:2;12804:3;12745:67;:::i;:::-;12738:74;;12842:34;12838:1;12833:3;12829:11;12822:55;12903:2;12898:3;12894:12;12887:19;;12728:184;;;:::o;12918:369::-;;13081:67;13145:2;13140:3;13081:67;:::i;:::-;13074:74;;13178:34;13174:1;13169:3;13165:11;13158:55;13244:7;13239:2;13234:3;13230:12;13223:29;13278:2;13273:3;13269:12;13262:19;;13064:223;;;:::o;13293:327::-;;13456:67;13520:2;13515:3;13456:67;:::i;:::-;13449:74;;13553:31;13549:1;13544:3;13540:11;13533:52;13611:2;13606:3;13602:12;13595:19;;13439:181;;;:::o;13626:372::-;;13789:67;13853:2;13848:3;13789:67;:::i;:::-;13782:74;;13886:34;13882:1;13877:3;13873:11;13866:55;13952:10;13947:2;13942:3;13938:12;13931:32;13989:2;13984:3;13980:12;13973:19;;13772:226;;;:::o;14004:324::-;;14167:67;14231:2;14226:3;14167:67;:::i;:::-;14160:74;;14264:28;14260:1;14255:3;14251:11;14244:49;14319:2;14314:3;14310:12;14303:19;;14150:178;;;:::o;14334:372::-;;14497:67;14561:2;14556:3;14497:67;:::i;:::-;14490:74;;14594:34;14590:1;14585:3;14581:11;14574:55;14660:10;14655:2;14650:3;14646:12;14639:32;14697:2;14692:3;14688:12;14681:19;;14480:226;;;:::o;14712:327::-;;14875:67;14939:2;14934:3;14875:67;:::i;:::-;14868:74;;14972:31;14968:1;14963:3;14959:11;14952:52;15030:2;15025:3;15021:12;15014:19;;14858:181;;;:::o;15045:382::-;;15208:67;15272:2;15267:3;15208:67;:::i;:::-;15201:74;;15305:34;15301:1;15296:3;15292:11;15285:55;15371:20;15366:2;15361:3;15357:12;15350:42;15418:2;15413:3;15409:12;15402:19;;15191:236;;;:::o;15433:374::-;;15596:67;15660:2;15655:3;15596:67;:::i;:::-;15589:74;;15693:34;15689:1;15684:3;15680:11;15673:55;15759:12;15754:2;15749:3;15745:12;15738:34;15798:2;15793:3;15789:12;15782:19;;15579:228;;;:::o;15813:323::-;;15976:67;16040:2;16035:3;15976:67;:::i;:::-;15969:74;;16073:27;16069:1;16064:3;16060:11;16053:48;16127:2;16122:3;16118:12;16111:19;;15959:177;;;:::o;16142:329::-;;16305:67;16369:2;16364:3;16305:67;:::i;:::-;16298:74;;16402:33;16398:1;16393:3;16389:11;16382:54;16462:2;16457:3;16453:12;16446:19;;16288:183;;;:::o;16477:375::-;;16640:67;16704:2;16699:3;16640:67;:::i;:::-;16633:74;;16737:34;16733:1;16728:3;16724:11;16717:55;16803:13;16798:2;16793:3;16789:12;16782:35;16843:2;16838:3;16834:12;16827:19;;16623:229;;;:::o;16858:376::-;;17021:67;17085:2;17080:3;17021:67;:::i;:::-;17014:74;;17118:34;17114:1;17109:3;17105:11;17098:55;17184:14;17179:2;17174:3;17170:12;17163:36;17225:2;17220:3;17216:12;17209:19;;17004:230;;;:::o;17240:368::-;;17403:67;17467:2;17462:3;17403:67;:::i;:::-;17396:74;;17500:34;17496:1;17491:3;17487:11;17480:55;17566:6;17561:2;17556:3;17552:12;17545:28;17599:2;17594:3;17590:12;17583:19;;17386:222;;;:::o;17614:115::-;17699:23;17716:5;17699:23;:::i;:::-;17694:3;17687:36;17677:52;;:::o;17735:118::-;17822:24;17840:5;17822:24;:::i;:::-;17817:3;17810:37;17800:53;;:::o;17859:271::-;;18011:93;18100:3;18091:6;18011:93;:::i;:::-;18004:100;;18121:3;18114:10;;17993:137;;;;:::o;18136:222::-;;18267:2;18256:9;18252:18;18244:26;;18280:71;18348:1;18337:9;18333:17;18324:6;18280:71;:::i;:::-;18234:124;;;;:::o;18364:442::-;;18551:2;18540:9;18536:18;18528:26;;18564:71;18632:1;18621:9;18617:17;18608:6;18564:71;:::i;:::-;18645:72;18713:2;18702:9;18698:18;18689:6;18645:72;:::i;:::-;18727;18795:2;18784:9;18780:18;18771:6;18727:72;:::i;:::-;18518:288;;;;;;:::o;18812:332::-;;18971:2;18960:9;18956:18;18948:26;;18984:71;19052:1;19041:9;19037:17;19028:6;18984:71;:::i;:::-;19065:72;19133:2;19122:9;19118:18;19109:6;19065:72;:::i;:::-;18938:206;;;;;:::o;19150:210::-;;19275:2;19264:9;19260:18;19252:26;;19288:65;19350:1;19339:9;19335:17;19326:6;19288:65;:::i;:::-;19242:118;;;;:::o;19366:908::-;;19676:3;19665:9;19661:19;19653:27;;19690:84;19771:1;19760:9;19756:17;19747:6;19690:84;:::i;:::-;19784:72;19852:2;19841:9;19837:18;19828:6;19784:72;:::i;:::-;19866;19934:2;19923:9;19919:18;19910:6;19866:72;:::i;:::-;19948;20016:2;20005:9;20001:18;19992:6;19948:72;:::i;:::-;20030:71;20096:3;20085:9;20081:19;20072:6;20030:71;:::i;:::-;20111:73;20179:3;20168:9;20164:19;20155:6;20111:73;:::i;:::-;20194;20262:3;20251:9;20247:19;20238:6;20194:73;:::i;:::-;19643:631;;;;;;;;;;:::o;20280:264::-;;20432:2;20421:9;20417:18;20409:26;;20445:92;20534:1;20523:9;20519:17;20510:6;20445:92;:::i;:::-;20399:145;;;;:::o;20550:313::-;;20701:2;20690:9;20686:18;20678:26;;20750:9;20744:4;20740:20;20736:1;20725:9;20721:17;20714:47;20778:78;20851:4;20842:6;20778:78;:::i;:::-;20770:86;;20668:195;;;;:::o;20869:419::-;;21073:2;21062:9;21058:18;21050:26;;21122:9;21116:4;21112:20;21108:1;21097:9;21093:17;21086:47;21150:131;21276:4;21150:131;:::i;:::-;21142:139;;21040:248;;;:::o;21294:419::-;;21498:2;21487:9;21483:18;21475:26;;21547:9;21541:4;21537:20;21533:1;21522:9;21518:17;21511:47;21575:131;21701:4;21575:131;:::i;:::-;21567:139;;21465:248;;;:::o;21719:419::-;;21923:2;21912:9;21908:18;21900:26;;21972:9;21966:4;21962:20;21958:1;21947:9;21943:17;21936:47;22000:131;22126:4;22000:131;:::i;:::-;21992:139;;21890:248;;;:::o;22144:419::-;;22348:2;22337:9;22333:18;22325:26;;22397:9;22391:4;22387:20;22383:1;22372:9;22368:17;22361:47;22425:131;22551:4;22425:131;:::i;:::-;22417:139;;22315:248;;;:::o;22569:419::-;;22773:2;22762:9;22758:18;22750:26;;22822:9;22816:4;22812:20;22808:1;22797:9;22793:17;22786:47;22850:131;22976:4;22850:131;:::i;:::-;22842:139;;22740:248;;;:::o;22994:419::-;;23198:2;23187:9;23183:18;23175:26;;23247:9;23241:4;23237:20;23233:1;23222:9;23218:17;23211:47;23275:131;23401:4;23275:131;:::i;:::-;23267:139;;23165:248;;;:::o;23419:419::-;;23623:2;23612:9;23608:18;23600:26;;23672:9;23666:4;23662:20;23658:1;23647:9;23643:17;23636:47;23700:131;23826:4;23700:131;:::i;:::-;23692:139;;23590:248;;;:::o;23844:419::-;;24048:2;24037:9;24033:18;24025:26;;24097:9;24091:4;24087:20;24083:1;24072:9;24068:17;24061:47;24125:131;24251:4;24125:131;:::i;:::-;24117:139;;24015:248;;;:::o;24269:419::-;;24473:2;24462:9;24458:18;24450:26;;24522:9;24516:4;24512:20;24508:1;24497:9;24493:17;24486:47;24550:131;24676:4;24550:131;:::i;:::-;24542:139;;24440:248;;;:::o;24694:419::-;;24898:2;24887:9;24883:18;24875:26;;24947:9;24941:4;24937:20;24933:1;24922:9;24918:17;24911:47;24975:131;25101:4;24975:131;:::i;:::-;24967:139;;24865:248;;;:::o;25119:419::-;;25323:2;25312:9;25308:18;25300:26;;25372:9;25366:4;25362:20;25358:1;25347:9;25343:17;25336:47;25400:131;25526:4;25400:131;:::i;:::-;25392:139;;25290:248;;;:::o;25544:419::-;;25748:2;25737:9;25733:18;25725:26;;25797:9;25791:4;25787:20;25783:1;25772:9;25768:17;25761:47;25825:131;25951:4;25825:131;:::i;:::-;25817:139;;25715:248;;;:::o;25969:419::-;;26173:2;26162:9;26158:18;26150:26;;26222:9;26216:4;26212:20;26208:1;26197:9;26193:17;26186:47;26250:131;26376:4;26250:131;:::i;:::-;26242:139;;26140:248;;;:::o;26394:419::-;;26598:2;26587:9;26583:18;26575:26;;26647:9;26641:4;26637:20;26633:1;26622:9;26618:17;26611:47;26675:131;26801:4;26675:131;:::i;:::-;26667:139;;26565:248;;;:::o;26819:419::-;;27023:2;27012:9;27008:18;27000:26;;27072:9;27066:4;27062:20;27058:1;27047:9;27043:17;27036:47;27100:131;27226:4;27100:131;:::i;:::-;27092:139;;26990:248;;;:::o;27244:419::-;;27448:2;27437:9;27433:18;27425:26;;27497:9;27491:4;27487:20;27483:1;27472:9;27468:17;27461:47;27525:131;27651:4;27525:131;:::i;:::-;27517:139;;27415:248;;;:::o;27669:419::-;;27873:2;27862:9;27858:18;27850:26;;27922:9;27916:4;27912:20;27908:1;27897:9;27893:17;27886:47;27950:131;28076:4;27950:131;:::i;:::-;27942:139;;27840:248;;;:::o;28094:419::-;;28298:2;28287:9;28283:18;28275:26;;28347:9;28341:4;28337:20;28333:1;28322:9;28318:17;28311:47;28375:131;28501:4;28375:131;:::i;:::-;28367:139;;28265:248;;;:::o;28519:419::-;;28723:2;28712:9;28708:18;28700:26;;28772:9;28766:4;28762:20;28758:1;28747:9;28743:17;28736:47;28800:131;28926:4;28800:131;:::i;:::-;28792:139;;28690:248;;;:::o;28944:419::-;;29148:2;29137:9;29133:18;29125:26;;29197:9;29191:4;29187:20;29183:1;29172:9;29168:17;29161:47;29225:131;29351:4;29225:131;:::i;:::-;29217:139;;29115:248;;;:::o;29369:419::-;;29573:2;29562:9;29558:18;29550:26;;29622:9;29616:4;29612:20;29608:1;29597:9;29593:17;29586:47;29650:131;29776:4;29650:131;:::i;:::-;29642:139;;29540:248;;;:::o;29794:419::-;;29998:2;29987:9;29983:18;29975:26;;30047:9;30041:4;30037:20;30033:1;30022:9;30018:17;30011:47;30075:131;30201:4;30075:131;:::i;:::-;30067:139;;29965:248;;;:::o;30219:419::-;;30423:2;30412:9;30408:18;30400:26;;30472:9;30466:4;30462:20;30458:1;30447:9;30443:17;30436:47;30500:131;30626:4;30500:131;:::i;:::-;30492:139;;30390:248;;;:::o;30644:419::-;;30848:2;30837:9;30833:18;30825:26;;30897:9;30891:4;30887:20;30883:1;30872:9;30868:17;30861:47;30925:131;31051:4;30925:131;:::i;:::-;30917:139;;30815:248;;;:::o;31069:419::-;;31273:2;31262:9;31258:18;31250:26;;31322:9;31316:4;31312:20;31308:1;31297:9;31293:17;31286:47;31350:131;31476:4;31350:131;:::i;:::-;31342:139;;31240:248;;;:::o;31494:419::-;;31698:2;31687:9;31683:18;31675:26;;31747:9;31741:4;31737:20;31733:1;31722:9;31718:17;31711:47;31775:131;31901:4;31775:131;:::i;:::-;31767:139;;31665:248;;;:::o;31919:419::-;;32123:2;32112:9;32108:18;32100:26;;32172:9;32166:4;32162:20;32158:1;32147:9;32143:17;32136:47;32200:131;32326:4;32200:131;:::i;:::-;32192:139;;32090:248;;;:::o;32344:419::-;;32548:2;32537:9;32533:18;32525:26;;32597:9;32591:4;32587:20;32583:1;32572:9;32568:17;32561:47;32625:131;32751:4;32625:131;:::i;:::-;32617:139;;32515:248;;;:::o;32769:218::-;;32898:2;32887:9;32883:18;32875:26;;32911:69;32977:1;32966:9;32962:17;32953:6;32911:69;:::i;:::-;32865:122;;;;:::o;32993:222::-;;33124:2;33113:9;33109:18;33101:26;;33137:71;33205:1;33194:9;33190:17;33181:6;33137:71;:::i;:::-;33091:124;;;;:::o;33221:332::-;;33380:2;33369:9;33365:18;33357:26;;33393:71;33461:1;33450:9;33446:17;33437:6;33393:71;:::i;:::-;33474:72;33542:2;33531:9;33527:18;33518:6;33474:72;:::i;:::-;33347:206;;;;;:::o;33559:553::-;;33774:3;33763:9;33759:19;33751:27;;33788:71;33856:1;33845:9;33841:17;33832:6;33788:71;:::i;:::-;33869:72;33937:2;33926:9;33922:18;33913:6;33869:72;:::i;:::-;33951;34019:2;34008:9;34004:18;33995:6;33951:72;:::i;:::-;34033;34101:2;34090:9;34086:18;34077:6;34033:72;:::i;:::-;33741:371;;;;;;;:::o;34118:98::-;;34203:5;34197:12;34187:22;;34176:40;;;:::o;34222:99::-;;34308:5;34302:12;34292:22;;34281:40;;;:::o;34327:147::-;;34465:3;34450:18;;34440:34;;;;:::o;34480:169::-;;34598:6;34593:3;34586:19;34638:4;34633:3;34629:14;34614:29;;34576:73;;;;:::o;34655:305::-;;34714:20;34732:1;34714:20;:::i;:::-;34709:25;;34748:20;34766:1;34748:20;:::i;:::-;34743:25;;34902:1;34834:66;34830:74;34827:1;34824:81;34821:2;;;34908:18;;:::i;:::-;34821:2;34952:1;34949;34945:9;34938:16;;34699:261;;;;:::o;34966:185::-;;35023:20;35041:1;35023:20;:::i;:::-;35018:25;;35057:20;35075:1;35057:20;:::i;:::-;35052:25;;35096:1;35086:2;;35101:18;;:::i;:::-;35086:2;35143:1;35140;35136:9;35131:14;;35008:143;;;;:::o;35157:348::-;;35220:20;35238:1;35220:20;:::i;:::-;35215:25;;35254:20;35272:1;35254:20;:::i;:::-;35249:25;;35442:1;35374:66;35370:74;35367:1;35364:81;35359:1;35352:9;35345:17;35341:105;35338:2;;;35449:18;;:::i;:::-;35338:2;35497:1;35494;35490:9;35479:20;;35205:300;;;;:::o;35511:191::-;;35571:20;35589:1;35571:20;:::i;:::-;35566:25;;35605:20;35623:1;35605:20;:::i;:::-;35600:25;;35644:1;35641;35638:8;35635:2;;;35649:18;;:::i;:::-;35635:2;35694:1;35691;35687:9;35679:17;;35556:146;;;;:::o;35708:96::-;;35774:24;35792:5;35774:24;:::i;:::-;35763:35;;35753:51;;;:::o;35810:90::-;;35887:5;35880:13;35873:21;35862:32;;35852:48;;;:::o;35906:109::-;;35985:24;36003:5;35985:24;:::i;:::-;35974:35;;35964:51;;;:::o;36021:89::-;;36097:6;36090:5;36086:18;36075:29;;36065:45;;;:::o;36116:126::-;;36193:42;36186:5;36182:54;36171:65;;36161:81;;;:::o;36248:77::-;;36314:5;36303:16;;36293:32;;;:::o;36331:152::-;;36427:50;36471:5;36427:50;:::i;:::-;36414:63;;36404:79;;;:::o;36489:126::-;;36585:24;36603:5;36585:24;:::i;:::-;36572:37;;36562:53;;;:::o;36621:168::-;;36725:58;36777:5;36725:58;:::i;:::-;36712:71;;36702:87;;;:::o;36795:134::-;;36899:24;36917:5;36899:24;:::i;:::-;36886:37;;36876:53;;;:::o;36935:307::-;37003:1;37013:113;37027:6;37024:1;37021:13;37013:113;;;37112:1;37107:3;37103:11;37097:18;37093:1;37088:3;37084:11;37077:39;37049:2;37046:1;37042:10;37037:15;;37013:113;;;37144:6;37141:1;37138:13;37135:2;;;37224:1;37215:6;37210:3;37206:16;37199:27;37135:2;36984:258;;;;:::o;37248:233::-;;37310:24;37328:5;37310:24;:::i;:::-;37301:33;;37356:66;37349:5;37346:77;37343:2;;;37426:18;;:::i;:::-;37343:2;37473:1;37466:5;37462:13;37455:20;;37291:190;;;:::o;37487:180::-;37535:77;37532:1;37525:88;37632:4;37629:1;37622:15;37656:4;37653:1;37646:15;37673:180;37721:77;37718:1;37711:88;37818:4;37815:1;37808:15;37842:4;37839:1;37832:15;37859:102;;37951:2;37947:7;37942:2;37935:5;37931:14;37927:28;37917:38;;37907:54;;;:::o;37967:122::-;38040:24;38058:5;38040:24;:::i;:::-;38033:5;38030:35;38020:2;;38079:1;38076;38069:12;38020:2;38010:79;:::o;38095:116::-;38165:21;38180:5;38165:21;:::i;:::-;38158:5;38155:32;38145:2;;38201:1;38198;38191:12;38145:2;38135:76;:::o;38217:148::-;38303:37;38334:5;38303:37;:::i;:::-;38296:5;38293:48;38283:2;;38355:1;38352;38345:12;38283:2;38273:92;:::o;38371:120::-;38443:23;38460:5;38443:23;:::i;:::-;38436:5;38433:34;38423:2;;38481:1;38478;38471:12;38423:2;38413:78;:::o;38497:122::-;38570:24;38588:5;38570:24;:::i;:::-;38563:5;38560:35;38550:2;;38609:1;38606;38599:12;38550:2;38540:79;:::o

ipfs://8e311456e6967eae471a1e3f60f74a30b799a32053243663c51cdfb5ebee914b