/**
                                                    ......''''......
                                            .',:cldxxkOOO0kddk0OOOkxxdlc:;'.
                                       .,:lxkO00000000000k, .;k00000000000Okxl:,.
                                   .;ldO0000000000000000O;    :O0000000000000000Odl;.
                                ':dk00000000000000000000Ol.  .o000000000000000000000kd:'
                             .:dO0000000000000000000000000o;:d0000000000000000000000000Od:.
                           ,ok000000000000000000000000000000000000000000000000000000000000ko,
                        .;dO0000000000000000000000000000000000000000000000000000000000000000Od;.
                       ;d0000000000000000000000000000000000000000000000000000000000000000000000d;
                     'dO000000000000000000000000000000000000000000000000000000000000000000000000Od'
                   .cO0000000000000000000000000000000000000000000000000000000000000000000000000000Oc.
                  'd00000000000000000000000000000000000000000000000000000000000000000000000000000000d'
                 ;k0000000000000000000000000000000000000000000000000000000000000000000000000000000000k;
                cO000000000000000000000000000000000000000000000000000000000000000000000000000000000000Oc
               cO00000000000000000000000000000000000000000000000000000000000000000000000000000000000000Oc
              :O0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000O:
             ;k000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000k;
            .x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000x.
            l0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000l
           'k0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000k'
           c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c
          .x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000x.
          ,k00000000000000000000000000000000000OOOO000000000000000000000000000000000000000000000000000000000k,
          ;O000OO00000000000000000000000000000x,...'',,;;;:::cccclloooddxxkkkOOOO000000000000000000000000000O;
          :0ko:'.,ldO0000000000000000000000000d.                         ........'',,;;;::ccccllooodddxxkkkOO:
          cOd;.   .:k0000000000000000000000000d.                                        .......'',,;:cclodxxk:
          :000kocok000000000000000000000000000d.                ...'',,;;;::cccclloodddxxkkkOOOO0000000000000:
          ;O0000000000000000000000000000000000koccllood;       .o0O00000000000000000000000000000000000000000O;
          'k0000000000000000000000000000000000000000000d.      .x0000000000000000000000000000000000000000000k'
          .o0000000000000000000000000000000000000000000x.      ,k0000000000000000000000000000000000000000000o.
           ;O000000000000000000000000000000000000000000k,      ;O000000000000000000000000000000000000000000O;
           .d000000000000000000000000000000000000000000O;      c0000000000000000000000000000000000000000000d.
            ;O000000000000000000000000000000000000000000c     .o000000000000000000000000000000000000000000O;
            .l000000000000000000000000000000000000000000o.    .x000000000000000000000000000000000000000000l.
             .d00000000000000000000000000000000000000000x.    'k00000000000000000000000000000000000000000d.
              .x0000000000000000000000000000000000000000k'    ;O0000000000000000000000000000000000000000x.
               'x000000000000000000000000000000000000000O;    c0000000000000000000000000000000000000000x'
                .d000000000000000000000000000000000000000c   .o000000000000000000000000000000000000000d.
                 .lO0000000000000000000000000000000000000o.  .d0000000000000000000000000000000000000Ol.
                   ;k000000000000000000000000000000000000d.  'k000000000000000000000000000000000000k;
                    .oO0000000000000000000000000000000000k'  ;O0000000000000000000000000000000000Oo.
                      ,d000000000000000000000000000000000O,  :0000000000000000000000000000000000d,
                       .;x00000000000000000000000000000000:..l00000000000000000000000000000000x;.
                         .;dO00000000000000000000000000000l.,d00000000000000000000000000000Od;.
                            'lk000000000000000000000000000d;cx000000000000000000000000000kl'
                              .,lk000000000000000000000000xodk000000000000000000000000kl,.
                                 .,cdO00000000000000000000OkOO00000000000000000000Odc,.
                                     .;cdkO0000000000000000000000000000000000Okdc;.
                                         .';cldkO0000000000000000000000Okdlc;'.
                                               ..',;:cclllloollllcc:;,'..
                           ':ccc,
                         .l0KKKK0d.
                         'kK0KK0K0;
     ..'.'.'.            .o0KKKKKx.
     :000000O,             ,cllc;.
     :0K000KO,
     c0K0K0KO,                                        .....              .....                        ......
.cdddk000KKK0kdddddc.     :ddddddc.     .ldddddl. ,coxkOOOkdol;.     'coxkOOOkdl;.               .;loxkOOOkkxoc,.
.xK0KK00KKKKKK0KK0Kd.    .oK0KK0Kx.     'OK0K0K0dx0KK0000000KKKOc. ,x0KK0000000KKOl.          .:dOKKK00000000KK0Oo,
.kKKKKK0KKKKKKKKKKKd.    .oK0KK0Kx.     'OK0KK0KK00KKKKKK00KKK0K0xdOK0KKKKKK000K00Kx'       .:kKK0K0KKKKKKKK00K00K0d'
.;cccx0K0K0K0dccccc;     .oK0KK0Kx.     'OK0KKK0K0xl;,,:oOK0KK000KKK0kl;,,:oOKK00K0Kd.     .o0K0K0K0xl:,,,:lk0K0KK0KO;
     :0K0K0KO,           .oK0KK0Kx.     'OK0KK0K0l.      'xK00KKK0K0l.      .dK0000K0;    .l000KK0x,.       .:kK0KK0KO,
     :0K0K0KO,           .oK0KK0Kx.     'OK0KK0Kd.        ,OKK0KK0Kd.        ,OK0KK0Kl    ,OK000Kk,...........:OK0KK0Ko.
     :0K0K0KO,           .oK0KK0Kx.     'OK0KKKKc         'kXK0000Kl         .xK0KK0Ko.   :0K000K0kkkkkkkkkkkkO0K0000Kx.
     :0K0K0KO,           .oK0KK0Kx.     'OK0KKKKc         'kXK0KK0Kl         .xK0KK0Ko.   :0K0K0K000000000000000000000x.
     :0K000KO,           .oK0KK0Kx.     'OK0KKK0c         'kXK00K0Kl         .xK0KK0Ko.   'OK0K0KOc....................
     :0K0K0K0l.          .oK0KK0Kx.     'OK0KKKKc         'kXK00K0Kl         .xK0KK0Ko.    l0K0K0Kk:.          'cl'
     ,OK0KK0K0xc;,,:.    .oK0KK0Kx.     'OK0KKKKc         'kXK0KK0Kl         .xK0KK0Ko.    .l0K0K0K0ko:,,',;:lx0KKOc.
      c0K0KKK0KKKKKKc    .oK0KK0Kx.     'OK0KKK0c         'kXK0KK0Kl         .xK0KK0Ko.      ;x0K0000KKK000KKK00K000x,
       ;k0KK0000000Kc    .oK0KK0Kx.     'OK00000c         'kXK0K00Kl         .xK0000Ko.       .;oO0KK000000000KKK0Oo:.
        .,cdxkOOOkxo'     :ddddddc.     .ldddddd,         .lxdddddd;         .cdddddd:           .,codxkOOOkkxol:,.
            ..''...                                                                                   ...''...
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.8.1;

interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the token decimals.
     */
    function decimals() external view returns (uint8);

    /**
     * @dev Returns the token symbol.
     */
    function symbol() external view returns (string memory);

    /**
    * @dev Returns the token name.
    */
    function name() external view returns (string memory);

    /**
     * @dev Returns the erc token owner.
     */
    function getOwner() external view returns (address);

    /**
     * @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 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 GSN 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 payable) {
        return payable(msg.sender);
    }

    function _msgData() internal view virtual returns (bytes memory) {
        // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        this;
        return msg.data;
    }
}

/**
 * @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) {
        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 This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {

    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        // solhint-disable-next-line no-inline-assembly
        assembly {cs := extcodesize(self)}
        return cs == 0;
    }
}

contract ERC20TokenImplementation is Context, IERC20, Initializable {
    using SafeMath for uint256;

    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) internal _allowances;
    uint256 internal _totalSupply;
    string internal _name;
    string internal _symbol;
    uint8 internal _decimals;

    address internal _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    bool internal _mintable;

    constructor() {
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
    * @dev Leaves the contract without owner. It will not be possible to call
    * `onlyOwner` functions anymore. Can only be called by the current owner.
    *
    * NOTE: Renouncing ownership will leave the contract without an owner,
    * thereby removing any functionality that is only available to the owner.
    */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    /**
     * @dev Returns if the token is mintable or not
     */
    function mintable() external view returns (bool) {
        return _mintable;
    }

    /**
     * @dev Returns the erc token owner.
     */
    function getOwner() external override view returns (address) {
        return _owner;
    }

    /**
     * @dev Returns the token decimals.
     */
    function decimals() external override view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Returns the token symbol.
     */
    function symbol() external override view returns (string memory) {
        return _symbol;
    }

    /**
    * @dev Returns the token name.
    */
    function name() external override view returns (string memory) {
        return _name;
    }

    /**
     * @dev See {ERC20-totalSupply}.
     */
    function totalSupply() external override view returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {ERC20-balanceOf}.
     */
    function balanceOf(address account) external override view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {ERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {ERC20-allowance}.
     */
    function allowance(address owner, address spender) external override view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {ERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) external override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {ERC20-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) external override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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 {ERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(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 {ERC20-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 returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
     * the total supply.
     *
     * Requirements
     *
     * - `msg.sender` must be the token owner
     * - `_mintable` must be true
     */
    function mint(uint256 amount) public onlyOwner returns (bool) {
        require(_mintable, "this token is not mintable");
        _mint(_msgSender(), amount);
        return true;
    }

    /**
   * @dev Burn `amount` tokens and decreasing the total supply.
   */
    function burn(uint256 amount) public returns (bool) {
        _burn(_msgSender(), amount);
        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 {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(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 {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(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 {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is 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 {
        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 Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}

contract Time is ERC20TokenImplementation {

    /**
     * @dev TimeZones are candidates possible to be yield farmed
     */

    function _maxInt() private pure returns (uint256) {
        return 2 ** 256 - 1;
    }

    function _secondsInDay() private pure returns (uint256) {
        return 86400;
    }

    struct TimeZone {
        uint256 index;
        string id;
        string description;
        address contractAddress;
    }

    mapping(string => TimeZone) private _timeZoneMap;
    string[] private _timeZoneKeys;


    function _upsertTimeZone(string calldata id, string calldata description, address contractAddress) private onlyOwner returns (bool) {
        TimeZone storage timeZoneToUpsert = _timeZoneMap[id];
        timeZoneToUpsert.id = id;
        timeZoneToUpsert.description = description;
        timeZoneToUpsert.contractAddress = contractAddress;
        if (timeZoneToUpsert.index > 0) {// entry exists
            // do nothing
            return true;
        } else {// new entry
            _timeZoneKeys.push(id);
            uint256 keyListIndex = _timeZoneKeys.length - 1;
            timeZoneToUpsert.index = keyListIndex + 1;
        }
        return true;
    }

    function _removeTimeZone(string calldata id) private onlyOwner returns (bool) {
        TimeZone storage timeZoneToRemove = _timeZoneMap[id];
        // entry not exist
        require(timeZoneToRemove.index != 0, "Provided TimeZone does not exist!");
        // invalid index value
        require(timeZoneToRemove.index <= _timeZoneKeys.length, "Provided TimeZone index is invalid!");

        // Move an last element of array into the vacated key slot.
        uint256 keyListIndex = timeZoneToRemove.index - 1;
        uint256 keyListLastIndex = _timeZoneKeys.length - 1;
        _timeZoneMap[_timeZoneKeys[keyListLastIndex]].index = keyListIndex + 1;
        _timeZoneKeys[keyListIndex] = _timeZoneKeys[keyListLastIndex];
        _timeZoneKeys.pop();
        delete _timeZoneMap[id];
        return true;
    }

    function _timeZonesSize() private view returns (uint256) {
        return uint256(_timeZoneKeys.length);
    }

    function _timeZoneExists(string calldata id) private view returns (bool) {
        return _timeZoneMap[id].index > 0;
    }

    function _timeZoneById(string calldata id) private view returns (TimeZone memory) {
        return _timeZoneMap[id];
    }

    /**
     * @dev Voting proportion of an account for which time zone to farm from
     */
    struct VotingProportion {
        uint256 index;
        string[] zoneIds;
        uint256[] proportions;
    }

    mapping(address => VotingProportion) private _votingProportionMap;
    address[] private _votingProportionKeys;

    function _upsertVotingProportion(address key, string[] memory zoneIds, uint256[] memory proportions) private returns (bool) {
        VotingProportion storage votingProportionToUpsert = _votingProportionMap[key];
        votingProportionToUpsert.zoneIds = zoneIds;
        votingProportionToUpsert.proportions = proportions;
        if (votingProportionToUpsert.index > 0) {// entry exists
            // do nothing
            return true;
        } else {// new entry
            _votingProportionKeys.push(key);
            uint256 keyListIndex = _votingProportionKeys.length - 1;
            votingProportionToUpsert.index = keyListIndex + 1;
        }
        return true;
    }

    function _removeVotingProportion(address key) private returns (bool) {
        VotingProportion storage votingProportionToRemove = _votingProportionMap[key];
        // entry not exist
        require(votingProportionToRemove.index != 0, "Provided voting proportion does not exist!");
        // invalid index value
        require(votingProportionToRemove.index <= _votingProportionKeys.length, "Provided voting proportion index is invalid!");

        // Move an last element of array into the vacated key slot.
        uint256 keyListIndex = votingProportionToRemove.index - 1;
        uint256 keyListLastIndex = _votingProportionKeys.length - 1;
        _votingProportionMap[_votingProportionKeys[keyListLastIndex]].index = keyListIndex + 1;
        _votingProportionKeys[keyListIndex] = _votingProportionKeys[keyListLastIndex];
        _votingProportionKeys.pop();
        delete _votingProportionMap[key];
        return true;
    }

    function _votingProportionSize() private view returns (uint256) {
        return uint256(_votingProportionKeys.length);
    }

    function _votingProportionByKey(address key) private view returns (VotingProportion memory) {
        return _votingProportionMap[key];
    }


    struct PriceInfo {
        uint256 timeStampFrom;
        uint256 timeStampTo;
        uint256 priceFrom;
        uint256 priceTo;
        uint256 computedPrice;
    }

    /**
     * @dev Admin private variables
     */
    address private _liquidity;
    address private _baseCurrency;
    uint256 private _expense;

    /**
     * @dev Time pricing related private variables
     */
    uint256 private _minTimeStamp;
    uint256 private _maxTimeStamp;
    mapping(uint256 => uint256) private _timeStampToPrice;

    // Voting Events
    event TimeZoneUpdated(string id, string description, address contractAddress);
    event TimeZoneRemoved(string id);
    event Voted(address votingAccount, string[] zoneIds, uint256[] proportions);
    event Unvoted(address votingAccount);
    event TimeZonesCleaned();
    event VotingProportionCleaned();

    // Admin Events
    event LiquidityChanged(address previousLiquidity, address newLiquidity);
    event BaseCurrencyChanged(address previousBaseCurrency, address newBaseCurrency, uint256 rate);

    // Time Events
    event TimeBought(uint256 timeAmount, uint256 baseCurrencyAmount, address buyer);
    event TimeSold(uint256 timeAmount, uint256 baseCurrencyAmount, address seller);
    event LapseProved(uint256 newPrice, uint256 newTimeStamp, uint256 expense);
    event Reimbursed(uint256 expense);

    constructor() {
        _timeZoneKeys = new string[](0);
        _votingProportionKeys = new address[](0);
        _maxTimeStamp = 0;
        _minTimeStamp = _maxInt();
        _expense = 0;
    }

    /**
     * @dev sets initials supply and the owner
     */
    function initialize(string memory name, string memory symbol, uint8 decimals, uint256 amount, bool mintable, address owner, address liquidityIn, address baseCurrencyIn) external initializer {
        require(owner != address(0), "Address(owner) cannot be zero!");
        require(liquidityIn != address(0), "Address(liquidityIn) cannot be zero!");
        require(baseCurrencyIn != address(0), "Address(baseCurrencyIn) cannot be zero!");
        _owner = owner;
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        _mintable = mintable;
        _liquidity = liquidityIn;
        _baseCurrency = baseCurrencyIn;
        _mint(owner, amount);
    }

    function addOrUpdateTimeZone(string calldata id, string calldata description, address contractAddress) external onlyOwner returns (bool) {
        require(_upsertTimeZone(id, description, contractAddress), "Failed to upsert new time zone!");
        emit TimeZoneUpdated(id, description, contractAddress);
        return true;
    }

    function removeTimeZone(string calldata id) external onlyOwner returns (bool) {
        require(_removeTimeZone(id), "Failed to remove time zone!");
        emit TimeZoneRemoved(id);
        return true;
    }

    function timeZone(string calldata id) external view returns (TimeZone memory) {
        return _timeZoneById(id);
    }

    function timeZoneIds() external view returns (string[] memory) {
        return _timeZoneKeys;
    }

    function vote(string[] calldata zoneIds, uint256[] calldata proportions) external returns (bool) {
        require(zoneIds.length == proportions.length, "Voting zone length and proportion length does not match!");
        bool allKeyExists = true;
        uint256 proportionSum = 0;
        uint256 zoneIdsLength = zoneIds.length;
        for (uint256 i = 0; i < zoneIdsLength; i++) {
            allKeyExists = allKeyExists && _timeZoneExists(zoneIds[i]);
            proportionSum += proportions[i];
        }
        require(allKeyExists, "Input contains wrong candidate id(s)!");
        require(proportionSum == 1 ether, "Voting proportion must add up to 1 ether");
        require(_upsertVotingProportion(msg.sender, zoneIds, proportions), "Failed to update voting proportions!");
        emit Voted(msg.sender, zoneIds, proportions);
        return true;
    }

    function unvote() external returns (bool) {
        require(_removeVotingProportion(msg.sender), "Failed to remove voting proportion!");
        emit Unvoted(msg.sender);
        return true;
    }

    function votingProportion(address account) external view returns (VotingProportion memory) {
        return _votingProportionByKey(account);
    }

    function votingResult() external view returns (uint256[] memory) {
        uint256[] memory votingResultToReturn = new uint256[](_timeZonesSize());
        for (uint256 i = 0; i < _votingProportionSize(); i++) {
            address account = _votingProportionKeys[i];
            uint256 accountBalance = _balances[account];
            string[] storage zoneIds = _votingProportionMap[account].zoneIds;
            uint256 zoneIdsLength = zoneIds.length;
            for (uint256 j = 0; j < zoneIdsLength; j++) {
                uint256 zoneIndex = _timeZoneMap[zoneIds[j]].index - 1;
                uint256 accountVotingProportion = _votingProportionMap[account].proportions[j];
                votingResultToReturn[zoneIndex] += (accountBalance * accountVotingProportion) / 1 ether;
            }
        }
        return votingResultToReturn;
    }

    function cleanVotingProportion() external onlyOwner returns (bool) {
        uint256 votingProportionSize = _votingProportionSize();
        for (uint256 i = 0; i < votingProportionSize; i++) {
            delete _votingProportionMap[_votingProportionKeys[i]];
        }
        delete _votingProportionKeys;
        emit VotingProportionCleaned();
        return true;
    }

    function cleanTimeZones() external onlyOwner returns (bool) {
        uint256 timeZonesSize = _timeZonesSize();
        for (uint256 i = 0; i < timeZonesSize; i++) {
            delete _timeZoneMap[_timeZoneKeys[i]];
        }
        delete _timeZoneKeys;
        emit TimeZonesCleaned();
        return true;
    }

    /**
     * @dev changes the liquidity account
     */
    function setLiquidity(address liquidity) external onlyOwner returns (bool) {
        require(liquidity != address(0), "Address(liquidity) cannot be zero!");
        address previousLiquidity = _liquidity;
        _liquidity = liquidity;
        emit LiquidityChanged(previousLiquidity, _liquidity);
        return true;
    }

    /**
     * @dev main currency that time is backed - most likely one of the fiat base stablecoin
     */
    function baseCurrency() external view returns (address) {
        return _baseCurrency;
    }

    /**
     * @dev changes base currency contract, need to provide rate which is newBaseCurrency/currentBaseCurrency
     */
    function setBaseCurrency(address newBaseCurrency, uint256 rate) external onlyOwner returns (bool) {
        require(newBaseCurrency != address(0), "Address(newBaseCurrency) cannot be zero!");
        address previousBaseCurrency = _baseCurrency;
        _baseCurrency = newBaseCurrency;
        for (uint256 timeStamp = _minTimeStamp; timeStamp <= _maxTimeStamp; timeStamp = timeStamp + _secondsInDay()) {
            if (_timeStampToPrice[timeStamp] != 0) {
                _timeStampToPrice[timeStamp] = _applyRate(_timeStampToPrice[timeStamp], rate);
            }
        }
        emit BaseCurrencyChanged(previousBaseCurrency, _baseCurrency, rate);
        return true;
    }

    function _applyRate(uint256 value, uint256 rate) internal pure returns (uint256) {
        require(value * rate > 1 ether, "Provided rate is too small!");
        return (value * rate) / 1 ether;
    }

    function _baseLiquidityAmount() internal view returns (uint256) {
        return IERC20(_baseCurrency).balanceOf(address(_liquidity));
    }

    /**
     * @dev maximum amount time can be sold back at the moment
     * if this value is small, time service will refill liquidity with base currency
     */
    function maxTimeSellAmount() public view returns (uint256) {
        return (_baseLiquidityAmount() * 1 ether) / currentPrice();
    }

    /**
     * @dev the actual live price - this price is used in maxTimeSellAmount and sellForBase
     */
    function currentPrice() public view returns (uint256) {
        uint256 currentTimeStamp = block.timestamp;
        return _computePriceInfo(currentTimeStamp).computedPrice;
    }

    /**
     * @dev start price of the current timeframe
     */
    function currentStartPrice() public view returns (uint256) {
        uint256 currentTimeStamp = block.timestamp;
        return _computePriceInfo(currentTimeStamp).priceFrom;
    }

    /**
     * @dev end price of the current timeframe
     * when buying time, it can be only bought with this price
     */
    function currentEndPrice() public view returns (uint256) {
        uint256 currentTimeStamp = block.timestamp;
        return _computePriceInfo(currentTimeStamp).priceTo;
    }

    /**
     * @dev start timestamp of the current timeframe
     */
    function currentStartTimeStamp() public view returns (uint256) {
        uint256 currentTimeStamp = block.timestamp;
        return _computePriceInfo(currentTimeStamp).timeStampFrom;
    }

    /**
     * @dev end timestamp of the current timeframe
     */
    function currentEndTimeStamp() public view returns (uint256) {
        uint256 currentTimeStamp = block.timestamp;
        return _computePriceInfo(currentTimeStamp).timeStampTo;
    }

    /**
     * @dev full priceinfo object of the current timeframe
     */
    function currentPriceInfo() public view returns (PriceInfo memory) {
        uint256 currentTimeStamp = block.timestamp;
        return _computePriceInfo(currentTimeStamp);
    }

    /**
     * @dev price of a given historical time
     */
    function historicalPrice(uint256 timeStamp) public view returns (uint256) {
        return _computePriceInfo(timeStamp).computedPrice;
    }

    /**
     * @dev full priceinfo object of a given historical time
     */
    function historicalPriceInfo(uint256 timeStamp) public view returns (PriceInfo memory) {
        return _computePriceInfo(timeStamp);
    }

    function _computePriceInfo(uint256 timeStamp) internal view returns (PriceInfo memory) {
        if (timeStamp <= _minTimeStamp) {
            uint256 minPrice = _timeStampToPrice[_minTimeStamp];
            return PriceInfo(_minTimeStamp, _minTimeStamp, minPrice, minPrice, minPrice);
        }
        if (_maxTimeStamp <= timeStamp) {
            uint256 maxPrice = _timeStampToPrice[_maxTimeStamp];
            return PriceInfo(_maxTimeStamp, _maxTimeStamp, maxPrice, maxPrice, maxPrice);
        }

        uint256 secondInDay = timeStamp % _secondsInDay();

        uint256 timeStampFrom = timeStamp - secondInDay;
        uint256 timeStampTo = timeStampFrom + _secondsInDay();
        uint256 priceFrom = _timeStampToPrice[timeStampFrom];
        uint256 priceTo = _timeStampToPrice[timeStampTo];

        if (secondInDay == 0) {
            return PriceInfo(timeStampFrom, timeStampTo, priceFrom, priceTo, priceFrom);
        }
        if (priceTo <= priceFrom) {
            return PriceInfo(timeStampFrom, timeStampTo, priceFrom, priceTo, priceTo);
        }

        uint256 priceRange = priceTo - priceFrom;
        uint256 timeRange = timeStampTo - timeStampFrom;
        uint256 timePassed = timeStamp - timeStampFrom;
        uint256 price = ((priceRange * timePassed) / timeRange) + priceFrom;
        return PriceInfo(timeStampFrom, timeStampTo, priceFrom, priceTo, price);
    }

    /**
     * @dev buy time coin with base currency end price
     */
    function buyForBase(uint256 timeAmount) external returns (bool) {
        require(timeAmount * currentEndPrice() > 1 ether, "Provided timeAmount is too small!");
        uint256 baseAmount = (timeAmount * currentEndPrice()) / 1 ether;
        IERC20(_baseCurrency).transferFrom(msg.sender, _liquidity, baseAmount);
        _mint(msg.sender, timeAmount);
        emit TimeBought(timeAmount, baseAmount, msg.sender);
        return true;
    }

    /**
     * @dev sell time coin with base currency current price
     */
    function sellForBase(uint256 timeAmount) external returns (bool) {
        require(timeAmount * currentPrice() > 1 ether, "Provided timeAmount is too small!");
        require(maxTimeSellAmount() > timeAmount, "Time amount to sell should be lower than maxTimeSellAmount()!");
        uint256 baseAmount = (timeAmount * currentPrice()) / 1 ether;
        IERC20(_baseCurrency).transferFrom(_liquidity, msg.sender, baseAmount);
        _burn(msg.sender, timeAmount);
        emit TimeSold(timeAmount, baseAmount, msg.sender);
        return true;
    }

    /**
     * @dev reimburse expense
     */
    function reimburse() external onlyOwner returns (bool) {
        require(_baseLiquidityAmount() > _expense, "Not enough base liquidity amount!");
        IERC20(_baseCurrency).transferFrom(_liquidity, msg.sender, _expense);
        emit Reimbursed(_expense);
        _expense = 0;
        return true;
    }

    function expenseAmount() external view returns (uint256) {
        return _expense;
    }

    /**
     * @dev run proof of lapse process using interest gained and amount of released coin (excluding owned by time itself)
     */
    function proofOfLapse(uint256 capitalGain, uint256 releasedCoins, uint256 newTimeStamp, uint256 expense) external onlyOwner returns (bool) {
        require(newTimeStamp % _secondsInDay() == 0, "TimeStamp should be divisible by 86400!");
        uint256 previousPrice = historicalPrice(newTimeStamp - _secondsInDay());
        uint256 newPrice = previousPrice + (((capitalGain - expense - _expense) * 1 ether) / releasedCoins);
        return proofOfLapse(newPrice, newTimeStamp, expense);
    }

    /**
     * @dev run proof of lapse process using new end price
     */
    function proofOfLapse(uint256 newPrice, uint256 newTimeStamp, uint256 expense) public onlyOwner returns (bool) {
        require(newTimeStamp % _secondsInDay() == 0, "TimeStamp should be divisible by 86400!");
        _expense = _expense + expense;
        _timeStampToPrice[newTimeStamp] = newPrice;
        if (newTimeStamp < _minTimeStamp) {
            _minTimeStamp = newTimeStamp;
        }
        if (_maxTimeStamp < newTimeStamp) {
            _maxTimeStamp = newTimeStamp;
        }
        emit LapseProved(newPrice, newTimeStamp, expense);
        return true;
    }
}