Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• library Address
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(bool succes ...
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
• interface IFIREFBX is IERC20
•    - function deposit(uint256 amountFBX)
•    - function withdraw(uint256 amountFireF ...
• interface ITRT is IERC20
•    - function deposit(uint256 assets, addr ...
•    - function redeem(uint256 shares, addre ...
•  contract TransmuterZapper *
•    - function depositFBX(uint256 amountFBX ...
•    - function withdrawFBX(uint256 amountTR ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2024-05-22
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @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.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
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].
     *
     * CAUTION: See Security Considerations above.
     */
    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/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @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);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// File: contracts/FireLabsTransmuter_FBX_FUSD_Zap.sol

pragma solidity ^0.8.25;
/* SPDX-License-Identifier: MIT
  _____ _          _          _         
 |  ___(_)_ __ ___| |    __ _| |__  ___ 
 | |_  | | '__/ _ \ |   / _` | '_ \/ __|
 |  _| | | | |  __/ |__| (_| | |_) \__ \
 |_|   |_|_|  \___|_____\__,_|_.__/|___/
 
 TransmuterZapper v1.2 FBX to FUSD
*/


interface IFIREFBX is IERC20 {
    function deposit(uint256 amountFBX) external returns (uint256 amountFireFBX);
    function withdraw(uint256 amountFireFBX) external returns (uint256 amountFBX);
}

interface ITRT is IERC20 {
    function deposit(uint256 assets, address receiver) external returns(uint256 shares);
    function redeem(uint256 shares, address receiver) external returns(uint256 assets);
}

contract TransmuterZapper {

    constructor() {}

    using SafeERC20 for IERC20;
    using SafeERC20 for ITRT;

    IERC20 public constant FBX = IERC20(0xD125443F38A69d776177c2B9c041f462936F8218);
    IFIREFBX public constant FIREFBX = IFIREFBX(0x960d43BE128585Ca45365CD74a7773B9d814dfBE);
    ITRT public constant TRT = ITRT(0x497407644F721284c05fb3070dbD8C05D892d791); // TRT_FBX_FUSD

    function depositFBX(uint256 amountFBX) external {
        FBX.safeTransferFrom(msg.sender, address(this), amountFBX);
        FBX.approve(address(FIREFBX), amountFBX);
        uint256 amountFireFBX = FIREFBX.deposit(amountFBX);
        FIREFBX.approve(address(TRT), amountFireFBX);
        TRT.deposit(amountFireFBX, msg.sender);
    }

    function withdrawFBX(uint256 amountTRT) external {
        TRT.safeTransferFrom(msg.sender, address(this), amountTRT);
        uint256 amountFireFBX = TRT.redeem(amountTRT, address(this));
        uint256 amountFBX = FIREFBX.withdraw(amountFireFBX);
        FBX.safeTransfer(msg.sender, amountFBX);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"FBX","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FIREFBX","outputs":[{"internalType":"contract IFIREFBX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRT","outputs":[{"internalType":"contract ITRT","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountFBX","type":"uint256"}],"name":"depositFBX","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountTRT","type":"uint256"}],"name":"withdrawFBX","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

19841:1066:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20052:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20595:309;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20146:75;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19966:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20246:341;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20052:87;20096:42;20052:87;:::o;20595:309::-;20655:58;20676:10;20696:4;20703:9;20178:42;20655:20;;;;:58;;;;;;:::i;:::-;20724:21;20178:42;20748:10;;;20759:9;20778:4;20748:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20724:60;;20795:17;20096:42;20815:16;;;20832:13;20815:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20795:51;;20857:39;20874:10;20886:9;20002:42;20857:16;;;;:39;;;;;:::i;:::-;20644:260;;20595:309;:::o;20146:75::-;20178:42;20146:75;:::o;19966:79::-;20002:42;19966:79;:::o;20246:341::-;20305:58;20326:10;20346:4;20353:9;20002:42;20305:20;;;;:58;;;;;;:::i;:::-;20002:42;20374:11;;;20096:42;20404:9;20374:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;20425:21;20096:42;20449:15;;;20465:9;20449:26;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20425:50;;20096:42;20486:15;;;20178:42;20516:13;20486:44;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;20178:42;20541:11;;;20553:13;20568:10;20541:38;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;20294:293;20246:341;:::o;14906:190::-;15007:81;15027:5;15049;:18;;;15070:4;15076:2;15080:5;15034:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15007:19;:81::i;:::-;14906:190;;;;:::o;14499:162::-;14582:71;14602:5;14624;:14;;;14641:2;14645:5;14609:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14582:19;:71::i;:::-;14499:162;;;:::o;17310:638::-;17734:23;17760:33;17788:4;17768:5;17760:27;;;;:33;;;;:::i;:::-;17734:59;;17829:1;17808:10;:17;:22;;:57;;;;;17846:10;17835:30;;;;;;;;;;;;:::i;:::-;17834:31;17808:57;17804:137;;;17922:5;17889:40;;;;;;;;;;;:::i;:::-;;;;;;;;17804:137;17380:568;17310:638;;:::o;2797:153::-;2872:12;2904:38;2926:6;2934:4;2940:1;2904:21;:38::i;:::-;2897:45;;2797:153;;;;:::o;3285:398::-;3384:12;3437:5;3413:21;:29;3409:110;;;3501:4;3466:41;;;;;;;;;;;:::i;:::-;;;;;;;;3409:110;3530:12;3544:23;3571:6;:11;;3590:5;3597:4;3571:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3529:73;;;;3620:55;3647:6;3655:7;3664:10;3620:26;:55::i;:::-;3613:62;;;;3285:398;;;;;:::o;4761:597::-;4909:12;4939:7;4934:417;;4963:19;4971:10;4963:7;:19::i;:::-;4934:417;;;5212:1;5191:10;:17;:22;:49;;;;;5239:1;5217:6;:18;;;:23;5191:49;5187:121;;;5285:6;5268:24;;;;;;;;;;;:::i;:::-;;;;;;;;5187:121;5329:10;5322:17;;;;4934:417;4761:597;;;;;;:::o;5911:528::-;6064:1;6044:10;:17;:21;6040:392;;;6276:10;6270:17;6333:15;6320:10;6316:2;6312:19;6305:44;6040:392;6403:17;;;;;;;;;;;;;;7:126:1;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:60::-;167:3;188:5;181:12;;139:60;;;:::o;205:142::-;255:9;288:53;306:34;315:24;333:5;315:24;:::i;:::-;306:34;:::i;:::-;288:53;:::i;:::-;275:66;;205:142;;;:::o;353:126::-;403:9;436:37;467:5;436:37;:::i;:::-;423:50;;353:126;;;:::o;485:142::-;551:9;584:37;615:5;584:37;:::i;:::-;571:50;;485:142;;;:::o;633:163::-;736:53;783:5;736:53;:::i;:::-;731:3;724:66;633:163;;:::o;802:254::-;911:4;949:2;938:9;934:18;926:26;;962:87;1046:1;1035:9;1031:17;1022:6;962:87;:::i;:::-;802:254;;;;:::o;1143:117::-;1252:1;1249;1242:12;1389:77;1426:7;1455:5;1444:16;;1389:77;;;:::o;1472:122::-;1545:24;1563:5;1545:24;:::i;:::-;1538:5;1535:35;1525:63;;1584:1;1581;1574:12;1525:63;1472:122;:::o;1600:139::-;1646:5;1684:6;1671:20;1662:29;;1700:33;1727:5;1700:33;:::i;:::-;1600:139;;;;:::o;1745:329::-;1804:6;1853:2;1841:9;1832:7;1828:23;1824:32;1821:119;;;1859:79;;:::i;:::-;1821:119;1979:1;2004:53;2049:7;2040:6;2029:9;2025:22;2004:53;:::i;:::-;1994:63;;1950:117;1745:329;;;;:::o;2080:138::-;2142:9;2175:37;2206:5;2175:37;:::i;:::-;2162:50;;2080:138;;;:::o;2224:155::-;2323:49;2366:5;2323:49;:::i;:::-;2318:3;2311:62;2224:155;;:::o;2385:246::-;2490:4;2528:2;2517:9;2513:18;2505:26;;2541:83;2621:1;2610:9;2606:17;2597:6;2541:83;:::i;:::-;2385:246;;;;:::o;2637:140::-;2701:9;2734:37;2765:5;2734:37;:::i;:::-;2721:50;;2637:140;;;:::o;2783:159::-;2884:51;2929:5;2884:51;:::i;:::-;2879:3;2872:64;2783:159;;:::o;2948:250::-;3055:4;3093:2;3082:9;3078:18;3070:26;;3106:85;3188:1;3177:9;3173:17;3164:6;3106:85;:::i;:::-;2948:250;;;;:::o;3204:118::-;3291:24;3309:5;3291:24;:::i;:::-;3286:3;3279:37;3204:118;;:::o;3328:96::-;3365:7;3394:24;3412:5;3394:24;:::i;:::-;3383:35;;3328:96;;;:::o;3430:118::-;3517:24;3535:5;3517:24;:::i;:::-;3512:3;3505:37;3430:118;;:::o;3554:332::-;3675:4;3713:2;3702:9;3698:18;3690:26;;3726:71;3794:1;3783:9;3779:17;3770:6;3726:71;:::i;:::-;3807:72;3875:2;3864:9;3860:18;3851:6;3807:72;:::i;:::-;3554:332;;;;;:::o;3892:143::-;3949:5;3980:6;3974:13;3965:22;;3996:33;4023:5;3996:33;:::i;:::-;3892:143;;;;:::o;4041:351::-;4111:6;4160:2;4148:9;4139:7;4135:23;4131:32;4128:119;;;4166:79;;:::i;:::-;4128:119;4286:1;4311:64;4367:7;4358:6;4347:9;4343:22;4311:64;:::i;:::-;4301:74;;4257:128;4041:351;;;;:::o;4398:222::-;4491:4;4529:2;4518:9;4514:18;4506:26;;4542:71;4610:1;4599:9;4595:17;4586:6;4542:71;:::i;:::-;4398:222;;;;:::o;4626:332::-;4747:4;4785:2;4774:9;4770:18;4762:26;;4798:71;4866:1;4855:9;4851:17;4842:6;4798:71;:::i;:::-;4879:72;4947:2;4936:9;4932:18;4923:6;4879:72;:::i;:::-;4626:332;;;;;:::o;4964:90::-;4998:7;5041:5;5034:13;5027:21;5016:32;;4964:90;;;:::o;5060:116::-;5130:21;5145:5;5130:21;:::i;:::-;5123:5;5120:32;5110:60;;5166:1;5163;5156:12;5110:60;5060:116;:::o;5182:137::-;5236:5;5267:6;5261:13;5252:22;;5283:30;5307:5;5283:30;:::i;:::-;5182:137;;;;:::o;5325:345::-;5392:6;5441:2;5429:9;5420:7;5416:23;5412:32;5409:119;;;5447:79;;:::i;:::-;5409:119;5567:1;5592:61;5645:7;5636:6;5625:9;5621:22;5592:61;:::i;:::-;5582:71;;5538:125;5325:345;;;;:::o;5676:442::-;5825:4;5863:2;5852:9;5848:18;5840:26;;5876:71;5944:1;5933:9;5929:17;5920:6;5876:71;:::i;:::-;5957:72;6025:2;6014:9;6010:18;6001:6;5957:72;:::i;:::-;6039;6107:2;6096:9;6092:18;6083:6;6039:72;:::i;:::-;5676:442;;;;;;:::o;6124:222::-;6217:4;6255:2;6244:9;6240:18;6232:26;;6268:71;6336:1;6325:9;6321:17;6312:6;6268:71;:::i;:::-;6124:222;;;;:::o;6352:98::-;6403:6;6437:5;6431:12;6421:22;;6352:98;;;:::o;6456:147::-;6557:11;6594:3;6579:18;;6456:147;;;;:::o;6609:139::-;6698:6;6693:3;6688;6682:23;6739:1;6730:6;6725:3;6721:16;6714:27;6609:139;;;:::o;6754:386::-;6858:3;6886:38;6918:5;6886:38;:::i;:::-;6940:88;7021:6;7016:3;6940:88;:::i;:::-;6933:95;;7037:65;7095:6;7090:3;7083:4;7076:5;7072:16;7037:65;:::i;:::-;7127:6;7122:3;7118:16;7111:23;;6862:278;6754:386;;;;:::o;7146:271::-;7276:3;7298:93;7387:3;7378:6;7298:93;:::i;:::-;7291:100;;7408:3;7401:10;;7146:271;;;;:::o

ipfs://cdaebf0c9674bc413cf7278eda3833b4217af3e5e4e194edf0d1025fd01f31a2