Contract 0x48d5e1A395F494f5a60C12E73179d71A9778Ce1f

/**
 *Submitted for verification at testnet.snowtrace.io on 2022-04-08
*/

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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


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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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


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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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


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

// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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


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

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


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

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File contracts/AccruingStake.sol

pragma solidity 0.8.9;

/// @title A staking contract which accrues over time based on the amount staked
/// @author Auroter
/// @notice Allows you to lock tokens in exchange for distribution tokens
/// @notice Locks can be deposited into or closed
/// @dev Simply call stake(...) to deposit tokens
/// @dev Call getAccrued(user) / getTotalAccrued() = users share




contract AccruingStake is ReentrancyGuard, Ownable {
    using SafeERC20 for IERC20;

    // Info pertaining to staking contract
    address public stakedToken; // An ERC20 Token to be staked (i.e. Axial)
    string public name; // New asset after staking (i.e. veAxial)
    string public symbol; // New asset symbol after staking (i.e. veAXIAL)
    //uint256 private AprDenominator = 1 days;  // Timeframe it takes for the user to accrue X tokens

    // Info pertaining to users
    uint256 private totalTokensLocked; // Total balance of tokens users have locked
    uint256 private totalTokensAccrued; // Total balance of accrued tokens currently awarded to users
    uint256 private lastUserIndexUpdated; // Index of the user whose accrual was most recently updated
    uint256 private timeStamp; // Last time Total Accrual was updated
    address[] private users; // An array containing all user addresses
    mapping(address => AccrueVe) private locks; // A mapping of each users tokens staked

    struct AccrueVe {
        uint256 accruedTokens; // Quantity of tokens awarded to the user at time of Timestamp
        uint256 stakedTokens; // Quantity of tokens the user has staked
        uint256 timeStamp; // Last time the accrual was updated
        uint256 userIndex; // Index of user, used to manage iteration
        bool initialized; // True if the user is staked
    }

    /// @notice Constructor
    /// @param _stakedToken Address of the token our users will deposit and lock in exchange for governance tokens
    /// @param _name Desired name of our governance token
    /// @param _symbol Desired symbol of our governance token
    /// @param _governance Address of wallet which will be given adminstrative access to this contract
    constructor(
        address _stakedToken,
        string memory _name,
        string memory _symbol,
        address _governance
    ) {
        transferOwnership(_governance);
        stakedToken = _stakedToken;
        name = _name;
        symbol = _symbol;
    }

    /// @notice Emitted when a user creates a new stake
    /// @param user Address of the user who staked
    /// @param amount Quantity of tokens deposited
    event userStaked(address indexed user, uint256 amount);

    /// @notice Emitted when a user adds to their stake
    /// @param user Address of the user who staked
    /// @param amount Quantity of tokens deposited
    event userRestaked(address indexed user, uint256 amount);

    /// @notice Emitted when a user withdraws their funds
    /// @param user Address of the user who withdrew
    /// @param amount Quantity of tokens withdrawn
    /// @param accrued Quantity of accrued tokens lost
    event userWithdrew(address indexed user, uint256 amount, uint256 accrued);

    /// @notice Get the number of tokens a user currently has staked
    /// @param _userAddr Address of any user to view the number of vested tokens they have not yet claimed
    /// @return Quantity of tokens which a user currently has staked
    function getStaked(address _userAddr) public view returns (uint256) {
        return locks[_userAddr].stakedTokens;
    }

    /// @notice Get the total number of tokens a user has accrued
    /// @param _userAddr Address of any user to view the number of vested tokens they have not yet claimed
    /// @return Quantity of tokens which a user has accrued over time
    /// @dev Use this function to get the numerator for a users share of the rewards pool
    function getAccrued(address _userAddr) public view returns (uint256) {
        //return Locks[_userAddr].AccruedTokens;
        return locks[_userAddr].accruedTokens + (locks[_userAddr].stakedTokens * (block.timestamp - locks[_userAddr].timeStamp));
    }

    /// @notice Get the total number of tokens accrued via this contract
    /// @return Quantity of all tokens awarded by this contract
    /// @dev Use this function to get the denominator for a users share of the rewards pool
    function getTotalAccrued() public view returns (uint256) {
        return totalTokensAccrued + (totalTokensLocked * (block.timestamp - timeStamp));
    }

    /// @notice Retrieve a list of all users who have ever staked
    /// @return An array of addresses of all users who have ever staked
    function getAllUsers() public view returns (address[] memory) {
        return users;
    }

    // Accrual is tokens locked * seconds
    /// @notice Update the accrual for a specific user
    /// @param _userAddr address of user to update
    /// @dev This synchronizes a users accrual when their deposit amount changes
    function _updateUsersAccrual(address _userAddr) private {
        AccrueVe storage lock = locks[_userAddr];
        uint256 blockTimestamp = block.timestamp;

        uint256 accrual = (blockTimestamp - lock.timeStamp) * lock.stakedTokens;

        lock.timeStamp = blockTimestamp;
        lock.accruedTokens += accrual;
    }

    /// @notice Update the total accrual for all users
    /// @dev This updates the value used as the denominator for a users accrual share
    /// @dev This must always be called before changing the amount of tokens deposited in this contract
    function _updateTotalAccrual() private {
        uint256 currentTime = block.timestamp;
        uint256 delta = currentTime - timeStamp;
        totalTokensAccrued += totalTokensLocked * delta;
        timeStamp = currentTime;
    }

    /// @notice Allow owner to reclaim tokens not matching the deposit token
    /// @notice Some users may have accidentally sent these to the contract
    /// @param _token Address of the non-deposit token
    /// @dev Always ensure the _token is legitimate before calling this
    /// @dev A bad token can mimic safetransfer or balanceof with a nocive function
    function ownerRemoveNonDepositToken(address _token) public nonReentrant onlyOwner {
        require(_token != stakedToken, "!invalid");
        uint256 balanceOfToken = IERC20(_token).balanceOf(address(this));
        require(balanceOfToken > 0, "!balance");
        IERC20(_token).safeTransfer(owner(), balanceOfToken);
    }

    /// @notice Transfers deposited tokens back to their original owner
    /// @notice This will reset the users accrual!
    /// @dev This could be called by the web application via a button or some other means
    function withdrawMyFunds() external nonReentrant {
        address userAddr = msg.sender;
        uint256 fundsToClaim = locks[userAddr].stakedTokens;

        require(fundsToClaim > 0, "!funds");
        IERC20(stakedToken).safeTransfer(userAddr, fundsToClaim);

        // decrement totals
        _updateTotalAccrual();
        uint256 tokensAccrued = getAccrued(userAddr);
        totalTokensLocked -= fundsToClaim;
        totalTokensAccrued -= tokensAccrued;

        // Broadcast withdrawal
        emit userWithdrew(userAddr, fundsToClaim, locks[userAddr].accruedTokens);

        locks[userAddr].stakedTokens = 0;
        locks[userAddr].accruedTokens = 0;
        locks[userAddr].initialized = false;

        // Fairly efficient way of removing user from list
        uint256 lastUsersIndex = users.length - 1;
        uint256 myIndex = locks[userAddr].userIndex;
        locks[users[lastUsersIndex]].userIndex = myIndex;
        users[myIndex] = users[lastUsersIndex];
        users.pop();
    }

    /// @notice Deposit tokens into the contract, adjusting accrual rate
    /// @param _amount Number of tokens to deposit
    function stake(uint256 _amount) external nonReentrant {
        require(_amount > 0, "!amount");

        address userAddr = msg.sender;

        // Receive the users tokens
        require(IERC20(stakedToken).balanceOf(userAddr) >= _amount, "!balance");
        require(IERC20(stakedToken).allowance(userAddr, address(this)) >= _amount, "!approved");
        IERC20(stakedToken).safeTransferFrom(userAddr, address(this), _amount);

        _updateTotalAccrual();
        totalTokensLocked += _amount;

        // Keep track of new users
        if (!locks[userAddr].initialized) {
            users.push(userAddr);
            locks[userAddr].initialized = true;
            locks[userAddr].timeStamp = block.timestamp; // begin accrual from time of initial deposit
            locks[userAddr].userIndex = users.length - 1;
            emit userStaked(userAddr, _amount);
        } else {
            _updateUsersAccrual(userAddr); // balance ledger before accrual rate is increased
            emit userRestaked(userAddr, _amount);
        }

        // Update balance
        locks[userAddr].stakedTokens += _amount;
    }
}

[{"inputs":[{"internalType":"address","name":"_stakedToken","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_governance","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"userRestaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"userStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accrued","type":"uint256"}],"name":"userWithdrew","type":"event"},{"inputs":[{"internalType":"address","name":"_userAddr","type":"address"}],"name":"getAccrued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllUsers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddr","type":"address"}],"name":"getStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalAccrued","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":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"ownerRemoveNonDepositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakedToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawMyFunds","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000708f10f657b16abe18954361e96a641b217648b000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000044a4b9e2a69d86ba382a511f845cbf2e3128677000000000000000000000000000000000000000000000000000000000000000077665417869616c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000077665415849414c00000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _stakedToken (address): 0x0708f10f657b16abe18954361e96a641b217648b
Arg [1] : _name (string): veAxial
Arg [2] : _symbol (string): veAXIAL
Arg [3] : _governance (address): 0x44a4b9e2a69d86ba382a511f845cbf2e31286770

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000708f10f657b16abe18954361e96a641b217648b
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [3] : 00000000000000000000000044a4b9e2a69d86ba382a511f845cbf2e31286770
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [5] : 7665417869616c00000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [7] : 7665415849414c00000000000000000000000000000000000000000000000000

22105:8757:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22319:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;27985:331;;;;;;:::i;:::-;;:::i;:::-;;25178:123;;;;;;:::i;:::-;-1:-1:-1;;;;;25264:16:0;25237:7;25264:16;;;:5;:16;;;;;:29;;;;25178:123;;;;1102:25:1;;;1090:2;1075:18;25178:123:0;956:177:1;28540:1033:0;;;:::i;20867:103::-;;;:::i;20216:87::-;20289:6;;-1:-1:-1;;;;;20289:6:0;20216:87;;;-1:-1:-1;;;;;1302:32:1;;;1284:51;;1272:2;1257:18;20216:87:0;1138:203:1;22386:20:0;;;:::i;25646:258::-;;;;;;:::i;:::-;;:::i;29707:1152::-;;;;;;:::i;:::-;;:::i;22242:26::-;;;;;-1:-1:-1;;;;;22242:26:0;;;26447:93;;;:::i;:::-;;;;;;;:::i;26144:155::-;;;:::i;21125:201::-;;;;;;:::i;:::-;;:::i;22319:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;27985:331::-;17304:1;17902:7;;:19;;17894:63;;;;-1:-1:-1;;;17894:63:0;;;;;;;:::i;:::-;;;;;;;;;17304:1;18035:7;:18;20289:6;;-1:-1:-1;;;;;20289:6:0;19016:10;20436:23:::1;20428:68;;;;-1:-1:-1::0;;;20428:68:0::1;;;;;;;:::i;:::-;28096:11:::2;::::0;-1:-1:-1;;;;;28086:21:0;;::::2;28096:11:::0;::::2;28086:21;;28078:42;;;::::0;-1:-1:-1;;;28078:42:0;;3502:2:1;28078:42:0::2;::::0;::::2;3484:21:1::0;3541:1;3521:18;;;3514:29;-1:-1:-1;;;3559:18:1;;;3552:38;3607:18;;28078:42:0::2;3300:331:1::0;28078:42:0::2;28156:39;::::0;-1:-1:-1;;;28156:39:0;;28189:4:::2;28156:39;::::0;::::2;1284:51:1::0;28131:22:0::2;::::0;-1:-1:-1;;;;;28156:24:0;::::2;::::0;::::2;::::0;1257:18:1;;28156:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;28131:64;;28231:1;28214:14;:18;28206:39;;;::::0;-1:-1:-1;;;28206:39:0;;4027:2:1;28206:39:0::2;::::0;::::2;4009:21:1::0;4066:1;4046:18;;;4039:29;-1:-1:-1;;;4084:18:1;;;4077:38;4132:18;;28206:39:0::2;3825:331:1::0;28206:39:0::2;28256:52;28284:7;20289:6:::0;;-1:-1:-1;;;;;20289:6:0;;20216:87;28284:7:::2;-1:-1:-1::0;;;;;28256:27:0;::::2;::::0;28293:14;28256:27:::2;:52::i;:::-;-1:-1:-1::0;;17260:1:0;18214:7;:22;27985:331::o;28540:1033::-;17304:1;17902:7;;:19;;17894:63;;;;-1:-1:-1;;;17894:63:0;;;;;;;:::i;:::-;17304:1;18035:7;:18;;;28619:10:::1;28663:15:::0;;;:5:::1;:15;::::0;;;;;:28:::1;;::::0;28712:16;28704:35:::1;;;::::0;-1:-1:-1;;;28704:35:0;;4363:2:1;28704:35:0::1;::::0;::::1;4345:21:1::0;4402:1;4382:18;;;4375:29;-1:-1:-1;;;4420:18:1;;;4413:36;4466:18;;28704:35:0::1;4161:329:1::0;28704:35:0::1;28757:11;::::0;28750:56:::1;::::0;-1:-1:-1;;;;;28757:11:0::1;28783:8:::0;28793:12;28750:32:::1;:56::i;:::-;28848:21;:19;:21::i;:::-;28880;28904:20;28915:8;28904:10;:20::i;:::-;28880:44;;28956:12;28935:17;;:33;;;;;;;:::i;:::-;;;;;;;;29001:13;28979:18;;:35;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;29065:67:0;::::1;29102:15;::::0;;;:5:::1;:15;::::0;;;;;;;;:29;29065:67;;4931:25:1;;;4972:18;;;4965:34;29065:67:0::1;::::0;4904:18:1;29065:67:0::1;;;;;;;-1:-1:-1::0;;;;;29145:15:0;::::1;29176:1;29145:15:::0;;;:5:::1;:15;::::0;;;;:28:::1;::::0;;::::1;:32:::0;;;29188:33;;;29232:27:::1;::::0;;::::1;:35:::0;;-1:-1:-1;;29232:35:0::1;::::0;;29365:5:::1;:12:::0;:16:::1;::::0;29145:28;29365:16:::1;:::i;:::-;-1:-1:-1::0;;;;;29410:15:0;::::1;29392;29410::::0;;;:5:::1;:15;::::0;;;;;;:25:::1;;::::0;29452:5:::1;:21:::0;;29340:41;;-1:-1:-1;29410:25:0;;;;29392:15;29452:5;29340:41;;29452:21;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;;::::1;::::0;-1:-1:-1;;;;;29452:21:0::1;29446:28:::0;;;::::1;::::0;;;;;;;;:38:::1;;:48:::0;29522:5:::1;:21:::0;;29528:14;;29522:21;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;29505:5:::1;:14:::0;;-1:-1:-1;;;;;29522:21:0;;::::1;::::0;29511:7;;29505:14;::::1;;;;;:::i;:::-;;;;;;;;;:38;;;;;-1:-1:-1::0;;;;;29505:38:0::1;;;;;-1:-1:-1::0;;;;;29505:38:0::1;;;;;;29554:5;:11;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;-1:-1:-1;;29554:11:0;;;;;-1:-1:-1;;;;;;29554:11:0::1;::::0;;;;;;;;::::1;18214:22:::0;;-1:-1:-1;;;;;28540:1033:0:o;20867:103::-;20289:6;;-1:-1:-1;;;;;20289:6:0;19016:10;20436:23;20428:68;;;;-1:-1:-1;;;20428:68:0;;;;;;;:::i;:::-;20932:30:::1;20959:1;20932:18;:30::i;:::-;20867:103::o:0;22386:20::-;;;;;;;:::i;25646:258::-;-1:-1:-1;;;;;25868:16:0;;25706:7;25868:16;;;:5;:16;;;;;:26;;;25850:44;;:15;:44;:::i;:::-;-1:-1:-1;;;;;25817:16:0;;;;;;:5;:16;;;;;:29;;;:78;;;;:::i;:::-;-1:-1:-1;;;;;25783:16:0;;;;;;:5;:16;;;;;:30;:113;;;;:::i;:::-;25776:120;25646:258;-1:-1:-1;;25646:258:0:o;29707:1152::-;17304:1;17902:7;;:19;;17894:63;;;;-1:-1:-1;;;17894:63:0;;;;;;;:::i;:::-;17304:1;18035:7;:18;29780:11;29772:31:::1;;;::::0;-1:-1:-1;;;29772:31:0;;5782:2:1;29772:31:0::1;::::0;::::1;5764:21:1::0;5821:1;5801:18;;;5794:29;-1:-1:-1;;;5839:18:1;;;5832:37;5886:18;;29772:31:0::1;5580:330:1::0;29772:31:0::1;29910:11;::::0;29903:39:::1;::::0;-1:-1:-1;;;29903:39:0;;29835:10:::1;29903:39;::::0;::::1;1284:51:1::0;;;29835:10:0;29946:7;;-1:-1:-1;;;;;29910:11:0;;::::1;::::0;29903:29:::1;::::0;1257:18:1;;29903:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;29895:71;;;::::0;-1:-1:-1;;;29895:71:0;;4027:2:1;29895:71:0::1;::::0;::::1;4009:21:1::0;4066:1;4046:18;;;4039:29;-1:-1:-1;;;4084:18:1;;;4077:38;4132:18;;29895:71:0::1;3825:331:1::0;29895:71:0::1;29992:11;::::0;29985:54:::1;::::0;-1:-1:-1;;;29985:54:0;;-1:-1:-1;;;;;6145:15:1;;;29985:54:0::1;::::0;::::1;6127:34:1::0;30033:4:0::1;6177:18:1::0;;;6170:43;30043:7:0;;29992:11:::1;::::0;29985:29:::1;::::0;6062:18:1;;29985:54:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:65;;29977:87;;;::::0;-1:-1:-1;;;29977:87:0;;6426:2:1;29977:87:0::1;::::0;::::1;6408:21:1::0;6465:1;6445:18;;;6438:29;-1:-1:-1;;;6483:18:1;;;6476:39;6532:18;;29977:87:0::1;6224:332:1::0;29977:87:0::1;30082:11;::::0;30075:70:::1;::::0;-1:-1:-1;;;;;30082:11:0::1;30112:8:::0;30130:4:::1;30137:7:::0;30075:36:::1;:70::i;:::-;30158:21;:19;:21::i;:::-;30211:7;30190:17;;:28;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;30272:15:0;::::1;;::::0;;;:5:::1;:15;::::0;;;;:27:::1;;::::0;::::1;;30267:506;;30316:5;:20:::0;;::::1;::::0;;::::1;::::0;;;;;::::1;::::0;;-1:-1:-1;;;;;;30316:20:0::1;-1:-1:-1::0;;;;;30316:20:0;::::1;::::0;;::::1;::::0;;;-1:-1:-1;30351:15:0;;;:5:::1;30316:20;30351:15:::0;;;;:27:::1;::::0;::::1;:34:::0;;-1:-1:-1;;30351:34:0::1;::::0;::::1;::::0;;30428:15:::1;30400:25;::::0;;::::1;:43:::0;30532:12;;:16:::1;::::0;30316:20;30532:16:::1;:::i;:::-;-1:-1:-1::0;;;;;30504:15:0;::::1;;::::0;;;:5:::1;:15;::::0;;;;;;:25:::1;;:44:::0;;;;30568:29;;::::1;::::0;::::1;::::0;30589:7;1102:25:1;;1090:2;1075:18;;956:177;30568:29:0::1;;;;;;;;30267:506;;;30630:29;30650:8;30630:19;:29::i;:::-;30743:8;-1:-1:-1::0;;;;;30730:31:0::1;;30753:7;30730:31;;;;1102:25:1::0;;1090:2;1075:18;;956:177;30730:31:0::1;;;;;;;;30267:506;-1:-1:-1::0;;;;;30812:15:0;::::1;;::::0;;;:5:::1;:15;::::0;;;;:28:::1;;:39:::0;;30844:7;;30812:15;:39:::1;::::0;30844:7;;30812:39:::1;:::i;:::-;::::0;;;-1:-1:-1;;17260:1:0;18214:7;:22;-1:-1:-1;;29707:1152:0:o;26447:93::-;26491:16;26527:5;26520:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26520:12:0;;;;;;;;;;;;;;;;;;;;;;;26447:93;:::o;26144:155::-;26192:7;26280:9;;26262:15;:27;;;;:::i;:::-;26241:17;;:49;;;;:::i;:::-;26219:18;;:72;;;;:::i;:::-;26212:79;;26144:155;:::o;21125:201::-;20289:6;;-1:-1:-1;;;;;20289:6:0;19016:10;20436:23;20428:68;;;;-1:-1:-1;;;20428:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;21214:22:0;::::1;21206:73;;;::::0;-1:-1:-1;;;21206:73:0;;6763:2:1;21206:73:0::1;::::0;::::1;6745:21:1::0;6802:2;6782:18;;;6775:30;6841:34;6821:18;;;6814:62;-1:-1:-1;;;6892:18:1;;;6885:36;6938:19;;21206:73:0::1;6561:402:1::0;21206:73:0::1;21290:28;21309:8;21290:18;:28::i;:::-;21125:201:::0;:::o;12190:211::-;12334:58;;-1:-1:-1;;;;;7160:32:1;;12334:58:0;;;7142:51:1;7209:18;;;7202:34;;;12307:86:0;;12327:5;;-1:-1:-1;;;12357:23:0;7115:18:1;;12334:58:0;;;;-1:-1:-1;;12334:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;12334:58:0;-1:-1:-1;;;;;;12334:58:0;;;;;;;;;;12307:19;:86::i;:::-;12190:211;;;:::o;27371:237::-;27499:9;;27443:15;;27421:19;;27485:23;;27443:15;27485:23;:::i;:::-;27469:39;;27561:5;27541:17;;:25;;;;:::i;:::-;27519:18;;:47;;;;;;;:::i;:::-;;;;-1:-1:-1;;;27577:9:0;:23;27371:237::o;21486:191::-;21579:6;;;-1:-1:-1;;;;;21596:17:0;;;-1:-1:-1;;;;;;21596:17:0;;;;;;;21629:40;;21579:6;;;21596:17;21579:6;;21629:40;;21560:16;;21629:40;21549:128;21486:191;:::o;12409:248::-;12580:68;;-1:-1:-1;;;;;7505:15:1;;;12580:68:0;;;7487:34:1;7557:15;;7537:18;;;7530:43;7589:18;;;7582:34;;;12553:96:0;;12573:5;;-1:-1:-1;;;12603:27:0;7422:18:1;;12580:68:0;7247:375:1;12553:96:0;12409:248;;;;:::o;26781:334::-;-1:-1:-1;;;;;26872:16:0;;26848:21;26872:16;;;:5;:16;;;;;27006:17;;;;26988:14;;;;26872:16;;26924:15;;26848:21;;27006:17;26971:31;;26924:15;26971:31;:::i;:::-;26970:53;;;;:::i;:::-;26952:71;;27053:14;27036:4;:14;;:31;;;;27100:7;27078:4;:18;;;:29;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;26781:334:0:o;14763:716::-;15187:23;15213:69;15241:4;15213:69;;;;;;;;;;;;;;;;;15221:5;-1:-1:-1;;;;;15213:27:0;;;:69;;;;;:::i;:::-;15297:17;;15187:95;;-1:-1:-1;15297:21:0;15293:179;;15394:10;15383:30;;;;;;;;;;;;:::i;:::-;15375:85;;;;-1:-1:-1;;;15375:85:0;;8111:2:1;15375:85:0;;;8093:21:1;8150:2;8130:18;;;8123:30;8189:34;8169:18;;;8162:62;-1:-1:-1;;;8240:18:1;;;8233:40;8290:19;;15375:85:0;7909:406:1;6964:229:0;7101:12;7133:52;7155:6;7163:4;7169:1;7172:12;7133:21;:52::i;:::-;7126:59;;6964:229;;;;;;:::o;8084:510::-;8254:12;8312:5;8287:21;:30;;8279:81;;;;-1:-1:-1;;;8279:81:0;;8522:2:1;8279:81:0;;;8504:21:1;8561:2;8541:18;;;8534:30;8600:34;8580:18;;;8573:62;-1:-1:-1;;;8651:18:1;;;8644:36;8697:19;;8279:81:0;8320:402:1;8279:81:0;-1:-1:-1;;;;;4514:19:0;;;8371:60;;;;-1:-1:-1;;;8371:60:0;;8929:2:1;8371:60:0;;;8911:21:1;8968:2;8948:18;;;8941:30;9007:31;8987:18;;;8980:59;9056:18;;8371:60:0;8727:353:1;8371:60:0;8445:12;8459:23;8486:6;-1:-1:-1;;;;;8486:11:0;8505:5;8512:4;8486:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8444:73;;;;8535:51;8552:7;8561:10;8573:12;8535:16;:51::i;:::-;8528:58;8084:510;-1:-1:-1;;;;;;;8084:510:0:o;10770:712::-;10920:12;10949:7;10945:530;;;-1:-1:-1;10980:10:0;10973:17;;10945:530;11094:17;;:21;11090:374;;11292:10;11286:17;11353:15;11340:10;11336:2;11332:19;11325:44;11090:374;11435:12;11428:20;;-1:-1:-1;;;11428:20:0;;;;;;;;:::i;14:258:1:-;86:1;96:113;110:6;107:1;104:13;96:113;;;186:11;;;180:18;167:11;;;160:39;132:2;125:10;96:113;;;227:6;224:1;221:13;218:48;;;-1:-1:-1;;262:1:1;244:16;;237:27;14:258::o;277:383::-;426:2;415:9;408:21;389:4;458:6;452:13;501:6;496:2;485:9;481:18;474:34;517:66;576:6;571:2;560:9;556:18;551:2;543:6;539:15;517:66;:::i;:::-;644:2;623:15;-1:-1:-1;;619:29:1;604:45;;;;651:2;600:54;;277:383;-1:-1:-1;;277:383:1:o;665:286::-;724:6;777:2;765:9;756:7;752:23;748:32;745:52;;;793:1;790;783:12;745:52;819:23;;-1:-1:-1;;;;;871:31:1;;861:42;;851:70;;917:1;914;907:12;1346:180;1405:6;1458:2;1446:9;1437:7;1433:23;1429:32;1426:52;;;1474:1;1471;1464:12;1426:52;-1:-1:-1;1497:23:1;;1346:180;-1:-1:-1;1346:180:1:o;1531:658::-;1702:2;1754:21;;;1824:13;;1727:18;;;1846:22;;;1673:4;;1702:2;1925:15;;;;1899:2;1884:18;;;1673:4;1968:195;1982:6;1979:1;1976:13;1968:195;;;2047:13;;-1:-1:-1;;;;;2043:39:1;2031:52;;2138:15;;;;2103:12;;;;2079:1;1997:9;1968:195;;;-1:-1:-1;2180:3:1;;1531:658;-1:-1:-1;;;;;;1531:658:1:o;2194:380::-;2273:1;2269:12;;;;2316;;;2337:61;;2391:4;2383:6;2379:17;2369:27;;2337:61;2444:2;2436:6;2433:14;2413:18;2410:38;2407:161;;;2490:10;2485:3;2481:20;2478:1;2471:31;2525:4;2522:1;2515:15;2553:4;2550:1;2543:15;2407:161;;2194:380;;;:::o;2579:355::-;2781:2;2763:21;;;2820:2;2800:18;;;2793:30;2859:33;2854:2;2839:18;;2832:61;2925:2;2910:18;;2579:355::o;2939:356::-;3141:2;3123:21;;;3160:18;;;3153:30;3219:34;3214:2;3199:18;;3192:62;3286:2;3271:18;;2939:356::o;3636:184::-;3706:6;3759:2;3747:9;3738:7;3734:23;3730:32;3727:52;;;3775:1;3772;3765:12;3727:52;-1:-1:-1;3798:16:1;;3636:184;-1:-1:-1;3636:184:1:o;4495:127::-;4556:10;4551:3;4547:20;4544:1;4537:31;4587:4;4584:1;4577:15;4611:4;4608:1;4601:15;4627:125;4667:4;4695:1;4692;4689:8;4686:34;;;4700:18;;:::i;:::-;-1:-1:-1;4737:9:1;;4627:125::o;5010:127::-;5071:10;5066:3;5062:20;5059:1;5052:31;5102:4;5099:1;5092:15;5126:4;5123:1;5116:15;5142:127;5203:10;5198:3;5194:20;5191:1;5184:31;5234:4;5231:1;5224:15;5258:4;5255:1;5248:15;5274:168;5314:7;5380:1;5376;5372:6;5368:14;5365:1;5362:21;5357:1;5350:9;5343:17;5339:45;5336:71;;;5387:18;;:::i;:::-;-1:-1:-1;5427:9:1;;5274:168::o;5447:128::-;5487:3;5518:1;5514:6;5511:1;5508:13;5505:39;;;5524:18;;:::i;:::-;-1:-1:-1;5560:9:1;;5447:128::o;7627:277::-;7694:6;7747:2;7735:9;7726:7;7722:23;7718:32;7715:52;;;7763:1;7760;7753:12;7715:52;7795:9;7789:16;7848:5;7841:13;7834:21;7827:5;7824:32;7814:60;;7870:1;7867;7860:12;9085:274;9214:3;9252:6;9246:13;9268:53;9314:6;9309:3;9302:4;9294:6;9290:17;9268:53;:::i;:::-;9337:16;;;;;9085:274;-1:-1:-1;;9085:274:1:o

ipfs://887b5a1f70742e37f5729338ff6788f10d1065c5333bab7843a410c69eecede1