Contract 0x8E8C6bD1Ce1A77885325aa69F3736ED41d66532e 1

// SPDX-License-Identifier: MIT

pragma solidity 0.8.6;

import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";

import "./interfaces/IJoeFactory.sol";
import "./interfaces/IJoePair.sol";
import "./interfaces/IJoeRouter02.sol";
import "./interfaces/IRocketJoeFactory.sol";
import "./interfaces/IRocketJoeToken.sol";
import "./interfaces/IWAVAX.sol";

interface Ownable {
    function owner() external view returns (address);
}

/// @title Rocket Joe Launch Event
/// @author Trader Joe
/// @notice A liquidity launch contract enabling price discovery and token distribution at secondary market listing price
contract LaunchEvent {
    using SafeERC20Upgradeable for IERC20MetadataUpgradeable;

    /// @notice The phases the launch event can be in
    /// @dev Should these have more semantic names: Bid, Cancel, Withdraw
    enum Phase {
        NotStarted,
        PhaseOne,
        PhaseTwo,
        PhaseThree
    }

    struct UserInfo {
        /// @notice How much AVAX user can deposit for this launch event
        /// @dev Can be increased by burning more rJOE, but will always be
        /// smaller than or equal to `maxAllocation`
        uint256 allocation;
        /// @notice How much AVAX user has deposited for this launch event
        uint256 balance;
        /// @notice Whether user has withdrawn the LP
        bool hasWithdrawnPair;
        /// @notice Whether user has withdrawn the issuing token incentives
        bool hasWithdrawnIncentives;
    }

    /// @notice Issuer of sale tokens
    address public issuer;

    /// @notice The start time of phase 1
    uint256 public auctionStart;

    uint256 public phaseOneDuration;
    uint256 public phaseOneNoFeeDuration;
    uint256 public phaseTwoDuration;

    /// @dev Amount of tokens used as incentives for locking up LPs during phase 3,
    /// in parts per 1e18 and expressed as an additional percentage to the tokens for auction.
    /// E.g. if tokenIncentivesPercent = 5e16 (5%), and issuer sends 105 000 tokens,
    /// then 105 000 * 5e16 / (1e18 + 5e16) = 5 000 tokens are used for incentives
    uint256 public tokenIncentivesPercent;

    /// @notice Floor price in AVAX per token (can be 0)
    /// @dev floorPrice is scaled to 1e18
    uint256 public floorPrice;

    /// @notice Timelock duration post phase 3 when can user withdraw their LP tokens
    uint256 public userTimelock;

    /// @notice Timelock duration post phase 3 When can issuer withdraw their LP tokens
    uint256 public issuerTimelock;

    /// @notice The max withdraw penalty during phase 1, in parts per 1e18
    /// e.g. max penalty of 50% `maxWithdrawPenalty`= 5e17
    uint256 public maxWithdrawPenalty;

    /// @notice The fixed withdraw penalty during phase 2, in parts per 1e18
    /// e.g. fixed penalty of 20% `fixedWithdrawPenalty = 2e17`
    uint256 public fixedWithdrawPenalty;

    IRocketJoeToken public rJoe;
    uint256 public rJoePerAvax;
    IWAVAX private WAVAX;
    IERC20MetadataUpgradeable public token;

    IJoeRouter02 private router;
    IJoeFactory private factory;
    IRocketJoeFactory public rocketJoeFactory;

    bool public stopped;

    uint256 public maxAllocation;

    mapping(address => UserInfo) public getUserInfo;

    /// @dev The address of the JoePair, set after createLiquidityPool is called
    IJoePair public pair;

    /// @dev The total amount of avax that was sent to the router to create the initial liquidity pair.
    /// Used to calculate the amount of LP to send based on the user's participation in the launch event
    uint256 public avaxAllocated;

    /// @dev The total amount of tokens that was sent to the router to create the initial liquidity pair.
    uint256 public tokenAllocated;

    /// @dev The exact supply of LP minted when creating the initial liquidity pair.
    uint256 private lpSupply;

    /// @dev Used to know how many issuing tokens will be sent to JoeRouter to create the initial
    /// liquidity pair. If floor price is not met, we will send fewer issuing tokens and `tokenReserve`
    /// will keep track of the leftover amount. It's then used to calculate the number of tokens needed
    /// to be sent to both issuer and users (if there are leftovers and every token is sent to the pair,
    /// tokenReserve will be equal to 0)
    uint256 private tokenReserve;

    /// @dev Keeps track of amount of token incentives that needs to be kept by contract in order to send the right
    /// amounts to issuer and users
    uint256 private tokenIncentivesBalance;
    /// @dev Total incentives for users for locking their LPs for an additional period of time after the pair is created
    uint256 private tokenIncentivesForUsers;
    /// @dev The share refunded to the issuer. Users receive 5% of the token that were sent to the Router.
    /// If the floor price is not met, the incentives still needs to be 5% of the value sent to the Router, so there
    /// will be an excess of tokens returned to the issuer if he calls `withdrawIncentives()`
    uint256 private tokenIncentiveIssuerRefund;

    /// @dev avaxReserve is the exact amount of AVAX that needs to be kept inside the contract in order to send everyone's
    /// AVAX. If there is some excess (because someone sent token directly to the contract), the
    /// penaltyCollector can collect the excess using `skim()`
    uint256 private avaxReserve;

    event LaunchEventInitialized(
        uint256 tokenIncentivesPercent,
        uint256 floorPrice,
        uint256 maxWithdrawPenalty,
        uint256 fixedWithdrawPenalty,
        uint256 maxAllocation,
        uint256 userTimelock,
        uint256 issuerTimelock,
        uint256 tokenReserve,
        uint256 tokenIncentives
    );

    event UserParticipated(
        address indexed user,
        uint256 avaxAmount,
        uint256 rJoeAmount
    );

    event UserWithdrawn(
        address indexed user,
        uint256 avaxAmount,
        uint256 penaltyAmount
    );

    event IncentiveTokenWithdraw(
        address indexed user,
        address indexed token,
        uint256 amount
    );

    event LiquidityPoolCreated(
        address indexed pair,
        address indexed token0,
        address indexed token1,
        uint256 amount0,
        uint256 amount1
    );

    event UserLiquidityWithdrawn(
        address indexed user,
        address indexed pair,
        uint256 amount
    );

    event IssuerLiquidityWithdrawn(
        address indexed issuer,
        address indexed pair,
        uint256 amount
    );

    event Stopped();

    event AvaxEmergencyWithdraw(address indexed user, uint256 amount);

    event TokenEmergencyWithdraw(address indexed user, uint256 amount);

    /// @notice Modifier which ensures contract is in a defined phase
    modifier atPhase(Phase _phase) {
        _atPhase(_phase);
        _;
    }

    /// @notice Modifier which ensures the caller's timelock to withdraw has elapsed
    modifier timelockElapsed() {
        _timelockElapsed();
        _;
    }

    /// @notice Ensures launch event is stopped/running
    modifier isStopped(bool _stopped) {
        _isStopped(_stopped);
        _;
    }

    /// @notice Initialize the launch event with needed parameters
    /// @param _issuer Address of the token issuer
    /// @param _auctionStart The start time of the auction
    /// @param _token The contract address of auctioned token
    /// @param _tokenIncentivesPercent The token incentives percent, in part per 1e18, e.g 5e16 is 5% of incentives
    /// @param _floorPrice The minimum price the token is sold at
    /// @param _maxWithdrawPenalty The max withdraw penalty during phase 1, in parts per 1e18
    /// @param _fixedWithdrawPenalty The fixed withdraw penalty during phase 2, in parts per 1e18
    /// @param _maxAllocation The maximum amount of AVAX depositable per user
    /// @param _userTimelock The time a user must wait after auction ends to withdraw liquidity
    /// @param _issuerTimelock The time the issuer must wait after auction ends to withdraw liquidity
    /// @dev This function is called by the factory immediately after it creates the contract instance
    function initialize(
        address _issuer,
        uint256 _auctionStart,
        address _token,
        uint256 _tokenIncentivesPercent,
        uint256 _floorPrice,
        uint256 _maxWithdrawPenalty,
        uint256 _fixedWithdrawPenalty,
        uint256 _maxAllocation,
        uint256 _userTimelock,
        uint256 _issuerTimelock
    ) external atPhase(Phase.NotStarted) {
        require(auctionStart == 0, "LaunchEvent: already initialized");
        rocketJoeFactory = IRocketJoeFactory(msg.sender);
        require(
            _token != rocketJoeFactory.wavax(),
            "LaunchEvent: token is wavax"
        );

        WAVAX = IWAVAX(rocketJoeFactory.wavax());
        router = IJoeRouter02(rocketJoeFactory.router());
        factory = IJoeFactory(rocketJoeFactory.factory());
        rJoe = IRocketJoeToken(rocketJoeFactory.rJoe());
        rJoePerAvax = rocketJoeFactory.rJoePerAvax();

        require(
            _maxWithdrawPenalty <= 5e17,
            "LaunchEvent: maxWithdrawPenalty too big"
        ); // 50%
        require(
            _fixedWithdrawPenalty <= 5e17,
            "LaunchEvent: fixedWithdrawPenalty too big"
        ); // 50%
        require(
            _userTimelock <= 7 days,
            "LaunchEvent: can't lock user LP for more than 7 days"
        );
        require(
            _issuerTimelock > _userTimelock,
            "LaunchEvent: issuer can't withdraw before users"
        );
        require(
            _auctionStart > block.timestamp,
            "LaunchEvent: start of phase 1 cannot be in the past"
        );
        require(
            _issuer != address(0),
            "LaunchEvent: issuer must be address zero"
        );
        require(
            _maxAllocation > 0,
            "LaunchEvent: max allocation must not be zero"
        );
        require(
            _tokenIncentivesPercent < 1 ether,
            "LaunchEvent: token incentives too high"
        );

        issuer = _issuer;

        auctionStart = _auctionStart;
        phaseOneDuration = rocketJoeFactory.phaseOneDuration();
        phaseOneNoFeeDuration = rocketJoeFactory.phaseOneNoFeeDuration();
        phaseTwoDuration = rocketJoeFactory.phaseTwoDuration();

        token = IERC20MetadataUpgradeable(_token);
        uint256 balance = token.balanceOf(address(this));

        tokenIncentivesPercent = _tokenIncentivesPercent;

        /// We do this math because `tokenIncentivesForUsers + tokenReserve = tokenSent`
        /// and `tokenIncentivesForUsers = tokenReserve * 0.05` (i.e. incentives are 5% of reserves for issuing).
        /// E.g. if issuer sends 105e18 tokens, `tokenReserve = 100e18` and `tokenIncentives = 5e18`
        tokenReserve = (balance * 1e18) / (1e18 + _tokenIncentivesPercent);
        require(tokenReserve > 0, "LaunchEvent: no token balance");
        tokenIncentivesForUsers = balance - tokenReserve;
        tokenIncentivesBalance = tokenIncentivesForUsers;

        floorPrice = _floorPrice;

        maxWithdrawPenalty = _maxWithdrawPenalty;
        fixedWithdrawPenalty = _fixedWithdrawPenalty;

        maxAllocation = _maxAllocation;

        userTimelock = _userTimelock;
        issuerTimelock = _issuerTimelock;

        emit LaunchEventInitialized(
            tokenIncentivesPercent,
            floorPrice,
            maxWithdrawPenalty,
            fixedWithdrawPenalty,
            maxAllocation,
            userTimelock,
            issuerTimelock,
            tokenReserve,
            tokenIncentivesBalance
        );
    }

    /// @notice The current phase the auction is in
    function currentPhase() public view returns (Phase) {
        if (auctionStart == 0 || block.timestamp < auctionStart) {
            return Phase.NotStarted;
        } else if (block.timestamp < auctionStart + phaseOneDuration) {
            return Phase.PhaseOne;
        } else if (
            block.timestamp < auctionStart + phaseOneDuration + phaseTwoDuration
        ) {
            return Phase.PhaseTwo;
        }
        return Phase.PhaseThree;
    }

    /// @notice Deposits AVAX and burns rJoe
    function depositAVAX()
        external
        payable
        isStopped(false)
        atPhase(Phase.PhaseOne)
    {
        require(msg.sender != issuer, "LaunchEvent: issuer cannot participate");
        require(
            msg.value > 0,
            "LaunchEvent: expected non-zero AVAX to deposit"
        );

        UserInfo storage user = getUserInfo[msg.sender];
        uint256 newAllocation = user.balance + msg.value;
        require(
            newAllocation <= maxAllocation,
            "LaunchEvent: amount exceeds max allocation"
        );

        uint256 rJoeNeeded;
        // check if additional allocation is required.
        if (newAllocation > user.allocation) {
            // Get amount of rJOE tokens needed to burn and update allocation
            rJoeNeeded = getRJoeAmount(newAllocation - user.allocation);
            // Set allocation to the current balance as it's impossible
            // to buy more allocation without sending AVAX too
            user.allocation = newAllocation;
        }

        user.balance = newAllocation;
        avaxReserve += msg.value;

        if (rJoeNeeded > 0) {
            rJoe.burnFrom(msg.sender, rJoeNeeded);
        }

        emit UserParticipated(msg.sender, msg.value, rJoeNeeded);
    }

    /// @notice Withdraw AVAX, only permitted during phase 1 and 2
    /// @param _amount The amount of AVAX to withdraw
    function withdrawAVAX(uint256 _amount) external isStopped(false) {
        Phase _currentPhase = currentPhase();
        require(
            _currentPhase == Phase.PhaseOne || _currentPhase == Phase.PhaseTwo,
            "LaunchEvent: unable to withdraw"
        );
        require(_amount > 0, "LaunchEvent: invalid withdraw amount");
        UserInfo storage user = getUserInfo[msg.sender];
        require(
            user.balance >= _amount,
            "LaunchEvent: withdrawn amount exceeds balance"
        );
        user.balance -= _amount;

        uint256 feeAmount = (_amount * getPenalty()) / 1e18;
        uint256 amountMinusFee = _amount - feeAmount;

        avaxReserve -= _amount;

        if (feeAmount > 0) {
            _safeTransferAVAX(rocketJoeFactory.penaltyCollector(), feeAmount);
        }
        _safeTransferAVAX(msg.sender, amountMinusFee);
        emit UserWithdrawn(msg.sender, _amount, feeAmount);
    }

    /// @notice Create the JoePair
    /// @dev Can only be called once after phase 3 has started
    function createPair() external isStopped(false) atPhase(Phase.PhaseThree) {
        (address wavaxAddress, address tokenAddress) = (
            address(WAVAX),
            address(token)
        );
        address _pair = factory.getPair(wavaxAddress, tokenAddress);
        require(
            _pair == address(0) || IJoePair(_pair).totalSupply() == 0,
            "LaunchEvent: liquid pair already exists"
        );
        require(avaxReserve > 0, "LaunchEvent: no avax balance");

        uint256 tokenDecimals = token.decimals();
        tokenAllocated = tokenReserve;

        // Adjust the amount of tokens sent to the pool if floor price not met
        if (floorPrice > (avaxReserve * 10**tokenDecimals) / tokenAllocated) {
            tokenAllocated = (avaxReserve * 10**tokenDecimals) / floorPrice;
            tokenIncentivesForUsers =
                (tokenIncentivesForUsers * tokenAllocated) /
                tokenReserve;
            tokenIncentiveIssuerRefund =
                tokenIncentivesBalance -
                tokenIncentivesForUsers;
        }

        avaxAllocated = avaxReserve;
        avaxReserve = 0;

        tokenReserve -= tokenAllocated;

        WAVAX.deposit{value: avaxAllocated}();
        if (_pair == address(0)) {
            pair = IJoePair(factory.createPair(wavaxAddress, tokenAddress));
        } else {
            pair = IJoePair(_pair);
        }
        WAVAX.transfer(address(pair), avaxAllocated);
        token.safeTransfer(address(pair), tokenAllocated);
        lpSupply = pair.mint(address(this));

        emit LiquidityPoolCreated(
            address(pair),
            tokenAddress,
            wavaxAddress,
            tokenAllocated,
            avaxAllocated
        );
    }

    /// @notice Withdraw liquidity pool tokens
    function withdrawLiquidity() external isStopped(false) timelockElapsed {
        require(address(pair) != address(0), "LaunchEvent: pair not created");

        UserInfo storage user = getUserInfo[msg.sender];

        uint256 balance = pairBalance(msg.sender);
        require(balance > 0, "LaunchEvent: caller has no liquidity to claim");

        user.hasWithdrawnPair = true;

        if (msg.sender == issuer) {
            emit IssuerLiquidityWithdrawn(msg.sender, address(pair), balance);
        } else {
            emit UserLiquidityWithdrawn(msg.sender, address(pair), balance);
        }

        pair.transfer(msg.sender, balance);
    }

    /// @notice Withdraw incentives tokens
    function withdrawIncentives() external {
        require(address(pair) != address(0), "LaunchEvent: pair not created");

        uint256 amount = getIncentives(msg.sender);
        require(amount > 0, "LaunchEvent: caller has no incentive to claim");

        UserInfo storage user = getUserInfo[msg.sender];
        user.hasWithdrawnIncentives = true;

        if (msg.sender == issuer) {
            tokenIncentivesBalance -= tokenIncentiveIssuerRefund;
            tokenReserve = 0;
        } else {
            tokenIncentivesBalance -= amount;
        }

        token.safeTransfer(msg.sender, amount);
        emit IncentiveTokenWithdraw(msg.sender, address(token), amount);
    }

    /// @notice Withdraw AVAX if launch has been cancelled
    function emergencyWithdraw() external isStopped(true) {
        if (address(pair) == address(0)) {
            if (msg.sender != issuer) {
                UserInfo storage user = getUserInfo[msg.sender];
                require(
                    user.balance > 0,
                    "LaunchEvent: expected user to have non-zero balance to perform emergency withdraw"
                );

                uint256 balance = user.balance;
                user.balance = 0;
                avaxReserve -= balance;

                _safeTransferAVAX(msg.sender, balance);

                emit AvaxEmergencyWithdraw(msg.sender, balance);
            } else {
                uint256 balance = tokenReserve + tokenIncentivesBalance;
                tokenReserve = 0;
                tokenIncentivesBalance = 0;
                token.safeTransfer(issuer, balance);
                emit TokenEmergencyWithdraw(msg.sender, balance);
            }
        } else {
            UserInfo storage user = getUserInfo[msg.sender];

            uint256 balance = pairBalance(msg.sender);
            require(
                balance > 0,
                "LaunchEvent: caller has no liquidity to claim"
            );

            user.hasWithdrawnPair = true;

            if (msg.sender == issuer) {
                emit IssuerLiquidityWithdrawn(
                    msg.sender,
                    address(pair),
                    balance
                );
            } else {
                emit UserLiquidityWithdrawn(msg.sender, address(pair), balance);
            }

            pair.transfer(msg.sender, balance);
        }
    }

    /// @notice Stops the launch event and allows participants to withdraw deposits
    function allowEmergencyWithdraw() external {
        require(
            msg.sender == Ownable(address(rocketJoeFactory)).owner(),
            "LaunchEvent: caller is not RocketJoeFactory owner"
        );
        stopped = true;
        emit Stopped();
    }

    /// @notice Force balances to match tokens that were deposited, but not sent directly to the contract.
    /// Any excess tokens are sent to the penaltyCollector
    function skim() external {
        require(msg.sender == tx.origin, "LaunchEvent: EOA only");
        address penaltyCollector = rocketJoeFactory.penaltyCollector();

        uint256 excessToken = token.balanceOf(address(this)) -
            tokenReserve -
            tokenIncentivesBalance;
        if (excessToken > 0) {
            token.safeTransfer(penaltyCollector, excessToken);
        }

        uint256 excessAvax = address(this).balance - avaxReserve;
        if (excessAvax > 0) {
            _safeTransferAVAX(penaltyCollector, excessAvax);
        }
    }

    /// @notice Returns the current penalty for early withdrawal
    /// @return The penalty to apply to a withdrawal amount
    function getPenalty() public view returns (uint256) {
        if (block.timestamp < auctionStart) {
            return 0;
        }
        uint256 timeElapsed = block.timestamp - auctionStart;
        if (timeElapsed < phaseOneNoFeeDuration) {
            return 0;
        } else if (timeElapsed < phaseOneDuration) {
            return
                ((timeElapsed - phaseOneNoFeeDuration) * maxWithdrawPenalty) /
                (phaseOneDuration - phaseOneNoFeeDuration);
        }
        return fixedWithdrawPenalty;
    }

    /// @notice Returns the incentives for a given user
    /// @param _user The user to look up
    /// @return The amount of incentives `_user` can withdraw
    function getIncentives(address _user) public view returns (uint256) {
        UserInfo memory user = getUserInfo[_user];

        if (user.hasWithdrawnIncentives) {
            return 0;
        }

        if (_user == issuer) {
            if (address(pair) == address(0)) return tokenIncentiveIssuerRefund;
            return tokenIncentiveIssuerRefund + tokenReserve;
        } else {
            if (avaxAllocated == 0) return 0;
            return (user.balance * tokenIncentivesForUsers) / avaxAllocated;
        }
    }

    /// @notice Returns the outstanding balance of the launch event contract
    /// @return The balances of AVAX and issued token held by the launch contract
    function getReserves() external view returns (uint256, uint256) {
        return (avaxReserve, tokenReserve + tokenIncentivesBalance);
    }

    /// @notice Get the rJOE amount needed to deposit AVAX
    /// @param _avaxAmount The amount of AVAX to deposit
    /// @return The amount of rJOE needed
    function getRJoeAmount(uint256 _avaxAmount) public view returns (uint256) {
        return (_avaxAmount * rJoePerAvax) / 1e18;
    }

    /// @notice The total amount of liquidity pool tokens the user can withdraw
    /// @param _user The address of the user to check
    /// @return The user's balance of liquidity pool token
    function pairBalance(address _user) public view returns (uint256) {
        UserInfo memory user = getUserInfo[_user];
        if (avaxAllocated == 0 || user.hasWithdrawnPair) {
            return 0;
        }
        if (msg.sender == issuer) {
            return lpSupply / 2;
        }
        return (user.balance * lpSupply) / avaxAllocated / 2;
    }

    /// @dev Bytecode size optimization for the `atPhase` modifier
    /// This works becuase internal functions are not in-lined in modifiers
    function _atPhase(Phase _phase) internal view {
        require(currentPhase() == _phase, "LaunchEvent: wrong phase");
    }

    /// @dev Bytecode size optimization for the `timelockElapsed` modifier
    /// This works becuase internal functions are not in-lined in modifiers
    function _timelockElapsed() internal view {
        uint256 phase3Start = auctionStart +
            phaseOneDuration +
            phaseTwoDuration;
        if (msg.sender == issuer) {
            require(
                block.timestamp > phase3Start + issuerTimelock,
                "LaunchEvent: can't withdraw before issuer's timelock"
            );
        } else {
            require(
                block.timestamp > phase3Start + userTimelock,
                "LaunchEvent: can't withdraw before user's timelock"
            );
        }
    }

    /// @dev Bytecode size optimization for the `isStopped` modifier
    /// This works becuase internal functions are not in-lined in modifiers
    function _isStopped(bool _stopped) internal view {
        if (_stopped) {
            require(stopped, "LaunchEvent: is still running");
        } else {
            require(!stopped, "LaunchEvent: stopped");
        }
    }

    /// @notice Send AVAX
    /// @param _to The receiving address
    /// @param _value The amount of AVAX to send
    /// @dev Will revert on failure
    function _safeTransferAVAX(address _to, uint256 _value) internal {
        require(
            address(this).balance >= avaxReserve,
            "LaunchEvent: not enough avax"
        );
        (bool success, ) = _to.call{value: _value}(new bytes(0));
        require(success, "LaunchEvent: avax transfer failed");
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20Upgradeable.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20Upgradeable.sol";
import "../../../utils/AddressUpgradeable.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 SafeERC20Upgradeable {
    using AddressUpgradeable for address;

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

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

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

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.6;

interface IJoeFactory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function migrator() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    function setMigrator(address) external;
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.6;

interface IJoePair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to)
        external
        returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.6;

import "./IJoeRouter01.sol";

interface IJoeRouter02 is IJoeRouter01 {
    function removeLiquidityAVAXSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountAVAXMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountAVAX);

    function removeLiquidityAVAXWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountAVAXMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountAVAX);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function swapExactAVAXForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForAVAXSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.6;

interface IRocketJoeFactory {
    event RJLaunchEventCreated(
        address indexed launchEvent,
        address indexed issuer,
        address indexed token,
        uint256 phaseOneStartTime,
        uint256 phaseTwoStartTime,
        uint256 phaseThreeStartTime,
        address rJoe,
        uint256 rJoePerAvax
    );
    event SetRJoe(address indexed token);
    event SetPenaltyCollector(address indexed collector);
    event SetRouter(address indexed router);
    event SetFactory(address indexed factory);
    event SetRJoePerAvax(uint256 rJoePerAvax);
    event SetEventImplementation(address indexed implementation);
    event IssuingTokenDeposited(address indexed token, uint256 amount);
    event PhaseDurationChanged(uint256 phase, uint256 duration);
    event NoFeeDurationChanged(uint256 duration);

    function eventImplementation() external view returns (address);

    function penaltyCollector() external view returns (address);

    function wavax() external view returns (address);

    function rJoePerAvax() external view returns (uint256);

    function router() external view returns (address);

    function factory() external view returns (address);

    function rJoe() external view returns (address);

    function phaseOneDuration() external view returns (uint256);

    function phaseOneNoFeeDuration() external view returns (uint256);

    function phaseTwoDuration() external view returns (uint256);

    function getRJLaunchEvent(address token)
        external
        view
        returns (address launchEvent);

    function isRJLaunchEvent(address token) external view returns (bool);

    function allRJLaunchEvents(uint256) external view returns (address pair);

    function numLaunchEvents() external view returns (uint256);

    function createRJLaunchEvent(
        address _issuer,
        uint256 _phaseOneStartTime,
        address _token,
        uint256 _tokenAmount,
        uint256 _tokenIncentivesPercent,
        uint256 _floorPrice,
        uint256 _maxWithdrawPenalty,
        uint256 _fixedWithdrawPenalty,
        uint256 _maxAllocation,
        uint256 _userTimelock,
        uint256 _issuerTimelock
    ) external returns (address pair);

    function setPenaltyCollector(address) external;

    function setRouter(address) external;

    function setFactory(address) external;

    function setRJoePerAvax(uint256) external;

    function setPhaseDuration(uint256, uint256) external;

    function setPhaseOneNoFeeDuration(uint256) external;

    function setEventImplementation(address) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity 0.8.6;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IRocketJoeToken {
    /**
     * @dev Initialize variables.
     *
     * Needs to be called by RocketJoeFactory.
     */
    function initialize() external;

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

    /**
     * @dev Destroys `amount` tokens from `from`.
     *
     * See {ERC20-_burn}.
     */
    function burnFrom(address from, uint256 amount) external;

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

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.6;

interface IWAVAX {
    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256) external;

    function balanceOf(address account) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.6;

interface IJoeRouter01 {
    function factory() external pure returns (address);

    function WAVAX() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityAVAX(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountAVAXMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountAVAX,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityAVAX(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountAVAXMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountToken, uint256 amountAVAX);

    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountA, uint256 amountB);

    function removeLiquidityAVAXWithPermit(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountAVAXMin,
        address to,
        uint256 deadline,
        bool approveMax,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external returns (uint256 amountToken, uint256 amountAVAX);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactAVAXForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapTokensForExactAVAX(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForAVAX(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapAVAXForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) external pure returns (uint256 amountB);

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountOut);

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) external pure returns (uint256 amountIn);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {}
}

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AvaxEmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IncentiveTokenWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"issuer","type":"address"},{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"IssuerLiquidityWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenIncentivesPercent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"floorPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maxWithdrawPenalty","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fixedWithdrawPenalty","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maxAllocation","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"userTimelock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"issuerTimelock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenReserve","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tokenIncentives","type":"uint256"}],"name":"LaunchEventInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"address","name":"token0","type":"address"},{"indexed":true,"internalType":"address","name":"token1","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"LiquidityPoolCreated","type":"event"},{"anonymous":false,"inputs":[],"name":"Stopped","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenEmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UserLiquidityWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"avaxAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rJoeAmount","type":"uint256"}],"name":"UserParticipated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"avaxAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"penaltyAmount","type":"uint256"}],"name":"UserWithdrawn","type":"event"},{"inputs":[],"name":"allowEmergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"auctionStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"avaxAllocated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentPhase","outputs":[{"internalType":"enum LaunchEvent.Phase","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depositAVAX","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fixedWithdrawPenalty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"floorPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getIncentives","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPenalty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_avaxAmount","type":"uint256"}],"name":"getRJoeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"getUserInfo","outputs":[{"internalType":"uint256","name":"allocation","type":"uint256"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"bool","name":"hasWithdrawnPair","type":"bool"},{"internalType":"bool","name":"hasWithdrawnIncentives","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_issuer","type":"address"},{"internalType":"uint256","name":"_auctionStart","type":"uint256"},{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_tokenIncentivesPercent","type":"uint256"},{"internalType":"uint256","name":"_floorPrice","type":"uint256"},{"internalType":"uint256","name":"_maxWithdrawPenalty","type":"uint256"},{"internalType":"uint256","name":"_fixedWithdrawPenalty","type":"uint256"},{"internalType":"uint256","name":"_maxAllocation","type":"uint256"},{"internalType":"uint256","name":"_userTimelock","type":"uint256"},{"internalType":"uint256","name":"_issuerTimelock","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"issuer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"issuerTimelock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxAllocation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWithdrawPenalty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"contract IJoePair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pairBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phaseOneDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phaseOneNoFeeDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phaseTwoDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rJoe","outputs":[{"internalType":"contract IRocketJoeToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rJoePerAvax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rocketJoeFactory","outputs":[{"internalType":"contract IRocketJoeFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"skim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stopped","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20MetadataUpgradeable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenAllocated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIncentivesPercent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"userTimelock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawAVAX","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawIncentives","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405234801561001057600080fd5b50615b6e80620000216000396000f3fe60806040526004361061020f5760003560e01c80637cc8850411610118578063b49fe2c0116100a0578063e087cd551161006f578063e087cd551461070c578063e56e56db14610723578063f3fbd7d61461074e578063f4b3b7d714610779578063fc0c546a146107a45761020f565b8063b49fe2c014610674578063d26c3f311461069f578063da5a9ded146106ca578063db2e21bc146106f55761020f565b80639b3ba79f116100e75780639b3ba79f146105d45780639e78fb4f146105ff578063a0d065c314610616578063a8aa1b3114610620578063aeb5cd5e1461064b5761020f565b80637cc885041461052a5780637ea382c114610567578063853920401461057e5780639363c812146105a95761020f565b8063382db5b51161019b5780636386c1c71161016a5780636386c1c71461042c57806375f12b211461046c57806378912f531461049757806378f7aeee146104d45780637b2020c6146104ff5761020f565b8063382db5b51461036e5780634f245ef7146103ab5780635822213f146103d65780635dd39c19146104015761020f565b80631a26af7a116101e25780631a26af7a146102bf5780631d143848146102d65780631dd19cb41461030157806325e5be61146103185780632a0a8d5b146103435761020f565b806302ee594b14610214578063055ad42e1461023d5780630902f1ac14610268578063145b026714610294575b600080fd5b34801561022057600080fd5b5061023b60048036038101906102369190613ecd565b6107cf565b005b34801561024957600080fd5b5061025261144c565b60405161025f9190614716565b60405180910390f35b34801561027457600080fd5b5061027d6114c2565b60405161028b929190614bce565b60405180910390f35b3480156102a057600080fd5b506102a96114e0565b6040516102b691906146fb565b60405180910390f35b3480156102cb57600080fd5b506102d4611506565b005b3480156102e257600080fd5b506102eb61165c565b6040516102f89190614622565b60405180910390f35b34801561030d57600080fd5b50610316611680565b005b34801561032457600080fd5b5061032d6118dd565b60405161033a9190614bb3565b60405180910390f35b34801561034f57600080fd5b506103586118e3565b6040516103659190614bb3565b60405180910390f35b34801561037a57600080fd5b5061039560048036038101906103909190613e73565b6118e9565b6040516103a29190614bb3565b60405180910390f35b3480156103b757600080fd5b506103c0611a42565b6040516103cd9190614bb3565b60405180910390f35b3480156103e257600080fd5b506103eb611a48565b6040516103f89190614bb3565b60405180910390f35b34801561040d57600080fd5b50610416611a4e565b6040516104239190614bb3565b60405180910390f35b34801561043857600080fd5b50610453600480360381019061044e9190613e73565b611a54565b6040516104639493929190614bf7565b60405180910390f35b34801561047857600080fd5b50610481611a9e565b60405161048e919061468f565b60405180910390f35b3480156104a357600080fd5b506104be60048036038101906104b99190613e73565b611ab1565b6040516104cb9190614bb3565b60405180910390f35b3480156104e057600080fd5b506104e9611c69565b6040516104f69190614bb3565b60405180910390f35b34801561050b57600080fd5b50610514611c6f565b6040516105219190614bb3565b60405180910390f35b34801561053657600080fd5b50610551600480360381019061054c9190613fd9565b611c75565b60405161055e9190614bb3565b60405180910390f35b34801561057357600080fd5b5061057c611c9f565b005b34801561058a57600080fd5b50610593612011565b6040516105a09190614bb3565b60405180910390f35b3480156105b557600080fd5b506105be612017565b6040516105cb9190614bb3565b60405180910390f35b3480156105e057600080fd5b506105e961201d565b6040516105f69190614bb3565b60405180910390f35b34801561060b57600080fd5b50610614612023565b005b61061e61287a565b005b34801561062c57600080fd5b50610635612b42565b60405161064291906146c5565b60405180910390f35b34801561065757600080fd5b50610672600480360381019061066d9190613fd9565b612b68565b005b34801561068057600080fd5b50610689612e65565b6040516106969190614bb3565b60405180910390f35b3480156106ab57600080fd5b506106b4612e6b565b6040516106c19190614bb3565b60405180910390f35b3480156106d657600080fd5b506106df612e71565b6040516106ec9190614bb3565b60405180910390f35b34801561070157600080fd5b5061070a612e77565b005b34801561071857600080fd5b506107216133f5565b005b34801561072f57600080fd5b506107386136a5565b6040516107459190614bb3565b60405180910390f35b34801561075a57600080fd5b50610763613731565b60405161077091906146e0565b60405180910390f35b34801561078557600080fd5b5061078e613757565b60405161079b9190614bb3565b60405180910390f35b3480156107b057600080fd5b506107b961375d565b6040516107c691906146aa565b60405180910390f35b60006107da81613783565b60006001541461081f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161081690614ab3565b60405180910390fd5b33601160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663117be4c26040518163ffffffff1660e01b815260040160206040518083038186803b1580156108c857600080fd5b505afa1580156108dc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109009190613ea0565b73ffffffffffffffffffffffffffffffffffffffff168973ffffffffffffffffffffffffffffffffffffffff16141561096e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161096590614753565b60405180910390fd5b601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663117be4c26040518163ffffffff1660e01b815260040160206040518083038186803b1580156109d657600080fd5b505afa1580156109ea573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a0e9190613ea0565b600d60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663f887ea406040518163ffffffff1660e01b815260040160206040518083038186803b158015610ab657600080fd5b505afa158015610aca573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610aee9190613ea0565b600f60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c45a01556040518163ffffffff1660e01b815260040160206040518083038186803b158015610b9657600080fd5b505afa158015610baa573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bce9190613ea0565b601060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663145b02676040518163ffffffff1660e01b815260040160206040518083038186803b158015610c7657600080fd5b505afa158015610c8a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cae9190613ea0565b600b60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663853920406040518163ffffffff1660e01b815260040160206040518083038186803b158015610d5657600080fd5b505afa158015610d6a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d8e9190614006565b600c819055506706f05b59d3b20000861115610ddf576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dd6906149b3565b60405180910390fd5b6706f05b59d3b20000851115610e2a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e2190614993565b60405180910390fd5b62093a80831115610e70576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e6790614833565b60405180910390fd5b828211610eb2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ea990614b93565b60405180910390fd5b428a11610ef4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eeb90614af3565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168b73ffffffffffffffffffffffffffffffffffffffff161415610f64576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f5b90614813565b60405180910390fd5b60008411610fa7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f9e90614a53565b60405180910390fd5b670de0b6b3a76400008810610ff1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fe890614a33565b60405180910390fd5b8a6000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555089600181905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663d26c3f316040518163ffffffff1660e01b815260040160206040518083038186803b1580156110a057600080fd5b505afa1580156110b4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110d89190614006565b600281905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166325e5be616040518163ffffffff1660e01b815260040160206040518083038186803b15801561114657600080fd5b505afa15801561115a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061117e9190614006565b600381905550601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635dd39c196040518163ffffffff1660e01b815260040160206040518083038186803b1580156111ec57600080fd5b505afa158015611200573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112249190614006565b60048190555088600e60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016112c89190614622565b60206040518083038186803b1580156112e057600080fd5b505afa1580156112f4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113189190614006565b90508860058190555088670de0b6b3a76400006113359190614cfb565b670de0b6b3a7640000826113499190614ef3565b6113539190614d51565b60188190555060006018541161139e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611395906147b3565b60405180910390fd5b601854816113ac9190614f4d565b601a81905550601a54601981905550876006819055508660098190555085600a819055508460128190555083600781905550826008819055507f403b44ba5bd4a00c008a3cbf335e20d2d9bd8c0d486ca3f37c129e91daee84d6600554600654600954600a5460125460075460085460185460195460405161143699989796959493929190614c3c565b60405180910390a1505050505050505050505050565b600080600154148061145f575060015442105b1561146d57600090506114bf565b60025460015461147d9190614cfb565b42101561148d57600190506114bf565b6004546002546001546114a09190614cfb565b6114aa9190614cfb565b4210156114ba57600290506114bf565b600390505b90565b600080601c546019546018546114d89190614cfb565b915091509091565b600b60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16638da5cb5b6040518163ffffffff1660e01b815260040160206040518083038186803b15801561156e57600080fd5b505afa158015611582573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115a69190613ea0565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611613576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161160a90614913565b60405180910390fd5b6001601160146101000a81548160ff0219169083151502179055507f7acc84e34091ae817647a4c49116f5cc07f319078ba80f8f5fde37ea7e25cbd660405160405180910390a1565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b3273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146116ee576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116e5906149f3565b60405180910390fd5b6000601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663308097b26040518163ffffffff1660e01b815260040160206040518083038186803b15801561175857600080fd5b505afa15801561176c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117909190613ea0565b90506000601954601854600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016117f59190614622565b60206040518083038186803b15801561180d57600080fd5b505afa158015611821573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118459190614006565b61184f9190614f4d565b6118599190614f4d565b905060008111156118b2576118b18282600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166137f39092919063ffffffff16565b5b6000601c54476118c29190614f4d565b905060008111156118d8576118d78382613879565b5b505050565b60035481565b60095481565b600080601360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060405180608001604052908160008201548152602001600182015481526020016002820160009054906101000a900460ff161515151581526020016002820160019054906101000a900460ff161515151581525050905060006015541480611994575080604001515b156119a3576000915050611a3d565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415611a0e576002601754611a069190614d51565b915050611a3d565b60026015546017548360200151611a259190614ef3565b611a2f9190614d51565b611a399190614d51565b9150505b919050565b60015481565b60085481565b60045481565b60136020528060005260406000206000915090508060000154908060010154908060020160009054906101000a900460ff16908060020160019054906101000a900460ff16905084565b601160149054906101000a900460ff1681565b600080601360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060405180608001604052908160008201548152602001600182015481526020016002820160009054906101000a900460ff161515151581526020016002820160019054906101000a900460ff1615151515815250509050806060015115611b5e576000915050611c64565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611c2c57600073ffffffffffffffffffffffffffffffffffffffff16601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161415611c1457601b54915050611c64565b601854601b54611c249190614cfb565b915050611c64565b60006015541415611c41576000915050611c64565b601554601a548260200151611c569190614ef3565b611c609190614d51565b9150505b919050565b60165481565b600a5481565b6000670de0b6b3a7640000600c5483611c8e9190614ef3565b611c989190614d51565b9050919050565b6000611caa816139be565b611cb2613a6c565b600073ffffffffffffffffffffffffffffffffffffffff16601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161415611d44576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d3b90614953565b60405180910390fd5b6000601360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000611d92336118e9565b905060008111611dd7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dce90614ad3565b60405180910390fd5b60018260020160006101000a81548160ff02191690831515021790555060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415611ed457601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f25f5629a2805dc97540e082b5064e0f293a9e3ab76c65e09ea158d7ab86e0ffa83604051611ec79190614bb3565b60405180910390a3611f5c565b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f861b5b4aea4c9b6c9f0a25eb3592c9028bd2a94954a4c56567f815cf38af5dca83604051611f539190614bb3565b60405180910390a35b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33836040518363ffffffff1660e01b8152600401611fb9929190614666565b602060405180830381600087803b158015611fd357600080fd5b505af1158015611fe7573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061200b9190613fac565b50505050565b600c5481565b60065481565b60125481565b600061202e816139be565b600361203981613783565b600080600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16915091506000601060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663e6a4390584846040518363ffffffff1660e01b81526004016120e592919061463d565b60206040518083038186803b1580156120fd57600080fd5b505afa158015612111573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121359190613ea0565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614806121ef575060008173ffffffffffffffffffffffffffffffffffffffff166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156121b557600080fd5b505afa1580156121c9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121ed9190614006565b145b61222e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612225906147d3565b60405180910390fd5b6000601c5411612273576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161226a90614933565b60405180910390fd5b6000600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663313ce5676040518163ffffffff1660e01b815260040160206040518083038186803b1580156122dd57600080fd5b505afa1580156122f1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906123159190614033565b60ff16905060185460168190555060165481600a6123339190614dd5565b601c546123409190614ef3565b61234a9190614d51565b60065411156123ba5760065481600a6123639190614dd5565b601c546123709190614ef3565b61237a9190614d51565b601681905550601854601654601a546123939190614ef3565b61239d9190614d51565b601a81905550601a546019546123b39190614f4d565b601b819055505b601c546015819055506000601c81905550601654601860008282546123df9190614f4d565b92505081905550600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663d0e30db06015546040518263ffffffff1660e01b81526004016000604051808303818588803b15801561245257600080fd5b505af1158015612466573d6000803e3d6000fd5b5050505050600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561259457601060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c9c6539685856040518363ffffffff1660e01b81526004016124fd92919061463d565b602060405180830381600087803b15801561251757600080fd5b505af115801561252b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061254f9190613ea0565b601460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506125d6565b81601460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166015546040518363ffffffff1660e01b8152600401612657929190614666565b602060405180830381600087803b15801561267157600080fd5b505af1158015612685573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906126a99190613fac565b5061271b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16601654600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166137f39092919063ffffffff16565b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16636a627842306040518263ffffffff1660e01b81526004016127769190614622565b602060405180830381600087803b15801561279057600080fd5b505af11580156127a4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127c89190614006565b6017819055508373ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f5c40bbf7a34ef1e42b8d0c2ea5fd1e07027254ce0a1ccf4f8ced71dacb8e596b60165460155460405161286a929190614bce565b60405180910390a4505050505050565b6000612885816139be565b600161289081613783565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141561291f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161291690614873565b60405180910390fd5b60003411612962576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161295990614773565b60405180910390fd5b6000601360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060003482600101546129b79190614cfb565b90506012548111156129fe576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016129f590614853565b60405180910390fd5b60008260000154821115612a3057612a24836000015483612a1f9190614f4d565b611c75565b90508183600001819055505b81836001018190555034601c6000828254612a4b9190614cfb565b925050819055506000811115612aeb57600b60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166379cc679033836040518363ffffffff1660e01b8152600401612ab8929190614666565b600060405180830381600087803b158015612ad257600080fd5b505af1158015612ae6573d6000803e3d6000fd5b505050505b3373ffffffffffffffffffffffffffffffffffffffff167fdf263dfdd75a72e5829e34d350ee8711b919e31df66d67aac31f6ed7d7cc82333483604051612b33929190614bce565b60405180910390a25050505050565b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000612b73816139be565b6000612b7d61144c565b905060016003811115612b9357612b9261511c565b5b816003811115612ba657612ba561511c565b5b1480612bd6575060026003811115612bc157612bc061511c565b5b816003811115612bd457612bd361511c565b5b145b612c15576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612c0c90614893565b60405180910390fd5b60008311612c58576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612c4f906149d3565b60405180910390fd5b6000601360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090508381600101541015612ce2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612cd9906148f3565b60405180910390fd5b83816001016000828254612cf69190614f4d565b925050819055506000670de0b6b3a7640000612d106136a5565b86612d1b9190614ef3565b612d259190614d51565b905060008186612d359190614f4d565b905085601c6000828254612d499190614f4d565b925050819055506000821115612e0357612e02601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663308097b26040518163ffffffff1660e01b815260040160206040518083038186803b158015612dc457600080fd5b505afa158015612dd8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612dfc9190613ea0565b83613879565b5b612e0d3382613879565b3373ffffffffffffffffffffffffffffffffffffffff167f43389e74a5f67d287aa20ee5677bf6eaea427b4b436414723562a06c75debdc18784604051612e55929190614bce565b60405180910390a2505050505050565b60155481565b60025481565b60075481565b6001612e82816139be565b600073ffffffffffffffffffffffffffffffffffffffff16601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614156131275760008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614613041576000601360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000816001015411612fb6576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612fad90614b13565b60405180910390fd5b6000816001015490506000826001018190555080601c6000828254612fdb9190614f4d565b92505081905550612fec3382613879565b3373ffffffffffffffffffffffffffffffffffffffff167f294f16210f954e5f97ec8fa6c28841b4e9242b2cb416033c671d1706d1802030826040516130329190614bb3565b60405180910390a25050613122565b60006019546018546130539190614cfb565b9050600060188190555060006019819055506130d260008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1682600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166137f39092919063ffffffff16565b3373ffffffffffffffffffffffffffffffffffffffff167f9b6c3d8b63229d4e633c9d23e1e20216ea84beb2e492f9c063cd4e47441dd2b4826040516131189190614bb3565b60405180910390a2505b6133f2565b6000601360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000613175336118e9565b9050600081116131ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016131b190614ad3565b60405180910390fd5b60018260020160006101000a81548160ff02191690831515021790555060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156132b757601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f25f5629a2805dc97540e082b5064e0f293a9e3ab76c65e09ea158d7ab86e0ffa836040516132aa9190614bb3565b60405180910390a361333f565b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f861b5b4aea4c9b6c9f0a25eb3592c9028bd2a94954a4c56567f815cf38af5dca836040516133369190614bb3565b60405180910390a35b601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33836040518363ffffffff1660e01b815260040161339c929190614666565b602060405180830381600087803b1580156133b657600080fd5b505af11580156133ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906133ee9190613fac565b5050505b50565b600073ffffffffffffffffffffffffffffffffffffffff16601460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161415613487576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161347e90614953565b60405180910390fd5b600061349233611ab1565b9050600081116134d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016134ce90614973565b60405180910390fd5b6000601360003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060018160020160016101000a81548160ff02191690831515021790555060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156135b357601b546019600082825461359f9190614f4d565b9250508190555060006018819055506135cd565b81601960008282546135c59190614f4d565b925050819055505b61361a3383600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166137f39092919063ffffffff16565b600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fc1038543e891141d837da01a4759fa3669d79d338a2f6989670452adfbab1168846040516136999190614bb3565b60405180910390a35050565b60006001544210156136ba576000905061372e565b6000600154426136ca9190614f4d565b90506003548110156136e057600091505061372e565b600254811015613727576003546002546136fa9190614f4d565b6009546003548361370b9190614f4d565b6137159190614ef3565b61371f9190614d51565b91505061372e565b600a549150505b90565b601160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60055481565b600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b8060038111156137965761379561511c565b5b61379e61144c565b60038111156137b0576137af61511c565b5b146137f0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016137e790614a13565b60405180910390fd5b50565b6138748363a9059cbb60e01b8484604051602401613812929190614666565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050613b88565b505050565b601c544710156138be576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016138b590614b53565b60405180910390fd5b60008273ffffffffffffffffffffffffffffffffffffffff1682600067ffffffffffffffff8111156138f3576138f261514b565b5b6040519080825280601f01601f1916602001820160405280156139255781602001600182028036833780820191505090505b50604051613933919061460b565b60006040518083038185875af1925050503d8060008114613970576040519150601f19603f3d011682016040523d82523d6000602084013e613975565b606091505b50509050806139b9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016139b090614b73565b60405180910390fd5b505050565b8015613a1857601160149054906101000a900460ff16613a13576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613a0a90614a73565b60405180910390fd5b613a69565b601160149054906101000a900460ff1615613a68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613a5f90614793565b60405180910390fd5b5b50565b6000600454600254600154613a819190614cfb565b613a8b9190614cfb565b905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415613b355760085481613aef9190614cfb565b4211613b30576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613b27906147f3565b60405180910390fd5b613b85565b60075481613b439190614cfb565b4211613b84576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613b7b906148d3565b60405180910390fd5b5b50565b6000613bea826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16613c4f9092919063ffffffff16565b9050600081511115613c4a5780806020019051810190613c0a9190613fac565b613c49576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613c4090614b33565b60405180910390fd5b5b505050565b6060613c5e8484600085613c67565b90509392505050565b606082471015613cac576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613ca3906148b3565b60405180910390fd5b613cb585613d7b565b613cf4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613ceb90614a93565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051613d1d919061460b565b60006040518083038185875af1925050503d8060008114613d5a576040519150601f19603f3d011682016040523d82523d6000602084013e613d5f565b606091505b5091509150613d6f828286613d8e565b92505050949350505050565b600080823b905060008111915050919050565b60608315613d9e57829050613dee565b600083511115613db15782518084602001fd5b816040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613de59190614731565b60405180910390fd5b9392505050565b600081359050613e0481615adc565b92915050565b600081519050613e1981615adc565b92915050565b600081519050613e2e81615af3565b92915050565b600081359050613e4381615b0a565b92915050565b600081519050613e5881615b0a565b92915050565b600081519050613e6d81615b21565b92915050565b600060208284031215613e8957613e8861517a565b5b6000613e9784828501613df5565b91505092915050565b600060208284031215613eb657613eb561517a565b5b6000613ec484828501613e0a565b91505092915050565b6000806000806000806000806000806101408b8d031215613ef157613ef061517a565b5b6000613eff8d828e01613df5565b9a50506020613f108d828e01613e34565b9950506040613f218d828e01613df5565b9850506060613f328d828e01613e34565b9750506080613f438d828e01613e34565b96505060a0613f548d828e01613e34565b95505060c0613f658d828e01613e34565b94505060e0613f768d828e01613e34565b935050610100613f888d828e01613e34565b925050610120613f9a8d828e01613e34565b9150509295989b9194979a5092959850565b600060208284031215613fc257613fc161517a565b5b6000613fd084828501613e1f565b91505092915050565b600060208284031215613fef57613fee61517a565b5b6000613ffd84828501613e34565b91505092915050565b60006020828403121561401c5761401b61517a565b5b600061402a84828501613e49565b91505092915050565b6000602082840312156140495761404861517a565b5b600061405784828501613e5e565b91505092915050565b61406981614f81565b82525050565b61407881614f93565b82525050565b600061408982614cc9565b6140938185614cdf565b93506140a381856020860161508b565b80840191505092915050565b6140b881614fe9565b82525050565b6140c78161500d565b82525050565b6140d681615031565b82525050565b6140e581615055565b82525050565b6140f481615079565b82525050565b600061410582614cd4565b61410f8185614cea565b935061411f81856020860161508b565b6141288161517f565b840191505092915050565b6000614140601b83614cea565b915061414b8261519d565b602082019050919050565b6000614163602e83614cea565b915061416e826151c6565b604082019050919050565b6000614186601483614cea565b915061419182615215565b602082019050919050565b60006141a9601d83614cea565b91506141b48261523e565b602082019050919050565b60006141cc602783614cea565b91506141d782615267565b604082019050919050565b60006141ef603483614cea565b91506141fa826152b6565b604082019050919050565b6000614212602883614cea565b915061421d82615305565b604082019050919050565b6000614235603483614cea565b915061424082615354565b604082019050919050565b6000614258602a83614cea565b9150614263826153a3565b604082019050919050565b600061427b602683614cea565b9150614286826153f2565b604082019050919050565b600061429e601f83614cea565b91506142a982615441565b602082019050919050565b60006142c1602683614cea565b91506142cc8261546a565b604082019050919050565b60006142e4603283614cea565b91506142ef826154b9565b604082019050919050565b6000614307602d83614cea565b915061431282615508565b604082019050919050565b600061432a603183614cea565b915061433582615557565b604082019050919050565b600061434d601c83614cea565b9150614358826155a6565b602082019050919050565b6000614370601d83614cea565b915061437b826155cf565b602082019050919050565b6000614393602d83614cea565b915061439e826155f8565b604082019050919050565b60006143b6602983614cea565b91506143c182615647565b604082019050919050565b60006143d9602783614cea565b91506143e482615696565b604082019050919050565b60006143fc602483614cea565b9150614407826156e5565b604082019050919050565b600061441f601583614cea565b915061442a82615734565b602082019050919050565b6000614442601883614cea565b915061444d8261575d565b602082019050919050565b6000614465602683614cea565b915061447082615786565b604082019050919050565b6000614488602c83614cea565b9150614493826157d5565b604082019050919050565b60006144ab601d83614cea565b91506144b682615824565b602082019050919050565b60006144ce601d83614cea565b91506144d98261584d565b602082019050919050565b60006144f1602083614cea565b91506144fc82615876565b602082019050919050565b6000614514602d83614cea565b915061451f8261589f565b604082019050919050565b6000614537603383614cea565b9150614542826158ee565b604082019050919050565b600061455a605183614cea565b91506145658261593d565b606082019050919050565b600061457d602a83614cea565b9150614588826159b2565b604082019050919050565b60006145a0601c83614cea565b91506145ab82615a01565b602082019050919050565b60006145c3602183614cea565b91506145ce82615a2a565b604082019050919050565b60006145e6602f83614cea565b91506145f182615a79565b604082019050919050565b61460581614fd2565b82525050565b6000614617828461407e565b915081905092915050565b60006020820190506146376000830184614060565b92915050565b60006040820190506146526000830185614060565b61465f6020830184614060565b9392505050565b600060408201905061467b6000830185614060565b61468860208301846145fc565b9392505050565b60006020820190506146a4600083018461406f565b92915050565b60006020820190506146bf60008301846140af565b92915050565b60006020820190506146da60008301846140be565b92915050565b60006020820190506146f560008301846140cd565b92915050565b600060208201905061471060008301846140dc565b92915050565b600060208201905061472b60008301846140eb565b92915050565b6000602082019050818103600083015261474b81846140fa565b905092915050565b6000602082019050818103600083015261476c81614133565b9050919050565b6000602082019050818103600083015261478c81614156565b9050919050565b600060208201905081810360008301526147ac81614179565b9050919050565b600060208201905081810360008301526147cc8161419c565b9050919050565b600060208201905081810360008301526147ec816141bf565b9050919050565b6000602082019050818103600083015261480c816141e2565b9050919050565b6000602082019050818103600083015261482c81614205565b9050919050565b6000602082019050818103600083015261484c81614228565b9050919050565b6000602082019050818103600083015261486c8161424b565b9050919050565b6000602082019050818103600083015261488c8161426e565b9050919050565b600060208201905081810360008301526148ac81614291565b9050919050565b600060208201905081810360008301526148cc816142b4565b9050919050565b600060208201905081810360008301526148ec816142d7565b9050919050565b6000602082019050818103600083015261490c816142fa565b9050919050565b6000602082019050818103600083015261492c8161431d565b9050919050565b6000602082019050818103600083015261494c81614340565b9050919050565b6000602082019050818103600083015261496c81614363565b9050919050565b6000602082019050818103600083015261498c81614386565b9050919050565b600060208201905081810360008301526149ac816143a9565b9050919050565b600060208201905081810360008301526149cc816143cc565b9050919050565b600060208201905081810360008301526149ec816143ef565b9050919050565b60006020820190508181036000830152614a0c81614412565b9050919050565b60006020820190508181036000830152614a2c81614435565b9050919050565b60006020820190508181036000830152614a4c81614458565b9050919050565b60006020820190508181036000830152614a6c8161447b565b9050919050565b60006020820190508181036000830152614a8c8161449e565b9050919050565b60006020820190508181036000830152614aac816144c1565b9050919050565b60006020820190508181036000830152614acc816144e4565b9050919050565b60006020820190508181036000830152614aec81614507565b9050919050565b60006020820190508181036000830152614b0c8161452a565b9050919050565b60006020820190508181036000830152614b2c8161454d565b9050919050565b60006020820190508181036000830152614b4c81614570565b9050919050565b60006020820190508181036000830152614b6c81614593565b9050919050565b60006020820190508181036000830152614b8c816145b6565b9050919050565b60006020820190508181036000830152614bac816145d9565b9050919050565b6000602082019050614bc860008301846145fc565b92915050565b6000604082019050614be360008301856145fc565b614bf060208301846145fc565b9392505050565b6000608082019050614c0c60008301876145fc565b614c1960208301866145fc565b614c26604083018561406f565b614c33606083018461406f565b95945050505050565b600061012082019050614c52600083018c6145fc565b614c5f602083018b6145fc565b614c6c604083018a6145fc565b614c7960608301896145fc565b614c8660808301886145fc565b614c9360a08301876145fc565b614ca060c08301866145fc565b614cad60e08301856145fc565b614cbb6101008301846145fc565b9a9950505050505050505050565b600081519050919050565b600081519050919050565b600081905092915050565b600082825260208201905092915050565b6000614d0682614fd2565b9150614d1183614fd2565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115614d4657614d456150be565b5b828201905092915050565b6000614d5c82614fd2565b9150614d6783614fd2565b925082614d7757614d766150ed565b5b828204905092915050565b6000808291508390505b6001851115614dcc57808604811115614da857614da76150be565b5b6001851615614db75780820291505b8081029050614dc585615190565b9450614d8c565b94509492505050565b6000614de082614fd2565b9150614deb83614fd2565b9250614e187fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8484614e20565b905092915050565b600082614e305760019050614eec565b81614e3e5760009050614eec565b8160018114614e545760028114614e5e57614e8d565b6001915050614eec565b60ff841115614e7057614e6f6150be565b5b8360020a915084821115614e8757614e866150be565b5b50614eec565b5060208310610133831016604e8410600b8410161715614ec25782820a905083811115614ebd57614ebc6150be565b5b614eec565b614ecf8484846001614d82565b92509050818404811115614ee657614ee56150be565b5b81810290505b9392505050565b6000614efe82614fd2565b9150614f0983614fd2565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615614f4257614f416150be565b5b828202905092915050565b6000614f5882614fd2565b9150614f6383614fd2565b925082821015614f7657614f756150be565b5b828203905092915050565b6000614f8c82614fb2565b9050919050565b60008115159050919050565b6000819050614fad82615ac8565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000614ff482614ffb565b9050919050565b600061500682614fb2565b9050919050565b60006150188261501f565b9050919050565b600061502a82614fb2565b9050919050565b600061503c82615043565b9050919050565b600061504e82614fb2565b9050919050565b600061506082615067565b9050919050565b600061507282614fb2565b9050919050565b600061508482614f9f565b9050919050565b60005b838110156150a957808201518184015260208101905061508e565b838111156150b8576000848401525b50505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b6000601f19601f8301169050919050565b60008160011c9050919050565b7f4c61756e63684576656e743a20746f6b656e2069732077617661780000000000600082015250565b7f4c61756e63684576656e743a206578706563746564206e6f6e2d7a65726f204160008201527f56415820746f206465706f736974000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a2073746f70706564000000000000000000000000600082015250565b7f4c61756e63684576656e743a206e6f20746f6b656e2062616c616e6365000000600082015250565b7f4c61756e63684576656e743a206c6971756964207061697220616c726561647960008201527f2065786973747300000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a2063616e2774207769746864726177206265666f60008201527f72652069737375657227732074696d656c6f636b000000000000000000000000602082015250565b7f4c61756e63684576656e743a20697373756572206d757374206265206164647260008201527f657373207a65726f000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a2063616e2774206c6f636b2075736572204c502060008201527f666f72206d6f7265207468616e20372064617973000000000000000000000000602082015250565b7f4c61756e63684576656e743a20616d6f756e742065786365656473206d61782060008201527f616c6c6f636174696f6e00000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206973737565722063616e6e6f7420706172746960008201527f6369706174650000000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a20756e61626c6520746f20776974686472617700600082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a2063616e2774207769746864726177206265666f60008201527f7265207573657227732074696d656c6f636b0000000000000000000000000000602082015250565b7f4c61756e63684576656e743a2077697468647261776e20616d6f756e7420657860008201527f63656564732062616c616e636500000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a2063616c6c6572206973206e6f7420526f636b6560008201527f744a6f65466163746f7279206f776e6572000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206e6f20617661782062616c616e636500000000600082015250565b7f4c61756e63684576656e743a2070616972206e6f742063726561746564000000600082015250565b7f4c61756e63684576656e743a2063616c6c657220686173206e6f20696e63656e60008201527f7469766520746f20636c61696d00000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206669786564576974686472617750656e616c7460008201527f7920746f6f206269670000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206d6178576974686472617750656e616c74792060008201527f746f6f2062696700000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a20696e76616c696420776974686472617720616d60008201527f6f756e7400000000000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a20454f41206f6e6c790000000000000000000000600082015250565b7f4c61756e63684576656e743a2077726f6e672070686173650000000000000000600082015250565b7f4c61756e63684576656e743a20746f6b656e20696e63656e746976657320746f60008201527f6f20686967680000000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206d617820616c6c6f636174696f6e206d75737460008201527f206e6f74206265207a65726f0000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206973207374696c6c2072756e6e696e67000000600082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f4c61756e63684576656e743a20616c726561647920696e697469616c697a6564600082015250565b7f4c61756e63684576656e743a2063616c6c657220686173206e6f206c6971756960008201527f6469747920746f20636c61696d00000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a207374617274206f66207068617365203120636160008201527f6e6e6f7420626520696e20746865207061737400000000000000000000000000602082015250565b7f4c61756e63684576656e743a206578706563746564207573657220746f20686160008201527f7665206e6f6e2d7a65726f2062616c616e636520746f20706572666f726d206560208201527f6d657267656e6379207769746864726177000000000000000000000000000000604082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206e6f7420656e6f756768206176617800000000600082015250565b7f4c61756e63684576656e743a2061766178207472616e73666572206661696c6560008201527f6400000000000000000000000000000000000000000000000000000000000000602082015250565b7f4c61756e63684576656e743a206973737565722063616e27742077697468647260008201527f6177206265666f72652075736572730000000000000000000000000000000000602082015250565b60048110615ad957615ad861511c565b5b50565b615ae581614f81565b8114615af057600080fd5b50565b615afc81614f93565b8114615b0757600080fd5b50565b615b1381614fd2565b8114615b1e57600080fd5b50565b615b2a81614fdc565b8114615b3557600080fd5b5056fea26469706673582212200fdc8350d33108bee0dcdaed6dfe28b02c7b2bc21055fbfb901e9298fab5ab4f64736f6c63430008060033