Contract 0x54e2d14df9348b3fba7e372328595b9f3ae243fe

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

// 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/vault/StellaVault.sol


pragma solidity ^0.8.0;






contract StellaVault 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
        uint256 lockDownDuration;
    }

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

    struct TimedStake {
      mapping(uint256 => uint256) stakes;
      uint256[] stakeTimes;
    }

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

    mapping(uint256 => mapping(address => TimedStake)) timeStakeInfo;

    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,
        uint256 _lockDownDuration
    ) 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,
                lockDownDuration: _lockDownDuration
            })
        );
    }

    // 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,
        uint256 _lockDownDuration,
        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;
        poolInfo[_pid].lockDownDuration = _lockDownDuration;
    }

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

            TimedStake storage _timedStake = timeStakeInfo[_pid][msg.sender];
            _timedStake.stakes[block.timestamp] = _amount;
            _timedStake.stakeTimes.push(block.timestamp);

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

        require(withdrawableAmount(_pid, msg.sender) >= _amount,"not enough withdrawable balance");
        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);
        }
    }

    // calcuate amount that can be withdrawn
    function withdrawableAmount(uint256 _pid, address account)public view returns(uint256){
        PoolInfo storage pool = poolInfo[_pid];
        uint256 amount = 0;
        TimedStake storage _timedStake = timeStakeInfo[_pid][account];
        
        for (uint8 index = 0; index < _timedStake.stakeTimes.length; index++) {
            uint256 key = _timedStake.stakeTimes[index];
            if (block.timestamp.sub(key) > pool.lockDownDuration){
                amount = amount.add(_timedStake.stakes[key]);
            }
        }
        return amount;
    }

    // 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"},{"internalType":"uint256","name":"_lockDownDuration","type":"uint256"}],"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"},{"internalType":"uint256","name":"lockDownDuration","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":"uint256","name":"_lockDownDuration","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"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"withdrawableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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

27972:24628:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30744:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30845;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36254:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49493:214;;;:::i;:::-;;48413:234;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30553:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29749:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;29994:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30427:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35513:304;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39903:286;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51735:333;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43448:1139;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30155:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30089:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40528:1231;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44658:832;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;35191:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34208:198;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49228:211;;;:::i;:::-;;29202:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40272:180;;;:::i;:::-;;50022:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17347:94;;;:::i;:::-;;46930:574;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29660:54;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52076:521;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51144;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;16696:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35352:153;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29833:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;50335:481;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50882:254;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30361:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35871:375;;;:::i;:::-;;48655:520;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30488:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36562:1163;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37839:901;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;30260:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49778:178;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29555:58;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30647:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41830:1586;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17596:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29479:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;38805:1033;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30744:30;;;;:::o;30845:::-;;;;:::o;36254:95::-;36299:7;36326:8;:15;;;;36319:22;;36254:95;:::o;49493:214::-;32594:10;32581:23;;:9;;;;;;;;;;;:23;;;32559:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;49559:15:::1;;;;;;;;;;;49551:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;49648:5;49630:15;;:23;;;;;;;;;;;;;;;;;;49686:12;:10;:12::i;:::-;49669:30;;;;;;;;;;;;49493:214::o:0;48413:234::-;32594:10;32581:23;;:9;;;;;;;;;;;:23;;;32559:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;48497:17:::1;:15;:17::i;:::-;48552:10;48532:64;;;48564:14;;48580:15;48532:64;;;;;;;:::i;:::-;;;;;;;;48624:15;48607:14;:32;;;;48413:234:::0;:::o;30553:30::-;;;;;;;;;;;;;:::o;29749:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;29994:34::-;;;;:::o;30427:26::-;;;;;;;;;;;;;:::o;35513:304::-;32594:10;32581:23;;:9;;;;;;;;;;;:23;;;32559:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;35636:1:::1;35613:25;;:11;:25;;;;35591:125;;;;;;;;;;;;:::i;:::-;;;;;;;;;35763:11;35732:43;;35752:9;;;;;;;;;;;35732:43;;;;;;;;;;;;35798:11;35786:9;;:23;;;;;;;;;;;;;;;;;;35513:304:::0;:::o;39903:286::-;40000:4;40022:21;40046:8;:14;40055:4;40046:14;;;;;;;;;;;:21;40061:5;40046:21;;;;;;;;;;;;;;;40022:45;;40114:10;;40098:12;:26;;:83;;;;;40160:4;:21;;;40141:15;:40;;40098:83;40078:103;;;39903:286;;;;:::o;51735:333::-;51843:15;;;;;;;;;;;51829:29;;:10;:29;;;51807:144;;;;;;;;;;;;:::i;:::-;;;;;;;;;51980:16;51962:15;;:34;;;;;;;;;;;;;;;;;;52043:16;52012:48;;52031:10;52012:48;;;;;;;;;;;;51735:333;:::o;43448:1139::-;19731:1;20327:7;;:19;;20319:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19731:1;20460:7;:18;;;;43528:21:::1;43552:8;43561:4;43552:14;;;;;;;;;;;;;;;;;;;;;;;;;;43528:38;;43577:21;43601:8;:14;43610:4;43601:14;;;;;;;;;;;:28;43616:12;:10;:12::i;:::-;43601:28;;;;;;;;;;;;;;;43577:52;;43738:7;43723:4;:11;;;:22;;43715:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43871:7;43855:4;:12;;;:23;;43847:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43929:16;43940:4;43929:10;:16::i;:::-;43958:30;43983:4;43958:24;:30::i;:::-;44049:7;44009:36;44028:4;44034:10;44009:18;:36::i;:::-;:47;;44001:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;44116:1;44106:7;:11;44102:347;;;44148:24;44164:7;44148:4;:11;;;:15;;:24;;;;:::i;:::-;44134:4;:11;;:38;;;;44202:25;44219:7;44202:4;:12;;;:16;;:25;;;;:::i;:::-;44187:4;:12;;:40;;;;44279:6;;;;;;;;;;;44246:40;;44254:4;:12;;;;;;;;;;;;44246:40;;;44242:133;;;44328:31;44351:7;44328:18;;:22;;:31;;;;:::i;:::-;44307:18;:52;;;;44242:133;44389:48;44415:12;:10;:12::i;:::-;44429:7;44389:4;:12;;;;;;;;;;;;:25;;;;:48;;;;;:::i;:::-;44102:347;44477:49;44521:4;44477:39;44493:4;:22;;;44477:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;44459:4;:15;;:67;;;;44565:4;44551:12;:10;:12::i;:::-;44542:37;;;44571:7;44542:37;;;;;;:::i;:::-;;;;;;;;20491:1;;19687::::0;20639:7;:22;;;;43448:1139;;:::o;30155:35::-;;;;:::o;30089:25::-;;;;:::o;40528:1231::-;40580:21;40604:8;40613:4;40604:14;;;;;;;;;;;;;;;;;;;;;;;;;;40580:38;;40649:4;:20;;;40633:12;:36;40629:75;;40686:7;;;40629:75;40716:16;40735:4;:12;;;40716:31;;40774:1;40762:8;:13;:37;;;;40798:1;40779:4;:15;;;:20;40762:37;40758:126;;;40839:12;40816:4;:20;;:35;;;;40866:7;;;;40758:126;40896:18;40917:49;40931:4;:20;;;40953:12;40917:13;:49::i;:::-;40896:70;;40977:20;41000:114;41098:15;;41000:79;41063:4;:15;;;41000:44;41029:14;;41000:10;:28;;:44;;;;:::i;:::-;:62;;:79;;;;:::i;:::-;:97;;:114;;;;:::i;:::-;40977:137;;41127:17;41213:15;;41186;;41163:11;;41147:4;:27;;;;:::i;:::-;:54;;;;:::i;:::-;:81;;;;:::i;:::-;41127:101;;41241:6;;;;;;;;;;;:11;;;41253;;;;;;;;;;;41297:4;41282:11;;41267:12;:26;;;;:::i;:::-;41266:35;;;;:::i;:::-;41241:61;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41313:6;;;;;;;;;;;:11;;;41325:15;;;;;;;;;;;41377:4;41358:15;;41343:12;:30;;;;:::i;:::-;41342:39;;;;:::i;:::-;41313:69;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41393:6;;;;;;;;;;;:11;;;41405:15;;;;;;;;;;;41457:4;41438:15;;41423:12;:30;;;;:::i;:::-;41422:39;;;;:::i;:::-;41393:69;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41473:6;;;;;;;;;;;:11;;;41493:4;41529;41516:9;41501:12;:24;;;;:::i;:::-;41500:33;;;;:::i;:::-;41473:61;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41691:4;41665:9;41649:4;:12;;;41641:4;41626:12;:19;;;;:::i;:::-;41625:36;;;;:::i;:::-;41624:50;;;;:::i;:::-;41623:72;;;;:::i;:::-;41585:4;:22;;;:110;;;;:::i;:::-;41547:4;:22;;:148;;;;41739:12;41716:4;:20;;:35;;;;40528:1231;;;;;;;:::o;44658:832::-;19731:1;20327:7;;:19;;20319:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19731:1;20460:7;:18;;;;44730:21:::1;44754:8;44763:4;44754:14;;;;;;;;;;;;;;;;;;;;;;;;;;44730:38;;44779:21;44803:8;:14;44812:4;44803:14;;;;;;;;;;;:28;44818:12;:10;:12::i;:::-;44803:28;;;;;;;;;;;;;;;44779:52;;44842:14;44859:4;:11;;;44842:28;;44973:6;44957:4;:12;;;:22;;44935:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;45074:1;45060:4;:11;;:15;;;;45104:1;45086:4;:15;;:19;;;;45138:1;45116:4;:19;;:23;;;;45174:1;45150:4;:21;;:25;;;;45201:24;45218:6;45201:4;:12;;;:16;;:24;;;;:::i;:::-;45186:4;:12;;:39;;;;45275:6;;;;;;;;;;;45242:40;;45250:4;:12;;;;;;;;;;;;45242:40;;;45238:124;;;45320:30;45343:6;45320:18;;:22;;:30;;;;:::i;:::-;45299:18;:51;;;;45238:124;45372:47;45398:12;:10;:12::i;:::-;45412:6;45372:4;:12;;;;;;;;;;;;:25;;;;:47;;;;;:::i;:::-;45469:4;45455:12;:10;:12::i;:::-;45437:45;;;45475:6;45437:45;;;;;;:::i;:::-;;;;;;;;20491:1;;;19687::::0;20639:7;:22;;;;44658:832;:::o;35191:85::-;35232:7;35259:9;;;;;;;;;;;35252:16;;35191:85;:::o;34208:198::-;34320:4;34349:15;;;;;;;;;;;:49;;;;;28120:42;34368:30;;:9;:30;;;34349:49;34342:56;;34208:198;;;:::o;49228:211::-;32594:10;32581:23;;:9;;;;;;;;;;;:23;;;32559:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;49294:15:::1;;;;;;;;;;;49293:16;49285:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;49382:4;49364:15;;:22;;;;;;;;;;;;;;;;;;49418:12;:10;:12::i;:::-;49402:29;;;;;;;;;;;;49228:211::o:0;29202:26::-;;;;;;;;;;;;;:::o;40272:180::-;40317:14;40334:8;:15;;;;40317:32;;40365:11;40360:85;40388:6;40382:3;:12;40360:85;;;40418:15;40429:3;40418:10;:15::i;:::-;40396:5;;;;:::i;:::-;;;40360:85;;;;40272:180;:::o;50022:305::-;50122:11;;;;;;;;;;;50108:25;;:10;:25;;;50086:140;;;;;;;;;;;;:::i;:::-;;;;;;;;;50251:12;50237:11;;:26;;;;;;;;;;;;;;;;;;50306:12;50279:40;;50294:10;50279:40;;;;;;;;;;;;50022: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;46930:574::-;47008:7;47027:21;47051:8;47060:4;47051:14;;;;;;;;;;;;;;;;;;;;;;;;;;47027:38;;47076:14;47105:30;47138:13;:19;47152:4;47138:19;;;;;;;;;;;:28;47158:7;47138:28;;;;;;;;;;;;;;;47105:61;;47192:11;47187:286;47217:11;:22;;:29;;;;47209:5;:37;;;47187:286;;;47272:11;47286;:22;;47309:5;47286:29;;;;;;;;;;;;;;;;;;;;;;;;;;47272:43;;47361:4;:21;;;47334:24;47354:3;47334:15;:19;;:24;;;;:::i;:::-;:48;47330:132;;;47411:35;47422:11;:18;;:23;47441:3;47422:23;;;;;;;;;;;;47411:6;:10;;:35;;;;:::i;:::-;47402:44;;47330:132;47187:286;47248:7;;;;;:::i;:::-;;;;47187:286;;;;47490:6;47483:13;;;;;46930:574;;;;:::o;29660:54::-;29710:4;29660:54;:::o;52076:521::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;52188:19:::1;52183:1;:24;;:55;;;;;52234:4;52211:19;:27;;52183:55;52161:148;;;;;;;;;;;;:::i;:::-;;;;;;;;;52397:4;52378:15;;52356:19;52342:11;;:33;;;;:::i;:::-;:51;;;;:::i;:::-;:59;;52320:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;52489:52;52504:15;;52521:19;52489:52;;;;;;;:::i;:::-;;;;;;;;52570:19;52552:15;:37;;;;52076:521:::0;:::o;51144:::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51256:19:::1;51251:1;:24;;:55;;;;;51302:4;51279:19;:27;;51251:55;51229:148;;;;;;;;;;;;:::i;:::-;;;;;;;;;51465:4;51446:15;;51424:19;51410:11;;:33;;;;:::i;:::-;:51;;;;:::i;:::-;:59;;51388:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;51557:52;51572:15;;51589:19;51557:52;;;;;;;:::i;:::-;;;;;;;;51638:19;51620:15;:37;;;;51144:521:::0;:::o;16696:87::-;16742:7;16769:6;;;;;;;;;;;16762:13;;16696:87;:::o;35352:153::-;35451:7;35483:14;35491:5;35483:3;:7;;:14;;;;:::i;:::-;35476:21;;35352:153;;;;:::o;29833:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50335:481::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;50439:15:::1;50434:1;:20;;:47;;;;;50477:4;50458:15;:23;;50434:47;50412:136;;;;;;;;;;;;:::i;:::-;;;;;;;;;50636:4;50617:15;;50599;50581;;:33;;;;:::i;:::-;:51;;;;:::i;:::-;:59;;50559:149;;;;;;;;;;;;:::i;:::-;;;;;;;;;50724:44;50739:11;;50752:15;50724:44;;;;;;;:::i;:::-;;;;;;;;50793:15;50779:11;:29;;;;50335:481:::0;:::o;50882:254::-;50973:15;;;;;;;;;;;50959:29;;:10;:29;;;50951:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51048:16;51030:15;;:34;;;;;;;;;;;;;;;;;;51111:16;51080:48;;51099:10;51080:48;;;;;;;;;;;;50882:254;:::o;30361:35::-;;;;;;;;;;;;;:::o;35871:375::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;35946:10:::1;;35931:12;:25;35923:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;36001:14;36018:8;:15;;;;36001:32;;36049:11;36044:157;36072:6;36066:3;:12;36044:157;;;36102:21;36126:8;36135:3;36126:13;;;;;;;;;;;;;;;;;;;;;;;;;;36102:37;;36177:12;36154:4;:20;;:35;;;;36044:157;36080:5;;;;:::i;:::-;;;36044:157;;;;36226:12;36213:10;:25;;;;16987:1;35871:375::o:0;48655:520::-;32594:10;32581:23;;:9;;;;;;;;;;;:23;;;32559:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;48803:11:::1;48799:61;;;48831:17;:15;:17::i;:::-;48799:61;48910:12;:10;:12::i;:::-;48877:122;;;48937:8;48946:4;48937:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;48977:11;48877:122;;;;;;;:::i;:::-;;;;;;;;49030:87;49095:11;49030:46;49050:8;49059:4;49050:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;49030:15;;:19;;:46;;;;:::i;:::-;:50;;:87;;;;:::i;:::-;49012:15;:105;;;;49156:11;49128:8;49137:4;49128:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;:39;;;;48655:520:::0;;;:::o;30488:30::-;;;;;;;;;;;;;:::o;36562:1163::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29710:4:::1;36817:41;;:13;:41;;;;36795:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;29606:7;36944:16;:44;;36922:123;;;;;;;;;;;;:::i;:::-;;;;;;;;;37060:11;37056:61;;;37088:17;:15;:17::i;:::-;37056:61;37127:23;37168:10;;37153:12;:25;:79;;37222:10;;37153:79;;;37194:12;37153:79;37127:105;;37261:32;37281:11;37261:15;;:19;;:32;;;;:::i;:::-;37243:15;:50;;;;37304:8;37332:374;;;;;;;;37369:8;37332:374;;;;;;37408:11;37332:374;;;;37455:15;37332:374;;;;37508:1;37332:374;;;;37542:13;37332:374;;;;;;37591:16;37332:374;;;;37635:1;37332:374;;;;37673:17;37332:374;;::::0;37304:413:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16987:1;36562:1163:::0;;;;;;:::o;37839:901::-;16927:12;:10;:12::i;:::-;16916:23;;:7;:5;:7::i;:::-;:23;;;16908:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;29710:4:::1;38091:41;;:13;:41;;;;38069:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;29606:7;38218:16;:44;;38196:123;;;;;;;;;;;;:::i;:::-;;;;;;;;;38334:11;38330:61;;;38362:17;:15;:17::i;:::-;38330:61;38419:87;38484:11;38419:46;38439:8;38448:4;38439:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;;38419:15;;:19;;:46;;;;:::i;:::-;:50;;:87;;;;:::i;:::-;38401:15;:105;;;;38545:11;38517:8;38526:4;38517:14;;;;;;;;;;;;;;;;;;;;;;;;;;:25;;:39;;;;38597:13;38567:8;38576:4;38567:14;;;;;;;;;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;38654:16;38621:8;38630:4;38621:14;;;;;;;;;;;;;;;;;;;;;;;;;;:30;;:49;;;;38715:17;38681:8;38690:4;38681:14;;;;;;;;;;;;;;;;;;;;;;;;;;:31;;:51;;;;37839:901:::0;;;;;;:::o;30260:37::-;;;;:::o;49778:178::-;49848:13;49843:106;49875:5;;:12;;49867:5;:20;49843:106;;;49913:24;49921:5;;49927;49921:12;;;;;;;;;;;;;;;;;;;;;49935:1;49913:7;:24::i;:::-;49889:7;;;;:::i;:::-;;;49843:106;;;;49778:178;;:::o;29555:58::-;29606:7;29555:58;:::o;30647:26::-;;;;:::o;41830:1586::-;19731:1;20327:7;;:19;;20319:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19731:1;20460:7;:18;;;;41947:10:::1;;41931:12;:26;;41909:123;;;;;;;;;;;;:::i;:::-;;;;;;;;;42045:21;42069:8;42078:4;42069:14;;;;;;;;;;;;;;;;;;;;;;;;;;42045:38;;42094:21;42118:8;:14;42127:4;42118:14;;;;;;;;;;;:28;42133:12;:10;:12::i;:::-;42118:28;;;;;;;;;;;;;;;42094:52;;42159:16;42170:4;42159:10;:16::i;:::-;42188:30;42213:4;42188:24;:30::i;:::-;42245:1;42235:7;:11;42231:1048;;;42263:21;42287:4;:12;;;;;;;;;;;;:22;;;42318:4;42287:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42263:61;;42339:67;42369:12;:10;:12::i;:::-;42391:4;42398:7;42339:4;:12;;;;;;;;;;;;:29;;;;:67;;;;;;:::i;:::-;42421:20;42444:4;:12;;;;;;;;;;;;:22;;;42475:4;42444:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42421:60;;42508:31;42525:13;42508:12;:16;;:31;;;;:::i;:::-;42498:41;;42580:1;42560:4;:17;;;;;;;;;;;;:21;;;42556:251;;;42602:18;42623:41;42658:5;42623:30;42635:4;:17;;;;;;;;;;;;42623:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;42602:62;;42683:54;42709:15;;;;;;;;;;;42726:10;42683:4;:12;;;;;;;;;;;;:25;;;;:54;;;;;:::i;:::-;42768:23;42780:10;42768:7;:11;;:23;;;;:::i;:::-;42758:33;;42556:251;;42837:24;42853:7;42837:4;:11;;;:15;;:24;;;;:::i;:::-;42823:4;:11;;:38;;;;42891:25;42908:7;42891:4;:12;;;:16;;:25;;;;:::i;:::-;42876:4;:12;;:40;;;;42970:6;;;;;;;;;;;42937:40;;42945:4;:12;;;;;;;;;;;;42937:40;;;42933:133;;;43019:31;43042:7;43019:18;;:22;;:31;;;;:::i;:::-;42998:18;:52;;;;42933:133;43082:30;43115:13;:19;43129:4;43115:19;;;;;;;;;;;:31;43135:10;43115:31;;;;;;;;;;;;;;;43082:64;;43199:7;43161:11;:18;;:35;43180:15;43161:35;;;;;;;;;;;:45;;;;43221:11;:22;;43249:15;43221:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42231:1048;;;;43307:49;43351:4;43307:39;43323:4;:22;;;43307:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;43289:4;:15;;:67;;;;43394:4;43380:12;:10;:12::i;:::-;43372:36;;;43400:7;43372:36;;;;;;:::i;:::-;;;;;;;;20491:1;;19687::::0;20639:7;:22;;;;41830:1586;;:::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;29479:29::-;;;;:::o;38805:1033::-;38907:7;38932:21;38956:8;38965:4;38956:14;;;;;;;;;;;;;;;;;;;;;;;;;;38932:38;;38981:21;39005:8;:14;39014:4;39005:14;;;;;;;;;;;:21;39020:5;39005:21;;;;;;;;;;;;;;;38981:45;;39037:25;39065:4;:22;;;39037:50;;39098:16;39117:4;:12;;;;;;;;;;;;:22;;;39148:4;39117:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39098:56;;39186:4;:20;;;39171:12;:35;:52;;;;;39222:1;39210:8;:13;;39171:52;39167:494;;;39240:18;39261:98;39293:4;:20;;;39332:12;39261:13;:98::i;:::-;39240:119;;39374:20;39397:126;39507:15;;39397:87;39468:4;:15;;;39397:48;39430:14;;39397:10;:32;;:48;;;;:::i;:::-;:70;;:87;;;;:::i;:::-;:109;;:126;;;;:::i;:::-;39374:149;;39558:91;39598:36;39625:8;39598:22;39615:4;39598:12;:16;;:22;;;;:::i;:::-;:26;;:36;;;;:::i;:::-;39558:17;:21;;:91;;;;:::i;:::-;39538:111;;39167:494;;;39673:15;39691:89;39754:4;:15;;;39691:44;39730:4;39691:34;39707:17;39691:4;:11;;;:15;;:34;;;;:::i;:::-;:38;;:44;;;;:::i;:::-;:48;;:89;;;;:::i;:::-;39673:107;;39798:32;39810:4;:19;;;39798:7;:11;;:32;;;;:::i;:::-;39791:39;;;;;;;38805:1033;;;;:::o;15478:98::-;15531:7;15558:10;15551:17;;15478:98;:::o;34414:460::-;34521:14;34557:30;34576:10;34557:18;:30::i;:::-;34553:314;;;34778:2;34762:14;34758:23;34745:37;34741:2;34737:46;34727:56;;34708:90;;;34837:18;:16;:18::i;:::-;34830:25;;;;34553:314;34414:460;;:::o;45536:1340::-;45604:21;45628:8;45637:4;45628:14;;;;;;;;;;;;;;;;;;;;;;;;;;45604:38;;45653:21;45677:8;:14;45686:4;45677:14;;;;;;;;;;;:28;45692:12;:10;:12::i;:::-;45677:28;;;;;;;;;;;;;;;45653:52;;45747:1;45722:4;:21;;;:26;:56;;;;;45768:10;;45752:12;:26;;45722:56;45718:154;;;45819:41;45839:4;:20;;;45819:15;:19;;:41;;;;:::i;:::-;45795:4;:21;;:65;;;;45718:154;45884:15;45902:94;45970:4;:15;;;45902:49;45946:4;45902:39;45918:4;:22;;;45902:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:94;;;;:::i;:::-;45884:112;;46011:30;46022:4;46028:12;:10;:12::i;:::-;46011:10;:30::i;:::-;46007:862;;;46072:1;46062:7;:11;:38;;;;46099:1;46077:4;:19;;;:23;46062:38;46058:562;;;46121:20;46144:32;46156:4;:19;;;46144:7;:11;;:32;;;;:::i;:::-;46121:55;;46253:85;46300:4;:19;;;46253:20;;:24;;:85;;;;:::i;:::-;46230:20;:108;;;;46379:1;46357:4;:19;;:23;;;;46423:81;46465:4;:20;;;46423:15;:19;;:81;;;;:::i;:::-;46399:4;:21;;:105;;;;46558:46;46577:12;:10;:12::i;:::-;46591;46558:18;:46::i;:::-;46058:562;;46007:862;;;46651:1;46641:7;:11;46637:232;;;46691:32;46715:7;46691:4;:19;;;:23;;:32;;;;:::i;:::-;46669:4;:19;;:54;;;;46761:33;46786:7;46761:20;;:24;;:33;;;;:::i;:::-;46738:20;:56;;;;46843:4;46829:12;:10;:12::i;:::-;46814:43;;;46849:7;46814:43;;;;;;:::i;:::-;;;;;;;;46637:232;46007:862;45536:1340;;;;:::o;23857:98::-;23915:7;23946:1;23942;:5;;;;:::i;:::-;23935:12;;23857:98;;;;:::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;23476:98::-;23534:7;23565:1;23561;:5;;;;:::i;:::-;23554:12;;23476:98;;;;:::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;47621:657::-;47737:18;;47703:6;;;;;;;;;;;:16;;;47728:4;47703:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;47699:572;;;47959:17;47979:87;48033:18;;47979:6;;;;;;;;;;;:16;;;48004:4;47979:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;;:87;;;;:::i;:::-;47959:107;;48096:9;48085:7;:20;48081:179;;48126:6;;;;;;;;;;;:15;;;48142:3;48147:9;48126:31;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48081:179;;;48193:1;48183:7;:11;48179:81;;;48215:6;;;;;;;;;;;:15;;;48231:3;48236:7;48215:29;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;48179:81;48081:179;47699:572;;47621: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:1008::-;;;;;;;3588:3;3576:9;3567:7;3563:23;3559:33;3556:2;;;3605:1;3602;3595:12;3556:2;3648:1;3673:53;3718:7;3709:6;3698:9;3694:22;3673:53;:::i;:::-;3663:63;;3619:117;3775:2;3801:66;3859:7;3850:6;3839:9;3835:22;3801:66;:::i;:::-;3791:76;;3746:131;3916:2;3942:52;3986:7;3977:6;3966:9;3962:22;3942:52;:::i;:::-;3932:62;;3887:117;4043:2;4069:53;4114:7;4105:6;4094:9;4090:22;4069:53;:::i;:::-;4059:63;;4014:118;4171:3;4198:50;4240:7;4231:6;4220:9;4216:22;4198:50;:::i;:::-;4188:60;;4142:116;4297:3;4324:53;4369:7;4360:6;4349:9;4345:22;4324:53;:::i;:::-;4314:63;;4268:119;3546:848;;;;;;;;:::o;4400:407::-;;;4525:2;4513:9;4504:7;4500:23;4496:32;4493:2;;;4541:1;4538;4531:12;4493:2;4584:1;4609:53;4654:7;4645:6;4634:9;4630:22;4609:53;:::i;:::-;4599:63;;4555:117;4711:2;4737:53;4782:7;4773:6;4762:9;4758:22;4737:53;:::i;:::-;4727:63;;4682:118;4483:324;;;;;:::o;4813:546::-;;;;4952:2;4940:9;4931:7;4927:23;4923:32;4920:2;;;4968:1;4965;4958:12;4920:2;5011:1;5036:53;5081:7;5072:6;5061:9;5057:22;5036:53;:::i;:::-;5026:63;;4982:117;5138:2;5164:53;5209:7;5200:6;5189:9;5185:22;5164:53;:::i;:::-;5154:63;;5109:118;5266:2;5292:50;5334:7;5325:6;5314:9;5310:22;5292:50;:::i;:::-;5282:60;;5237:115;4910:449;;;;;:::o;5365:982::-;;;;;;;5554:3;5542:9;5533:7;5529:23;5525:33;5522:2;;;5571:1;5568;5561:12;5522:2;5614:1;5639:53;5684:7;5675:6;5664:9;5660:22;5639:53;:::i;:::-;5629:63;;5585:117;5741:2;5767:53;5812:7;5803:6;5792:9;5788:22;5767:53;:::i;:::-;5757:63;;5712:118;5869:2;5895:52;5939:7;5930:6;5919:9;5915:22;5895:52;:::i;:::-;5885:62;;5840:117;5996:2;6022:53;6067:7;6058:6;6047:9;6043:22;6022:53;:::i;:::-;6012:63;;5967:118;6124:3;6151:53;6196:7;6187:6;6176:9;6172:22;6151:53;:::i;:::-;6141:63;;6095:119;6253:3;6280:50;6322:7;6313:6;6302:9;6298:22;6280:50;:::i;:::-;6270:60;;6224:116;5512:835;;;;;;;;:::o;6353:118::-;6440:24;6458:5;6440:24;:::i;:::-;6435:3;6428:37;6418:53;;:::o;6477:109::-;6558:21;6573:5;6558:21;:::i;:::-;6553:3;6546:34;6536:50;;:::o;6592:373::-;;6724:38;6756:5;6724:38;:::i;:::-;6778:88;6859:6;6854:3;6778:88;:::i;:::-;6771:95;;6875:52;6920:6;6915:3;6908:4;6901:5;6897:16;6875:52;:::i;:::-;6952:6;6947:3;6943:16;6936:23;;6700:265;;;;;:::o;6971:157::-;7071:50;7115:5;7071:50;:::i;:::-;7066:3;7059:63;7049:79;;:::o;7134:173::-;7242:58;7294:5;7242:58;:::i;:::-;7237:3;7230:71;7220:87;;:::o;7313:364::-;;7429:39;7462:5;7429:39;:::i;:::-;7484:71;7548:6;7543:3;7484:71;:::i;:::-;7477:78;;7564:52;7609:6;7604:3;7597:4;7590:5;7586:16;7564:52;:::i;:::-;7641:29;7663:6;7641:29;:::i;:::-;7636:3;7632:39;7625:46;;7405:272;;;;;:::o;7683:323::-;;7846:67;7910:2;7905:3;7846:67;:::i;:::-;7839:74;;7943:27;7939:1;7934:3;7930:11;7923:48;7997:2;7992:3;7988:12;7981:19;;7829:177;;;:::o;8012:379::-;;8175:67;8239:2;8234:3;8175:67;:::i;:::-;8168:74;;8272:34;8268:1;8263:3;8259:11;8252:55;8338:17;8333:2;8328:3;8324:12;8317:39;8382:2;8377:3;8373:12;8366:19;;8158:233;;;:::o;8397:330::-;;8560:67;8624:2;8619:3;8560:67;:::i;:::-;8553:74;;8657:34;8653:1;8648:3;8644:11;8637:55;8718:2;8713:3;8709:12;8702:19;;8543:184;;;:::o;8733:370::-;;8896:67;8960:2;8955:3;8896:67;:::i;:::-;8889:74;;8993:34;8989:1;8984:3;8980:11;8973:55;9059:8;9054:2;9049:3;9045:12;9038:30;9094:2;9089:3;9085:12;9078:19;;8879:224;;;:::o;9109:325::-;;9272:67;9336:2;9331:3;9272:67;:::i;:::-;9265:74;;9369:29;9365:1;9360:3;9356:11;9349:50;9425:2;9420:3;9416:12;9409:19;;9255:179;;;:::o;9440:329::-;;9603:67;9667:2;9662:3;9603:67;:::i;:::-;9596:74;;9700:33;9696:1;9691:3;9687:11;9680:54;9760:2;9755:3;9751:12;9744:19;;9586:183;;;:::o;9775:370::-;;9938:67;10002:2;9997:3;9938:67;:::i;:::-;9931:74;;10035:34;10031:1;10026:3;10022:11;10015:55;10101:8;10096:2;10091:3;10087:12;10080:30;10136:2;10131:3;10127:12;10120:19;;9921:224;;;:::o;10151:329::-;;10314:67;10378:2;10373:3;10314:67;:::i;:::-;10307:74;;10411:33;10407:1;10402:3;10398:11;10391:54;10471:2;10466:3;10462:12;10455:19;;10297:183;;;:::o;10486:327::-;;10649:67;10713:2;10708:3;10649:67;:::i;:::-;10642:74;;10746:31;10742:1;10737:3;10733:11;10726:52;10804:2;10799:3;10795:12;10788:19;;10632:181;;;:::o;10819:370::-;;10982:67;11046:2;11041:3;10982:67;:::i;:::-;10975:74;;11079:34;11075:1;11070:3;11066:11;11059:55;11145:8;11140:2;11135:3;11131:12;11124:30;11180:2;11175:3;11171:12;11164:19;;10965:224;;;:::o;11195:376::-;;11358:67;11422:2;11417:3;11358:67;:::i;:::-;11351:74;;11455:34;11451:1;11446:3;11442:11;11435:55;11521:14;11516:2;11511:3;11507:12;11500:36;11562:2;11557:3;11553:12;11546:19;;11341:230;;;:::o;11577:431::-;;11740:67;11804:2;11799:3;11740:67;:::i;:::-;11733:74;;11837:34;11833:1;11828:3;11824:11;11817:55;11903:34;11898:2;11893:3;11889:12;11882:56;11969:3;11964:2;11959:3;11955:12;11948:25;11999:2;11994:3;11990:12;11983:19;;11723:285;;;:::o;12014:375::-;;12177:67;12241:2;12236:3;12177:67;:::i;:::-;12170:74;;12274:34;12270:1;12265:3;12261:11;12254:55;12340:13;12335:2;12330:3;12326:12;12319:35;12380:2;12375:3;12371:12;12364:19;;12160:229;;;:::o;12395:431::-;;12558:67;12622:2;12617:3;12558:67;:::i;:::-;12551:74;;12655:34;12651:1;12646:3;12642:11;12635:55;12721:34;12716:2;12711:3;12707:12;12700:56;12787:3;12782:2;12777:3;12773:12;12766:25;12817:2;12812:3;12808:12;12801:19;;12541:285;;;:::o;12832:371::-;;12995:67;13059:2;13054:3;12995:67;:::i;:::-;12988:74;;13092:34;13088:1;13083:3;13079:11;13072:55;13158:9;13153:2;13148:3;13144:12;13137:31;13194:2;13189:3;13185:12;13178:19;;12978:225;;;:::o;13209:330::-;;13372:67;13436:2;13431:3;13372:67;:::i;:::-;13365:74;;13469:34;13465:1;13460:3;13456:11;13449:55;13530:2;13525:3;13521:12;13514:19;;13355:184;;;:::o;13545:369::-;;13708:67;13772:2;13767:3;13708:67;:::i;:::-;13701:74;;13805:34;13801:1;13796:3;13792:11;13785:55;13871:7;13866:2;13861:3;13857:12;13850:29;13905:2;13900:3;13896:12;13889:19;;13691:223;;;:::o;13920:327::-;;14083:67;14147:2;14142:3;14083:67;:::i;:::-;14076:74;;14180:31;14176:1;14171:3;14167:11;14160:52;14238:2;14233:3;14229:12;14222:19;;14066:181;;;:::o;14253:372::-;;14416:67;14480:2;14475:3;14416:67;:::i;:::-;14409:74;;14513:34;14509:1;14504:3;14500:11;14493:55;14579:10;14574:2;14569:3;14565:12;14558:32;14616:2;14611:3;14607:12;14600:19;;14399:226;;;:::o;14631:324::-;;14794:67;14858:2;14853:3;14794:67;:::i;:::-;14787:74;;14891:28;14887:1;14882:3;14878:11;14871:49;14946:2;14941:3;14937:12;14930:19;;14777:178;;;:::o;14961:372::-;;15124:67;15188:2;15183:3;15124:67;:::i;:::-;15117:74;;15221:34;15217:1;15212:3;15208:11;15201:55;15287:10;15282:2;15277:3;15273:12;15266:32;15324:2;15319:3;15315:12;15308:19;;15107:226;;;:::o;15339:327::-;;15502:67;15566:2;15561:3;15502:67;:::i;:::-;15495:74;;15599:31;15595:1;15590:3;15586:11;15579:52;15657:2;15652:3;15648:12;15641:19;;15485:181;;;:::o;15672:382::-;;15835:67;15899:2;15894:3;15835:67;:::i;:::-;15828:74;;15932:34;15928:1;15923:3;15919:11;15912:55;15998:20;15993:2;15988:3;15984:12;15977:42;16045:2;16040:3;16036:12;16029:19;;15818:236;;;:::o;16060:374::-;;16223:67;16287:2;16282:3;16223:67;:::i;:::-;16216:74;;16320:34;16316:1;16311:3;16307:11;16300:55;16386:12;16381:2;16376:3;16372:12;16365:34;16425:2;16420:3;16416:12;16409:19;;16206:228;;;:::o;16440:323::-;;16603:67;16667:2;16662:3;16603:67;:::i;:::-;16596:74;;16700:27;16696:1;16691:3;16687:11;16680:48;16754:2;16749:3;16745:12;16738:19;;16586:177;;;:::o;16769:329::-;;16932:67;16996:2;16991:3;16932:67;:::i;:::-;16925:74;;17029:33;17025:1;17020:3;17016:11;17009:54;17089:2;17084:3;17080:12;17073:19;;16915:183;;;:::o;17104:375::-;;17267:67;17331:2;17326:3;17267:67;:::i;:::-;17260:74;;17364:34;17360:1;17355:3;17351:11;17344:55;17430:13;17425:2;17420:3;17416:12;17409:35;17470:2;17465:3;17461:12;17454:19;;17250:229;;;:::o;17485:376::-;;17648:67;17712:2;17707:3;17648:67;:::i;:::-;17641:74;;17745:34;17741:1;17736:3;17732:11;17725:55;17811:14;17806:2;17801:3;17797:12;17790:36;17852:2;17847:3;17843:12;17836:19;;17631:230;;;:::o;17867:368::-;;18030:67;18094:2;18089:3;18030:67;:::i;:::-;18023:74;;18127:34;18123:1;18118:3;18114:11;18107:55;18193:6;18188:2;18183:3;18179:12;18172:28;18226:2;18221:3;18217:12;18210:19;;18013:222;;;:::o;18241:115::-;18326:23;18343:5;18326:23;:::i;:::-;18321:3;18314:36;18304:52;;:::o;18362:118::-;18449:24;18467:5;18449:24;:::i;:::-;18444:3;18437:37;18427:53;;:::o;18486:271::-;;18638:93;18727:3;18718:6;18638:93;:::i;:::-;18631:100;;18748:3;18741:10;;18620:137;;;;:::o;18763:222::-;;18894:2;18883:9;18879:18;18871:26;;18907:71;18975:1;18964:9;18960:17;18951:6;18907:71;:::i;:::-;18861:124;;;;:::o;18991:442::-;;19178:2;19167:9;19163:18;19155:26;;19191:71;19259:1;19248:9;19244:17;19235:6;19191:71;:::i;:::-;19272:72;19340:2;19329:9;19325:18;19316:6;19272:72;:::i;:::-;19354;19422:2;19411:9;19407:18;19398:6;19354:72;:::i;:::-;19145:288;;;;;;:::o;19439:332::-;;19598:2;19587:9;19583:18;19575:26;;19611:71;19679:1;19668:9;19664:17;19655:6;19611:71;:::i;:::-;19692:72;19760:2;19749:9;19745:18;19736:6;19692:72;:::i;:::-;19565:206;;;;;:::o;19777:210::-;;19902:2;19891:9;19887:18;19879:26;;19915:65;19977:1;19966:9;19962:17;19953:6;19915:65;:::i;:::-;19869:118;;;;:::o;19993:1019::-;;20331:3;20320:9;20316:19;20308:27;;20345:84;20426:1;20415:9;20411:17;20402:6;20345:84;:::i;:::-;20439:72;20507:2;20496:9;20492:18;20483:6;20439:72;:::i;:::-;20521;20589:2;20578:9;20574:18;20565:6;20521:72;:::i;:::-;20603;20671:2;20660:9;20656:18;20647:6;20603:72;:::i;:::-;20685:71;20751:3;20740:9;20736:19;20727:6;20685:71;:::i;:::-;20766:73;20834:3;20823:9;20819:19;20810:6;20766:73;:::i;:::-;20849;20917:3;20906:9;20902:19;20893:6;20849:73;:::i;:::-;20932;21000:3;20989:9;20985:19;20976:6;20932:73;:::i;:::-;20298:714;;;;;;;;;;;:::o;21018:264::-;;21170:2;21159:9;21155:18;21147:26;;21183:92;21272:1;21261:9;21257:17;21248:6;21183:92;:::i;:::-;21137:145;;;;:::o;21288:313::-;;21439:2;21428:9;21424:18;21416:26;;21488:9;21482:4;21478:20;21474:1;21463:9;21459:17;21452:47;21516:78;21589:4;21580:6;21516:78;:::i;:::-;21508:86;;21406:195;;;;:::o;21607:419::-;;21811:2;21800:9;21796:18;21788:26;;21860:9;21854:4;21850:20;21846:1;21835:9;21831:17;21824:47;21888:131;22014:4;21888:131;:::i;:::-;21880:139;;21778:248;;;:::o;22032:419::-;;22236:2;22225:9;22221:18;22213:26;;22285:9;22279:4;22275:20;22271:1;22260:9;22256:17;22249:47;22313:131;22439:4;22313:131;:::i;:::-;22305:139;;22203:248;;;:::o;22457:419::-;;22661:2;22650:9;22646:18;22638:26;;22710:9;22704:4;22700:20;22696:1;22685:9;22681:17;22674:47;22738:131;22864:4;22738:131;:::i;:::-;22730:139;;22628:248;;;:::o;22882:419::-;;23086:2;23075:9;23071:18;23063:26;;23135:9;23129:4;23125:20;23121:1;23110:9;23106:17;23099:47;23163:131;23289:4;23163:131;:::i;:::-;23155:139;;23053:248;;;:::o;23307:419::-;;23511:2;23500:9;23496:18;23488:26;;23560:9;23554:4;23550:20;23546:1;23535:9;23531:17;23524:47;23588:131;23714:4;23588:131;:::i;:::-;23580:139;;23478:248;;;:::o;23732:419::-;;23936:2;23925:9;23921:18;23913:26;;23985:9;23979:4;23975:20;23971:1;23960:9;23956:17;23949:47;24013:131;24139:4;24013:131;:::i;:::-;24005:139;;23903:248;;;:::o;24157:419::-;;24361:2;24350:9;24346:18;24338:26;;24410:9;24404:4;24400:20;24396:1;24385:9;24381:17;24374:47;24438:131;24564:4;24438:131;:::i;:::-;24430:139;;24328:248;;;:::o;24582:419::-;;24786:2;24775:9;24771:18;24763:26;;24835:9;24829:4;24825:20;24821:1;24810:9;24806:17;24799:47;24863:131;24989:4;24863:131;:::i;:::-;24855:139;;24753:248;;;:::o;25007:419::-;;25211:2;25200:9;25196:18;25188:26;;25260:9;25254:4;25250:20;25246:1;25235:9;25231:17;25224:47;25288:131;25414:4;25288:131;:::i;:::-;25280:139;;25178:248;;;:::o;25432:419::-;;25636:2;25625:9;25621:18;25613:26;;25685:9;25679:4;25675:20;25671:1;25660:9;25656:17;25649:47;25713:131;25839:4;25713:131;:::i;:::-;25705:139;;25603:248;;;:::o;25857:419::-;;26061:2;26050:9;26046:18;26038:26;;26110:9;26104:4;26100:20;26096:1;26085:9;26081:17;26074:47;26138:131;26264:4;26138:131;:::i;:::-;26130:139;;26028:248;;;:::o;26282:419::-;;26486:2;26475:9;26471:18;26463:26;;26535:9;26529:4;26525:20;26521:1;26510:9;26506:17;26499:47;26563:131;26689:4;26563:131;:::i;:::-;26555:139;;26453:248;;;:::o;26707:419::-;;26911:2;26900:9;26896:18;26888:26;;26960:9;26954:4;26950:20;26946:1;26935:9;26931:17;26924:47;26988:131;27114:4;26988:131;:::i;:::-;26980:139;;26878:248;;;:::o;27132:419::-;;27336:2;27325:9;27321:18;27313:26;;27385:9;27379:4;27375:20;27371:1;27360:9;27356:17;27349:47;27413:131;27539:4;27413:131;:::i;:::-;27405:139;;27303:248;;;:::o;27557:419::-;;27761:2;27750:9;27746:18;27738:26;;27810:9;27804:4;27800:20;27796:1;27785:9;27781:17;27774:47;27838:131;27964:4;27838:131;:::i;:::-;27830:139;;27728:248;;;:::o;27982:419::-;;28186:2;28175:9;28171:18;28163:26;;28235:9;28229:4;28225:20;28221:1;28210:9;28206:17;28199:47;28263:131;28389:4;28263:131;:::i;:::-;28255:139;;28153:248;;;:::o;28407:419::-;;28611:2;28600:9;28596:18;28588:26;;28660:9;28654:4;28650:20;28646:1;28635:9;28631:17;28624:47;28688:131;28814:4;28688:131;:::i;:::-;28680:139;;28578:248;;;:::o;28832:419::-;;29036:2;29025:9;29021:18;29013:26;;29085:9;29079:4;29075:20;29071:1;29060:9;29056:17;29049:47;29113:131;29239:4;29113:131;:::i;:::-;29105:139;;29003:248;;;:::o;29257:419::-;;29461:2;29450:9;29446:18;29438:26;;29510:9;29504:4;29500:20;29496:1;29485:9;29481:17;29474:47;29538:131;29664:4;29538:131;:::i;:::-;29530:139;;29428:248;;;:::o;29682:419::-;;29886:2;29875:9;29871:18;29863:26;;29935:9;29929:4;29925:20;29921:1;29910:9;29906:17;29899:47;29963:131;30089:4;29963:131;:::i;:::-;29955:139;;29853:248;;;:::o;30107:419::-;;30311:2;30300:9;30296:18;30288:26;;30360:9;30354:4;30350:20;30346:1;30335:9;30331:17;30324:47;30388:131;30514:4;30388:131;:::i;:::-;30380:139;;30278:248;;;:::o;30532:419::-;;30736:2;30725:9;30721:18;30713:26;;30785:9;30779:4;30775:20;30771:1;30760:9;30756:17;30749:47;30813:131;30939:4;30813:131;:::i;:::-;30805:139;;30703:248;;;:::o;30957:419::-;;31161:2;31150:9;31146:18;31138:26;;31210:9;31204:4;31200:20;31196:1;31185:9;31181:17;31174:47;31238:131;31364:4;31238:131;:::i;:::-;31230:139;;31128:248;;;:::o;31382:419::-;;31586:2;31575:9;31571:18;31563:26;;31635:9;31629:4;31625:20;31621:1;31610:9;31606:17;31599:47;31663:131;31789:4;31663:131;:::i;:::-;31655:139;;31553:248;;;:::o;31807:419::-;;32011:2;32000:9;31996:18;31988:26;;32060:9;32054:4;32050:20;32046:1;32035:9;32031:17;32024:47;32088:131;32214:4;32088:131;:::i;:::-;32080:139;;31978:248;;;:::o;32232:419::-;;32436:2;32425:9;32421:18;32413:26;;32485:9;32479:4;32475:20;32471:1;32460:9;32456:17;32449:47;32513:131;32639:4;32513:131;:::i;:::-;32505:139;;32403:248;;;:::o;32657:419::-;;32861:2;32850:9;32846:18;32838:26;;32910:9;32904:4;32900:20;32896:1;32885:9;32881:17;32874:47;32938:131;33064:4;32938:131;:::i;:::-;32930:139;;32828:248;;;:::o;33082:419::-;;33286:2;33275:9;33271:18;33263:26;;33335:9;33329:4;33325:20;33321:1;33310:9;33306:17;33299:47;33363:131;33489:4;33363:131;:::i;:::-;33355:139;;33253:248;;;:::o;33507:419::-;;33711:2;33700:9;33696:18;33688:26;;33760:9;33754:4;33750:20;33746:1;33735:9;33731:17;33724:47;33788:131;33914:4;33788:131;:::i;:::-;33780:139;;33678:248;;;:::o;33932:218::-;;34061:2;34050:9;34046:18;34038:26;;34074:69;34140:1;34129:9;34125:17;34116:6;34074:69;:::i;:::-;34028:122;;;;:::o;34156:222::-;;34287:2;34276:9;34272:18;34264:26;;34300:71;34368:1;34357:9;34353:17;34344:6;34300:71;:::i;:::-;34254:124;;;;:::o;34384:332::-;;34543:2;34532:9;34528:18;34520:26;;34556:71;34624:1;34613:9;34609:17;34600:6;34556:71;:::i;:::-;34637:72;34705:2;34694:9;34690:18;34681:6;34637:72;:::i;:::-;34510:206;;;;;:::o;34722:553::-;;34937:3;34926:9;34922:19;34914:27;;34951:71;35019:1;35008:9;35004:17;34995:6;34951:71;:::i;:::-;35032:72;35100:2;35089:9;35085:18;35076:6;35032:72;:::i;:::-;35114;35182:2;35171:9;35167:18;35158:6;35114:72;:::i;:::-;35196;35264:2;35253:9;35249:18;35240:6;35196:72;:::i;:::-;34904:371;;;;;;;:::o;35281:98::-;;35366:5;35360:12;35350:22;;35339:40;;;:::o;35385:99::-;;35471:5;35465:12;35455:22;;35444:40;;;:::o;35490:147::-;;35628:3;35613:18;;35603:34;;;;:::o;35643:169::-;;35761:6;35756:3;35749:19;35801:4;35796:3;35792:14;35777:29;;35739:73;;;;:::o;35818:305::-;;35877:20;35895:1;35877:20;:::i;:::-;35872:25;;35911:20;35929:1;35911:20;:::i;:::-;35906:25;;36065:1;35997:66;35993:74;35990:1;35987:81;35984:2;;;36071:18;;:::i;:::-;35984:2;36115:1;36112;36108:9;36101:16;;35862:261;;;;:::o;36129:185::-;;36186:20;36204:1;36186:20;:::i;:::-;36181:25;;36220:20;36238:1;36220:20;:::i;:::-;36215:25;;36259:1;36249:2;;36264:18;;:::i;:::-;36249:2;36306:1;36303;36299:9;36294:14;;36171:143;;;;:::o;36320:348::-;;36383:20;36401:1;36383:20;:::i;:::-;36378:25;;36417:20;36435:1;36417:20;:::i;:::-;36412:25;;36605:1;36537:66;36533:74;36530:1;36527:81;36522:1;36515:9;36508:17;36504:105;36501:2;;;36612:18;;:::i;:::-;36501:2;36660:1;36657;36653:9;36642:20;;36368:300;;;;:::o;36674:191::-;;36734:20;36752:1;36734:20;:::i;:::-;36729:25;;36768:20;36786:1;36768:20;:::i;:::-;36763:25;;36807:1;36804;36801:8;36798:2;;;36812:18;;:::i;:::-;36798:2;36857:1;36854;36850:9;36842:17;;36719:146;;;;:::o;36871:96::-;;36937:24;36955:5;36937:24;:::i;:::-;36926:35;;36916:51;;;:::o;36973:90::-;;37050:5;37043:13;37036:21;37025:32;;37015:48;;;:::o;37069:109::-;;37148:24;37166:5;37148:24;:::i;:::-;37137:35;;37127:51;;;:::o;37184:89::-;;37260:6;37253:5;37249:18;37238:29;;37228:45;;;:::o;37279:126::-;;37356:42;37349:5;37345:54;37334:65;;37324:81;;;:::o;37411:77::-;;37477:5;37466:16;;37456:32;;;:::o;37494:86::-;;37569:4;37562:5;37558:16;37547:27;;37537:43;;;:::o;37586:152::-;;37682:50;37726:5;37682:50;:::i;:::-;37669:63;;37659:79;;;:::o;37744:126::-;;37840:24;37858:5;37840:24;:::i;:::-;37827:37;;37817:53;;;:::o;37876:168::-;;37980:58;38032:5;37980:58;:::i;:::-;37967:71;;37957:87;;;:::o;38050:134::-;;38154:24;38172:5;38154:24;:::i;:::-;38141:37;;38131:53;;;:::o;38190:307::-;38258:1;38268:113;38282:6;38279:1;38276:13;38268:113;;;38367:1;38362:3;38358:11;38352:18;38348:1;38343:3;38339:11;38332:39;38304:2;38301:1;38297:10;38292:15;;38268:113;;;38399:6;38396:1;38393:13;38390:2;;;38479:1;38470:6;38465:3;38461:16;38454:27;38390:2;38239:258;;;;:::o;38503:233::-;;38565:24;38583:5;38565:24;:::i;:::-;38556:33;;38611:66;38604:5;38601:77;38598:2;;;38681:18;;:::i;:::-;38598:2;38728:1;38721:5;38717:13;38710:20;;38546:190;;;:::o;38742:167::-;;38802:22;38818:5;38802:22;:::i;:::-;38793:31;;38846:4;38839:5;38836:15;38833:2;;;38854:18;;:::i;:::-;38833:2;38901:1;38894:5;38890:13;38883:20;;38783:126;;;:::o;38915:180::-;38963:77;38960:1;38953:88;39060:4;39057:1;39050:15;39084:4;39081:1;39074:15;39101:180;39149:77;39146:1;39139:88;39246:4;39243:1;39236:15;39270:4;39267:1;39260:15;39287:102;;39379:2;39375:7;39370:2;39363:5;39359:14;39355:28;39345:38;;39335:54;;;:::o;39395:122::-;39468:24;39486:5;39468:24;:::i;:::-;39461:5;39458:35;39448:2;;39507:1;39504;39497:12;39448:2;39438:79;:::o;39523:116::-;39593:21;39608:5;39593:21;:::i;:::-;39586:5;39583:32;39573:2;;39629:1;39626;39619:12;39573:2;39563:76;:::o;39645:148::-;39731:37;39762:5;39731:37;:::i;:::-;39724:5;39721:48;39711:2;;39783:1;39780;39773:12;39711:2;39701:92;:::o;39799:120::-;39871:23;39888:5;39871:23;:::i;:::-;39864:5;39861:34;39851:2;;39909:1;39906;39899:12;39851:2;39841:78;:::o;39925:122::-;39998:24;40016:5;39998:24;:::i;:::-;39991:5;39988:35;39978:2;;40037:1;40034;40027:12;39978:2;39968:79;:::o

ipfs://69f32c886523577ffa1542bc4ad07a4a30caff43297b5a39c8ee15d99a9113e7