Contract 0x67218f66a84809201CfBa5c8b46dBd3aB95A42da 7

/**
 *Submitted for verification at Arbiscan.io on 2023-09-07
*/

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;

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

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

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


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

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

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


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

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


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

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}


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

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


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

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

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


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

// OpenZeppelin Contracts (last updated v4.8.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;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File contracts/Utils/ReentrancyGuard.sol


/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


// File contracts/Staking/FraxFarmRageQuitter_Saddle_L2D4.sol


// ====================================================================
// |     ______                   _______                             |
// |    / _____________ __  __   / ____(_____  ____ _____  ________   |
// |   / /_  / ___/ __ `| |/_/  / /_  / / __ \/ __ `/ __ \/ ___/ _ \  |
// |  / __/ / /  / /_/ _>  <   / __/ / / / / / /_/ / / / / /__/  __/  |
// | /_/   /_/   \__,_/_/|_|  /_/   /_/_/ /_/\__,_/_/ /_/\___/\___/   |
// |                                                                  |
// ====================================================================
// ==================== FraxFarmRageQuitter_Saddle_L2D4 ===================
// ====================================================================
// Exits a Frax farm early, with a penalty. Deployed on a case-by-case basis

// Frax Finance: https://github.com/FraxFinance

// Primary Author(s)
// Dennis: https://github.com/denett

// Reviewer(s) / Contributor(s)
// Travis Moore: https://github.com/FortisFortuna
contract FraxFarmRageQuitter_Saddle_L2D4 is ReentrancyGuard {
   IFarm public farm = IFarm(0xd1dF24e8D225b20F9c8f4912BE88cCCec93f36E5);
   IERC20 lp_token = IERC20(0x147D0Af556C6D89640BFa915D2b9619d7b55947a);
   address fraxTreasuryAddress = 0xe61D9ed1e5Dc261D1e90a99304fADCef2c76FD10;
   uint256 treasuryPercentage = 2000; // 20%;

   // Rewards tokens
   IERC20 fxsToken = IERC20(0x9d2F299715D94d8A7E6F5eaa8E654E8c74a988A7);
   IERC20 sdlToken = IERC20(0x75C9bC761d88f70156DAf83aa010E84680baF131);

   // NOTE
   // Make sure to enable this contract as a migrator first on the target farm
   
   /// @notice Exits stake for a specific kek_id
   function ragequitOne(bytes32 _kek_id) nonReentrant external {
      uint256 _liquidity;

      // Get all locked stake of the user
      IFarm.LockedStake[] memory lockedStakes = farm.lockedStakesOf(msg.sender);

      // Find stake with the correct kek_id
      for (uint256 i; i < lockedStakes.length; i++) {
         if (lockedStakes[i].kek_id == _kek_id) {
            _liquidity = lockedStakes[i].liquidity;
            break;
         }
      }
      require(_liquidity > 0, "Stake not found");

      // Unlock the stake and transfer the LP tokens to this contract
      farm.migrator_withdraw_locked(msg.sender, _kek_id);

      // Split the LP tokens between the Frax treasury and the user
      uint256 liquidityToTreasury = (_liquidity * treasuryPercentage) / 10000;
      SafeERC20.safeTransfer(lp_token, fraxTreasuryAddress, liquidityToTreasury);
      SafeERC20.safeTransfer(lp_token, msg.sender, _liquidity - liquidityToTreasury);
      
      // All rewards collected during the migration are sent to the user.
      SafeERC20.safeTransfer(fxsToken, msg.sender, fxsToken.balanceOf(address(this)));
      SafeERC20.safeTransfer(sdlToken, msg.sender, sdlToken.balanceOf(address(this)));
   }
   
   /// @notice Exits all stakes
   function ragequitAll() nonReentrant external {  
      uint256 _totalLiquidity;

      // Get all locked stake of the user
      IFarm.LockedStake[] memory lockedStakes = farm.lockedStakesOf(msg.sender);

      for (uint256 i; i < lockedStakes.length; i++) {
         uint256 _liquidity = lockedStakes[i].liquidity;
         if (_liquidity > 0) {
            farm.migrator_withdraw_locked(msg.sender, lockedStakes[i].kek_id); // Unlock the stake and transfer the LP tokens to this contract
            _totalLiquidity += _liquidity;
         }
      }
      require(_totalLiquidity > 0, "Nothing to unlock");

      // Split the LP tokens between the Frax treasury and the user
      uint256 liquidityToTreasury = (_totalLiquidity * treasuryPercentage) / 10000;
      SafeERC20.safeTransfer(lp_token, fraxTreasuryAddress, liquidityToTreasury);
      SafeERC20.safeTransfer(lp_token, msg.sender, _totalLiquidity - liquidityToTreasury);

      // All reward tokens collected during the migration are send to the user.
      SafeERC20.safeTransfer(fxsToken,msg.sender,fxsToken.balanceOf(address(this)));
      SafeERC20.safeTransfer(sdlToken,msg.sender,sdlToken.balanceOf(address(this)));
   }
}

interface IFarm{
   struct LockedStake {
      bytes32 kek_id;
      uint256 start_timestamp;
      uint256 liquidity;
      uint256 ending_timestamp;
      uint256 lock_multiplier; 
   }
   function migrator_withdraw_locked(address, bytes32) external;
   function lockedStakesOf(address) external view returns(LockedStake[] memory);
}

[{"inputs":[],"name":"farm","outputs":[{"internalType":"contract IFarm","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ragequitAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_kek_id","type":"bytes32"}],"name":"ragequitOne","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

22972:3151:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23633:1231;;;;;;:::i;:::-;;:::i;:::-;;23038:69;;;;;;;;;;;;389:42:1;377:55;;;359:74;;347:2;332:18;23038:69:0;;;;;;;24907:1213;;;:::i;23633:1231::-;20937:1;21543:7;;:19;21535:63;;;;;;;646:2:1;21535:63:0;;;628:21:1;685:2;665:18;;;658:30;724:33;704:18;;;697:61;775:18;;21535:63:0;;;;;;;;;20937:1;21676:7;:18;;;23816:4:::1;::::0;:31:::1;::::0;;;;23836:10:::1;23816:31;::::0;::::1;359:74:1::0;21676:7:0;;23816:4:::1;;::::0;:19:::1;::::0;332:18:1;;23816:31:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;::::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;23774:73;;23908:9;23903:192;23923:12;:19;23919:1;:23;23903:192;;;23991:7;23965:12;23978:1;23965:15;;;;;;;;:::i;:::-;;;;;;;:22;;;:33:::0;23961:125:::1;;24028:12;24041:1;24028:15;;;;;;;;:::i;:::-;;;;;;;:25;;;24015:38;;24068:5;;23961:125;23944:3:::0;::::1;::::0;::::1;:::i;:::-;;;;23903:192;;;;24124:1;24111:10;:14;24103:42;;;::::0;::::1;::::0;;4092:2:1;24103:42:0::1;::::0;::::1;4074:21:1::0;4131:2;4111:18;;;4104:30;4170:17;4150:18;;;4143:45;4205:18;;24103:42:0::1;3890:339:1::0;24103:42:0::1;24227:4;::::0;:50:::1;::::0;;;;24257:10:::1;24227:50;::::0;::::1;4408:74:1::0;4498:18;;;4491:34;;;24227:4:0::1;::::0;;::::1;::::0;:29:::1;::::0;4381:18:1;;24227:50:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;24357:27;24423:5;24401:18;;24388:10;:31;;;;:::i;:::-;24387:41;;;;:::i;:::-;24460:8;::::0;24470:19:::1;::::0;24357:71;;-1:-1:-1;24437:74:0::1;::::0;24460:8:::1;::::0;;::::1;::::0;24470:19:::1;24357:71:::0;24437:22:::1;:74::i;:::-;24543:8;::::0;24520:78:::1;::::0;24543:8:::1;;24553:10;24565:32;24578:19:::0;24565:10;:32:::1;:::i;:::-;24520:22;:78::i;:::-;24713:8;::::0;24735:33:::1;::::0;;;;24762:4:::1;24735:33;::::0;::::1;359:74:1::0;24690:79:0::1;::::0;24713:8:::1;;::::0;24723:10:::1;::::0;24713:8;;24735:18:::1;::::0;332::1;;24735:33:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;24690:79::-;24801:8;::::0;24823:33:::1;::::0;;;;24850:4:::1;24823:33;::::0;::::1;359:74:1::0;24778:79:0::1;::::0;24801:8:::1;;::::0;24811:10:::1;::::0;24801:8;;24823:18:::1;::::0;332::1;;24823:33:0::1;199:240:1::0;24778:79:0::1;-1:-1:-1::0;;20893:1:0;21855:7;:22;-1:-1:-1;;23633:1231:0:o;24907:1213::-;20937:1;21543:7;;:19;21535:63;;;;;;;646:2:1;21535:63:0;;;628:21:1;685:2;665:18;;;658:30;724:33;704:18;;;697:61;775:18;;21535:63:0;444:355:1;21535:63:0;20937:1;21676:7;:18;;;25082:4:::1;::::0;:31:::1;::::0;;;;25102:10:::1;25082:31;::::0;::::1;359:74:1::0;21676:7:0;;25082:4:::1;;::::0;:19:::1;::::0;332:18:1;;25082:31:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;::::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;25040:73;;25129:9;25124:346;25144:12;:19;25140:1;:23;25124:346;;;25182:18;25203:12;25216:1;25203:15;;;;;;;;:::i;:::-;;;;;;;:25;;;25182:46;;25257:1;25244:10;:14;25240:221;;;25275:4;::::0;25317:15;;25275:4:::1;::::0;;::::1;::::0;:29:::1;::::0;25305:10:::1;::::0;25317:12;;25330:1;;25317:15;::::1;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;:22;25275:65:::1;::::0;;::::1;::::0;;;;;;4438:42:1;4426:55;;;25275:65:0::1;::::0;::::1;4408:74:1::0;4498:18;;;4491:34;4381:18;;25275:65:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;25438:10;25419:29;;;;;:::i;:::-;;;25240:221;-1:-1:-1::0;25165:3:0;::::1;::::0;::::1;:::i;:::-;;;;25124:346;;;;25504:1;25486:15;:19;25478:49;;;::::0;::::1;::::0;;5642:2:1;25478:49:0::1;::::0;::::1;5624:21:1::0;5681:2;5661:18;;;5654:30;5720:19;5700:18;;;5693:47;5757:18;;25478:49:0::1;5440:341:1::0;25478:49:0::1;25607:27;25678:5;25656:18;;25638:15;:36;;;;:::i;:::-;25637:46;;;;:::i;:::-;25715:8;::::0;25725:19:::1;::::0;25607:76;;-1:-1:-1;25692:74:0::1;::::0;25715:8:::1;::::0;;::::1;::::0;25725:19:::1;25607:76:::0;25692:22:::1;:74::i;:::-;25798:8;::::0;25775:83:::1;::::0;25798:8:::1;;25808:10;25820:37;25838:19:::0;25820:15;:37:::1;:::i;25775:83::-;25973:8;::::0;25993:33:::1;::::0;;;;26020:4:::1;25993:33;::::0;::::1;359:74:1::0;25950:77:0::1;::::0;25973:8:::1;;::::0;25982:10:::1;::::0;25973:8;;25993:18:::1;::::0;332::1;;25993:33:0::1;199:240:1::0;25950:77:0::1;26059:8;::::0;26079:33:::1;::::0;;;;26106:4:::1;26079:33;::::0;::::1;359:74:1::0;26036:77:0::1;::::0;26059:8:::1;;::::0;26068:10:::1;::::0;26059:8;;26079:18:::1;::::0;332::1;;26079:33:0::1;199:240:1::0;26036:77:0::1;-1:-1:-1::0;;20893:1:0;21855:7;:22;-1:-1:-1;24907:1213:0:o;15445:211::-;15589:58;;;4438:42:1;4426:55;;15589:58:0;;;4408:74:1;4498:18;;;;4491:34;;;15589:58:0;;;;;;;;;;4381:18:1;;;;15589:58:0;;;;;;;;;;15612:23;15589:58;;;15562:86;;15582:5;;15562:19;:86::i;:::-;15445:211;;;:::o;18512:716::-;18936:23;18962:69;18990:4;18962:69;;;;;;;;;;;;;;;;;18970:5;18962:27;;;;:69;;;;;:::i;:::-;19046:17;;18936:95;;-1:-1:-1;19046:21:0;19042:179;;19143:10;19132:30;;;;;;;;;;;;:::i;:::-;19124:85;;;;;;;6572:2:1;19124:85:0;;;6554:21:1;6611:2;6591:18;;;6584:30;6650:34;6630:18;;;6623:62;6721:12;6701:18;;;6694:40;6751:19;;19124:85:0;6370:406:1;9314:229:0;9451:12;9483:52;9505:6;9513:4;9519:1;9522:12;9483:21;:52::i;:::-;9476:59;9314:229;-1:-1:-1;;;;9314:229:0:o;10434:455::-;10604:12;10662:5;10637:21;:30;;10629:81;;;;;;;6983:2:1;10629:81:0;;;6965:21:1;7022:2;7002:18;;;6995:30;7061:34;7041:18;;;7034:62;7132:8;7112:18;;;7105:36;7158:19;;10629:81:0;6781:402:1;10629:81:0;10722:12;10736:23;10763:6;:11;;10782:5;10789:4;10763:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10721:73;;;;10812:69;10839:6;10847:7;10856:10;10868:12;10812:26;:69::i;:::-;10805:76;10434:455;-1:-1:-1;;;;;;;10434:455:0:o;13007:644::-;13192:12;13221:7;13217:427;;;13249:10;:17;13270:1;13249:22;13245:290;;6852:19;;;;13459:60;;;;;;;7937:2:1;13459:60:0;;;7919:21:1;7976:2;7956:18;;;7949:30;8015:31;7995:18;;;7988:59;8064:18;;13459:60:0;7735:353:1;13459:60:0;-1:-1:-1;13556:10:0;13549:17;;13217:427;13599:33;13607:10;13619:12;14354:17;;:21;14350:388;;14586:10;14580:17;14643:15;14630:10;14626:2;14622:19;14615:44;14350:388;14713:12;14706:20;;;;;;;;;;;:::i;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;1035:184::-;1087:77;1084:1;1077:88;1184:4;1181:1;1174:15;1208:4;1205:1;1198:15;1224:253;1296:2;1290:9;1338:4;1326:17;;1373:18;1358:34;;1394:22;;;1355:62;1352:88;;;1420:18;;:::i;:::-;1456:2;1449:22;1224:253;:::o;1482:334::-;1553:2;1547:9;1609:2;1599:13;;1614:66;1595:86;1583:99;;1712:18;1697:34;;1733:22;;;1694:62;1691:88;;;1759:18;;:::i;:::-;1795:2;1788:22;1482:334;;-1:-1:-1;1482:334:1:o;1821:1486::-;1945:6;1976:2;2019;2007:9;1998:7;1994:23;1990:32;1987:52;;;2035:1;2032;2025:12;1987:52;2068:9;2062:16;2097:18;2138:2;2130:6;2127:14;2124:34;;;2154:1;2151;2144:12;2124:34;2192:6;2181:9;2177:22;2167:32;;2237:7;2230:4;2226:2;2222:13;2218:27;2208:55;;2259:1;2256;2249:12;2208:55;2288:2;2282:9;2310:2;2306;2303:10;2300:36;;;2316:18;;:::i;:::-;2356:36;2388:2;2383;2380:1;2376:10;2372:19;2356:36;:::i;:::-;2426:15;;;2457:12;;;;-1:-1:-1;2488:4:1;2527:11;;;2519:20;;2515:29;;;2556:19;;;2553:39;;;2588:1;2585;2578:12;2553:39;2612:11;;;;2632:645;2648:6;2643:3;2640:15;2632:645;;;2728:2;2722:3;2713:7;2709:17;2705:26;2702:116;;;2772:1;2801:2;2797;2790:14;2702:116;2844:22;;:::i;:::-;2893:10;;2879:25;;2946:12;;;2940:19;2924:14;;;2917:43;2983:2;3027:12;;;3021:19;3005:14;;;2998:43;3064:2;3108:12;;;3102:19;3086:14;;;3079:43;3145:3;3190:12;;;3184:19;3168:14;;;3161:43;3217:18;;2665:12;;;;3255;;;;2632:645;;;-1:-1:-1;3296:5:1;1821:1486;-1:-1:-1;;;;;;;1821:1486:1:o;3312:184::-;3364:77;3361:1;3354:88;3461:4;3458:1;3451:15;3485:4;3482:1;3475:15;3501:184;3553:77;3550:1;3543:88;3650:4;3647:1;3640:15;3674:4;3671:1;3664:15;3690:195;3729:3;3760:66;3753:5;3750:77;3747:103;;3830:18;;:::i;:::-;-1:-1:-1;3877:1:1;3866:13;;3690:195::o;4536:168::-;4609:9;;;4640;;4657:15;;;4651:22;;4637:37;4627:71;;4678:18;;:::i;:::-;4536:168;;;;:::o;4709:274::-;4749:1;4775;4765:189;;4810:77;4807:1;4800:88;4911:4;4908:1;4901:15;4939:4;4936:1;4929:15;4765:189;-1:-1:-1;4968:9:1;;4709:274::o;4988:128::-;5055:9;;;5076:11;;;5073:37;;;5090:18;;:::i;5121:184::-;5191:6;5244:2;5232:9;5223:7;5219:23;5215:32;5212:52;;;5260:1;5257;5250:12;5212:52;-1:-1:-1;5283:16:1;;5121:184;-1:-1:-1;5121:184:1:o;5310:125::-;5375:9;;;5396:10;;;5393:36;;;5409:18;;:::i;6088:277::-;6155:6;6208:2;6196:9;6187:7;6183:23;6179:32;6176:52;;;6224:1;6221;6214:12;6176:52;6256:9;6250:16;6309:5;6302:13;6295:21;6288:5;6285:32;6275:60;;6331:1;6328;6321:12;6275:60;6354:5;6088:277;-1:-1:-1;;;6088:277:1:o;7188:250::-;7273:1;7283:113;7297:6;7294:1;7291:13;7283:113;;;7373:11;;;7367:18;7354:11;;;7347:39;7319:2;7312:10;7283:113;;;-1:-1:-1;;7430:1:1;7412:16;;7405:27;7188:250::o;7443:287::-;7572:3;7610:6;7604:13;7626:66;7685:6;7680:3;7673:4;7665:6;7661:17;7626:66;:::i;:::-;7708:16;;;;;7443:287;-1:-1:-1;;7443:287:1:o;8093:455::-;8242:2;8231:9;8224:21;8205:4;8274:6;8268:13;8317:6;8312:2;8301:9;8297:18;8290:34;8333:79;8405:6;8400:2;8389:9;8385:18;8380:2;8372:6;8368:15;8333:79;:::i;:::-;8464:2;8452:15;8469:66;8448:88;8433:104;;;;8539:2;8429:113;;8093:455;-1:-1:-1;;8093:455:1:o

059d9fa432c27bcd7cceec0bebb9999288edb5d47c8a752a60930a279ddf166b