Contract 0x8d37b12DB32E07d6ddF10979c7e3cDECCac3dC13 5

/**
 *Submitted for verification at polygonscan.com on 2021-11-07
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with 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 msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


pragma solidity ^0.7.0;

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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `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);
}


pragma solidity ^0.7.0;

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


pragma solidity ^0.7.0;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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);
        _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 {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].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 {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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _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 virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _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 virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _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 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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}


pragma solidity ^0.7.0;

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    using SafeMath for uint256;

    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");

        _approve(account, _msgSender(), decreasedAllowance);
        _burn(account, amount);
    }
}



pragma solidity ^0.7.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


pragma solidity ^0.7.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


pragma solidity ^0.7.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}


pragma solidity ^0.7.6;

// KommunitasVoting - Governance Token
contract KommunitasVoting is ERC20("KommunitasVoting", "KOMV"), Ownable {
    using SafeMath for uint256;
    
    IERC20 public immutable oldKomV;
    bool public oneToken = true;
    bool public swapPaused = false;
    
    mapping(address => bool) public permissioned;
    
    modifier hasPermission{
        if(oneToken){
            require(permissioned[msg.sender], "You are not allowed to run this function");
        }
        _;
    }
    
    modifier onlyPermission{
        require(permissioned[msg.sender], "You are not allowed to run this function");
        _;
    }
    
    modifier isSwapPaused{
        require(!swapPaused, "Swap to New KomV is Paused");
        _;
    }
    
    constructor (IERC20 _oldKomV){
        oldKomV = _oldKomV;
        _setupDecimals(0);
    }
    
    function swapToKomV2() isSwapPaused public {
        require(oldKomV.balanceOf(msg.sender) > 0, "You don't have any old KomV");
        
        uint256 oldAmount = oldKomV.balanceOf(msg.sender);
        oldKomV.transferFrom(msg.sender, 0x000000000000000000000000000000000000dEaD, oldAmount);
        
        if(oneToken){
            require(balanceOf(msg.sender) == 0, "You are just allowed to have 1 new KomV");
            _mint(msg.sender, 1);
            _moveDelegates(address(0), _delegates[_msgSender()], 1);
        } else{
            _mint(msg.sender, oldAmount);
            _moveDelegates(address(0), _delegates[_msgSender()], oldAmount);
        }
    }
    
    /// @notice Creates `_amount` token to `_to`. Must only be called by the Permissioned Contract.
    function mint(address _to, uint256 _amount) public onlyPermission {
        _mint(_to, _amount);
        _moveDelegates(address(0), _delegates[_to], _amount);
    }
    
    /// @notice Destroys `_amount` token to `_to`. Must only be called by the Permissioned Contract.
    function burn(address _to, uint256 _amount) public onlyPermission {
        _burn(_to, _amount);
        _moveDelegates(_delegates[_to], address(0), _amount);
    }
    
    function transfer(address recipient, uint256 amount) public override hasPermission returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        _moveDelegates(_delegates[_msgSender()], _delegates[recipient], amount);
        return true;
    }
    
    function transferFrom(address sender, address recipient, uint256 amount) public override hasPermission returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), allowance(sender, _msgSender()).sub(amount, "ERC20: transfer amount exceeds allowance"));
        _moveDelegates(_delegates[sender], _delegates[recipient], amount);
        return true;
    }
    
    function setPermission(address _target, bool _status) public onlyOwner returns(bool){
        require(_target != address(0), "Can't assigned to address(0)");
        permissioned[_target] = _status;
        return true;
    }
    
    function toggleOneToken() public onlyOwner{
        oneToken = !oneToken;
    }
    
    function toggleSwap() public onlyOwner{
        swapPaused = !swapPaused;
    }

    /// @dev A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    /// @notice A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

      /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @notice Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "KOMV::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "KOMV::delegateBySig: invalid nonce");
        require(block.timestamp <= expiry, "KOMV::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "KOMV::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying KOMVs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld - amount;
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld + amount;
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "KOMV::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}


pragma solidity = 0.7.6;
pragma experimental ABIEncoderV2;

contract KommunitasStakingV2 is Ownable {
    using SafeMath for uint256;
    
    modifier isStakePaused{
        require(!stakePaused, "Stake is Paused");
        _;
    }
    
    /* ========== STATE VARIABLES ========== */
    ERC20Burnable public immutable komToken;
    KommunitasVoting public immutable komVToken;    //Kommunitas Voting Token  
    
    uint256 public constant MIN_STAKING_AMOUNT = 100*1e8; //100 Kommunitas Token
    uint256 public apy;
    bool public stakePaused = false;
    uint256 public penaltyFeesPercentage = 20;   //20% inital penalty fee
    uint256 constant yearDuration = 365 days;
    uint256 public minPrivateSale;
    uint256[3] public lockPeriod;
    address[] private userStaked;
    
    struct KomStaked{
        uint256 lockPeriodIndex;
        uint256 multiplier;
        uint256 kommunitasStaked;
    }

    struct TokenLock {
        uint256 lockPeriodIndex;
        uint256 userStakedIndex;
        uint256 amount;
        uint256 start;
        uint256 maturity;
        uint256 reward;
        uint256 claimedTime;
        bool premature;
        bool claimed;
    }
    
    mapping(address => TokenLock[]) public locks;
    mapping(uint256 => KomStaked) public staked;
    
    
    /* ========== EVENTS ========== */

    event Locked (address indexed _of, uint256 _amount, uint256 _reward, uint256 _maturity);
    event Unlocked (address indexed _of, uint256 _amount);
    event EmergencyUnlocked (address indexed _of, uint256 _amount);

     /* ========== CONSTRUCTOR ========== */
    constructor(address _komToken, address _komVToken, uint256 _apy, uint256[3] memory _lockPeriod, uint256[3] memory _multiplier, uint256 _minPrivateSale) {
        komToken = ERC20Burnable(_komToken);
        komVToken = KommunitasVoting(_komVToken);
        apy = _apy;
        for(uint256 i=0; i<3; i++){
            lockPeriod[i] = _lockPeriod[i] * 1 days;
            
            staked[lockPeriod[i]].lockPeriodIndex = i;
            staked[lockPeriod[i]].multiplier = _multiplier[i];
            staked[lockPeriod[i]].kommunitasStaked = 0;
        }
        minPrivateSale = _minPrivateSale;
    }

    function calculateReward(uint256 _amount, uint256 _lockPeriod) 
    public 
    view returns (uint256 _lockReward) {   
        uint256 multiplier = staked[_lockPeriod].multiplier;
        if (multiplier == 0){
            multiplier = 10;
        }
        uint256 effectiveAPY = multiplier.mul(apy).mul(_lockPeriod).mul(1e10).div(yearDuration).div(10); 
        _lockReward = effectiveAPY.mul(_amount).div(1e12);
    }

    /**
     * @dev Locks specified amount of tokens for a specified period lock time
     * @param _amount Number of tokens to be locked
     * @param _lockPeriod Lock period in seconds
     */
    function stake(uint256 _amount, uint256 _lockPeriod) isStakePaused public {
        require(msg.sender != address(0),"Zero Address");
        require(_amount >= MIN_STAKING_AMOUNT, "Minimum staking amount is 100 KOM");
        require(lockPeriod[staked[_lockPeriod].lockPeriodIndex] == _lockPeriod, "Lock Period Not Exist");

        uint256 matureUntil = block.timestamp.add(_lockPeriod);
        uint256 lockReward = calculateReward(_amount, _lockPeriod);

        uint userId;
        if(everStaked(msg.sender) == false){
            userStaked.push(msg.sender);
            userId = userStaked.length-1;
        }else{
            userId = locks[msg.sender][0].userStakedIndex;
        }
        
        komToken.transferFrom(msg.sender, address(this), _amount);
        locks[msg.sender].push(TokenLock(staked[_lockPeriod].lockPeriodIndex, userId, _amount, block.timestamp, matureUntil, lockReward, 0, false, false));
        staked[_lockPeriod].kommunitasStaked += _amount;
        
        if(getUserStakedTokens(msg.sender) >= 3000*1e8 && komVToken.balanceOf(msg.sender) == 0){
            komVToken.mint(msg.sender, 1);
        }
        
        emit Locked(msg.sender, _amount, lockReward, matureUntil);
    }

    /**
     * @dev Unlocks the unlockable tokens
     * @param _sid User staked index
     */
    function unlock(uint256 _sid) public returns (uint256) {
        require(locks[msg.sender].length > _sid, "Exceed the user history stake length");
        require(locks[msg.sender][_sid].maturity <= block.timestamp, "Still pre-mature");
        require(!locks[msg.sender][_sid].claimed, "Already claimed");
        
        uint256 unlockableTokens = locks[msg.sender][_sid].amount.add(locks[msg.sender][_sid].reward);
        uint256 unlockablePrincipalStakedAmount = locks[msg.sender][_sid].amount;
        
        locks[msg.sender][_sid].claimedTime = block.timestamp;
        locks[msg.sender][_sid].claimed = true;
        staked[lockPeriod[locks[msg.sender][_sid].lockPeriodIndex]].kommunitasStaked -= unlockablePrincipalStakedAmount;
        
        if(getUserStakedTokens(msg.sender) < 3000*1e8 && komVToken.balanceOf(msg.sender) > 0){
            komVToken.burn(msg.sender, 1);
        }
        
        komToken.transfer(msg.sender, unlockableTokens);
        emit Unlocked(msg.sender, unlockableTokens);
        return unlockableTokens;
    }

    /**
     * @dev Pre Mature Withdrawal without caring about rewards. WILL CHARGE PENALTY FEES.
     */
    function preMatureWithdraw(uint256 _sid, uint256 _amount) external returns (uint256) {
        require(locks[msg.sender].length > _sid, "Exceed the user history stake length");
        require(locks[msg.sender][_sid].maturity > block.timestamp, "Not pre-mature");
        require(!locks[msg.sender][_sid].claimed, "Already claimed");
        require(locks[msg.sender][_sid].amount >= _amount, "pre-mature amount exceeds");
        
        uint256 unlockableTokens;
        
        if(locks[msg.sender][_sid].amount == _amount){
            unlockableTokens = locks[msg.sender][_sid].amount;
            
            locks[msg.sender][_sid].claimed = true;
        } else{
            unlockableTokens = _amount;
            
            TokenLock memory temp = locks[msg.sender][_sid];
            locks[msg.sender].push(temp);
            uint newSid = locks[msg.sender].length-1;
            locks[msg.sender][newSid].amount = _amount;
            locks[msg.sender][newSid].reward = calculateReward(_amount, lockPeriod[locks[msg.sender][newSid].lockPeriodIndex]);
            locks[msg.sender][newSid].claimedTime = block.timestamp;
            locks[msg.sender][newSid].premature = true;
            locks[msg.sender][newSid].claimed = true;
            
            locks[msg.sender][_sid].amount = locks[msg.sender][_sid].amount.sub(_amount);
            locks[msg.sender][_sid].reward = calculateReward(locks[msg.sender][_sid].amount, lockPeriod[locks[msg.sender][_sid].lockPeriodIndex]);
        }
        
        uint256 penaltyAmount = unlockableTokens.mul(penaltyFeesPercentage).div(100);
        uint256 withdrawableAmount = unlockableTokens.sub(penaltyAmount);

        komToken.burn(penaltyAmount);

        staked[lockPeriod[locks[msg.sender][_sid].lockPeriodIndex]].kommunitasStaked -= unlockableTokens;
        
        if(getUserStakedTokens(msg.sender) < 3000*1e8 && komVToken.balanceOf(msg.sender) > 0){
            komVToken.burn(msg.sender, 1);
        }
        
        komToken.transfer(msg.sender, withdrawableAmount);
        
        emit EmergencyUnlocked(msg.sender, unlockableTokens);
        return unlockableTokens;
    }

    /**
     * @dev Gets the length stake history of a specified address
     * @param _of The address to query the length stake history of
     */
    function getUserStakedLength(address _of) public view returns(uint256){
        return locks[_of].length;
    }
    
    function getUserStakedInfo(address _of, uint256 _sid) public view returns(
        uint256 amount,
        uint256 start,
        uint256 maturity,
        uint256 reward,
        bool claimed
    ){
        amount = locks[_of][_sid].amount;
        start = locks[_of][_sid].start;
        maturity = locks[_of][_sid].maturity;
        reward = locks[_of][_sid].reward;
        claimed = locks[_of][_sid].claimed;
    }

    /**
     * @dev Gets the total withdrawable tokens of a specified address
     * @param _of The address to query the the withdrawable token count of
     */
    function getTotalWithdrawableTokens(address _of) public view returns (uint256) {
        uint256 withdrawableTokens;
        uint256 locksLength = locks[_of].length;
        for (uint256 i = 0; i < locksLength; i++) {
            if (locks[_of][i].maturity <= block.timestamp && !locks[_of][i].claimed) {
                withdrawableTokens = withdrawableTokens.add(locks[_of][i].amount).add(locks[_of][i].reward);
            }
        }
        return withdrawableTokens;
    }    

    /**
     * @dev Gets the total locked tokens of a specified address
     * @param _of The address to query the the locked token count of
     */
    function getTotalLockedTokens(address _of) public view returns (uint256) {
        uint256 lockedTokens;
        uint256 locksLength = locks[_of].length;
        for (uint256 i = 0; i < locksLength; i++) {
            if (locks[_of][i].maturity > block.timestamp && !locks[_of][i].claimed) {
                lockedTokens = lockedTokens.add(locks[_of][i].amount).add(locks[_of][i].reward);
            }
        }
        return lockedTokens;
    }


    /**
     * @dev Gets the pending rewards tokens of a specified address to be claimed
     * @param _of The address to query the the pending rewards for
     */
    function getUserPendingRewards(address _of) public view returns (uint256) {
        uint256 pendingRewards;
        uint256 locksLength = locks[_of].length;
        for (uint256 i = 0; i < locksLength; i++) {
            if (locks[_of][i].maturity <= block.timestamp && !locks[_of][i].claimed) {
                pendingRewards = pendingRewards.add(locks[_of][i].reward);
            }
        }
        return pendingRewards;
    }
    
    /**
     * @dev Gets the staked tokens of a specified address
     * @param _of The address to query the the locked token count of
     */
    function getUserStakedTokens(address _of) public view returns (uint256) {
        uint256 lockedTokens;
        uint256 locksLength = locks[_of].length;
        for (uint256 i = 0; i < locksLength; i++) {
            if (!locks[_of][i].claimed) {
                lockedTokens = lockedTokens.add(locks[_of][i].amount);
            }
        }
        return lockedTokens;
    }
    
    /**
     * @dev Gets the staked tokens of a specified address & date before
     * @param _of The address to query the the locked token count of
     */
    function getUserStakedTokensBeforeDate(address _of, uint256 _before) public view returns (uint256) {
        uint256 lockedTokens;
        uint256 locksLength = locks[_of].length;
        for (uint256 i = 0; i < locksLength; i++) {
            if (!locks[_of][i].claimed && locks[_of][i].start <= _before) {
                lockedTokens = lockedTokens.add(locks[_of][i].amount);
            }
        }
        return lockedTokens;
    }

    /**
     * @dev Gets the next unlock of a specified address
     * @param _of The address to query the the locked token count of
     */
    function getUserNextUnlock(address _of) public view returns (uint256, uint256) {
        uint256 nextUnlockTime;
        uint256 nextUnlockRewards;
        uint256 locksLength = locks[_of].length;
        for (uint256 i = 0; i < locksLength; i++) {
            uint256 maturity = locks[_of][i].maturity;
            if (maturity > block.timestamp && !locks[_of][i].claimed) {
                if(nextUnlockTime == 0 || nextUnlockTime > maturity) 
                {
                    nextUnlockTime = maturity;
                    nextUnlockRewards = locks[_of][i].reward;
                }
            }
        }
        return (nextUnlockTime,nextUnlockRewards);
    }
    
    /**
     * @dev Gets the stake status of a specified address
     * @param _of The address to query the stake status of
     */
    function everStaked(address _of) public view returns(bool){
        if(userStaked.length == 0) return false;
        return (getUserStakedLength(_of) > 0);
    }
    
    /**
     * @dev Gets the total Staked of all Users start from private sale
     */
    function getTotalStakedMinPrivateSale() public view returns(uint256 total){
        total = 0;
        
        for(uint256 i=0; i<userStaked.length; i++){
            if(getUserStakedTokens(userStaked[i]) >= minPrivateSale){
                total += getUserStakedTokens(userStaked[i]);
            }
        }
    }
    
     /**
     * @dev Gets the total staking amount + rewards of all Users until now
     */
    function getTotalRewards() public view returns(uint256 totalRewards){
        totalRewards = 0;
        for(uint256 i=0; i<userStaked.length; i++){
            for(uint256 j=0; j<locks[userStaked[i]].length; j++){
                totalRewards += locks[userStaked[i]][j].amount.add(locks[userStaked[i]][j].reward);
            }
        }
    }
    
    /**
     * @dev Gets the total staking amount of all Users before date
     */
    function getTotalStakedAmountBeforeDate(uint256 _before) public view returns(uint256 totalStaked){
        totalStaked = 0;
        for(uint256 i=0; i<userStaked.length; i++){
            for(uint256 j=0; j<locks[userStaked[i]].length; j++){
                if(!locks[userStaked[i]][j].claimed && locks[userStaked[i]][j].start <= _before){
                    totalStaked += locks[userStaked[i]][j].amount;
                }
            }
        }
    }
    
    /**
     * @dev Gets the total staking info
     */
    function getStakedInfo() public view returns(KomStaked memory first, KomStaked memory second, KomStaked memory third){
        first = staked[lockPeriod[0]];
        second = staked[lockPeriod[1]];
        third = staked[lockPeriod[2]];
    }
    
    function getLockPeriod() public view returns(uint256[3] memory result){
        result = lockPeriod;
    }

    /* ========== RESTRICTED FUNCTIONS ========== */

    /**
     * @dev Change multiplier for rewards for a particularDuration.
     * @param _multiplier Value of new multiplier (x / 1e2).
     * @param _oldLockPeriod Old Lock Period in days to remove.
     * @param _newLockPeriod New Lock Period in days to assign.
     */
    function setPeriod(uint256 _multiplier, uint256 _oldLockPeriod, uint256 _newLockPeriod) public onlyOwner {
        uint256 oldPeriodInSecs = _oldLockPeriod * 1 days;
        uint256 newPeriodInSecs = _newLockPeriod * 1 days;
        
        require(lockPeriod[staked[oldPeriodInSecs].lockPeriodIndex] == oldPeriodInSecs, "Old Lock Period Not Exist");
        
        // old index lock period to move
        uint256 indexToMove = staked[oldPeriodInSecs].lockPeriodIndex;
        
        // assign new lock period
        lockPeriod[indexToMove] = newPeriodInSecs;
        
        staked[newPeriodInSecs].lockPeriodIndex = indexToMove;
        staked[newPeriodInSecs].multiplier = _multiplier;
        staked[newPeriodInSecs].kommunitasStaked = staked[oldPeriodInSecs].kommunitasStaked;
        
        // delete old lock period from mapping
        delete staked[oldPeriodInSecs];
    }
    
    function setMinPrivateSale(uint256 _minPrivateSale) public onlyOwner{
        require(_minPrivateSale > 0, "Can't be 0");
        minPrivateSale = _minPrivateSale;
    }

    function updatePenaltyFees(uint256 _feesPercentage) public onlyOwner{
        // Fees shouldn't be greater than 10%
        require(_feesPercentage <= 10, "Very High fees");
        penaltyFeesPercentage = _feesPercentage;
    }

    function updateAPY(uint256 _apy) public onlyOwner{
        apy = _apy;
    }
    
    function toggleStake() public onlyOwner{
        stakePaused = !stakePaused;
    } 
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_komToken","type":"address"},{"internalType":"address","name":"_komVToken","type":"address"},{"internalType":"uint256","name":"_apy","type":"uint256"},{"internalType":"uint256[3]","name":"_lockPeriod","type":"uint256[3]"},{"internalType":"uint256[3]","name":"_multiplier","type":"uint256[3]"},{"internalType":"uint256","name":"_minPrivateSale","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_of","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"EmergencyUnlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_of","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_maturity","type":"uint256"}],"name":"Locked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_of","type":"address"},{"indexed":false,"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"Unlocked","type":"event"},{"inputs":[],"name":"MIN_STAKING_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"apy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_lockPeriod","type":"uint256"}],"name":"calculateReward","outputs":[{"internalType":"uint256","name":"_lockReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"everStaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLockPeriod","outputs":[{"internalType":"uint256[3]","name":"result","type":"uint256[3]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakedInfo","outputs":[{"components":[{"internalType":"uint256","name":"lockPeriodIndex","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"},{"internalType":"uint256","name":"kommunitasStaked","type":"uint256"}],"internalType":"struct KommunitasStakingV2.KomStaked","name":"first","type":"tuple"},{"components":[{"internalType":"uint256","name":"lockPeriodIndex","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"},{"internalType":"uint256","name":"kommunitasStaked","type":"uint256"}],"internalType":"struct KommunitasStakingV2.KomStaked","name":"second","type":"tuple"},{"components":[{"internalType":"uint256","name":"lockPeriodIndex","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"},{"internalType":"uint256","name":"kommunitasStaked","type":"uint256"}],"internalType":"struct KommunitasStakingV2.KomStaked","name":"third","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"getTotalLockedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalRewards","outputs":[{"internalType":"uint256","name":"totalRewards","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_before","type":"uint256"}],"name":"getTotalStakedAmountBeforeDate","outputs":[{"internalType":"uint256","name":"totalStaked","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalStakedMinPrivateSale","outputs":[{"internalType":"uint256","name":"total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"getTotalWithdrawableTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"getUserNextUnlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"getUserPendingRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"},{"internalType":"uint256","name":"_sid","type":"uint256"}],"name":"getUserStakedInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"bool","name":"claimed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"getUserStakedLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"}],"name":"getUserStakedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_of","type":"address"},{"internalType":"uint256","name":"_before","type":"uint256"}],"name":"getUserStakedTokensBeforeDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"komToken","outputs":[{"internalType":"contract ERC20Burnable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"komVToken","outputs":[{"internalType":"contract KommunitasVoting","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"locks","outputs":[{"internalType":"uint256","name":"lockPeriodIndex","type":"uint256"},{"internalType":"uint256","name":"userStakedIndex","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"maturity","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"claimedTime","type":"uint256"},{"internalType":"bool","name":"premature","type":"bool"},{"internalType":"bool","name":"claimed","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minPrivateSale","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"penaltyFeesPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"preMatureWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minPrivateSale","type":"uint256"}],"name":"setMinPrivateSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_multiplier","type":"uint256"},{"internalType":"uint256","name":"_oldLockPeriod","type":"uint256"},{"internalType":"uint256","name":"_newLockPeriod","type":"uint256"}],"name":"setPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_lockPeriod","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakePaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"staked","outputs":[{"internalType":"uint256","name":"lockPeriodIndex","type":"uint256"},{"internalType":"uint256","name":"multiplier","type":"uint256"},{"internalType":"uint256","name":"kommunitasStaked","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sid","type":"uint256"}],"name":"unlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_apy","type":"uint256"}],"name":"updateAPY","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feesPercentage","type":"uint256"}],"name":"updatePenaltyFees","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000c004e2318722ea2b15499d6375905d75ee5390b8000000000000000000000000e1bb02b367173ac31077a8c443802f75cc9accb6000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000001e000000000000000000000000000000000000000000000000000000000000003c000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000f0000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000016bcc41e9000

-----Decoded View---------------
Arg [0] : _komToken (address): 0xc004e2318722ea2b15499d6375905d75ee5390b8
Arg [1] : _komVToken (address): 0xe1bb02b367173ac31077a8c443802f75cc9accb6
Arg [2] : _apy (uint256): 30
Arg [3] : _lockPeriod (uint256[3]): 30,60,90
Arg [4] : _multiplier (uint256[3]): 10,15,20
Arg [5] : _minPrivateSale (uint256): 25000000000000

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 000000000000000000000000c004e2318722ea2b15499d6375905d75ee5390b8
Arg [1] : 000000000000000000000000e1bb02b367173ac31077a8c443802f75cc9accb6
Arg [2] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [3] : 000000000000000000000000000000000000000000000000000000000000001e
Arg [4] : 000000000000000000000000000000000000000000000000000000000000003c
Arg [5] : 000000000000000000000000000000000000000000000000000000000000005a
Arg [6] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000f
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000014
Arg [9] : 000000000000000000000000000000000000000000000000000016bcc41e9000

42623:16267:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43263:29;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42909:43;;;:::i;:::-;;;;;;;:::i;44837:429::-;;;;;;:::i;:::-;;:::i;58292:172::-;;;;;;:::i;:::-;;:::i;:::-;;55249:324;;;:::i;43078:18::-;;;:::i;50378:113::-;;;;;;:::i;:::-;;:::i;58472:232::-;;;;;;:::i;:::-;;:::i;54983:164::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;43840:43::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;43103:31::-;;;:::i;46827:1075::-;;;;;;:::i;:::-;;:::i;51107:487::-;;;;;;:::i;:::-;;:::i;58802:84::-;;;:::i;43141:41::-;;;:::i;22778:148::-;;;:::i;45474:1246::-;;;;;;:::i;:::-;;:::i;22136:79::-;;;:::i;53550:446::-;;;;;;:::i;:::-;;:::i;57371:909::-;;;;;;:::i;:::-;;:::i;48019:2199::-;;;;;;:::i;:::-;;:::i;50503:431::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;42863:39::-;;;:::i;42996:52::-;;;:::i;52992:385::-;;;;;;:::i;:::-;;:::i;43789:44::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;:::i;56128:463::-;;;;;;:::i;:::-;;:::i;56662:246::-;;;:::i;:::-;;;;;;;;;:::i;52393:440::-;;;;;;:::i;:::-;;:::i;54149:686::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;56920:108::-;;;:::i;:::-;;;;;;;:::i;55680:350::-;;;:::i;51759:456::-;;;;;;:::i;:::-;;:::i;43299:28::-;;;;;;:::i;:::-;;:::i;23081:244::-;;;;;;:::i;:::-;;:::i;58712:78::-;;;;;;:::i;:::-;;:::i;43263:29::-;;;;:::o;42909:43::-;;;:::o;44837:429::-;44933:19;44989;;;:6;:19;;;;;:30;;;45034:15;45030:62;;-1:-1:-1;45078:2:0;45030:62;45102:20;45125:72;45194:2;45125:64;43248:8;45125:46;45166:4;45125:36;45149:11;45125:19;45140:3;;45125:10;:14;;:19;;;;:::i;:::-;:23;;:36::i;:46::-;:50;;:64::i;:72::-;45102:95;-1:-1:-1;45223:35:0;45253:4;45223:25;45102:95;45240:7;45223:16;:25::i;:35::-;45209:49;44837:429;-1:-1:-1;;;;;44837:429:0:o;58292:172::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;;;;;;;;;58397:1:::1;58379:15;:19;58371:42;;;;-1:-1:-1::0;;;58371:42:0::1;;;;;;;:::i;:::-;58424:14;:32:::0;58292:172::o;55249:324::-;55309:13;55368:9;55364:202;55383:10;:17;55381:19;;55364:202;;;55462:14;;55424:34;55444:10;55455:1;55444:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55444:13:0;55424:19;:34::i;:::-;:52;55421:134;;55505:34;55525:10;55536:1;55525:13;;;;;;;55505:34;55496:43;;;;55421:134;55402:3;;55364:202;;;;55249:324;:::o;43078:18::-;;;;:::o;50378:113::-;-1:-1:-1;;;;;50466:10:0;;50440:7;50466:10;;;:5;:10;;;;;:17;50378:113;;;;:::o;58472:232::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;58625:2:::1;58606:15;:21;;58598:48;;;;-1:-1:-1::0;;;58598:48:0::1;;;;;;;:::i;:::-;58657:21;:39:::0;58472:232::o;54983:164::-;55055:10;:17;55036:4;;55052:39;;-1:-1:-1;55086:5:0;55079:12;;55052:39;55137:1;55110:24;55130:3;55110:19;:24::i;:::-;:28;;54983:164;-1:-1:-1;;54983:164:0:o;43840:43::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43103:31::-;;;;;;:::o;46827:1075::-;46907:10;46873:7;46901:17;;;:5;:17;;;;;:24;:31;-1:-1:-1;46893:80:0;;;;-1:-1:-1;;;46893:80:0;;;;;;;:::i;:::-;46998:10;46992:17;;;;:5;:17;;;;;:23;;47028:15;;46992:17;47010:4;;46992:23;;;;;;;;;;;;;;;;:32;;;:51;;46984:80;;;;-1:-1:-1;;;46984:80:0;;;;;;;:::i;:::-;47090:10;47084:17;;;;:5;:17;;;;;:23;;47102:4;;47084:23;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;47083:32;47075:60;;;;-1:-1:-1;;;47075:60:0;;;;;;;:::i;:::-;47224:10;47156:24;47218:17;;;:5;:17;;;;;:23;;47183:66;;47218:17;47236:4;;47218:23;;;;;;;;;;;;;;;;:30;;;47183:5;:17;47189:10;-1:-1:-1;;;;;47183:17:0;-1:-1:-1;;;;;47183:17:0;;;;;;;;;;;;47201:4;47183:23;;;;;;;;;;;;;;;;;;:30;;;:34;;:66;;;;:::i;:::-;47308:10;47260:39;47302:17;;;:5;:17;;;;;:23;;47156:93;;-1:-1:-1;47260:39:0;;47320:4;;47302:23;;;;;;;;;;;;;;;;:30;;;47260:72;;47391:15;47353:5;:17;47359:10;-1:-1:-1;;;;;47353:17:0;-1:-1:-1;;;;;47353:17:0;;;;;;;;;;;;47371:4;47353:23;;;;;;;;;;;;;;;;;;:35;;:53;;;;47451:4;47417:5;:17;47423:10;-1:-1:-1;;;;;47417:17:0;-1:-1:-1;;;;;47417:17:0;;;;;;;;;;;;47435:4;47417:23;;;;;;;;;;;;;;;;;;:31;;;:38;;;;;;;;;;;;;;;;;;47546:31;47466:6;:59;47473:10;47484:5;:17;47490:10;-1:-1:-1;;;;;47484:17:0;-1:-1:-1;;;;;47484:17:0;;;;;;;;;;;;47502:4;47484:23;;;;;;;;;;;;;;;;;;:39;;;47473:51;;;;;;;;;47466:59;;;;;;;;;;;-1:-1:-1;47466:59:0;:76;;:111;;;;;;;;47635:8;47601:31;47621:10;47601:19;:31::i;:::-;:42;:81;;;;-1:-1:-1;47647:31:0;;-1:-1:-1;;;47647:31:0;;47681:1;;-1:-1:-1;;;;;47647:9:0;:19;;;;:31;;47667:10;;47647:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;47601:81;47598:141;;;47698:29;;-1:-1:-1;;;47698:29:0;;-1:-1:-1;;;;;47698:9:0;:14;;;;:29;;47713:10;;47725:1;;47698:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47598:141;47759:47;;-1:-1:-1;;;47759:47:0;;-1:-1:-1;;;;;47759:8:0;:17;;;;:47;;47777:10;;47789:16;;47759:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;47831:10;-1:-1:-1;;;;;47822:38:0;;47843:16;47822:38;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;47878:16:0;46827:1075;-1:-1:-1;;46827:1075:0:o;51107:487::-;-1:-1:-1;;;;;51256:10:0;;51177:7;51256:10;;;:5;:10;;;;;:17;51177:7;;;51284:267;51308:11;51304:1;:15;51284:267;;;-1:-1:-1;;;;;51345:10:0;;;;;;:5;:10;;;;;:13;;51371:15;;51345:10;51356:1;;51345:13;;;;;;;;;;;;;;;;:22;;;:41;;:67;;;;-1:-1:-1;;;;;;51391:10:0;;;;;;:5;:10;;;;;:13;;51402:1;;51391:13;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;51390:22;51345:67;51341:199;;;-1:-1:-1;;;;;51503:10:0;;;;;;:5;:10;;;;;:13;;51454:70;;51503:10;51514:1;;51503:13;;;;;;;;;;;;;;;;:20;;;51454:44;51477:5;:10;51483:3;-1:-1:-1;;;;;51477:10:0;-1:-1:-1;;;;;51477:10:0;;;;;;;;;;;;51488:1;51477:13;;;;;;;;;;;;;;;;;;:20;;;51454:18;:22;;:44;;;;:::i;:::-;:48;;:70::i;:::-;51433:91;;51341:199;51321:3;;51284:267;;;-1:-1:-1;51568:18:0;;51107:487;-1:-1:-1;;;51107:487:0:o;58802:84::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;58867:11:::1;::::0;;-1:-1:-1;;58852:26:0;::::1;58867:11;::::0;;::::1;58866:12;58852:26;::::0;;58802:84::o;43141:41::-;;;;:::o;22778:148::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;22885:1:::1;22869:6:::0;;22848:40:::1;::::0;-1:-1:-1;;;;;22869:6:0;;::::1;::::0;22848:40:::1;::::0;22885:1;;22848:40:::1;22916:1;22899:19:::0;;-1:-1:-1;;;;;;22899:19:0::1;::::0;;22778:148::o;45474:1246::-;42751:11;;;;42750:12;42742:40;;;;-1:-1:-1;;;42742:40:0;;;;;;;:::i;:::-;45567:10:::1;45559:48;;;;-1:-1:-1::0;;;45559:48:0::1;;;;;;;:::i;:::-;43041:7;45626;:29;;45618:75;;;;-1:-1:-1::0;;;45618:75:0::1;;;;;;;:::i;:::-;45723:19;::::0;;;:6:::1;:19;::::0;;;;:35;45763:11;;45712:10:::1;::::0;:47:::1;::::0;::::1;;;;;;;:62;45704:96;;;;-1:-1:-1::0;;;45704:96:0::1;;;;;;;:::i;:::-;45813:19;45835:32;:15;45855:11:::0;45835:19:::1;:32::i;:::-;45813:54;;45878:18;45899:37;45915:7;45924:11;45899:15;:37::i;:::-;45878:58;;45949:11;45974:22;45985:10;45974;:22::i;:::-;45971:208;;-1:-1:-1::0;46021:10:0::1;:27:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;46021:27:0;;;;::::1;::::0;;-1:-1:-1;;;;;;46021:27:0::1;46037:10;46021:27;::::0;;46072:17;-1:-1:-1;;46072:19:0;45971:208:::1;;;46137:10;46131:17;::::0;;;:5:::1;:17;::::0;;;;:20;;:17;;;:20:::1;;;;;;;;;;;;;;:36;;;46122:45;;45971:208;46199:57;::::0;-1:-1:-1;;;46199:57:0;;-1:-1:-1;;;;;46199:8:0::1;:21;::::0;::::1;::::0;:57:::1;::::0;46221:10:::1;::::0;46241:4:::1;::::0;46248:7;;46199:57:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46267:5;:17;46273:10;-1:-1:-1::0;;;;;46267:17:0::1;-1:-1:-1::0;;;;;46267:17:0::1;;;;;;;;;;;;46290:122;;;;;;;;46300:6;:19;46307:11;46300:19;;;;;;;;;;;:35;;;46290:122;;;;46337:6;46290:122;;;;46345:7;46290:122;;;;46354:15;46290:122;;;;46371:11;46290:122;;;;46384:10;46290:122;;;;46396:1;46290:122;;;;46399:5;46290:122;;;;;;46406:5;46290:122;;;;::::0;46267:146:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46464:7;46424:6;:19;46431:11;46424:19;;;;;;;;;;;:36;;;:47;;;;;;;;;;;46530:8;46495:31;46515:10;46495:19;:31::i;:::-;:43;;:83;;;;-1:-1:-1::0;46542:31:0::1;::::0;-1:-1:-1;;;46542:31:0;;-1:-1:-1;;;;;46542:9:0::1;:19;::::0;::::1;::::0;:31:::1;::::0;46562:10:::1;::::0;46542:31:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36:::0;46495:83:::1;46492:143;;;46594:29;::::0;-1:-1:-1;;;46594:29:0;;-1:-1:-1;;;;;46594:9:0::1;:14;::::0;::::1;::::0;:29:::1;::::0;46609:10:::1;::::0;46621:1:::1;::::0;46594:29:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;46492:143;46667:10;-1:-1:-1::0;;;;;46660:52:0::1;;46679:7;46688:10;46700:11;46660:52;;;;;;;;:::i;:::-;;;;;;;;42793:1;;;45474:1246:::0;;:::o;22136:79::-;22174:7;22201:6;-1:-1:-1;;;;;22201:6:0;22136:79;:::o;53550:446::-;-1:-1:-1;;;;;53713:10:0;;53640:7;53713:10;;;:5;:10;;;;;:17;53640:7;;;53741:218;53765:11;53761:1;:15;53741:218;;;-1:-1:-1;;;;;53803:10:0;;;;;;:5;:10;;;;;:13;;53814:1;;53803:13;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;53802:22;:56;;;;-1:-1:-1;;;;;;53828:10:0;;;;;;:5;:10;;;;;:13;;53851:7;;53828:10;53839:1;;53828:13;;;;;;;;;;;;;;;;:19;;;:30;;53802:56;53798:150;;;-1:-1:-1;;;;;53911:10:0;;;;;;:5;:10;;;;;:13;;53894:38;;53911:10;53922:1;;53911:13;;;;;;;;;;;;;;;;:20;;;53894:12;:16;;:38;;;;:::i;:::-;53879:53;;53798:150;53778:3;;53741:218;;;-1:-1:-1;53976:12:0;;-1:-1:-1;;53550:446:0;;;;;:::o;57371:909::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;57530:6:::1;57513:23:::0;;::::1;57487;57636::::0;;;:6:::1;:23;::::0;;;;:39;57513:23;;57573;::::1;::::0;57513;;57625:10:::1;::::0;:51:::1;::::0;::::1;;;;;;;:70;57617:108;;;;-1:-1:-1::0;;;57617:108:0::1;;;;;;;:::i;:::-;57788:19;57810:23:::0;;;:6:::1;:23;::::0;;;;:39;57931:15;57905:10:::1;57810:39:::0;57905:23:::1;::::0;::::1;;;;;;:41:::0;57967:23:::1;::::0;;;:6:::1;:23;::::0;;;;;:53;;;58031:34:::1;::::0;;::::1;:48:::0;;;;58133:23;;;;;;:40:::1;::::0;;::::1;::::0;;58090;;;::::1;:83:::0;58242:30;;;;;::::1;::::0;;;;;;;-1:-1:-1;;57371:909:0:o;48019:2199::-;48129:10;48095:7;48123:17;;;:5;:17;;;;;:24;:31;-1:-1:-1;48115:80:0;;;;-1:-1:-1;;;48115:80:0;;;;;;;:::i;:::-;48220:10;48214:17;;;;:5;:17;;;;;:23;;48249:15;;48214:17;48232:4;;48214:23;;;;;;;;;;;;;;;;:32;;;:50;48206:77;;;;-1:-1:-1;;;48206:77:0;;;;;;;:::i;:::-;48309:10;48303:17;;;;:5;:17;;;;;:23;;48321:4;;48303:23;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;48302:32;48294:60;;;;-1:-1:-1;;;48294:60:0;;;;;;;:::i;:::-;48379:10;48373:17;;;;:5;:17;;;;;:23;;48407:7;;48373:17;48391:4;;48373:23;;;;;;;;;;;;;;;;:30;;;:41;;48365:79;;;;-1:-1:-1;;;48365:79:0;;;;;;;:::i;:::-;48519:10;48465:24;48513:17;;;:5;:17;;;;;:23;;48547:7;;48513:17;48531:4;;48513:23;;;;;;;;;;;;;;;;:30;;;:41;48510:1041;;;48595:10;48589:17;;;;:5;:17;;;;;:23;;48607:4;;48589:23;;;;;;;;;;;;;;;;:30;;;48570:49;;48682:4;48648:5;:17;48654:10;-1:-1:-1;;;;;48648:17:0;-1:-1:-1;;;;;48648:17:0;;;;;;;;;;;;48666:4;48648:23;;;;;;;;;;;;;;;;;;:31;;;:38;;;;;;;;;;;;;;;;;;48510:1041;;;-1:-1:-1;48803:10:0;48773:21;48797:17;;;:5;:17;;;;;:23;;48737:7;;48773:21;48797:17;48815:4;;48797:23;;;;;;;;;;;;;;;;48773:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48835:5;:17;48841:10;-1:-1:-1;;;;;48835:17:0;-1:-1:-1;;;;;48835:17:0;;;;;;;;;;;;48858:4;48835:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48878:11;48917:1;48892:5;:17;48898:10;-1:-1:-1;;;;;48892:17:0;-1:-1:-1;;;;;48892:17:0;;;;;;;;;;;;:24;;;;:26;48878:40;;48968:7;48933:5;:17;48939:10;-1:-1:-1;;;;;48933:17:0;-1:-1:-1;;;;;48933:17:0;;;;;;;;;;;;48951:6;48933:25;;;;;;;;;;;;;;;;;;:32;;:42;;;;49025:79;49041:7;49050:10;49061:5;:17;49067:10;-1:-1:-1;;;;;49061:17:0;-1:-1:-1;;;;;49061:17:0;;;;;;;;;;;;49079:6;49061:25;;;;;;;;;;;;;;;;;;:41;;;49050:53;;;;;;;;;49025:15;:79::i;:::-;48996:10;48990:17;;;;:5;:17;;;;;:25;;49008:6;;48990:25;;;;;;;;;;;;;;;;:32;;:114;;;;49159:15;49119:5;:17;49125:10;-1:-1:-1;;;;;49119:17:0;-1:-1:-1;;;;;49119:17:0;;;;;;;;;;;;49137:6;49119:25;;;;;;;;;;;;;;;;;;:37;;:55;;;;49227:4;49189:5;:17;49195:10;-1:-1:-1;;;;;49189:17:0;-1:-1:-1;;;;;49189:17:0;;;;;;;;;;;;49207:6;49189:25;;;;;;;;;;;;;;;;;;;;;;;;:35;;:42;;-1:-1:-1;;49189:42:0;;;;;;;;;;;49252:10;49246:17;;:5;:17;;;;;;:25;;-1:-1:-1;;49246:17:0;49264:6;;49246:25;;;;;;;;;;;;;;;;:33;;;:40;;;;;;;;;;;;;;;;;;49348:43;49383:7;49348:5;:17;49354:10;-1:-1:-1;;;;;49348:17:0;-1:-1:-1;;;;;49348:17:0;;;;;;;;;;;;49366:4;49348:23;;;;;;;;;;;;;;;;;;:30;;;:34;;:43;;;;:::i;:::-;49321:10;49315:17;;;;:5;:17;;;;;:23;;49333:4;;49315:23;;;;;;;;;;;;;;;;:30;;:76;;;;49439:100;49455:5;:17;49461:10;-1:-1:-1;;;;;49455:17:0;-1:-1:-1;;;;;49455:17:0;;;;;;;;;;;;49473:4;49455:23;;;;;;;;;;;;;;;;;;:30;;;49487:10;49498:5;:17;49504:10;-1:-1:-1;;;;;49498:17:0;-1:-1:-1;;;;;49498:17:0;;;;;;;;;;;;49516:4;49498:23;;;;;;;49439:100;49412:10;49406:17;;;;:5;:17;;;;;:23;;49424:4;;49406:23;;;;;;;;;;;;;;;;:30;;:133;;;;48510:1041;;;49571:21;49595:52;49643:3;49595:43;49616:21;;49595:16;:20;;:43;;;;:::i;:52::-;49571:76;-1:-1:-1;49658:26:0;49687:35;:16;49571:76;49687:20;:35::i;:::-;49735:28;;-1:-1:-1;;;49735:28:0;;49658:64;;-1:-1:-1;;;;;;49735:8:0;:13;;;;:28;;49749:13;;49735:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49800:10:0;49776:59;49794:17;;;:5;:17;;;;;:23;;49856:16;;-1:-1:-1;49776:6:0;;-1:-1:-1;49783:10:0;;49794:17;49812:4;;49794:23;;;;;;;;;;;;;;;;:39;;;49783:51;;;;;;;;;49776:59;;;;;;;;;;;-1:-1:-1;49776:59:0;:76;;:96;;;;;;;;49930:8;49896:31;49916:10;49896:19;:31::i;:::-;:42;:81;;;;-1:-1:-1;49942:31:0;;-1:-1:-1;;;49942:31:0;;49976:1;;-1:-1:-1;;;;;49942:9:0;:19;;;;:31;;49962:10;;49942:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;49896:81;49893:141;;;49993:29;;-1:-1:-1;;;49993:29:0;;-1:-1:-1;;;;;49993:9:0;:14;;;;:29;;50008:10;;50020:1;;49993:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49893:141;50054:49;;-1:-1:-1;;;50054:49:0;;-1:-1:-1;;;;;50054:8:0;:17;;;;:49;;50072:10;;50084:18;;50054:49;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50147:10;-1:-1:-1;;;;;50129:47:0;;50159:16;50129:47;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;50194:16:0;;48019:2199;-1:-1:-1;;;;48019:2199:0:o;50503:431::-;-1:-1:-1;;;;;50727:10:0;;50587:14;50727:10;;;:5;:10;;;;;:16;;50587:14;;;;;;;;50738:4;;50727:16;;;;;;;;;;;;;;;;:23;;;50718:32;;50769:5;:10;50775:3;-1:-1:-1;;;;;50769:10:0;-1:-1:-1;;;;;50769:10:0;;;;;;;;;;;;50780:4;50769:16;;;;;;;;;;;;;;;;;;:22;;;50761:30;;50813:5;:10;50819:3;-1:-1:-1;;;;;50813:10:0;-1:-1:-1;;;;;50813:10:0;;;;;;;;;;;;50824:4;50813:16;;;;;;;;;;;;;;;;;;:25;;;50802:36;;50858:5;:10;50864:3;-1:-1:-1;;;;;50858:10:0;-1:-1:-1;;;;;50858:10:0;;;;;;;;;;;;50869:4;50858:16;;;;;;;;;;;;;;;;;;:23;;;50849:32;;50902:5;:10;50908:3;-1:-1:-1;;;;;50902:10:0;-1:-1:-1;;;;;50902:10:0;;;;;;;;;;;;50913:4;50902:16;;;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;50892:34;;50503:431;;;;;;;;:::o;42863:39::-;;;:::o;42996:52::-;43041:7;42996:52;:::o;52992:385::-;-1:-1:-1;;;;;53128:10:0;;53055:7;53128:10;;;:5;:10;;;;;:17;53055:7;;;53156:184;53180:11;53176:1;:15;53156:184;;;-1:-1:-1;;;;;53218:10:0;;;;;;:5;:10;;;;;:13;;53229:1;;53218:13;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;53213:116;;-1:-1:-1;;;;;53292:10:0;;;;;;:5;:10;;;;;:13;;53275:38;;53292:10;53303:1;;53292:13;;;;;53275:38;53260:53;;53213:116;53193:3;;53156:184;;43789:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43789:44:0;;-1:-1:-1;43789:44:0;;;;;;;;;;;;;;;;;:::o;56128:463::-;56205:19;56266:9;56262:322;56281:10;:17;56279:19;;56262:322;;;56323:9;56319:254;56338:5;:20;56344:10;56355:1;56344:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56344:13:0;56338:20;;;;;;;;;;;;:27;56336:29;;56319:254;;;56394:5;:20;56400:10;56411:1;56400:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56400:13:0;56394:20;;;;;;;;;;;;:23;;56415:1;;56394:23;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;56393:32;:76;;;;;56462:7;56429:5;:20;56435:10;56446:1;56435:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56435:13:0;56429:20;;;;;;;;;;;;:23;;56450:1;;56429:23;;;;;;;;;;;;;;;;:29;;;:40;;56393:76;56390:168;;;56508:5;:20;56514:10;56525:1;56514:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56514:13:0;56508:20;;;;;;;;;;;;:23;;56529:1;;56508:23;;;;;;;;;;;;;;;;:30;;;56493:45;;;;56390:168;56367:3;;56319:254;;;-1:-1:-1;56300:3:0;;56262:322;;;;56128:463;;;:::o;56662:246::-;56707:22;;:::i;:::-;56731:23;;:::i;:::-;56756:22;;:::i;:::-;-1:-1:-1;;56805:10:0;:13;56798:21;;;;:6;:21;;;;;;;;56790:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56846:13;;56839:21;;;;;;;;56830:30;;;;;;;;;;;;;;;;;;;;;;;;;;;56886:13;;56879:21;;;;;;;;;56871:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56790;;56830:30;;-1:-1:-1;56662:246:0:o;52393:440::-;-1:-1:-1;;;;;52533:10:0;;52458:7;52533:10;;;:5;:10;;;;;:17;52458:7;;;52561:233;52585:11;52581:1;:15;52561:233;;;-1:-1:-1;;;;;52622:10:0;;;;;;:5;:10;;;;;:13;;52648:15;;52622:10;52633:1;;52622:13;;;;;;;;;;;;;;;;:22;;;:41;;:67;;;;-1:-1:-1;;;;;;52668:10:0;;;;;;:5;:10;;;;;:13;;52679:1;;52668:13;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;52667:22;52622:67;52618:165;;;-1:-1:-1;;;;;52746:10:0;;;;;;:5;:10;;;;;:13;;52727:40;;52746:10;52757:1;;52746:13;;;;;;;;;;;;;;;;:20;;;52727:14;:18;;:40;;;;:::i;:::-;52710:57;;52618:165;52598:3;;52561:233;;54149:686;-1:-1:-1;;;;;54330:10:0;;54210:7;54330:10;;;:5;:10;;;;;:17;54210:7;;;;;;;54358:418;54382:11;54378:1;:15;54358:418;;;-1:-1:-1;;;;;54434:10:0;;54415:16;54434:10;;;:5;:10;;;;;:13;;54445:1;;54434:13;;;;;;;;;;;;;;;;:22;;;54415:41;;54486:15;54475:8;:26;:52;;;;-1:-1:-1;;;;;;54506:10:0;;;;;;:5;:10;;;;;:13;;54517:1;;54506:13;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;54505:22;54475:52;54471:294;;;54551:19;;;:48;;;54591:8;54574:14;:25;54551:48;54548:202;;;-1:-1:-1;;;;;54710:10:0;;;;;;:5;:10;;;;;:13;;54659:8;;-1:-1:-1;54659:8:0;;54721:1;;54710:13;;;;;;;;;;;;;;;;:20;;;54690:40;;54548:202;-1:-1:-1;54395:3:0;;54358:418;;;-1:-1:-1;54794:14:0;;-1:-1:-1;54809:17:0;-1:-1:-1;;54149:686:0;;;:::o;56920:108::-;56965:24;;:::i;:::-;57001:19;;;;;;;;;;;57010:10;;57001:19;;57010:10;57001:19;;;;;;;;;;;;;;;;;;;;;;;;56920:108;:::o;55680:350::-;55727:20;55790:9;55786:237;55805:10;:17;55803:19;;55786:237;;;55847:9;55843:169;55862:5;:20;55868:10;55879:1;55868:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55868:13:0;55862:20;;;;;;;;;;;;:27;55860:29;;55843:169;;;55930:66;55965:5;:20;55971:10;55982:1;55971:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55971:13:0;55965:20;;;;;;;;;;;;:23;;55986:1;;55965:23;;;;;;;;;;;;;;;;:30;;;55930:5;:20;55936:10;55947:1;55936:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55936:13:0;55930:20;;;;;;;;;;;;:23;;55951:1;;55930:23;;;;;:66;55914:82;;;;55891:3;;55843:169;;;-1:-1:-1;55824:3:0;;55786:237;;51759:456;-1:-1:-1;;;;;51896:10:0;;51823:7;51896:10;;;:5;:10;;;;;:17;51823:7;;;51924:254;51948:11;51944:1;:15;51924:254;;;-1:-1:-1;;;;;51985:10:0;;;;;;:5;:10;;;;;:13;;52010:15;;51985:10;51996:1;;51985:13;;;;;;;;;;;;;;;;:22;;;:40;:66;;;;-1:-1:-1;;;;;;52030:10:0;;;;;;:5;:10;;;;;:13;;52041:1;;52030:13;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;52029:22;51985:66;51981:186;;;-1:-1:-1;;;;;52130:10:0;;;;;;:5;:10;;;;;:13;;52087:64;;52130:10;52141:1;;52130:13;;;;;52087:64;52072:79;;51981:186;51961:3;;51924:254;;43299:28;;;;;;;;;;;;;;;-1:-1:-1;43299:28:0;:::o;23081:244::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;23170:22:0;::::1;23162:73;;;;-1:-1:-1::0;;;23162:73:0::1;;;;;;;:::i;:::-;23272:6;::::0;;23251:38:::1;::::0;-1:-1:-1;;;;;23251:38:0;;::::1;::::0;23272:6;::::1;::::0;23251:38:::1;::::0;::::1;23300:6;:17:::0;;-1:-1:-1;;;;;;23300:17:0::1;-1:-1:-1::0;;;;;23300:17:0;;;::::1;::::0;;;::::1;::::0;;23081:244::o;58712:78::-;22358:12;:10;:12::i;:::-;22348:6;;-1:-1:-1;;;;;22348:6:0;;;:22;;;22340:67;;;;-1:-1:-1;;;22340:67:0;;;;;;;:::i;:::-;58772:3:::1;:10:::0;58712:78::o;5924:471::-;5982:7;6227:6;6223:47;;-1:-1:-1;6257:1:0;6250:8;;6223:47;6294:5;;;6298:1;6294;:5;:1;6318:5;;;;;:10;6310:56;;;;-1:-1:-1;;;6310:56:0;;;;;;;:::i;:::-;6386:1;5924:471;-1:-1:-1;;;5924:471:0:o;6871:132::-;6929:7;6956:39;6960:1;6963;6956:39;;;;;;;;;;;;;;;;;:3;:39::i;605:106::-;693:10;605:106;:::o;4570:181::-;4628:7;4660:5;;;4684:6;;;;4676:46;;;;-1:-1:-1;;;4676:46:0;;;;;;;:::i;5034:136::-;5092:7;5119:43;5123:1;5126;5119:43;;;;;;;;;;;;;;;;;:3;:43::i;7499:278::-;7585:7;7620:12;7613:5;7605:28;;;;-1:-1:-1;;;7605:28:0;;;;;;;;:::i;:::-;;7644:9;7660:1;7656;:5;;;;;;;7499:278;-1:-1:-1;;;;;7499:278:0:o;5473:192::-;5559:7;5595:12;5587:6;;;;5579:29;;;;-1:-1:-1;;;5579:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;5631:5:0;;;5473:192::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:266::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;653:2;638:18;;;;625:32;;-1:-1:-1;;;484:179:1:o;668:297::-;;788:2;776:9;767:7;763:23;759:32;756:2;;;809:6;801;794:22;756:2;846:9;840:16;899:5;892:13;885:21;878:5;875:32;865:2;;926:6;918;911:22;970:190;;1082:2;1070:9;1061:7;1057:23;1053:32;1050:2;;;1103:6;1095;1088:22;1050:2;-1:-1:-1;1131:23:1;;1040:120;-1:-1:-1;1040:120:1:o;1165:194::-;;1288:2;1276:9;1267:7;1263:23;1259:32;1256:2;;;1309:6;1301;1294:22;1256:2;-1:-1:-1;1337:16:1;;1246:113;-1:-1:-1;1246:113:1:o;1364:258::-;;;1493:2;1481:9;1472:7;1468:23;1464:32;1461:2;;;1514:6;1506;1499:22;1461:2;-1:-1:-1;;1542:23:1;;;1612:2;1597:18;;;1584:32;;-1:-1:-1;1451:171:1:o;1627:326::-;;;;1773:2;1761:9;1752:7;1748:23;1744:32;1741:2;;;1794:6;1786;1779:22;1741:2;-1:-1:-1;;1822:23:1;;;1892:2;1877:18;;1864:32;;-1:-1:-1;1943:2:1;1928:18;;;1915:32;;1731:222;-1:-1:-1;1731:222:1:o;1958:209::-;2036:12;;2024:25;;2098:4;2087:16;;;2081:23;2065:14;;;2058:47;2154:4;2143:16;;;2137:23;2121:14;;2114:47;2014:153::o;2172:203::-;-1:-1:-1;;;;;2336:32:1;;;;2318:51;;2306:2;2291:18;;2273:102::o;2596:383::-;-1:-1:-1;;;;;2862:15:1;;;2844:34;;2914:15;;;;2909:2;2894:18;;2887:43;2961:2;2946:18;;2939:34;;;;2794:2;2779:18;;2761:218::o;2984:290::-;-1:-1:-1;;;;;3192:32:1;;;;3174:51;;3256:2;3241:18;;3234:34;3162:2;3147:18;;3129:145::o;3566:494::-;3746:2;3731:18;;3735:9;3826:6;3566:494;3860:194;3874:4;3871:1;3868:11;3860:194;;;3933:13;;3921:26;;3970:4;3994:12;;;;4029:15;;;;3894:1;3887:9;3860:194;;;3864:3;;;3713:347;;;;:::o;4065:187::-;4230:14;;4223:22;4205:41;;4193:2;4178:18;;4160:92::o;4719:603::-;;4860:2;4889;4878:9;4871:21;4921:6;4915:13;4964:6;4959:2;4948:9;4944:18;4937:34;4989:4;5002:140;5016:6;5013:1;5010:13;5002:140;;;5111:14;;;5107:23;;5101:30;5077:17;;;5096:2;5073:26;5066:66;5031:10;;5002:140;;;5160:6;5157:1;5154:13;5151:2;;;5230:4;5225:2;5216:6;5205:9;5201:22;5197:31;5190:45;5151:2;-1:-1:-1;5306:2:1;5285:15;-1:-1:-1;;5281:29:1;5266:45;;;;5313:2;5262:54;;4840:482;-1:-1:-1;;;4840:482:1:o;5327:402::-;5529:2;5511:21;;;5568:2;5548:18;;;5541:30;5607:34;5602:2;5587:18;;5580:62;-1:-1:-1;;;5673:2:1;5658:18;;5651:36;5719:3;5704:19;;5501:228::o;5734:351::-;5936:2;5918:21;;;5975:2;5955:18;;;5948:30;6014:29;6009:2;5994:18;;5987:57;6076:2;6061:18;;5908:177::o;6090:400::-;6292:2;6274:21;;;6331:2;6311:18;;;6304:30;6370:34;6365:2;6350:18;;6343:62;-1:-1:-1;;;6436:2:1;6421:18;;6414:34;6480:3;6465:19;;6264:226::o;6495:397::-;6697:2;6679:21;;;6736:2;6716:18;;;6709:30;6775:34;6770:2;6755:18;;6748:62;-1:-1:-1;;;6841:2:1;6826:18;;6819:31;6882:3;6867:19;;6669:223::o;6897:349::-;7099:2;7081:21;;;7138:2;7118:18;;;7111:30;7177:27;7172:2;7157:18;;7150:55;7237:2;7222:18;;7071:175::o;7251:349::-;7453:2;7435:21;;;7492:2;7472:18;;;7465:30;7531:27;7526:2;7511:18;;7504:55;7591:2;7576:18;;7425:175::o;7605:340::-;7807:2;7789:21;;;7846:2;7826:18;;;7819:30;-1:-1:-1;;;7880:2:1;7865:18;;7858:46;7936:2;7921:18;;7779:166::o;7950:334::-;8152:2;8134:21;;;8191:2;8171:18;;;8164:30;-1:-1:-1;;;8225:2:1;8210:18;;8203:40;8275:2;8260:18;;8124:160::o;8289:339::-;8491:2;8473:21;;;8530:2;8510:18;;;8503:30;-1:-1:-1;;;8564:2:1;8549:18;;8542:45;8619:2;8604:18;;8463:165::o;8633:397::-;8835:2;8817:21;;;8874:2;8854:18;;;8847:30;8913:34;8908:2;8893:18;;8886:62;-1:-1:-1;;;8979:2:1;8964:18;;8957:31;9020:3;9005:19;;8807:223::o;9035:345::-;9237:2;9219:21;;;9276:2;9256:18;;;9249:30;-1:-1:-1;;;9310:2:1;9295:18;;9288:51;9371:2;9356:18;;9209:171::o;9385:356::-;9587:2;9569:21;;;9606:18;;;9599:30;9665:34;9660:2;9645:18;;9638:62;9732:2;9717:18;;9559:182::o;9746:336::-;9948:2;9930:21;;;9987:2;9967:18;;;9960:30;-1:-1:-1;;;10021:2:1;10006:18;;9999:42;10073:2;10058:18;;9920:162::o;10087:338::-;10289:2;10271:21;;;10328:2;10308:18;;;10301:30;-1:-1:-1;;;10362:2:1;10347:18;;10340:44;10416:2;10401:18;;10261:164::o;10430:339::-;10632:2;10614:21;;;10671:2;10651:18;;;10644:30;-1:-1:-1;;;10705:2:1;10690:18;;10683:45;10760:2;10745:18;;10604:165::o;10774:338::-;10976:2;10958:21;;;11015:2;10995:18;;;10988:30;-1:-1:-1;;;11049:2:1;11034:18;;11027:44;11103:2;11088:18;;10948:164::o;11117:555::-;11469:3;11454:19;;11482:49;11458:9;11513:6;11482:49;:::i;:::-;11540:58;11594:2;11583:9;11579:18;11571:6;11540:58;:::i;:::-;11607:59;11661:3;11650:9;11646:19;11638:6;11607:59;:::i;:::-;11436:236;;;;;;:::o;11677:177::-;11823:25;;;11811:2;11796:18;;11778:76::o;11859:248::-;12033:25;;;12089:2;12074:18;;12067:34;12021:2;12006:18;;11988:119::o;12112:319::-;12314:25;;;12370:2;12355:18;;12348:34;;;;12413:2;12398:18;;12391:34;12302:2;12287:18;;12269:162::o;12436:473::-;12689:25;;;12745:2;12730:18;;12723:34;;;;12788:2;12773:18;;12766:34;;;;12831:2;12816:18;;12809:34;12887:14;12880:22;12874:3;12859:19;;12852:51;12676:3;12661:19;;12643:266::o;12914:771::-;13273:25;;;13329:2;13314:18;;13307:34;;;;13372:2;13357:18;;13350:34;;;;13415:2;13400:18;;13393:34;;;;13458:3;13443:19;;13436:35;;;;13502:3;13487:19;;13480:35;13546:3;13531:19;;13524:35;13603:14;13596:22;13590:3;13575:19;;13568:51;13663:14;13656:22;13650:3;13635:19;;13628:51;13260:3;13245:19;;13227:458::o

ipfs://9e7aa5845d8149b56fc8001b79dd86de737c05a004d6d84d625a6a17474b05c9