Contract 0xA242636a9A4c879824568DA87C40be91c6727432

/**
 *Submitted for verification at polygonscan.com on 2021-12-20
*/

/**
 *Submitted for verification at Etherscan.io on 2021-05-28
*/

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;

/**
 * @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() {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        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 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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


/**
 * @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 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 guidelines: functions revert instead
 * of 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 defaut 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");
        _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");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(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:
     *
     * - `to` 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);
    }

    /**
     * @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");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(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 to 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 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;
    }
}

/**
 * @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 make 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 Contract for Staking ERC-20 Tokens and pay interest on real time
 */
contract StakeContract is Owner, ReentrancyGuard {

    // safe uint256
    using SafeMath for uint256;
    
    // the token to be used for staking
    ERC20 public token;

    // Annual Percentage Yield
    uint8 public APY;

    // minimum stake time in seconds, if the user withdraws before this time a penalty will be charged
    uint256 public minimumStakeTime;

    // the penalty, a number between 0 and 100
    uint8 public penalty;

    // penalties are collected and stored by the contract
    uint256 private collectedPenalty;

    // the Stake
    struct Stake {
        // opening timestamp
        uint256 startDate;
        // amount staked
    	uint256 amount;
        // interest accrued, this will be available only after closing stake
    	uint256 interest;
        // penalty charged, if any
    	uint256 penalty;
        // closing timestamp
    	uint256 finishedDate;
        // is closed or not
    	bool closed;
    }

    // stakes that the owner have    
    mapping(address => Stake[]) private stakesOfOwner;
    
    // all accounts that have or have had stakes, this for the owner to be able to query stakes
    address[] private ownersAccounts;
    
    // @param _apy: APY 0 to 100
    // @param _mst: minimum stake time in seconds
    // @param _penalty: the penalty percentage 0 to 100
    // @_token: the ERC20 token to be used
    constructor(uint8 _apy, uint256 _mst, uint8 _penalty, ERC20 _token) {
        token = _token;
        require(_apy<=100, "APY has to be lower or equal than 100");
        require(_penalty<=100, "Penalty has to be lower or equal than 100");
        APY = _apy;
        minimumStakeTime = _mst;
        penalty = _penalty;
    }
    
    // owner can change the basic parameters of the contract
    // interest will be recalculated in real time for all accounts if changed
    function modifyAnnualInterestRatePercentage(uint8 _newVal) external isOwner {
        APY = _newVal;
    }
    function modifyMinimumStakeTime(uint256 _newVal) external isOwner {
        minimumStakeTime = _newVal;
    }
    function modifyPenalty(uint8 _newVal) external isOwner {
        penalty = _newVal;
    }

    // owner can query all stake accounts holders
    function queryOwnersAccounts() external view isOwner returns (address[] memory) {
    	return ownersAccounts;
    }

    function calculateInterest(address _ownerAccount, uint256 i) private view returns (uint256) {

        // APY per year = amount * APY / 100 / seconds of the year
        uint256 interest_per_year = stakesOfOwner[_ownerAccount][i].amount.mul(APY).div(100);

        // number of seconds since opening date
        uint256 num_seconds = block.timestamp.sub(stakesOfOwner[_ownerAccount][i].startDate);

        // calculate interest by a rule of three
        //  seconds of the year: 31536000 = 365*24*60*60
        //  interest_per_year   -   31536000
        //  interest            -   num_seconds
        //  interest = num_seconds * interest_per_year / 31536000
        return num_seconds.mul(interest_per_year).div(31536000);

    }

    // stake holders or owner can query the stakes
    function queryStakesOfOwner(address _ownerAccount) external view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
        // sender is querying their own account, or owner is querying stakes
        require(msg.sender==_ownerAccount || msg.sender==getOwner(), "You dont have permission");

        // create arrays to return results
        uint256[] memory startDate_r = new uint256[](stakesOfOwner[_ownerAccount].length);
    	uint256[] memory amount_r = new uint256[](stakesOfOwner[_ownerAccount].length);
    	uint256[] memory interest_r = new uint256[](stakesOfOwner[_ownerAccount].length);
    	uint256[] memory penalty_r = new uint256[](stakesOfOwner[_ownerAccount].length);
    	uint256[] memory finishedDate_r = new uint256[](stakesOfOwner[_ownerAccount].length);
    	bool[] memory closed_r = new bool[](stakesOfOwner[_ownerAccount].length);

        // loop the stakes and store them in the array of results
        for(uint256 i=0; i<stakesOfOwner[_ownerAccount].length; i++){
            startDate_r[i] = stakesOfOwner[_ownerAccount][i].startDate;
            amount_r[i] = stakesOfOwner[_ownerAccount][i].amount;
            
            // if the stake is closed return the interest, otherwise calculate it in real time
            if(stakesOfOwner[_ownerAccount][i].closed == true){
                interest_r[i] = stakesOfOwner[_ownerAccount][i].interest;
            }else{
                // calculate interest
                interest_r[i] = calculateInterest(_ownerAccount, i);
            }
            
            penalty_r[i] = stakesOfOwner[_ownerAccount][i].penalty;
            finishedDate_r[i] = stakesOfOwner[_ownerAccount][i].finishedDate;
            closed_r[i] = stakesOfOwner[_ownerAccount][i].closed;
        }
    	return (startDate_r, amount_r, interest_r, penalty_r, finishedDate_r, closed_r);
    }
    
    // anyone can create a stake
    function createStake(uint256 amount) external {
        // store the tokens of the user in the contract
        // requires approve
		token.transferFrom(msg.sender, address(this), amount);
        // store the account of the staker in ownersAccounts if it doesnt exists
		if(stakesOfOwner[msg.sender].length == 0){
		    ownersAccounts.push(msg.sender);
		}
        // create the stake
        stakesOfOwner[msg.sender].push(Stake(block.timestamp, amount, 0, 0, 0, false));
    }

    // finalize the stake and pay interest or charge penalty accordingly
    // arrayIndex: is the id of the stake to be finalized
    function withdrawStake(uint256 arrayIndex) external nonReentrant {

        // Stake should exists and opened
        require(arrayIndex < stakesOfOwner[msg.sender].length, "Stake does not exist");
        require(stakesOfOwner[msg.sender][arrayIndex].closed==false, "This stake is closed");
        
        // charge penalty if below minimum stake time
        if(block.timestamp.sub(stakesOfOwner[msg.sender][arrayIndex].startDate) < minimumStakeTime){

            // calculate penalty = amount * penalty / 100
            uint256 the_penalty = stakesOfOwner[msg.sender][arrayIndex].amount.mul(penalty).div(100);

            // remaining amount= amount - penaty
            uint256 amountToWithdraw = stakesOfOwner[msg.sender][arrayIndex].amount.sub(the_penalty);
            
            // transfer remaining
            token.transfer(msg.sender, amountToWithdraw);

            // penalty funds are hold by the contract, but keep the account of how much is it here
            collectedPenalty = collectedPenalty.add(the_penalty);
            
            // store the results in the stakes array of the user
            stakesOfOwner[msg.sender][arrayIndex].penalty = the_penalty;
            stakesOfOwner[msg.sender][arrayIndex].finishedDate = block.timestamp;
            stakesOfOwner[msg.sender][arrayIndex].closed = true;
        
        // pay interest if above or equal minimum stake time
        }else{

            // get the interest
            uint256 interest = calculateInterest(msg.sender, arrayIndex);

            // transfer the interes from owner account, it has to have enough funds approved
            token.transferFrom(getOwner(), msg.sender, interest);

            // transfer the amount from the contract itself
            token.transfer(msg.sender, stakesOfOwner[msg.sender][arrayIndex].amount);
            
            // record the transaction
            stakesOfOwner[msg.sender][arrayIndex].interest = interest;
            stakesOfOwner[msg.sender][arrayIndex].finishedDate = block.timestamp;
            stakesOfOwner[msg.sender][arrayIndex].closed = true;

        }
    }

    // owner can query and collect the penalty stored in the contract
    function queryCollectedPenalty() external view isOwner returns (uint256) {
    	return collectedPenalty;
    }
    function withdrawPenalty() external isOwner nonReentrant {
    	token.transfer(msg.sender, collectedPenalty);
    	collectedPenalty = 0;
    }
    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint8","name":"_apy","type":"uint8"},{"internalType":"uint256","name":"_mst","type":"uint256"},{"internalType":"uint8","name":"_penalty","type":"uint8"},{"internalType":"contract ERC20","name":"_token","type":"address"}],"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"},{"inputs":[],"name":"APY","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"changeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"createStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minimumStakeTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"_newVal","type":"uint8"}],"name":"modifyAnnualInterestRatePercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newVal","type":"uint256"}],"name":"modifyMinimumStakeTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"_newVal","type":"uint8"}],"name":"modifyPenalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"penalty","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"queryCollectedPenalty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"queryOwnersAccounts","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_ownerAccount","type":"address"}],"name":"queryStakesOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bool[]","name":"","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawPenalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"arrayIndex","type":"uint256"}],"name":"withdrawStake","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b5060405162001a1738038062001a178339810160408190526200003491620001ae565b600080546001600160a01b0319163390811782556040519091907f342827c97908e5e2f71151c08502a66d44b6f758e3ac2f1de95f02eb95f0a735908290a360018055600280546001600160a01b0319166001600160a01b038316179055606460ff85161115620000fa5760405162461bcd60e51b815260206004820152602560248201527f4150592068617320746f206265206c6f776572206f7220657175616c2074686160448201526406e203130360dc1b60648201526084015b60405180910390fd5b60648260ff161115620001625760405162461bcd60e51b815260206004820152602960248201527f50656e616c74792068617320746f206265206c6f776572206f7220657175616c6044820152680207468616e203130360bc1b6064820152608401620000f1565b506002805460ff60a01b1916600160a01b60ff958616021790556003919091556004805460ff19169190921617905562000210565b805160ff81168114620001a957600080fd5b919050565b60008060008060808587031215620001c557600080fd5b620001d08562000197565b935060208501519250620001e76040860162000197565b60608601519092506001600160a01b03811681146200020557600080fd5b939692955090935050565b6117f780620002206000396000f3fe608060405234801561001057600080fd5b50600436106100f55760003560e01c8063893d20e811610097578063ad76a27411610066578063ad76a274146101e0578063b5b11683146101f3578063ef8bd30514610218578063fc0c546a1461022c57600080fd5b8063893d20e8146101805780638e688575146101a55780639403ac38146101ba578063a6f9dae1146101cd57600080fd5b8063242df9e1116100d3578063242df9e11461013b57806325d5971f146101525780633fdfdb1f1461016557806358531eb51461017857600080fd5b80630edd2ffc146100fa5780631a1ce2fc1461011e5780631bf6ddae14610128575b600080fd5b6004546101079060ff1681565b60405160ff90911681526020015b60405180910390f35b61012661023f565b005b610126610136366004611504565b61035e565b61014460035481565b604051908152602001610115565b610126610160366004611504565b6104cb565b610126610173366004611504565b610a78565b610144610aa7565b6000546001600160a01b03165b6040516001600160a01b039091168152602001610115565b6101ad610ad9565b604051610115919061157b565b6101266101c836600461151d565b610b66565b6101266101db3660046114b9565b610ba6565b6101266101ee36600461151d565b610c2b565b6102066102013660046114b9565b610c75565b604051610115969594939291906115c8565b60025461010790600160a01b900460ff1681565b60025461018d906001600160a01b031681565b6000546001600160a01b031633146102725760405162461bcd60e51b8152600401610269906116c7565b60405180910390fd5b600260015414156102c55760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610269565b600260018190555460055460405163a9059cbb60e01b815233600482015260248101919091526001600160a01b039091169063a9059cbb90604401602060405180830381600087803b15801561031a57600080fd5b505af115801561032e573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061035291906114e2565b50600060055560018055565b6002546040516323b872dd60e01b8152336004820152306024820152604481018390526001600160a01b03909116906323b872dd90606401602060405180830381600087803b1580156103b057600080fd5b505af11580156103c4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103e891906114e2565b503360009081526006602052604090205461044057600780546001810182556000919091527fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c6880180546001600160a01b031916331790555b336000908152600660208181526040808420815160c081018352428152808401968752918201858152606083018681526080840187815260a08501888152845460018082018755958a52969098209451959096029093019384559551908301559351600282015592516003840155516004830155516005909101805460ff1916911515919091179055565b6002600154141561051e5760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610269565b60026001553360009081526006602052604090205481106105785760405162461bcd60e51b815260206004820152601460248201527314dd185ad948191bd95cc81b9bdd08195e1a5cdd60621b6044820152606401610269565b33600090815260066020526040902080548290811061059957610599611795565b600091825260209091206005600690920201015460ff16156105f45760405162461bcd60e51b8152602060048201526014602482015273151a1a5cc81cdd185ad9481a5cc818db1bdcd95960621b6044820152606401610269565b600354336000908152600660205260409020805461063591908490811061061d5761061d611795565b60009182526020909120600690910201544290611241565b10156108385760045433600090815260066020526040812080549192610696926064926106909260ff16918790811061067057610670611795565b90600052602060002090600602016001015461128c90919063ffffffff16565b9061130b565b336000908152600660205260408120805492935090916106e2918491869081106106c2576106c2611795565b90600052602060002090600602016001015461124190919063ffffffff16565b60025460405163a9059cbb60e01b8152336004820152602481018390529192506001600160a01b03169063a9059cbb90604401602060405180830381600087803b15801561072f57600080fd5b505af1158015610743573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061076791906114e2565b50600554610775908361134d565b60055533600090815260066020526040902080548391908590811061079c5761079c611795565b6000918252602080832060069283020160030193909355338252909152604090208054429190859081106107d2576107d2611795565b6000918252602080832060069283020160040193909355338252909152604090208054600191908590811061080957610809611795565b906000526020600020906006020160050160006101000a81548160ff0219169083151502179055505050610a71565b600061084433836113ac565b6002549091506001600160a01b03166323b872dd61086a6000546001600160a01b031690565b6040516001600160e01b031960e084901b1681526001600160a01b03909116600482015233602482015260448101849052606401602060405180830381600087803b1580156108b857600080fd5b505af11580156108cc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108f091906114e2565b5060025433600081815260066020526040902080546001600160a01b039093169263a9059cbb9291908690811061092957610929611795565b60009182526020909120600160069092020101546040516001600160e01b031960e085901b1681526001600160a01b0390921660048301526024820152604401602060405180830381600087803b15801561098357600080fd5b505af1158015610997573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109bb91906114e2565b503360009081526006602052604090208054829190849081106109e0576109e0611795565b600091825260208083206006928302016002019390935533825290915260409020805442919084908110610a1657610a16611795565b60009182526020808320600692830201600401939093553382529091526040902080546001919084908110610a4d57610a4d611795565b60009182526020909120600690910201600501805460ff1916911515919091179055505b5060018055565b6000546001600160a01b03163314610aa25760405162461bcd60e51b8152600401610269906116c7565b600355565b600080546001600160a01b03163314610ad25760405162461bcd60e51b8152600401610269906116c7565b5060055490565b6000546060906001600160a01b03163314610b065760405162461bcd60e51b8152600401610269906116c7565b6007805480602002602001604051908101604052809291908181526020018280548015610b5c57602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311610b3e575b5050505050905090565b6000546001600160a01b03163314610b905760405162461bcd60e51b8152600401610269906116c7565b6004805460ff191660ff92909216919091179055565b6000546001600160a01b03163314610bd05760405162461bcd60e51b8152600401610269906116c7565b600080546040516001600160a01b03808516939216917f342827c97908e5e2f71151c08502a66d44b6f758e3ac2f1de95f02eb95f0a73591a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b6000546001600160a01b03163314610c555760405162461bcd60e51b8152600401610269906116c7565b6002805460ff909216600160a01b0260ff60a01b19909216919091179055565b60608080808080336001600160a01b0388161480610c9d57506000546001600160a01b031633145b610ce95760405162461bcd60e51b815260206004820152601860248201527f596f7520646f6e742068617665207065726d697373696f6e00000000000000006044820152606401610269565b6001600160a01b03871660009081526006602052604081205467ffffffffffffffff811115610d1a57610d1a6117ab565b604051908082528060200260200182016040528015610d43578160200160208202803683370190505b506001600160a01b0389166000908152600660205260408120549192509067ffffffffffffffff811115610d7957610d796117ab565b604051908082528060200260200182016040528015610da2578160200160208202803683370190505b506001600160a01b038a166000908152600660205260408120549192509067ffffffffffffffff811115610dd857610dd86117ab565b604051908082528060200260200182016040528015610e01578160200160208202803683370190505b506001600160a01b038b166000908152600660205260408120549192509067ffffffffffffffff811115610e3757610e376117ab565b604051908082528060200260200182016040528015610e60578160200160208202803683370190505b506001600160a01b038c166000908152600660205260408120549192509067ffffffffffffffff811115610e9657610e966117ab565b604051908082528060200260200182016040528015610ebf578160200160208202803683370190505b506001600160a01b038d166000908152600660205260408120549192509067ffffffffffffffff811115610ef557610ef56117ab565b604051908082528060200260200182016040528015610f1e578160200160208202803683370190505b50905060005b6001600160a01b038e1660009081526006602052604090205481101561122c576001600160a01b038e166000908152600660205260409020805482908110610f6e57610f6e611795565b906000526020600020906006020160000154878281518110610f9257610f92611795565b602002602001018181525050600660008f6001600160a01b03166001600160a01b031681526020019081526020016000208181548110610fd457610fd4611795565b906000526020600020906006020160010154868281518110610ff857610ff8611795565b602002602001018181525050600660008f6001600160a01b03166001600160a01b03168152602001908152602001600020818154811061103a5761103a611795565b600091825260209091206005600690920201015460ff161515600114156110ba576001600160a01b038e16600090815260066020526040902080548290811061108557611085611795565b9060005260206000209060060201600201548582815181106110a9576110a9611795565b6020026020010181815250506110e3565b6110c48e826113ac565b8582815181106110d6576110d6611795565b6020026020010181815250505b6001600160a01b038e16600090815260066020526040902080548290811061110d5761110d611795565b90600052602060002090600602016003015484828151811061113157611131611795565b602002602001018181525050600660008f6001600160a01b03166001600160a01b03168152602001908152602001600020818154811061117357611173611795565b90600052602060002090600602016004015483828151811061119757611197611795565b602002602001018181525050600660008f6001600160a01b03166001600160a01b0316815260200190815260200160002081815481106111d9576111d9611795565b906000526020600020906006020160050160009054906101000a900460ff1682828151811061120a5761120a611795565b911515602092830291909101909101528061122481611764565b915050610f24565b50949c939b5091995097509550909350915050565b600061128383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f77000081525061145a565b90505b92915050565b60008261129b57506000611286565b60006112a7838561172e565b9050826112b4858361170c565b146112835760405162461bcd60e51b815260206004820152602160248201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6044820152607760f81b6064820152608401610269565b600061128383836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f00000000000081525061148b565b60008061135a83856116f4565b9050838110156112835760405162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006044820152606401610269565b6000806114006064610690600260149054906101000a900460ff1660ff1660066000896001600160a01b03166001600160a01b03168152602001908152602001600020878154811061067057610670611795565b9050600061143d60066000876001600160a01b03166001600160a01b03168152602001908152602001600020858154811061061d5761061d611795565b90506114516301e13380610690838561128c565b95945050505050565b6000818484111561147e5760405162461bcd60e51b81526004016102699190611672565b506000611451848661174d565b600081836114ac5760405162461bcd60e51b81526004016102699190611672565b506000611451848661170c565b6000602082840312156114cb57600080fd5b81356001600160a01b038116811461128357600080fd5b6000602082840312156114f457600080fd5b8151801515811461128357600080fd5b60006020828403121561151657600080fd5b5035919050565b60006020828403121561152f57600080fd5b813560ff8116811461128357600080fd5b600081518084526020808501945080840160005b8381101561157057815187529582019590820190600101611554565b509495945050505050565b6020808252825182820181905260009190848201906040850190845b818110156115bc5783516001600160a01b031683529284019291840191600101611597565b50909695505050505050565b60c0815260006115db60c0830189611540565b6020838203818501526115ee828a611540565b915083820360408501526116028289611540565b915083820360608501526116168288611540565b9150838203608085015261162a8287611540565b84810360a0860152855180825282870193509082019060005b81811015611661578451151583529383019391830191600101611643565b50909b9a5050505050505050505050565b600060208083528351808285015260005b8181101561169f57858101830151858201604001528201611683565b818111156116b1576000604083870101525b50601f01601f1916929092016040019392505050565b60208082526013908201527221b0b63632b91034b9903737ba1037bbb732b960691b604082015260600190565b600082198211156117075761170761177f565b500190565b60008261172957634e487b7160e01b600052601260045260246000fd5b500490565b60008160001904831182151516156117485761174861177f565b500290565b60008282101561175f5761175f61177f565b500390565b60006000198214156117785761177861177f565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fdfea2646970667358221220a3dba54c4e981aa4fa2b1a15c594f74be8ed467a3c521aca0cd4f5f5db7c4df364736f6c63430008070033000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ae29ac47a9e3b0a52840e547adf74b912999f7fc

000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ae29ac47a9e3b0a52840e547adf74b912999f7fc

-----Decoded View---------------
Arg [0] : _apy (uint8): 20
Arg [1] : _mst (uint256): 86400
Arg [2] : _penalty (uint8): 0
Arg [3] : _token (address): 0xae29ac47a9e3b0a52840e547adf74b912999f7fc

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [1] : 0000000000000000000000000000000000000000000000000000000000015180
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 000000000000000000000000ae29ac47a9e3b0a52840e547adf74b912999f7fc

24478:8345:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24913:20;;;;;;;;;;;;8349:4:1;8337:17;;;8319:36;;8307:2;8292:18;24913:20:0;;;;;;;;32669:145;;;:::i;:::-;;29676:489;;;;;;:::i;:::-;;:::i;24825:31::-;;;;;;;;;8141:25:1;;;8129:2;8114:18;24825:31:0;7995:177:1;30306:2166:0;;;;;;:::i;:::-;;:::i;26491:111::-;;;;;;:::i;:::-;;:::i;32551:112::-;;;:::i;1511:81::-;1552:7;1579:5;-1:-1:-1;;;;;1579:5:0;1511:81;;;-1:-1:-1;;;;;1650:32:1;;;1632:51;;1620:2;1605:18;1511:81:0;1486:203:1;26758:117:0;;;:::i;:::-;;;;;;;:::i;26608:91::-;;;;;;:::i;:::-;;:::i;1287:130::-;;;;;;:::i;:::-;;:::i;26377:108::-;;;;;;:::i;:::-;;:::i;27694:1936::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;24696:16::-;;;;;-1:-1:-1;;;24696:16:0;;;;;;24637:18;;;;;-1:-1:-1;;;;;24637:18:0;;;32669:145;894:5;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;;;;;;;;;23448:1:::1;24045:7;;:19;;24037:63;;;::::0;-1:-1:-1;;;24037:63:0;;7837:2:1;24037:63:0::1;::::0;::::1;7819:21:1::0;7876:2;7856:18;;;7849:30;7915:33;7895:18;;;7888:61;7966:18;;24037:63:0::1;7635:355:1::0;24037:63:0::1;23448:1;24178:7;:18:::0;;;32734:5;32761:16:::2;::::0;32734:44:::2;::::0;-1:-1:-1;;;32734:44:0;;32749:10:::2;32734:44;::::0;::::2;2248:51:1::0;2315:18;;;2308:34;;;;-1:-1:-1;;;;;32734:5:0;;::::2;::::0;:14:::2;::::0;2221:18:1;;32734:44:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;32805:1:0::2;32786:16;:20:::0;23404:1:::1;24357:22:::0;;32669:145::o;29676:489::-;29813:5;;:53;;-1:-1:-1;;;29813:53:0;;29832:10;29813:53;;;1934:34:1;29852:4:0;1984:18:1;;;1977:43;2036:18;;;2029:34;;;-1:-1:-1;;;;;29813:5:0;;;;:18;;1869::1;;29813:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;29970:10:0;29956:25;;;;:13;:25;;;;;:32;29953:87;;30003:14;:31;;;;;;;-1:-1:-1;30003:31:0;;;;;;;;-1:-1:-1;;;;;;30003:31:0;30023:10;30003:31;;;29953:87;30093:10;30079:25;;;;:13;:25;;;;;;;;30110:46;;;;;;;30116:15;30110:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30079:78;;30110:46;30079:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;30079:78:0;;;;;;;;;;29676:489::o;30306:2166::-;23448:1;24045:7;;:19;;24037:63;;;;-1:-1:-1;;;24037:63:0;;7837:2:1;24037:63:0;;;7819:21:1;7876:2;7856:18;;;7849:30;7915:33;7895:18;;;7888:61;7966:18;;24037:63:0;7635:355:1;24037:63:0;23448:1;24178:7;:18;30462:10:::1;30448:25;::::0;;;:13:::1;:25;::::0;;;;:32;30435:45;::::1;30427:78;;;::::0;-1:-1:-1;;;30427:78:0;;5680:2:1;30427:78:0::1;::::0;::::1;5662:21:1::0;5719:2;5699:18;;;5692:30;-1:-1:-1;;;5738:18:1;;;5731:50;5798:18;;30427:78:0::1;5478:344:1::0;30427:78:0::1;30538:10;30524:25;::::0;;;:13:::1;:25;::::0;;;;:37;;30550:10;;30524:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;:44:::1;:37;::::0;;::::1;;:44;::::0;::::1;;:51;30516:84;;;::::0;-1:-1:-1;;;30516:84:0;;7086:2:1;30516:84:0::1;::::0;::::1;7068:21:1::0;7125:2;7105:18;;;7098:30;-1:-1:-1;;;7144:18:1;;;7137:50;7204:18;;30516:84:0::1;6884:344:1::0;30516:84:0::1;30750:16;::::0;30713:10:::1;30699:25;::::0;;;:13:::1;:25;::::0;;;;:37;;30679:68:::1;::::0;30699:25;30725:10;;30699:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:47:::0;30679:15:::1;::::0;:19:::1;:68::i;:::-;:87;30676:1789;;;30914:7;::::0;30879:10:::1;30843:19;30865:25:::0;;;:13:::1;:25;::::0;;;;:37;;30843:19;;30865:66:::1;::::0;30927:3:::1;::::0;30865:57:::1;::::0;30914:7:::1;;::::0;30891:10;;30865:37;::::1;;;;;:::i;:::-;;;;;;;;;;;:44;;;:48;;:57;;;;:::i;:::-;:61:::0;::::1;:66::i;:::-;31039:10;30998:24;31025:25:::0;;;:13:::1;:25;::::0;;;;:37;;30843:88;;-1:-1:-1;30998:24:0;;31025:61:::1;::::0;30843:88;;31051:10;;31025:37;::::1;;;;;:::i;:::-;;;;;;;;;;;:44;;;:48;;:61;;;;:::i;:::-;31150:5;::::0;:44:::1;::::0;-1:-1:-1;;;31150:44:0;;31165:10:::1;31150:44;::::0;::::1;2248:51:1::0;2315:18;;;2308:34;;;30998:88:0;;-1:-1:-1;;;;;;31150:5:0::1;::::0;:14:::1;::::0;2221:18:1;;31150:44:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;31330:16:0::1;::::0;:33:::1;::::0;31351:11;31330:20:::1;:33::i;:::-;31311:16;:52:::0;31472:10:::1;31458:25;::::0;;;:13:::1;:25;::::0;;;;:37;;31506:11;;31458:25;31484:10;;31458:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:45;;:59:::0;;;;31546:10:::1;31532:25:::0;;;;;;;;:37;;31585:15:::1;::::0;31532:25;31558:10;;31532:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:50;;:68:::0;;;;31629:10:::1;31615:25:::0;;;;;;;;:37;;31662:4:::1;::::0;31615:25;31641:10;;31615:37;::::1;;;;;:::i;:::-;;;;;;;;;;;:44;;;:51;;;;;;;;;;;;;;;;;;30767:983;;30676:1789;;;31804:16;31823:41;31841:10;31853;31823:17;:41::i;:::-;31975:5;::::0;31804:60;;-1:-1:-1;;;;;;31975:5:0::1;:18;31994:10;1552:7:::0;1579:5;-1:-1:-1;;;;;1579:5:0;;1511:81;31994:10:::1;31975:52;::::0;-1:-1:-1;;;;;;31975:52:0::1;::::0;;;;;;-1:-1:-1;;;;;1952:15:1;;;31975:52:0::1;::::0;::::1;1934:34:1::0;32006:10:0::1;1984:18:1::0;;;1977:43;2036:18;;;2029:34;;;1869:18;;31975:52:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;32105:5:0::1;::::0;32120:10:::1;32105:5;32132:25:::0;;;:13:::1;:25;::::0;;;;:37;;-1:-1:-1;;;;;32105:5:0;;::::1;::::0;:14:::1;::::0;32120:10;32132:25;32158:10;;32132:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;:44:::1;:37;::::0;;::::1;;:44;::::0;32105:72:::1;::::0;-1:-1:-1;;;;;;32105:72:0::1;::::0;;;;;;-1:-1:-1;;;;;2266:32:1;;;32105:72:0::1;::::0;::::1;2248:51:1::0;2315:18;;;2308:34;2221:18;;32105:72:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;32259:10:0::1;32245:25;::::0;;;:13:::1;:25;::::0;;;;:37;;32294:8;;32245:25;32271:10;;32245:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:46;;:57:::0;;;;32331:10:::1;32317:25:::0;;;;;;;;:37;;32370:15:::1;::::0;32317:25;32343:10;;32317:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:50;;:68:::0;;;;32414:10:::1;32400:25:::0;;;;;;;;:37;;32447:4:::1;::::0;32400:25;32426:10;;32400:37;::::1;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:44;;:51:::0;;-1:-1:-1;;32400:51:0::1;::::0;::::1;;::::0;;;::::1;::::0;;-1:-1:-1;30676:1789:0::1;-1:-1:-1::0;23404:1:0;24357:22;;30306:2166::o;26491:111::-;894:5;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;26568:16:::1;:26:::0;26491:111::o;32551:112::-;32615:7;894:5;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;-1:-1:-1;32639:16:0::1;::::0;32551:112;:::o;26758:117::-;894:5;;26820:16;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;26853:14:::1;26846:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;26846:21:0::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;;;;26758:117:::0;:::o;26608:91::-;894:5;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;26674:7:::1;:17:::0;;-1:-1:-1;;26674:17:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;26608:91::o;1287:130::-;894:5;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;1366:5:::1;::::0;;1357:25:::1;::::0;-1:-1:-1;;;;;1357:25:0;;::::1;::::0;1366:5;::::1;::::0;1357:25:::1;::::0;::::1;1393:5;:16:::0;;-1:-1:-1;;;;;;1393:16:0::1;-1:-1:-1::0;;;;;1393:16:0;;;::::1;::::0;;;::::1;::::0;;1287:130::o;26377:108::-;894:5;;-1:-1:-1;;;;;894:5:0;880:10;:19;872:51;;;;-1:-1:-1;;;872:51:0;;;;;;;:::i;:::-;26464:3:::1;:13:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;;26464:13:0::1;-1:-1:-1::0;;;;26464:13:0;;::::1;::::0;;;::::1;::::0;;26377:108::o;27694:1936::-;27768:16;;;;;;27970:10;-1:-1:-1;;;;;27970:25:0;;;;:51;;-1:-1:-1;1552:7:0;1579:5;-1:-1:-1;;;;;1579:5:0;27999:10;:22;27970:51;27962:88;;;;-1:-1:-1;;;27962:88:0;;6733:2:1;27962:88:0;;;6715:21:1;6772:2;6752:18;;;6745:30;6811:26;6791:18;;;6784:54;6855:18;;27962:88:0;6531:348:1;27962:88:0;-1:-1:-1;;;;;28152:28:0;;28107;28152;;;:13;:28;;;;;:35;28138:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28138:50:0;-1:-1:-1;;;;;;28238:28:0;;28196:25;28238:28;;;:13;:28;;;;;:35;28107:81;;-1:-1:-1;28196:25:0;28224:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28224:50:0;-1:-1:-1;;;;;;28326:28:0;;28282:27;28326:28;;;:13;:28;;;;;:35;28196:78;;-1:-1:-1;28282:27:0;28312:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28312:50:0;-1:-1:-1;;;;;;28413:28:0;;28370:26;28413:28;;;:13;:28;;;;;:35;28282:80;;-1:-1:-1;28370:26:0;28399:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28399:50:0;-1:-1:-1;;;;;;28505:28:0;;28457:31;28505:28;;;:13;:28;;;;;:35;28370:79;;-1:-1:-1;28457:31:0;28491:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28491:50:0;-1:-1:-1;;;;;;28585:28:0;;28549:22;28585:28;;;:13;:28;;;;;:35;28457:84;;-1:-1:-1;28549:22:0;28574:47;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28574:47:0;;28549:72;;28705:9;28701:835;-1:-1:-1;;;;;28720:28:0;;;;;;:13;:28;;;;;:35;28718:37;;28701:835;;;-1:-1:-1;;;;;28793:28:0;;;;;;:13;:28;;;;;:31;;28822:1;;28793:31;;;;;;:::i;:::-;;;;;;;;;;;:41;;;28776:11;28788:1;28776:14;;;;;;;;:::i;:::-;;;;;;:58;;;;;28863:13;:28;28877:13;-1:-1:-1;;;;;28863:28:0;-1:-1:-1;;;;;28863:28:0;;;;;;;;;;;;28892:1;28863:31;;;;;;;;:::i;:::-;;;;;;;;;;;:38;;;28849:8;28858:1;28849:11;;;;;;;;:::i;:::-;;;;;;:52;;;;;29029:13;:28;29043:13;-1:-1:-1;;;;;29029:28:0;-1:-1:-1;;;;;29029:28:0;;;;;;;;;;;;29058:1;29029:31;;;;;;;;:::i;:::-;;;;;;;;;:38;:31;;;;;:38;;;;:46;;:38;:46;29026:270;;;-1:-1:-1;;;;;29111:28:0;;;;;;:13;:28;;;;;:31;;29140:1;;29111:31;;;;;;:::i;:::-;;;;;;;;;;;:40;;;29095:10;29106:1;29095:13;;;;;;;;:::i;:::-;;;;;;:56;;;;;29026:270;;;29245:35;29263:13;29278:1;29245:17;:35::i;:::-;29229:10;29240:1;29229:13;;;;;;;;:::i;:::-;;;;;;:51;;;;;29026:270;-1:-1:-1;;;;;29339:28:0;;;;;;:13;:28;;;;;:31;;29368:1;;29339:31;;;;;;:::i;:::-;;;;;;;;;;;:39;;;29324:9;29334:1;29324:12;;;;;;;;:::i;:::-;;;;;;:54;;;;;29413:13;:28;29427:13;-1:-1:-1;;;;;29413:28:0;-1:-1:-1;;;;;29413:28:0;;;;;;;;;;;;29442:1;29413:31;;;;;;;;:::i;:::-;;;;;;;;;;;:44;;;29393:14;29408:1;29393:17;;;;;;;;:::i;:::-;;;;;;:64;;;;;29486:13;:28;29500:13;-1:-1:-1;;;;;29486:28:0;-1:-1:-1;;;;;29486:28:0;;;;;;;;;;;;29515:1;29486:31;;;;;;;;:::i;:::-;;;;;;;;;;;:38;;;;;;;;;;;;29472:8;29481:1;29472:11;;;;;;;;:::i;:::-;:52;;;:11;;;;;;;;;;;:52;28757:3;;;;:::i;:::-;;;;28701:835;;;-1:-1:-1;29551:11:0;;29564:8;;-1:-1:-1;29574:10:0;;-1:-1:-1;29574:10:0;-1:-1:-1;29564:8:0;-1:-1:-1;29551:11:0;;-1:-1:-1;27694:1936:0;-1:-1:-1;;27694:1936:0:o;17782:136::-;17840:7;17867:43;17871:1;17874;17867:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;17860:50;;17782:136;;;;;:::o;18656:471::-;18714:7;18959:6;18955:47;;-1:-1:-1;18989:1:0;18982:8;;18955:47;19014:9;19026:5;19030:1;19026;:5;:::i;:::-;19014:17;-1:-1:-1;19059:1:0;19050:5;19054:1;19014:17;19050:5;:::i;:::-;:10;19042:56;;;;-1:-1:-1;;;19042:56:0;;7435:2:1;19042:56:0;;;7417:21:1;7474:2;7454:18;;;7447:30;7513:34;7493:18;;;7486:62;-1:-1:-1;;;7564:18:1;;;7557:31;7605:19;;19042:56:0;7233:397:1;19595:132:0;19653:7;19680:39;19684:1;19687;19680:39;;;;;;;;;;;;;;;;;:3;:39::i;17326:181::-;17384:7;;17416:5;17420:1;17416;:5;:::i;:::-;17404:17;;17445:1;17440;:6;;17432:46;;;;-1:-1:-1;;;17432:46:0;;6377:2:1;17432:46:0;;;6359:21:1;6416:2;6396:18;;;6389:30;6455:29;6435:18;;;6428:57;6502:18;;17432:46:0;6175:351:1;26883:751:0;26966:7;27056:25;27084:56;27136:3;27084:47;27127:3;;;;;;;;;;;27084:47;;:13;:28;27098:13;-1:-1:-1;;;;;27084:28:0;-1:-1:-1;;;;;27084:28:0;;;;;;;;;;;;27113:1;27084:31;;;;;;;;:::i;:56::-;27056:84;;27202:19;27224:62;27244:13;:28;27258:13;-1:-1:-1;;;;;27244:28:0;-1:-1:-1;;;;;27244:28:0;;;;;;;;;;;;27273:1;27244:31;;;;;;;;:::i;27224:62::-;27202:84;-1:-1:-1;27576:48:0;27615:8;27576:34;27202:84;27592:17;27576:15;:34::i;:48::-;27569:55;26883:751;-1:-1:-1;;;;;26883:751:0:o;18213:192::-;18299:7;18335:12;18327:6;;;;18319:29;;;;-1:-1:-1;;;18319:29:0;;;;;;;;:::i;:::-;-1:-1:-1;18359:9:0;18371:5;18375:1;18371;:5;:::i;20215:345::-;20301:7;20403:12;20396:5;20388:28;;;;-1:-1:-1;;;20388:28:0;;;;;;;;:::i;:::-;-1:-1:-1;20427:9:0;20439:5;20443:1;20439;:5;:::i;14:286:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;168:23;;-1:-1:-1;;;;;220:31:1;;210:42;;200:70;;266:1;263;256:12;305:277;372:6;425:2;413:9;404:7;400:23;396:32;393:52;;;441:1;438;431:12;393:52;473:9;467:16;526:5;519:13;512:21;505:5;502:32;492:60;;548:1;545;538:12;587:180;646:6;699:2;687:9;678:7;674:23;670:32;667:52;;;715:1;712;705:12;667:52;-1:-1:-1;738:23:1;;587:180;-1:-1:-1;587:180:1:o;772:269::-;829:6;882:2;870:9;861:7;857:23;853:32;850:52;;;898:1;895;888:12;850:52;937:9;924:23;987:4;980:5;976:16;969:5;966:27;956:55;;1007:1;1004;997:12;1046:435;1099:3;1137:5;1131:12;1164:6;1159:3;1152:19;1190:4;1219:2;1214:3;1210:12;1203:19;;1256:2;1249:5;1245:14;1277:1;1287:169;1301:6;1298:1;1295:13;1287:169;;;1362:13;;1350:26;;1396:12;;;;1431:15;;;;1323:1;1316:9;1287:169;;;-1:-1:-1;1472:3:1;;1046:435;-1:-1:-1;;;;;1046:435:1:o;2353:658::-;2524:2;2576:21;;;2646:13;;2549:18;;;2668:22;;;2495:4;;2524:2;2747:15;;;;2721:2;2706:18;;;2495:4;2790:195;2804:6;2801:1;2798:13;2790:195;;;2869:13;;-1:-1:-1;;;;;2865:39:1;2853:52;;2960:15;;;;2925:12;;;;2901:1;2819:9;2790:195;;;-1:-1:-1;3002:3:1;;2353:658;-1:-1:-1;;;;;;2353:658:1:o;3016:1634::-;3579:3;3568:9;3561:22;3542:4;3606:57;3658:3;3647:9;3643:19;3635:6;3606:57;:::i;:::-;3682:2;3732:9;3724:6;3720:22;3715:2;3704:9;3700:18;3693:50;3766:44;3803:6;3795;3766:44;:::i;:::-;3752:58;;3858:9;3850:6;3846:22;3841:2;3830:9;3826:18;3819:50;3892:44;3929:6;3921;3892:44;:::i;:::-;3878:58;;3984:9;3976:6;3972:22;3967:2;3956:9;3952:18;3945:50;4018:44;4055:6;4047;4018:44;:::i;:::-;4004:58;;4111:9;4103:6;4099:22;4093:3;4082:9;4078:19;4071:51;4145:44;4182:6;4174;4145:44;:::i;:::-;4226:22;;;4220:3;4205:19;;4198:51;4298:13;;4320:22;;;4396:15;;;;-1:-1:-1;4358:15:1;;;;4429:1;4439:185;4453:6;4450:1;4447:13;4439:185;;;4528:13;;4521:21;4514:29;4502:42;;4599:15;;;;4564:12;;;;4475:1;4468:9;4439:185;;;-1:-1:-1;4641:3:1;;3016:1634;-1:-1:-1;;;;;;;;;;;3016:1634:1:o;4876:597::-;4988:4;5017:2;5046;5035:9;5028:21;5078:6;5072:13;5121:6;5116:2;5105:9;5101:18;5094:34;5146:1;5156:140;5170:6;5167:1;5164:13;5156:140;;;5265:14;;;5261:23;;5255:30;5231:17;;;5250:2;5227:26;5220:66;5185:10;;5156:140;;;5314:6;5311:1;5308:13;5305:91;;;5384:1;5379:2;5370:6;5359:9;5355:22;5351:31;5344:42;5305:91;-1:-1:-1;5457:2:1;5436:15;-1:-1:-1;;5432:29:1;5417:45;;;;5464:2;5413:54;;4876:597;-1:-1:-1;;;4876:597:1:o;5827:343::-;6029:2;6011:21;;;6068:2;6048:18;;;6041:30;-1:-1:-1;;;6102:2:1;6087:18;;6080:49;6161:2;6146:18;;5827:343::o;8366:128::-;8406:3;8437:1;8433:6;8430:1;8427:13;8424:39;;;8443:18;;:::i;:::-;-1:-1:-1;8479:9:1;;8366:128::o;8499:217::-;8539:1;8565;8555:132;;8609:10;8604:3;8600:20;8597:1;8590:31;8644:4;8641:1;8634:15;8672:4;8669:1;8662:15;8555:132;-1:-1:-1;8701:9:1;;8499:217::o;8721:168::-;8761:7;8827:1;8823;8819:6;8815:14;8812:1;8809:21;8804:1;8797:9;8790:17;8786:45;8783:71;;;8834:18;;:::i;:::-;-1:-1:-1;8874:9:1;;8721:168::o;8894:125::-;8934:4;8962:1;8959;8956:8;8953:34;;;8967:18;;:::i;:::-;-1:-1:-1;9004:9:1;;8894:125::o;9024:135::-;9063:3;-1:-1:-1;;9084:17:1;;9081:43;;;9104:18;;:::i;:::-;-1:-1:-1;9151:1:1;9140:13;;9024:135::o;9164:127::-;9225:10;9220:3;9216:20;9213:1;9206:31;9256:4;9253:1;9246:15;9280:4;9277:1;9270:15;9296:127;9357:10;9352:3;9348:20;9345:1;9338:31;9388:4;9385:1;9378:15;9412:4;9409:1;9402:15;9428:127;9489:10;9484:3;9480:20;9477:1;9470:31;9520:4;9517:1;9510:15;9544:4;9541:1;9534:15

ipfs://a3dba54c4e981aa4fa2b1a15c594f74be8ed467a3c521aca0cd4f5f5db7c4df3