Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-06-25
*/

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity =0.8.19 ^0.8.4;

// lib/solady/src/utils/SafeTransferLib.sol

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for gas griefing protection.
/// - For ERC20s, this implementation won't check that a token has code,
/// responsibility is delegated to the caller.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();

    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();

    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();

    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Suggested gas stipend for contract receiving ETH
    /// that disallows any storage writes.
    uint256 internal constant _GAS_STIPEND_NO_STORAGE_WRITES = 2300;

    /// @dev Suggested gas stipend for contract receiving ETH to perform a few
    /// storage reads and writes, but low enough to prevent griefing.
    /// Multiply by a small constant (e.g. 2), if needed.
    uint256 internal constant _GAS_STIPEND_NO_GRIEF = 100000;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ETH OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` (in wei) ETH to `to`.
    /// Reverts upon failure.
    ///
    /// Note: This implementation does NOT protect against gas griefing.
    /// Please use `forceSafeTransferETH` for gas griefing protection.
    function safeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gas(), to, amount, 0, 0, 0, 0)) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gasStipend, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // To coerce gas estimation to provide enough gas for the `create` above.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a gas stipend
    /// equal to `_GAS_STIPEND_NO_GRIEF`. This gas stipend is a reasonable default
    /// for 99% of cases and can be overridden with the three-argument version of this
    /// function if necessary.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount) internal {
        // Manually inlined because the compiler doesn't inline functions with branches.
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(_GAS_STIPEND_NO_GRIEF, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // To coerce gas estimation to provide enough gas for the `create` above.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// Simply use `gasleft()` for `gasStipend` if you don't need a gas stipend.
    ///
    /// Note: Does NOT revert upon failure.
    /// Returns whether the transfer of ETH is successful instead.
    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            success := call(gasStipend, to, amount, 0, 0, 0, 0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC20 OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x0c, 0x23b872dd000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends all of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have their entire balance approved for
    /// the current contract to manage.
    function safeTransferAllFrom(address token, address from, address to)
        internal
        returns (uint256 amount)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x0c, 0x70a08231000000000000000000000000)
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x00, 0x23b872dd)
            // The `amount` argument is already written to the memory word at 0x60.
            amount := mload(0x60)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransfer(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sends all of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransferAll(address token, address to) internal returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
            mstore(0x20, address()) // Store the address of the current contract.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x14, to) // Store the `to` argument.
            // The `amount` argument is already written to the memory word at 0x34.
            amount := mload(0x34)
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// Reverts upon failure.
    function safeApprove(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `approve(address,uint256)`.
            mstore(0x00, 0x095ea7b3000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `ApproveFailed()`.
                mstore(0x00, 0x3e3f8f73)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Returns the amount of ERC20 `token` owned by `account`.
    /// Returns zero if the `token` does not exist.
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, account) // Store the `account` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x00, 0x70a08231000000000000000000000000)
            amount :=
                mul(
                    mload(0x20),
                    and( // The arguments of `and` are evaluated from right to left.
                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                    )
                )
        }
    }
}

// src/base/fee/Recipient.sol

/// @title Recipient - Contract to receive tokens and outsource their management to allowlist.
abstract contract Recipient {
    using SafeTransferLib for address;

    /// @notice Address of the governance contract.
    address public governance;

    /// @notice Address of the future governance contract.
    address public futureGovernance;

    /// @notice Address authorized to call the execute function.
    mapping(address => bool) public isAllowed;

    ////////////////////////////////////////////////////////////////
    /// --- EVENTS & ERRORS
    ///////////////////////////////////////////////////////////////

    /// @notice Event emitted when a new governance is proposed.
    event GovernanceProposed(address indexed newGovernance);

    /// @notice Event emitted when the governance is changed.
    event GovernanceChanged(address indexed newGovernance);

    /// @notice Throws if caller is not the governance.
    error GOVERNANCE();

    /// @notice Throws if caller is not allowed.
    error NOT_ALLOWED();

    /// @notice Throws if the length of the tokens and amounts arrays are not equal.
    error WRONG_LENGTH();

    ////////////////////////////////////////////////////////////////
    /// --- MODIFIERS
    ///////////////////////////////////////////////////////////////

    modifier onlyGovernance() {
        if (msg.sender != governance) revert GOVERNANCE();
        _;
    }

    modifier onlyAllowed() {
        if (!isAllowed[msg.sender]) revert NOT_ALLOWED();
        _;
    }

    constructor(address _governance) {
        governance = _governance;
    }

    ////////////////////////////////////////////////////////////////
    /// --- ADMIN FUNCTIONS
    ///////////////////////////////////////////////////////////////

    /// @notice Allow an address to call the execute function.
    /// @param _address Address to allow.
    function allowAddress(address _address) external onlyGovernance {
        isAllowed[_address] = true;
    }

    /// @notice Disallow an address to call the execute function.
    /// @param _address Address to disallow.
    function disallowAddress(address _address) external onlyGovernance {
        isAllowed[_address] = false;
    }

    /// @notice Transfer the governance to a new address.
    /// @param _governance Address of the new governance.
    function transferGovernance(address _governance) external onlyGovernance {
        emit GovernanceProposed(futureGovernance = _governance);
    }

    /// @notice Accept the governance transfer.
    function acceptGovernance() external {
        if (msg.sender != futureGovernance) revert GOVERNANCE();
        emit GovernanceChanged(governance = msg.sender);
    }

    /// @notice Withdraw ETH or ERC20 tokens from the contract.
    function withdraw(address[] calldata _tokens, uint256[] calldata _amount, address _recipient)
        external
        onlyAllowed
    {
        if (_tokens.length != _amount.length) revert WRONG_LENGTH();

        for (uint256 i = 0; i < _tokens.length; i++) {
            if (_tokens[i] == address(0)) {
                SafeTransferLib.safeTransferETH(_recipient, _amount[i]);
            } else {
                SafeTransferLib.safeTransfer(_tokens[i], _recipient, _amount[i]);
            }
        }
    }

    receive() external payable {}
}

// src/base/fee/LiquidityFeeRecipient.sol

/// @title LiquidityFeeRecipient - Contract to receive Accrued Liquidity Fees to refuel SdToken vote bounties.
contract LiquidityFeeRecipient is Recipient {
    constructor(address _governance) Recipient(_governance) {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"GOVERNANCE","type":"error"},{"inputs":[],"name":"NOT_ALLOWED","type":"error"},{"inputs":[],"name":"WRONG_LENGTH","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newGovernance","type":"address"}],"name":"GovernanceChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newGovernance","type":"address"}],"name":"GovernanceProposed","type":"event"},{"inputs":[],"name":"acceptGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"allowAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"disallowAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"futureGovernance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"transferGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_tokens","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"},{"internalType":"address","name":"_recipient","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000b0552b6860ce5c0202976db056b5e3cc4f9cc765

-----Decoded View---------------
Arg [0] : _governance (address): 0xB0552b6860CE5C0202976Db056b5e3Cc4f9CC765

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000b0552b6860ce5c0202976db056b5e3cc4f9cc765

20816:112:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19176:109;;;;;;;;;;-1:-1:-1;19176:109:0;;;;;:::i;:::-;;:::i;:::-;;19849:169;;;;;;;;;;;;;:::i;20091:524::-;;;;;;;;;;-1:-1:-1;20091:524:0;;;;;:::i;:::-;;:::i;17474:25::-;;;;;;;;;;-1:-1:-1;17474:25:0;;;;-1:-1:-1;;;;;17474:25:0;;;;;;-1:-1:-1;;;;;1771:32:1;;;1753:51;;1741:2;1726:18;17474:25:0;;;;;;;;17568:31;;;;;;;;;;-1:-1:-1;17568:31:0;;;;-1:-1:-1;;;;;17568:31:0;;;19406:113;;;;;;;;;;-1:-1:-1;19406:113:0;;;;;:::i;:::-;;:::i;17674:41::-;;;;;;;;;;-1:-1:-1;17674:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;1980:14:1;;1973:22;1955:41;;1943:2;1928:18;17674:41:0;1815:187:1;19645:147:0;;;;;;;;;;-1:-1:-1;19645:147:0;;;;;:::i;:::-;;:::i;19176:109::-;18646:10;;-1:-1:-1;;;;;18646:10:0;18632;:24;18628:49;;18665:12;;-1:-1:-1;;;18665:12:0;;;;;;;;;;;18628:49;-1:-1:-1;;;;;19251:19:0::1;;::::0;;;:9:::1;:19;::::0;;;;:26;;-1:-1:-1;;19251:26:0::1;19273:4;19251:26;::::0;;19176:109::o;19849:169::-;19915:16;;-1:-1:-1;;;;;19915:16:0;19901:10;:30;19897:55;;19940:12;;-1:-1:-1;;;19940:12:0;;;;;;;;;;;19897:55;19986:10;:23;;-1:-1:-1;;;;;;19986:23:0;19999:10;19986:23;;;;;19968:42;;19999:10;;19968:42;;;19849:169::o;20091:524::-;18754:10;18744:21;;;;:9;:21;;;;;;;;18739:48;;18774:13;;-1:-1:-1;;;18774:13:0;;;;;;;;;;;18739:48;20244:32;;::::1;20240:59;;20285:14;;-1:-1:-1::0;;;20285:14:0::1;;;;;;;;;;;20240:59;20317:9;20312:296;20332:18:::0;;::::1;20312:296;;;20398:1;20376:7:::0;;20384:1;20376:10;;::::1;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;20376:24:0::1;::::0;20372:225:::1;;20421:55;20453:10;20465:7;;20473:1;20465:10;;;;;;;:::i;:::-;;;;;;;20421:31;:55::i;:::-;20372:225;;;20517:64;20546:7;;20554:1;20546:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;20558;20570:7;;20578:1;20570:10;;;;;;;:::i;:::-;;;;;;;20517:28;:64::i;:::-;20352:3:::0;::::1;::::0;::::1;:::i;:::-;;;;20312:296;;;;20091:524:::0;;;;;:::o;19406:113::-;18646:10;;-1:-1:-1;;;;;18646:10:0;18632;:24;18628:49;;18665:12;;-1:-1:-1;;;18665:12:0;;;;;;;;;;;18628:49;-1:-1:-1;;;;;19484:19:0::1;19506:5;19484:19:::0;;;:9:::1;:19;::::0;;;;:27;;-1:-1:-1;;19484:27:0::1;::::0;;19406:113::o;19645:147::-;18646:10;;-1:-1:-1;;;;;18646:10:0;18632;:24;18628:49;;18665:12;;-1:-1:-1;;;18665:12:0;;;;;;;;;;;18628:49;19753:16:::1;:30:::0;;-1:-1:-1;;;;;;19753:30:0::1;-1:-1:-1::0;;;;;19753:30:0;::::1;::::0;;::::1;::::0;;;19734:50:::1;::::0;::::1;::::0;-1:-1:-1;;19734:50:0::1;19645:147:::0;:::o;2572:489::-;2823:1;2820;2817;2814;2806:6;2802:2;2795:5;2790:35;2780:263;;2933:10;2927:4;2920:24;3023:4;3017;3010:18;2780:263;2572:489;;:::o;11702:1213::-;11868:2;11862:4;11855:16;11926:6;11920:4;11913:20;-1:-1:-1;;;12062:4:0;12055:48;12533:4;12527;12521;12515;12512:1;12505:5;12498;12493:45;12452:16;12445:24;12441:1;12434:4;12428:11;12425:18;12422:48;12147:410;12119:667;;12676:10;12670:4;12663:24;12766:4;12760;12753:18;12119:667;12895:1;12889:4;12882:15;11702:1213;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;:::-;333:39;192:186;-1:-1:-1;;;192:186:1:o;383:367::-;446:8;456:6;510:3;503:4;495:6;491:17;487:27;477:55;;528:1;525;518:12;477:55;-1:-1:-1;551:20:1;;594:18;583:30;;580:50;;;626:1;623;616:12;580:50;663:4;655:6;651:17;639:29;;723:3;716:4;706:6;703:1;699:14;691:6;687:27;683:38;680:47;677:67;;;740:1;737;730:12;677:67;383:367;;;;;:::o;755:847::-;886:6;894;902;910;918;971:2;959:9;950:7;946:23;942:32;939:52;;;987:1;984;977:12;939:52;1027:9;1014:23;1056:18;1097:2;1089:6;1086:14;1083:34;;;1113:1;1110;1103:12;1083:34;1152:70;1214:7;1205:6;1194:9;1190:22;1152:70;:::i;:::-;1241:8;;-1:-1:-1;1126:96:1;-1:-1:-1;1329:2:1;1314:18;;1301:32;;-1:-1:-1;1345:16:1;;;1342:36;;;1374:1;1371;1364:12;1342:36;;1413:72;1477:7;1466:8;1455:9;1451:24;1413:72;:::i;:::-;1504:8;;-1:-1:-1;1387:98:1;-1:-1:-1;1558:38:1;;-1:-1:-1;1592:2:1;1577:18;;1558:38;:::i;:::-;1548:48;;755:847;;;;;;;;:::o;2007:127::-;2068:10;2063:3;2059:20;2056:1;2049:31;2099:4;2096:1;2089:15;2123:4;2120:1;2113:15;2139:232;2178:3;2199:17;;;2196:140;;2258:10;2253:3;2249:20;2246:1;2239:31;2293:4;2290:1;2283:15;2321:4;2318:1;2311:15;2196:140;-1:-1:-1;2363:1:1;2352:13;;2139:232::o

ipfs://35fcb53e1cebf9a118c12a37cd6d668beff74ee02fec083da547fb7722579392