Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "@1inch/delegating/contracts/FarmingDelegationPod.sol";
import "./helpers/VotingPowerCalculator.sol";
import "./interfaces/IVotable.sol";
import "./St1inch.sol";

contract PowerPod is FarmingDelegationPod, VotingPowerCalculator, IVotable {
    uint256 private constant _MAX_SHARE_PODS = 3;
    uint256 private constant _SHARE_POD_GAS_LIMIT = 140_000;

    constructor(string memory name_, string memory symbol_, St1inch st1inch)
        FarmingDelegationPod(name_, symbol_, st1inch, _MAX_SHARE_PODS, _SHARE_POD_GAS_LIMIT)
        VotingPowerCalculator(st1inch.expBase(), st1inch.origin())
    {}

    function votingPowerOf(address account) external view virtual returns (uint256) {
        return _votingPowerAt(balanceOf(account), block.timestamp);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@1inch/erc20-pods/contracts/ERC20Pods.sol";
import "./interfaces/IDelegatedShare.sol";

contract DelegatedShare is IDelegatedShare, ERC20Pods {
    error ApproveDisabled();
    error TransferDisabled();
    error NotOwner();

    address immutable private _owner;

    modifier onlyOwner {
        if (msg.sender != _owner) revert NotOwner();
        _;
    }

    constructor(
        string memory name,
        string memory symbol,
        uint256 maxUserPods,
        uint256 podCallGasLimit
    ) ERC20(name, symbol) ERC20Pods(maxUserPods, podCallGasLimit) {
        _owner = msg.sender;
    }

    function addDefaultFarmIfNeeded(address account, address farm) external onlyOwner {
        if (!hasPod(account, farm)) {
            _addPod(account, farm);
        }
    }

    function mint(address account, uint256 amount) external onlyOwner {
        _mint(account, amount);
    }

    function burn(address account, uint256 amount) external onlyOwner {
        _burn(account, amount);
    }

    function approve(address /* spender */, uint256 /* amount */) public pure override(ERC20, IERC20) returns (bool) {
        revert ApproveDisabled();
    }

    function transfer(address /* to */, uint256 /* amount */) public pure override(IERC20, ERC20) returns (bool) {
        revert TransferDisabled();
    }

    function transferFrom(address /* from */, address /* to */, uint256 /* amount */) public pure override(IERC20, ERC20) returns (bool) {
        revert TransferDisabled();
    }

    function increaseAllowance(address /* spender */, uint256 /* addedValue */) public pure override returns (bool) {
        revert ApproveDisabled();
    }

    function decreaseAllowance(address /* spender */, uint256 /* subtractedValue */) public pure override returns (bool) {
        revert ApproveDisabled();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@1inch/erc20-pods/contracts/interfaces/IERC20Pods.sol";
import "@1inch/erc20-pods/contracts/Pod.sol";

import "./interfaces/IDelegationPod.sol";

contract DelegationPod is IDelegationPod, Pod, ERC20 {
    error ApproveDisabled();
    error TransferDisabled();

    mapping(address => address) public delegated;

    constructor(string memory name_, string memory symbol_, IERC20Pods token_)
        ERC20(name_, symbol_) Pod(token_)
    {}  // solhint-disable-line no-empty-blocks

    function delegate(address delegatee) public virtual {
        address prevDelegatee = delegated[msg.sender];
        if (prevDelegatee != delegatee) {
            delegated[msg.sender] = delegatee;
            emit Delegated(msg.sender, delegatee);
            uint256 balance = IERC20Pods(token).podBalanceOf(address(this), msg.sender);
            if (balance > 0) {
                _updateBalances(msg.sender, msg.sender, prevDelegatee, delegatee, balance);
            }
        }
    }

    function _updateBalances(address from, address to, uint256 amount) internal override {
        _updateBalances(
            from,
            to,
            from == address(0) ? address(0) : delegated[from],
            to == address(0) ? address(0) : delegated[to],
            amount
        );
    }

    function _updateBalances(address /* from */, address /* to */, address fromDelegatee, address toDelegatee, uint256 amount) internal virtual {
        if (fromDelegatee != toDelegatee && amount > 0) {
            if (fromDelegatee == address(0)) {
                _mint(toDelegatee, amount);
            } else if (toDelegatee == address(0)) {
                _burn(fromDelegatee, amount);
            } else {
                _transfer(fromDelegatee, toDelegatee, amount);
            }
        }
    }

    // ERC20 overrides

    function transfer(address /* to */, uint256 /* amount */) public pure override(IERC20, ERC20) returns (bool) {
        revert TransferDisabled();
    }

    function transferFrom(address /* from */, address /* to */, uint256 /* amount */) public pure override(IERC20, ERC20) returns (bool) {
        revert TransferDisabled();
    }

    function approve(address /* spender */, uint256 /* amount */) public pure override(ERC20, IERC20) returns (bool) {
        revert ApproveDisabled();
    }

    function increaseAllowance(address /* spender */, uint256 /* addedValue */) public pure override returns (bool) {
        revert ApproveDisabled();
    }

    function decreaseAllowance(address /* spender */, uint256 /* subtractedValue */) public pure override returns (bool) {
        revert ApproveDisabled();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./TokenizedDelegationPod.sol";
import "./interfaces/IFarmingDelegationPod.sol";
import "@1inch/farming/contracts/MultiFarmingPod.sol";

contract FarmingDelegationPod is IFarmingDelegationPod, TokenizedDelegationPod {
    error DefaultFarmTokenMismatch();

    uint256 private constant _MAX_FARM_REWARDS = 3;

    mapping(address => address) public defaultFarms;

    constructor(string memory name_, string memory symbol_, IERC20Pods token_, uint256 maxSharePods_, uint256 sharePodGasLimit_)
        TokenizedDelegationPod(name_, symbol_, token_, maxSharePods_, sharePodGasLimit_)
    {}  // solhint-disable-line no-empty-blocks

    function register(string memory name, string memory symbol) public override(ITokenizedDelegationPod, TokenizedDelegationPod) returns(IDelegatedShare shareToken) {
        shareToken = super.register(name, symbol);
        MultiFarmingPod farm = new MultiFarmingPod(shareToken, _MAX_FARM_REWARDS);
        farm.transferOwnership(msg.sender);
        defaultFarms[msg.sender] = address(farm);
    }

    function delegate(address delegatee) public override(IDelegationPod, TokenizedDelegationPod) {
        super.delegate(delegatee);
        address defaultFarm = defaultFarms[delegatee];
        if (defaultFarm != address(0)) {
            registration[delegatee].addDefaultFarmIfNeeded(msg.sender, defaultFarm);
        }
    }

    function setDefaultFarm(address farm) external onlyRegistered {
        if (farm != address(0) && Pod(farm).token() != registration[msg.sender]) revert DefaultFarmTokenMismatch();
        defaultFarms[msg.sender] = farm;
        emit DefaultFarmSet(farm);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@1inch/erc20-pods/contracts/interfaces/IERC20Pods.sol";

interface IDelegatedShare is IERC20Pods {
    function addDefaultFarmIfNeeded(address account, address farm) external; // onlyOwner
    function mint(address account, uint256 amount) external; // onlyOwner
    function burn(address account, uint256 amount) external; // onlyOwner
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@1inch/erc20-pods/contracts/interfaces/IPod.sol";

interface IDelegationPod is IPod, IERC20 {
    event Delegated(address account, address delegatee);

    function delegated(address delegator) external view returns(address delegatee);
    function delegate(address delegatee) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ITokenizedDelegationPod.sol";

interface IFarmingDelegationPod is ITokenizedDelegationPod {
    event DefaultFarmSet(address defaultFarm);

    function setDefaultFarm(address farm) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IDelegationPod.sol";
import "./IDelegatedShare.sol";

interface ITokenizedDelegationPod is IDelegationPod {
    event RegisterDelegatee(address delegatee);

    function register(string memory name, string memory symbol) external returns(IDelegatedShare shareToken);
    function registration(address account) external returns(IDelegatedShare shareToken);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./DelegationPod.sol";
import "./DelegatedShare.sol";
import "./interfaces/ITokenizedDelegationPod.sol";
import "./interfaces/IDelegatedShare.sol";

contract TokenizedDelegationPod is ITokenizedDelegationPod, DelegationPod {
    error NotRegisteredDelegatee();
    error AlreadyRegistered();

    uint256 public immutable maxSharePods;
    uint256 public immutable sharePodGasLimit;

    mapping(address => IDelegatedShare) public registration;

    modifier onlyRegistered {
        if (address(registration[msg.sender]) == address(0)) revert NotRegisteredDelegatee();
        _;
    }

    modifier onlyNotRegistered {
        if (address(registration[msg.sender]) != address(0)) revert AlreadyRegistered();
        _;
    }

    constructor(string memory name_, string memory symbol_, IERC20Pods token_, uint256 maxSharePods_, uint256 sharePodGasLimit_) DelegationPod(name_, symbol_, token_) {
        maxSharePods = maxSharePods_;
        sharePodGasLimit = sharePodGasLimit_;
    }

    function delegate(address delegatee) public virtual override(IDelegationPod, DelegationPod) {
        if (delegatee != address(0) && address(registration[delegatee]) == address(0)) revert NotRegisteredDelegatee();
        super.delegate(delegatee);
    }

    function register(string memory name, string memory symbol) public virtual onlyNotRegistered returns(IDelegatedShare shareToken) {
        shareToken = new DelegatedShare(name, symbol, maxSharePods, sharePodGasLimit);
        registration[msg.sender] = shareToken;
        emit RegisterDelegatee(msg.sender);
    }

    function _updateBalances(address from, address to, address fromDelegatee, address toDelegatee, uint256 amount) internal virtual override {
        super._updateBalances(from, to, fromDelegatee, toDelegatee, amount);

        if (fromDelegatee != address(0)) {
            registration[fromDelegatee].burn(from, amount);
        }
        if (toDelegatee != address(0)) {
            registration[toDelegatee].mint(to, amount);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@1inch/solidity-utils/contracts/libraries/AddressSet.sol";

import "./interfaces/IERC20Pods.sol";
import "./interfaces/IPod.sol";
import "./libs/ReentrancyGuard.sol";

abstract contract ERC20Pods is ERC20, IERC20Pods, ReentrancyGuardExt {
    using AddressSet for AddressSet.Data;
    using AddressArray for AddressArray.Data;
    using ReentrancyGuardLib for ReentrancyGuardLib.Data;

    error PodAlreadyAdded();
    error PodNotFound();
    error InvalidPodAddress();
    error PodsLimitReachedForAccount();
    error InsufficientGas();
    error ZeroPodsLimit();

    uint256 public immutable podsLimit;
    uint256 public immutable podCallGasLimit;

    ReentrancyGuardLib.Data private _guard;
    mapping(address => AddressSet.Data) private _pods;

    constructor(uint256 podsLimit_, uint256 podCallGasLimit_) {
        if (podsLimit_ == 0) revert ZeroPodsLimit();
        podsLimit = podsLimit_;
        podCallGasLimit = podCallGasLimit_;
        _guard.init();
    }

    function hasPod(address account, address pod) public view virtual returns(bool) {
        return _pods[account].contains(pod);
    }

    function podsCount(address account) public view virtual returns(uint256) {
        return _pods[account].length();
    }

    function podAt(address account, uint256 index) public view virtual returns(address) {
        return _pods[account].at(index);
    }

    function pods(address account) public view virtual returns(address[] memory) {
        return _pods[account].items.get();
    }

    function balanceOf(address account) public nonReentrantView(_guard) view override(IERC20, ERC20) virtual returns(uint256) {
        return super.balanceOf(account);
    }

    function podBalanceOf(address pod, address account) public nonReentrantView(_guard) view virtual returns(uint256) {
        if (hasPod(account, pod)) {
            return super.balanceOf(account);
        }
        return 0;
    }

    function addPod(address pod) public virtual {
        _addPod(msg.sender, pod);
    }

    function removePod(address pod) public virtual {
        _removePod(msg.sender, pod);
    }

    function removeAllPods() public virtual {
        _removeAllPods(msg.sender);
    }

    function _addPod(address account, address pod) internal virtual {
        if (pod == address(0)) revert InvalidPodAddress();
        if (!_pods[account].add(pod)) revert PodAlreadyAdded();
        if (_pods[account].length() > podsLimit) revert PodsLimitReachedForAccount();

        emit PodAdded(account, pod);
        uint256 balance = balanceOf(account);
        if (balance > 0) {
            _updateBalances(pod, address(0), account, balance);
        }
    }

    function _removePod(address account, address pod) internal virtual {
        if (!_pods[account].remove(pod)) revert PodNotFound();

        emit PodRemoved(account, pod);
        uint256 balance = balanceOf(account);
        if (balance > 0) {
            _updateBalances(pod, account, address(0), balance);
        }
    }

    function _removeAllPods(address account) internal virtual {
        address[] memory items = _pods[account].items.get();
        uint256 balance = balanceOf(account);
        unchecked {
            for (uint256 i = items.length; i > 0; i--) {
                _pods[account].remove(items[i - 1]);
                emit PodRemoved(account, items[i - 1]);
                if (balance > 0) {
                    _updateBalances(items[i - 1], account, address(0), balance);
                }
            }
        }
    }

    /// @notice Assembly implementation of the gas limited call to avoid return gas bomb,
    // moreover call to a destructed pod would also revert even inside try-catch block in Solidity 0.8.17
    /// @dev try IPod(pod).updateBalances{gas: _POD_CALL_GAS_LIMIT}(from, to, amount) {} catch {}
    function _updateBalances(address pod, address from, address to, uint256 amount) private {
        bytes4 selector = IPod.updateBalances.selector;
        bytes4 exception = InsufficientGas.selector;
        uint256 gasLimit = podCallGasLimit;
        assembly {  // solhint-disable-line no-inline-assembly
            let ptr := mload(0x40)
            mstore(ptr, selector)
            mstore(add(ptr, 0x04), from)
            mstore(add(ptr, 0x24), to)
            mstore(add(ptr, 0x44), amount)

            if lt(div(mul(gas(), 63), 64), gasLimit) {
                mstore(0, exception)
                revert(0, 4)
            }
            pop(call(gasLimit, pod, 0, ptr, 0x64, 0, 0))
        }
    }

    // ERC20 Overrides

    function _afterTokenTransfer(address from, address to, uint256 amount) internal nonReentrant(_guard) override virtual {
        super._afterTokenTransfer(from, to, amount);

        unchecked {
            if (amount > 0 && from != to) {
                address[] memory a = _pods[from].items.get();
                address[] memory b = _pods[to].items.get();
                uint256 aLength = a.length;
                uint256 bLength = b.length;

                for (uint256 i = 0; i < aLength; i++) {
                    address pod = a[i];

                    uint256 j;
                    for (j = 0; j < bLength; j++) {
                        if (pod == b[j]) {
                            // Both parties are participating of the same Pod
                            _updateBalances(pod, from, to, amount);
                            b[j] = address(0);
                            break;
                        }
                    }

                    if (j == bLength) {
                        // Sender is participating in a Pod, but receiver is not
                        _updateBalances(pod, from, address(0), amount);
                    }
                }

                for (uint256 j = 0; j < bLength; j++) {
                    address pod = b[j];
                    if (pod != address(0)) {
                        // Receiver is participating in a Pod, but sender is not
                        _updateBalances(pod, address(0), to, amount);
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IERC20Pods is IERC20 {
    event PodAdded(address account, address pod);
    event PodRemoved(address account, address pod);

    function hasPod(address account, address pod) external view returns(bool);
    function podsCount(address account) external view returns(uint256);
    function podAt(address account, uint256 index) external view returns(address);
    function pods(address account) external view returns(address[] memory);
    function podBalanceOf(address pod, address account) external view returns(uint256);

    function addPod(address pod) external;
    function removePod(address pod) external;
    function removeAllPods() external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IPod {
    function updateBalances(address from, address to, uint256 amount) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library ReentrancyGuardLib {
    error ReentrantCall();

    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    struct Data {
        uint256 _status;
    }

    function init(Data storage self) internal {
        self._status = _NOT_ENTERED;
    }

    function enter(Data storage self) internal {
        if (self._status == _ENTERED) revert ReentrantCall();
        self._status = _ENTERED;
    }

    function exit(Data storage self) internal {
        self._status = _NOT_ENTERED;
    }

    function check(Data storage self) internal view returns (bool) {
        return self._status == _ENTERED;
    }
}

contract ReentrancyGuardExt {
    using ReentrancyGuardLib for ReentrancyGuardLib.Data;

    modifier nonReentrant(ReentrancyGuardLib.Data storage self) {
        self.enter();
        _;
        self.exit();
    }

    modifier nonReentrantView(ReentrancyGuardLib.Data storage self) {
        if (self.check()) revert ReentrancyGuardLib.ReentrantCall();
        _;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./interfaces/IPod.sol";
import "./interfaces/IERC20Pods.sol";

abstract contract Pod is IPod {
    error AccessDenied();

    IERC20Pods public immutable token;

    modifier onlyToken {
        if (msg.sender != address(token)) revert AccessDenied();
        _;
    }

    constructor(IERC20Pods token_) {
        token = token_;
    }

    function updateBalances(address from, address to, uint256 amount) external onlyToken {
        _updateBalances(from, to, amount);
    }

    function _updateBalances(address from, address to, uint256 amount) internal virtual;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/Math.sol";

library FarmAccounting {
    error ZeroDuration();
    error DurationTooLarge();
    error AmountTooLarge();

    struct Info {
        uint40 finished;
        uint32 duration;
        uint184 reward;
    }

    uint256 internal constant _MAX_REWARD_AMOUNT = 1e32;  // 108 bits
    uint256 internal constant _SCALE = 1e18;  // 60 bits

    /// @dev Requires extra 18 decimals for precision, result fits in 168 bits
    function farmedSinceCheckpointScaled(Info memory info, uint256 checkpoint) internal view returns(uint256 amount) {
        unchecked {
            if (info.duration > 0) {
                uint256 elapsed = Math.min(block.timestamp, info.finished) - Math.min(checkpoint, info.finished);
                // size of (type(uint32).max * _MAX_REWARD_AMOUNT * _SCALE) is less than 200 bits, so there is no overflow
                return elapsed * info.reward * _SCALE / info.duration;
            }
        }
    }

    function startFarming(Info storage info, uint256 amount, uint256 period) internal returns(uint256) {
        if (period == 0) revert ZeroDuration();
        if (period > type(uint32).max) revert DurationTooLarge();
        if (amount > _MAX_REWARD_AMOUNT) revert AmountTooLarge();

        // If something left from prev farming add it to the new farming
        Info memory prev = info;
        if (block.timestamp < prev.finished) {
            amount += prev.reward - farmedSinceCheckpointScaled(prev, prev.finished - prev.duration) / _SCALE;
        }

        (info.finished, info.duration, info.reward) = (uint40(block.timestamp + period), uint32(period), uint184(amount));
        return amount;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./FarmAccounting.sol";

library UserAccounting {
    struct Info {
        uint40 checkpoint;
        uint216 farmedPerTokenStored;
        mapping(address => int256) corrections;
    }

    function farmedPerToken(
        Info storage info,
        bytes32 context,
        function(bytes32) internal view returns(uint256) lazyGetSupply,
        function(bytes32, uint256) internal view returns(uint256) lazyGetFarmed
    ) internal view returns(uint256) {
        (uint256 checkpoint, uint256 fpt) = (info.checkpoint, info.farmedPerTokenStored);
        if (block.timestamp != checkpoint) {
            uint256 supply = lazyGetSupply(context);
            if (supply > 0) {
                // fpt increases by 168 bit / supply
                unchecked { fpt += lazyGetFarmed(context, checkpoint) / supply; }
            }
        }
        return fpt;
    }

    function farmed(Info storage info, address account, uint256 balance, uint256 fpt) internal view returns(uint256) {
        // balance * fpt is less than 168 bit
        return uint256(int256(balance * fpt) - info.corrections[account]) / FarmAccounting._SCALE;
    }

    function eraseFarmed(Info storage info, address account, uint256 balance, uint256 fpt) internal {
        // balance * fpt is less than 168 bit
        info.corrections[account] = int256(balance * fpt);
    }

    function updateFarmedPerToken(Info storage info, uint256 fpt) internal {
        (info.checkpoint, info.farmedPerTokenStored) = (uint40(block.timestamp), uint216(fpt));
    }

    function updateBalances(Info storage info, address from, address to, uint256 amount, uint256 fpt) internal {
        bool fromZero = (from == address(0));
        bool toZero = (to == address(0));
        if (amount > 0 && from != to) {
            if (fromZero || toZero) {
                updateFarmedPerToken(info, fpt);
            }

            // fpt is less than 168 bit, so amount should be less 98 bit
            int256 diff = int256(amount * fpt);
            if (!fromZero) {
                info.corrections[from] -= diff;
            }
            if (!toZero) {
                info.corrections[to] += diff;
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./accounting/FarmAccounting.sol";
import "./accounting/UserAccounting.sol";

library FarmingLib {
    using FarmAccounting for FarmAccounting.Info;
    using UserAccounting for UserAccounting.Info;
    using FarmingLib for FarmingLib.Info;

    struct Data {
        FarmAccounting.Info farmInfo;
        UserAccounting.Info userInfo;
    }

    struct Info {
        function() internal view returns(uint256) getTotalSupply;
        bytes32 dataSlot;
    }

    function makeInfo(function() internal view returns(uint256) getTotalSupply, Data storage data) internal pure returns(Info memory info) {
        info.getTotalSupply = getTotalSupply;
        bytes32 dataSlot;
        assembly {  // solhint-disable-line no-inline-assembly
            dataSlot := data.slot
        }
        info.dataSlot = dataSlot;
    }

    function getData(Info memory self) internal pure returns(Data storage data) {
        bytes32 dataSlot = self.dataSlot;
        assembly {  // solhint-disable-line no-inline-assembly
            data.slot := dataSlot
        }
    }

    function startFarming(Info memory self, uint256 amount, uint256 period) internal returns(uint256 reward) {
        Data storage data = self.getData();
        data.userInfo.updateFarmedPerToken(_farmedPerToken(self));
        reward = data.farmInfo.startFarming(amount, period);
    }

    function farmed(Info memory self, address account, uint256 balance) internal view returns(uint256) {
        return self.getData().userInfo.farmed(account, balance, _farmedPerToken(self));
    }

    function claim(Info memory self, address account, uint256 balance) internal returns(uint256 amount) {
        Data storage data = self.getData();
        uint256 fpt = _farmedPerToken(self);
        amount = data.userInfo.farmed(account, balance, fpt);
        if (amount > 0) {
            data.userInfo.eraseFarmed(account, balance, fpt);
        }
    }

    function updateBalances(Info memory self, address from, address to, uint256 amount) internal {
        self.getData().userInfo.updateBalances(from, to, amount, _farmedPerToken(self));
    }

    function _farmedPerToken(Info memory self) private view returns (uint256) {
        return self.getData().userInfo.farmedPerToken(_infoToContext(self), _lazyGetSupply, _lazyGetFarmed);
    }

    // UserAccounting bindings

    function _lazyGetSupply(bytes32 context) private view returns(uint256) {
        Info memory self = _contextToInfo(context);
        return self.getTotalSupply();
    }

    function _lazyGetFarmed(bytes32 context, uint256 checkpoint) private view returns(uint256) {
        Info memory self = _contextToInfo(context);
        return self.getData().farmInfo.farmedSinceCheckpointScaled(checkpoint);
    }

    function _contextToInfo(bytes32 context) private pure returns(Info memory self) {
        assembly {  // solhint-disable-line no-inline-assembly
            self := context
        }
    }

    function _infoToContext(Info memory self) private pure returns(bytes32 context) {
        assembly {  // solhint-disable-line no-inline-assembly
            context := self
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@1inch/erc20-pods/contracts/interfaces/IPod.sol";
import "../accounting/FarmAccounting.sol";

interface IMultiFarmingPod is IPod {
    event FarmCreated(address token, address reward);
    event DistributorChanged(address oldDistributor, address newDistributor);
    event RewardAdded(address token, uint256 reward, uint256 duration);

    // View functions
    function totalSupply() external view returns(uint256);
    function distributor() external view returns(address);
    function farmInfo(IERC20 rewardsToken) external view returns(FarmAccounting.Info memory);
    function farmed(IERC20 rewardsToken, address account) external view returns(uint256);

    // User functions
    function claim(IERC20 rewardsToken) external;
    function claim() external;

    // Owner functions
    function setDistributor(address distributor_) external;

    // Distributor functions
    function startFarming(IERC20 rewardsToken, uint256 amount, uint256 period) external;
    function rescueFunds(IERC20 token, uint256 amount) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@1inch/erc20-pods/contracts/Pod.sol";
import "@1inch/solidity-utils/contracts/libraries/SafeERC20.sol";
import "@1inch/solidity-utils/contracts/libraries/AddressSet.sol";
import "@1inch/erc20-pods/contracts/interfaces/IERC20Pods.sol";

import "./interfaces/IMultiFarmingPod.sol";
import "./FarmingLib.sol";

contract MultiFarmingPod is Pod, IMultiFarmingPod, Ownable {
    using SafeERC20 for IERC20;
    using FarmingLib for FarmingLib.Info;
    using Address for address payable;
    using AddressSet for AddressSet.Data;
    using AddressArray for AddressArray.Data;

    error ZeroFarmableTokenAddress();
    error ZeroRewardsTokenAddress();
    error SameDistributor();
    error RewardsTokenAlreadyAdded();
    error RewardsTokensLimitTooHigh(uint256);
    error RewardsTokensLimitReached();
    error RewardsTokenNotFound();

    uint256 public immutable rewardsTokensLimit;

    address private _distributor;
    uint256 private _totalSupply;
    mapping(IERC20 => FarmingLib.Data) private _farms;
    AddressSet.Data private _rewardsTokens;

    modifier onlyDistributor {
        if (msg.sender != _distributor) revert AccessDenied();
        _;
    }

    constructor(IERC20Pods farmableToken_, uint256 rewardsTokensLimit_) Pod(farmableToken_) {
        if (rewardsTokensLimit_ > 5) revert RewardsTokensLimitTooHigh(rewardsTokensLimit_);
        if (address(farmableToken_) == address(0)) revert ZeroFarmableTokenAddress();

        rewardsTokensLimit = rewardsTokensLimit_;
    }

    function rewardsTokens() external view returns(address[] memory) {
        return _rewardsTokens.items.get();
    }

    function farmInfo(IERC20 rewardsToken) public view returns(FarmAccounting.Info memory) {
        return _farms[rewardsToken].farmInfo;
    }

    function totalSupply() public view returns(uint256) {
        return _totalSupply;
    }

    function distributor() public view returns(address) {
        return _distributor;
    }

    function setDistributor(address distributor_) public virtual onlyOwner {
        address oldDistributor = _distributor;
        if (distributor_ == oldDistributor) revert SameDistributor();
        emit DistributorChanged(oldDistributor, distributor_);
        _distributor = distributor_;
    }

    function addRewardsToken(address rewardsToken) public virtual onlyOwner {
        if (_rewardsTokens.length() == rewardsTokensLimit) revert RewardsTokensLimitReached();
        if (!_rewardsTokens.add(rewardsToken)) revert RewardsTokenAlreadyAdded();
        emit FarmCreated(address(token), rewardsToken);
    }

    function startFarming(IERC20 rewardsToken, uint256 amount, uint256 period) public virtual onlyDistributor {
        if (!_rewardsTokens.contains(address(rewardsToken))) revert RewardsTokenNotFound();

        uint256 reward = _makeInfo(rewardsToken).startFarming(amount, period);
        emit RewardAdded(address(rewardsToken), reward, period);
        rewardsToken.safeTransferFrom(msg.sender, address(this), amount);
    }

    function farmed(IERC20 rewardsToken, address account) public view virtual returns(uint256) {
        uint256 balance = IERC20Pods(token).podBalanceOf(address(this), account);
        return _makeInfo(rewardsToken).farmed(account, balance);
    }

    function claim(IERC20 rewardsToken) public virtual {
        uint256 podBalance = IERC20Pods(token).podBalanceOf(address(this), msg.sender);
        _claim(rewardsToken, msg.sender, podBalance);
    }

    function claim() public virtual {
        uint256 podBalance = IERC20Pods(token).podBalanceOf(address(this), msg.sender);
        address[] memory tokens = _rewardsTokens.items.get();
        unchecked {
            for (uint256 i = 0; i < tokens.length; i++) {
                _claim(IERC20(tokens[i]), msg.sender, podBalance);
            }
        }
    }

    function _claim(IERC20 rewardsToken, address account, uint256 podBalance) private {
        uint256 amount = _makeInfo(rewardsToken).claim(account, podBalance);
        if (amount > 0) {
            _transferReward(rewardsToken, account, amount);
        }
    }

    function _transferReward(IERC20 reward, address to, uint256 amount) internal virtual {
        reward.safeTransfer(to, amount);
    }

    function _updateBalances(address from, address to, uint256 amount) internal virtual override {
        address[] memory tokens = _rewardsTokens.items.get();
        unchecked {
            for (uint256 i = 0; i < tokens.length; i++) {
                _makeInfo(IERC20(tokens[i])).updateBalances(from, to, amount);
            }
        }
        if (from == address(0)) {
            _totalSupply += amount;
        }
        if (to == address(0)) {
            _totalSupply -= amount;
        }
    }

    function rescueFunds(IERC20 token, uint256 amount) public virtual onlyDistributor {
        if(token == IERC20(address(0))) {
            payable(_distributor).sendValue(amount);
        } else {
            token.safeTransfer(_distributor, amount);
        }
    }

    function _makeInfo(IERC20 rewardsToken) private view returns(FarmingLib.Info memory) {
        return FarmingLib.makeInfo(totalSupply, _farms[rewardsToken]);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
pragma abicoder v1;

interface IDaiLikePermit {
    function permit(
        address holder,
        address spender,
        uint256 nonce,
        uint256 expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
pragma abicoder v1;

/// @title Library that implements address array on mapping, stores array length at 0 index.
library AddressArray {
    error IndexOutOfBounds();
    error PopFromEmptyArray();
    error OutputArrayTooSmall();

    /// @dev Data struct containing raw mapping.
    struct Data {
        mapping(uint256 => uint256) _raw;
    }

    /// @dev Length of array.
    function length(Data storage self) internal view returns (uint256) {
        return self._raw[0] >> 160;
    }

    /// @dev Returns data item from `self` storage at `i`.
    function at(Data storage self, uint256 i) internal view returns (address) {
        return address(uint160(self._raw[i]));
    }

    /// @dev Returns list of addresses from storage `self`.
    function get(Data storage self) internal view returns (address[] memory arr) {
        uint256 lengthAndFirst = self._raw[0];
        arr = new address[](lengthAndFirst >> 160);
        _get(self, arr, lengthAndFirst);
    }

    /// @dev Puts list of addresses from `self` storage into `output` array.
    function get(Data storage self, address[] memory output) internal view returns (address[] memory) {
        return _get(self, output, self._raw[0]);
    }

    function _get(
        Data storage self,
        address[] memory output,
        uint256 lengthAndFirst
    ) private view returns (address[] memory) {
        uint256 len = lengthAndFirst >> 160;
        if (len > output.length) revert OutputArrayTooSmall();
        if (len > 0) {
            output[0] = address(uint160(lengthAndFirst));
            unchecked {
                for (uint256 i = 1; i < len; i++) {
                    output[i] = address(uint160(self._raw[i]));
                }
            }
        }
        return output;
    }

    /// @dev Array push back `account` operation on storage `self`.
    function push(Data storage self, address account) internal returns (uint256) {
        unchecked {
            uint256 lengthAndFirst = self._raw[0];
            uint256 len = lengthAndFirst >> 160;
            if (len == 0) {
                self._raw[0] = (1 << 160) + uint160(account);
            } else {
                self._raw[0] = lengthAndFirst + (1 << 160);
                self._raw[len] = uint160(account);
            }
            return len + 1;
        }
    }

    /// @dev Array pop back operation for storage `self`.
    function pop(Data storage self) internal {
        unchecked {
            uint256 lengthAndFirst = self._raw[0];
            uint256 len = lengthAndFirst >> 160;
            if (len == 0) revert PopFromEmptyArray();
            self._raw[len - 1] = 0;
            if (len > 1) {
                self._raw[0] = lengthAndFirst - (1 << 160);
            }
        }
    }

    /// @dev Set element for storage `self` at `index` to `account`.
    function set(
        Data storage self,
        uint256 index,
        address account
    ) internal {
        uint256 len = length(self);
        if (index >= len) revert IndexOutOfBounds();

        if (index == 0) {
            self._raw[0] = (len << 160) | uint160(account);
        } else {
            self._raw[index] = uint160(account);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
pragma abicoder v1;

import "./AddressArray.sol";

/** @title Library that is using AddressArray library for AddressArray.Data
 * and allows Set operations on address storage data:
 * 1. add
 * 2. remove
 * 3. contains
 */
library AddressSet {
    using AddressArray for AddressArray.Data;

    /** @dev Data struct from AddressArray.Data items
     * and lookup mapping address => index in data array.
     */
    struct Data {
        AddressArray.Data items;
        mapping(address => uint256) lookup;
    }

    /// @dev Length of data storage.
    function length(Data storage s) internal view returns (uint256) {
        return s.items.length();
    }

    /// @dev Returns data item from `s` storage at `index`.
    function at(Data storage s, uint256 index) internal view returns (address) {
        return s.items.at(index);
    }

    /// @dev Returns true if storage `s` has `item`.
    function contains(Data storage s, address item) internal view returns (bool) {
        return s.lookup[item] != 0;
    }

    /// @dev Adds `item` into storage `s` and returns true if successful.
    function add(Data storage s, address item) internal returns (bool) {
        if (s.lookup[item] > 0) {
            return false;
        }
        s.lookup[item] = s.items.push(item);
        return true;
    }

    /// @dev Removes `item` from storage `s` and returns true if successful.
    function remove(Data storage s, address item) internal returns (bool) {
        uint256 index = s.lookup[item];
        if (index == 0) {
            return false;
        }
        if (index < s.items.length()) {
            unchecked {
                address lastItem = s.items.at(s.items.length() - 1);
                s.items.set(index - 1, lastItem);
                s.lookup[lastItem] = index;
            }
        }
        s.items.pop();
        delete s.lookup[item];
        return true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
pragma abicoder v1;

/// @title Revert reason forwarder.
library RevertReasonForwarder {
    /// @dev Forwards latest externall call revert.
    function reRevert() internal pure {
        // bubble up revert reason from latest external call
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, returndatasize())
            revert(ptr, returndatasize())
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;
pragma abicoder v1;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
import "../interfaces/IDaiLikePermit.sol";
import "../libraries/RevertReasonForwarder.sol";

/// @title Implements efficient safe methods for ERC20 interface.
library SafeERC20 {
    error SafeTransferFailed();
    error SafeTransferFromFailed();
    error ForceApproveFailed();
    error SafeIncreaseAllowanceFailed();
    error SafeDecreaseAllowanceFailed();
    error SafePermitBadLength();

    /// @dev Ensures method do not revert or return boolean `true`, admits call to non-smart-contract.
    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        bytes4 selector = token.transferFrom.selector;
        bool success;
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let data := mload(0x40)

            mstore(data, selector)
            mstore(add(data, 0x04), from)
            mstore(add(data, 0x24), to)
            mstore(add(data, 0x44), amount)
            success := call(gas(), token, 0, data, 100, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 {
                    success := gt(extcodesize(token), 0)
                }
                default {
                    success := and(gt(returndatasize(), 31), eq(mload(0), 1))
                }
            }
        }
        if (!success) revert SafeTransferFromFailed();
    }

    /// @dev Ensures method do not revert or return boolean `true`, admits call to non-smart-contract.
    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        if (!_makeCall(token, token.transfer.selector, to, value)) {
            revert SafeTransferFailed();
        }
    }

    /// @dev If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry.
    function forceApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        if (!_makeCall(token, token.approve.selector, spender, value)) {
            if (
                !_makeCall(token, token.approve.selector, spender, 0) ||
                !_makeCall(token, token.approve.selector, spender, value)
            ) {
                revert ForceApproveFailed();
            }
        }
    }

    /// @dev Allowance increase with safe math check.
    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 allowance = token.allowance(address(this), spender);
        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();
        forceApprove(token, spender, allowance + value);
    }

    /// @dev Allowance decrease with safe math check.
    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 allowance = token.allowance(address(this), spender);
        if (value > allowance) revert SafeDecreaseAllowanceFailed();
        forceApprove(token, spender, allowance - value);
    }

    /// @dev Calls either ERC20 or Dai `permit` for `token`, if unsuccessful forwards revert from external call.
    function safePermit(IERC20 token, bytes calldata permit) internal {
        if (!tryPermit(token, permit)) RevertReasonForwarder.reRevert();
    }

    function tryPermit(IERC20 token, bytes calldata permit) internal returns(bool) {
        if (permit.length == 32 * 7) {
            return _makeCalldataCall(token, IERC20Permit.permit.selector, permit);
        }
        if (permit.length == 32 * 8) {
            return _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);
        }
        revert SafePermitBadLength();
    }

    function _makeCall(
        IERC20 token,
        bytes4 selector,
        address to,
        uint256 amount
    ) private returns (bool success) {
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let data := mload(0x40)

            mstore(data, selector)
            mstore(add(data, 0x04), to)
            mstore(add(data, 0x24), amount)
            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 {
                    success := gt(extcodesize(token), 0)
                }
                default {
                    success := and(gt(returndatasize(), 31), eq(mload(0), 1))
                }
            }
        }
    }

    function _makeCalldataCall(
        IERC20 token,
        bytes4 selector,
        bytes calldata args
    ) private returns (bool success) {
        /// @solidity memory-safe-assembly
        assembly { // solhint-disable-line no-inline-assembly
            let len := add(4, args.length)
            let data := mload(0x40)

            mstore(data, selector)
            calldatacopy(add(data, 0x04), args.offset, args.length)
            success := call(gas(), token, 0, data, len, 0x0, 0x20)
            if success {
                switch returndatasize()
                case 0 {
                    success := gt(extcodesize(token), 0)
                }
                default {
                    success := and(gt(returndatasize(), 31), eq(mload(0), 1))
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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

pragma solidity ^0.8.0;

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

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

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

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

pragma solidity ^0.8.0;

import "../IERC20.sol";

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

contract VotingPowerCalculator {
    error OriginInTheFuture();

    uint256 private constant _ONE = 1e18;

    uint256 public immutable origin;
    uint256 public immutable expBase;

    uint256 private immutable _expTable0;
    uint256 private immutable _expTable1;
    uint256 private immutable _expTable2;
    uint256 private immutable _expTable3;
    uint256 private immutable _expTable4;
    uint256 private immutable _expTable5;
    uint256 private immutable _expTable6;
    uint256 private immutable _expTable7;
    uint256 private immutable _expTable8;
    uint256 private immutable _expTable9;
    uint256 private immutable _expTable10;
    uint256 private immutable _expTable11;
    uint256 private immutable _expTable12;
    uint256 private immutable _expTable13;
    uint256 private immutable _expTable14;
    uint256 private immutable _expTable15;
    uint256 private immutable _expTable16;
    uint256 private immutable _expTable17;
    uint256 private immutable _expTable18;
    uint256 private immutable _expTable19;
    uint256 private immutable _expTable20;
    uint256 private immutable _expTable21;
    uint256 private immutable _expTable22;
    uint256 private immutable _expTable23;
    uint256 private immutable _expTable24;
    uint256 private immutable _expTable25;
    uint256 private immutable _expTable26;
    uint256 private immutable _expTable27;
    uint256 private immutable _expTable28;
    uint256 private immutable _expTable29;

    constructor(uint256 expBase_, uint256 origin_) {
        if (origin_ > block.timestamp) revert OriginInTheFuture();

        origin = origin_;
        expBase = expBase_;
        _expTable0 = expBase_;
        _expTable1 = (_expTable0 * _expTable0) / _ONE;
        _expTable2 = (_expTable1 * _expTable1) / _ONE;
        _expTable3 = (_expTable2 * _expTable2) / _ONE;
        _expTable4 = (_expTable3 * _expTable3) / _ONE;
        _expTable5 = (_expTable4 * _expTable4) / _ONE;
        _expTable6 = (_expTable5 * _expTable5) / _ONE;
        _expTable7 = (_expTable6 * _expTable6) / _ONE;
        _expTable8 = (_expTable7 * _expTable7) / _ONE;
        _expTable9 = (_expTable8 * _expTable8) / _ONE;
        _expTable10 = (_expTable9 * _expTable9) / _ONE;
        _expTable11 = (_expTable10 * _expTable10) / _ONE;
        _expTable12 = (_expTable11 * _expTable11) / _ONE;
        _expTable13 = (_expTable12 * _expTable12) / _ONE;
        _expTable14 = (_expTable13 * _expTable13) / _ONE;
        _expTable15 = (_expTable14 * _expTable14) / _ONE;
        _expTable16 = (_expTable15 * _expTable15) / _ONE;
        _expTable17 = (_expTable16 * _expTable16) / _ONE;
        _expTable18 = (_expTable17 * _expTable17) / _ONE;
        _expTable19 = (_expTable18 * _expTable18) / _ONE;
        _expTable20 = (_expTable19 * _expTable19) / _ONE;
        _expTable21 = (_expTable20 * _expTable20) / _ONE;
        _expTable22 = (_expTable21 * _expTable21) / _ONE;
        _expTable23 = (_expTable22 * _expTable22) / _ONE;
        _expTable24 = (_expTable23 * _expTable23) / _ONE;
        _expTable25 = (_expTable24 * _expTable24) / _ONE;
        _expTable26 = (_expTable25 * _expTable25) / _ONE;
        _expTable27 = (_expTable26 * _expTable26) / _ONE;
        _expTable28 = (_expTable27 * _expTable27) / _ONE;
        _expTable29 = (_expTable28 * _expTable28) / _ONE;
    }

    function _votingPowerAt(uint256 balance, uint256 timestamp) internal view returns (uint256 votingPower) {
        timestamp = timestamp < origin ? origin : timestamp;  // logic in timestamps before origin is undefined
        unchecked {
            uint256 t = timestamp - origin;
            votingPower = balance;
            if (t & 0x01 != 0) {
                votingPower = (votingPower * _expTable0) / _ONE;
            }
            if (t & 0x02 != 0) {
                votingPower = (votingPower * _expTable1) / _ONE;
            }
            if (t & 0x04 != 0) {
                votingPower = (votingPower * _expTable2) / _ONE;
            }
            if (t & 0x08 != 0) {
                votingPower = (votingPower * _expTable3) / _ONE;
            }
            if (t & 0x10 != 0) {
                votingPower = (votingPower * _expTable4) / _ONE;
            }
            if (t & 0x20 != 0) {
                votingPower = (votingPower * _expTable5) / _ONE;
            }
            if (t & 0x40 != 0) {
                votingPower = (votingPower * _expTable6) / _ONE;
            }
            if (t & 0x80 != 0) {
                votingPower = (votingPower * _expTable7) / _ONE;
            }
            if (t & 0x100 != 0) {
                votingPower = (votingPower * _expTable8) / _ONE;
            }
            if (t & 0x200 != 0) {
                votingPower = (votingPower * _expTable9) / _ONE;
            }
            if (t & 0x400 != 0) {
                votingPower = (votingPower * _expTable10) / _ONE;
            }
            if (t & 0x800 != 0) {
                votingPower = (votingPower * _expTable11) / _ONE;
            }
            if (t & 0x1000 != 0) {
                votingPower = (votingPower * _expTable12) / _ONE;
            }
            if (t & 0x2000 != 0) {
                votingPower = (votingPower * _expTable13) / _ONE;
            }
            if (t & 0x4000 != 0) {
                votingPower = (votingPower * _expTable14) / _ONE;
            }
            if (t & 0x8000 != 0) {
                votingPower = (votingPower * _expTable15) / _ONE;
            }
            if (t & 0x10000 != 0) {
                votingPower = (votingPower * _expTable16) / _ONE;
            }
            if (t & 0x20000 != 0) {
                votingPower = (votingPower * _expTable17) / _ONE;
            }
            if (t & 0x40000 != 0) {
                votingPower = (votingPower * _expTable18) / _ONE;
            }
            if (t & 0x80000 != 0) {
                votingPower = (votingPower * _expTable19) / _ONE;
            }
            if (t & 0x100000 != 0) {
                votingPower = (votingPower * _expTable20) / _ONE;
            }
            if (t & 0x200000 != 0) {
                votingPower = (votingPower * _expTable21) / _ONE;
            }
            if (t & 0x400000 != 0) {
                votingPower = (votingPower * _expTable22) / _ONE;
            }
            if (t & 0x800000 != 0) {
                votingPower = (votingPower * _expTable23) / _ONE;
            }
            if (t & 0x1000000 != 0) {
                votingPower = (votingPower * _expTable24) / _ONE;
            }
            if (t & 0x2000000 != 0) {
                votingPower = (votingPower * _expTable25) / _ONE;
            }
            if (t & 0x4000000 != 0) {
                votingPower = (votingPower * _expTable26) / _ONE;
            }
            if (t & 0x8000000 != 0) {
                votingPower = (votingPower * _expTable27) / _ONE;
            }
            if (t & 0x10000000 != 0) {
                votingPower = (votingPower * _expTable28) / _ONE;
            }
            if (t & 0x20000000 != 0) {
                votingPower = (votingPower * _expTable29) / _ONE;
            }
        }
        return votingPower;
    }

    function _balanceAt(uint256 votingPower, uint256 timestamp) internal view returns (uint256 balance) {
        timestamp = timestamp < origin ? origin : timestamp;  // logic in timestamps before origin is undefined
        unchecked {
            uint256 t = timestamp - origin;
            balance = votingPower;
            if (t & 0x01 != 0) {
                balance = (balance * _ONE) / _expTable0;
            }
            if (t & 0x02 != 0) {
                balance = (balance * _ONE) / _expTable1;
            }
            if (t & 0x04 != 0) {
                balance = (balance * _ONE) / _expTable2;
            }
            if (t & 0x08 != 0) {
                balance = (balance * _ONE) / _expTable3;
            }
            if (t & 0x10 != 0) {
                balance = (balance * _ONE) / _expTable4;
            }
            if (t & 0x20 != 0) {
                balance = (balance * _ONE) / _expTable5;
            }
            if (t & 0x40 != 0) {
                balance = (balance * _ONE) / _expTable6;
            }
            if (t & 0x80 != 0) {
                balance = (balance * _ONE) / _expTable7;
            }
            if (t & 0x100 != 0) {
                balance = (balance * _ONE) / _expTable8;
            }
            if (t & 0x200 != 0) {
                balance = (balance * _ONE) / _expTable9;
            }
            if (t & 0x400 != 0) {
                balance = (balance * _ONE) / _expTable10;
            }
            if (t & 0x800 != 0) {
                balance = (balance * _ONE) / _expTable11;
            }
            if (t & 0x1000 != 0) {
                balance = (balance * _ONE) / _expTable12;
            }
            if (t & 0x2000 != 0) {
                balance = (balance * _ONE) / _expTable13;
            }
            if (t & 0x4000 != 0) {
                balance = (balance * _ONE) / _expTable14;
            }
            if (t & 0x8000 != 0) {
                balance = (balance * _ONE) / _expTable15;
            }
            if (t & 0x10000 != 0) {
                balance = (balance * _ONE) / _expTable16;
            }
            if (t & 0x20000 != 0) {
                balance = (balance * _ONE) / _expTable17;
            }
            if (t & 0x40000 != 0) {
                balance = (balance * _ONE) / _expTable18;
            }
            if (t & 0x80000 != 0) {
                balance = (balance * _ONE) / _expTable19;
            }
            if (t & 0x100000 != 0) {
                balance = (balance * _ONE) / _expTable20;
            }
            if (t & 0x200000 != 0) {
                balance = (balance * _ONE) / _expTable21;
            }
            if (t & 0x400000 != 0) {
                balance = (balance * _ONE) / _expTable22;
            }
            if (t & 0x800000 != 0) {
                balance = (balance * _ONE) / _expTable23;
            }
            if (t & 0x1000000 != 0) {
                balance = (balance * _ONE) / _expTable24;
            }
            if (t & 0x2000000 != 0) {
                balance = (balance * _ONE) / _expTable25;
            }
            if (t & 0x4000000 != 0) {
                balance = (balance * _ONE) / _expTable26;
            }
            if (t & 0x8000000 != 0) {
                balance = (balance * _ONE) / _expTable27;
            }
            if (t & 0x10000000 != 0) {
                balance = (balance * _ONE) / _expTable28;
            }
            if (t & 0x20000000 != 0) {
                balance = (balance * _ONE) / _expTable29;
            }
        }
        return balance;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;
pragma abicoder v1;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IVotable is IERC20 {
    /// @dev we assume that voting power is a function of balance that preserves order
    function votingPowerOf(address account) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.17;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@1inch/erc20-pods/contracts/ERC20Pods.sol";
import "@1inch/erc20-pods/contracts/Pod.sol";
import "@1inch/solidity-utils/contracts/libraries/SafeERC20.sol";
import "./helpers/VotingPowerCalculator.sol";
import "./interfaces/IVotable.sol";

/**
 * @title 1inch staking contract
 * @notice The contract provides the following features: staking, delegation, farming
 * How lock period works:
 * - balances and voting power
 * - Lock min and max
 * - Add lock
 * - earlyWithdrawal
 * - penalty math
 */
contract St1inch is ERC20Pods, Ownable, VotingPowerCalculator, IVotable {
    using SafeERC20 for IERC20;

    event EmergencyExitSet(bool status);
    event MaxLossRatioSet(uint256 ratio);
    event MinLockPeriodRatioSet(uint256 ratio);
    event FeeReceiverSet(address receiver);
    event DefaultFarmSet(address defaultFarm);

    error ApproveDisabled();
    error TransferDisabled();
    error LockTimeMoreMaxLock();
    error LockTimeLessMinLock();
    error UnlockTimeHasNotCome();
    error StakeUnlocked();
    error MinLockPeriodRatioNotReached();
    error MinReturnIsNotMet();
    error MaxLossIsNotMet();
    error MaxLossOverflow();
    error LossIsTooBig();
    error RescueAmountIsTooLarge();
    error ExpBaseTooBig();
    error ExpBaseTooSmall();
    error DefaultFarmTokenMismatch();
    error DepositsDisabled();
    error ZeroAddress();

    /// @notice The minimum allowed staking period
    uint256 public constant MIN_LOCK_PERIOD = 30 days;
    /// @notice The maximum allowed staking period
    /// @dev WARNING: It is not enough to change the constant only but voting power decrease curve should be revised also
    uint256 public constant MAX_LOCK_PERIOD = 2 * 365 days;
    /// @notice Voting power decreased to 1/_VOTING_POWER_DIVIDER after lock expires
    /// @dev WARNING: It is not enough to change the constant only but voting power decrease curve should be revised also
    uint256 private constant _VOTING_POWER_DIVIDER = 20;
    uint256 private constant _PODS_LIMIT = 5;
    /// @notice Maximum allowed gas spent by each attached pod. If there not enough gas for pod execution then
    /// transaction is reverted. If pod uses more gas then its execution is reverted silently, not affection the
    /// main transaction
    uint256 private constant _POD_CALL_GAS_LIMIT = 500_000;
    uint256 private constant _ONE = 1e9;

    IERC20 public immutable oneInch;

    /// @notice The stucture to store stake information for a staker
    struct Depositor {
        uint40 lockTime;    // Unix time in seconds
        uint40 unlockTime;  // Unix time in seconds
        uint176 amount;     // Staked 1inch token amount
    }

    mapping(address => Depositor) public depositors;

    uint256 public totalDeposits;
    bool public emergencyExit;
    uint256 public maxLossRatio;
    uint256 public minLockPeriodRatio;
    address public feeReceiver;
    address public defaultFarm;

    /**
     * @notice Initializes the contract
     * @param oneInch_ The token to be staked
     * @param expBase_ The rate for the voting power decrease over time
     */
    constructor(IERC20 oneInch_, uint256 expBase_)
        ERC20Pods(_PODS_LIMIT, _POD_CALL_GAS_LIMIT)
        ERC20("Staking 1INCH v2", "st1INCH")
        VotingPowerCalculator(expBase_, block.timestamp)
    {
        // voting power after MAX_LOCK_PERIOD should be equal to staked amount divided by _VOTING_POWER_DIVIDER
        if (_votingPowerAt(1e18, block.timestamp + MAX_LOCK_PERIOD) * _VOTING_POWER_DIVIDER < 1e18) revert ExpBaseTooBig();
        if (_votingPowerAt(1e18, block.timestamp + MAX_LOCK_PERIOD + 1) * _VOTING_POWER_DIVIDER > 1e18) revert ExpBaseTooSmall();
        oneInch = oneInch_;
    }

    /**
     * @notice Sets the new contract that would recieve early withdrawal fees
     * @param feeReceiver_ The receiver contract address
     */
    function setFeeReceiver(address feeReceiver_) external onlyOwner {
        if (feeReceiver_ == address(0)) revert ZeroAddress();
        feeReceiver = feeReceiver_;
        emit FeeReceiverSet(feeReceiver_);
    }

    /**
     * @notice Sets the new farm that all staking users will automatically join after staking for reward farming
     * @param defaultFarm_ The farm contract address
     */
    function setDefaultFarm(address defaultFarm_) external onlyOwner {
        if (defaultFarm_ != address(0) && Pod(defaultFarm_).token() != this) revert DefaultFarmTokenMismatch();
        defaultFarm = defaultFarm_;
        emit DefaultFarmSet(defaultFarm_);
    }

    /**
     * @notice Sets the maximum allowed loss ratio for early withdrawal. If the ratio is not met, actual is more than allowed,
     * then early withdrawal will revert.
     * Example: maxLossRatio = 90% and 1000 staked 1inch tokens means that a user can execute early withdrawal only
     * if his loss is less than or equals 90% of his stake, which is 900 tokens. Thus, if a user loses 900 tokens he is allowed
     * to do early withdrawal and not if the loss is greater.
     * @param maxLossRatio_ The maximum loss allowed (9 decimals).
     */
    function setMaxLossRatio(uint256 maxLossRatio_) external onlyOwner {
        if (maxLossRatio_ > _ONE) revert MaxLossOverflow();
        maxLossRatio = maxLossRatio_;
        emit MaxLossRatioSet(maxLossRatio_);
    }

    /**
     * @notice Sets the minimum allowed lock period ratio for early withdrawal. If the ratio is not met, actual is more than allowed,
     * then early withdrawal will revert.
     * @param minLockPeriodRatio_ The maximum loss allowed (9 decimals).
     */
    function setMinLockPeriodRatio(uint256 minLockPeriodRatio_) external onlyOwner {
        if (minLockPeriodRatio_ > _ONE) revert MaxLossOverflow();
        minLockPeriodRatio = minLockPeriodRatio_;
        emit MinLockPeriodRatioSet(minLockPeriodRatio_);
    }

    /**
     * @notice Sets the emergency exit mode. In emergency mode any stake may withdraw its stake regardless of lock.
     * The mode is intended to use only for migration to a new version of staking contract.
     * @param emergencyExit_ set `true` to enter emergency exit mode and `false` to return to normal operations
     */
    function setEmergencyExit(bool emergencyExit_) external onlyOwner {
        emergencyExit = emergencyExit_;
        emit EmergencyExitSet(emergencyExit_);
    }

    /**
     * @notice Gets the voting power of the provided account
     * @param account The address of an account to get voting power for
     * @return votingPower The voting power available at the block timestamp
     */
    function votingPowerOf(address account) external view returns (uint256) {
        return _votingPowerAt(balanceOf(account), block.timestamp);
    }

    /**
     * @notice Gets the voting power of the provided account at the given timestamp
     * @dev To calculate voting power at any timestamp provided the contract stores each balance
     * as it was staked for the maximum lock time. If a staker locks its stake for less than the maximum
     * then at the moment of deposit its balance is recorded as it was staked for the maximum but time
     * equal to `max lock period-lock time` has passed. It makes available voting power calculation
     * available at any point in time within the maximum lock period.
     * @param account The address of an account to get voting power for
     * @param timestamp The timestamp to calculate voting power at
     * @return votingPower The voting power available at the moment of `timestamp`
     */
    function votingPowerOfAt(address account, uint256 timestamp) external view returns (uint256) {
        return _votingPowerAt(balanceOf(account), timestamp);
    }

    /**
     * @notice Gets the voting power for the provided balance at the current timestamp assuming that
     * the balance is a balance at the moment of the maximum lock time
     * @param balance The balance for the maximum lock time
     * @return votingPower The voting power available at the block timestamp
     */
    function votingPower(uint256 balance) external view returns (uint256) {
        return _votingPowerAt(balance, block.timestamp);
    }

    /**
     * @notice Gets the voting power for the provided balance at the current timestamp assuming that
     * the balance is a balance at the moment of the maximum lock time
     * @param balance The balance for the maximum lock time
     * @param timestamp The timestamp to calculate the voting power at
     * @return votingPower The voting power available at the block timestamp
     */
    function votingPowerAt(uint256 balance, uint256 timestamp) external view returns (uint256) {
        return _votingPowerAt(balance, timestamp);
    }

    /**
     * @notice Stakes given amount and locks it for the given duration
     * @param amount The amount of tokens to stake
     * @param duration The lock period in seconds. If there is a stake locked then the lock period is extended by the duration.
     * To keep the current lock period unchanged pass 0 for the duration.
     */
    function deposit(uint256 amount, uint256 duration) external {
        _deposit(msg.sender, amount, duration);
    }

    /**
     * @notice Stakes given amount and locks it for the given duration with permit
     * @param amount The amount of tokens to stake
     * @param duration The lock period in seconds. If there is a stake locked then the lock period is extended by the duration.
     * To keep the current lock period unchanged pass 0 for the duration
     * @param permit Permit given by the staker
     */
    function depositWithPermit(uint256 amount, uint256 duration, bytes calldata permit) external {
        oneInch.safePermit(permit);
        _deposit(msg.sender, amount, duration);
    }


    /**
     * @notice Stakes given amount on behalf of provided account without locking or extending lock
     * @param account The account to stake for
     * @param amount The amount to stake
     */
    function depositFor(address account, uint256 amount) external {
        _deposit(account, amount, 0);
    }

    /**
     * @notice Stakes given amount on behalf of provided account without locking or extending lock with permit
     * @param account The account to stake for
     * @param amount The amount to stake
     * @param permit Permit given by the caller
     */
    function depositForWithPermit(address account, uint256 amount, bytes calldata permit) external {
        oneInch.safePermit(permit);
        _deposit(account, amount, 0);
    }

    function _deposit(address account, uint256 amount, uint256 duration) private {
        if (emergencyExit) revert DepositsDisabled();
        Depositor memory depositor = depositors[account]; // SLOAD

        uint256 lockedTill = Math.max(depositor.unlockTime, block.timestamp) + duration;
        uint256 lockLeft = lockedTill - block.timestamp;
        if (lockLeft < MIN_LOCK_PERIOD) revert LockTimeLessMinLock();
        if (lockLeft > MAX_LOCK_PERIOD) revert LockTimeMoreMaxLock();
        uint256 balanceDiff = _balanceAt(depositor.amount + amount, lockedTill) / _VOTING_POWER_DIVIDER - balanceOf(account);

        depositor.lockTime = uint40(duration == 0 ? depositor.lockTime : block.timestamp);
        depositor.unlockTime = uint40(lockedTill);
        depositor.amount += uint176(amount);
        depositors[account] = depositor; // SSTORE
        totalDeposits += amount;
        _mint(account, balanceDiff);

        if (amount > 0) {
            oneInch.safeTransferFrom(msg.sender, address(this), amount);
        }

        if (defaultFarm != address(0) && !hasPod(account, defaultFarm)) {
            _addPod(account, defaultFarm);
        }
    }

    /**
     * @notice Withdraw stake before lock period expires at the cost of losing part of a stake.
     * The stake loss is proportional to the time passed from the maximum lock period to the lock expiration and voting power.
     * The more time is passed the less would be the loss.
     * Formula to calculate return amount = (deposit - voting power)) / 0.95
     * @param minReturn The minumum amount of stake acceptable for return. If actual amount is less then the transaction is reverted
     * @param maxLoss The maximum amount of loss acceptable. If actual loss is bigger then the transaction is reverted
     */
    function earlyWithdraw(uint256 minReturn, uint256 maxLoss) external {
        earlyWithdrawTo(msg.sender, minReturn, maxLoss);
    }

    /**
     * @notice Withdraw stake before lock period expires at the cost of losing part of a stake to the specified account
     * The stake loss is proportional to the time passed from the maximum lock period to the lock expiration and voting power.
     * The more time is passed the less would be the loss.
     * Formula to calculate return amount = (deposit - voting power)) / 0.95
     * @param to The account to withdraw the stake to
     * @param minReturn The minumum amount of stake acceptable for return. If actual amount is less then the transaction is reverted
     * @param maxLoss The maximum amount of loss acceptable. If actual loss is bigger then the transaction is reverted
     */
    // ret(balance) = (deposit - vp(balance)) / 0.95
    function earlyWithdrawTo(address to, uint256 minReturn, uint256 maxLoss) public {
        Depositor memory depositor = depositors[msg.sender]; // SLOAD
        if (emergencyExit || block.timestamp >= depositor.unlockTime) revert StakeUnlocked();
        uint256 allowedExitTime = depositor.lockTime + (depositor.unlockTime - depositor.lockTime) * minLockPeriodRatio / _ONE;
        if (block.timestamp < allowedExitTime) revert MinLockPeriodRatioNotReached();

        uint256 amount = depositor.amount;
        if (amount > 0) {
            uint256 balance = balanceOf(msg.sender);
            (uint256 loss, uint256 ret) = _earlyWithdrawLoss(amount, balance);
            if (ret < minReturn) revert MinReturnIsNotMet();
            if (loss > maxLoss) revert MaxLossIsNotMet();
            if (loss > amount * maxLossRatio / _ONE) revert LossIsTooBig();

            _withdraw(depositor, balance);
            oneInch.safeTransfer(to, ret);
            oneInch.safeTransfer(feeReceiver, loss);
        }
    }

    /**
     * @notice Gets the loss amount if the staker do early withdrawal at the current block
     * @param account The account to calculate early withdrawal loss for
     * @return loss The loss amount amount
     * @return ret The return amount
     * @return canWithdraw  True if the staker can withdraw without penalty, false otherwise
     */
    function earlyWithdrawLoss(address account) external view returns (uint256 loss, uint256 ret, bool canWithdraw) {
        uint256 amount = depositors[account].amount;
        (loss, ret) = _earlyWithdrawLoss(amount, balanceOf(account));
        canWithdraw = loss <= amount * maxLossRatio / _ONE;
    }

    function _earlyWithdrawLoss(uint256 depAmount, uint256 stBalance) private view returns (uint256 loss, uint256 ret) {
        ret = (depAmount - _votingPowerAt(stBalance, block.timestamp)) * 100 / 95;
        loss = depAmount - ret;
    }

    /**
     * @notice Withdraws stake if lock period expired
     */
    function withdraw() external {
        withdrawTo(msg.sender);
    }

    /**
     * @notice Withdraws stake if lock period expired to the given address
     */
    function withdrawTo(address to) public {
        Depositor memory depositor = depositors[msg.sender]; // SLOAD
        if (!emergencyExit && block.timestamp < depositor.unlockTime) revert UnlockTimeHasNotCome();

        uint256 amount = depositor.amount;
        if (amount > 0) {
            _withdraw(depositor, balanceOf(msg.sender));
            oneInch.safeTransfer(to, amount);
        }
    }

    function _withdraw(Depositor memory depositor, uint256 balance) private {
        totalDeposits -= depositor.amount;
        depositor.amount = 0;
        // keep unlockTime in storage for next tx optimization
        depositor.unlockTime = uint40(Math.min(depositor.unlockTime, block.timestamp));
        depositors[msg.sender] = depositor; // SSTORE
        _burn(msg.sender, balance);
    }

    /**
     * @notice Retrieves funds from the contract in emergency situations
     * @param token The token to retrieve
     * @param amount The amount of funds to transfer
     */
    function rescueFunds(IERC20 token, uint256 amount) external onlyOwner {
        if (address(token) == address(0)) {
            Address.sendValue(payable(msg.sender), amount);
        } else {
            if (token == oneInch) {
                if (amount > oneInch.balanceOf(address(this)) - totalDeposits) revert RescueAmountIsTooLarge();
            }
            token.safeTransfer(msg.sender, amount);
        }
    }

    // ERC20 methods disablers

    function approve(address, uint256) public pure override(IERC20, ERC20) returns (bool) {
        revert ApproveDisabled();
    }

    function transfer(address, uint256) public pure override(IERC20, ERC20) returns (bool) {
        revert TransferDisabled();
    }

    function transferFrom(address, address, uint256) public pure override(IERC20, ERC20) returns (bool) {
        revert TransferDisabled();
    }

    function increaseAllowance(address, uint256) public pure override returns (bool) {
        revert ApproveDisabled();
    }

    function decreaseAllowance(address, uint256) public pure override returns (bool) {
        revert ApproveDisabled();
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"contract St1inch","name":"st1inch","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessDenied","type":"error"},{"inputs":[],"name":"AlreadyRegistered","type":"error"},{"inputs":[],"name":"ApproveDisabled","type":"error"},{"inputs":[],"name":"DefaultFarmTokenMismatch","type":"error"},{"inputs":[],"name":"NotRegisteredDelegatee","type":"error"},{"inputs":[],"name":"OriginInTheFuture","type":"error"},{"inputs":[],"name":"TransferDisabled","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"defaultFarm","type":"address"}],"name":"DefaultFarmSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"delegatee","type":"address"}],"name":"Delegated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"delegatee","type":"address"}],"name":"RegisterDelegatee","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"defaultFarms","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"delegated","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expBase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"maxSharePods","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"origin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"name":"register","outputs":[{"internalType":"contract IDelegatedShare","name":"shareToken","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"registration","outputs":[{"internalType":"contract IDelegatedShare","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"farm","type":"address"}],"name":"setDefaultFarm","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sharePodGasLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract IERC20Pods","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateBalances","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"votingPowerOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

6104e06040523480156200001257600080fd5b5060405162006ab638038062006ab68339810160408190526200003591620006dd565b806001600160a01b031663bca9c3fc6040518163ffffffff1660e01b8152600401602060405180830381865afa15801562000074573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200009a91906200076a565b816001600160a01b031663938b5f326040518163ffffffff1660e01b8152600401602060405180830381865afa158015620000d9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620000ff91906200076a565b6001600160a01b0383166080528484846003620222e084848484848484848282866200012c838262000813565b5060046200013b828262000813565b50505060a094909452505060c0525050504287111595506200017694505050505057604051635a59719b60e01b815260040160405180910390fd5b60e0819052610100829052610120829052670de0b6b3a76400006200019c8380620008df565b620001a891906200090b565b610140819052670de0b6b3a764000090620001c49080620008df565b620001d091906200090b565b610160819052670de0b6b3a764000090620001ec9080620008df565b620001f891906200090b565b610180819052670de0b6b3a764000090620002149080620008df565b6200022091906200090b565b6101a0819052670de0b6b3a7640000906200023c9080620008df565b6200024891906200090b565b6101c0819052670de0b6b3a764000090620002649080620008df565b6200027091906200090b565b6101e0819052670de0b6b3a7640000906200028c9080620008df565b6200029891906200090b565b610200819052670de0b6b3a764000090620002b49080620008df565b620002c091906200090b565b610220819052670de0b6b3a764000090620002dc9080620008df565b620002e891906200090b565b610240819052670de0b6b3a764000090620003049080620008df565b6200031091906200090b565b610260819052670de0b6b3a7640000906200032c9080620008df565b6200033891906200090b565b610280819052670de0b6b3a764000090620003549080620008df565b6200036091906200090b565b6102a0819052670de0b6b3a7640000906200037c9080620008df565b6200038891906200090b565b6102c0819052670de0b6b3a764000090620003a49080620008df565b620003b091906200090b565b6102e0819052670de0b6b3a764000090620003cc9080620008df565b620003d891906200090b565b610300819052670de0b6b3a764000090620003f49080620008df565b6200040091906200090b565b610320819052670de0b6b3a7640000906200041c9080620008df565b6200042891906200090b565b610340819052670de0b6b3a764000090620004449080620008df565b6200045091906200090b565b610360819052670de0b6b3a7640000906200046c9080620008df565b6200047891906200090b565b610380819052670de0b6b3a764000090620004949080620008df565b620004a091906200090b565b6103a0819052670de0b6b3a764000090620004bc9080620008df565b620004c891906200090b565b6103c0819052670de0b6b3a764000090620004e49080620008df565b620004f091906200090b565b6103e0819052670de0b6b3a7640000906200050c9080620008df565b6200051891906200090b565b610400819052670de0b6b3a764000090620005349080620008df565b6200054091906200090b565b610420819052670de0b6b3a7640000906200055c9080620008df565b6200056891906200090b565b610440819052670de0b6b3a764000090620005849080620008df565b6200059091906200090b565b610460819052670de0b6b3a764000090620005ac9080620008df565b620005b891906200090b565b610480819052670de0b6b3a764000090620005d49080620008df565b620005e091906200090b565b6104a0819052670de0b6b3a764000090620005fc9080620008df565b6200060891906200090b565b6104c052506200092e9350505050565b634e487b7160e01b600052604160045260246000fd5b600082601f8301126200064057600080fd5b81516001600160401b03808211156200065d576200065d62000618565b604051601f8301601f19908116603f0116810190828211818310171562000688576200068862000618565b81604052838152602092508683858801011115620006a557600080fd5b600091505b83821015620006c95785820183015181830184015290820190620006aa565b600093810190920192909252949350505050565b600080600060608486031215620006f357600080fd5b83516001600160401b03808211156200070b57600080fd5b62000719878388016200062e565b945060208601519150808211156200073057600080fd5b506200073f868287016200062e565b604086015190935090506001600160a01b03811681146200075f57600080fd5b809150509250925092565b6000602082840312156200077d57600080fd5b5051919050565b600181811c908216806200079957607f821691505b602082108103620007ba57634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200080e57600081815260208120601f850160051c81016020861015620007e95750805b601f850160051c820191505b818110156200080a57828155600101620007f5565b5050505b505050565b81516001600160401b038111156200082f576200082f62000618565b620008478162000840845462000784565b84620007c0565b602080601f8311600181146200087f5760008415620008665750858301515b600019600386901b1c1916600185901b1785556200080a565b600085815260208120601f198616915b82811015620008b0578886015182559484019460019091019084016200088f565b5085821015620008cf5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b80820281158282048414176200090557634e487b7160e01b600052601160045260246000fd5b92915050565b6000826200092957634e487b7160e01b600052601260045260246000fd5b500490565b60805160a05160c05160e05161010051610120516101405161016051610180516101a0516101c0516101e05161020051610220516102405161026051610280516102a0516102c0516102e05161030051610320516103405161036051610380516103a0516103c0516103e05161040051610420516104405161046051610480516104a0516104c051615fc862000aee60003960006114be015260006114810152600061144401526000611407015260006113ca0152600061138d0152600061135001526000611314015260006112d80152600061129c0152600061126001526000611224015260006111e8015260006111ac0152600061117001526000611135015260006110fa015260006110bf01526000611084015260006110490152600061100e01526000610fd301526000610f9801526000610f5e01526000610f2401526000610eea01526000610eb001526000610e7601526000610e3c01526000610e020152600061040a01526000818161036601528181610d7601528181610da50152610dcc0152600081816103e20152610b540152600081816102d70152610b330152600081816104cb01528181610a1e01526115db0152615fc86000f3fe60806040523480156200001157600080fd5b5060043610620001b95760003560e01c80637a1f1aa911620000f5578063b74c3b301162000097578063dd62ed3e116200006e578063dd62ed3e1462000443578063f3598ad9146200048c578063fc0c546a14620004c557600080fd5b8063b74c3b3014620003dc578063bca9c3fc1462000404578063bcc3f3bd146200042c57600080fd5b8063a457c2d711620000cc578063a457c2d7146200023f578063a9059cbb1462000392578063b04807ec14620003a357600080fd5b80637a1f1aa91462000349578063938b5f32146200036057806395d89b41146200038857600080fd5b806339509351116200015f5780634d5f8b6311620001365780634d5f8b6314620002d15780635c19a95c14620002f957806370a08231146200031057600080fd5b806339509351146200023f5780633c3f3c2314620002a15780633ffbd47f14620002ba57600080fd5b806318160ddd116200019457806318160ddd146200026757806323b872dd146200027a578063313ce567146200029157600080fd5b806306fdde0314620001be5780630840605a14620001e0578063095ea7b3146200023f575b600080fd5b620001c8620004ed565b604051620001d7919062001e5e565b60405180910390f35b62000219620001f136600462001e9d565b60066020526000908152604090205473ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001620001d7565b620002566200025036600462001ebd565b62000587565b6040519015158152602001620001d7565b6002545b604051908152602001620001d7565b620002566200028b36600462001eec565b620005bb565b60405160128152602001620001d7565b620002b8620002b236600462001e9d565b620005ef565b005b62000219620002cb36600462002014565b620007ea565b6200026b7f000000000000000000000000000000000000000000000000000000000000000081565b620002b86200030a36600462001e9d565b6200092b565b6200026b6200032136600462001e9d565b73ffffffffffffffffffffffffffffffffffffffff1660009081526020819052604090205490565b620002b86200035a36600462001eec565b62000a06565b6200026b7f000000000000000000000000000000000000000000000000000000000000000081565b620001c862000a88565b620002566200028b36600462001ebd565b62000219620003b436600462001e9d565b60076020526000908152604090205473ffffffffffffffffffffffffffffffffffffffff1681565b6200026b7f000000000000000000000000000000000000000000000000000000000000000081565b6200026b7f000000000000000000000000000000000000000000000000000000000000000081565b6200026b6200043d36600462001e9d565b62000a99565b6200026b620004543660046200207f565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260016020908152604080832093909416825291909152205490565b620002196200049d36600462001e9d565b60056020526000908152604090205473ffffffffffffffffffffffffffffffffffffffff1681565b620002197f000000000000000000000000000000000000000000000000000000000000000081565b606060038054620004fe90620020bd565b80601f01602080910402602001604051908101604052809291908181526020018280546200052c90620020bd565b80156200057d5780601f1062000551576101008083540402835291602001916200057d565b820191906000526020600020905b8154815290600101906020018083116200055f57829003601f168201915b5050505050905090565b60006040517feb60c2c400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006040517fa24e573d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b3360009081526006602052604090205473ffffffffffffffffffffffffffffffffffffffff166200064c576040517fccd4942000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8116158015906200072b5750336000908152600660209081526040918290205482517ffc0c546a000000000000000000000000000000000000000000000000000000008152925173ffffffffffffffffffffffffffffffffffffffff918216939185169263fc0c546a92600480820193918290030181865afa158015620006ec573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000712919062002112565b73ffffffffffffffffffffffffffffffffffffffff1614155b1562000763576040517fb599ae3000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b3360009081526007602090815260409182902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff851690811790915591519182527fdd367fa3b0132bc9c4680deca3d4565375dda9ed37c98f8321370efe4594785a910160405180910390a150565b6000620007f8838362000ad1565b905060008160036040516200080d9062001ddc565b73ffffffffffffffffffffffffffffffffffffffff90921682526020820152604001604051809103906000f0801580156200084c573d6000803e3d6000fd5b506040517ff2fde38b00000000000000000000000000000000000000000000000000000000815233600482015290915073ffffffffffffffffffffffffffffffffffffffff82169063f2fde38b90602401600060405180830381600087803b158015620008b857600080fd5b505af1158015620008cd573d6000803e3d6000fd5b505033600090815260076020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff949094169390931790925550909392505050565b620009368162000c38565b73ffffffffffffffffffffffffffffffffffffffff80821660009081526007602052604090205416801562000a025773ffffffffffffffffffffffffffffffffffffffff828116600090815260066020526040908190205490517ff70f6a9a000000000000000000000000000000000000000000000000000000008152336004820152838316602482015291169063f70f6a9a90604401600060405180830381600087803b158015620009e857600080fd5b505af1158015620009fd573d6000803e3d6000fd5b505050505b5050565b3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000161462000a76576040517f4ca8886700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b62000a8383838362000cc9565b505050565b606060048054620004fe90620020bd565b73ffffffffffffffffffffffffffffffffffffffff811660009081526020819052604081205462000acb904262000d72565b92915050565b3360009081526006602052604081205473ffffffffffffffffffffffffffffffffffffffff161562000b2f576040517f3a81d6fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b82827f00000000000000000000000000000000000000000000000000000000000000007f000000000000000000000000000000000000000000000000000000000000000060405162000b819062001dea565b62000b90949392919062002132565b604051809103906000f08015801562000bad573d6000803e3d6000fd5b503360008181526006602090815260409182902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff861617905590519182529192507fb2bd819aacce2076359caf6d49d9ac5252134cffdffe026bf4ad781dc3847790910160405180910390a192915050565b73ffffffffffffffffffffffffffffffffffffffff81161580159062000c83575073ffffffffffffffffffffffffffffffffffffffff81811660009081526006602052604090205416155b1562000cbb576040517fccd4942000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b62000cc681620014ea565b50565b62000a83838373ffffffffffffffffffffffffffffffffffffffff82161562000d1a5773ffffffffffffffffffffffffffffffffffffffff8087166000908152600560205260409020541662000d1d565b60005b73ffffffffffffffffffffffffffffffffffffffff86161562000d685773ffffffffffffffffffffffffffffffffffffffff8087166000908152600560205260409020541662000d6b565b60005b8562001671565b60007f0000000000000000000000000000000000000000000000000000000000000000821062000da3578162000dc5565b7f00000000000000000000000000000000000000000000000000000000000000005b91508290507f00000000000000000000000000000000000000000000000000000000000000008203600181161562000e2757670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b600281161562000e6157670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b600481161562000e9b57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b600881161562000ed557670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b601081161562000f0f57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b602081161562000f4957670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b604081161562000f8357670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b608081161562000fbd57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b61010081161562000ff857670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6102008116156200103357670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6104008116156200106e57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b610800811615620010a957670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b611000811615620010e457670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6120008116156200111f57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6140008116156200115a57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6180008116156200119557670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b62010000811615620011d157670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b620200008116156200120d57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b620400008116156200124957670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b620800008116156200128557670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b62100000811615620012c157670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b62200000811615620012fd57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b624000008116156200133957670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b628000008116156200137557670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6301000000811615620013b257670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6302000000811615620013ef57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b63040000008116156200142c57670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b63080000008116156200146957670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6310000000811615620014a657670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b6320000000811615620014e357670de0b6b3a76400007f000000000000000000000000000000000000000000000000000000000000000083020491505b5092915050565b3360009081526005602052604090205473ffffffffffffffffffffffffffffffffffffffff908116908216811462000a02573360008181526005602090815260409182902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff87169081179091558251938452908301527f4bc154dd35d6a5cb9206482ecb473cdbf2473006d6bce728b9cc0741bcc59ea2910160405180910390a16040517f3466a8860000000000000000000000000000000000000000000000000000000081523060048201523360248201526000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690633466a88690604401602060405180830381865afa15801562001638573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200165e91906200216f565b9050801562000a835762000a8333338486855b620016808585858585620017fd565b73ffffffffffffffffffffffffffffffffffffffff8316156200173b5773ffffffffffffffffffffffffffffffffffffffff838116600090815260066020526040908190205490517f9dc29fac000000000000000000000000000000000000000000000000000000008152878316600482015260248101849052911690639dc29fac90604401600060405180830381600087803b1580156200172157600080fd5b505af115801562001736573d6000803e3d6000fd5b505050505b73ffffffffffffffffffffffffffffffffffffffff821615620017f65773ffffffffffffffffffffffffffffffffffffffff828116600090815260066020526040908190205490517f40c10f190000000000000000000000000000000000000000000000000000000081528683166004820152602481018490529116906340c10f1990604401600060405180830381600087803b158015620017dc57600080fd5b505af1158015620017f1573d6000803e3d6000fd5b505050505b5050505050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141580156200183a5750600081115b15620017f65773ffffffffffffffffffffffffffffffffffffffff83166200186e57620018688282620018a3565b620017f6565b73ffffffffffffffffffffffffffffffffffffffff821662001896576200186883826200199e565b620017f683838362001b66565b73ffffffffffffffffffffffffffffffffffffffff821662001926576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064015b60405180910390fd5b80600260008282546200193a919062002189565b909155505073ffffffffffffffffffffffffffffffffffffffff8216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b73ffffffffffffffffffffffffffffffffffffffff821662001a43576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360448201527f730000000000000000000000000000000000000000000000000000000000000060648201526084016200191d565b73ffffffffffffffffffffffffffffffffffffffff82166000908152602081905260409020548181101562001afb576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60448201527f636500000000000000000000000000000000000000000000000000000000000060648201526084016200191d565b73ffffffffffffffffffffffffffffffffffffffff83166000818152602081815260408083208686039055600280548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff831662001c0b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016200191d565b73ffffffffffffffffffffffffffffffffffffffff821662001cb0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016200191d565b73ffffffffffffffffffffffffffffffffffffffff83166000908152602081905260409020548181101562001d68576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e6365000000000000000000000000000000000000000000000000000060648201526084016200191d565b73ffffffffffffffffffffffffffffffffffffffff848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a350505050565b611fbb80620021c583390190565b611e13806200418083390190565b6000815180845260005b8181101562001e205760208185018101518683018201520162001e02565b5060006020828601015260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011685010191505092915050565b60208152600062001e73602083018462001df8565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff8116811462000cc657600080fd5b60006020828403121562001eb057600080fd5b813562001e738162001e7a565b6000806040838503121562001ed157600080fd5b823562001ede8162001e7a565b946020939093013593505050565b60008060006060848603121562001f0257600080fd5b833562001f0f8162001e7a565b9250602084013562001f218162001e7a565b929592945050506040919091013590565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600082601f83011262001f7357600080fd5b813567ffffffffffffffff8082111562001f915762001f9162001f32565b604051601f83017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190828211818310171562001fda5762001fda62001f32565b8160405283815286602085880101111562001ff457600080fd5b836020870160208301376000602085830101528094505050505092915050565b600080604083850312156200202857600080fd5b823567ffffffffffffffff808211156200204157600080fd5b6200204f8683870162001f61565b935060208501359150808211156200206657600080fd5b50620020758582860162001f61565b9150509250929050565b600080604083850312156200209357600080fd5b8235620020a08162001e7a565b91506020830135620020b28162001e7a565b809150509250929050565b600181811c90821680620020d257607f821691505b6020821081036200210c577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b6000602082840312156200212557600080fd5b815162001e738162001e7a565b60808152600062002147608083018762001df8565b82810360208401526200215b818762001df8565b604084019590955250506060015292915050565b6000602082840312156200218257600080fd5b5051919050565b8082018082111562000acb577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fdfe60c06040523480156200001157600080fd5b5060405162001fbb38038062001fbb8339810160408190526200003491620000f8565b6001600160a01b0382166080526200004c33620000a8565b60058111156200007657604051632c22366560e11b81526004810182905260240160405180910390fd5b6001600160a01b0382166200009e5760405163d0af4eb760e01b815260040160405180910390fd5b60a0525062000134565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b600080604083850312156200010c57600080fd5b82516001600160a01b03811681146200012457600080fd5b6020939093015192949293505050565b60805160a051611e37620001846000396000818161023d015261056901526000818161036b015281816103ca01528181610492015281816106250152818161085601526109080152611e376000f3fe608060405234801561001057600080fd5b506004361061011b5760003560e01c806378e3214f116100b2578063bfe1092811610081578063e6235ba711610066578063e6235ba714610340578063f2fde38b14610353578063fc0c546a1461036657600080fd5b8063bfe109281461030d578063cd00671b1461032b57600080fd5b806378e3214f146102955780637a1f1aa9146102a85780638da5cb5b146102bb578063b1bd3517146102fa57600080fd5b80634e71d92d116100ee5780634e71d92d1461025f57806366fa3e1e14610267578063715018a61461027a57806375619ab51461028257600080fd5b806318160ddd146101205780631e83409a146101375780632915cbec1461014c5780633717a68914610238575b600080fd5b6002545b6040519081526020015b60405180910390f35b61014a610145366004611ac6565b610393565b005b6101f061015a366004611ac6565b60408051606080820183526000808352602080840182905292840181905273ffffffffffffffffffffffffffffffffffffffff9490941684526003825292829020825193840183525464ffffffffff8116845265010000000000810463ffffffff16918401919091526901000000000000000000900476ffffffffffffffffffffffffffffffffffffffffffffff169082015290565b60408051825164ffffffffff16815260208084015163ffffffff16908201529181015176ffffffffffffffffffffffffffffffffffffffffffffff169082015260600161012e565b6101247f000000000000000000000000000000000000000000000000000000000000000081565b61014a61045b565b61014a610275366004611ac6565b61055f565b61014a61067d565b61014a610290366004611ac6565b610691565b61014a6102a3366004611ae3565b610788565b61014a6102b6366004611b0f565b61083e565b60005473ffffffffffffffffffffffffffffffffffffffff165b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161012e565b610124610308366004611b50565b6108b8565b60015473ffffffffffffffffffffffffffffffffffffffff166102d5565b610333610994565b60405161012e9190611b89565b61014a61034e366004611be3565b6109a5565b61014a610361366004611ac6565b610aeb565b6102d57f000000000000000000000000000000000000000000000000000000000000000081565b60025490565b6040517f3466a8860000000000000000000000000000000000000000000000000000000081523060048201523360248201526000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690633466a88690604401602060405180830381865afa158015610426573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061044a9190611c18565b9050610457823383610ba7565b5050565b6040517f3466a8860000000000000000000000000000000000000000000000000000000081523060048201523360248201526000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690633466a88690604401602060405180830381865afa1580156104ee573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105129190611c18565b905060006105206004610bd1565b905060005b815181101561055a5761055282828151811061054357610543611c31565b60200260200101513385610ba7565b600101610525565b505050565b610567610c3e565b7f00000000000000000000000000000000000000000000000000000000000000006105926004610cbf565b036105c9576040517f62bc61f800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6105d4600482610cd6565b61060a576040517f4c95008300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805173ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000081168252831660208201527f6bff9ddd187ef283e9c7726f406ab27bcc3719a41b6bee3585c7447183cffcec910160405180910390a150565b610685610c3e565b61068f6000610d47565b565b610699610c3e565b60015473ffffffffffffffffffffffffffffffffffffffff9081169082168190036106f0576040517f8750ee9000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805173ffffffffffffffffffffffffffffffffffffffff8084168252841660208201527fa9f739537fc57540bed0a44e33e27baa63290d865cc15f0f16cf17d38c998a4d910160405180910390a150600180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b60015473ffffffffffffffffffffffffffffffffffffffff1633146107d9576040517f4ca8886700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8216610817576001546104579073ffffffffffffffffffffffffffffffffffffffff1682610dbc565b6001546104579073ffffffffffffffffffffffffffffffffffffffff848116911683610f16565b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016146108ad576040517f4ca8886700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61055a838383610f78565b6040517f3466a88600000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff828116602483015260009182917f00000000000000000000000000000000000000000000000000000000000000001690633466a88690604401602060405180830381865afa15801561094f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109739190611c18565b905061098a838261098387611036565b9190611086565b9150505b92915050565b60606109a06004610bd1565b905090565b60015473ffffffffffffffffffffffffffffffffffffffff1633146109f6576040517f4ca8886700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8316600090815260056020526040902054610a52576040517f24060f4f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610a698383610a6287611036565b91906110ae565b6040805173ffffffffffffffffffffffffffffffffffffffff87168152602081018390529081018490529091507f6a6f77044107a33658235d41bedbbaf2fe9ccdceb313143c947a5e76e1ec84749060600160405180910390a1610ae573ffffffffffffffffffffffffffffffffffffffff8516333086611139565b50505050565b610af3610c3e565b73ffffffffffffffffffffffffffffffffffffffff8116610b9b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b610ba481610d47565b50565b6000610bbe8383610bb787611036565b91906111d6565b90508015610ae557610ae5848483611222565b60008080526020829052604090205460609060a081901c67ffffffffffffffff811115610c0057610c00611c60565b604051908082528060200260200182016040528015610c29578160200160208202803683370190505b509150610c37838383611243565b5050919050565b60005473ffffffffffffffffffffffffffffffffffffffff16331461068f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610b92565b60008080526020829052604081205460a01c61098e565b73ffffffffffffffffffffffffffffffffffffffff8116600090815260018301602052604081205415610d0b5750600061098e565b610d15838361132c565b73ffffffffffffffffffffffffffffffffffffffff929092166000908152600193840160205260409020919091555090565b6000805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b80471015610e26576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e63650000006044820152606401610b92565b60008273ffffffffffffffffffffffffffffffffffffffff168260405160006040518083038185875af1925050503d8060008114610e80576040519150601f19603f3d011682016040523d82523d6000602084013e610e85565b606091505b505090508061055a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d617920686176652072657665727465640000000000006064820152608401610b92565b610f42837fa9059cbb0000000000000000000000000000000000000000000000000000000084846113f4565b61055a576040517ffb7f507900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610f846004610bd1565b905060005b8151811015610fca57610fc2858585610fba868681518110610fad57610fad611c31565b6020026020010151611036565b929190611447565b600101610f89565b5073ffffffffffffffffffffffffffffffffffffffff8416610ffe578160026000828254610ff89190611cbe565b90915550505b73ffffffffffffffffffffffffffffffffffffffff8316610ae557816002600082825461102b9190611cd1565b909155505050505050565b604080518082018252611a9c81526000602080830182905273ffffffffffffffffffffffffffffffffffffffff851682526003815290839020835180850190945261038d8452908301529061098e565b60006110a6838361109687611467565b6020880151600101929190611489565b949350505050565b6000806110bc856020015190565b90506111256110ca86611467565b600183019064ffffffffff42167affffffffffffffffffffffffffffffffffffffffffffffffffffff90911665010000000000027fffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000016179055565b6111308185856114d9565b95945050505050565b60006323b872dd60e01b905060006040518281528560048201528460248201528360448201526020600060648360008b5af19150508015611197573d801561118d57600160005114601f3d11169150611195565b6000873b1191505b505b806111ce576040517ff405907100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505050505050565b6000806111e4856020015190565b905060006111f186611467565b905061120260018301868684611489565b925082156112195761121960018301868684611715565b50509392505050565b61055a73ffffffffffffffffffffffffffffffffffffffff84168383610f16565b815160609060a083901c90811115611287576040517ff9a99b2500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80156113235782846000815181106112a1576112a1611c31565b73ffffffffffffffffffffffffffffffffffffffff9092166020928302919091019091015260015b818110156113215760008181526020879052604090205485518690839081106112f4576112f4611c31565b73ffffffffffffffffffffffffffffffffffffffff909216602092830291909101909101526001016112c9565b505b50919392505050565b60008080526020839052604081205460a081901c8083036113a157600080805260208690526040902074ffffffffffffffffffffffffffffffffffffffffff7401000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff8716011690556113e9565b6000808052602086905260408082207401000000000000000000000000000000000000000085019055828252902073ffffffffffffffffffffffffffffffffffffffff851690555b600101949350505050565b60006040518481528360048201528260248201526020600060448360008a5af191505080156110a6573d801561143657600160005114601f3d1116915061143e565b6000863b1191505b50949350505050565b610ae583838361145688611467565b60208901516001019392919061174e565b600061098e826118aa6118e461147e866020015190565b600101929190611979565b73ffffffffffffffffffffffffffffffffffffffff83166000908152600185016020526040812054670de0b6b3a7640000906114c58486611ce4565b6114cf9190611cfb565b6111309190611d51565b600081600003611515576040517f68d5686e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b63ffffffff821115611553576040517f426a107300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6d04ee2d6d415b85acef810000000083111561159b576040517f0625040100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60408051606081018252855464ffffffffff811680835265010000000000820463ffffffff166020840152690100000000000000000090910476ffffffffffffffffffffffffffffffffffffffffffffff16928201929092529042101561166e57670de0b6b3a764000061162f82836020015163ffffffff1684600001516116239190611d8c565b64ffffffffff166119f9565b6116399190611d51565b816040015176ffffffffffffffffffffffffffffffffffffffffffffff166116619190611cd1565b61166b9085611cbe565b93505b6116788342611cbe565b855464ffffffffff908116690100000000000000000076ffffffffffffffffffffffffffffffffffffffffffffff8816027fffffffffffffffffffffffffffffffffffffffffffffff00000000ffffffffff16176501000000000063ffffffff9690961695909502949094177fffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000001693169290921790935550919050565b61171f8183611ce4565b73ffffffffffffffffffffffffffffffffffffffff909316600090815260019094016020525050604090912055565b73ffffffffffffffffffffffffffffffffffffffff848116159084161583158015906117a657508473ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614155b156118a15781806117b45750805b1561180d577fffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000650100000000007affffffffffffffffffffffffffffffffffffffffffffffffffffff851602164264ffffffffff161787555b60006118198486611ce4565b90508261185d5773ffffffffffffffffffffffffffffffffffffffff8716600090815260018901602052604081208054839290611857908490611cfb565b90915550505b8161189f5773ffffffffffffffffffffffffffffffffffffffff8616600090815260018901602052604081208054839290611899908490611daa565b90915550505b505b50505050505050565b6000806118cb8360408051808201909152611a9c8152600060208201525090565b90506118dd816000015163ffffffff16565b9392505050565b6000806119058460408051808201909152611a9c8152600060208201525090565b905061098a83611916836020015190565b60408051606081018252915464ffffffffff8116835265010000000000810463ffffffff9081166020850152690100000000000000000090910476ffffffffffffffffffffffffffffffffffffffffffffff16918301919091529091906119f916565b835460009064ffffffffff8116906501000000000090047affffffffffffffffffffffffffffffffffffffffffffffffffffff164282146119ef5760006119c3878763ffffffff16565b905080156119ed57806119da88858863ffffffff16565b816119e7576119e7611d22565b04820191505b505b9695505050505050565b602082015160009063ffffffff161561098e576000611a2383856000015164ffffffffff16611a86565b611a3842866000015164ffffffffff16611a86565b039050836020015163ffffffff16670de0b6b3a7640000856040015176ffffffffffffffffffffffffffffffffffffffffffffff1683020281611a7d57611a7d611d22565b0491505061098e565b6000818310611a9557816118dd565b5090919050565b61068f611dd2565b73ffffffffffffffffffffffffffffffffffffffff81168114610ba457600080fd5b600060208284031215611ad857600080fd5b81356118dd81611aa4565b60008060408385031215611af657600080fd5b8235611b0181611aa4565b946020939093013593505050565b600080600060608486031215611b2457600080fd5b8335611b2f81611aa4565b92506020840135611b3f81611aa4565b929592945050506040919091013590565b60008060408385031215611b6357600080fd5b8235611b6e81611aa4565b91506020830135611b7e81611aa4565b809150509250929050565b6020808252825182820181905260009190848201906040850190845b81811015611bd757835173ffffffffffffffffffffffffffffffffffffffff1683529284019291840191600101611ba5565b50909695505050505050565b600080600060608486031215611bf857600080fd5b8335611c0381611aa4565b95602085013595506040909401359392505050565b600060208284031215611c2a57600080fd5b5051919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b8082018082111561098e5761098e611c8f565b8181038181111561098e5761098e611c8f565b808202811582820484141761098e5761098e611c8f565b8181036000831280158383131683831282161715611d1b57611d1b611c8f565b5092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b600082611d87577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b64ffffffffff828116828216039080821115611d1b57611d1b611c8f565b8082018281126000831280158216821582161715611dca57611dca611c8f565b505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052605160045260246000fdfea264697066735822122033d2e53b7d8d7fef22ac60ee554dd5c92e09220b60eab4ee92937f19f8b38d7864736f6c6343000811003360e06040523480156200001157600080fd5b5060405162001e1338038062001e13833981016040819052620000349162000178565b81818585600362000046838262000281565b50600462000055828262000281565b505050816000036200007a576040516337f1632160e11b815260040160405180910390fd5b608082905260a08190526200009c6005620000ad602090811b6200084b17901c565b50503360c052506200034d92505050565b60019055565b634e487b7160e01b600052604160045260246000fd5b600082601f830112620000db57600080fd5b81516001600160401b0380821115620000f857620000f8620000b3565b604051601f8301601f19908116603f01168101908282118183101715620001235762000123620000b3565b816040528381526020925086838588010111156200014057600080fd5b600091505b8382101562000164578582018301518183018401529082019062000145565b600093810190920192909252949350505050565b600080600080608085870312156200018f57600080fd5b84516001600160401b0380821115620001a757600080fd5b620001b588838901620000c9565b95506020870151915080821115620001cc57600080fd5b50620001db87828801620000c9565b604087015160609097015195989097509350505050565b600181811c908216806200020757607f821691505b6020821081036200022857634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200027c57600081815260208120601f850160051c81016020861015620002575750805b601f850160051c820191505b81811015620002785782815560010162000263565b5050505b505050565b81516001600160401b038111156200029d576200029d620000b3565b620002b581620002ae8454620001f2565b846200022e565b602080601f831160018114620002ed5760008415620002d45750858301515b600019600386901b1c1916600185901b17855562000278565b600085815260208120601f198616915b828110156200031e57888601518255948401946001909101908401620002fd565b50858210156200033d5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60805160a05160c051611a7a62000399600039600081816105760152818161072701526107dc015260008181610318015261113d01526000818161029d0152610b180152611a7a6000f3fe608060405234801561001057600080fd5b50600436106101985760003560e01c806370a08231116100e3578063a457c2d71161008c578063dd62ed3e11610066578063dd62ed3e14610350578063f55f545c14610396578063f70f6a9a146103b657600080fd5b8063a457c2d7146101bb578063a9059cbb1461033a578063ada6f64b1461034857600080fd5b806395d89b41116100bd57806395d89b41146102f85780639dc29fac14610300578063a44282dc1461031357600080fd5b806370a08231146102bf5780637a3e60e9146102d25780638da031df146102e557600080fd5b80633466a8861161014557806340f99a941161011f57806340f99a941461024d578063538db9231461028557806366b0dede1461029857600080fd5b80633466a8861461022757806339509351146101bb57806340c10f191461023a57600080fd5b8063222d6b4d11610176578063222d6b4d146101f057806323b872dd14610205578063313ce5671461021857600080fd5b806306fdde031461019d578063095ea7b3146101bb57806318160ddd146101de575b600080fd5b6101a56103c9565b6040516101b291906117bc565b60405180910390f35b6101ce6101c9366004611851565b61045b565b60405190151581526020016101b2565b6002545b6040519081526020016101b2565b6102036101fe36600461187b565b61048f565b005b6101ce610213366004611896565b61049c565b604051601281526020016101b2565b6101e26102353660046118d2565b6104d0565b610203610248366004611851565b61055e565b61026061025b366004611851565b6105db565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016101b2565b61020361029336600461187b565b610613565b6101e27f000000000000000000000000000000000000000000000000000000000000000081565b6101e26102cd36600461187b565b61061d565b6101e26102e036600461187b565b610692565b6101ce6102f33660046118d2565b6106c0565b6101a5610700565b61020361030e366004611851565b61070f565b6101e27f000000000000000000000000000000000000000000000000000000000000000081565b6101ce610213366004611851565b610203610788565b6101e261035e3660046118d2565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260016020908152604080832093909416825291909152205490565b6103a96103a436600461187b565b610793565b6040516101b29190611905565b6102036103c43660046118d2565b6107c4565b6060600380546103d89061195f565b80601f01602080910402602001604051908101604052809291908181526020018280546104049061195f565b80156104515780601f1061042657610100808354040283529160200191610451565b820191906000526020600020905b81548152906001019060200180831161043457829003601f168201915b5050505050905090565b60006040517feb60c2c400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6104993382610851565b50565b60006040517fa24e573d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060056104df815460021490565b15610516576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61052083856106c0565b156105525773ffffffffffffffffffffffffffffffffffffffff83166000908152602081905260409020549150610557565b600091505b5092915050565b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016146105cd576040517f30cd747100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6105d7828261092b565b5050565b73ffffffffffffffffffffffffffffffffffffffff8216600090815260066020526040812061060a9083610a2b565b90505b92915050565b6104993382610a3f565b6000600561062c815460021490565b15610663576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff831660009081526020819052604090205491505b50919050565b73ffffffffffffffffffffffffffffffffffffffff8116600090815260066020526040812061060d90610be9565b73ffffffffffffffffffffffffffffffffffffffff828116600090815260066020908152604080832093851683526001909301905290812054151561060a565b6060600480546103d89061195f565b3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000161461077e576040517f30cd747100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6105d78282610c00565b61079133610dcb565b565b73ffffffffffffffffffffffffffffffffffffffff8116600090815260066020526040902060609061060d90610f53565b3373ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001614610833576040517f30cd747100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61083d82826106c0565b6105d7576105d78282610a3f565b60019055565b73ffffffffffffffffffffffffffffffffffffffff821660009081526006602052604090206108809082610fc0565b6108b6576040517f826fbca300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805173ffffffffffffffffffffffffffffffffffffffff8085168252831660208201527fb94b1adfafd33f45e2ba5c713871f026dc1ef0fdc3d75b4f24e954f15b9f8e64910160405180910390a160006109118361061d565b905080156109265761092682846000846110db565b505050565b73ffffffffffffffffffffffffffffffffffffffff82166109ad576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064015b60405180910390fd5b80600260008282546109bf91906119ac565b909155505073ffffffffffffffffffffffffffffffffffffffff8216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a36105d76000838361118a565b60008181526020839052604081205461060a565b73ffffffffffffffffffffffffffffffffffffffff8116610a8c576040517f960357e400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff82166000908152600660205260409020610abb90826113c6565b610af1576040517fcbdb297300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff821660009081526006602052604090207f000000000000000000000000000000000000000000000000000000000000000090610b4190610be9565b1115610b79576040517fc87e91a600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805173ffffffffffffffffffffffffffffffffffffffff8085168252831660208201527fde03e097fdd335e4d488cd0bc9645f306e7f5569ad042d918dc75be13107c677910160405180910390a16000610bd48361061d565b905080156109265761092682600085846110db565b60008080526020829052604081205460a01c61060d565b73ffffffffffffffffffffffffffffffffffffffff8216610ca3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360448201527f730000000000000000000000000000000000000000000000000000000000000060648201526084016109a4565b73ffffffffffffffffffffffffffffffffffffffff821660009081526020819052604090205481811015610d59576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60448201527f636500000000000000000000000000000000000000000000000000000000000060648201526084016109a4565b73ffffffffffffffffffffffffffffffffffffffff83166000818152602081815260408083208686039055600280548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a36109268360008461118a565b73ffffffffffffffffffffffffffffffffffffffff81166000908152600660205260408120610df990610f53565b90506000610e068361061d565b82519091505b8015610f4d57610e7f836001830381518110610e2a57610e2a6119e6565b6020026020010151600660008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020610fc090919063ffffffff16565b507fb94b1adfafd33f45e2ba5c713871f026dc1ef0fdc3d75b4f24e954f15b9f8e6484846001840381518110610eb757610eb76119e6565b6020026020010151604051610eef92919073ffffffffffffffffffffffffffffffffffffffff92831681529116602082015260400190565b60405180910390a18115610f2657610f26836001830381518110610f1557610f156119e6565b6020026020010151856000856110db565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01610e0c565b50505050565b60008080526020829052604090205460609060a081901c67ffffffffffffffff811115610f8257610f82611a15565b604051908082528060200260200182016040528015610fab578160200160208202803683370190505b509150610fb9838383611437565b5050919050565b73ffffffffffffffffffffffffffffffffffffffff81166000908152600183016020526040812054808203610ff957600091505061060d565b60008080526020859052604090205460a01c8110156110a5576000808052602085905260408082205460a01c7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff018252812054905061107b857fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff840183611520565b73ffffffffffffffffffffffffffffffffffffffff16600090815260018501602052604090208190555b6110ae846115d2565b505073ffffffffffffffffffffffffffffffffffffffff1660009081526001918201602052604081205590565b604080517f7a1f1aa900000000000000000000000000000000000000000000000000000000808252600482018690526024820185905260448201849052917f1c26714c00000000000000000000000000000000000000000000000000000000917f0000000000000000000000000000000000000000000000000000000000000000918290603f5a02041015611174578260005260046000fd5b60008060648360008c87f1505050505050505050565b600561119581611694565b6000821180156111d157508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614155b156113bd5773ffffffffffffffffffffffffffffffffffffffff8416600090815260066020526040812061120490610f53565b73ffffffffffffffffffffffffffffffffffffffff851660009081526006602052604081209192509061123690610f53565b825181519192509060005b8281101561134357600085828151811061125d5761125d6119e6565b6020026020010151905060005b8381101561132557858181518110611284576112846119e6565b602002602001015173ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160361131d576112ca828c8c8c6110db565b60008682815181106112de576112de6119e6565b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff1681525050611325565b60010161126a565b83810361133957611339828c60008c6110db565b5050600101611241565b5060005b818110156113b7576000848281518110611363576113636119e6565b60200260200101519050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146113ae576113ae8160008b8b6110db565b50600101611347565b50505050505b60018155610f4d565b73ffffffffffffffffffffffffffffffffffffffff81166000908152600183016020526040812054156113fb5750600061060d565b61140583836116f4565b73ffffffffffffffffffffffffffffffffffffffff929092166000908152600193840160205260409020919091555090565b815160609060a083901c9081111561147b576040517ff9a99b2500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8015611517578284600081518110611495576114956119e6565b73ffffffffffffffffffffffffffffffffffffffff9092166020928302919091019091015260015b818110156115155760008181526020879052604090205485518690839081106114e8576114e86119e6565b73ffffffffffffffffffffffffffffffffffffffff909216602092830291909101909101526001016114bd565b505b50919392505050565b60008080526020849052604090205460a01c80831061156b576040517f4e23d03500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b826000036115a557600080805260208590526040902060a082901b73ffffffffffffffffffffffffffffffffffffffff8416179055610f4d565b600083815260208590526040902073ffffffffffffffffffffffffffffffffffffffff8316905550505050565b6000808052602082905260408120549060a082901c90819003611621576040517f06a2af9e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff810160009081526020849052604081205560018111156109265760008080526020849052604090207fffffffffffffffffffffffff000000000000000000000000000000000000000083019055505050565b80547ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016116ee576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60029055565b60008080526020839052604081205460a081901c80830361176957600080805260208690526040902074ffffffffffffffffffffffffffffffffffffffffff7401000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff8716011690556117b1565b6000808052602086905260408082207401000000000000000000000000000000000000000085019055828252902073ffffffffffffffffffffffffffffffffffffffff851690555b600101949350505050565b600060208083528351808285015260005b818110156117e9578581018301518582016040015282016117cd565b5060006040828601015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8301168501019250505092915050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461184c57600080fd5b919050565b6000806040838503121561186457600080fd5b61186d83611828565b946020939093013593505050565b60006020828403121561188d57600080fd5b61060a82611828565b6000806000606084860312156118ab57600080fd5b6118b484611828565b92506118c260208501611828565b9150604084013590509250925092565b600080604083850312156118e557600080fd5b6118ee83611828565b91506118fc60208401611828565b90509250929050565b6020808252825182820181905260009190848201906040850190845b8181101561195357835173ffffffffffffffffffffffffffffffffffffffff1683529284019291840191600101611921565b50909695505050505050565b600181811c9082168061197357607f821691505b60208210810361068c577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b8082018082111561060d577f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fdfea2646970667358221220cadc776809523181702befb6128347b2f47f0d4e53d7ae0b9191e6574b758d4364736f6c63430008110033a2646970667358221220569d7109ea3faada53b173883a366537ba219820ed71958409595c7e95e030d564736f6c63430008110033000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000009a0c8ff858d273f57072d714bca7411d717501d7000000000000000000000000000000000000000000000000000000000000001144656c65676174656420737431494e4348000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000864737431494e4348000000000000000000000000000000000000000000000000

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000009a0c8ff858d273f57072d714bca7411d717501d7000000000000000000000000000000000000000000000000000000000000001144656c65676174656420737431494e4348000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000864737431494e4348000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Delegated st1INCH
Arg [1] : symbol_ (string): dst1INCH
Arg [2] : st1inch (address): 0x9A0C8Ff858d273f57072D714bca7411D717501D7

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000009a0c8ff858d273f57072d714bca7411d717501d7
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000011
Arg [4] : 44656c65676174656420737431494e4348000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [6] : 64737431494e4348000000000000000000000000000000000000000000000000