Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at bttcscan.com on 2023-04-29
*/

// Sources flattened with hardhat v2.14.0 https://hardhat.org

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

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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


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

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}


// File @openzeppelin/contracts/token/ERC20/[email protected]

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev 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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}


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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


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

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

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

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since 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 subtraction 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/interfaces/IChefIncentivesController.sol

pragma solidity ^0.8.9;
pragma experimental ABIEncoderV2;

interface IChefIncentivesController {

  /**
   * @dev Called by the corresponding asset on any update that affects the rewards distribution
   * @param user The address of the user
   * @param userBalance The balance of the user of the asset in the lending pool
   * @param totalSupply The total supply of the asset in the lending pool
   **/
  function handleAction(
    address user,
    uint256 userBalance,
    uint256 totalSupply
  ) external;

    function addPool(address _token, uint256 _allocPoint) external;

    function claim(address _user, address[] calldata _tokens) external;

    function setClaimReceiver(address _user, address _receiver) external;

}


// File contracts/interfaces/IMultiFeeDistribution.sol

pragma solidity ^0.8.9;

interface IMultiFeeDistribution {

    function addReward(address rewardsToken) external;
    function mint(address user, uint256 amount, bool withPenalty) external;
    function exit(bool claimRewards, address onBehalfOf) external;
    function stake(uint256 amount, bool lock, address onBehalfOf) external;
}


// File contracts/MultiFeeDistribution.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;







interface IMintableToken is IERC20 {
    function mint(address _receiver, uint256 _amount) external returns (bool);
    function setMinter(address _minter) external returns (bool);
}

// Based on Ellipsis EPS Staker
// https://github.com/ellipsis-finance/ellipsis/blob/master/contracts/EpsStaker.sol
contract MultiFeeDistribution is IMultiFeeDistribution, Ownable {

    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using SafeERC20 for IMintableToken;

    /* ========== STATE VARIABLES ========== */

    struct Reward {
        uint256 periodFinish;
        uint256 rewardRate;
        uint256 lastUpdateTime;
        uint256 rewardPerTokenStored;
        // tracks already-added balances to handle accrued interest in aToken rewards
        // for the stakingToken this value is unused and will always be 0
        uint256 balance;
    }
    struct Balances {
        uint256 total;
        uint256 unlocked;
        uint256 locked;
        uint256 earned;
    }
    struct LockedBalance {
        uint256 amount;
        uint256 unlockTime;
    }
    struct RewardData {
        address token;
        uint256 amount;
    }

    IChefIncentivesController public incentivesController;
    IMintableToken public immutable stakingToken;
    address[] public rewardTokens;
    mapping(address => Reward) public rewardData;

    // Duration that rewards are streamed over
    uint256 public constant rewardsDuration = 86400; //86400 * 7; //60;
    uint256 public constant rewardLookback = 86400; //30; //86400;
    
    // Duration of lock/earned penalty period
    uint256 public constant lockDuration = rewardsDuration * 7; // rewardsDuration * 4;

    // Addresses approved to call mint
    mapping(address => bool) public minters;
    bool public mintersAreSet;

    // user -> reward token -> amount
    mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
    mapping(address => mapping(address => uint256)) public rewards;

    uint256 public totalSupply;
    uint256 public lockedSupply;

    // Private mappings for balance data
    mapping(address => Balances) private balances;
    mapping(address => LockedBalance[]) private userLocks;
    mapping(address => LockedBalance[]) private userEarnings;

    mapping(address => address) public exitDelegatee;

    /* ========== CONSTRUCTOR ========== */

    constructor(address _stakingToken) Ownable() {
        stakingToken = IMintableToken(_stakingToken);
        // IMintableToken(_stakingToken).setMinter(address(this));
        // First reward MUST be the staking token or things will break
        // related to the 50% penalty and distribution to locked balances
        rewardTokens.push(_stakingToken);
        rewardData[_stakingToken].lastUpdateTime = block.timestamp;
    }

    /* ========== ADMIN CONFIGURATION ========== */

    function setMinters(address[] memory _minters) external onlyOwner {
        require(!mintersAreSet);
        for (uint i; i < _minters.length; i++) {
            minters[_minters[i]] = true;
        }
        mintersAreSet = true;
    }

    function setIncentivesController(IChefIncentivesController _controller) external onlyOwner {
        incentivesController = _controller;
    }

    // Add a new reward token to be distributed to stakers
    function addReward(address _rewardsToken) external override onlyOwner {
        require(rewardData[_rewardsToken].lastUpdateTime == 0);
        rewardTokens.push(_rewardsToken);
        rewardData[_rewardsToken].lastUpdateTime = block.timestamp;
        rewardData[_rewardsToken].periodFinish = block.timestamp;
    }

    /* ========== VIEWS ========== */

    function _rewardPerToken(address _rewardsToken, uint256 _supply) internal view returns (uint256) {
        if (_supply == 0) {
            return rewardData[_rewardsToken].rewardPerTokenStored;
        }
        return
            rewardData[_rewardsToken].rewardPerTokenStored.add(
                lastTimeRewardApplicable(_rewardsToken).sub(
                    rewardData[_rewardsToken].lastUpdateTime).mul(
                        rewardData[_rewardsToken].rewardRate).mul(1e18).div(_supply)
            );
    }

    function _earned(
        address _user,
        address _rewardsToken,
        uint256 _balance,
        uint256 _currentRewardPerToken
    ) internal view returns (uint256) {
        return _balance.mul(
            _currentRewardPerToken.sub(userRewardPerTokenPaid[_user][_rewardsToken])
        ).div(1e18).add(rewards[_user][_rewardsToken]);
    }

    function lastTimeRewardApplicable(address _rewardsToken) public view returns (uint256) {
        uint periodFinish = rewardData[_rewardsToken].periodFinish;
        return block.timestamp < periodFinish ? block.timestamp : periodFinish;
    }

    function rewardPerToken(address _rewardsToken) external view returns (uint256) {
        uint256 supply = _rewardsToken == address(stakingToken) ? lockedSupply : totalSupply;
        return _rewardPerToken(_rewardsToken, supply);

    }

    function getRewardForDuration(address _rewardsToken) external view returns (uint256) {
        return rewardData[_rewardsToken].rewardRate.mul(rewardsDuration).div(1e12);
    }

    // Address and claimable amount of all reward tokens for the given account
    function claimableRewards(address account) external view returns (RewardData[] memory claimRewards) {
        claimRewards = new RewardData[](rewardTokens.length);
        for (uint256 i = 0; i < claimRewards.length; i++) {
            // If i == 0 this is the stakingReward, distribution is based on locked balances
            uint256 balance = i == 0 ? balances[account].locked : balances[account].total;
            uint256 supply = i == 0 ? lockedSupply : totalSupply;
            claimRewards[i].token = rewardTokens[i];
            claimRewards[i].amount = _earned(account, claimRewards[i].token, balance, _rewardPerToken(rewardTokens[i], supply)).div(1e12);
        }
        return claimRewards;
    }

    // Total balance of an account, including unlocked, locked and earned tokens
    function totalBalance(address user) view external returns (uint256 amount) {
        return balances[user].total;
    }

    // Total withdrawable balance for an account to which no penalty is applied
    function unlockedBalance(address user) view external returns (uint256 amount) {
        amount = balances[user].unlocked;
        LockedBalance[] storage earnings = userEarnings[msg.sender];
        for (uint i = 0; i < earnings.length; i++) {
            if (earnings[i].unlockTime > block.timestamp) {
                break;
            }
            amount = amount.add(earnings[i].amount);
        }
        return amount;
    }

    // Information on the "earned" balances of a user
    // Earned balances may be withdrawn immediately for a 50% penalty
    function earnedBalances(
        address user
    ) view external returns (
        uint256 total,
        LockedBalance[] memory earningsData
    ) {
        LockedBalance[] storage earnings = userEarnings[user];
        uint256 idx;
        for (uint i = 0; i < earnings.length; i++) {
            if (earnings[i].unlockTime > block.timestamp) {
                if (idx == 0) {
                    earningsData = new LockedBalance[](earnings.length - i);
                }
                earningsData[idx] = earnings[i];
                idx++;
                total = total.add(earnings[i].amount);
            }
        }
        return (total, earningsData);
    }

    // Information on a user's locked balances
    function lockedBalances(
        address user
    ) view external returns (
        uint256 total,
        uint256 unlockable,
        uint256 locked,
        LockedBalance[] memory lockData
    ) {
        LockedBalance[] storage locks = userLocks[user];
        uint256 idx;
        for (uint i = 0; i < locks.length; i++) {
            if (locks[i].unlockTime > block.timestamp) {
                if (idx == 0) {
                    lockData = new LockedBalance[](locks.length - i);
                }
                lockData[idx] = locks[i];
                idx++;
                locked = locked.add(locks[i].amount);
            } else {
                unlockable = unlockable.add(locks[i].amount);
            }
        }
        return (balances[user].locked, unlockable, locked, lockData);
    }

    // Final balance received and penalty balance paid by user upon calling exit
    function withdrawableBalance(
        address user
    ) view public returns (
        uint256 amount,
        uint256 penaltyAmount
    ) {
        Balances storage bal = balances[user];
        uint256 earned = bal.earned;
        if (earned > 0) {
            uint256 amountWithoutPenalty;
            uint256 length = userEarnings[user].length;
            for (uint i = 0; i < length; i++) {
                uint256 earnedAmount = userEarnings[user][i].amount;
                if (earnedAmount == 0) continue;
                if (userEarnings[user][i].unlockTime > block.timestamp) {
                    break;
                }
                amountWithoutPenalty = amountWithoutPenalty.add(earnedAmount);
            }

            penaltyAmount = earned.sub(amountWithoutPenalty).div(2);
        }
        amount = bal.unlocked.add(earned).sub(penaltyAmount);
        return (amount, penaltyAmount);
    }

    /* ========== MUTATIVE FUNCTIONS ========== */

    // Stake tokens to receive rewards
    // Locked tokens cannot be withdrawn for lockDuration and are eligible to receive stakingReward rewards
    function stake(uint256 amount, bool lock, address onBehalfOf) external override {
        require(amount > 0, "Cannot stake 0");
        require(lock == true, "Staking disabled");
        _updateReward(onBehalfOf);
        totalSupply = totalSupply.add(amount);
        Balances storage bal = balances[onBehalfOf];
        bal.total = bal.total.add(amount);
        if (lock) {
            lockedSupply = lockedSupply.add(amount);
            bal.locked = bal.locked.add(amount);
            uint256 unlockTime = block.timestamp.div(rewardsDuration).mul(rewardsDuration).add(lockDuration);
            uint256 idx = userLocks[onBehalfOf].length;
            if (idx == 0 || userLocks[onBehalfOf][idx-1].unlockTime < unlockTime) {
                userLocks[onBehalfOf].push(LockedBalance({amount: amount, unlockTime: unlockTime}));
            } else {
                userLocks[onBehalfOf][idx-1].amount = userLocks[onBehalfOf][idx-1].amount.add(amount);
            }
        } else {
            bal.unlocked = bal.unlocked.add(amount);
        }
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        emit Staked(onBehalfOf, amount, lock);
    }

    // Mint new tokens
    // Minted tokens receive rewards normally but incur a 50% penalty when
    // withdrawn before lockDuration has passed.
    function mint(address user, uint256 amount, bool withPenalty) external override {
        require(minters[msg.sender]);
        if (amount == 0) return;
        _updateReward(user);
        stakingToken.mint(address(this), amount);
        if (user == address(this)) {
            // minting to this contract adds the new tokens as incentives for lockers
            _notifyReward(address(stakingToken), amount);
            return;
        }
        totalSupply = totalSupply.add(amount);
        Balances storage bal = balances[user];
        bal.total = bal.total.add(amount);
        if (withPenalty) {
            bal.earned = bal.earned.add(amount);
            uint256 unlockTime = block.timestamp.div(rewardsDuration).mul(rewardsDuration).add(lockDuration);
            LockedBalance[] storage earnings = userEarnings[user];
            uint256 idx = earnings.length;
            if (idx == 0 || earnings[idx-1].unlockTime < unlockTime) {
                earnings.push(LockedBalance({amount: amount, unlockTime: unlockTime}));
            } else {
                earnings[idx-1].amount = earnings[idx-1].amount.add(amount);
            }
        } else {
            bal.unlocked = bal.unlocked.add(amount);
        }
        emit Staked(user, amount, false);
    }

    // Withdraw staked tokens
    // First withdraws unlocked tokens, then earned tokens. Withdrawing earned tokens
    // incurs a 50% penalty which is distributed based on locked balances.
    function withdraw(uint256 amount) public {
        require(amount > 0, "Cannot withdraw 0");
        _updateReward(msg.sender);
        Balances storage bal = balances[msg.sender];
        uint256 penaltyAmount;

        if (amount <= bal.unlocked) {
            bal.unlocked = bal.unlocked.sub(amount);
        } else {
            uint256 remaining = amount.sub(bal.unlocked);
            require(bal.earned >= remaining, "Insufficient unlocked balance");
            bal.unlocked = 0;
            bal.earned = bal.earned.sub(remaining);
            for (uint i = 0; ; i++) {
                uint256 earnedAmount = userEarnings[msg.sender][i].amount;
                if (earnedAmount == 0) continue;
                if (penaltyAmount == 0 && userEarnings[msg.sender][i].unlockTime > block.timestamp) {
                    penaltyAmount = remaining;
                    require(bal.earned >= remaining, "Insufficient balance after penalty");
                    bal.earned = bal.earned.sub(remaining);
                    if (bal.earned == 0) {
                        delete userEarnings[msg.sender];
                        break;
                    }
                    remaining = remaining.mul(2);
                }
                if (remaining <= earnedAmount) {
                    userEarnings[msg.sender][i].amount = earnedAmount.sub(remaining);
                    break;
                } else {
                    delete userEarnings[msg.sender][i];
                    remaining = remaining.sub(earnedAmount);
                }
            }
        }

        uint256 adjustedAmount = amount.add(penaltyAmount);
        bal.total = bal.total.sub(adjustedAmount);
        totalSupply = totalSupply.sub(adjustedAmount);
        stakingToken.safeTransfer(msg.sender, amount);
        if (penaltyAmount > 0) {
            incentivesController.claim(address(this), new address[](0));
            _notifyReward(address(stakingToken), penaltyAmount);
        }
        emit Withdrawn(msg.sender, amount, penaltyAmount);
    }

    function _getReward(address[] memory _rewardTokens) internal {
        uint256 length = _rewardTokens.length;
        for (uint i; i < length; i++) {
            address token = _rewardTokens[i];
            uint256 reward = rewards[msg.sender][token].div(1e12);
            if (token != address(stakingToken)) {
                // for rewards other than stakingToken, every 24 hours we check if new
                // rewards were sent to the contract or accrued via aToken interest
                Reward storage r = rewardData[token];
                uint256 periodFinish = r.periodFinish;
                require(periodFinish > 0, "Unknown reward token");
                uint256 balance = r.balance;
                if (periodFinish < block.timestamp.add(rewardsDuration - rewardLookback)) {
                    uint256 unseen = IERC20(token).balanceOf(address(this)).sub(balance);
                    if (unseen > 0) {
                        _notifyReward(token, unseen);
                        balance = balance.add(unseen);
                    }
                }
                r.balance = balance.sub(reward);
            }
            if (reward == 0) continue;
            rewards[msg.sender][token] = 0;
            IERC20(token).safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, token, reward);
        }
    }

    // Claim all pending staking rewards
    function getReward(address[] memory _rewardTokens) public {
        _updateReward(msg.sender);
        _getReward(_rewardTokens);
    }

    // Delegate exit
    function delegateExit(address delegatee) external {
        exitDelegatee[msg.sender] = delegatee;
    }

    // Withdraw full unlocked balance and optionally claim pending rewards
    function exit(bool claimRewards, address onBehalfOf) external override {
        require(onBehalfOf == msg.sender || exitDelegatee[onBehalfOf] == msg.sender);
        _updateReward(onBehalfOf);
        (uint256 amount, uint256 penaltyAmount) = withdrawableBalance(onBehalfOf);
        delete userEarnings[onBehalfOf];
        Balances storage bal = balances[onBehalfOf];
        bal.total = bal.total.sub(bal.unlocked).sub(bal.earned);
        bal.unlocked = 0;
        bal.earned = 0;

        totalSupply = totalSupply.sub(amount.add(penaltyAmount));
        stakingToken.safeTransfer(onBehalfOf, amount);
        if (penaltyAmount > 0) {
            incentivesController.claim(address(this), new address[](0));
            _notifyReward(address(stakingToken), penaltyAmount);
        }
        if (claimRewards) {
            _getReward(rewardTokens);
        }
        emit Withdrawn(onBehalfOf, amount, penaltyAmount);
    }

    // Withdraw all currently locked tokens where the unlock time has passed
    function withdrawExpiredLocks() external {
        _updateReward(msg.sender);
        LockedBalance[] storage locks = userLocks[msg.sender];
        Balances storage bal = balances[msg.sender];
        uint256 amount;
        uint256 length = locks.length;
        if (locks[length-1].unlockTime <= block.timestamp) {
            amount = bal.locked;
            delete userLocks[msg.sender];
        } else {
            for (uint i = 0; i < length; i++) {
                if (locks[i].unlockTime > block.timestamp) break;
                amount = amount.add(locks[i].amount);
                delete locks[i];
            }
        }
        bal.locked = bal.locked.sub(amount);
        bal.total = bal.total.sub(amount);
        totalSupply = totalSupply.sub(amount);
        lockedSupply = lockedSupply.sub(amount);
        stakingToken.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount, 0);
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    function _notifyReward(address _rewardsToken, uint256 reward) internal {
        Reward storage r = rewardData[_rewardsToken];
        if (block.timestamp >= r.periodFinish) {
            r.rewardRate = reward.mul(1e12).div(rewardsDuration);
        } else {
            uint256 remaining = r.periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(r.rewardRate).div(1e12);
            r.rewardRate = reward.add(leftover).mul(1e12).div(rewardsDuration);
        }

        r.lastUpdateTime = block.timestamp;
        r.periodFinish = block.timestamp.add(rewardsDuration);

    }

    // Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
    function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
        require(tokenAddress != address(stakingToken), "Cannot withdraw staking token");
        require(rewardData[tokenAddress].lastUpdateTime == 0, "Cannot withdraw reward token");
        IERC20(tokenAddress).safeTransfer(owner(), tokenAmount);
        emit Recovered(tokenAddress, tokenAmount);
    }

    function _updateReward(address account) internal {
        address token = address(stakingToken);
        uint256 balance;
        Reward storage r = rewardData[token];
        uint256 rpt = _rewardPerToken(token, lockedSupply);
        r.rewardPerTokenStored = rpt;
        r.lastUpdateTime = lastTimeRewardApplicable(token);
        if (account != address(this)) {
            // Special case, use the locked balances and supply for stakingReward rewards
            rewards[account][token] = _earned(account, token, balances[account].locked, rpt);
            userRewardPerTokenPaid[account][token] = rpt;
            balance = balances[account].total;
        }

        uint256 supply = totalSupply;
        uint256 length = rewardTokens.length;
        for (uint i = 1; i < length; i++) {
            token = rewardTokens[i];
            r = rewardData[token];
            rpt = _rewardPerToken(token, supply);
            r.rewardPerTokenStored = rpt;
            r.lastUpdateTime = lastTimeRewardApplicable(token);
            if (account != address(this)) {
                rewards[account][token] = _earned(account, token, balance, rpt);
                userRewardPerTokenPaid[account][token] = rpt;
            }
        }
    }

    /* ========== EVENTS ========== */

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount, bool locked);
    event Withdrawn(address indexed user, uint256 receivedAmount, uint256 penaltyPaid);
    event RewardPaid(address indexed user, address indexed rewardsToken, uint256 reward);
    event RewardsDurationUpdated(address token, uint256 newDuration);
    event Recovered(address token, uint256 amount);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stakingToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"rewardsToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"RewardsDurationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"locked","type":"bool"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"receivedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"penaltyPaid","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"address","name":"_rewardsToken","type":"address"}],"name":"addReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimableRewards","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct MultiFeeDistribution.RewardData[]","name":"claimRewards","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegateExit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"earnedBalances","outputs":[{"internalType":"uint256","name":"total","type":"uint256"},{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"}],"internalType":"struct MultiFeeDistribution.LockedBalance[]","name":"earningsData","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"claimRewards","type":"bool"},{"internalType":"address","name":"onBehalfOf","type":"address"}],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"exitDelegatee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_rewardTokens","type":"address[]"}],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsToken","type":"address"}],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"incentivesController","outputs":[{"internalType":"contract IChefIncentivesController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsToken","type":"address"}],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"lockedBalances","outputs":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"unlockable","type":"uint256"},{"internalType":"uint256","name":"locked","type":"uint256"},{"components":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"}],"internalType":"struct MultiFeeDistribution.LockedBalance[]","name":"lockData","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"withPenalty","type":"bool"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintersAreSet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardData","outputs":[{"internalType":"uint256","name":"periodFinish","type":"uint256"},{"internalType":"uint256","name":"rewardRate","type":"uint256"},{"internalType":"uint256","name":"lastUpdateTime","type":"uint256"},{"internalType":"uint256","name":"rewardPerTokenStored","type":"uint256"},{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardLookback","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardsToken","type":"address"}],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IChefIncentivesController","name":"_controller","type":"address"}],"name":"setIncentivesController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_minters","type":"address[]"}],"name":"setMinters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"lock","type":"bool"},{"internalType":"address","name":"onBehalfOf","type":"address"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IMintableToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"totalBalance","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"unlockedBalance","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawExpiredLocks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"withdrawableBalance","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"penaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000680693effc3e8f61dabfb00150e8120682360a13

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x680693EFFC3E8F61dAbFb00150e8120682360A13

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000680693effc3e8f61dabfb00150e8120682360a13

31564:21172:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39946:938;;;;;;:::i;:::-;;:::i;:::-;;;;715:25:1;;;771:2;756:18;;749:34;;;;688:18;39946:938:0;;;;;;;;47638:106;;;;;;:::i;:::-;47713:10;47699:25;;;;:13;:25;;;;;:37;;-1:-1:-1;;;;;;47699:37:0;-1:-1:-1;;;;;47699:37:0;;;;;;;;;;47638:106;;;32890:58;;;:::i;:::-;;;940:25:1;;;928:2;913:18;32890:58:0;794:177:1;39028:828:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;33295:26::-;;;;;;43953:2082;;;;;;:::i;:::-;;:::i;41095:1197::-;;;;;;:::i;:::-;;:::i;32696:47::-;;32738:5;32696:47;;32595:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3094:25:1;;;3150:2;3135:18;;3128:34;;;;3178:18;;;3171:34;;;;3236:2;3221:18;;3214:34;3279:3;3264:19;;3257:35;3081:3;3066:19;32595:44:0;2835:463:1;34185:242:0;;;;;;:::i;:::-;;:::i;37708:442::-;;;;;;:::i;:::-;;:::i;35921:245::-;;;;;;:::i;:::-;;:::i;37498:121::-;;;;;;:::i;:::-;-1:-1:-1;;;;;37591:14:0;37557;37591;;;:8;:14;;;;;:20;;37498:121;33140:77;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;2849:103;;;:::i;47828:949::-;;;;;;:::i;:::-;;:::i;32508:44::-;;;;;;;;-1:-1:-1;;;;;5528:32:1;;;5510:51;;5498:2;5483:18;32508:44:0;5341:226:1;32559:29:0;;;;;;:::i;:::-;;:::i;47470:138::-;;;;;;:::i;:::-;;:::i;50605:396::-;;;;;;:::i;:::-;;:::i;33583:48::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;33583:48:0;;;2201:87;2247:7;2274:6;-1:-1:-1;;;;;2274:6:0;2201:87;;33067:25;;;;;;;;;;;;6265:14:1;;6258:22;6240:41;;6228:2;6213:18;33067:25:0;6100:187:1;34647:322:0;;;;;;:::i;:::-;;:::i;48863:948::-;;;:::i;32448:53::-;;;;;-1:-1:-1;;;;;32448:53:0;;;36422:178;;;;;;:::i;:::-;;:::i;33328:27::-;;;;;;42450:1301;;;;;;:::i;:::-;;:::i;36688:720::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;38284:688::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;34435:144::-;;;;;;:::i;:::-;;:::i;33224:62::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;36174:240;;;;;;:::i;:::-;;:::i;3107:201::-;;;;;;:::i;:::-;;:::i;33021:39::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;39946:938;-1:-1:-1;;;;;40124:14:0;;40036;40124;;;:8;:14;;;;;40166:10;;;;40036:14;;40124;40191:10;;40187:586;;-1:-1:-1;;;;;40278:18:0;;40218:28;40278:18;;;:12;:18;;;;;:25;40218:28;40318:372;40339:6;40335:1;:10;40318:372;;;-1:-1:-1;;;;;40394:18:0;;40371:20;40394:18;;;:12;:18;;;;;:21;;40413:1;;40394:21;;;;;;:::i;:::-;;;;;;;;;;;:28;;;40371:51;;40445:12;40461:1;40445:17;40441:31;;40464:8;;;40441:31;-1:-1:-1;;;;;40495:18:0;;;;;;:12;:18;;;;;:21;;40530:15;;40495:18;40514:1;;40495:21;;;;;;:::i;:::-;;;;;;;;;;;:32;;;:50;40491:104;;;40570:5;;;40491:104;40636:38;:20;40661:12;40636:24;:38::i;:::-;40613:61;;40352:338;40318:372;40347:3;;;;:::i;:::-;;;;40318:372;;;-1:-1:-1;40722:39:0;40759:1;40722:32;:6;40733:20;40722:10;:32::i;:::-;:36;;:39::i;:::-;40706:55;;40203:570;;40187:586;40792:43;40821:13;40792:24;40809:6;40792:3;:12;;;:16;;:24;;;;:::i;:::-;:28;;:43::i;:::-;40783:52;;40846:30;;39946:938;;;:::o;32890:58::-;32929:19;32738:5;32947:1;32929:19;:::i;:::-;32890:58;:::o;39028:828::-;-1:-1:-1;;;;;39275:15:0;;39115:13;39275:15;;;:9;:15;;;;;39115:13;;;;39193:31;;39115:13;;39323:455;39344:12;;39340:16;;39323:455;;;39404:15;39382:5;39388:1;39382:8;;;;;;;;:::i;:::-;;;;;;;;;;;:19;;;:37;39378:389;;;39444:3;39451:1;39444:8;39440:105;;39508:12;;:16;;39523:1;;39508:16;:::i;:::-;39488:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;39488:37:0;;;;;;;;;;;;;;;;39477:48;;39440:105;39579:5;39585:1;39579:8;;;;;;;;:::i;:::-;;;;;;;;;;;39563:24;;;;;;;;;;;;;;;;;;;;;;;;;:8;39572:3;39563:13;;;;;;;;:::i;:::-;;;;;;:24;;;;39606:5;;;;;:::i;:::-;;;;39639:27;39650:5;39656:1;39650:8;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:15;39639:6;;:10;:27::i;:::-;39630:36;;39378:389;;;39720:31;39735:5;39741:1;39735:8;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:15;39720:10;;:14;:31::i;:::-;39707:44;;39378:389;39358:3;;;;:::i;:::-;;;;39323:455;;;-1:-1:-1;;;;;;;;39796:14:0;;;;;;:8;:14;;;;;:21;;;;-1:-1:-1;39028:828:0;;;;;:::o;43953:2082::-;44022:1;44013:6;:10;44005:40;;;;-1:-1:-1;;;44005:40:0;;9424:2:1;44005:40:0;;;9406:21:1;9463:2;9443:18;;;9436:30;-1:-1:-1;;;9482:18:1;;;9475:47;9539:18;;44005:40:0;;;;;;;;;44056:25;44070:10;44056:13;:25::i;:::-;44124:10;44092:20;44115;;;:8;:20;;;;;44194:12;;;;44115:20;;44092;44184:22;;44180:1376;;44238:12;;;;:24;;44255:6;44238:16;:24::i;:::-;44223:12;;;:39;44180:1376;;;44295:17;44315:24;44326:3;:12;;;44315:6;:10;;:24;;;;:::i;:::-;44295:44;;44376:9;44362:3;:10;;;:23;;44354:65;;;;-1:-1:-1;;;44354:65:0;;9770:2:1;44354:65:0;;;9752:21:1;9809:2;9789:18;;;9782:30;9848:31;9828:18;;;9821:59;9897:18;;44354:65:0;9568:353:1;44354:65:0;44449:1;44434:12;;;:16;44478:10;;;;:25;;44493:9;44478:14;:25::i;:::-;44465:10;;;:38;44523:6;44518:1027;44597:10;44561:20;44584:24;;;:12;:24;;;;;:27;;44609:1;;44584:27;;;;;;:::i;:::-;;;;;;;;;;;:34;;;44561:57;;44641:12;44657:1;44641:17;44637:31;;44660:8;;;44637:31;44691:18;;:78;;;;-1:-1:-1;44726:10:0;44713:24;;;;:12;:24;;;;;:27;;44754:15;;44713:24;44738:1;;44713:27;;;;;;:::i;:::-;;;;;;;;;;;:38;;;:56;44691:78;44687:514;;;44810:9;44794:25;;44864:9;44850:3;:10;;;:23;;44842:70;;;;-1:-1:-1;;;44842:70:0;;10128:2:1;44842:70:0;;;10110:21:1;10167:2;10147:18;;;10140:30;10206:34;10186:18;;;10179:62;-1:-1:-1;;;10257:18:1;;;10250:32;10299:19;;44842:70:0;9926:398:1;44842:70:0;44948:10;;;;:25;;44963:9;44948:14;:25::i;:::-;44935:10;;;:38;;;45014:1;45000:15;44996:135;;45064:10;45051:24;;;;:12;:24;;;;;45044:31;;;:::i;:::-;45102:5;;;44996:135;45165:16;:9;45179:1;45165:13;:16::i;:::-;45153:28;;44687:514;45236:12;45223:9;:25;45219:311;;45310:27;:12;45327:9;45310:16;:27::i;:::-;45286:10;45273:24;;;;:12;:24;;;;;:27;;45298:1;;45273:27;;;;;;:::i;:::-;;;;;;;;;;;;;;:64;-1:-1:-1;45360:5:0;;45219:311;45434:10;45421:24;;;;:12;:24;;;;;:27;;45446:1;;45421:27;;;;;;:::i;:::-;;;;;;;;;;;;;45414:34;;;;;;45483:27;:9;45497:12;45483:13;:27::i;:::-;45471:39;;44542:1003;44518:1027;44537:3;;;;:::i;:::-;;;;44518:1027;;;;44280:1276;44180:1376;45568:22;45593:25;:6;45604:13;45593:10;:25::i;:::-;45641:9;;45568:50;;-1:-1:-1;45641:29:0;;45568:50;45641:13;:29::i;:::-;45629:41;;45695:11;;:31;;45711:14;45695:15;:31::i;:::-;45681:11;:45;45737;-1:-1:-1;;;;;45737:12:0;:25;45763:10;45775:6;45737:25;:45::i;:::-;45797:17;;45793:175;;45831:20;;-1:-1:-1;;;;;45831:20:0;:26;45866:4;45831:20;45873:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45873:16:0;;45831:59;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45905:51;45927:12;45942:13;45905;:51::i;:::-;45983:44;;;715:25:1;;;771:2;756:18;;749:34;;;45993:10:0;;45983:44;;688:18:1;45983:44:0;;;;;;;;43994:2041;;;43953:2082;:::o;41095:1197::-;41203:1;41194:6;:10;41186:37;;;;-1:-1:-1;;;41186:37:0;;11295:2:1;41186:37:0;;;11277:21:1;11334:2;11314:18;;;11307:30;-1:-1:-1;;;11353:18:1;;;11346:44;11407:18;;41186:37:0;11093:338:1;41186:37:0;41250:4;41242:12;;;;41234:41;;;;-1:-1:-1;;;41234:41:0;;11638:2:1;41234:41:0;;;11620:21:1;11677:2;11657:18;;;11650:30;-1:-1:-1;;;11696:18:1;;;11689:46;11752:18;;41234:41:0;11436:340:1;41234:41:0;41286:25;41300:10;41286:13;:25::i;:::-;41336:11;;:23;;41352:6;41336:15;:23::i;:::-;41322:11;:37;-1:-1:-1;;;;;41393:20:0;;41370;41393;;;:8;:20;;;;;41436:9;;:21;;41450:6;41436:13;:21::i;:::-;41424:33;;41468:694;;;;41508:12;;:24;;41525:6;41508:16;:24::i;:::-;41493:12;:39;41560:10;;;;:22;;41575:6;41560:14;:22::i;:::-;41547:10;;;:35;41597:18;41618:75;32929:19;32738:5;32947:1;32929:19;:::i;:::-;41618:57;32738:5;41618:36;:15;32738:5;41618:19;:36::i;:::-;:40;;:57::i;:::-;:61;;:75::i;:::-;-1:-1:-1;;;;;41722:21:0;;41708:11;41722:21;;;:9;:21;;;;;:28;41597:96;;-1:-1:-1;41769:8:0;;;:64;;-1:-1:-1;;;;;;41781:21:0;;;;;;:9;:21;;;;;41823:10;;41803:5;41807:1;41803:3;:5;:::i;:::-;41781:28;;;;;;;;:::i;:::-;;;;;;;;;;;:39;;;:52;41769:64;41765:314;;;-1:-1:-1;;;;;41854:21:0;;;;;;:9;:21;;;;;;;;41881:55;;;;;;;;;;;;;;;;;41854:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41765:314;;;-1:-1:-1;;;;;42016:21:0;;;;;;:9;:21;;;;;:47;;42056:6;;42038:5;42042:1;42038:3;:5;:::i;:::-;42016:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:35;;:39;:47::i;:::-;-1:-1:-1;;;;;41978:21:0;;;;;;:9;:21;;;;;42000:5;42004:1;42000:3;:5;:::i;:::-;41978:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:85;41765:314;41478:612;;41468:694;;;42126:12;;;;:24;;42143:6;42126:16;:24::i;:::-;42111:12;;;:39;41468:694;42172:64;-1:-1:-1;;;;;42172:12:0;:29;42202:10;42222:4;42229:6;42172:29;:64::i;:::-;42252:32;;;11949:25:1;;;12017:14;;12010:22;12005:2;11990:18;;11983:50;-1:-1:-1;;;;;42252:32:0;;;;;11922:18:1;42252:32:0;11781:258:1;34185:242:0;2087:13;:11;:13::i;:::-;34271::::1;::::0;::::1;;34270:14;34262:23;;;::::0;::::1;;34301:6;34296:93;34313:8;:15;34309:1;:19;34296:93;;;34373:4;34350:7;:20;34358:8;34367:1;34358:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;34350:20:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;34350:20:0;:27;;-1:-1:-1;;34350:27:0::1;::::0;::::1;;::::0;;;::::1;::::0;;34330:3;::::1;::::0;::::1;:::i;:::-;;;;34296:93;;;-1:-1:-1::0;;34399:13:0::1;:20:::0;;-1:-1:-1;;34399:20:0::1;34415:4;34399:20;::::0;;34185:242::o;37708:442::-;-1:-1:-1;;;;;37806:14:0;;37770;37806;;;:8;:14;;;;;;;;:23;;;37888:10;37875:24;;:12;:24;;;;;37806:23;;37910:209;37931:15;;37927:19;;37910:209;;;37997:15;37972:8;37981:1;37972:11;;;;;;;;:::i;:::-;;;;;;;;;;;:22;;;:40;38033:5;37968:86;38077:30;38088:8;38097:1;38088:11;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:18;38077:6;;:10;:30::i;:::-;38068:39;-1:-1:-1;37948:3:0;;;;:::i;:::-;;;;37910:209;;;;38129:13;37708:442;;;:::o;35921:245::-;-1:-1:-1;;;;;36039:25:0;;35999:7;36039:25;;;:10;:25;;;;;:38;36095:15;:30;-1:-1:-1;36095:63:0;;36146:12;36095:63;;;36128:15;36095:63;36088:70;35921:245;-1:-1:-1;;;35921:245:0:o;2849:103::-;2087:13;:11;:13::i;:::-;2914:30:::1;2941:1;2914:18;:30::i;:::-;2849:103::o:0;47828:949::-;-1:-1:-1;;;;;47918:24:0;;47932:10;47918:24;;:67;;-1:-1:-1;;;;;;47946:25:0;;;;;;;:13;:25;;;;;;;47975:10;47946:39;47918:67;47910:76;;;;;;47997:25;48011:10;47997:13;:25::i;:::-;48034:14;48050:21;48075:31;48095:10;48075:19;:31::i;:::-;-1:-1:-1;;;;;48124:24:0;;;;;;:12;:24;;;;;48033:73;;-1:-1:-1;48033:73:0;;-1:-1:-1;48117:31:0;;48124:24;48117:31;:::i;:::-;-1:-1:-1;;;;;48182:20:0;;48159;48182;;;:8;:20;;;;;48257:10;;;;48239:12;;;;48225:9;;:43;;48257:10;48225:27;;:9;:13;:27::i;:43::-;48213:55;;:9;48279:12;;;:16;;;48306:10;;;:14;48347:42;48363:25;:6;48374:13;48363:10;:25::i;:::-;48347:11;;;:15;:42::i;:::-;48333:11;:56;48400:45;-1:-1:-1;;;;;48400:12:0;:25;48426:10;48438:6;48400:25;:45::i;:::-;48460:17;;48456:175;;48494:20;;-1:-1:-1;;;;;48494:20:0;:26;48529:4;48494:20;48536:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48536:16:0;;48494:59;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48568:51;48590:12;48605:13;48568;:51::i;:::-;48645:12;48641:69;;;48674:24;48685:12;48674:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48674:24:0;;;;;;;;;;;;;;;;;;;;;:10;:24::i;:::-;48725:44;;;715:25:1;;;771:2;756:18;;749:34;;;-1:-1:-1;;;;;48725:44:0;;;;;688:18:1;48725:44:0;;;;;;;47899:878;;;47828:949;;:::o;32559:29::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;32559:29:0;;-1:-1:-1;32559:29:0;:::o;47470:138::-;47539:25;47553:10;47539:13;:25::i;:::-;47575;47586:13;47575:10;:25::i;:::-;47470:138;:::o;50605:396::-;2087:13;:11;:13::i;:::-;50732:12:::1;-1:-1:-1::0;;;;;50708:37:0::1;:12;-1:-1:-1::0;;;;;50708:37:0::1;::::0;50700:79:::1;;;::::0;-1:-1:-1;;;50700:79:0;;12246:2:1;50700:79:0::1;::::0;::::1;12228:21:1::0;12285:2;12265:18;;;12258:30;12324:31;12304:18;;;12297:59;12373:18;;50700:79:0::1;12044:353:1::0;50700:79:0::1;-1:-1:-1::0;;;;;50798:24:0;::::1;;::::0;;;:10:::1;:24;::::0;;;;:39:::1;;::::0;:44;50790:85:::1;;;::::0;-1:-1:-1;;;50790:85:0;;12604:2:1;50790:85:0::1;::::0;::::1;12586:21:1::0;12643:2;12623:18;;;12616:30;12682;12662:18;;;12655:58;12730:18;;50790:85:0::1;12402:352:1::0;50790:85:0::1;50886:55;50920:7;2247::::0;2274:6;-1:-1:-1;;;;;2274:6:0;;2201:87;50920:7:::1;-1:-1:-1::0;;;;;50886:33:0;::::1;::::0;50929:11;50886:33:::1;:55::i;:::-;50957:36;::::0;;-1:-1:-1;;;;;12951:32:1;;12933:51;;13015:2;13000:18;;12993:34;;;50957:36:0::1;::::0;12906:18:1;50957:36:0::1;;;;;;;50605:396:::0;;:::o;34647:322::-;2087:13;:11;:13::i;:::-;-1:-1:-1;;;;;34736:25:0;::::1;;::::0;;;:10:::1;:25;::::0;;;;:40:::1;;::::0;:45;34728:54:::1;;;::::0;::::1;;34793:12;:32:::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;;;34793:32:0;;::::1;-1:-1:-1::0;;;;;;34793:32:0;;::::1;::::0;::::1;::::0;;-1:-1:-1;34836:25:0;;;:10:::1;34793:32;34836:25:::0;;;;;34879:15:::1;34836:40:::0;;::::1;:58:::0;;;34905:56;34647:322::o;48863:948::-;48915:25;48929:10;48915:13;:25::i;:::-;48993:10;48951:29;48983:21;;;:9;:21;;;;;;;;49038:8;:20;;;;;49111:12;;48983:21;;49038:20;;49168:15;48983:21;49144:8;49151:1;49111:12;49144:8;:::i;:::-;49138:15;;;;;;;;:::i;:::-;;;;;;;;;;;:26;;;:45;49134:378;;49209:10;;;;49251;49241:21;;;;:9;:21;;;;;49209:10;;-1:-1:-1;49234:28:0;;49241:21;49234:28;:::i;:::-;49134:378;;;49300:6;49295:206;49316:6;49312:1;:10;49295:206;;;49374:15;49352:5;49358:1;49352:8;;;;;;;;:::i;:::-;;;;;;;;;;;:19;;;:37;49391:5;49348:48;49424:27;49435:5;49441:1;49435:8;;;;;;;;:::i;49424:27::-;49415:36;;49477:5;49483:1;49477:8;;;;;;;;:::i;:::-;;;;;;;;;;;;;49470:15;;;;;;49324:3;;;;:::i;:::-;;;;49295:206;;;;49134:378;49535:10;;;;:22;;49550:6;49535:14;:22::i;:::-;49522:10;;;:35;49580:9;;:21;;49594:6;49580:13;:21::i;:::-;49568:33;;49626:11;;:23;;49642:6;49626:15;:23::i;:::-;49612:11;:37;49675:12;;:24;;49692:6;49675:16;:24::i;:::-;49660:12;:39;49710:45;-1:-1:-1;;;;;49710:12:0;:25;49736:10;49748:6;49710:25;:45::i;:::-;49771:32;;;715:25:1;;;49801:1:0;771:2:1;756:18;;749:34;49781:10:0;;49771:32;;688:18:1;49771:32:0;541:248:1;36422:178:0;-1:-1:-1;;;;;36525:25:0;;36498:7;36525:25;;;:10;:25;;;;;:36;;;:67;;36587:4;;36525:57;;32738:5;36525:40;:57::i;:67::-;36518:74;36422:178;-1:-1:-1;;36422:178:0:o;42450:1301::-;42557:10;42549:19;;;;:7;:19;;;;;;;;42541:28;;;;;;42584:6;42594:1;42584:11;42580:24;;42450:1301;;;:::o;42580:24::-;42614:19;42628:4;42614:13;:19::i;:::-;42644:40;;-1:-1:-1;;;42644:40:0;;42670:4;42644:40;;;12933:51:1;13000:18;;;12993:34;;;42644:12:0;-1:-1:-1;;;;;42644:17:0;;;;12906:18:1;;42644:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;42715:4:0;-1:-1:-1;;;;;42699:21:0;;;42695:206;;42824:44;42846:12;42861:6;42824:13;:44::i;:::-;42450:1301;;;:::o;42695:206::-;42925:11;;:23;;42941:6;42925:15;:23::i;:::-;42911:11;:37;-1:-1:-1;;;;;42982:14:0;;42959:20;42982:14;;;:8;:14;;;;;43019:9;;:21;;43033:6;43019:13;:21::i;:::-;43007:33;;43051:650;;;;43096:10;;;;:22;;43111:6;43096:14;:22::i;:::-;43083:10;;;:35;43133:18;43154:75;32929:19;32738:5;32947:1;32929:19;:::i;43154:75::-;-1:-1:-1;;;;;43279:18:0;;43244:32;43279:18;;;:12;:18;;;;;43326:15;;43133:96;;-1:-1:-1;43279:18:0;43360:8;;;:51;;-1:-1:-1;43401:10:0;43372:8;43381:5;43385:1;43381:3;:5;:::i;:::-;43372:15;;;;;;;;:::i;:::-;;;;;;;;;;;:26;;;:39;43360:51;43356:262;;;43446:55;;;;;;;;;;;;;;;;;;;43432:70;;;;;;;;-1:-1:-1;43432:70:0;;;;;;;;;;;;;;;;;;;;;;;43356:262;;;43568:34;43595:6;43568:8;43577:5;43581:1;43577:3;:5;:::i;43568:34::-;43543:8;43552:5;43556:1;43552:3;:5;:::i;:::-;43543:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:59;43356:262;43068:561;;;43051:650;;;43665:12;;;;:24;;43682:6;43665:16;:24::i;:::-;43650:12;;;:39;43051:650;43716:27;;;11949:25:1;;;43737:5:0;12005:2:1;11990:18;;11983:50;-1:-1:-1;;;;;43716:27:0;;;;;11922:18:1;43716:27:0;11781:258:1;36688:720:0;36831:12;:19;36754:32;;36814:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;36814:37:0;;;;;;;;;;;;;;;;36799:52;;36867:9;36862:509;36886:12;:19;36882:1;:23;36862:509;;;37021:15;37039:6;;:59;;-1:-1:-1;;;;;37075:17:0;;;;;;:8;:17;;;;;:23;37039:59;;;-1:-1:-1;;;;;37048:17:0;;;;;;:8;:17;;;;;:24;;;37039:59;37021:77;-1:-1:-1;37113:14:0;37130:6;;:35;;37154:11;;37130:35;;;37139:12;;37130:35;37113:52;;37204:12;37217:1;37204:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37204:15:0;37180:12;37193:1;37180:15;;;;;;;;:::i;:::-;;;;;;;:21;;:39;-1:-1:-1;;;;;37180:39:0;;;-1:-1:-1;;;;;37180:39:0;;;;;37259:100;37354:4;37259:90;37267:7;37276:12;37289:1;37276:15;;;;;;;;:::i;:::-;;;;;;;:21;;;37299:7;37308:40;37324:12;37337:1;37324:15;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;37324:15:0;37341:6;37308:15;:40::i;:::-;37259:7;:90::i;:100::-;37234:12;37247:1;37234:15;;;;;;;;:::i;:::-;;;;;;;:22;;:125;;;;;36912:459;;36907:3;;;;;:::i;:::-;;;;36862:509;;;;36688:720;;;:::o;38284:688::-;-1:-1:-1;;;;;38484:18:0;;38371:13;38484:18;;;:12;:18;;;;;38395:35;;38371:13;;38535:391;38556:15;;38552:19;;38535:391;;;38622:15;38597:8;38606:1;38597:11;;;;;;;;:::i;:::-;;;;;;;;;;;:22;;;:40;38593:322;;;38662:3;38669:1;38662:8;38658:112;;38730:15;;:19;;38748:1;;38730:19;:::i;:::-;38710:40;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;38710:40:0;;;;;;;;;;;;;;;;38695:55;;38658:112;38808:8;38817:1;38808:11;;;;;;;;:::i;:::-;;;;;;;;;;;38788:31;;;;;;;;;;;;;;;;;;;;;;;;;:12;38801:3;38788:17;;;;;;;;:::i;:::-;;;;;;:31;;;;38838:5;;;;;:::i;:::-;;;;38870:29;38880:8;38889:1;38880:11;;;;;;;;:::i;38870:29::-;38862:37;;38593:322;38573:3;;;;:::i;:::-;;;;38535:391;;;;38936:28;;38284:688;;;:::o;34435:144::-;2087:13;:11;:13::i;:::-;34537:20:::1;:34:::0;;-1:-1:-1;;;;;;34537:34:0::1;-1:-1:-1::0;;;;;34537:34:0;;;::::1;::::0;;;::::1;::::0;;34435:144::o;36174:240::-;36244:7;36264:14;36306:12;-1:-1:-1;;;;;36281:38:0;:13;-1:-1:-1;;;;;36281:38:0;;:67;;36337:11;;36281:67;;;36322:12;;36281:67;36264:84;;36366:38;36382:13;36397:6;36366:15;:38::i;3107:201::-;2087:13;:11;:13::i;:::-;-1:-1:-1;;;;;3196:22:0;::::1;3188:73;;;::::0;-1:-1:-1;;;3188:73:0;;13751:2:1;3188:73:0::1;::::0;::::1;13733:21:1::0;13790:2;13770:18;;;13763:30;13829:34;13809:18;;;13802:62;-1:-1:-1;;;13880:18:1;;;13873:36;13926:19;;3188:73:0::1;13549:402:1::0;3188:73:0::1;3272:28;3291:8;3272:18;:28::i;25746:98::-:0;25804:7;25831:5;25835:1;25831;:5;:::i;26127:98::-;26185:7;26212:5;26216:1;26212;:5;:::i;26883:98::-;26941:7;26968:5;26972:1;26968;:5;:::i;51009:1266::-;51093:12;-1:-1:-1;;;;;51162:17:0;;51069:13;51162:17;;;:10;:17;;;;;51227:12;;51069:13;;51204:36;;51093:12;;51204:15;:36::i;:::-;51251:22;;;:28;;;51190:50;-1:-1:-1;51309:31:0;51334:5;51309:24;:31::i;:::-;51290:16;;;:50;-1:-1:-1;;;;;51355:24:0;;51374:4;51355:24;51351:335;;-1:-1:-1;;;;;51537:17:0;;;;;;:8;:17;;;;;:24;;;51513:54;;51521:7;;51530:5;;51563:3;51513:7;:54::i;:::-;-1:-1:-1;;;;;51487:16:0;;;;;;;:7;:16;;;;;;;;:23;;;;;;;;;;;;:80;;;;51582:31;;;:22;:31;;;;;:38;;;;;;;;;:44;;;51651:17;;;:8;:17;;;;:23;;-1:-1:-1;51351:335:0;51715:11;;51754:12;:19;51798:1;51784:484;51805:6;51801:1;:10;51784:484;;;51841:12;51854:1;51841:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;51841:15:0;51875:17;;;:10;:17;;;;;;;51841:15;;-1:-1:-1;51875:17:0;-1:-1:-1;51913:30:0;51841:15;51936:6;51913:15;:30::i;:::-;51958:22;;;:28;;;51907:36;-1:-1:-1;52020:31:0;52045:5;52020:24;:31::i;:::-;52001:16;;;:50;-1:-1:-1;;;;;52070:24:0;;52089:4;52070:24;52066:191;;52141:37;52149:7;52158:5;52165:7;52174:3;52141:7;:37::i;:::-;-1:-1:-1;;;;;52115:16:0;;;;;;;:7;:16;;;;;;;;:23;;;;;;;;;;;;:63;;;;52197:31;;;:22;:31;;;;;:38;;;;;;;:44;;;52066:191;51813:3;;;;:::i;:::-;;;;51784:484;;;;51058:1217;;;;;;51009:1266;:::o;26484:98::-;26542:7;26569:5;26573:1;26569;:5;:::i;19074:211::-;19218:58;;-1:-1:-1;;;;;12951:32:1;;19218:58:0;;;12933:51:1;13000:18;;;12993:34;;;19191:86:0;;19211:5;;-1:-1:-1;;;19241:23:0;12906:18:1;;19218:58:0;;;;-1:-1:-1;;19218:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;19218:58:0;-1:-1:-1;;;;;;19218:58:0;;;;;;;;;;19191:19;:86::i;49875:615::-;-1:-1:-1;;;;;49976:25:0;;49957:16;49976:25;;;:10;:25;;;;;50035:14;;50016:15;:33;50012:358;;50081:37;32738:5;50081:16;:6;50092:4;50081:10;:16::i;:37::-;50066:12;;;:52;50012:358;;;50171:14;;50151:17;;50171:35;;50190:15;50171:18;:35::i;:::-;50151:55;;50221:16;50240:37;50272:4;50240:27;50254:1;:12;;;50240:9;:13;;:27;;;;:::i;:37::-;50221:56;-1:-1:-1;50307:51:0;32738:5;50307:30;50332:4;50307:20;:6;50221:56;50307:10;:20::i;:51::-;50292:12;;;:66;-1:-1:-1;;50012:358:0;50401:15;50382:16;;;:34;;;50444:36;;32738:5;50444:19;:36::i;:::-;50427:53;;-1:-1:-1;;49875:615:0:o;19293:248::-;19464:68;;-1:-1:-1;;;;;14566:15:1;;;19464:68:0;;;14548:34:1;14618:15;;14598:18;;;14591:43;14650:18;;;14643:34;;;19437:96:0;;19457:5;;-1:-1:-1;;;19487:27:0;14483:18:1;;19464:68:0;14308:375:1;19437:96:0;19293:248;;;;:::o;2366:132::-;2247:7;2274:6;-1:-1:-1;;;;;2274:6:0;828:10;2430:23;2422:68;;;;-1:-1:-1;;;2422:68:0;;14890:2:1;2422:68:0;;;14872:21:1;;;14909:18;;;14902:30;14968:34;14948:18;;;14941:62;15020:18;;2422:68:0;14688:356:1;3468:191:0;3542:16;3561:6;;-1:-1:-1;;;;;3578:17:0;;;-1:-1:-1;;;;;;3578:17:0;;;;;;3611:40;;3561:6;;;;;;;3611:40;;3542:16;3611:40;3531:128;3468:191;:::o;46043:1377::-;46132:20;;46115:14;46163:1250;46180:6;46176:1;:10;46163:1250;;;46208:13;46224;46238:1;46224:16;;;;;;;;:::i;:::-;;;;;;;;;;;;46280:10;46255:14;46272:19;;;:7;:19;;;;;;-1:-1:-1;;;;;46272:26:0;;;;;;;;;;;46224:16;;-1:-1:-1;46272:36:0;;46303:4;46272:30;:36::i;:::-;46255:53;;46344:12;-1:-1:-1;;;;;46327:30:0;:5;-1:-1:-1;;;;;46327:30:0;;46323:876;;-1:-1:-1;;;;;46570:17:0;;46551:16;46570:17;;;:10;:17;;;;;46629:14;;46670:16;46662:49;;;;-1:-1:-1;;;46662:49:0;;15251:2:1;46662:49:0;;;15233:21:1;15290:2;15270:18;;;15263:30;-1:-1:-1;;;15309:18:1;;;15302:50;15369:18;;46662:49:0;15049:344:1;46662:49:0;46748:9;;;;46795:53;46815:32;32810:5;;46815:32;:::i;:::-;46795:15;;:19;:53::i;:::-;46780:12;:68;46776:358;;;46890:38;;-1:-1:-1;;;46890:38:0;;46922:4;46890:38;;;5510:51:1;46873:14:0;;46890:51;;46933:7;;-1:-1:-1;;;;;46890:23:0;;;;;5483:18:1;;46890:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:51::-;46873:68;-1:-1:-1;46968:10:0;;46964:151;;47007:28;47021:5;47028:6;47007:13;:28::i;:::-;47072:19;:7;47084:6;47072:11;:19::i;:::-;47062:29;;46964:151;46850:284;46776:358;47164:19;:7;47176:6;47164:11;:19::i;:::-;47152:1;:9;;:31;;;;46359:840;;;46323:876;47217:6;47227:1;47217:11;47213:25;;47230:8;;;;47213:25;47261:10;47282:1;47253:19;;;:7;:19;;;;;;;;-1:-1:-1;;;;;47253:26:0;;;;;;;;;:30;;;;47298:46;;47337:6;47298:26;:46::i;:::-;47364:37;;940:25:1;;;-1:-1:-1;;;;;47364:37:0;;;47375:10;;47364:37;;928:2:1;913:18;47364:37:0;;;;;;;46193:1220;;46163:1250;46188:3;;;;:::i;:::-;;;;46163:1250;;35018:526;35106:7;35130;35141:1;35130:12;35126:98;;-1:-1:-1;;;;;;35166:25:0;;;;;;:10;:25;;;;;;;;:46;;35159:53;;35126:98;-1:-1:-1;;;;;35461:25:0;;;;;;:10;:25;;;;;:36;;;;35389:40;;;;;35254:282;;35323:198;;35513:7;;35323:185;;35503:4;;35323:175;;;;:39;35472:13;35323:24;:39::i;:198::-;-1:-1:-1;;;;;35254:25:0;;;;;;:10;:25;;;;;;;;:46;;;:50;:282::i;35552:361::-;-1:-1:-1;;;;;35875:14:0;;;35723:7;35875:14;;;:7;:14;;;;;;;;:29;;;;;;;;;;;;;35804;;;:22;:29;;;;;:44;;;;;;;;;;35750:155;;35875:29;35750:120;;35865:4;;35750:110;;35777:72;;:22;;:26;:72::i;:::-;35750:8;;:12;:110::i;:155::-;35743:162;;35552:361;;;;;;;:::o;22141:716::-;22565:23;22591:69;22619:4;22591:69;;;;;;;;;;;;;;;;;22599:5;-1:-1:-1;;;;;22591:27:0;;;:69;;;;;:::i;:::-;22675:17;;22565:95;;-1:-1:-1;22675:21:0;22671:179;;22772:10;22761:30;;;;;;;;;;;;:::i;:::-;22753:85;;;;-1:-1:-1;;;22753:85:0;;15789:2:1;22753:85:0;;;15771:21:1;15828:2;15808:18;;;15801:30;15867:34;15847:18;;;15840:62;-1:-1:-1;;;15918:18:1;;;15911:40;15968:19;;22753:85:0;15587:406:1;12918:229:0;13055:12;13087:52;13109:6;13117:4;13123:1;13126:12;13055;14326;14340:23;14367:6;-1:-1:-1;;;;;14367:11:0;14386:5;14393:4;14367:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14325:73;;;;14416:69;14443:6;14451:7;14460:10;14472:12;14416:26;:69::i;:::-;14409:76;14038:455;-1:-1:-1;;;;;;;14038:455:0:o;16611:644::-;16796:12;16825:7;16821:427;;;16853:10;:17;16874:1;16853:22;16849:290;;-1:-1:-1;;;;;10456:19:0;;;17063:60;;;;-1:-1:-1;;;17063:60:0;;17154:2:1;17063:60:0;;;17136:21:1;17193:2;17173:18;;;17166:30;17232:31;17212:18;;;17205:59;17281:18;;17063:60:0;16952:353:1;17063:60:0;-1:-1:-1;17160:10:0;17153:17;;16821:427;17203:33;17211:10;17223:12;17958:17;;:21;17954:388;;18190:10;18184:17;18247:15;18234:10;18230:2;18226:19;18219:44;17954:388;18317:12;18310:20;;-1:-1:-1;;;18310:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:134;218:20;;247:31;218:20;247:31;:::i;:::-;150:134;;;:::o;289:247::-;348:6;401:2;389:9;380:7;376:23;372:32;369:52;;;417:1;414;407:12;369:52;456:9;443:23;475:31;500:5;475:31;:::i;976:535::-;1042:3;1080:5;1074:12;1107:6;1102:3;1095:19;1133:4;1162:2;1157:3;1153:12;1146:19;;1199:2;1192:5;1188:14;1220:1;1230:256;1244:6;1241:1;1238:13;1230:256;;;1303:13;;1341:9;;1329:22;;1391:11;;1385:18;1371:12;;;1364:40;1433:4;1424:14;;;;1461:15;;;;1266:1;1259:9;1230:256;;;-1:-1:-1;1502:3:1;;976:535;-1:-1:-1;;;;;976:535:1:o;1516:551::-;1841:6;1830:9;1823:25;1884:6;1879:2;1868:9;1864:18;1857:34;1927:6;1922:2;1911:9;1907:18;1900:34;1970:3;1965:2;1954:9;1950:18;1943:31;1804:4;1991:70;2056:3;2045:9;2041:19;2033:6;1991:70;:::i;:::-;1983:78;1516:551;-1:-1:-1;;;;;;1516:551:1:o;2072:180::-;2131:6;2184:2;2172:9;2163:7;2159:23;2155:32;2152:52;;;2200:1;2197;2190:12;2152:52;-1:-1:-1;2223:23:1;;2072:180;-1:-1:-1;2072:180:1:o;2257:118::-;2343:5;2336:13;2329:21;2322:5;2319:32;2309:60;;2365:1;2362;2355:12;2380:450;2454:6;2462;2470;2523:2;2511:9;2502:7;2498:23;2494:32;2491:52;;;2539:1;2536;2529:12;2491:52;2575:9;2562:23;2552:33;;2635:2;2624:9;2620:18;2607:32;2648:28;2670:5;2648:28;:::i;:::-;2695:5;-1:-1:-1;2752:2:1;2737:18;;2724:32;2765:33;2724:32;2765:33;:::i;:::-;2817:7;2807:17;;;2380:450;;;;;:::o;3303:127::-;3364:10;3359:3;3355:20;3352:1;3345:31;3395:4;3392:1;3385:15;3419:4;3416:1;3409:15;3435:1121;3519:6;3550:2;3593;3581:9;3572:7;3568:23;3564:32;3561:52;;;3609:1;3606;3599:12;3561:52;3649:9;3636:23;3678:18;3719:2;3711:6;3708:14;3705:34;;;3735:1;3732;3725:12;3705:34;3773:6;3762:9;3758:22;3748:32;;3818:7;3811:4;3807:2;3803:13;3799:27;3789:55;;3840:1;3837;3830:12;3789:55;3876:2;3863:16;3898:2;3894;3891:10;3888:36;;;3904:18;;:::i;:::-;3950:2;3947:1;3943:10;3982:2;3976:9;4045:2;4041:7;4036:2;4032;4028:11;4024:25;4016:6;4012:38;4100:6;4088:10;4085:22;4080:2;4068:10;4065:18;4062:46;4059:72;;;4111:18;;:::i;:::-;4147:2;4140:22;4197:18;;;4231:15;;;;-1:-1:-1;4273:11:1;;;4269:20;;;4301:19;;;4298:39;;;4333:1;4330;4323:12;4298:39;4357:11;;;;4377:148;4393:6;4388:3;4385:15;4377:148;;;4459:23;4478:3;4459:23;:::i;:::-;4447:36;;4410:12;;;;4503;;;;4377:148;;;4544:6;3435:1121;-1:-1:-1;;;;;;;;3435:1121:1:o;4561:388::-;4629:6;4637;4690:2;4678:9;4669:7;4665:23;4661:32;4658:52;;;4706:1;4703;4696:12;4658:52;4745:9;4732:23;4764:31;4789:5;4764:31;:::i;:::-;4814:5;-1:-1:-1;4871:2:1;4856:18;;4843:32;4884:33;4843:32;4884:33;:::i;:::-;4936:7;4926:17;;;4561:388;;;;;:::o;4954:382::-;5019:6;5027;5080:2;5068:9;5059:7;5055:23;5051:32;5048:52;;;5096:1;5093;5086:12;5048:52;5135:9;5122:23;5154:28;5176:5;5154:28;:::i;5780:315::-;5848:6;5856;5909:2;5897:9;5888:7;5884:23;5880:32;5877:52;;;5925:1;5922;5915:12;5877:52;5964:9;5951:23;5983:31;6008:5;5983:31;:::i;:::-;6033:5;6085:2;6070:18;;;;6057:32;;-1:-1:-1;;;5780:315:1:o;6534:450::-;6608:6;6616;6624;6677:2;6665:9;6656:7;6652:23;6648:32;6645:52;;;6693:1;6690;6683:12;6645:52;6732:9;6719:23;6751:31;6776:5;6751:31;:::i;:::-;6801:5;-1:-1:-1;6853:2:1;6838:18;;6825:32;;-1:-1:-1;6909:2:1;6894:18;;6881:32;6922:30;6881:32;6922:30;:::i;6989:820::-;7216:2;7268:21;;;7338:13;;7241:18;;;7360:22;;;7187:4;;7216:2;7401;;7419:18;;;;7460:15;;;7187:4;7503:280;7517:6;7514:1;7511:13;7503:280;;;7576:13;;7618:9;;-1:-1:-1;;;;;7614:35:1;7602:48;;7690:11;;7684:18;7670:12;;;7663:40;7723:12;;;;7758:15;;;;7646:1;7532:9;7503:280;;;-1:-1:-1;7800:3:1;;6989:820;-1:-1:-1;;;;;;;6989:820:1:o;7814:407::-;8083:6;8072:9;8065:25;8126:2;8121;8110:9;8106:18;8099:30;8046:4;8146:69;8211:2;8200:9;8196:18;8188:6;8146:69;:::i;8512:127::-;8573:10;8568:3;8564:20;8561:1;8554:31;8604:4;8601:1;8594:15;8628:4;8625:1;8618:15;8644:127;8705:10;8700:3;8696:20;8693:1;8686:31;8736:4;8733:1;8726:15;8760:4;8757:1;8750:15;8776:135;8815:3;8836:17;;;8833:43;;8856:18;;:::i;:::-;-1:-1:-1;8903:1:1;8892:13;;8776:135::o;8916:168::-;8989:9;;;9020;;9037:15;;;9031:22;;9017:37;9007:71;;9058:18;;:::i;9089:128::-;9156:9;;;9177:11;;;9174:37;;;9191:18;;:::i;10329:759::-;-1:-1:-1;;;;;10615:15:1;;;10597:34;;10547:2;10650;10668:18;;;10661:30;;;10740:13;;10532:18;;;10762:22;;;10499:4;;10841:15;;;;10569:19;;10650:2;10815;10800:18;;;10499:4;10884:178;10898:6;10895:1;10892:13;10884:178;;;10963:13;;10959:22;;10947:35;;11037:15;;;;11002:12;;;;10920:1;10913:9;10884:178;;;-1:-1:-1;11079:3:1;;10329:759;-1:-1:-1;;;;;;;;10329:759:1:o;13299:245::-;13366:6;13419:2;13407:9;13398:7;13394:23;13390:32;13387:52;;;13435:1;13432;13425:12;13387:52;13467:9;13461:16;13486:28;13508:5;13486:28;:::i;13956:125::-;14021:9;;;14042:10;;;14039:36;;;14055:18;;:::i;14086:217::-;14126:1;14152;14142:132;;14196:10;14191:3;14187:20;14184:1;14177:31;14231:4;14228:1;14221:15;14259:4;14256:1;14249:15;14142:132;-1:-1:-1;14288:9:1;;14086:217::o;15398:184::-;15468:6;15521:2;15509:9;15500:7;15496:23;15492:32;15489:52;;;15537:1;15534;15527:12;15489:52;-1:-1:-1;15560:16:1;;15398:184;-1:-1:-1;15398:184:1:o;16405:250::-;16490:1;16500:113;16514:6;16511:1;16508:13;16500:113;;;16590:11;;;16584:18;16571:11;;;16564:39;16536:2;16529:10;16500:113;;;-1:-1:-1;;16647:1:1;16629:16;;16622:27;16405:250::o;16660:287::-;16789:3;16827:6;16821:13;16843:66;16902:6;16897:3;16890:4;16882:6;16878:17;16843:66;:::i;:::-;16925:16;;;;;16660:287;-1:-1:-1;;16660:287:1:o;17310:396::-;17459:2;17448:9;17441:21;17422:4;17491:6;17485:13;17534:6;17529:2;17518:9;17514:18;17507:34;17550:79;17622:6;17617:2;17606:9;17602:18;17597:2;17589:6;17585:15;17550:79;:::i;:::-;17690:2;17669:15;-1:-1:-1;;17665:29:1;17650:45;;;;17697:2;17646:54;;17310:396;-1:-1:-1;;17310:396:1:o

ipfs://0ec74f18fe42eb21284701e7c9fc4c99643182b742035c88762a93b6cf96f8bc