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

import "@openzeppelin-4.5.0/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin-4.5.0/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin-4.5.0/contracts/access/Ownable.sol";
import {ReentrancyGuardTransient} from "../base/ReentrancyGuardTransient.sol";

import "./interfaces/IIFOV10.sol";
import "./libraries/IFOLibV10.sol";

/**
 * @title IFOInitializableV10
 */
contract IFOInitializableV10 is IIFOV10, ReentrancyGuardTransient, Ownable {
    using SafeERC20 for IERC20;

    address public NATIVE = address(0);

    // Whether it is initialized
    bool private isInitialized;

    // all the addresses
    // [0] lpToken0 [1] lpToken1 [2] offeringToken [3] adminAddress
    address[4] public addresses;

    // The timestamp when IFO starts
    uint256 public startTimestamp;

    // The timestamp when IFO ends
    uint256 public endTimestamp;

    // Max buffer seconds (for sanity checks)
    uint256 public MAX_BUFFER_SECONDS;

    // Max pool id
    uint8 public MAX_POOL_ID;

    // Total tokens distributed across the pools
    uint256 public totalTokensOffered;

    // Struct that contains each pool characteristics
    struct PoolCharacteristics {
        uint256 raisingAmountPool; // amount of tokens raised for the pool (in LP tokens)
        uint256 offeringAmountPool; // amount of tokens offered for the pool (in offeringTokens)
        uint256 limitPerUserInLP; // limit of tokens per user (if 0, it is ignored)
        bool hasTax; // tax on the overflow (if any, it works with _calculateTaxOverflow)
        uint256 flatTaxRate; // new rate for flat tax
        uint256 totalAmountPool; // total amount pool deposited (in LP tokens)
        uint256 sumTaxesOverflow; // total taxes collected (starts at 0, increases with each harvest if overflow)
        VestingConfig vestingConfig;
    }

    // Array of PoolCharacteristics of size NUMBER_POOLS
    PoolCharacteristics[2] private _poolInformation;

    // Struct that contains each user information for both pools
    struct UserInfo {
        uint256 amountPool; // How many tokens the user has provided for pool
        bool claimedPool; // Whether the user has claimed (default: false) for pool
    }

    // It maps the address to pool id to UserInfo
    mapping(address => mapping(uint8 => UserInfo)) private _userInfo;

    // vesting startTime, everyone will be started at same timestamp
    uint256 public vestingStartTime;

    // A flag for vesting is being revoked
    bool public vestingRevoked;

    // Struct that contains vesting schedule
    struct VestingSchedule {
        bool isVestingInitialized;
        // beneficiary of tokens after they are released
        address beneficiary;
        // pool id
        uint8 pid;
        // total amount of tokens to be released at the end of the vesting
        uint256 amountTotal;
        // amount of tokens has been released
        uint256 released;
    }

    bytes32[] private vestingSchedulesIds;
    mapping(bytes32 => VestingSchedule) private vestingSchedules;
    uint256 private vestingSchedulesTotalAmount;
    mapping(address => uint256) private holdersVestingCount;

    // Admin withdraw events
    event AdminWithdraw(uint256 amountLP0, uint256 amountLP1, uint256 amountOfferingToken);

    // Admin recovers token
    event AdminTokenRecovery(address tokenAddress, uint256 amountTokens);

    // Deposit event
    event Deposit(address indexed user, uint256 amount, uint8 indexed pid);

    // Harvest event
    event Harvest(address indexed user, uint256 offeringAmount, uint256 excessAmount, uint8 indexed pid);

    // Create VestingSchedule event
    event CreateVestingSchedule(address indexed user, uint256 offeringAmount, uint256 excessAmount, uint8 indexed pid);

    // Event for new start & end timestamps
    event NewStartAndEndTimestamps(uint256 startTimestamp, uint256 endTimestamp);

    // Event when parameters are set for one of the pools
    event PoolParametersSet(uint256 offeringAmountPool, uint256 raisingAmountPool, uint8 pid);

    // Event when released new amount
    event Released(address indexed beneficiary, uint256 amount);

    // Event when revoked
    event Revoked();

    error PoolIdNotValid();
    error TokensNotDepositedProperly();
    error NewAmountAboveUserLimit();
    error InvalidToken();
    error VestingOnlyBeneficiaryOrOwnerCanRelease();
    error VestingNotEnoughToRelease();
    error VestingIsRevoked();
    error NativeTransferFailed();

    /**
     * @notice Constructor
     */
    constructor() {}

    /**
     * @notice It initializes the contract
     * @dev It can only be called once.
     * @param _addresses [0] lpToken0 [1] lpToken1 [2] offeringToken [3] adminAddress
     * @param _startAndEndTimestamps [0] startTimestamp [1] endTimestamp
     * @param _maxBufferSeconds Maximum buffer of blocks from the current block number
     * @param _maxPoolId Maximum id of pools
     * @param _vestingStartTime The start timestamp of vesting
     */
    function initialize(
        address[] calldata _addresses,
        uint256[] calldata _startAndEndTimestamps,
        uint256 _maxBufferSeconds,
        uint8 _maxPoolId,
        uint256 _vestingStartTime
    ) public {
        // Check validation
        IFOLibV10.InitializePreCheck(isInitialized, _addresses.length, _startAndEndTimestamps.length, _maxPoolId);

        // Make this contract initialized
        isInitialized = true;

        // [0] lpToken0 [1] lpToken1 [2] offeringToken [3] adminAddress
        for (uint8 i = 0; i < _addresses.length; i++) {
            addresses[i] = _addresses[i];
        }

        startTimestamp = _startAndEndTimestamps[0];
        endTimestamp = _startAndEndTimestamps[1];
        MAX_BUFFER_SECONDS = _maxBufferSeconds;
        MAX_POOL_ID = _maxPoolId;
        vestingStartTime = _vestingStartTime;

        // Transfer ownership to admin
        transferOwnership(_addresses[3]);
    }

    /**
     * @notice It allows users to deposit LP tokens to pool
     * @param _amount The number of LP token used (18 decimals)
     * @param _pid Pool id
     */
    function depositPool(uint256 _amount, uint8 _pid) external payable override nonReentrant {
        // Checks whether the pool id is valid
        _checkPid(_pid);

        // Check validation
        IFOLibV10.DepositPoolPreCheck(
            _amount,
            _poolInformation[_pid].offeringAmountPool,
            _poolInformation[_pid].raisingAmountPool,
            startTimestamp,
            endTimestamp
        );

        // Verify tokens were deposited properly
        if (IERC20(addresses[2]).balanceOf(address(this)) < totalTokensOffered) {
            revert TokensNotDepositedProperly();
        }

        _deposit(_amount, _pid);
    }

    /**
     * @notice It allows users to harvest from pool
     * @param _pid Pool id
     */
    function harvestPool(uint8 _pid) external override nonReentrant {
        // Checks whether the pool id is valid
        _checkPid(_pid);

        // Check validation
        IFOLibV10.HarvestPoolPreCheck(
            endTimestamp, _userInfo[msg.sender][_pid].amountPool, _userInfo[msg.sender][_pid].claimedPool
        );

        // Updates the harvest status
        _userInfo[msg.sender][_pid].claimedPool = true;

        // Updates the vesting startTime
        if (vestingStartTime == 0) {
            vestingStartTime = block.timestamp;
        }

        // Initialize the variables for offering, refunding user amounts, and tax amount
        (uint256 offeringTokenAmount, uint256 refundingTokenAmount, uint256 userTaxOverflow) =
            _calculateOfferingAndRefundingAmountsPool(msg.sender, _pid);

        // Increment the sumTaxesOverflow
        if (userTaxOverflow > 0) {
            _poolInformation[_pid].sumTaxesOverflow = _poolInformation[_pid].sumTaxesOverflow + userTaxOverflow;
        }

        // Transfer these tokens back to the user if quantity > 0
        if (offeringTokenAmount > 0) {
            if (100 - _poolInformation[_pid].vestingConfig.percentage > 0) {
                uint256 amount = (offeringTokenAmount * (100 - _poolInformation[_pid].vestingConfig.percentage)) / 100;

                // Transfer the tokens at TGE
                IERC20(addresses[2]).safeTransfer(msg.sender, amount);

                emit Harvest(msg.sender, amount, refundingTokenAmount, _pid);
            }
            // If this pool is Vesting modal, create a VestingSchedule for each user
            if (_poolInformation[_pid].vestingConfig.percentage > 0) {
                uint256 amount = (offeringTokenAmount * _poolInformation[_pid].vestingConfig.percentage) / 100;

                // Create VestingSchedule object
                _createVestingSchedule(msg.sender, _pid, amount);

                emit CreateVestingSchedule(msg.sender, amount, refundingTokenAmount, _pid);
            }
        }

        if (refundingTokenAmount > 0) {
            _safeTransferOut(addresses[_pid], refundingTokenAmount);
        }
    }

    /**
     * @notice It allows the admin to withdraw funds
     * @param _lp0Amount The number of LP token0 to withdraw
     * @param _lp1Amount The number of LP token1 to withdraw
     * @param _offerAmount The number of offering amount to withdraw
     * @dev This function is only callable by admin.
     */
    function finalWithdraw(uint256 _lp0Amount, uint256 _lp1Amount, uint256 _offerAmount) external override onlyOwner {
        if (_lp0Amount > 0) {
            _safeTransferOut(addresses[0], _lp0Amount);
        }

        if (_lp1Amount > 0) {
            _safeTransferOut(addresses[1], _lp1Amount);
        }

        if (_offerAmount > 0) {
            IERC20(addresses[2]).safeTransfer(msg.sender, _offerAmount);
        }

        emit AdminWithdraw(_lp0Amount, _lp1Amount, _offerAmount);
    }

    /**
     * @notice It allows the admin to recover wrong tokens sent to the contract
     * @param _tokenAddress The address of the token to withdraw (18 decimals)
     * @param _tokenAmount The number of token amount to withdraw
     * @dev This function is only callable by admin.
     */
    function recoverWrongTokens(address _tokenAddress, uint256 _tokenAmount) external onlyOwner {
        if (_tokenAddress == addresses[0] || _tokenAddress == addresses[1] || _tokenAddress == addresses[2]) {
            revert InvalidToken();
        }

        IERC20(_tokenAddress).safeTransfer(msg.sender, _tokenAmount);

        emit AdminTokenRecovery(_tokenAddress, _tokenAmount);
    }

    /**
     * @notice It sets parameters for pool
     * @param _offeringAmountPool Offering amount (in tokens)
     * @param _raisingAmountPool Raising amount (in LP tokens)
     * @param _limitPerUserInLP Limit per user (in LP tokens)
     * @param _hasTax If the pool has a tax
     * @param _flatTaxRate Flat tax rate
     * @param _pid Pool id
     * @param _vestingConfig Vesting config parameters: (percentage, cliff, duration, slicePeriodSeconds)
     *   percentage: amount of offering token to be vested when harvestPool
     *   cliff: time (in seconds), before vesting starts. eg. 3600 means vesting start after vestingStartTime + cliff
     *   duration: total vesting duration (in second)
     *   slicePeriodSeconds: how frequent vested token become available. eg. 60 means some token vested every min
     * @dev This function is only callable by admin.
     */
    function setPool(
        uint256 _offeringAmountPool,
        uint256 _raisingAmountPool,
        uint256 _limitPerUserInLP,
        bool _hasTax,
        uint256 _flatTaxRate,
        uint8 _pid,
        VestingConfig calldata _vestingConfig
    ) external override onlyOwner {
        // Checks whether the pool id is valid
        _checkPid(_pid);

        // Check validation
        IFOLibV10.SetPoolPreCheck(
            startTimestamp,
            _hasTax,
            _flatTaxRate,
            _vestingConfig.percentage,
            _vestingConfig.duration,
            _vestingConfig.slicePeriodSeconds
        );

        PoolCharacteristics storage poolInfo = _poolInformation[_pid];

        // update totalTokensOffered
        totalTokensOffered -= poolInfo.offeringAmountPool;
        totalTokensOffered += _offeringAmountPool;

        poolInfo.offeringAmountPool = _offeringAmountPool;
        poolInfo.raisingAmountPool = _raisingAmountPool;
        poolInfo.limitPerUserInLP = _limitPerUserInLP;
        poolInfo.hasTax = _hasTax;
        poolInfo.flatTaxRate = _flatTaxRate;
        poolInfo.vestingConfig.percentage = _vestingConfig.percentage;
        poolInfo.vestingConfig.cliff = _vestingConfig.cliff;
        poolInfo.vestingConfig.duration = _vestingConfig.duration;
        poolInfo.vestingConfig.slicePeriodSeconds = _vestingConfig.slicePeriodSeconds;

        emit PoolParametersSet(_offeringAmountPool, _raisingAmountPool, _pid);
    }

    /**
     * @notice It allows the admin to update start and end blocks
     * @param _startAndEndTimestamps [0] startTimestamp [1] endTimestamp
     * @dev This function is only callable by admin.
     */
    function updateStartAndEndTimestamps(uint256[] calldata _startAndEndTimestamps) external onlyOwner {
        // Check validation
        IFOLibV10.UpdateStartAndEndTimestampsPreCheck(
            MAX_BUFFER_SECONDS,
            _startAndEndTimestamps.length,
            startTimestamp,
            _startAndEndTimestamps[0], // startTimestamp
            _startAndEndTimestamps[1] // endTimestamp
        );

        startTimestamp = _startAndEndTimestamps[0];
        endTimestamp = _startAndEndTimestamps[1];

        emit NewStartAndEndTimestamps(_startAndEndTimestamps[0], _startAndEndTimestamps[1]);
    }

    /**
     * @notice It returns the pool information
     * @param _pid Pool id
     * @return raisingAmountPool Amount of LP tokens raised (in LP tokens)
     * @return offeringAmountPool Amount of tokens offered for the pool (in offeringTokens)
     * @return limitPerUserInLP Limit of tokens per user (if 0, it is ignored)
     * @return If the pool has a tax
     * @return totalAmountPool Total amount pool deposited (in LP tokens)
     * @return sumTaxesOverflow Total taxes collected (starts at 0, increases with each harvest if overflow)
     */
    function viewPoolInformation(uint256 _pid)
        external
        view
        returns (uint256, uint256, uint256, bool, uint256, uint256)
    {
        return (
            _poolInformation[_pid].raisingAmountPool,
            _poolInformation[_pid].offeringAmountPool,
            _poolInformation[_pid].limitPerUserInLP,
            _poolInformation[_pid].hasTax,
            _poolInformation[_pid].totalAmountPool,
            _poolInformation[_pid].sumTaxesOverflow
        );
    }

    /**
     * @notice It returns the pool vesting information
     * @param _pid Pool id
     * @return vestingPercentage The percentage of vesting part, claimingPercentage + vestingPercentage should be 100
     * @return vestingCliff The cliff of vesting
     * @return vestingDuration The duration of vesting
     * @return vestingSlicePeriodSeconds The slice period seconds of vesting
     */
    function viewPoolVestingInformation(uint256 _pid)
        external
        view
        override
        returns (uint256, uint256, uint256, uint256)
    {
        return (
            _poolInformation[_pid].vestingConfig.percentage,
            _poolInformation[_pid].vestingConfig.cliff,
            _poolInformation[_pid].vestingConfig.duration,
            _poolInformation[_pid].vestingConfig.slicePeriodSeconds
        );
    }

    /**
     * @notice It returns the tax overflow rate calculated for a pool
     * @dev 100,000,000,000 means 0.1 (10%) / 1 means 0.0000000000001 (0.0000001%) / 1,000,000,000,000 means 1 (100%)
     * @param _pid Pool id
     * @return It returns the tax percentage
     */
    function viewPoolTaxRateOverflow(uint256 _pid) external view returns (uint256) {
        if (!_poolInformation[_pid].hasTax) {
            return 0;
        } else {
            if (_poolInformation[_pid].flatTaxRate > 0) {
                return _poolInformation[_pid].flatTaxRate;
            } else {
                return
                    _calculateTaxOverflow(
                        _poolInformation[_pid].totalAmountPool, _poolInformation[_pid].raisingAmountPool
                    );
            }
        }
    }

    /**
     * @notice External view function to see user allocations for both pools
     * @param _user User address
     * @param _pids Array of pool id
     * @return
     */
    function viewUserAllocationPools(address _user, uint8[] calldata _pids) external view returns (uint256[] memory) {
        uint256[] memory allocationPools = new uint256[](_pids.length);
        for (uint8 i = 0; i < _pids.length; i++) {
            allocationPools[i] = _getUserAllocationPool(_user, _pids[i]);
        }
        return allocationPools;
    }

    /**
     * @notice External view function to see user information
     * @param _user User address
     * @param _pids Array of pool id
     */
    function viewUserInfo(address _user, uint8[] calldata _pids)
        external
        view
        returns (uint256[] memory, bool[] memory)
    {
        uint256[] memory amountPools = new uint256[](_pids.length);
        bool[] memory statusPools = new bool[](_pids.length);

        for (uint8 i = 0; i < _pids.length; i++) {
            uint8 pid = _pids[i];
            if (pid <= MAX_POOL_ID) {
                amountPools[i] = _userInfo[_user][pid].amountPool;
                statusPools[i] = _userInfo[_user][pid].claimedPool;
            }
        }
        return (amountPools, statusPools);
    }

    /**
     * @notice External view function to see user offering and refunding amounts for both pools
     * @param _user User address
     * @param _pids Array of pool id
     */
    function viewUserOfferingAndRefundingAmountsForPools(address _user, uint8[] calldata _pids)
        external
        view
        returns (uint256[3][] memory)
    {
        uint256[3][] memory amountPools = new uint256[3][](_pids.length);

        for (uint8 i = 0; i < _pids.length; i++) {
            uint256 userOfferingAmountPool;
            uint256 userRefundingAmountPool;
            uint256 userTaxAmountPool;

            if (_poolInformation[_pids[i]].raisingAmountPool > 0) {
                (userOfferingAmountPool, userRefundingAmountPool, userTaxAmountPool) =
                    _calculateOfferingAndRefundingAmountsPool(_user, _pids[i]);
            }

            amountPools[i] = [userOfferingAmountPool, userRefundingAmountPool, userTaxAmountPool];
        }
        return amountPools;
    }

    /**
     * @notice Returns the vesting schedule information of a given holder and index
     * @return The vesting schedule object
     */
    function getVestingScheduleByAddressAndIndex(address _holder, uint256 _index)
        external
        view
        returns (VestingSchedule memory)
    {
        return getVestingSchedule(computeVestingScheduleIdForAddressAndIndex(_holder, _index));
    }

    /**
     * @notice Returns the total amount of vesting schedules
     * @return The vesting schedule total amount
     */
    function getVestingSchedulesTotalAmount() external view returns (uint256) {
        return vestingSchedulesTotalAmount;
    }

    /**
     * @notice Release vested amount of offering tokens
     * @param _vestingScheduleId the vesting schedule identifier
     */
    function release(bytes32 _vestingScheduleId) external nonReentrant {
        // Check validation
        IFOLibV10.IsVestingInitializedPreCheck(vestingSchedules[_vestingScheduleId].isVestingInitialized);

        VestingSchedule storage vestingSchedule = vestingSchedules[_vestingScheduleId];
        bool isBeneficiary = msg.sender == vestingSchedule.beneficiary;
        if (!isBeneficiary && (msg.sender != owner())) {
            revert VestingOnlyBeneficiaryOrOwnerCanRelease();
        }
        uint256 vestedAmount = _computeReleasableAmount(vestingSchedule);
        if (vestedAmount <= 0) {
            revert VestingNotEnoughToRelease();
        }
        vestingSchedule.released = vestingSchedule.released + vestedAmount;
        vestingSchedulesTotalAmount = vestingSchedulesTotalAmount - vestedAmount;
        IERC20(addresses[2]).safeTransfer(vestingSchedule.beneficiary, vestedAmount);

        emit Released(vestingSchedule.beneficiary, vestedAmount);
    }

    /**
     * @notice Revokes all the vesting schedules
     */
    function revoke() external onlyOwner {
        if (vestingRevoked) {
            revert VestingIsRevoked();
        }

        vestingRevoked = true;
        emit Revoked();
    }

    /**
     * @notice Returns the number of vesting schedules managed by the contract
     * @return The number of vesting count
     */
    function getVestingSchedulesCount() public view returns (uint256) {
        return vestingSchedulesIds.length;
    }

    /**
     * @notice Returns the vested amount of tokens for the given vesting schedule identifier
     * @return The number of vested count
     */
    function computeReleasableAmount(bytes32 _vestingScheduleId) public view returns (uint256) {
        // Check validation
        IFOLibV10.IsVestingInitializedPreCheck(vestingSchedules[_vestingScheduleId].isVestingInitialized);

        return _computeReleasableAmount(vestingSchedules[_vestingScheduleId]);
    }

    /**
     * @notice Returns the vesting schedule information of a given identifier
     * @return The vesting schedule object
     */
    function getVestingSchedule(bytes32 _vestingScheduleId) public view returns (VestingSchedule memory) {
        return vestingSchedules[_vestingScheduleId];
    }

    /**
     * @notice Returns the amount of offering token that can be withdrawn by the owner
     * @return The amount of offering token
     */
    function getWithdrawableOfferingTokenAmount() public view returns (uint256) {
        return IERC20(addresses[2]).balanceOf(address(this)) - vestingSchedulesTotalAmount;
    }

    /**
     * @notice Computes the next vesting schedule identifier for a given holder address
     * @return The id string
     */
    function computeNextVestingScheduleIdForHolder(address _holder) public view returns (bytes32) {
        return computeVestingScheduleIdForAddressAndIndex(_holder, holdersVestingCount[_holder]);
    }

    /**
     * @notice Computes the next vesting schedule identifier for an address and an index
     * @return The id string
     */
    function computeVestingScheduleIdForAddressAndIndex(address _holder, uint256 _index) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(_holder, _index));
    }

    /**
     * @notice Computes the next vesting schedule identifier for an address and an pid
     * @return The id string
     */
    function computeVestingScheduleIdForAddressAndPid(address _holder, uint8 _pid) external view returns (bytes32) {
        // Checks whether the pool id is valid
        if (_pid > MAX_POOL_ID) {
            return bytes32(0);
        }

        bytes32 vestingScheduleId = computeVestingScheduleIdForAddressAndIndex(_holder, 0);
        VestingSchedule memory vestingSchedule = vestingSchedules[vestingScheduleId];
        if (vestingSchedule.pid == _pid) {
            return vestingScheduleId;
        } else {
            return computeVestingScheduleIdForAddressAndIndex(_holder, 1);
        }
    }

    /**
     * @notice Computes the releasable amount of tokens for a vesting schedule
     * @return The amount of releasable tokens
     */
    function _computeReleasableAmount(VestingSchedule memory _vestingSchedule) internal view returns (uint256) {
        if (block.timestamp < vestingStartTime + _poolInformation[_vestingSchedule.pid].vestingConfig.cliff) {
            return 0;
        } else if (
            block.timestamp >= vestingStartTime + _poolInformation[_vestingSchedule.pid].vestingConfig.duration
                || vestingRevoked
        ) {
            return _vestingSchedule.amountTotal - _vestingSchedule.released;
        } else {
            uint256 timeFromStart = block.timestamp - vestingStartTime;
            uint256 secondsPerSlice = _poolInformation[_vestingSchedule.pid].vestingConfig.slicePeriodSeconds;
            uint256 vestedSlicePeriods = timeFromStart / secondsPerSlice;
            uint256 vestedSeconds = vestedSlicePeriods * secondsPerSlice;
            uint256 vestedAmount = (_vestingSchedule.amountTotal * vestedSeconds)
                / _poolInformation[_vestingSchedule.pid].vestingConfig.duration;
            vestedAmount = vestedAmount - _vestingSchedule.released;
            return vestedAmount;
        }
    }

    /**
     * @notice Creates a new vesting schedule for a beneficiary
     * @param _beneficiary address of the beneficiary to whom vested tokens are transferred
     * @param _pid the pool id
     * @param _amount total amount of tokens to be released at the end of the vesting
     */
    function _createVestingSchedule(address _beneficiary, uint8 _pid, uint256 _amount) internal {
        require(
            getWithdrawableOfferingTokenAmount() >= _amount, "can not create vesting schedule with sufficient tokens"
        );

        bytes32 vestingScheduleId = computeNextVestingScheduleIdForHolder(_beneficiary);
        require(vestingSchedules[vestingScheduleId].beneficiary == address(0), "vestingScheduleId is been created");
        vestingSchedules[vestingScheduleId] = VestingSchedule(true, _beneficiary, _pid, _amount, 0);
        vestingSchedulesTotalAmount = vestingSchedulesTotalAmount + _amount;
        vestingSchedulesIds.push(vestingScheduleId);
        holdersVestingCount[_beneficiary]++;
    }

    /**
     * @notice It calculates the tax overflow given the raisingAmountPool and the totalAmountPool.
     * @dev 100,000,000,000 means 0.1 (10%) / 1 means 0.0000000000001 (0.0000001%) / 1,000,000,000,000 means 1 (100%)
     * @return It returns the tax percentage
     */
    function _calculateTaxOverflow(uint256 _totalAmountPool, uint256 _raisingAmountPool)
        internal
        pure
        returns (uint256)
    {
        uint256 ratioOverflow = _totalAmountPool / _raisingAmountPool;

        if (ratioOverflow >= 5000) {
            return 170000000; // 0.017%
        } else if (ratioOverflow >= 4000) {
            return 200000000; // 0.02%
        } else if (ratioOverflow >= 3300) {
            return 250000000; // 0.025%
        } else if (ratioOverflow >= 2700) {
            return 300000000; // 0.03%
        } else if (ratioOverflow >= 2200) {
            return 370000000; // 0.037%
        } else if (ratioOverflow >= 1800) {
            return 450000000; // 0.045%
        } else if (ratioOverflow >= 1500) {
            return 550000000; // 0.055%
        } else if (ratioOverflow >= 1250) {
            return 650000000; // 0.065%
        } else if (ratioOverflow >= 1000) {
            return 800000000; // 0.08%
        } else if (ratioOverflow >= 800) {
            return 1000000000; // 0.1%
        } else if (ratioOverflow >= 650) {
            return 1200000000; // 0.12%
        } else if (ratioOverflow >= 500) {
            return 1500000000; // 0.15%
        } else if (ratioOverflow >= 400) {
            return 2000000000; // 0.2%
        } else if (ratioOverflow >= 300) {
            return 2500000000; // 0.25%
        } else if (ratioOverflow >= 250) {
            return 3000000000; // 0.3%
        } else if (ratioOverflow >= 200) {
            return 4000000000; // 0.4%
        } else if (ratioOverflow >= 150) {
            return 5000000000; // 0.5%
        } else if (ratioOverflow >= 100) {
            return 6000000000; // 0.6%
        } else if (ratioOverflow >= 50) {
            return 8000000000; // 0.8%
        } else {
            return 10000000000; // 1%
        }
    }

    /**
     * @notice It calculates the offering amount for a user and the number of LP tokens to transfer back.
     * @param _user User address
     * @param _pid Pool id
     * @return {uint256, uint256, uint256} It returns the offering amount, the refunding amount (in LP tokens),
     * and the tax (if any, else 0)
     */
    function _calculateOfferingAndRefundingAmountsPool(address _user, uint8 _pid)
        internal
        view
        returns (uint256, uint256, uint256)
    {
        uint256 userOfferingAmount;
        uint256 userRefundingAmount;
        uint256 taxAmount;

        if (_poolInformation[_pid].totalAmountPool > _poolInformation[_pid].raisingAmountPool) {
            // Calculate allocation for the user
            uint256 allocation = _getUserAllocationPool(_user, _pid);

            // Calculate the offering amount for the user based on the offeringAmount for the pool
            userOfferingAmount = (_poolInformation[_pid].offeringAmountPool * allocation) / 1e12;

            // Calculate the payAmount
            uint256 payAmount = (_poolInformation[_pid].raisingAmountPool * allocation) / 1e12;

            // Calculate the pre-tax refunding amount
            userRefundingAmount = _userInfo[_user][_pid].amountPool - payAmount;

            // Retrieve the tax rate
            if (_poolInformation[_pid].hasTax) {
                uint256 tax = _poolInformation[_pid].flatTaxRate;

                if (tax == 0) {
                    tax = _calculateTaxOverflow(
                        _poolInformation[_pid].totalAmountPool, _poolInformation[_pid].raisingAmountPool
                    );
                }
                // Calculate the final taxAmount
                taxAmount = (userRefundingAmount * tax) / 1e12;

                // Adjust the refunding amount
                userRefundingAmount = userRefundingAmount - taxAmount;
            }
        } else {
            // _userInfo[_user] / (raisingAmount / offeringAmount)
            userOfferingAmount = (_userInfo[_user][_pid].amountPool * _poolInformation[_pid].offeringAmountPool)
                / _poolInformation[_pid].raisingAmountPool;
        }
        return (userOfferingAmount, userRefundingAmount, taxAmount);
    }

    /**
     * @notice It returns the user allocation for pool
     * @dev 100,000,000,000 means 0.1 (10%) / 1 means 0.0000000000001 (0.0000001%) / 1,000,000,000,000 means 1 (100%)
     * @param _user User address
     * @param _pid Pool id
     * @return It returns the user's share of pool
     */
    function _getUserAllocationPool(address _user, uint8 _pid) internal view returns (uint256) {
        if (_pid > MAX_POOL_ID) {
            return 0;
        }

        if (_poolInformation[_pid].totalAmountPool > 0) {
            return (_userInfo[_user][_pid].amountPool * 1e12) / _poolInformation[_pid].totalAmountPool;
        } else {
            return 0;
        }
    }

    function _deposit(uint256 _amount, uint8 _pid) internal {
        // Transfers funds to this contract
        _safeTransferIn(addresses[_pid], _amount);

        // Update the user status
        _userInfo[msg.sender][_pid].amountPool = _userInfo[msg.sender][_pid].amountPool + _amount;

        // Check if the pool has a limit per user
        if (_poolInformation[_pid].limitPerUserInLP > 0) {
            // Checks whether the limit has been reached
            if (_userInfo[msg.sender][_pid].amountPool > _poolInformation[_pid].limitPerUserInLP) {
                revert NewAmountAboveUserLimit();
            }
        }

        // Updates the totalAmount for pool
        _poolInformation[_pid].totalAmountPool = _poolInformation[_pid].totalAmountPool + _amount;

        emit Deposit(msg.sender, _amount, _pid);
    }

    function _checkPid(uint8 _pid) internal view {
        if (_pid > MAX_POOL_ID) {
            revert PoolIdNotValid();
        }
    }

    function _safeTransferIn(address token, uint256 value) internal {
        if (token == NATIVE) {
            if (msg.value != value) {
                revert NativeTransferFailed();
            }
        } else {
            if (msg.value != 0) {
                revert NativeTransferFailed();
            }
            IERC20(token).safeTransferFrom(msg.sender, address(this), value);
        }
    }

    function _safeTransferOut(address token, uint256 value) internal {
        if (token == NATIVE) {
            _safeTransferNative(msg.sender, value);
        } else {
            IERC20(token).safeTransfer(msg.sender, value);
        }
    }

    // This function is used to transfer native tokens safely
    // Copy from "solmate/src/utils/SafeTransferLib.sol"
    function _safeTransferNative(address to, uint256 amount) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the native and store if it succeeded or not.
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }

        if (!success) {
            revert NativeTransferFailed();
        }
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @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 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

/// @notice Using transient storage slot for the lock status
/// @dev credit to https://github.com/Vectorized/solady/blob/main/src/utils/ReentrancyGuardTransient.sol
abstract contract ReentrancyGuardTransient {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Unauthorized reentrant call.
    error Reentrancy();

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

    /// @dev Equivalent to: `uint32(bytes4(keccak256("Reentrancy()"))) | 1 << 71`.
    /// 9 bytes is large enough to avoid collisions in practice,
    /// but not too large to result in excessive bytecode bloat.
    uint256 private constant _REENTRANCY_GUARD_SLOT = 0x8000000000ab143c06;

    modifier nonReentrant() {
        /// @solidity memory-safe-assembly
        assembly {
            if tload(_REENTRANCY_GUARD_SLOT) {
                mstore(0x00, 0xab143c06) // `Reentrancy()`.
                revert(0x1c, 0x04)
            }
            tstore(_REENTRANCY_GUARD_SLOT, address())
        }

        _;

        /// @solidity memory-safe-assembly
        assembly {
            tstore(_REENTRANCY_GUARD_SLOT, 0)
        }
    }
}

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

/**
 * @title IIFOV10.
 * @notice It is an interface for IFOV10.sol
 */
interface IIFOV10 {
    struct VestingConfig {
        uint256 percentage;
        uint256 cliff;
        uint256 duration;
        uint256 slicePeriodSeconds;
    }

    function depositPool(uint256 _amount, uint8 _pid) external payable;

    function harvestPool(uint8 _pid) external;

    function finalWithdraw(uint256 _lp0Amount, uint256 _lp1Amount, uint256 _offerAmount) external;

    function setPool(
        uint256 _offeringAmountPool,
        uint256 _raisingAmountPool,
        uint256 _limitPerUserInLP,
        bool _hasTax,
        uint256 _flatTaxRate,
        uint8 _pid,
        VestingConfig memory _vestingConfig
    ) external;

    function viewPoolInformation(uint256 _pid) external view returns (uint256, uint256, uint256, bool, uint256, uint256);

    function viewPoolVestingInformation(uint256 _pid) external view returns (uint256, uint256, uint256, uint256);

    function viewPoolTaxRateOverflow(uint256 _pid) external view returns (uint256);

    function viewUserAllocationPools(address _user, uint8[] calldata _pids) external view returns (uint256[] memory);

    function viewUserInfo(address _user, uint8[] calldata _pids) external view returns (uint256[] memory, bool[] memory);

    function viewUserOfferingAndRefundingAmountsForPools(address _user, uint8[] calldata _pids)
        external
        view
        returns (uint256[3][] memory);
}

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

library IFOLibV10 {
    error EndTimeTooFar();
    error StartTimeMustInferiorToEndTime();
    error StartTimeMustGreaterThanCurrentBlockTime();
    error AlreadyInitialized();
    error AddressesLengthNotCorrect();
    error StartAndEndTimestampsLengthNotCorrect();
    error ShouldNotLargerThanTheNumberOfPools();
    error PoolNotSet();
    error TooEarly();
    error TooLate();
    error AmountMustExceedZero();
    error DidNotParticipate();
    error AlreadyHarvested();
    error IFOHasStarted();
    error IFOHasEnded();
    error FlatTaxRateMustBeLessThan1e12();
    error FlatTaxRateMustBe0WhenHasTaxIsFalse();
    error VestingPercentageShouldRangeIn0And100();
    error VestingDurationMustExceeds0();
    error VestingSlicePerSecondsMustBeExceeds1();
    error VestingSlicePerSecondsMustBeInteriorDuration();
    error InvalidVestingConfig();
    error VestingNotExist();

    function InitializePreCheck(
        bool isInitialized,
        uint256 addresses_length,
        uint256 startAndEndTimestamps_length,
        uint8 maxPoolId
    ) internal pure {
        if (isInitialized) {
            revert AlreadyInitialized();
        }

        if (addresses_length != 4) {
            revert AddressesLengthNotCorrect();
        }

        if (startAndEndTimestamps_length != 2) {
            revert StartAndEndTimestampsLengthNotCorrect();
        }

        if (maxPoolId >= 2) {
            revert ShouldNotLargerThanTheNumberOfPools();
        }
    }

    function DepositPoolPreCheck(
        uint256 amount,
        uint256 offeringAmountPool,
        uint256 raisingAmountPool,
        uint256 startTimestamp,
        uint256 endTimestamp
    ) internal view {
        // Checks that pool was set
        if (offeringAmountPool == 0 || raisingAmountPool == 0) {
            revert PoolNotSet();
        }

        // Checks whether the timestamp is not too early
        if (block.timestamp < startTimestamp) {
            revert TooEarly();
        }

        // Checks whether the timestamp is not too late
        if (block.timestamp > endTimestamp) {
            revert TooLate();
        }

        // Checks that the amount deposited is not inferior to 0
        if (amount == 0) {
            revert AmountMustExceedZero();
        }
    }

    function HarvestPoolPreCheck(uint256 endTimestamp, uint256 amountPool, bool claimedPool) internal view {
        // Checks whether pool id is valid
        if (block.timestamp <= endTimestamp) {
            revert TooEarly();
        }

        // Checks whether the user has participated
        if (amountPool == 0) {
            revert DidNotParticipate();
        }

        // Checks whether the user has already harvested
        if (claimedPool) {
            revert AlreadyHarvested();
        }
    }

    function SetPoolPreCheck(
        uint256 startTimestamp,
        bool hasTax,
        uint256 flatTaxRate,
        uint256 vestingPercentage,
        uint256 vestingDuration,
        uint256 vestingSlicePeriodSeconds
    ) internal view {
        if (block.timestamp >= startTimestamp) {
            revert IFOHasStarted();
        }

        if (flatTaxRate >= 1e12) {
            revert FlatTaxRateMustBeLessThan1e12();
        }

        if (vestingPercentage > 0) {
            if (vestingPercentage > 100) {
                revert VestingPercentageShouldRangeIn0And100();
            }

            if (vestingDuration == 0) {
                revert VestingDurationMustExceeds0();
            }

            if (vestingSlicePeriodSeconds < 1) {
                revert VestingSlicePerSecondsMustBeExceeds1();
            }

            if (vestingSlicePeriodSeconds > vestingDuration) {
                revert VestingSlicePerSecondsMustBeInteriorDuration();
            }
        } else {
            if (vestingDuration != 0 || vestingSlicePeriodSeconds != 0) {
                revert InvalidVestingConfig();
            }
        }

        if (!hasTax) {
            if (flatTaxRate != 0) {
                revert FlatTaxRateMustBe0WhenHasTaxIsFalse();
            }
        }
    }

    function UpdateStartAndEndTimestampsPreCheck(
        uint256 MAX_BUFFER_SECONDS,
        uint256 startAndEndTimestamps_length,
        uint256 currentStartTimestamp,
        uint256 startTimestamp,
        uint256 endTimestamp
    ) internal view {
        if (startAndEndTimestamps_length != 2) {
            revert StartAndEndTimestampsLengthNotCorrect();
        }
        if (endTimestamp >= (block.timestamp + MAX_BUFFER_SECONDS)) revert EndTimeTooFar();
        if (block.timestamp >= currentStartTimestamp) revert IFOHasStarted();
        if (startTimestamp >= endTimestamp) revert StartTimeMustInferiorToEndTime();
        if (block.timestamp >= startTimestamp) revert StartTimeMustGreaterThanCurrentBlockTime();
    }

    function IsVestingInitializedPreCheck(bool isVestingInitialized) internal pure {
        if (!isVestingInitialized) {
            revert VestingNotExist();
        }
    }
}

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(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: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

{
  "remappings": [
    "@openzeppelin-4.5.0/=lib/openzeppelin-contracts/",
    "solmate/=lib/solmate/",
    "ds-test/=lib/solmate/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 999999
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": true
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressesLengthNotCorrect","type":"error"},{"inputs":[],"name":"AlreadyHarvested","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"AmountMustExceedZero","type":"error"},{"inputs":[],"name":"DidNotParticipate","type":"error"},{"inputs":[],"name":"EndTimeTooFar","type":"error"},{"inputs":[],"name":"FlatTaxRateMustBe0WhenHasTaxIsFalse","type":"error"},{"inputs":[],"name":"FlatTaxRateMustBeLessThan1e12","type":"error"},{"inputs":[],"name":"IFOHasStarted","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[],"name":"InvalidVestingConfig","type":"error"},{"inputs":[],"name":"NativeTransferFailed","type":"error"},{"inputs":[],"name":"NewAmountAboveUserLimit","type":"error"},{"inputs":[],"name":"PoolIdNotValid","type":"error"},{"inputs":[],"name":"PoolNotSet","type":"error"},{"inputs":[],"name":"Reentrancy","type":"error"},{"inputs":[],"name":"ShouldNotLargerThanTheNumberOfPools","type":"error"},{"inputs":[],"name":"StartAndEndTimestampsLengthNotCorrect","type":"error"},{"inputs":[],"name":"StartTimeMustGreaterThanCurrentBlockTime","type":"error"},{"inputs":[],"name":"StartTimeMustInferiorToEndTime","type":"error"},{"inputs":[],"name":"TokensNotDepositedProperly","type":"error"},{"inputs":[],"name":"TooEarly","type":"error"},{"inputs":[],"name":"TooLate","type":"error"},{"inputs":[],"name":"VestingDurationMustExceeds0","type":"error"},{"inputs":[],"name":"VestingIsRevoked","type":"error"},{"inputs":[],"name":"VestingNotEnoughToRelease","type":"error"},{"inputs":[],"name":"VestingNotExist","type":"error"},{"inputs":[],"name":"VestingOnlyBeneficiaryOrOwnerCanRelease","type":"error"},{"inputs":[],"name":"VestingPercentageShouldRangeIn0And100","type":"error"},{"inputs":[],"name":"VestingSlicePerSecondsMustBeExceeds1","type":"error"},{"inputs":[],"name":"VestingSlicePerSecondsMustBeInteriorDuration","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountTokens","type":"uint256"}],"name":"AdminTokenRecovery","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountLP0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLP1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOfferingToken","type":"uint256"}],"name":"AdminWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"offeringAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"excessAmount","type":"uint256"},{"indexed":true,"internalType":"uint8","name":"pid","type":"uint8"}],"name":"CreateVestingSchedule","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint8","name":"pid","type":"uint8"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"offeringAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"excessAmount","type":"uint256"},{"indexed":true,"internalType":"uint8","name":"pid","type":"uint8"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTimestamp","type":"uint256"}],"name":"NewStartAndEndTimestamps","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"offeringAmountPool","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"raisingAmountPool","type":"uint256"},{"indexed":false,"internalType":"uint8","name":"pid","type":"uint8"}],"name":"PoolParametersSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beneficiary","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Released","type":"event"},{"anonymous":false,"inputs":[],"name":"Revoked","type":"event"},{"inputs":[],"name":"MAX_BUFFER_SECONDS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_POOL_ID","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NATIVE","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"addresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"}],"name":"computeNextVestingScheduleIdForHolder","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_vestingScheduleId","type":"bytes32"}],"name":"computeReleasableAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"computeVestingScheduleIdForAddressAndIndex","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"uint8","name":"_pid","type":"uint8"}],"name":"computeVestingScheduleIdForAddressAndPid","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint8","name":"_pid","type":"uint8"}],"name":"depositPool","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"endTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lp0Amount","type":"uint256"},{"internalType":"uint256","name":"_lp1Amount","type":"uint256"},{"internalType":"uint256","name":"_offerAmount","type":"uint256"}],"name":"finalWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_vestingScheduleId","type":"bytes32"}],"name":"getVestingSchedule","outputs":[{"components":[{"internalType":"bool","name":"isVestingInitialized","type":"bool"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint8","name":"pid","type":"uint8"},{"internalType":"uint256","name":"amountTotal","type":"uint256"},{"internalType":"uint256","name":"released","type":"uint256"}],"internalType":"struct IFOInitializableV10.VestingSchedule","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_holder","type":"address"},{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getVestingScheduleByAddressAndIndex","outputs":[{"components":[{"internalType":"bool","name":"isVestingInitialized","type":"bool"},{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint8","name":"pid","type":"uint8"},{"internalType":"uint256","name":"amountTotal","type":"uint256"},{"internalType":"uint256","name":"released","type":"uint256"}],"internalType":"struct IFOInitializableV10.VestingSchedule","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVestingSchedulesCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVestingSchedulesTotalAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWithdrawableOfferingTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"_pid","type":"uint8"}],"name":"harvestPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256[]","name":"_startAndEndTimestamps","type":"uint256[]"},{"internalType":"uint256","name":"_maxBufferSeconds","type":"uint256"},{"internalType":"uint8","name":"_maxPoolId","type":"uint8"},{"internalType":"uint256","name":"_vestingStartTime","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_tokenAmount","type":"uint256"}],"name":"recoverWrongTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_vestingScheduleId","type":"bytes32"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revoke","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_offeringAmountPool","type":"uint256"},{"internalType":"uint256","name":"_raisingAmountPool","type":"uint256"},{"internalType":"uint256","name":"_limitPerUserInLP","type":"uint256"},{"internalType":"bool","name":"_hasTax","type":"bool"},{"internalType":"uint256","name":"_flatTaxRate","type":"uint256"},{"internalType":"uint8","name":"_pid","type":"uint8"},{"components":[{"internalType":"uint256","name":"percentage","type":"uint256"},{"internalType":"uint256","name":"cliff","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint256","name":"slicePeriodSeconds","type":"uint256"}],"internalType":"struct IIFOV10.VestingConfig","name":"_vestingConfig","type":"tuple"}],"name":"setPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalTokensOffered","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_startAndEndTimestamps","type":"uint256[]"}],"name":"updateStartAndEndTimestamps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vestingRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vestingStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"viewPoolInformation","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"viewPoolTaxRateOverflow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"viewPoolVestingInformation","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint8[]","name":"_pids","type":"uint8[]"}],"name":"viewUserAllocationPools","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint8[]","name":"_pids","type":"uint8[]"}],"name":"viewUserInfo","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bool[]","name":"","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint8[]","name":"_pids","type":"uint8[]"}],"name":"viewUserOfferingAndRefundingAmountsForPools","outputs":[{"internalType":"uint256[3][]","name":"","type":"uint256[3][]"}],"stateMutability":"view","type":"function"}]

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

0x60806040526004361015610011575f80fd5b5f3560e01c806313083617146102545780631e3bba081461024f5780632374876c1461024a578063269de8181461024557806328fddfaf146102405780632937049e1461023b57806337f859b8146102365780633f138d4b1461023157806346ab91bf1461022c57806348deb471146102275780634af3c9b71461022257806354070e391461021d57806367d42a8b146102185780636993c73314610213578063715018a61461020e578063760b31801461020957806379795108146102045780637f1bdd76146101ff5780638af104da146101fa5780638da5cb5b146101f55780639ef346b4146101f0578063a0cf0aea146101eb578063a85adeab146101e6578063a8660a78146101e1578063b1ced5e7146101dc578063b6549f75146101d7578063b86c6f14146101d2578063ca463ca4146101cd578063caa7f232146101c8578063e6fd48bc146101c3578063ea1bb3d5146101be578063edf26d9b146101b9578063f2fde38b146101b4578063f51321d7146101af578063f7c469f0146101aa5763f9cd5c12146101a5575f80fd5b611f6f565b611f07565b611eb1565b611dab565b611d4b565b611ccf565b611c94565b611aca565b6119b0565b6118d5565b611804565b6117c6565b61178b565b611750565b6116ff565b611690565b611640565b6115f7565b611497565b61145f565b611424565b611370565b6111d0565b610fb9565b610f4e565b610dfb565b610ce2565b610c20565b610a98565b610a5c565b61092b565b6108eb565b610672565b610316565b6102bc565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020602454604051908152f35b5f80fd5b73ffffffffffffffffffffffffffffffffffffffff81160361028f57565b60ff81160361028f57565b3461028f5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602061030e6004356102fc81610293565b60243590610309826102b1565b6120e2565b604051908152f35b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57600435610351816102b1565b688000000000ab143c065c6106345730688000000000ab143c065d61037581612597565b6103f76007546103b7836103a73373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b9060ff165f5260205260405f2090565b546103f160016103e9866103a73373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b015460ff1690565b916125cf565b6104546001610428836103a73373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b0160017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00825416179055565b60225415610626575b6104678133612659565b809291926105fb575b50806104c7575b508061048c575b5f688000000000ab143c065d005b6104bb61049b6104c093611d3a565b905473ffffffffffffffffffffffffffffffffffffffff9160031b1c1690565b612ba9565b5f8061047e565b6104dd60076104d585612171565b5001546121bf565b610560575b60076104ed84612171565b500154156104775761051061051791600761050786612171565b500154906121da565b6064900490565b610522818433612a05565b604080519182526020820183905260ff84169133917f4b386667138d87683f75b2e46ad8ac192b053af4c8875da8689415997663a95091a35f610477565b61057a61051061057460076104d587612171565b836121da565b6004546105be90829033906105b99073ffffffffffffffffffffffffffffffffffffffff165b73ffffffffffffffffffffffffffffffffffffffff1690565b6127bb565b604080519182526020820184905260ff85169133917f51524c2e5edfedf8b01b29719c661e4fbe27e71734e7cd773dabb7cb712fb3b391a36104e2565b61061290600661060a86612171565b5001546121b2565b600661061d85612171565b5001555f610470565b61062f42602255565b61045d565b63ab143c065f526004601cfd5b9181601f8401121561028f5782359167ffffffffffffffff831161028f576020808501948460051b01011161028f57565b3461028f5760a07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f5760043567ffffffffffffffff811161028f576106c1903690600401610641565b60243567ffffffffffffffff811161028f576106e1903690600401610641565b916044356064356106f1816102b1565b6084359160ff60015460a01c166108c3576004840361089b576002860361087357600260ff8316101561084b57610762740100000000000000000000000000000000000000007fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff6001541617600155565b5f5b60ff8116858110156107c957906107bf61078a6107856107c494898d61225c565b61226c565b61079383611d3a565b90919073ffffffffffffffffffffffffffffffffffffffff8084549260031b9316831b921b1916179055565b612224565b610764565b50509161083a61083f9261080c61084999956108076108016108449b6107859b6107fc6107f68383612235565b35600655565b61223e565b35600755565b600855565b60ff167fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006009541617600955565b602255565b61224d565b612550565b005b7fa854b3bd000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f9cbf71a8000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f3b9b621f000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f0dc149f0000000000000000000000000000000000000000000000000000000005f5260045ffd5b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602060ff602354166040519015158152f35b3461028f5760607ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f577f5cba002c3841a6704789c1f41f4dab171dc5a8c972c928498c961665cdecf41b600435602435906109d96044356109aa73ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b82610a35575b83610a0d575b806109de575b604051938493846040919493926060820195825260208201520152565b0390a1005b600454610a0890829033906105b99073ffffffffffffffffffffffffffffffffffffffff166105a0565b6109bc565b610a30846104bb60035473ffffffffffffffffffffffffffffffffffffffff1690565b6109b6565b610a578373ffffffffffffffffffffffffffffffffffffffff60025416612ba9565b6109b0565b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602061030e6004356122db565b3461028f5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57600435610ad381610293565b602435610af873ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b610b1a6105a060025473ffffffffffffffffffffffffffffffffffffffff1690565b9173ffffffffffffffffffffffffffffffffffffffff81169283148015610bf6575b8015610bcc575b610ba457610b74827f74545154aac348a3eac92596bd1971957ca94795f4e954ec5f613b55fab781299433906127bb565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252602082019290925290819081016109d9565b7fc1ab6dc1000000000000000000000000000000000000000000000000000000005f5260045ffd5b50600454610bef9073ffffffffffffffffffffffffffffffffffffffff166105a0565b8314610b43565b50600354610c199073ffffffffffffffffffffffffffffffffffffffff166105a0565b8314610b3c565b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576004356002811015610cdd57600b810290610cd982600b015491600d600c85015494015490610c8b6003610c8283612171565b50015460ff1690565b6006610ca46005610c9b85612171565b50015493612171565b50015492604051968796879260a094919796959260c08501988552602085015260408401521515606083015260808201520152565b0390f35b611d0d565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020602654604051908152f35b9060407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc83011261028f57600435610d5481610293565b916024359067ffffffffffffffff821161028f57610d7491600401610641565b9091565b90602080835192838152019201905f5b818110610d955750505090565b8251845260209384019390920191600101610d88565b90610dbe90604083526040830190610d78565b906020818303910152602080835192838152019201905f5b818110610de35750505090565b82511515845260209384019390920191600101610dd6565b3461028f57610e0936610d1d565b91610e1383612365565b90610e1d8461234d565b90610e2b604051928361202b565b8482527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0610e588661234d565b013660208401375f93610e76610e7060095460ff1690565b60ff1690565b945b60ff811687811015610f3f5790858285610e9e610e99610eb3968d8961225c565b6123b4565b8a60ff82161115610eb8575b50505050612224565b610e78565b60016103e982610f3696610eff87610ef8610f28976103a7610f2f9a73ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b54926123be565b526103a78b73ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b91886123be565b9015159052565b855f8581610eaa565b60405180610cd9878983610dab565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020600854604051908152f35b7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc602091011261028f5760043590565b3461028f57610fc736610f89565b688000000000ab143c065c610634576110189030688000000000ab143c065d61100a611005610ffe835f52602560205260405f2090565b5460ff1690565b612d75565b5f52602560205260405f2090565b805461103c9060081c73ffffffffffffffffffffffffffffffffffffffff166105a0565b3314158061119c575b6111745761105a6110558261208b565b612da4565b90811561114c5761113b73ffffffffffffffffffffffffffffffffffffffff6111298360027fb21fb52d5749b80f3182f8c6992236b5e5576681880914484d7f4c9b062e619e95016110ad8782546121b2565b90556110c36110be876026546121cd565b602655565b60045461110c9087906110eb9073ffffffffffffffffffffffffffffffffffffffff166105a0565b835460081c73ffffffffffffffffffffffffffffffffffffffff16906127bb565b5460081c73ffffffffffffffffffffffffffffffffffffffff1690565b60405194855216929081906020820190565b0390a25f688000000000ab143c065d005b7f5b2e7e9a000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f61c042c1000000000000000000000000000000000000000000000000000000005f5260045ffd5b506111be6105a073ffffffffffffffffffffffffffffffffffffffff5f541690565b331415611045565b8015150361028f57565b3461028f576101407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57606435602435600435604435611215846111c6565b6084359360a43590611226826102b1565b60807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c36011261028f57600a6109d9937fddaf243a142670be60c19ff7116b5d8b124717b29bb4cc03cead42161614105b9761129a73ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b6112a385612597565b6006549060c43590611335866112c66101043595868686610124359c8d94612e82565b6112cf89612171565b50958b600188016112ea6112e582548c546121cd565b600a55565b6112f86112e5838c546121b2565b558c87556002870155600386019060ff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0083541691151516179055565b6004840155600783015560e4356008830155600982015501556040519384938491604091949360ff9160608501968552602085015216910152565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576113c073ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b5f73ffffffffffffffffffffffffffffffffffffffff81547fffffffffffffffffffffffff000000000000000000000000000000000000000081168355167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a3005b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020600a54604051908152f35b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602061030e6123ec565b60407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576004356024356114d0816102b1565b688000000000ab143c065c6106345730688000000000ab143c065d6114f481612597565b61151e600161150283612171565b50015461150e83612171565b5054600654906007549286613069565b600454611542906105a09073ffffffffffffffffffffffffffffffffffffffff1681565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015290602090829060249082905afa9081156115f2575f916115c3575b50600a541161159b5761047e9161310f565b7fe4db4faa000000000000000000000000000000000000000000000000000000005f5260045ffd5b6115e5915060203d6020116115eb575b6115dd818361202b565b8101906123d2565b5f611589565b503d6115d3565b6123e1565b3461028f5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602061030e60043561163781610293565b602435906124c5565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602073ffffffffffffffffffffffffffffffffffffffff5f5416604051908152f35b3461028f57610cd96116a96116a436610f89565b612534565b6040519182918291909160808060a083019480511515845273ffffffffffffffffffffffffffffffffffffffff602082015116602085015260ff6040820151166040850152606081015160608501520151910152565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602073ffffffffffffffffffffffffffffffffffffffff60015416604051908152f35b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020600754604051908152f35b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020602254604051908152f35b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602060ff60095416604051908152f35b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f5761185473ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b60235460ff81166118ad577fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001176023557f44825a4b2df8acb19ce4e1afba9aa850c8b65cdb7942e2078f27d0b0960efee65f80a1005b7f11db5254000000000000000000000000000000000000000000000000000000005f5260045ffd5b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576004356002811015610cdd57600b81026012810154600a61192e6014601385015494015494612171565b500154604051938493608085019385526020850152604084015260608301520390f35b60206040818301928281528451809452019201905f5b8181106119745750505090565b909192835181905f915b6003831061199a57505050606001926020019190600101611967565b602080600192845181520192019201919061197e565b3461028f576119be36610d1d565b906119c88261234d565b926119d6604051948561202b565b8284527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0611a038461234d565b60609391015f5b818110611aaa5750505f5b60ff811685811015611a9c5790611a71611a77925f885f611a43611a3e610e99865f958c61225c565b612171565b5054611a7c575b611a538a61207d565b92835260208301526040820152611a6a828b6123be565b52886123be565b50612224565b611a15565b505050611a96611a90610e99838b8961225c565b87612659565b90611a4a565b60405180610cd98982611951565b602090604051611aba878261202b565b8636823782828a01015201611a0a565b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f5760043567ffffffffffffffff811161028f57611b19903690600401610641565b90611b3c73ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b600854600654908315610cdd578235918460011015610cdd5760208401359160028603610873574201804211611c8f57821015611c6757421015611c3f57811015611c1757421015611bef57611bd882611bba6107f67f57df350cfad05a64accd73700fee8a7febd6d8430e035e45f0599ca62494aa8b9585612235565b611bc7610801828561223e565b611bd18184612235565b359261223e565b6040805192835290356020830152819081016109d9565b7fb04629aa000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f46bdc214000000000000000000000000000000000000000000000000000000005f5260045ffd5b7fcb7cb9fa000000000000000000000000000000000000000000000000000000005f5260045ffd5b7feb47c4f3000000000000000000000000000000000000000000000000000000005f5260045ffd5b612185565b3461028f575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f576020600654604051908152f35b3461028f57611cdd36610f89565b805f526025602052611cf560ff60405f205416612d75565b5f526025602052602061030e61105560405f2061208b565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b6004811015610cdd57600201905f90565b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57600435600481101561028f5773ffffffffffffffffffffffffffffffffffffffff6020916002015416604051908152f35b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57600435611de681610293565b611e0873ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b73ffffffffffffffffffffffffffffffffffffffff811615611e2d5761084990613000565b60846040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152fd5b3461028f5760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57610cd96116a96116a4600435611ef581610293565b60243590611f0161250a565b506124c5565b3461028f5760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc36011261028f57602061030e600435611f4781610293565b73ffffffffffffffffffffffffffffffffffffffff81165f526027835260405f2054906124c5565b3461028f57611f7d36610d1d565b90611f8782612365565b925f5b60ff811684811015611fc7579081611fbc610f28611fac611fc295898961225c565b35611fb6816102b1565b8661325f565b52612224565b611f8a565b60405160208082528190610cd990820189610d78565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b60a0810190811067ffffffffffffffff82111761202657604052565b611fdd565b90601f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0910116810190811067ffffffffffffffff82111761202657604052565b6040519061207b60a08361202b565b565b9061207b604051928361202b565b906040516120988161200a565b60806002829460ff81548181161515865273ffffffffffffffffffffffffffffffffffffffff8160081c16602087015260a81c166040850152600181015460608501520154910152565b60ff8060095416921691821161216b5760405160208101907fffffffffffffffffffffffffffffffffffffffff0000000000000000000000008360601b1682525f60348201526034815261213760548261202b565b51902091825f52602560205260ff6040612152815f2061208b565b0151160361215e575090565b612168915061247a565b90565b50505f90565b6002811015610cdd57600b02600b01905f90565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b91908201809211611c8f57565b6064039060648211611c8f57565b91908203918211611c8f57565b81810292918115918404141715611c8f57565b81156121f7570490565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b60ff1660ff8114611c8f5760010190565b9015610cdd5790565b9060011015610cdd5760200190565b9060031015610cdd5760600190565b9190811015610cdd5760051b0190565b3561216881610293565b1561227d57565b60646040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602060248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152fd5b6002811015610cdd576122fc6122f8600e600b8402015460ff1690565b1590565b1561230657505f90565b600461231182612171565b5001541561232a57612324600491612171565b50015490565b80612345600561233c61216894612171565b50015491612171565b505490612c10565b67ffffffffffffffff81116120265760051b60200190565b9061236f8261234d565b61237c604051918261202b565b8281527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe06123aa829461234d565b0190602036910137565b35612168816102b1565b8051821015610cdd5760209160051b010190565b9081602091031261028f575190565b6040513d5f823e3d90fd5b600480546040517f70a0823100000000000000000000000000000000000000000000000000000000815230928101929092526020908290602490829073ffffffffffffffffffffffffffffffffffffffff165afa80156115f257612168915f9161245b575b50602654906121cd565b612474915060203d6020116115eb576115dd818361202b565b5f612451565b6040517fffffffffffffffffffffffffffffffffffffffff000000000000000000000000602082019260601b16825260016034820152603481526124bf60548261202b565b51902090565b90604051907fffffffffffffffffffffffffffffffffffffffff000000000000000000000000602083019360601b1683526034820152603481526124bf60548261202b565b604051906125178261200a565b5f6080838281528260208201528260408201528260608201520152565b61253c61250a565b505f52602560205261216860405f2061208b565b61257273ffffffffffffffffffffffffffffffffffffffff5f54163314612276565b73ffffffffffffffffffffffffffffffffffffffff811615611e2d5761207b90613000565b60ff80600954169116116125a757565b7f51365128000000000000000000000000000000000000000000000000000000005f5260045ffd5b4211156126315715612609576125e157565b7f0b3394dc000000000000000000000000000000000000000000000000000000005f5260045ffd5b7fdc646a14000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f085de625000000000000000000000000000000000000000000000000000000005f5260045ffd5b90915f9182600561266986612171565b50015461267586612171565b5054101561276657506126fa61268b858361325f565b916126f4866103a76126cf6126b36126be6126b38960016126ab88612171565b5001546121da565b64e8d4a51000900490565b976126c885612171565b50546121da565b9373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b546121cd565b936127096003610c8283612171565b612714575b50929190565b612746919493506126b381600461272d61273f94612171565b50015490811561274d575b50856121da565b80936121cd565b925f61270e565b6127609150612345600561233c83612171565b5f612738565b936127ae6127a861279c836103a76127b69673ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b54600161050785612171565b91612171565b5054906121ed565b929190565b6040517fa9059cbb00000000000000000000000000000000000000000000000000000000602082015273ffffffffffffffffffffffffffffffffffffffff92909216602483015260448083019390935291815261207b9161281d60648361202b565b61337a565b1561282957565b60846040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f76657374696e675363686564756c654964206973206265656e2063726561746560448201527f64000000000000000000000000000000000000000000000000000000000000006064820152fd5b9060806002916128eb81511515859060ff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0083541691151516179055565b602081015174ffffffffffffffffffffffffffffffffffffffff0085549160081b16807fffffffffffffffffffffff0000000000000000000000000000000000000000ff83161786557fffffffffffffffffffff000000000000000000000000000000000000000000ff75ff000000000000000000000000000000000000000000604085015160a81b16921617178455606081015160018501550151910155565b60245468010000000000000000811015612026576001810180602455811015610cdd5760245f527f7cd332d19b93bcabe3cce7ca0c18a052f57e5fd03b4758a09f30f5ddc4b22ec40155565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114611c8f5760010190565b909180612a106123ec565b10612b2557612b1792612aee6110be612af393612ae6612a58612a518873ffffffffffffffffffffffffffffffffffffffff165f52602760205260405f2090565b54886124c5565b94612a8d73ffffffffffffffffffffffffffffffffffffffff612a8661110c895f52602560205260405f2090565b1615612822565b612ac3612a9861206c565b600181529173ffffffffffffffffffffffffffffffffffffffff8a16602084015260ff166040830152565b8260608201525f6080820152612ae1865f52602560205260405f2090565b6128ad565b6026546121b2565b61298c565b73ffffffffffffffffffffffffffffffffffffffff165f52602760205260405f2090565b612b2181546129d8565b9055565b60846040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603660248201527f63616e206e6f74206372656174652076657374696e67207363686564756c652060448201527f776974682073756666696369656e7420746f6b656e73000000000000000000006064820152fd5b60015473ffffffffffffffffffffffffffffffffffffffff91821691168103612c0457505f80808093335af115612bdc57565b7ff4b3b1bc000000000000000000000000000000000000000000000000000000005f5260045ffd5b9061207b9133906127bb565b90612c1a916121ed565b6113888110612c2c5750630a21fe8090565b610fa08110612c3e5750630bebc20090565b610ce48110612c505750630ee6b28090565b610a8c8110612c6257506311e1a30090565b6108988110612c74575063160dc08090565b6107088110612c865750631ad2748090565b6105dc8110612c9857506320c8558090565b6104e28110612caa57506326be368090565b6103e88110612cbc5750632faf080090565b6103208110612cce5750633b9aca0090565b61028a8110612ce057506347868c0090565b6101f48110612cf257506359682f0090565b6101908110612d045750637735940090565b61012c8110612d165750639502f90090565b60fa8110612d27575063b2d05e0090565b60c88110612d38575063ee6b280090565b60968110612d4a575064012a05f20090565b60648110612d5c5750640165a0bc0090565b603211612d6c576401dcd6500090565b6402540be40090565b15612d7c57565b7f8bc0c805000000000000000000000000000000000000000000000000000000005f5260045ffd5b602254906040810191612dc96008612dc0611a3e865160ff1690565b500154826121b2565b421015612dd7575050505f90565b612dea6009612dc0611a3e865160ff1690565b4210801590612e76575b15612e0f5750612168915060806060820151910151906121cd565b612e6d612168936009612e64611a3e612e5c612e52612e30608098426121cd565b612e4d600a612e43611a3e8a5160ff1690565b50015480926121ed565b6121da565b60608901516121da565b935160ff1690565b500154906121ed565b910151906121cd565b5060235460ff16612df4565b94919493929093421015611c3f5764e8d4a51000851015612fd8578015612f9457606410612f6c578115612f445760018110612f1c5711612ef4575b15612ec65750565b612ecc57565b7f55d8bb67000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f0cdbeed7000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f2030ecea000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f914cb9d0000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f0e07a92f000000000000000000000000000000000000000000000000000000005f5260045ffd5b50901590811591612fce575b5015612ebe577f5c9504c2000000000000000000000000000000000000000000000000000000005f5260045ffd5b905015155f612fa0565b7f892888c2000000000000000000000000000000000000000000000000000000005f5260045ffd5b73ffffffffffffffffffffffffffffffffffffffff805f54921691827fffffffffffffffffffffffff00000000000000000000000000000000000000008216175f55167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a3565b9392919015908115613106575b506130de5742106126315742116130b6571561308e57565b7f9e6c6895000000000000000000000000000000000000000000000000000000005f5260045ffd5b7fecdd1c29000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f3c675863000000000000000000000000000000000000000000000000000000005f5260045ffd5b9050155f613076565b6131248161311f61049b85611d3a565b613473565b61315a81613154846103a73373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b546121b2565b613186836103a73373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b55600261319283612171565b5001546131f6575b6131a981600561060a85612171565b60056131b484612171565b5001557ff763e680fce25a97ffd55d8b705370c98b47b2285f7b3b2900c43606fd41804560ff604051931692806131f13394829190602083019252565b0390a3565b613222826103a73373ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b54600261322e84612171565b500154101561319a577f06e6a3a6000000000000000000000000000000000000000000000000000000005f5260045ffd5b60ff6009541660ff83161161216b576002821015610cdd57600b8202601001541561216b57816103a76132b09273ffffffffffffffffffffffffffffffffffffffff165f52602160205260405f2090565b5464e8d4a5100081029080820464e8d4a510001490151715611c8f576005612e6461216893612171565b9081602091031261028f5751612168816111c6565b156132f657565b60846040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152fd5b73ffffffffffffffffffffffffffffffffffffffff1690604051906133a060408361202b565b602082527f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65646020830152823b15613415575f816133f0948260208195519301915af16133ea6134f3565b90613550565b8051806133fb575050565b816020806134109361207b95010191016132da565b6132ef565b60646040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152fd5b60015473ffffffffffffffffffffffffffffffffffffffff9182169116810361349f57503403612bdc57565b9034612bdc5761207b91604051917f23b872dd00000000000000000000000000000000000000000000000000000000602084015233602484015230604484015260648301526064825261281d60848361202b565b3d1561354b573d9067ffffffffffffffff82116120265760405191613540601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0166020018461202b565b82523d5f602084013e565b606090565b9091901561355c575090565b81511561356c5750805190602001fd5b60446020917fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f6040519485937f08c379a00000000000000000000000000000000000000000000000000000000085528160048601528051918291826024880152018686015e5f85828601015201168101030190fdfea2646970667358221220a475a4eeb8a9107d36d7ce8bafd2368a885a03513275450029834b0677901e9164736f6c634300081a0033

442:32598:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;21009:19;442:32598;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1273:230:5;;;;;;;7046:4:6;;;:::i;:::-;7187:39;7133:12;442:32598;7147:27;7157:10;7147:21;7157:10;442:32598;;;;7147:9;442:32598;;;;;;;7147:21;442:32598;;;;;;;;;;;;7147:27;442:32598;;7187:39;:27;7157:10;7187:21;7157:10;442:32598;;;;7147:9;442:32598;;;;;;;7187:27;:39;442:32598;;;;;;7187:39;;:::i;:::-;7285:46;7187:39;7285:27;7157:10;7285:21;7157:10;442:32598;;;;7147:9;442:32598;;;;;;;7285:27;:39;7187;442:32598;;;;;;;;7285:46;7387:16;442:32598;7387:21;7383:86;;442:32598;7667:59;7157:10;;7667:59;:::i;:::-;7783:19;;;;7779:149;;442:32598;8008:23;;8004:939;;442:32598;8957:24;;8953:110;;442:32598;-1:-1:-1;1273:230:5;1568:66;442:32598:6;8953:110;442:32598;9014:15;9031:20;9014:15;;:::i;:::-;442:32598;;;;;;;;;;;9031:20;:::i;:::-;8953:110;;;;8004:939;8051:53;7133:12;8057:22;;;:::i;:::-;:36;;442:32598;8051:53;:::i;:::-;8047:395;;8004:939;7133:12;8544:22;;;:::i;:::-;:36;;442:32598;8540:393;8004:939;8540:393;8633:69;8632:77;8655:22;7133:12;8655:22;;;:::i;:::-;:36;;442:32598;8633:69;;:::i;:::-;8051:3;442:32598;;;;8632:77;8818:6;7157:10;;;8818:6;:::i;:::-;442:32598;;;;;;;;;;;;;;;;7157:10;;8849:69;;;8540:393;8004:939;;8047:395;8145:85;8146:77;8169:53;7133:12;8175:22;;;:::i;8169:53::-;8146:77;;:::i;8145:85::-;442:32598;;8341:6;;7157:10;;;;8295:20;;442:32598;;;;;;;8295:20;8341:6;:::i;:::-;442:32598;;;;;;;;;;;;;;;;7157:10;;8372:55;;;8047:395;;7779:149;7860:57;:22;:39;:22;;;:::i;:::-;:39;;442:32598;7860:57;:::i;:::-;:39;7818:22;;;:::i;:::-;:39;;442:32598;7779:149;;;7383:86;7424:34;7443:15;7387:16;442:32598;;7424:34;7383:86;;1273:230:5;;-1:-1:-1;1273:230:5;442:32598:6;1273:230:5;;442:32598:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;5336:13;442:32598;;;;1139:71:8;;442:32598:6;1224:21:8;;1220:86;;1352:1;1320:33;;1316:110;;1352:1;442:32598:6;;;1440:14:8;;1436:89;;5465:20:6;442:32598;;5336:13;442:32598;;;5336:13;442:32598;;5465:20;-1:-1:-1;5609:3:6;442:32598;;;5586:21;;;;;;5643:13;5628:28;5643:13;;5609:3;5643:13;;;;:::i;:::-;;:::i;:::-;5628:12;;;:::i;:::-;:28;442:32598;;;;;;;;;;;;;;;;;;;;;5628:28;5609:3;:::i;:::-;5573:11;;5586:21;;;;5827:24;5861:36;5586:21;5779:38;1918:198:0;5586:21:6;;5729:40;5744:25;5965:13;5586:21;5965:13;5586:21;5677:42;5694:25;;;;:::i;:::-;442:32598;5677:42;442:32598;;5677:42;5744:25;:::i;:::-;442:32598;5729:40;442:32598;;5729:40;5779:38;442:32598;;5779:38;442:32598;;;5827:24;442:32598;;;5827:24;442:32598;;5827:24;7387:16;442:32598;;5861:36;5965:13;:::i;:::-;1918:198:0;:::i;:::-;442:32598:6;1436:89:8;1477:37;-1:-1:-1;1477:37:8;442:32598:6;-1:-1:-1;1477:37:8;1316:110;1376:39;-1:-1:-1;1376:39:8;442:32598:6;-1:-1:-1;1376:39:8;1220:86;1268:27;-1:-1:-1;1268:27:8;442:32598:6;-1:-1:-1;1268:27:8;1139:71;1179:20;-1:-1:-1;1179:20:8;442:32598:6;-1:-1:-1;1179:20:8;442:32598:6;;;;;;;;;;;;;2534:26;442:32598;;;;;;;;;;;;;;;;;;;;;9826:51;442:32598;;;;;9826:51;442:32598;;1240:68:0;442:32598:6;-1:-1:-1;442:32598:6;;719:10:4;1248:23:0;1240:68;:::i;:::-;9515:14:6;9511:87;;442:32598;9612:14;9608:87;;442:32598;9709:16;9705:106;;442:32598;;;9826:51;;;;442:32598;;;;;;;;;;;;;;;;;;9826:51;;;;442:32598;9705:106;442:32598;;9787:12;;719:10:4;;;;9741:20:6;;442:32598;;;;9787:12;9705:106;;9608:87;9673:10;442:32598;;;;;;;;9673:10;9608:87;;9511;9576:10;442:32598;;9562:9;442:32598;;9576:10;:::i;:::-;9511:87;;442:32598;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;1240:68:0;442:32598:6;-1:-1:-1;442:32598:6;;719:10:4;1248:23:0;1240:68;:::i;:::-;10290:29:6;442:32598;10307:9;442:32598;;;;;10290:29;442:32598;;;;10290:29;;;:62;;;;442:32598;10290:95;;;;442:32598;10286:147;;10490:12;719:10:4;10519:47:6;719:10:4;;10490:12:6;;:::i;:::-;442:32598;;;;;;;;;;;;;;;;;;;;;10519:47;442:32598;10286:147;10408:14;-1:-1:-1;10408:14:6;442:32598;-1:-1:-1;10408:14:6;10290:95;-1:-1:-1;442:32598:6;;10356:29;;442:32598;;;;10356:29;;;10290:95;;:62;-1:-1:-1;442:32598:6;;10323:29;;442:32598;;;;10323:29;;;10290:62;;442:32598;;;;;;;;;;;;;;;;;;;14488:16;442:32598;;;;;14488:16;442:32598;;;14597:39;14542:41;;;442:32598;;14597:39;442:32598;14650:22;442:32598;14650:29;:22;;;:::i;:::-;:29;;442:32598;;;;;;14745:39;:22;14693:38;:22;;;:::i;:::-;:38;;442:32598;14745:22;;:::i;:::-;:39;;442:32598;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;19380:27;442:32598;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;-1:-1:-1;442:32598:6;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17329:27;;;;:::i;:::-;442:32598;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;442:32598:6;17522:18;442:32598;17529:11;442:32598;;;;;;;;;;17522:18;17429:273;17465:3;442:32598;;;17447:16;;;;;;17496:8;;;;;;17465:3;17496:8;;;;:::i;:::-;;:::i;:::-;442:32598;;;;17522:18;;17518:174;;17465:3;;;;;;:::i;:::-;17434:11;;17518:174;17644:33;:21;17577:16;17627:50;17577:16;17560:49;17577:16;:21;442:32598;17577:16;;17627:50;17577:16;442:32598;;;;7147:9;442:32598;;;;;;;17577:21;442:32598;17560:49;;:::i;:::-;442:32598;17644:16;;442:32598;;;;7147:9;442:32598;;;;;;;;17627:50;;;:::i;:::-;442:32598;;;;;;17627:50;17518:174;;;;;;17447:16;442:32598;;;;17447:16;;442:32598;;:::i;:::-;;;;;;;;;;;;978:33;442:32598;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;1273:230:5;;;;19812:36:6;1273:230:5;;;;19701:57:6;442:32598;19701:36;;442:32598;;19701:16;442:32598;;;;;;;19701:36;442:32598;;;;;;19701:57;:::i;:::-;442:32598;;19701:16;442:32598;;;;;;;19812:36;442:32598;;19879:41;;442:32598;;;;;;19879:41;:10;:41;19934:14;:41;;;442:32598;19930:120;;20082:41;442:32598;;;:::i;:::-;20082:41;:::i;:::-;20137:17;;;20133:82;;20474:51;442:32598;;20251:24;;20474:51;20251:24;;:39;442:32598;;;20251:39;:::i;:::-;442:32598;;20300:72;20330:42;442:32598;20330:27;442:32598;20330:42;:::i;:::-;:27;442:32598;;20300:72;442:32598;;20445:12;;442:32598;;20382:20;;442:32598;;;;20382:20;442:32598;;;;;;20445:12;;:::i;:::-;442:32598;;;;;;;;;;;;;;;;;;;;;;;20474:51;;;;-1:-1:-1;1273:230:5;1568:66;442:32598:6;20133:82;20177:27;-1:-1:-1;20177:27:6;442:32598;-1:-1:-1;20177:27:6;19930:120;19998:41;-1:-1:-1;19998:41:6;442:32598;-1:-1:-1;19998:41:6;19934;1108:6:0;19953:21:6;1108:6:0;442:32598:6;1108:6:0;442:32598:6;;;;19953:21;19879:10;19953:21;;19934:41;;442:32598;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;12200:49;12854:64;442:32598;12854:64;442:32598;1240:68:0;442:32598:6;-1:-1:-1;442:32598:6;;719:10:4;1248:23:0;1240:68;:::i;:::-;11803:4:6;;;:::i;:::-;11886:14;442:32598;;;;12000:23;12482:25;12000:23;12037:33;12000:23;442:32598;12037:33;;;;;442:32598;12037:33;;;;:::i;:::-;12130:22;;;:::i;:::-;12222:27;;;;;;12200:49;;442:32598;;;;12200:49;:::i;:::-;;442:32598;;12200:49;12259:41;;442:32598;;;12259:41;:::i;:::-;442:32598;;;;12427:25;;;442:32598;12482:15;;;442:32598;;;;;;;;;;;;;;12482:25;442:32598;12517:20;;442:32598;12562:22;;;442:32598;12664:20;442:32598;12633:28;;;442:32598;12694:31;;;442:32598;12761:41;442:32598;;;12854:64;;;;442:32598;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1240:68:0;442:32598:6;;;;719:10:4;1248:23:0;1240:68;:::i;:::-;442:32598:6;;;;;;;;;;2410:40:0;;;;442:32598:6;;;;;;;;;;;;;1117:33;442:32598;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;1273:230:5;;;;;;;6315:4:6;;;:::i;:::-;6560:12;6423:41;:22;;;:::i;:::-;:41;;442:32598;6478:22;;;:::i;:::-;442:32598;;6532:14;442:32598;;6560:12;442:32598;6560:12;;;:::i;:::-;442:32598;;6646:30;;:20;;442:32598;;6646:20;442:32598;6646:30;442:32598;;;6646:45;;1273:230:5;442:32598:6;6646:45;;442:32598;;;;;;;;;;6646:45;;;;;;;-1:-1:-1;6646:45:6;;;442:32598;;6694:18;442:32598;-1:-1:-1;6642:132:6;;6802:4;;;:::i;6642:132::-;6735:28;-1:-1:-1;6735:28:6;442:32598;-1:-1:-1;6735:28:6;6646:45;;;;442:32598;6646:45;442:32598;6646:45;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;:::i;442:32598::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;556:34;442:32598;;;;;;;;;;;;;;;;;;;;898:27;442:32598;;;;;;;;;;;;;;;;;;;2453:31;442:32598;;;;;;;;;;;;;;;;;;;;1037:24;442:32598;;;;;;;;;;;;;;;;;;;1240:68:0;442:32598:6;;;;719:10:4;1248:23:0;1240:68;:::i;:::-;20654:14:6;442:32598;;;;20650:70;;442:32598;;20747:4;442:32598;20654:14;442:32598;20766:9;442:32598;;20766:9;442:32598;20650:70;20691:18;442:32598;20691:18;442:32598;;20691:18;442:32598;;;;;;;;;;;;;;;;;;;15389:16;442:32598;;15389:36;;;442:32598;15565:55;:22;15506:45;15450:42;;;442:32598;;15506:45;442:32598;15565:22;;:::i;:::-;:55;;442:32598;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;442:32598:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;-1:-1:-1;442:32598:6;;;;;;18193:11;;-1:-1:-1;18224:3:6;442:32598;;;18206:16;;;;;;18243:30;18622:85;18224:3;18243:30;-1:-1:-1;18287:31:6;-1:-1:-1;18376:26:6;18393:8;;18332:25;-1:-1:-1;18393:8:6;;;:::i;:::-;18376:26;:::i;:::-;442:32598;;18372:236;;18224:3;442:32598;;;:::i;:::-;;;;;18639:68;;442:32598;;18639:68;;442:32598;18622:85;;;;:::i;:::-;;;;:::i;:::-;;18224:3;:::i;:::-;18193:11;;18372:236;18584:8;;;18535:58;18584:8;;;;;;:::i;:::-;18535:58;;:::i;:::-;18444:149;18372:236;;18206:16;442:32598;;;;18206:16;442:32598;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1240:68:0;442:32598:6;-1:-1:-1;442:32598:6;;719:10:4;1248:23:0;1240:68;:::i;:::-;13335:18:6;442:32598;13410:14;442:32598;;;;;;;;;;13518:1;442:32598;;;;;;;;4409:33:8;4441:1;4409:33;;4405:110;;4545:15;442:32598:6;4545:15:8;;442:32598:6;;;4528:54:8;;;4524:82;;4545:15;4620:40;;4616:68;;4698:30;;;4694:75;;4545:15;4783:33;;4779:88;;13717:25:6;13574;13557:42;13574:25;13665:78;13574:25;;;:::i;13557:42::-;13609:40;13624:25;;;;:::i;13609:40::-;13690:25;;;;:::i;:::-;442:32598;13717:25;;:::i;:::-;442:32598;;;;;;;;;;;;;;;;13665:78;442:32598;4779:88:8;4825:42;-1:-1:-1;4825:42:8;442:32598:6;-1:-1:-1;4825:42:8;4694:75;4737:32;-1:-1:-1;4737:32:8;442:32598:6;-1:-1:-1;4737:32:8;4616:68;4669:15;-1:-1:-1;4669:15:8;442:32598:6;-1:-1:-1;4669:15:8;4524:82;4591:15;-1:-1:-1;4591:15:8;442:32598:6;-1:-1:-1;4591:15:8;442:32598:6;;:::i;:::-;;;;;;;;;;;;827:29;442:32598;;;;;;;;;;;;;;:::i;:::-;;-1:-1:-1;442:32598:6;21367:16;442:32598;;21367:57;442:32598;;-1:-1:-1;442:32598:6;;;21367:57;:::i;:::-;-1:-1:-1;442:32598:6;21367:16;442:32598;;;21443:62;442:32598;;-1:-1:-1;442:32598:6;;:::i;:::-;;;;;;;;;;;;;;;;;9014:9;442:32598;;;;:::o;:::-;;;;;;;;;;;;;;756:27;;;;;442:32598;;;756:27;442:32598;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1240:68:0;442:32598:6;-1:-1:-1;442:32598:6;;719:10:4;1248:23:0;1240:68;:::i;:::-;442:32598:6;;;2006:22:0;442:32598:6;;2100:8:0;;;:::i;442:32598:6:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19071:79;19090:59;442:32598;;;;;:::i;:::-;;;;;;:::i;:::-;;19090:59;:::i;442:32598::-;;;;;;;;;;;;22394:81;442:32598;;;;;:::i;:::-;;;;-1:-1:-1;442:32598:6;22446:19;442:32598;;;-1:-1:-1;442:32598:6;;22394:81;;:::i;442:32598::-;;;;;;;:::i;:::-;16788:27;;;;:::i;:::-;16830:11;-1:-1:-1;16861:3:6;442:32598;;;16843:16;;;;;;16931:8;;16880:60;16901:39;16931:8;16861:3;16931:8;;;;:::i;:::-;442:32598;;;;:::i;:::-;16901:39;;:::i;16880:60::-;442:32598;16861:3;:::i;:::-;16830:11;;16843:16;442:32598;;;;;;;;;;;;16843:16;442:32598;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;:::i;:::-;:::o;:::-;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;22943:602::-;442:32598;;23122:11;442:32598;;;;23115:18;;;23111:66;;442:32598;;22764:33;;;442:32598;;;;;;;;;;;;;;22764:33;;;;;;:::i;:::-;442:32598;22754:44;;442:32598;;;;23320:16;22764:33;442:32598;;;;;;;;:::i;:::-;23369:19;442:32598;;23369:27;;;23412:24;;:::o;23365:174::-;23474:54;;;;:::i;:::-;23467:61;:::o;23111:66::-;23149:17;;442:32598;23149:17;:::o;442:32598::-;;;;;;;7860:16;442:32598;7860:16;442:32598;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;8051:3;442:32598;;8051:3;442:32598;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;:::o;:::-;;5336:13;442:32598;;;;;;;:::o;:::-;;5976:1;442:32598;;;;;;;:::o;:::-;;;;;;;;;;;;:::o;:::-;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;15919:527;442:32598;;;;;;16012:30;442:32598;16013:29;:16;442:32598;;16013:29;442:32598;;;;;;16012:30;;442:32598;16012:30;16013:29;;;16058:8;442:32598;16058:8;:::o;16008:432::-;16101:34;:22;;;:::i;:::-;-1:-1:-1;16101:34:6;442:32598;16101:38;:34;;16166:22;16101:34;16166:22;;:::i;:::-;:34;;442:32598;16159:41;:::o;16097:333::-;16313:22;16353;16313:38;:22;16266:149;16313:22;;:::i;:::-;:38;;442:32598;16353:22;;:::i;:::-;442:32598;;16266:149;;:::i;442:32598::-;;;;;;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;21969:175;442:32598;;;;;;22062:45;;22101:4;22062:45;;;442:32598;;;;22062:45;;442:32598;;;;;;;;22062:45;;;;;;:75;:45;-1:-1:-1;22062:45:6;;;21969:175;442:32598;22110:27;442:32598;22062:75;;:::i;:45::-;;;;;;;;;;;;;;:::i;:::-;;;;22622:183;442:32598;;;22764:33;;;442:32598;;;;;;23526:1;442:32598;;;;;22764:33;;;;;;:::i;:::-;442:32598;22754:44;;22622:183;:::o;:::-;;442:32598;;22764:33;442:32598;22764:33;;;442:32598;;;;;;;;;;;22764:33;;;;;;:::i;442:32598::-;;;;;;;:::i;:::-;-1:-1:-1;442:32598:6;;;;;;;;;;;;;;;;;;;;;;:::o;21655:161::-;442:32598;;:::i;:::-;;-1:-1:-1;442:32598:6;21773:16;442:32598;;;;-1:-1:-1;442:32598:6;;:::i;1209:117:0:-;1240:68;442:32598:6;1108:6:0;442:32598:6;;719:10:4;1248:23:0;1240:68;:::i;:::-;442:32598:6;;;2006:22:0;442:32598:6;;2100:8:0;;;:::i;31752:133:6:-;442:32598;;31818:11;442:32598;;;;31811:18;31807:72;;31752:133::o;31807:72::-;31852:16;-1:-1:-1;31852:16:6;;-1:-1:-1;31852:16:6;2336:509:8;2496:15;:31;;2492:79;;2637:15;2633:72;;2772:67;;2336:509::o;2772:67::-;2810:18;2651:1;2810:18;;2651:1;2810:18;2633:72;2675:19;2651:1;2675:19;;2651:1;2675:19;2492:79;2550:10;;;;;;28318:1913:6;;;442:32598;;;28589:38;:22;28318:1913;28589:22;:::i;:::-;:38;;442:32598;28630:22;;;:::i;:::-;-1:-1:-1;442:32598:6;-1:-1:-1;28630:40:6;;;28756:35;29216:45;28756:35;;;;:::i;:::-;28927:22;29216;28927;29216:16;29063:62;29064:53;28926:63;28927:54;:22;:41;:22;;;:::i;:::-;:41;;442:32598;28927:54;:::i;:::-;28985:4;442:32598;;;;28926:63;29064:22;;;;:::i;:::-;442:32598;;29064:53;:::i;29063:62::-;29216:16;442:32598;;;;7147:9;442:32598;;;;;;;29216:22;442:32598;29216:45;:::i;:::-;29317:22;442:32598;29317:29;:22;;;:::i;442:32598::-;29313:576;;28585:1571;;30165:59;;28318:1913;:::o;29313:576::-;29843:31;29380:22;;;;29722:25;29380:22;:34;:22;29721:34;29380:22;;:::i;:::-;:34;;442:32598;29437:8;;;29433:210;;29313:576;29722:25;;;:::i;29721:34::-;29843:31;;;:::i;:::-;29313:576;;;;29433:210;29475:149;29522:22;;29562;28589:38;29522:22;;;:::i;29475:149::-;29433:210;;;28585:1571;30008:16;30105:22;30008:77;:22;:16;;30007:138;30008:16;442:32598;;;;7147:9;442:32598;;;;;;;30008:22;442:32598;30044:41;:22;;;:::i;30008:77::-;30105:22;;:::i;:::-;442:32598;;30007:138;;:::i;:::-;30165:59;;28318:1913;:::o;701:205:2:-;442:32598:6;;;840:58:2;;;;442:32598:6;;;;;840:58:2;;;442:32598:6;;;;;;;;;840:58:2;;;;;;442:32598:6;;840:58:2;:::i;:::-;;:::i;442:32598:6:-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;25746:19;442:32598;;;;;;;;;;;25746:19;442:32598;;;;;;25746:19;-1:-1:-1;442:32598:6;;;;:::o;:::-;;;;;;;;;:::o;25113:728::-;;;25236:36;;;:::i;:::-;:47;442:32598;;25799:33;22446:28;25669:67;25699:37;25746:43;22446:28;442:32598;22394:81;22446:28;;442:32598;;;;22446:19;442:32598;;;;;;;22446:28;442:32598;22394:81;;:::i;:::-;25459:35;25451:107;442:32598;;25459:35;;442:32598;;19701:16;442:32598;;;;;;;;;25459:61;25451:107;:::i;:::-;25606:53;442:32598;;:::i;:::-;25622:4;442:32598;;25606:53;442:32598;;;25606:53;;;442:32598;;;25606:53;;;442:32598;;25606:53;;;;;442:32598;-1:-1:-1;25606:53:6;;;442:32598;25568:35;;442:32598;;19701:16;442:32598;;;;;;;25568:35;442:32598;:::i;:::-;25699:27;442:32598;25699:37;:::i;25669:67::-;25746:43;:::i;:::-;442:32598;;;;22446:19;442:32598;;;;;;;25799:33;:35;442:32598;;25799:35;:::i;:::-;442:32598;;25113:728::o;442:32598::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;32298:241;32386:6;442:32598;;;;;;;32377:15;;;;32428:10;-1:-1:-1;32428:10:6;;;;;32806:148;;32968:8;32964:68;;32298:241::o;32964:68::-;32999:22;-1:-1:-1;32999:22:6;;-1:-1:-1;32999:22:6;32373:160;32504:10;32516:5;32504:10;;32516:5;;:::i;26125:1857::-;;26304:37;26125:1857;26304:37;:::i;:::-;26373:4;26356:21;;26373:4;;26393:16;26400:9;26393:16;:::o;26352:1624::-;26457:4;26440:21;;26457:4;;26477:16;26484:9;26477:16;:::o;26436:1540::-;26540:4;26523:21;;26540:4;;26560:16;26567:9;26560:16;:::o;26519:1457::-;26624:4;26607:21;;26624:4;;26644:16;26651:9;26644:16;:::o;26603:1373::-;26707:4;26690:21;;26707:4;;26727:16;26734:9;26727:16;:::o;26686:1290::-;26791:4;26774:21;;26791:4;;26811:16;26818:9;26811:16;:::o;26770:1206::-;26875:4;26858:21;;26875:4;;26895:16;26902:9;26895:16;:::o;26854:1122::-;26959:4;26942:21;;26959:4;;26979:16;26986:9;26979:16;:::o;26938:1038::-;27043:4;27026:21;;27043:4;;27063:16;27070:9;27063:16;:::o;27022:954::-;27126:3;27109:20;;27126:3;;27145:17;27152:10;27145:17;:::o;27105:871::-;27208:3;27191:20;;27208:3;;27227:17;27234:10;27227:17;:::o;27187:789::-;27291:3;27274:20;;27291:3;;27310:17;27317:10;27310:17;:::o;27270:706::-;27374:3;27357:20;;27374:3;;27393:17;27400:10;27393:17;:::o;27353:623::-;27456:3;27439:20;;27456:3;;27475:17;27482:10;27475:17;:::o;27435:541::-;27539:3;27522:20;;27539:3;;27558:17;27565:10;27558:17;:::o;27518:458::-;27621:3;27604:20;;27621:3;;27640:17;27647:10;27640:17;:::o;27600:376::-;27703:3;27686:20;;27703:3;;27722:17;27729:10;27722:17;:::o;27682:294::-;27785:3;27768:20;;27785:3;;27804:17;27811:10;27804:17;:::o;27764:212::-;27867:2;-1:-1:-1;27867:2:6;;27892:10;27885:17;:::o;27846:130::-;27948:11;27941:18;:::o;4880:171:8:-;4973:21;4969:76;;4880:171::o;4969:76::-;5017:17;;;;;;23693:1125:6;23832:16;442:32598;23868:20;;;;442:32598;23832:77;23851:58;:38;442:32598;;;;;;;23851:38;:58;;442:32598;23832:77;;:::i;:::-;23814:15;:95;23851:58;;;23925:8;;;442:32598;23925:8;:::o;23810:1002::-;23986:80;24005:61;:38;442:32598;;;;;;;23986:80;23814:15;23967:99;;;:133;;;23810:1002;23950:862;;;24132:28;:56;:28;;24163:25;24132:28;;;442:32598;24163:25;;442:32598;24132:56;;:::i;23950:862::-;24573:126;24728:40;23814:15;24005:61;24638:38;442:32598;24574:44;24500:36;24243:34;24743:25;23814:15;;24243:34;:::i;:::-;24431:31;24317:71;:38;442:32598;;;;;;;24317:38;:71;;442:32598;24431:31;;;:::i;:::-;24500:36;:::i;:::-;24574:28;;;442:32598;24574:44;:::i;:::-;442:32598;;;;;;24638:38;:61;;442:32598;24573:126;;:::i;:::-;24743:25;;442:32598;24728:40;;:::i;23967:133::-;-1:-1:-1;24086:14:6;442:32598;;;23967:133;;2851:1290:8;;;;;;;;3103:15;:33;;3099:86;;3214:4;3199:19;;;3195:88;;3297:21;;;;3358:3;-1:-1:-1;3334:108:8;;3460:20;;3456:95;;3597:1;3569:29;;3565:113;;3696:43;3692:135;;3293:696;4003:7;3999:136;;2851:1290;:::o;3999:136::-;4026:99;;2851:1290::o;4026:99::-;4073:37;3317:1;4073:37;;3317:1;4073:37;3692:135;3766:46;3317:1;3766:46;;3317:1;3766:46;3565:113;3625:38;3317:1;3625:38;;3317:1;3625:38;3456:95;3507:29;3317:1;3507:29;;3317:1;3507:29;3334:108;3388:39;3317:1;3388:39;;3317:1;3388:39;3293:696;3861:20;;;;;;:54;;;3293:696;3857:122;;3293:696;3857:122;3942:22;3317:1;3942:22;;3317:1;3942:22;3861:54;3885:30;;;;3861:54;;;3195:88;3241:31;;;;;;2270:187:0;442:32598:6;;2362:6:0;442:32598:6;;;;;;;;;2362:6:0;442:32598:6;;2410:40:0;2362:6;2410:40;;2270:187::o;1537:793:8:-;;;;;1793:23;:49;;;;;1537:793;1789:99;;;1959:15;:32;1955:80;;1959:15;2105:30;2101:77;;2257:11;2253:71;;1537:793::o;2253:71::-;2291:22;1815:1;2291:22;;1815:1;2291:22;2101:77;2158:9;1815:1;2158:9;;1815:1;2158:9;1789:99;1865:12;1815:1;1865:12;;1815:1;1865:12;1793:49;1820:22;;;1793:49;;;30919:827:6;31062:7;31045:15;442:32598;31045:15;;;:::i;442:32598::-;31062:7;:::i;:::-;31156:48;31166:10;31156:27;31166:10;31156:21;31166:10;442:32598;;;;7147:9;442:32598;;;;;;;31156:27;442:32598;31156:48;:::i;:::-;31115:27;31166:10;31115:21;31166:10;442:32598;;;;7147:9;442:32598;;;;;;;31115:27;442:32598;31045:9;31269:22;;;:::i;:::-;:39;;442:32598;31265:281;;30919:827;31641:48;:22;:38;:22;;;:::i;:48::-;:38;31600:22;;;:::i;:::-;:38;;442:32598;31705:34;442:32598;;;;;31166:10;;31705:34;31166:10;31705:34;;442:32598;;;;;;;;31705:34;;;;30919:827::o;31265:281::-;31389:27;31166:10;31389:21;31166:10;442:32598;;;;7147:9;442:32598;;;;;;;31389:27;442:32598;31045:9;31430:22;;;:::i;:::-;:39;;442:32598;-1:-1:-1;31385:151:6;31265:281;31385:151;31496:25;-1:-1:-1;31496:25:6;;-1:-1:-1;31496:25:6;30537:376;442:32598;30649:11;442:32598;;;;;30642:18;30638:57;;442:32598;;;;;;30709:16;442:32598;;30709:38;;442:32598;30709:42;:38;;30775:16;;:22;:16;442:32598;;;;7147:9;442:32598;;;;;;;30775:22;442:32598;30811:4;442:32598;;;;;;30811:4;442:32598;;;;;;;30709:38;30819:22;30774:83;30819:22;;:::i;442:32598::-;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;3207:706:2;442:32598:6;;;;;;;;;;:::i;:::-;;;;;;;;;1465:19:3;;:23;442:32598:6;;-1:-1:-1;5341:31:3;5389:51;5341:31;;442:32598:6;5341:31:3;;;;;;;;;;:::i;:::-;5389:51;;:::i;:::-;442:32598:6;;3735:21:2;3731:176;;3207:706;;:::o;3731:176::-;3819:30;442:32598:6;3819:30:2;;;3811:85;3819:30;;;;;;:::i;:::-;3811:85;:::i;442:32598:6:-;;;;;;;;;;;;;;;;;;;;;;;31891:401;31978:6;442:32598;;;;;;;31969:15;;;;32004:9;;:18;32000:86;;31891:401::o;31965:321::-;32120:9;;32116:82;;1077:68:2;442:32598:6;;;1077:68:2;442:32598:6;1077:68:2;;;;32242:10:6;1077:68:2;;;442:32598:6;32262:4;442:32598;;;;;;;;;1077:68:2;;;;;;:::i;442:32598:6:-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;442:32598:6;;;;:::o;:::-;;;:::o;7561:692:3:-;;;;7731:516;;;7758:17;;:::o;7731:516::-;442:32598:6;;7876:21:3;:17;;8010:154;;;;;;;7872:365;442:32598:6;;;;;;;8202:20:3;;;;;;;;;;442:32598:6;;;;;;;;;;;;;;;;7896:1:3;442:32598:6;;;;;;;;;;8202:20:3;;;

ipfs://a475a4eeb8a9107d36d7ce8bafd2368a885a03513275450029834b0677901e91