Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Owner
•    - function changeOwner(address newOwner ...
•    - function getOwner()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function _msgSender()
•    - function _msgData()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•  contract SingleStaking is Owner, R ... *
•    - function start(uint256 _value)
•    - function end(uint256 i)
•    - function set(uint256 _lower, uint256 ...
•    - function get_gains(address _address, ...
•    - function ledger_length(address _addre ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-09-21
*/

/**
 *Submitted for verification at Etherscan.io on 2023-06-13
*/

// SPDX-License-Identifier: MIT

// Single Staking contract for DeFi Platform. Easy access for projects to have asset to asset staking earning interest based on APY %

pragma solidity ^0.8.2;

/**
 * @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 SingleStaking is Owner, ReentrancyGuard {

    // token    
    ERC20 public asset;

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

    // contract parameters
    uint16 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, uint16 _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 nonReentrant {
        require(_value >= lower_amount, "Invalid value");
        require(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 - ledger[msg.sender][i].from < maturity) {
            uint256 _penalization = ledger[msg.sender][i].amount * penalization / 100;
            require(asset.transfer(msg.sender, ledger[msg.sender][i].amount - _penalization));
            require(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) {
                require(asset.transferFrom(getOwner(), msg.sender, _interest));
            } else {
                _interest = 0;
            }
            require(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, uint16 _rate, uint8 _penalization) external 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 - ledger[_address][_rec_number].from;
        uint256 _year_seconds = 365*24*60*60;
        return _record_seconds * ledger[_address][_rec_number].amount * interest_rate / 100 / _year_seconds;
    }

    function ledger_length(address _address) external 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":"uint16","name":"_rate","type":"uint16"},{"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":"uint16","name":"","type":"uint16"}],"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":"uint16","name":"_rate","type":"uint16"},{"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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

20583:3895:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22035:1597;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21007:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23640:297;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20945:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20659:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20975:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21043:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;1573:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21676:351;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1349:130;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;24351:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24001:342;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20911:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22035:1597;3312:1;3910:7;;:19;3902:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;3312:1;4043:7;:18;;;;22106:6:::1;:18;22113:10;22106:18;;;;;;;;;;;;;;;:25;;;;22102:1;:29;22094:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;22197:5;22168:34;;:6;:18;22175:10;22168:18;;;;;;;;;;;;;;;22187:1;22168:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:27;;;;;;;;;;;;:34;;;22160:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;22316:8;;22287:6;:18;22294:10;22287:18;;;;;;;;;;;;;;;22306:1;22287:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:26;;;22269:15;:44;;;;:::i;:::-;:55;22266:1359;;;22341:21;22411:3;22396:12;;;;;;;;;;;22365:43;;:6;:18;22372:10;22365:18;;;;;;;;;;;;;;;22384:1;22365:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:28;;;:43;;;;:::i;:::-;:49;;;;:::i;:::-;22341:73;;22437:5;;;;;;;;;;;:14;;;22452:10;22495:13;22464:6;:18;22471:10;22464:18;;;;;;;;;;;;;;;22483:1;22464:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:28;;;:44;;;;:::i;:::-;22437:72;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22429:81;;;::::0;::::1;;22533:5;;;;;;;;;;;:14;;;22548:10;:8;:10::i;:::-;22560:13;22533:41;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22525:50;;;::::0;::::1;;22627:13;22590:6;:18;22597:10;22590:18;;;;;;;;;;;;;;;22609:1;22590:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:34;;:50;;;;22682:15;22655:6;:18;22662:10;22655:18;;;;;;;;;;;;;;;22674:1;22655:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:24;;:42;;;;22742:4;22712:6;:18;22719:10;22712:18;;;;;;;;;;;;;;;22731:1;22712:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:27;;;:34;;;;;;;;;;;;;;;;;;22775:10;22766:71;;;22787:6;:18;22794:10;22787:18;;;;;;;;;;;;;;;22806:1;22787:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:28;;;22817:13;22832:1;22835;22766:71;;;;;;;;;:::i;:::-;;;;;;;;22326:551;22266:1359;;;22898:17;22918:24;22928:10;22940:1;22918:9;:24::i;:::-;22898:44;;23082:9;23036:5;;;;;;;;;;;:15;;;23052:10;:8;:10::i;:::-;23072:4;23036:42;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:55;;:99;;;;;23126:9;23095:5;;;;;;;;;;;:15;;;23111:10;:8;:10::i;:::-;23095:27;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;;23036:99;23032:256;;;23164:5;;;;;;;;;;;:18;;;23183:10;:8;:10::i;:::-;23195;23207:9;23164:53;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23156:62;;;::::0;::::1;;23032:256;;;23271:1;23259:13;;23032:256;23310:5;;;;;;;;;;;:14;;;23325:10;23337:6;:18;23344:10;23337:18;;;;;;;;;;;;;;;23356:1;23337:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:28;;;23310:56;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23302:65;;;::::0;::::1;;23411:9;23382:6;:18;23389:10;23382:18;;;;;;;;;;;;;;;23401:1;23382:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:26;;:38;;;;23462:15;23435:6;:18;23442:10;23435:18;;;;;;;;;;;;;;;23454:1;23435:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:24;;:42;;;;23522:4;23492:6;:18;23499:10;23492:18;;;;;;;;;;;;;;;23511:1;23492:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:27;;;:34;;;;;;;;;;;;;;;;;;23555:10;23546:67;;;23567:6;:18;23574:10;23567:18;;;;;;;;;;;;;;;23586:1;23567:21;;;;;;;;:::i;:::-;;;;;;;;;;;;:28;;;23597:1;23600:9;23611:1;23546:67;;;;;;;;;:::i;:::-;;;;;;;;22883:742;22266:1359;3268:1:::0;4222:7;:22;;;;22035:1597;:::o;21007:27::-;;;;:::o;23640:297::-;1025:5;;;;;;;;;;1011:19;;:10;:19;;;1003:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;23774:3:::1;23759:13;:18;;;;23751:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;23821:6;23806:12;:21;;;;23849:9;23838:8;:20;;;;23885:5;23869:13;;:21;;;;;;;;;;;;;;;;;;23916:13;23901:12;;:28;;;;;;;;;;;;;;;;;;23640:297:::0;;;;:::o;20945:23::-;;;;:::o;20659:18::-;;;;;;;;;;;;;:::o;20975:25::-;;;;;;;;;;;;;:::o;21043:42::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1573:81::-;1614:7;1641:5;;;;;;;;;;;1634:12;;1573:81;:::o;21676:351::-;3312:1;3910:7;;:19;3902:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;3312:1;4043:7;:18;;;;21758:12:::1;;21748:6;:22;;21740:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;21807:5;;;;;;;;;;;:18;;;21826:10;21846:4;21853:6;21807:53;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21799:62;;;::::0;::::1;;21872:6;:18;21879:10;21872:18;;;;;;;;;;;;;;;21896:47;;;;;;;;21903:15;21896:47;;;;21920:6;21896:47;;;;21928:1;21896:47;;;;21931:1;21896:47;;;;21934:1;21896:47;;;;21937:5;21896:47;;;;::::0;21872:72:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21971:10;21960:59;;;21983:6;22017:1;21991:6;:18;21998:10;21991:18;;;;;;;;;;;;;;;:25;;;;:27;;;;:::i;:::-;21960:59;;;;;;;:::i;:::-;;;;;;;;3268:1:::0;4222:7;:22;;;;21676:351;:::o;1349:130::-;1025:5;;;;;;;;;;1011:19;;:10;:19;;;1003:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;1435:8:::1;1419:25;;1428:5;::::0;::::1;;;;;;;;1419:25;;;;;;;;;;;;1463:8;1455:5;::::0;:16:::1;;;;;;;;;;;;;;;;;;1349:130:::0;:::o;24351:122::-;24415:7;24442:6;:16;24449:8;24442:16;;;;;;;;;;;;;;;:23;;;;24435:30;;24351:122;;;:::o;24001:342::-;24080:7;24100:23;24144:6;:16;24151:8;24144:16;;;;;;;;;;;;;;;24161:11;24144:29;;;;;;;;:::i;:::-;;;;;;;;;;;;:34;;;24126:15;:52;;;;:::i;:::-;24100:78;;24189:21;24213:12;24189:36;;24322:13;24316:3;24300:13;;;;;;;;;;;24243:70;;24261:6;:16;24268:8;24261:16;;;;;;;;;;;;;;;24278:11;24261:29;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;24243:15;:54;;;;:::i;:::-;:70;;;;:::i;:::-;:76;;;;:::i;:::-;:92;;;;:::i;:::-;24236:99;;;;24001:342;;;;:::o;20911:27::-;;;;;;;;;;;;;:::o;88:117:1:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:118::-;1112:24;1130:5;1112:24;:::i;:::-;1107:3;1100:37;1025:118;;:::o;1149:222::-;1242:4;1280:2;1269:9;1265:18;1257:26;;1293:71;1361:1;1350:9;1346:17;1337:6;1293:71;:::i;:::-;1149:222;;;;:::o;1377:89::-;1413:7;1453:6;1446:5;1442:18;1431:29;;1377:89;;;:::o;1472:120::-;1544:23;1561:5;1544:23;:::i;:::-;1537:5;1534:34;1524:62;;1582:1;1579;1572:12;1524:62;1472:120;:::o;1598:137::-;1643:5;1681:6;1668:20;1659:29;;1697:32;1723:5;1697:32;:::i;:::-;1598:137;;;;:::o;1741:86::-;1776:7;1816:4;1809:5;1805:16;1794:27;;1741:86;;;:::o;1833:118::-;1904:22;1920:5;1904:22;:::i;:::-;1897:5;1894:33;1884:61;;1941:1;1938;1931:12;1884:61;1833:118;:::o;1957:135::-;2001:5;2039:6;2026:20;2017:29;;2055:31;2080:5;2055:31;:::i;:::-;1957:135;;;;:::o;2098:759::-;2181:6;2189;2197;2205;2254:3;2242:9;2233:7;2229:23;2225:33;2222:120;;;2261:79;;:::i;:::-;2222:120;2381:1;2406:53;2451:7;2442:6;2431:9;2427:22;2406:53;:::i;:::-;2396:63;;2352:117;2508:2;2534:53;2579:7;2570:6;2559:9;2555:22;2534:53;:::i;:::-;2524:63;;2479:118;2636:2;2662:52;2706:7;2697:6;2686:9;2682:22;2662:52;:::i;:::-;2652:62;;2607:117;2763:2;2789:51;2832:7;2823:6;2812:9;2808:22;2789:51;:::i;:::-;2779:61;;2734:116;2098:759;;;;;;;:::o;2863:126::-;2900:7;2940:42;2933:5;2929:54;2918:65;;2863:126;;;:::o;2995:60::-;3023:3;3044:5;3037:12;;2995:60;;;:::o;3061:142::-;3111:9;3144:53;3162:34;3171:24;3189:5;3171:24;:::i;:::-;3162:34;:::i;:::-;3144:53;:::i;:::-;3131:66;;3061:142;;;:::o;3209:126::-;3259:9;3292:37;3323:5;3292:37;:::i;:::-;3279:50;;3209:126;;;:::o;3341:139::-;3404:9;3437:37;3468:5;3437:37;:::i;:::-;3424:50;;3341:139;;;:::o;3486:157::-;3586:50;3630:5;3586:50;:::i;:::-;3581:3;3574:63;3486:157;;:::o;3649:248::-;3755:4;3793:2;3782:9;3778:18;3770:26;;3806:84;3887:1;3876:9;3872:17;3863:6;3806:84;:::i;:::-;3649:248;;;;:::o;3903:112::-;3986:22;4002:5;3986:22;:::i;:::-;3981:3;3974:35;3903:112;;:::o;4021:214::-;4110:4;4148:2;4137:9;4133:18;4125:26;;4161:67;4225:1;4214:9;4210:17;4201:6;4161:67;:::i;:::-;4021:214;;;;:::o;4241:96::-;4278:7;4307:24;4325:5;4307:24;:::i;:::-;4296:35;;4241:96;;;:::o;4343:122::-;4416:24;4434:5;4416:24;:::i;:::-;4409:5;4406:35;4396:63;;4455:1;4452;4445:12;4396:63;4343:122;:::o;4471:139::-;4517:5;4555:6;4542:20;4533:29;;4571:33;4598:5;4571:33;:::i;:::-;4471:139;;;;:::o;4616:474::-;4684:6;4692;4741:2;4729:9;4720:7;4716:23;4712:32;4709:119;;;4747:79;;:::i;:::-;4709:119;4867:1;4892:53;4937:7;4928:6;4917:9;4913:22;4892:53;:::i;:::-;4882:63;;4838:117;4994:2;5020:53;5065:7;5056:6;5045:9;5041:22;5020:53;:::i;:::-;5010:63;;4965:118;4616:474;;;;;:::o;5096:90::-;5130:7;5173:5;5166:13;5159:21;5148:32;;5096:90;;;:::o;5192:109::-;5273:21;5288:5;5273:21;:::i;:::-;5268:3;5261:34;5192:109;;:::o;5307:763::-;5534:4;5572:3;5561:9;5557:19;5549:27;;5586:71;5654:1;5643:9;5639:17;5630:6;5586:71;:::i;:::-;5667:72;5735:2;5724:9;5720:18;5711:6;5667:72;:::i;:::-;5749;5817:2;5806:9;5802:18;5793:6;5749:72;:::i;:::-;5831;5899:2;5888:9;5884:18;5875:6;5831:72;:::i;:::-;5913:73;5981:3;5970:9;5966:19;5957:6;5913:73;:::i;:::-;5996:67;6058:3;6047:9;6043:19;6034:6;5996:67;:::i;:::-;5307:763;;;;;;;;;:::o;6076:118::-;6163:24;6181:5;6163:24;:::i;:::-;6158:3;6151:37;6076:118;;:::o;6200:222::-;6293:4;6331:2;6320:9;6316:18;6308:26;;6344:71;6412:1;6401:9;6397:17;6388:6;6344:71;:::i;:::-;6200:222;;;;:::o;6428:329::-;6487:6;6536:2;6524:9;6515:7;6511:23;6507:32;6504:119;;;6542:79;;:::i;:::-;6504:119;6662:1;6687:53;6732:7;6723:6;6712:9;6708:22;6687:53;:::i;:::-;6677:63;;6633:117;6428:329;;;;:::o;6763:115::-;6848:23;6865:5;6848:23;:::i;:::-;6843:3;6836:36;6763:115;;:::o;6884:218::-;6975:4;7013:2;7002:9;6998:18;6990:26;;7026:69;7092:1;7081:9;7077:17;7068:6;7026:69;:::i;:::-;6884:218;;;;:::o;7108:169::-;7192:11;7226:6;7221:3;7214:19;7266:4;7261:3;7257:14;7242:29;;7108:169;;;;:::o;7283:181::-;7423:33;7419:1;7411:6;7407:14;7400:57;7283:181;:::o;7470:366::-;7612:3;7633:67;7697:2;7692:3;7633:67;:::i;:::-;7626:74;;7709:93;7798:3;7709:93;:::i;:::-;7827:2;7822:3;7818:12;7811:19;;7470:366;;;:::o;7842:419::-;8008:4;8046:2;8035:9;8031:18;8023:26;;8095:9;8089:4;8085:20;8081:1;8070:9;8066:17;8059:47;8123:131;8249:4;8123:131;:::i;:::-;8115:139;;7842:419;;;:::o;8267:163::-;8407:15;8403:1;8395:6;8391:14;8384:39;8267:163;:::o;8436:366::-;8578:3;8599:67;8663:2;8658:3;8599:67;:::i;:::-;8592:74;;8675:93;8764:3;8675:93;:::i;:::-;8793:2;8788:3;8784:12;8777:19;;8436:366;;;:::o;8808:419::-;8974:4;9012:2;9001:9;8997:18;8989:26;;9061:9;9055:4;9051:20;9047:1;9036:9;9032:17;9025:47;9089:131;9215:4;9089:131;:::i;:::-;9081:139;;8808:419;;;:::o;9233:180::-;9281:77;9278:1;9271:88;9378:4;9375:1;9368:15;9402:4;9399:1;9392:15;9419:163;9559:15;9555:1;9547:6;9543:14;9536:39;9419:163;:::o;9588:366::-;9730:3;9751:67;9815:2;9810:3;9751:67;:::i;:::-;9744:74;;9827:93;9916:3;9827:93;:::i;:::-;9945:2;9940:3;9936:12;9929:19;;9588:366;;;:::o;9960:419::-;10126:4;10164:2;10153:9;10149:18;10141:26;;10213:9;10207:4;10203:20;10199:1;10188:9;10184:17;10177:47;10241:131;10367:4;10241:131;:::i;:::-;10233:139;;9960:419;;;:::o;10385:180::-;10433:77;10430:1;10423:88;10530:4;10527:1;10520:15;10554:4;10551:1;10544:15;10571:194;10611:4;10631:20;10649:1;10631:20;:::i;:::-;10626:25;;10665:20;10683:1;10665:20;:::i;:::-;10660:25;;10709:1;10706;10702:9;10694:17;;10733:1;10727:4;10724:11;10721:37;;;10738:18;;:::i;:::-;10721:37;10571:194;;;;:::o;10771:410::-;10811:7;10834:20;10852:1;10834:20;:::i;:::-;10829:25;;10868:20;10886:1;10868:20;:::i;:::-;10863:25;;10923:1;10920;10916:9;10945:30;10963:11;10945:30;:::i;:::-;10934:41;;11124:1;11115:7;11111:15;11108:1;11105:22;11085:1;11078:9;11058:83;11035:139;;11154:18;;:::i;:::-;11035:139;10819:362;10771:410;;;;:::o;11187:180::-;11235:77;11232:1;11225:88;11332:4;11329:1;11322:15;11356:4;11353:1;11346:15;11373:185;11413:1;11430:20;11448:1;11430:20;:::i;:::-;11425:25;;11464:20;11482:1;11464:20;:::i;:::-;11459:25;;11503:1;11493:35;;11508:18;;:::i;:::-;11493:35;11550:1;11547;11543:9;11538:14;;11373:185;;;;:::o;11564:332::-;11685:4;11723:2;11712:9;11708:18;11700:26;;11736:71;11804:1;11793:9;11789:17;11780:6;11736:71;:::i;:::-;11817:72;11885:2;11874:9;11870:18;11861:6;11817:72;:::i;:::-;11564:332;;;;;:::o;11902:116::-;11972:21;11987:5;11972:21;:::i;:::-;11965:5;11962:32;11952:60;;12008:1;12005;11998:12;11952:60;11902:116;:::o;12024:137::-;12078:5;12109:6;12103:13;12094:22;;12125:30;12149:5;12125:30;:::i;:::-;12024:137;;;;:::o;12167:345::-;12234:6;12283:2;12271:9;12262:7;12258:23;12254:32;12251:119;;;12289:79;;:::i;:::-;12251:119;12409:1;12434:61;12487:7;12478:6;12467:9;12463:22;12434:61;:::i;:::-;12424:71;;12380:125;12167:345;;;;:::o;12518:85::-;12563:7;12592:5;12581:16;;12518:85;;;:::o;12609:158::-;12667:9;12700:61;12718:42;12727:32;12753:5;12727:32;:::i;:::-;12718:42;:::i;:::-;12700:61;:::i;:::-;12687:74;;12609:158;;;:::o;12773:147::-;12868:45;12907:5;12868:45;:::i;:::-;12863:3;12856:58;12773:147;;:::o;12926:569::-;13111:4;13149:3;13138:9;13134:19;13126:27;;13163:71;13231:1;13220:9;13216:17;13207:6;13163:71;:::i;:::-;13244:72;13312:2;13301:9;13297:18;13288:6;13244:72;:::i;:::-;13326:80;13402:2;13391:9;13387:18;13378:6;13326:80;:::i;:::-;13416:72;13484:2;13473:9;13469:18;13460:6;13416:72;:::i;:::-;12926:569;;;;;;;:::o;13501:332::-;13622:4;13660:2;13649:9;13645:18;13637:26;;13673:71;13741:1;13730:9;13726:17;13717:6;13673:71;:::i;:::-;13754:72;13822:2;13811:9;13807:18;13798:6;13754:72;:::i;:::-;13501:332;;;;;:::o;13839:143::-;13896:5;13927:6;13921:13;13912:22;;13943:33;13970:5;13943:33;:::i;:::-;13839:143;;;;:::o;13988:351::-;14058:6;14107:2;14095:9;14086:7;14082:23;14078:32;14075:119;;;14113:79;;:::i;:::-;14075:119;14233:1;14258:64;14314:7;14305:6;14294:9;14290:22;14258:64;:::i;:::-;14248:74;;14204:128;13988:351;;;;:::o;14345:442::-;14494:4;14532:2;14521:9;14517:18;14509:26;;14545:71;14613:1;14602:9;14598:17;14589:6;14545:71;:::i;:::-;14626:72;14694:2;14683:9;14679:18;14670:6;14626:72;:::i;:::-;14708;14776:2;14765:9;14761:18;14752:6;14708:72;:::i;:::-;14345:442;;;;;;:::o;14793:569::-;14978:4;15016:3;15005:9;15001:19;14993:27;;15030:71;15098:1;15087:9;15083:17;15074:6;15030:71;:::i;:::-;15111:80;15187:2;15176:9;15172:18;15163:6;15111:80;:::i;:::-;15201:72;15269:2;15258:9;15254:18;15245:6;15201:72;:::i;:::-;15283;15351:2;15340:9;15336:18;15327:6;15283:72;:::i;:::-;14793:569;;;;;;;:::o;15368:169::-;15508:21;15504:1;15496:6;15492:14;15485:45;15368:169;:::o;15543:366::-;15685:3;15706:67;15770:2;15765:3;15706:67;:::i;:::-;15699:74;;15782:93;15871:3;15782:93;:::i;:::-;15900:2;15895:3;15891:12;15884:19;;15543:366;;;:::o;15915:419::-;16081:4;16119:2;16108:9;16104:18;16096:26;;16168:9;16162:4;16158:20;16154:1;16143:9;16139:17;16132:47;16196:131;16322:4;16196:131;:::i;:::-;16188:139;;15915:419;;;:::o;16340:163::-;16480:15;16476:1;16468:6;16464:14;16457:39;16340:163;:::o;16509:366::-;16651:3;16672:67;16736:2;16731:3;16672:67;:::i;:::-;16665:74;;16748:93;16837:3;16748:93;:::i;:::-;16866:2;16861:3;16857:12;16850:19;;16509:366;;;:::o;16881:419::-;17047:4;17085:2;17074:9;17070:18;17062:26;;17134:9;17128:4;17124:20;17120:1;17109:9;17105:17;17098:47;17162:131;17288:4;17162:131;:::i;:::-;17154:139;;16881:419;;;:::o;17306:332::-;17427:4;17465:2;17454:9;17450:18;17442:26;;17478:71;17546:1;17535:9;17531:17;17522:6;17478:71;:::i;:::-;17559:72;17627:2;17616:9;17612:18;17603:6;17559:72;:::i;:::-;17306:332;;;;;:::o

ipfs://dca3da18b3390711272fdc809db2dfa1117c895b38596e344871997d500df135