Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-10-17
*/

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

interface IFraxswapRouterMultihop {

    struct FraxswapParams {
        address tokenIn;
        uint256 amountIn;
        address tokenOut;
        uint256 amountOutMinimum;
        address recipient;
        uint256 deadline;
        bool approveMax;
        uint8 v;
        bytes32 r;
        bytes32 s;
        bytes route;
    }

    function encodeRoute ( address tokenOut, uint256 percentOfHop, bytes[] memory steps, bytes[] memory nextHops ) external pure returns ( bytes memory out );
    function encodeStep ( uint8 swapType, uint8 directFundNextPool, uint8 directFundThisPool, address tokenOut, address pool, uint256 extraParam1, uint256 extraParam2, uint256 percentOfHop ) external pure returns ( bytes memory out );
    function owner (  ) external view returns ( address );
    function renounceOwnership (  ) external;
    function swap ( FraxswapParams memory params ) external returns ( uint256 amountOut );
    function transferOwnership ( address newOwner ) external;
    function uniswapV3SwapCallback ( int256 amount0Delta, int256 amount1Delta, bytes memory _data ) external;
}


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

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

// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}

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

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



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

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

/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */

library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equal_nonAligned(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let endMinusWord := add(_preBytes, length)
                let mc := add(_preBytes, 0x20)
                let cc := add(_postBytes, 0x20)

                for {
                // the next line is the loop condition:
                // while(uint256(mc < endWord) + cb == 2)
                } eq(add(lt(mc, endMinusWord), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }

                // Only if still successful
                // For <1 word tail bytes
                if gt(success, 0) {
                    // Get the remainder of length/32
                    // length % 32 = AND(length, 32 - 1)
                    let numTailBytes := and(length, 0x1f)
                    let mcRem := mload(mc)
                    let ccRem := mload(cc)
                    for {
                        let i := 0
                    // the next line is the loop condition:
                    // while(uint256(i < numTailBytes) + cb == 2)
                    } eq(add(lt(i, numTailBytes), cb), 2) {
                        i := add(i, 1)
                    } {
                        if iszero(eq(byte(i, mcRem), byte(i, ccRem))) {
                            // unsuccess:
                            success := 0
                            cb := 0
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

interface ILlamalendController { 
    function liquidate_extended(address user, uint256 min_x, uint256 frac, address callbacker, uint256[] memory callback_args, bytes memory callback_bytes) external;
}

contract LlamaLiquidation is Ownable {
   address public operator;
   address currentController=address(1);
   IFraxswapRouterMultihop public immutable routerMultihop;
   
   modifier onlyOperator() {
      require(msg.sender==operator);
      _;
   }   

   constructor(address _routerMultihop) Ownable(msg.sender) {
      operator = msg.sender;
      routerMultihop = IFraxswapRouterMultihop(_routerMultihop);
   }
   
   function liquidatePacked(address controller, address user, uint256 fraction, bytes calldata packedData) external returns (uint256) {
      return liquidate(controller, user, fraction, unpackBytes(packedData));
   }
   
   function liquidate(address controller, address user, uint256 fraction, bytes memory data) onlyOperator public returns (uint256) {
       (, address tokenOut,) = abi.decode(data, (address, address, bytes));
       uint balanceBefore = IERC20(tokenOut).balanceOf(address(this));
       currentController = controller;
       uint256[] memory callback_args;
       ILlamalendController(controller).liquidate_extended(user,0,fraction,address(this),callback_args,data);
       currentController = address(1); // Reset to safe gas
       uint balanceAfter = IERC20(tokenOut).balanceOf(address(this));
       SafeERC20.safeTransfer(IERC20(tokenOut), owner(), balanceAfter - balanceBefore);
       return balanceAfter - balanceBefore;
   }
   
   function callback_liquidate(address user, uint256 stablecoins, uint256 collateral ,uint256 debt, uint256[] memory callback_args, bytes memory callback_bytes) external returns (uint256 stablecoinsOut, uint256 collateralOut) {
       require (msg.sender==currentController);
       IFraxswapRouterMultihop.FraxswapParams memory swapParams;
       (swapParams.tokenIn, swapParams.tokenOut, swapParams.route) = abi.decode(callback_bytes, (address, address, bytes));
       // Approve the input token to the router
       SafeERC20.safeIncreaseAllowance({
          token: IERC20(swapParams.tokenIn),
          spender: address(routerMultihop),
          value: collateral
       });
       swapParams.amountIn = collateral;
       swapParams.recipient = address(this); 
       swapParams.amountOutMinimum = debt-stablecoins;
       swapParams.deadline=block.timestamp;
       
       // Execute the swap
       routerMultihop.swap(swapParams);
       stablecoinsOut = debt-stablecoins;
       collateralOut = 0;
       
       // Approve to send back the stablecoins
       SafeERC20.safeIncreaseAllowance({
           token: IERC20(swapParams.tokenOut),
           spender: address(currentController),
           value: debt-stablecoins
       });
   }
   
   function withdrawERC20(IERC20 _token, address _to, uint256 _value) onlyOwner external {
      SafeERC20.safeTransfer(_token, _to, _value);
   }
   
   function withdrawETH(address _to, uint256 _value) onlyOwner external {
      (bool sent,)=_to.call{value: _value}("");
      require(sent, "Failed to send Ether");
   }
    
   function setOperator(address _operator) onlyOwner external {
      operator = _operator;
   }
   
   function packBytes(bytes calldata inBytes) public view returns (bytes memory result) {
      bytes memory temp;
      uint8 countZero;
      for (uint i=0;i<inBytes.length;++i) {
         uint8 b = BytesLib.toUint8(inBytes,i);
         if (b==0) {
            if (temp.length==0) {
               countZero++;
               if (countZero==255) {
                  temp = BytesLib.concat(temp,abi.encodePacked(uint8(0),countZero-1));
                  countZero=0;
               }
            } else {
               result = BytesLib.concat(result,temp);
               temp = "";
               countZero=1;
            }
         } else {
            if (countZero!=0) {
               result = BytesLib.concat(result,abi.encodePacked(uint8(0),countZero-1));
               countZero=0;
            }
            temp = BytesLib.concat(temp,abi.encodePacked(b));
         }
      }
      if (countZero>0) result = BytesLib.concat(result,abi.encodePacked(uint8(0),countZero-1));
      if (temp.length>0) result = BytesLib.concat(result,temp);
   }
   
   function unpackBytes(bytes calldata inBytes) public view returns (bytes memory result) {
         bytes memory temp = new bytes(100000);
         uint counter=0;
         for (uint i=0;i<inBytes.length;++i) {
            uint8 b = uint8(uint256(bytes32(inBytes[i:i+1]))>>248);
            if (b==0) {
               i++;
               uint8 zeroCount = uint8(uint256(bytes32(inBytes[i:i+1]))>>248);
               counter+=zeroCount+1;
            } else {
               assembly { 
                  let offset := add(temp, 0x20)
                  mstore8(add(offset, counter), b)
               }
               counter++;
            }
         }
         result = BytesLib.slice(temp,0,counter);
   }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_routerMultihop","type":"address"}],"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":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"stablecoins","type":"uint256"},{"internalType":"uint256","name":"collateral","type":"uint256"},{"internalType":"uint256","name":"debt","type":"uint256"},{"internalType":"uint256[]","name":"callback_args","type":"uint256[]"},{"internalType":"bytes","name":"callback_bytes","type":"bytes"}],"name":"callback_liquidate","outputs":[{"internalType":"uint256","name":"stablecoinsOut","type":"uint256"},{"internalType":"uint256","name":"collateralOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"fraction","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"liquidate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"fraction","type":"uint256"},{"internalType":"bytes","name":"packedData","type":"bytes"}],"name":"liquidatePacked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"inBytes","type":"bytes"}],"name":"packBytes","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"routerMultihop","outputs":[{"internalType":"contract IFraxswapRouterMultihop","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"inBytes","type":"bytes"}],"name":"unpackBytes","outputs":[{"internalType":"bytes","name":"result","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000046d2487cdbea04411c49e6c55ace805bfa8f5de5

-----Decoded View---------------
Arg [0] : _routerMultihop (address): 0x46D2487CdbeA04411C49e6c55aCE805bfA8f5dE5

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000046d2487cdbea04411c49e6c55ace805bfa8f5de5

43531:4957:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46674:1077;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44196:741;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46232:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46387:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43574:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47761:724;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43645:55;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6668:103;;;:::i;:::-;;44947:1275;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;5993:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46569:95;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43970:216;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6926:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46674:1077;46738:19;46768:17;46794:15;46823:6;46830:1;46823:8;;46818:765;46834:7;;:14;;46832:1;:16;46818:765;;;46866:7;46876:27;46893:7;;46876:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46901:1;46876:16;:27::i;:::-;46866:37;;46922:1;46919;:4;;;46915:659;;46957:1;46944:4;:11;:14;46940:374;;46978:11;;;;;:::i;:::-;;;;47022:3;47011:9;:14;;;47007:159;;47055:60;47071:4;47099:1;47112;47102:9;:11;;;;:::i;:::-;47076:38;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47055:15;:60::i;:::-;47048:67;;47146:1;47136:11;;47007:159;46940:374;;;47214:28;47230:6;47237:4;47214:15;:28::i;:::-;47205:37;;47260:9;;;;;;;;;;;;;;47297:1;47287:11;;46940:374;46915:659;;;47362:1;47351:9;:12;;;47347:152;;47392:62;47408:6;47438:1;47451;47441:9;:11;;;;:::i;:::-;47415:38;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47392:15;:62::i;:::-;47383:71;;47482:1;47472:11;;47347:152;47520:41;47536:4;47558:1;47541:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;47520:15;:41::i;:::-;47513:48;;46915:659;46854:729;46849:3;;;;;46818:765;;;;47605:1;47595:9;:11;;;47591:88;;;47617:62;47633:6;47663:1;47676;47666:9;:11;;;;:::i;:::-;47640:38;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47617:15;:62::i;:::-;47608:71;;47591:88;47704:1;47692:4;:11;:13;47688:56;;;47716:28;47732:6;47739:4;47716:15;:28::i;:::-;47707:37;;47688:56;46759:992;;46674:1077;;;;:::o;44196:741::-;44315:7;43764:8;;;;;;;;;;;43752:20;;:10;:20;;;43744:29;;;;;;44337:16:::1;44369:4;44358:43;;;;;;;;;;;;:::i;:::-;44334:67;;;;44411:18;44439:8;44432:26;;;44467:4;44432:41;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44411:62;;44503:10;44483:17;;:30;;;;;;;;;;;;;;;;;;44523;44584:10;44563:51;;;44615:4;44620:1;44622:8;44639:4;44645:13;44659:4;44563:101;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;44702:1;44674:17;;:30;;;;;;;;;;;;;;;;;;44735:17;44762:8;44755:26;;;44790:4;44755:41;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44735:61;;44806:79;44836:8;44847:7;:5;:7::i;:::-;44871:13;44856:12;:28;;;;:::i;:::-;44806:22;:79::i;:::-;44917:13;44902:12;:28;;;;:::i;:::-;44895:35;;;;;;44196:741:::0;;;;;;:::o;46232:145::-;5879:13;:11;:13::i;:::-;46327:43:::1;46350:6;46358:3;46363:6;46327:22;:43::i;:::-;46232:145:::0;;;:::o;46387:171::-;5879:13;:11;:13::i;:::-;46466:9:::1;46478:3;:8;;46494:6;46478:27;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46465:40;;;46522:4;46514:37;;;;;;;;;;;;:::i;:::-;;;;;;;;;46456:102;46387:171:::0;;:::o;43574:23::-;;;;;;;;;;;;;:::o;47761:724::-;47827:19;47860:17;47890:6;47880:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47860:37;;47909:12;47940:6;47935:493;47951:7;;:14;;47949:1;:16;47935:493;;;47986:7;48036:3;48018:7;;48026:1;48018:14;48030:1;48028;:3;;;;:::i;:::-;48018:14;;;;;;;:::i;:::-;48010:23;;;;;:::i;:::-;48002:32;;:37;;47986:54;;48062:1;48059;:4;;;48055:361;;48083:3;;;;;:::i;:::-;;;;48104:15;48162:3;48144:7;;48152:1;48144:14;48156:1;48154;:3;;;;:::i;:::-;48144:14;;;;;;;:::i;:::-;48136:23;;;;;:::i;:::-;48128:32;;:37;;48104:62;;48203:1;48193:9;:11;;;;:::i;:::-;48184:20;;;;;;;:::i;:::-;;;48065:155;48055:361;;;48299:4;48293;48289:15;48354:1;48344:7;48336:6;48332:20;48324:32;48253:121;48391:9;;;;;:::i;:::-;;;;48055:361;47971:457;47966:3;;;;:::i;:::-;;;47935:493;;;;48448:30;48463:4;48468:1;48470:7;48448:14;:30::i;:::-;48439:39;;47848:637;;47761:724;;;;:::o;43645:55::-;;;:::o;6668:103::-;5879:13;:11;:13::i;:::-;6733:30:::1;6760:1;6733:18;:30::i;:::-;6668:103::o:0;44947:1275::-;45123:22;45147:21;45201:17;;;;;;;;;;;45189:29;;:10;:29;;;45180:39;;;;;;45229:56;;:::i;:::-;45368:14;45357:53;;;;;;;;;;;;:::i;:::-;45296:10;:18;;45316:10;:19;;45337:10;:16;;45295:115;;;;;;;;;;;;;;;;;;;;;;45469:164;45528:10;:18;;;45577:14;45612:10;45469:31;:164::i;:::-;45665:10;45643;:19;;:32;;;;;45716:4;45685:10;:20;;:36;;;;;;;;;;;45767:11;45762:4;:16;;;;:::i;:::-;45732:10;:27;;:46;;;;;45808:15;45788:10;:19;;:35;;;;;45870:14;:19;;;45890:10;45870:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;45933:11;45928:4;:16;;;;:::i;:::-;45911:33;;45970:1;45954:17;;46038:177;46098:10;:19;;;46149:17;;;;;;;;;;;46193:11;46188:4;:16;;;;:::i;:::-;46038:31;:177::i;:::-;45170:1052;44947:1275;;;;;;;;;:::o;5993:87::-;6039:7;6066:6;;;;;;;;;;;6059:13;;5993:87;:::o;46569:95::-;5879:13;:11;:13::i;:::-;46648:9:::1;46637:8;;:20;;;;;;;;;;;;;;;;;;46569:95:::0;:::o;43970:216::-;44092:7;44117:62;44127:10;44139:4;44145:8;44155:23;44167:10;;44155:11;:23::i;:::-;44117:9;:62::i;:::-;44110:69;;43970:216;;;;;;;:::o;6926:220::-;5879:13;:11;:13::i;:::-;7031:1:::1;7011:22;;:8;:22;;::::0;7007:93:::1;;7085:1;7057:31;;;;;;;;;;;:::i;:::-;;;;;;;;7007:93;7110:28;7129:8;7110:18;:28::i;:::-;6926:220:::0;:::o;34002:311::-;34079:5;34131:1;34122:6;:10;;;;:::i;:::-;34105:6;:13;:27;;34097:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;34168:14;34259:6;34253:3;34245:6;34241:16;34237:29;34231:36;34219:48;;34297:8;34290:15;;;34002:311;;;;:::o;21473:3031::-;21613:12;21643:22;21853:4;21847:11;21834:24;;22014:9;22008:16;22056:6;22045:9;22038:25;22303:4;22292:9;22288:20;22455:6;22451:2;22447:15;22654:4;22643:9;22639:20;22478:537;22682:3;22678:2;22675:11;22478:537;;;22996:2;22990:9;22986:2;22979:21;22791:4;22787:2;22783:13;22777:19;;22828:4;22824:2;22820:13;22814:19;;22478:537;;;22482:192;23237:10;23231:17;23221:27;;23298:9;23292:16;23284:6;23280:29;23269:9;23262:48;23458:3;23452:9;;23606:6;23602:2;23598:15;23591:22;;23678:4;23666:10;23662:21;23629:228;23706:3;23702:2;23699:11;23629:228;;;23838:2;23832:9;23828:2;23821:21;23744:4;23740:2;23736:13;23730:19;;23781:4;23777:2;23773:13;23767:19;;23629:228;;;23633:65;24399:2;24395:7;24375:2;24360:9;24354:16;24346:6;24342:29;24335:37;24330:3;24326:47;24322:56;24302:154;24296:4;24289:168;21687:2781;;;24487:9;24480:16;;;21473:3031;;;;:::o;16590:162::-;16673:71;16693:5;16715;:14;;;16732:2;16736:5;16700:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16673:19;:71::i;:::-;16590:162;;;:::o;6158:166::-;6229:12;:10;:12::i;:::-;6218:23;;:7;:5;:7::i;:::-;:23;;;6214:103;;6292:12;:10;:12::i;:::-;6265:40;;;;;;;;;;;:::i;:::-;;;;;;;;6214:103;6158:166::o;30752:2871::-;30905:12;30959:7;30953:2;30943:7;:12;;;;:::i;:::-;:23;;30935:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;31030:7;31021:6;:16;;;;:::i;:::-;31004:6;:13;:33;;30996:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;31072:22;31145:7;31138:15;31172:1;31167:2005;;;;33316:4;33310:11;33297:24;;33505:1;33494:9;33487:20;33555:4;33544:9;33540:20;33534:4;33527:34;31131:2445;;31167:2005;31352:4;31346:11;31333:24;;32021:2;32012:7;32008:16;32409:9;32402:17;32396:4;32392:28;32380:9;32369;32365:25;32361:60;32458:7;32454:2;32450:16;32715:6;32701:9;32694:17;32688:4;32684:28;32672:9;32664:6;32660:22;32656:57;32652:70;32486:434;32749:3;32745:2;32742:11;32486:434;;;32897:2;32891:9;32887:2;32880:21;32791:4;32787:2;32783:13;32777:19;;32832:4;32828:2;32824:13;32818:19;;32486:434;;;32490:251;32958:7;32947:9;32940:26;33152:2;33148:7;33143:2;33139;33135:11;33131:25;33125:4;33118:39;31174:1998;;;31131:2445;;33606:9;33599:16;;;30752:2871;;;;;:::o;7306:191::-;7380:16;7399:6;;;;;;;;;;;7380:25;;7425:8;7416:6;;:17;;;;;;;;;;;;;;;;;;7480:8;7449:40;;7470:8;7449:40;;;;;;;;;;;;7369:128;7306:191;:::o;17384:228::-;17481:20;17504:5;:15;;;17528:4;17535:7;17504:39;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17481:62;;17554:50;17567:5;17574:7;17598:5;17583:12;:20;;;;:::i;:::-;17554:12;:50::i;:::-;17470:142;17384:228;;;:::o;19401:638::-;19825:23;19851:33;19879:4;19859:5;19851:27;;;;:33;;;;:::i;:::-;19825:59;;19920:1;19899:10;:17;:22;;:57;;;;;19937:10;19926:30;;;;;;;;;;;;:::i;:::-;19925:31;19899:57;19895:137;;;20013:5;19980:40;;;;;;;;;;;:::i;:::-;;;;;;;;19895:137;19471:568;19401:638;;:::o;4091:98::-;4144:7;4171:10;4164:17;;4091:98;:::o;18623:387::-;18711:25;18754:5;:13;;;18770:7;18779:5;18739:47;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18711:75;;18804:44;18828:5;18835:12;18804:23;:44::i;:::-;18799:204;;18865:71;18885:5;18907;:13;;;18923:7;18932:1;18892:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18865:19;:71::i;:::-;18951:40;18971:5;18978:12;18951:19;:40::i;:::-;18799:204;18700:310;18623:387;;;:::o;11816:153::-;11891:12;11923:38;11945:6;11953:4;11959:1;11923:21;:38::i;:::-;11916:45;;11816:153;;;;:::o;20550:585::-;20633:4;20940:12;20954:23;20989:5;20981:19;;21001:4;20981:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20939:67;;;;21024:7;:69;;;;;21057:1;21036:10;:17;:22;:56;;;;21073:10;21062:30;;;;;;;;;;;;:::i;:::-;21036:56;21024:69;:103;;;;;21126:1;21105:5;21097:26;;;:30;21024:103;21017:110;;;;20550:585;;;;:::o;12304:398::-;12403:12;12456:5;12432:21;:29;12428:110;;;12520:4;12485:41;;;;;;;;;;;:::i;:::-;;;;;;;;12428:110;12549:12;12563:23;12590:6;:11;;12609:5;12616:4;12590:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12548:73;;;;12639:55;12666:6;12674:7;12683:10;12639:26;:55::i;:::-;12632:62;;;;12304:398;;;;;:::o;13780:597::-;13928:12;13958:7;13953:417;;13982:19;13990:10;13982:7;:19::i;:::-;13953:417;;;14231:1;14210:10;:17;:22;:49;;;;;14258:1;14236:6;:18;;;:23;14210:49;14206:121;;;14304:6;14287:24;;;;;;;;;;;:::i;:::-;;;;;;;;14206:121;14348:10;14341:17;;;;13953:417;13780:597;;;;;;:::o;14930:528::-;15083:1;15063:10;:17;:21;15059:392;;;15295:10;15289:17;15352:15;15339:10;15335:2;15331:19;15324:44;15059:392;15422:17;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:117;566:1;563;556:12;580:117;689:1;686;679:12;716:552;773:8;783:6;833:3;826:4;818:6;814:17;810:27;800:122;;841:79;;:::i;:::-;800:122;954:6;941:20;931:30;;984:18;976:6;973:30;970:117;;;1006:79;;:::i;:::-;970:117;1120:4;1112:6;1108:17;1096:29;;1174:3;1166:4;1158:6;1154:17;1144:8;1140:32;1137:41;1134:128;;;1181:79;;:::i;:::-;1134:128;716:552;;;;;:::o;1274:527::-;1344:6;1352;1401:2;1389:9;1380:7;1376:23;1372:32;1369:119;;;1407:79;;:::i;:::-;1369:119;1555:1;1544:9;1540:17;1527:31;1585:18;1577:6;1574:30;1571:117;;;1607:79;;:::i;:::-;1571:117;1720:64;1776:7;1767:6;1756:9;1752:22;1720:64;:::i;:::-;1702:82;;;;1498:296;1274:527;;;;;:::o;1807:98::-;1858:6;1892:5;1886:12;1876:22;;1807:98;;;:::o;1911:168::-;1994:11;2028:6;2023:3;2016:19;2068:4;2063:3;2059:14;2044:29;;1911:168;;;;:::o;2085:139::-;2174:6;2169:3;2164;2158:23;2215:1;2206:6;2201:3;2197:16;2190:27;2085:139;;;:::o;2230:102::-;2271:6;2322:2;2318:7;2313:2;2306:5;2302:14;2298:28;2288:38;;2230:102;;;:::o;2338:373::-;2424:3;2452:38;2484:5;2452:38;:::i;:::-;2506:70;2569:6;2564:3;2506:70;:::i;:::-;2499:77;;2585:65;2643:6;2638:3;2631:4;2624:5;2620:16;2585:65;:::i;:::-;2675:29;2697:6;2675:29;:::i;:::-;2670:3;2666:39;2659:46;;2428:283;2338:373;;;;:::o;2717:309::-;2828:4;2866:2;2855:9;2851:18;2843:26;;2915:9;2909:4;2905:20;2901:1;2890:9;2886:17;2879:47;2943:76;3014:4;3005:6;2943:76;:::i;:::-;2935:84;;2717:309;;;;:::o;3032:126::-;3069:7;3109:42;3102:5;3098:54;3087:65;;3032:126;;;:::o;3164:96::-;3201:7;3230:24;3248:5;3230:24;:::i;:::-;3219:35;;3164:96;;;:::o;3266:122::-;3339:24;3357:5;3339:24;:::i;:::-;3332:5;3329:35;3319:63;;3378:1;3375;3368:12;3319:63;3266:122;:::o;3394:139::-;3440:5;3478:6;3465:20;3456:29;;3494:33;3521:5;3494:33;:::i;:::-;3394:139;;;;:::o;3539:77::-;3576:7;3605:5;3594:16;;3539:77;;;:::o;3622:122::-;3695:24;3713:5;3695:24;:::i;:::-;3688:5;3685:35;3675:63;;3734:1;3731;3724:12;3675:63;3622:122;:::o;3750:139::-;3796:5;3834:6;3821:20;3812:29;;3850:33;3877:5;3850:33;:::i;:::-;3750:139;;;;:::o;3895:117::-;4004:1;4001;3994:12;4018:180;4066:77;4063:1;4056:88;4163:4;4160:1;4153:15;4187:4;4184:1;4177:15;4204:281;4287:27;4309:4;4287:27;:::i;:::-;4279:6;4275:40;4417:6;4405:10;4402:22;4381:18;4369:10;4366:34;4363:62;4360:88;;;4428:18;;:::i;:::-;4360:88;4468:10;4464:2;4457:22;4247:238;4204:281;;:::o;4491:129::-;4525:6;4552:20;;:::i;:::-;4542:30;;4581:33;4609:4;4601:6;4581:33;:::i;:::-;4491:129;;;:::o;4626:307::-;4687:4;4777:18;4769:6;4766:30;4763:56;;;4799:18;;:::i;:::-;4763:56;4837:29;4859:6;4837:29;:::i;:::-;4829:37;;4921:4;4915;4911:15;4903:23;;4626:307;;;:::o;4939:148::-;5037:6;5032:3;5027;5014:30;5078:1;5069:6;5064:3;5060:16;5053:27;4939:148;;;:::o;5093:423::-;5170:5;5195:65;5211:48;5252:6;5211:48;:::i;:::-;5195:65;:::i;:::-;5186:74;;5283:6;5276:5;5269:21;5321:4;5314:5;5310:16;5359:3;5350:6;5345:3;5341:16;5338:25;5335:112;;;5366:79;;:::i;:::-;5335:112;5456:54;5503:6;5498:3;5493;5456:54;:::i;:::-;5176:340;5093:423;;;;;:::o;5535:338::-;5590:5;5639:3;5632:4;5624:6;5620:17;5616:27;5606:122;;5647:79;;:::i;:::-;5606:122;5764:6;5751:20;5789:78;5863:3;5855:6;5848:4;5840:6;5836:17;5789:78;:::i;:::-;5780:87;;5596:277;5535:338;;;;:::o;5879:943::-;5974:6;5982;5990;5998;6047:3;6035:9;6026:7;6022:23;6018:33;6015:120;;;6054:79;;:::i;:::-;6015:120;6174:1;6199:53;6244:7;6235:6;6224:9;6220:22;6199:53;:::i;:::-;6189:63;;6145:117;6301:2;6327:53;6372:7;6363:6;6352:9;6348:22;6327:53;:::i;:::-;6317:63;;6272:118;6429:2;6455:53;6500:7;6491:6;6480:9;6476:22;6455:53;:::i;:::-;6445:63;;6400:118;6585:2;6574:9;6570:18;6557:32;6616:18;6608:6;6605:30;6602:117;;;6638:79;;:::i;:::-;6602:117;6743:62;6797:7;6788:6;6777:9;6773:22;6743:62;:::i;:::-;6733:72;;6528:287;5879:943;;;;;;;:::o;6828:118::-;6915:24;6933:5;6915:24;:::i;:::-;6910:3;6903:37;6828:118;;:::o;6952:222::-;7045:4;7083:2;7072:9;7068:18;7060:26;;7096:71;7164:1;7153:9;7149:17;7140:6;7096:71;:::i;:::-;6952:222;;;;:::o;7180:110::-;7231:7;7260:24;7278:5;7260:24;:::i;:::-;7249:35;;7180:110;;;:::o;7296:150::-;7383:38;7415:5;7383:38;:::i;:::-;7376:5;7373:49;7363:77;;7436:1;7433;7426:12;7363:77;7296:150;:::o;7452:167::-;7512:5;7550:6;7537:20;7528:29;;7566:47;7607:5;7566:47;:::i;:::-;7452:167;;;;:::o;7625:647::-;7716:6;7724;7732;7781:2;7769:9;7760:7;7756:23;7752:32;7749:119;;;7787:79;;:::i;:::-;7749:119;7907:1;7932:67;7991:7;7982:6;7971:9;7967:22;7932:67;:::i;:::-;7922:77;;7878:131;8048:2;8074:53;8119:7;8110:6;8099:9;8095:22;8074:53;:::i;:::-;8064:63;;8019:118;8176:2;8202:53;8247:7;8238:6;8227:9;8223:22;8202:53;:::i;:::-;8192:63;;8147:118;7625:647;;;;;:::o;8278:474::-;8346:6;8354;8403:2;8391:9;8382:7;8378:23;8374:32;8371:119;;;8409:79;;:::i;:::-;8371:119;8529:1;8554:53;8599:7;8590:6;8579:9;8575:22;8554:53;:::i;:::-;8544:63;;8500:117;8656:2;8682:53;8727:7;8718:6;8707:9;8703:22;8682:53;:::i;:::-;8672:63;;8627:118;8278:474;;;;;:::o;8758:118::-;8845:24;8863:5;8845:24;:::i;:::-;8840:3;8833:37;8758:118;;:::o;8882:222::-;8975:4;9013:2;9002:9;8998:18;8990:26;;9026:71;9094:1;9083:9;9079:17;9070:6;9026:71;:::i;:::-;8882:222;;;;:::o;9110:60::-;9138:3;9159:5;9152:12;;9110:60;;;:::o;9176:142::-;9226:9;9259:53;9277:34;9286:24;9304:5;9286:24;:::i;:::-;9277:34;:::i;:::-;9259:53;:::i;:::-;9246:66;;9176:142;;;:::o;9324:126::-;9374:9;9407:37;9438:5;9407:37;:::i;:::-;9394:50;;9324:126;;;:::o;9456:156::-;9536:9;9569:37;9600:5;9569:37;:::i;:::-;9556:50;;9456:156;;;:::o;9618:191::-;9735:67;9796:5;9735:67;:::i;:::-;9730:3;9723:80;9618:191;;:::o;9815:282::-;9938:4;9976:2;9965:9;9961:18;9953:26;;9989:101;10087:1;10076:9;10072:17;10063:6;9989:101;:::i;:::-;9815:282;;;;:::o;10103:311::-;10180:4;10270:18;10262:6;10259:30;10256:56;;;10292:18;;:::i;:::-;10256:56;10342:4;10334:6;10330:17;10322:25;;10402:4;10396;10392:15;10384:23;;10103:311;;;:::o;10437:710::-;10533:5;10558:81;10574:64;10631:6;10574:64;:::i;:::-;10558:81;:::i;:::-;10549:90;;10659:5;10688:6;10681:5;10674:21;10722:4;10715:5;10711:16;10704:23;;10775:4;10767:6;10763:17;10755:6;10751:30;10804:3;10796:6;10793:15;10790:122;;;10823:79;;:::i;:::-;10790:122;10938:6;10921:220;10955:6;10950:3;10947:15;10921:220;;;11030:3;11059:37;11092:3;11080:10;11059:37;:::i;:::-;11054:3;11047:50;11126:4;11121:3;11117:14;11110:21;;10997:144;10981:4;10976:3;10972:14;10965:21;;10921:220;;;10925:21;10539:608;;10437:710;;;;;:::o;11170:370::-;11241:5;11290:3;11283:4;11275:6;11271:17;11267:27;11257:122;;11298:79;;:::i;:::-;11257:122;11415:6;11402:20;11440:94;11530:3;11522:6;11515:4;11507:6;11503:17;11440:94;:::i;:::-;11431:103;;11247:293;11170:370;;;;:::o;11546:1445::-;11684:6;11692;11700;11708;11716;11724;11773:3;11761:9;11752:7;11748:23;11744:33;11741:120;;;11780:79;;:::i;:::-;11741:120;11900:1;11925:53;11970:7;11961:6;11950:9;11946:22;11925:53;:::i;:::-;11915:63;;11871:117;12027:2;12053:53;12098:7;12089:6;12078:9;12074:22;12053:53;:::i;:::-;12043:63;;11998:118;12155:2;12181:53;12226:7;12217:6;12206:9;12202:22;12181:53;:::i;:::-;12171:63;;12126:118;12283:2;12309:53;12354:7;12345:6;12334:9;12330:22;12309:53;:::i;:::-;12299:63;;12254:118;12439:3;12428:9;12424:19;12411:33;12471:18;12463:6;12460:30;12457:117;;;12493:79;;:::i;:::-;12457:117;12598:78;12668:7;12659:6;12648:9;12644:22;12598:78;:::i;:::-;12588:88;;12382:304;12753:3;12742:9;12738:19;12725:33;12785:18;12777:6;12774:30;12771:117;;;12807:79;;:::i;:::-;12771:117;12912:62;12966:7;12957:6;12946:9;12942:22;12912:62;:::i;:::-;12902:72;;12696:288;11546:1445;;;;;;;;:::o;12997:332::-;13118:4;13156:2;13145:9;13141:18;13133:26;;13169:71;13237:1;13226:9;13222:17;13213:6;13169:71;:::i;:::-;13250:72;13318:2;13307:9;13303:18;13294:6;13250:72;:::i;:::-;12997:332;;;;;:::o;13335:329::-;13394:6;13443:2;13431:9;13422:7;13418:23;13414:32;13411:119;;;13449:79;;:::i;:::-;13411:119;13569:1;13594:53;13639:7;13630:6;13619:9;13615:22;13594:53;:::i;:::-;13584:63;;13540:117;13335:329;;;;:::o;13670:963::-;13767:6;13775;13783;13791;13799;13848:3;13836:9;13827:7;13823:23;13819:33;13816:120;;;13855:79;;:::i;:::-;13816:120;13975:1;14000:53;14045:7;14036:6;14025:9;14021:22;14000:53;:::i;:::-;13990:63;;13946:117;14102:2;14128:53;14173:7;14164:6;14153:9;14149:22;14128:53;:::i;:::-;14118:63;;14073:118;14230:2;14256:53;14301:7;14292:6;14281:9;14277:22;14256:53;:::i;:::-;14246:63;;14201:118;14386:2;14375:9;14371:18;14358:32;14417:18;14409:6;14406:30;14403:117;;;14439:79;;:::i;:::-;14403:117;14552:64;14608:7;14599:6;14588:9;14584:22;14552:64;:::i;:::-;14534:82;;;;14329:297;13670:963;;;;;;;;:::o;14639:180::-;14687:77;14684:1;14677:88;14784:4;14781:1;14774:15;14808:4;14805:1;14798:15;14825:86;14860:7;14900:4;14893:5;14889:16;14878:27;;14825:86;;;:::o;14917:167::-;14954:3;14977:22;14993:5;14977:22;:::i;:::-;14968:31;;15021:4;15014:5;15011:15;15008:41;;15029:18;;:::i;:::-;15008:41;15076:1;15069:5;15065:13;15058:20;;14917:167;;;:::o;15090:191::-;15128:4;15148:18;15164:1;15148:18;:::i;:::-;15143:23;;15180:18;15196:1;15180:18;:::i;:::-;15175:23;;15222:1;15219;15215:9;15207:17;;15246:4;15240;15237:14;15234:40;;;15254:18;;:::i;:::-;15234:40;15090:191;;;;:::o;15287:96::-;15321:8;15370:5;15365:3;15361:15;15340:36;;15287:96;;;:::o;15389:93::-;15426:7;15455:21;15470:5;15455:21;:::i;:::-;15444:32;;15389:93;;;:::o;15488:149::-;15589:41;15607:22;15623:5;15607:22;:::i;:::-;15589:41;:::i;:::-;15584:3;15577:54;15488:149;;:::o;15643:379::-;15775:3;15790:71;15857:3;15848:6;15790:71;:::i;:::-;15886:1;15881:3;15877:11;15870:18;;15898:71;15965:3;15956:6;15898:71;:::i;:::-;15994:1;15989:3;15985:11;15978:18;;16013:3;16006:10;;15643:379;;;;;:::o;16028:247::-;16136:3;16151:71;16218:3;16209:6;16151:71;:::i;:::-;16247:1;16242:3;16238:11;16231:18;;16266:3;16259:10;;16028:247;;;;:::o;16281:104::-;16326:7;16355:24;16373:5;16355:24;:::i;:::-;16344:35;;16281:104;;;:::o;16391:138::-;16472:32;16498:5;16472:32;:::i;:::-;16465:5;16462:43;16452:71;;16519:1;16516;16509:12;16452:71;16391:138;:::o;16535:159::-;16600:5;16631:6;16625:13;16616:22;;16647:41;16682:5;16647:41;:::i;:::-;16535:159;;;;:::o;16700:432::-;16788:5;16813:65;16829:48;16870:6;16829:48;:::i;:::-;16813:65;:::i;:::-;16804:74;;16901:6;16894:5;16887:21;16939:4;16932:5;16928:16;16977:3;16968:6;16963:3;16959:16;16956:25;16953:112;;;16984:79;;:::i;:::-;16953:112;17074:52;17119:6;17114:3;17109;17074:52;:::i;:::-;16794:338;16700:432;;;;;:::o;17151:353::-;17217:5;17266:3;17259:4;17251:6;17247:17;17243:27;17233:122;;17274:79;;:::i;:::-;17233:122;17384:6;17378:13;17409:89;17494:3;17486:6;17479:4;17471:6;17467:17;17409:89;:::i;:::-;17400:98;;17223:281;17151:353;;;;:::o;17510:866::-;17623:6;17631;17639;17688:2;17676:9;17667:7;17663:23;17659:32;17656:119;;;17694:79;;:::i;:::-;17656:119;17814:1;17839:72;17903:7;17894:6;17883:9;17879:22;17839:72;:::i;:::-;17829:82;;17785:136;17960:2;17986:72;18050:7;18041:6;18030:9;18026:22;17986:72;:::i;:::-;17976:82;;17931:137;18128:2;18117:9;18113:18;18107:25;18159:18;18151:6;18148:30;18145:117;;;18181:79;;:::i;:::-;18145:117;18286:73;18351:7;18342:6;18331:9;18327:22;18286:73;:::i;:::-;18276:83;;18078:291;17510:866;;;;;:::o;18382:143::-;18439:5;18470:6;18464:13;18455:22;;18486:33;18513:5;18486:33;:::i;:::-;18382:143;;;;:::o;18531:351::-;18601:6;18650:2;18638:9;18629:7;18625:23;18621:32;18618:119;;;18656:79;;:::i;:::-;18618:119;18776:1;18801:64;18857:7;18848:6;18837:9;18833:22;18801:64;:::i;:::-;18791:74;;18747:128;18531:351;;;;:::o;18888:85::-;18933:7;18962:5;18951:16;;18888:85;;;:::o;18979:158::-;19037:9;19070:61;19088:42;19097:32;19123:5;19097:32;:::i;:::-;19088:42;:::i;:::-;19070:61;:::i;:::-;19057:74;;18979:158;;;:::o;19143:147::-;19238:45;19277:5;19238:45;:::i;:::-;19233:3;19226:58;19143:147;;:::o;19296:114::-;19363:6;19397:5;19391:12;19381:22;;19296:114;;;:::o;19416:184::-;19515:11;19549:6;19544:3;19537:19;19589:4;19584:3;19580:14;19565:29;;19416:184;;;;:::o;19606:132::-;19673:4;19696:3;19688:11;;19726:4;19721:3;19717:14;19709:22;;19606:132;;;:::o;19744:108::-;19821:24;19839:5;19821:24;:::i;:::-;19816:3;19809:37;19744:108;;:::o;19858:179::-;19927:10;19948:46;19990:3;19982:6;19948:46;:::i;:::-;20026:4;20021:3;20017:14;20003:28;;19858:179;;;;:::o;20043:113::-;20113:4;20145;20140:3;20136:14;20128:22;;20043:113;;;:::o;20192:732::-;20311:3;20340:54;20388:5;20340:54;:::i;:::-;20410:86;20489:6;20484:3;20410:86;:::i;:::-;20403:93;;20520:56;20570:5;20520:56;:::i;:::-;20599:7;20630:1;20615:284;20640:6;20637:1;20634:13;20615:284;;;20716:6;20710:13;20743:63;20802:3;20787:13;20743:63;:::i;:::-;20736:70;;20829:60;20882:6;20829:60;:::i;:::-;20819:70;;20675:224;20662:1;20659;20655:9;20650:14;;20615:284;;;20619:14;20915:3;20908:10;;20316:608;;;20192:732;;;;:::o;20930:1029::-;21239:4;21277:3;21266:9;21262:19;21254:27;;21291:71;21359:1;21348:9;21344:17;21335:6;21291:71;:::i;:::-;21372:80;21448:2;21437:9;21433:18;21424:6;21372:80;:::i;:::-;21462:72;21530:2;21519:9;21515:18;21506:6;21462:72;:::i;:::-;21544;21612:2;21601:9;21597:18;21588:6;21544:72;:::i;:::-;21664:9;21658:4;21654:20;21648:3;21637:9;21633:19;21626:49;21692:108;21795:4;21786:6;21692:108;:::i;:::-;21684:116;;21848:9;21842:4;21838:20;21832:3;21821:9;21817:19;21810:49;21876:76;21947:4;21938:6;21876:76;:::i;:::-;21868:84;;20930:1029;;;;;;;;;:::o;21965:194::-;22005:4;22025:20;22043:1;22025:20;:::i;:::-;22020:25;;22059:20;22077:1;22059:20;:::i;:::-;22054:25;;22103:1;22100;22096:9;22088:17;;22127:1;22121:4;22118:11;22115:37;;;22132:18;;:::i;:::-;22115:37;21965:194;;;;:::o;22165:147::-;22266:11;22303:3;22288:18;;22165:147;;;;:::o;22318:114::-;;:::o;22438:398::-;22597:3;22618:83;22699:1;22694:3;22618:83;:::i;:::-;22611:90;;22710:93;22799:3;22710:93;:::i;:::-;22828:1;22823:3;22819:11;22812:18;;22438:398;;;:::o;22842:379::-;23026:3;23048:147;23191:3;23048:147;:::i;:::-;23041:154;;23212:3;23205:10;;22842:379;;;:::o;23227:169::-;23311:11;23345:6;23340:3;23333:19;23385:4;23380:3;23376:14;23361:29;;23227:169;;;;:::o;23402:170::-;23542:22;23538:1;23530:6;23526:14;23519:46;23402:170;:::o;23578:366::-;23720:3;23741:67;23805:2;23800:3;23741:67;:::i;:::-;23734:74;;23817:93;23906:3;23817:93;:::i;:::-;23935:2;23930:3;23926:12;23919:19;;23578:366;;;:::o;23950:419::-;24116:4;24154:2;24143:9;24139:18;24131:26;;24203:9;24197:4;24193:20;24189:1;24178:9;24174:17;24167:47;24231:131;24357:4;24231:131;:::i;:::-;24223:139;;23950:419;;;:::o;24375:191::-;24415:3;24434:20;24452:1;24434:20;:::i;:::-;24429:25;;24468:20;24486:1;24468:20;:::i;:::-;24463:25;;24511:1;24508;24504:9;24497:16;;24532:3;24529:1;24526:10;24523:36;;;24539:18;;:::i;:::-;24523:36;24375:191;;;;:::o;24572:117::-;24681:1;24678;24671:12;24695:117;24804:1;24801;24794:12;24818:469;24923:9;24934;24972:8;24960:10;24957:24;24954:111;;;24984:79;;:::i;:::-;24954:111;25090:6;25080:8;25077:20;25074:107;;;25100:79;;:::i;:::-;25074:107;25231:1;25219:10;25215:18;25207:6;25203:31;25190:44;;25270:10;25260:8;25256:25;25243:38;;24818:469;;;;;;;:::o;25293:96::-;25351:6;25379:3;25369:13;;25293:96;;;;:::o;25487:77::-;25524:7;25553:5;25542:16;;25487:77;;;:::o;25570:107::-;25614:8;25664:5;25658:4;25654:16;25633:37;;25570:107;;;;:::o;25683:552::-;25774:5;25805:45;25846:3;25839:5;25805:45;:::i;:::-;25875:5;25899:41;25930:8;25917:22;25899:41;:::i;:::-;25890:50;;25964:2;25956:6;25953:14;25950:278;;;26035:169;26120:66;26090:6;26086:2;26082:15;26079:1;26075:23;26035:169;:::i;:::-;26012:5;25991:227;25982:236;;25950:278;25780:455;;25683:552;;;;:::o;26241:233::-;26280:3;26303:24;26321:5;26303:24;:::i;:::-;26294:33;;26349:66;26342:5;26339:77;26336:103;;26419:18;;:::i;:::-;26336:103;26466:1;26459:5;26455:13;26448:20;;26241:233;;;:::o;26480:188::-;26518:3;26537:18;26553:1;26537:18;:::i;:::-;26532:23;;26569:18;26585:1;26569:18;:::i;:::-;26564:23;;26610:1;26607;26603:9;26596:16;;26633:4;26628:3;26625:13;26622:39;;;26641:18;;:::i;:::-;26622:39;26480:188;;;;:::o;26674:108::-;26751:24;26769:5;26751:24;:::i;:::-;26746:3;26739:37;26674:108;;:::o;26788:90::-;26822:7;26865:5;26858:13;26851:21;26840:32;;26788:90;;;:::o;26884:99::-;26955:21;26970:5;26955:21;:::i;:::-;26950:3;26943:34;26884:99;;:::o;26989:102::-;27062:22;27078:5;27062:22;:::i;:::-;27057:3;27050:35;26989:102;;:::o;27097:108::-;27174:24;27192:5;27174:24;:::i;:::-;27169:3;27162:37;27097:108;;:::o;27211:158::-;27284:11;27318:6;27313:3;27306:19;27358:4;27353:3;27349:14;27334:29;;27211:158;;;;:::o;27375:353::-;27451:3;27479:38;27511:5;27479:38;:::i;:::-;27533:60;27586:6;27581:3;27533:60;:::i;:::-;27526:67;;27602:65;27660:6;27655:3;27648:4;27641:5;27637:16;27602:65;:::i;:::-;27692:29;27714:6;27692:29;:::i;:::-;27687:3;27683:39;27676:46;;27455:273;27375:353;;;;:::o;27836:2214::-;27965:3;28001:6;27996:3;27992:16;28093:4;28086:5;28082:16;28076:23;28112:63;28169:4;28164:3;28160:14;28146:12;28112:63;:::i;:::-;28018:167;28271:4;28264:5;28260:16;28254:23;28290:63;28347:4;28342:3;28338:14;28324:12;28290:63;:::i;:::-;28195:168;28449:4;28442:5;28438:16;28432:23;28468:63;28525:4;28520:3;28516:14;28502:12;28468:63;:::i;:::-;28373:168;28635:4;28628:5;28624:16;28618:23;28654:63;28711:4;28706:3;28702:14;28688:12;28654:63;:::i;:::-;28551:176;28814:4;28807:5;28803:16;28797:23;28833:63;28890:4;28885:3;28881:14;28867:12;28833:63;:::i;:::-;28737:169;28992:4;28985:5;28981:16;28975:23;29011:63;29068:4;29063:3;29059:14;29045:12;29011:63;:::i;:::-;28916:168;29172:4;29165:5;29161:16;29155:23;29191:57;29242:4;29237:3;29233:14;29219:12;29191:57;:::i;:::-;29094:164;29337:4;29330:5;29326:16;29320:23;29356:59;29409:4;29404:3;29400:14;29386:12;29356:59;:::i;:::-;29268:157;29504:6;29497:5;29493:18;29487:25;29525:65;29582:6;29577:3;29573:16;29559:12;29525:65;:::i;:::-;29435:165;29679:6;29672:5;29668:18;29662:25;29700:65;29757:6;29752:3;29748:16;29734:12;29700:65;:::i;:::-;29610:165;29858:6;29851:5;29847:18;29841:25;29915:3;29909:4;29905:14;29896:6;29891:3;29887:16;29880:40;29941:71;30007:4;29993:12;29941:71;:::i;:::-;29933:79;;29785:238;30040:4;30033:11;;27970:2080;27836:2214;;;;:::o;30056:393::-;30209:4;30247:2;30236:9;30232:18;30224:26;;30296:9;30290:4;30286:20;30282:1;30271:9;30267:17;30260:47;30324:118;30437:4;30428:6;30324:118;:::i;:::-;30316:126;;30056:393;;;;:::o;30455:169::-;30595:21;30591:1;30583:6;30579:14;30572:45;30455:169;:::o;30630:366::-;30772:3;30793:67;30857:2;30852:3;30793:67;:::i;:::-;30786:74;;30869:93;30958:3;30869:93;:::i;:::-;30987:2;30982:3;30978:12;30971:19;;30630:366;;;:::o;31002:419::-;31168:4;31206:2;31195:9;31191:18;31183:26;;31255:9;31249:4;31245:20;31241:1;31230:9;31226:17;31219:47;31283:131;31409:4;31283:131;:::i;:::-;31275:139;;31002:419;;;:::o;31427:332::-;31548:4;31586:2;31575:9;31571:18;31563:26;;31599:71;31667:1;31656:9;31652:17;31643:6;31599:71;:::i;:::-;31680:72;31748:2;31737:9;31733:18;31724:6;31680:72;:::i;:::-;31427:332;;;;;:::o;31765:164::-;31905:16;31901:1;31893:6;31889:14;31882:40;31765:164;:::o;31935:366::-;32077:3;32098:67;32162:2;32157:3;32098:67;:::i;:::-;32091:74;;32174:93;32263:3;32174:93;:::i;:::-;32292:2;32287:3;32283:12;32276:19;;31935:366;;;:::o;32307:419::-;32473:4;32511:2;32500:9;32496:18;32488:26;;32560:9;32554:4;32550:20;32546:1;32535:9;32531:17;32524:47;32588:131;32714:4;32588:131;:::i;:::-;32580:139;;32307:419;;;:::o;32732:167::-;32872:19;32868:1;32860:6;32856:14;32849:43;32732:167;:::o;32905:366::-;33047:3;33068:67;33132:2;33127:3;33068:67;:::i;:::-;33061:74;;33144:93;33233:3;33144:93;:::i;:::-;33262:2;33257:3;33253:12;33246:19;;32905:366;;;:::o;33277:419::-;33443:4;33481:2;33470:9;33466:18;33458:26;;33530:9;33524:4;33520:20;33516:1;33505:9;33501:17;33494:47;33558:131;33684:4;33558:131;:::i;:::-;33550:139;;33277:419;;;:::o;33702:332::-;33823:4;33861:2;33850:9;33846:18;33838:26;;33874:71;33942:1;33931:9;33927:17;33918:6;33874:71;:::i;:::-;33955:72;34023:2;34012:9;34008:18;33999:6;33955:72;:::i;:::-;33702:332;;;;;:::o;34040:116::-;34110:21;34125:5;34110:21;:::i;:::-;34103:5;34100:32;34090:60;;34146:1;34143;34136:12;34090:60;34040:116;:::o;34162:137::-;34216:5;34247:6;34241:13;34232:22;;34263:30;34287:5;34263:30;:::i;:::-;34162:137;;;;:::o;34305:345::-;34372:6;34421:2;34409:9;34400:7;34396:23;34392:32;34389:119;;;34427:79;;:::i;:::-;34389:119;34547:1;34572:61;34625:7;34616:6;34605:9;34601:22;34572:61;:::i;:::-;34562:71;;34518:125;34305:345;;;;:::o;34656:348::-;34785:4;34823:2;34812:9;34808:18;34800:26;;34836:71;34904:1;34893:9;34889:17;34880:6;34836:71;:::i;:::-;34917:80;34993:2;34982:9;34978:18;34969:6;34917:80;:::i;:::-;34656:348;;;;;:::o;35010:386::-;35114:3;35142:38;35174:5;35142:38;:::i;:::-;35196:88;35277:6;35272:3;35196:88;:::i;:::-;35189:95;;35293:65;35351:6;35346:3;35339:4;35332:5;35328:16;35293:65;:::i;:::-;35383:6;35378:3;35374:16;35367:23;;35118:278;35010:386;;;;:::o;35402:271::-;35532:3;35554:93;35643:3;35634:6;35554:93;:::i;:::-;35547:100;;35664:3;35657:10;;35402:271;;;;:::o

ipfs://f5caa295f88d450d0183797f779417cd5f1edd39d29aba810aaa1840f05fdab2