Contract 0x7fe25f98A1eAbae3254cC03BaE1e9a0294a4A665

/**
 *Submitted for verification at PolygonScan.com on 2022-04-14
*/

// SPDX-License-Identifier: MIT
// File: Stake.sol


pragma solidity ^0.8.2;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

/**
 * @title Owner
 * @dev Set & change owner
 */
contract Owner {

    address private owner;
    
    // event for EVM logging
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    // modifier to check if caller is owner
    modifier isOwner() {
        // If the first argument of 'require' evaluates to 'false', execution terminates and all
        // changes to the state and to Ether balances are reverted.
        // This used to consume all gas in old EVM versions, but not anymore.
        // It is often a good idea to use 'require' to check if functions are called correctly.
        // As a second argument, you can also provide an explanation about what went wrong.
        require(msg.sender == owner, "Caller is not owner");
        _;
    }
    
    /**
     * @dev Set contract deployer as owner
     */
    constructor(address _owner) {
        owner = _owner;
        emit OwnerSet(address(0), owner);
    }

    /**
     * @dev Change owner
     * @param newOwner address of new owner
     */
    function changeOwner(address newOwner) public isOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    /**
     * @dev Return owner address 
     * @return address of owner
     */
    function getOwner() public view returns (address) {
        return owner;
    }
}

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

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

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

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

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

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

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

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

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

/**
 * @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.zeppelin.solutions/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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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;
        _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;
        }
        _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 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 {}
}

/**
 * 
 * Stakes is an interest gain contract for ERC-20 tokens
 * 
 * assets is the ERC20 token
 * interest_rate: percentage rate
 * maturity is the time in seconds after which is safe to end the stake
 * penalization for ending a stake before maturity time
 * lower_amount is the minimum amount for creating a stake
 * 
 */
contract LCUVault is Owner, ReentrancyGuard {

    using SafeMath for uint256;

    // token    
    ERC20 public asset;

    // stakes history
    struct Record {
        uint256 from;
        uint256 amount;
        uint256 gain;
        uint256 penalization;
        uint256 to;
        bool ended;
    }

    // contract parameters
    uint8 public interest_rate;
    uint256 public maturity;
    uint8 public penalization;
    uint256 public lower_amount;

    mapping(address => Record[]) public ledger;

    event StakeStart(address indexed user, uint256 value, uint256 index);
    event StakeEnd(address indexed user, uint256 value, uint256 penalty, uint256 interest, uint256 index);
    
    constructor(ERC20 _erc20, address _owner, uint8 _rate, uint256 _maturity, uint8 _penalization, uint256 _lower) Owner(_owner) {
        require(_penalization<=100, "Penalty has to be an integer between 0 and 100");
        asset = _erc20;
        interest_rate = _rate;
        maturity = _maturity;
        penalization = _penalization;
        lower_amount = _lower;
    }
    
    function start(uint256 _value) external {
        require(_value >= lower_amount, "Invalid value");
        asset.transferFrom(msg.sender, address(this), _value);
        ledger[msg.sender].push(Record(block.timestamp, _value, 0, 0, 0, false));
        emit StakeStart(msg.sender, _value, ledger[msg.sender].length-1);
    }

    function end(uint256 i) external nonReentrant {

        require(i < ledger[msg.sender].length, "Invalid index");
        require(ledger[msg.sender][i].ended==false, "Invalid stake");
        
        // penalization
        if(block.timestamp.sub(ledger[msg.sender][i].from) < maturity) {
            uint256 _penalization = ledger[msg.sender][i].amount.mul(penalization).div(100);
            asset.transfer(msg.sender, ledger[msg.sender][i].amount.sub(_penalization));
            asset.transfer(getOwner(), _penalization);
            ledger[msg.sender][i].penalization = _penalization;
            ledger[msg.sender][i].to = block.timestamp;
            ledger[msg.sender][i].ended = true;
            emit StakeEnd(msg.sender, ledger[msg.sender][i].amount, _penalization, 0, i);
        // interest gained
        } else {
            uint256 _interest = get_gains(msg.sender, i);
            // check that the owner can pay interest before trying to pay
            if (asset.allowance(getOwner(), address(this)) >= _interest && asset.balanceOf(getOwner()) >= _interest) {
                asset.transferFrom(getOwner(), msg.sender, _interest);
            } else {
                _interest = 0;
            }
            asset.transfer(msg.sender, ledger[msg.sender][i].amount);
            ledger[msg.sender][i].gain = _interest;
            ledger[msg.sender][i].to = block.timestamp;
            ledger[msg.sender][i].ended = true;
            emit StakeEnd(msg.sender, ledger[msg.sender][i].amount, 0, _interest, i);
        }
    }

    function set(uint256 _lower, uint256 _maturity, uint8 _rate, uint8 _penalization) public isOwner {
        require(_penalization<=100, "Invalid value");
        lower_amount = _lower;
        maturity = _maturity;
        interest_rate = _rate;
        penalization = _penalization;
    }
    
    // calculate interest to the current date time
    function get_gains(address _address, uint256 _rec_number) public view returns (uint256) {
        uint256 _record_seconds = block.timestamp.sub(ledger[_address][_rec_number].from);
        uint256 _year_seconds = 365*24*60*60;
        return _record_seconds.mul(
            ledger[_address][_rec_number].amount.mul(interest_rate).div(100)
        ).div(_year_seconds);
    }

    function ledger_length(address _address) public view returns (uint256) {
        return ledger[_address].length;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ERC20","name":"_erc20","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint8","name":"_rate","type":"uint8"},{"internalType":"uint256","name":"_maturity","type":"uint256"},{"internalType":"uint8","name":"_penalization","type":"uint8"},{"internalType":"uint256","name":"_lower","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"penalty","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"interest","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"StakeEnd","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"StakeStart","type":"event"},{"inputs":[],"name":"asset","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"changeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"i","type":"uint256"}],"name":"end","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"uint256","name":"_rec_number","type":"uint256"}],"name":"get_gains","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"interest_rate","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"ledger","outputs":[{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"gain","type":"uint256"},{"internalType":"uint256","name":"penalization","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"bool","name":"ended","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"ledger_length","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lower_amount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maturity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"penalization","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lower","type":"uint256"},{"internalType":"uint256","name":"_maturity","type":"uint256"},{"internalType":"uint8","name":"_rate","type":"uint8"},{"internalType":"uint8","name":"_penalization","type":"uint8"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"start","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d6afbb6ee1b9ab0bd405714a8b231bc2f2345df4000000000000000000000000fe65593a05b0a28a0fede6efa127370a7cc73b8e000000000000000000000000000000000000000000000000000000000000005a0000000000000000000000000000000000000000000000000000000000ed4e00000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000010f0cf064dd59200000

-----Decoded View---------------
Arg [0] : _erc20 (address): 0xd6afbb6ee1b9ab0bd405714a8b231bc2f2345df4
Arg [1] : _owner (address): 0xfe65593a05b0a28a0fede6efa127370a7cc73b8e
Arg [2] : _rate (uint8): 90
Arg [3] : _maturity (uint256): 15552000
Arg [4] : _penalization (uint8): 1
Arg [5] : _lower (uint256): 5000000000000000000000

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000d6afbb6ee1b9ab0bd405714a8b231bc2f2345df4
Arg [1] : 000000000000000000000000fe65593a05b0a28a0fede6efa127370a7cc73b8e
Arg [2] : 000000000000000000000000000000000000000000000000000000000000005a
Arg [3] : 0000000000000000000000000000000000000000000000000000000000ed4e00
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : 00000000000000000000000000000000000000000000010f0cf064dd59200000

25700:3911:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27158:1573;;;;;;:::i;:::-;;:::i;:::-;;26153:27;;;;;;;;;6210:25:1;;;6198:2;6183:18;26153:27:0;;;;;;;;26091:23;;;;;;25806:18;;;;;-1:-1:-1;;;;;25806:18:0;;;;;;-1:-1:-1;;;;;2087:32:1;;;2069:51;;2057:2;2042:18;25806::0;2024:102:1;26121:25:0;;;;;;;;;;;;8029:4:1;8017:17;;;7999:36;;7987:2;7972:18;26121:25:0;7954:87:1;26189:42:0;;;;;;:::i;:::-;;:::i;:::-;;;;7588:25:1;;;7644:2;7629:18;;7622:34;;;;7672:18;;;7665:34;;;;7730:2;7715:18;;7708:34;7773:3;7758:19;;7751:35;7830:14;7823:22;7817:3;7802:19;;7795:51;7575:3;7560:19;26189:42:0;7542:310:1;6690:81:0;6731:7;6758:5;-1:-1:-1;;;;;6758:5:0;6690:81;;26821:329;;;;;;:::i;:::-;;:::i;6466:130::-;;;;;;:::i;:::-;;:::i;29486:120::-;;;;;;:::i;:::-;;:::i;29097:381::-;;;;;;:::i;:::-;;:::i;28739:294::-;;;;;;:::i;:::-;;:::i;26058:26::-;;;;;-1:-1:-1;;;26058:26:0;;;;;;27158:1573;8429:1;9027:7;;:19;;9019:63;;;;-1:-1:-1;;;9019:63:0;;5906:2:1;9019:63:0;;;5888:21:1;5945:2;5925:18;;;5918:30;5984:33;5964:18;;;5957:61;6035:18;;9019:63:0;;;;;;;;;8429:1;9160:7;:18;27236:10:::1;27229:18;::::0;;;:6:::1;:18;::::0;;;;:25;27225:29;::::1;27217:55;;;::::0;-1:-1:-1;;;27217:55:0;;4820:2:1;27217:55:0::1;::::0;::::1;4802:21:1::0;4859:2;4839:18;;;4832:30;-1:-1:-1;;;4878:18:1;;;4871:43;4931:18;;27217:55:0::1;4792:163:1::0;27217:55:0::1;27298:10;27291:18;::::0;;;:6:::1;:18;::::0;;;;:21;;27310:1;;27291:21;::::1;;;-1:-1:-1::0;;;27291:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;:27:::1;:21;::::0;;::::1;;:27;::::0;::::1;;:34;27283:60;;;::::0;-1:-1:-1;;;27283:60:0;;4130:2:1;27283:60:0::1;::::0;::::1;4112:21:1::0;4169:2;4149:18;;;4142:30;-1:-1:-1;;;4188:18:1;;;4181:43;4241:18;;27283:60:0::1;4102:163:1::0;27283:60:0::1;27442:8;::::0;27419:10:::1;27412:18;::::0;;;:6:::1;:18;::::0;;;;:21;;27392:47:::1;::::0;27412:18;27431:1;;27412:21;::::1;;;-1:-1:-1::0;;;27412:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:26:::0;27392:15:::1;::::0;:19:::1;:47::i;:::-;:58;27389:1335;;;27524:12;::::0;27498:10:::1;27467:21;27491:18:::0;;;:6:::1;:18;::::0;;;;:21;;27467;;27491:55:::1;::::0;27542:3:::1;::::0;27491:46:::1;::::0;27524:12:::1;;::::0;27510:1;;27491:21;::::1;;;-1:-1:-1::0;;;27491:21:0::1;;;;;;;;;;;;;;;;;;;:28;;;:32;;:46;;;;:::i;:::-;:50:::0;::::1;:55::i;:::-;27561:5;::::0;27576:10:::1;27561:5;27588:18:::0;;;:6:::1;:18;::::0;;;;:21;;27467:79;;-1:-1:-1;;;;;;27561:5:0;;::::1;::::0;:14:::1;::::0;27588:47:::1;::::0;27467:79;;27588:18;27607:1;;27588:21;::::1;;;-1:-1:-1::0;;;27588:21:0::1;;;;;;;;;;;;;;;;;;;:28;;;:32;;:47;;;;:::i;:::-;27561:75;::::0;-1:-1:-1;;;;;;27561:75:0::1;::::0;;;;;;-1:-1:-1;;;;;3012:32:1;;;27561:75:0::1;::::0;::::1;2994:51:1::0;3061:18;;;3054:34;2967:18;;27561:75:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;27651:5:0::1;::::0;-1:-1:-1;;;;;27651:5:0::1;:14;27666:10;6731:7:::0;6758:5;-1:-1:-1;;;;;6758:5:0;6690:81;;27666:10:::1;27651:41;::::0;-1:-1:-1;;;;;;27651:41:0::1;::::0;;;;;;-1:-1:-1;;;;;3012:32:1;;;27651:41:0::1;::::0;::::1;2994:51:1::0;3061:18;;;3054:34;;;2967:18;;27651:41:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;27714:10:0::1;27707:18;::::0;;;:6:::1;:18;::::0;;;;:21;;27744:13;;27707:18;27726:1;;27707:21;::::1;;;-1:-1:-1::0;;;27707:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:34;;:50:::0;;;;27779:10:::1;27772:18:::0;;;;;;;;:21;;27799:15:::1;::::0;27772:18;27791:1;;27772:21;::::1;;;-1:-1:-1::0;;;27772:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:24;;:42:::0;;;;27836:10:::1;27829:18:::0;;;;;;;;:21;;27859:4:::1;::::0;27829:18;27848:1;;27829:21;::::1;;;-1:-1:-1::0;;;27829:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:27;;:34:::0;;-1:-1:-1;;27829:34:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;27892:10:::1;27904:18:::0;;;;;;;;:21;;27883:71:::1;::::0;27904:18;27923:1;;27904:21;::::1;;;-1:-1:-1::0;;;27904:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;:28:::1;:21;::::0;;::::1;;:28;::::0;27883:71:::1;::::0;::::1;::::0;27934:13;;27952:1;;6485:25:1;;;6541:2;6526:18;;6519:34;;;;6584:2;6569:18;;6562:34;6627:2;6612:18;;6605:34;6472:3;6457:19;;6439:206;27883:71:0::1;;;;;;;;27389:1335;;;;28015:17;28035:24;28045:10;28057:1;28035:9;:24::i;:::-;28153:5;::::0;28015:44;;-1:-1:-1;28015:44:0;;-1:-1:-1;;;;;28153:5:0::1;:15;28169:10;6731:7:::0;6758:5;-1:-1:-1;;;;;6758:5:0;6690:81;;28169:10:::1;28153:42;::::0;-1:-1:-1;;;;;;28153:42:0::1;::::0;;;;;;-1:-1:-1;;;;;2361:15:1;;;28153:42:0::1;::::0;::::1;2343:34:1::0;28189:4:0::1;2393:18:1::0;;;2386:43;2278:18;;28153:42:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:55;;:99;;;;-1:-1:-1::0;28212:5:0::1;::::0;28243:9;;-1:-1:-1;;;;;28212:5:0::1;:15;28228:10;6731:7:::0;6758:5;-1:-1:-1;;;;;6758:5:0;6690:81;;28228:10:::1;28212:27;::::0;-1:-1:-1;;;;;;28212:27:0::1;::::0;;;;;;-1:-1:-1;;;;;2087:32:1;;;28212:27:0::1;::::0;::::1;2069:51:1::0;2042:18;;28212:27:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;;28153:99;28149:247;;;28273:5;::::0;-1:-1:-1;;;;;28273:5:0::1;:18;28292:10;6731:7:::0;6758:5;-1:-1:-1;;;;;6758:5:0;6690:81;;28292:10:::1;28273:53;::::0;-1:-1:-1;;;;;;28273:53:0::1;::::0;;;;;;-1:-1:-1;;;;;2698:15:1;;;28273:53:0::1;::::0;::::1;2680:34:1::0;28304:10:0::1;2730:18:1::0;;;2723:43;2782:18;;;2775:34;;;2615:18;;28273:53:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;28149:247;;;-1:-1:-1::0;28379:1:0::1;28149:247;28410:5;::::0;28425:10:::1;28410:5;28437:18:::0;;;:6:::1;:18;::::0;;;;:21;;-1:-1:-1;;;;;28410:5:0;;::::1;::::0;:14:::1;::::0;28425:10;28437:18;28456:1;;28437:21;::::1;;;-1:-1:-1::0;;;28437:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;:28:::1;:21;::::0;;::::1;;:28;::::0;28410:56:::1;::::0;-1:-1:-1;;;;;;28410:56:0::1;::::0;;;;;;-1:-1:-1;;;;;3012:32:1;;;28410:56:0::1;::::0;::::1;2994:51:1::0;3061:18;;;3054:34;2967:18;;28410:56:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;28488:10:0::1;28481:18;::::0;;;:6:::1;:18;::::0;;;;:21;;28510:9;;28481:18;28500:1;;28481:21;::::1;;;-1:-1:-1::0;;;28481:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:26;;:38:::0;;;;28541:10:::1;28534:18:::0;;;;;;;;:21;;28561:15:::1;::::0;28534:18;28553:1;;28534:21;::::1;;;-1:-1:-1::0;;;28534:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:24;;:42:::0;;;;28598:10:::1;28591:18:::0;;;;;;;;:21;;28621:4:::1;::::0;28591:18;28610:1;;28591:21;::::1;;;-1:-1:-1::0;;;28591:21:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:27;;:34:::0;;-1:-1:-1;;28591:34:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;28654:10:::1;28666:18:::0;;;;;;;;:21;;28645:67:::1;::::0;28666:18;28685:1;;28666:21;::::1;;;-1:-1:-1::0;;;28666:21:0::1;;;;;;;;;;;;;;;;;;;:28;;;28696:1;28699:9;28710:1;28645:67;;;;;;;;6485:25:1::0;;;6541:2;6526:18;;6519:34;;;;6584:2;6569:18;;6562:34;6627:2;6612:18;;6605:34;6472:3;6457:19;;6439:206;28645:67:0::1;;;;;;;;27389:1335;;-1:-1:-1::0;8385:1:0;9339:22;;27158:1573::o;26189:42::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26189:42:0;;-1:-1:-1;26189:42:0;;;;;;:::o;26821:329::-;26890:12;;26880:6;:22;;26872:48;;;;-1:-1:-1;;;26872:48:0;;5564:2:1;26872:48:0;;;5546:21:1;5603:2;5583:18;;;5576:30;-1:-1:-1;;;5622:18:1;;;5615:43;5675:18;;26872:48:0;5536:163:1;26872:48:0;26931:5;;:53;;-1:-1:-1;;;26931:53:0;;26950:10;26931:53;;;2680:34:1;26970:4:0;2730:18:1;;;2723:43;2782:18;;;2775:34;;;-1:-1:-1;;;;;26931:5:0;;;;:18;;2615::1;;26931:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;27002:10:0;26995:18;;;;:6;:18;;;;;;;;27019:47;;;;;;;27026:15;27019:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26995:72;;27019:47;26995:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;26995:72:0;;;;;;;;;;;27114:18;;;;;;;:25;;27083:59;;27019:47;;27114:27;;27019:47;27114:27;:::i;:::-;27083:59;;;6824:25:1;;;6880:2;6865:18;;6858:34;;;;6797:18;27083:59:0;;;;;;;26821:329;:::o;6466:130::-;6142:5;;-1:-1:-1;;;;;6142:5:0;6128:10;:19;6120:51;;;;-1:-1:-1;;;6120:51:0;;4472:2:1;6120:51:0;;;4454:21:1;4511:2;4491:18;;;4484:30;-1:-1:-1;;;4530:18:1;;;4523:49;4589:18;;6120:51:0;4444:169:1;6120:51:0;6545:5:::1;::::0;;6536:25:::1;::::0;-1:-1:-1;;;;;6536:25:0;;::::1;::::0;6545:5;::::1;::::0;6536:25:::1;::::0;::::1;6572:5;:16:::0;;-1:-1:-1;;;;;;6572:16:0::1;-1:-1:-1::0;;;;;6572:16:0;;;::::1;::::0;;;::::1;::::0;;6466:130::o;29486:120::-;-1:-1:-1;;;;;29575:16:0;;29548:7;29575:16;;;:6;:16;;;;;:23;29486:120;;;;:::o;29097:381::-;-1:-1:-1;;;;;29242:16:0;;29176:7;29242:16;;;:6;:16;;;;;:29;;29176:7;;29222:55;;29259:11;;29242:29;;;;-1:-1:-1;;;29242:29:0;;;;;;;;29222:55;29196:81;;29288:21;29312:12;29288:36;;29342:128;29456:13;29342:109;29376:64;29436:3;29376:55;29417:13;;;;;;;;;;;29376:55;;:6;:16;29383:8;-1:-1:-1;;;;;29376:16:0;-1:-1:-1;;;;;29376:16:0;;;;;;;;;;;;29393:11;29376:29;;;;;;-1:-1:-1;;;29376:29:0;;;;;;;;:64;29342:15;;:19;:109::i;:128::-;29335:135;;;;29097:381;;;;;:::o;28739:294::-;6142:5;;-1:-1:-1;;;;;6142:5:0;6128:10;:19;6120:51;;;;-1:-1:-1;;;6120:51:0;;4472:2:1;6120:51:0;;;4454:21:1;4511:2;4491:18;;;4484:30;-1:-1:-1;;;4530:18:1;;;4523:49;4589:18;;6120:51:0;4444:169:1;6120:51:0;28870:3:::1;28855:13;:18;;;;28847:44;;;::::0;-1:-1:-1;;;28847:44:0;;5564:2:1;28847:44:0::1;::::0;::::1;5546:21:1::0;5603:2;5583:18;;;5576:30;-1:-1:-1;;;5622:18:1;;;5615:43;5675:18;;28847:44:0::1;5536:163:1::0;28847:44:0::1;28902:12;:21:::0;;;;28934:8:::1;:20:::0;;;;-1:-1:-1;28965:21:0;;-1:-1:-1;;;;28965:21:0::1;-1:-1:-1::0;;;28965:21:0::1;::::0;;::::1;;;::::0;;28997:12:::1;:28:::0;;-1:-1:-1;;28997:28:0::1;::::0;;;::::1;;::::0;;28739:294::o;1372:136::-;1430:7;1457:43;1461:1;1464;1457:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1450:50;1372:136;-1:-1:-1;;;1372:136:0:o;2246:471::-;2304:7;2549:6;2545:47;;-1:-1:-1;2579:1:0;2572:8;;2545:47;2604:9;2616:5;2620:1;2616;:5;:::i;:::-;2604:17;-1:-1:-1;2649:1:0;2640:5;2644:1;2604:17;2640:5;:::i;:::-;:10;2632:56;;;;-1:-1:-1;;;2632:56:0;;5162:2:1;2632:56:0;;;5144:21:1;5201:2;5181:18;;;5174:30;5240:34;5220:18;;;5213:62;-1:-1:-1;;;5291:18:1;;;5284:31;5332:19;;2632:56:0;5134:223:1;3185:132:0;3243:7;3270:39;3274:1;3277;3270:39;;;;;;;;;;;;;;;;;:3;:39::i;1803:192::-;1889:7;1925:12;1917:6;;;;1909:29;;;;-1:-1:-1;;;1909:29:0;;;;;;;;:::i;:::-;-1:-1:-1;1949:9:0;1961:5;1965:1;1961;:5;:::i;:::-;1949:17;1803:192;-1:-1:-1;;;;;1803:192:0:o;3805:345::-;3891:7;3993:12;3986:5;3978:28;;;;-1:-1:-1;;;3978:28:0;;;;;;;;:::i;:::-;-1:-1:-1;4017:9:0;4029:5;4033:1;4029;:5;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;192:156;258:20;;318:4;307:16;;297:27;;287:2;;338:1;335;328:12;353:196;;465:2;453:9;444:7;440:23;436:32;433:2;;;486:6;478;471:22;433:2;514:29;533:9;514:29;:::i;554:264::-;;;683:2;671:9;662:7;658:23;654:32;651:2;;;704:6;696;689:22;651:2;732:29;751:9;732:29;:::i;:::-;722:39;808:2;793:18;;;;780:32;;-1:-1:-1;;;641:177:1:o;823:297::-;;943:2;931:9;922:7;918:23;914:32;911:2;;;964:6;956;949:22;911:2;1001:9;995:16;1054:5;1047:13;1040:21;1033:5;1030:32;1020:2;;1081:6;1073;1066:22;1125:190;;1237:2;1225:9;1216:7;1212:23;1208:32;1205:2;;;1258:6;1250;1243:22;1205:2;-1:-1:-1;1286:23:1;;1195:120;-1:-1:-1;1195:120:1:o;1320:194::-;;1443:2;1431:9;1422:7;1418:23;1414:32;1411:2;;;1464:6;1456;1449:22;1411:2;-1:-1:-1;1492:16:1;;1401:113;-1:-1:-1;1401:113:1:o;1519:399::-;;;;;1678:3;1666:9;1657:7;1653:23;1649:33;1646:2;;;1700:6;1692;1685:22;1646:2;1741:9;1728:23;1718:33;;1798:2;1787:9;1783:18;1770:32;1760:42;;1821:36;1853:2;1842:9;1838:18;1821:36;:::i;:::-;1811:46;;1876:36;1908:2;1897:9;1893:18;1876:36;:::i;:::-;1866:46;;1636:282;;;;;;;:::o;3320:603::-;;3461:2;3490;3479:9;3472:21;3522:6;3516:13;3565:6;3560:2;3549:9;3545:18;3538:34;3590:4;3603:140;3617:6;3614:1;3611:13;3603:140;;;3712:14;;;3708:23;;3702:30;3678:17;;;3697:2;3674:26;3667:66;3632:10;;3603:140;;;3761:6;3758:1;3755:13;3752:2;;;3831:4;3826:2;3817:6;3806:9;3802:22;3798:31;3791:45;3752:2;-1:-1:-1;3907:2:1;3886:15;-1:-1:-1;;3882:29:1;3867:45;;;;3914:2;3863:54;;3441:482;-1:-1:-1;;;3441:482:1:o;8046:217::-;;8112:1;8102:2;;-1:-1:-1;;;8137:31:1;;8191:4;8188:1;8181:15;8219:4;8144:1;8209:15;8102:2;-1:-1:-1;8248:9:1;;8092:171::o;8268:168::-;;8374:1;8370;8366:6;8362:14;8359:1;8356:21;8351:1;8344:9;8337:17;8333:45;8330:2;;;8381:18;;:::i;:::-;-1:-1:-1;8421:9:1;;8320:116::o;8441:125::-;;8509:1;8506;8503:8;8500:2;;;8514:18;;:::i;:::-;-1:-1:-1;8551:9:1;;8490:76::o;8571:127::-;8632:10;8627:3;8623:20;8620:1;8613:31;8663:4;8660:1;8653:15;8687:4;8684:1;8677:15

ipfs://62239bf76ca1d1b4f42e383a6fa9353e5a00ca1e88563d1be8d4c79e53db89b8