Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity 0.6.5;

import "./PROS.sol";
import "./SafeMath.sol";
import "./SafeMath64.sol";

contract Vesting {

  using SafeMath for uint256;
  using SafeMath64 for uint64;
  PROS public token;
  address public owner;

  uint constant internal SECONDS_PER_DAY = 1 days;

  event Allocated(address recipient, uint64 startTime, uint256 amount, uint64 vestingDuration, uint64 vestingPeriodInDays, uint _upfront);
  event TokensClaimed(address recipient, uint256 amountClaimed);

  struct Allocation {
    uint64 vestingDuration; 
    uint64 periodClaimed;  
    uint64 periodInDays; 
    uint64 startTime; 
    uint256 amount;
    uint256 totalClaimed;
  }
  mapping (address => Allocation) public tokenAllocations;

  modifier onlyOwner {
    require(msg.sender == owner, "unauthorized");
    _;
  }

  modifier nonZeroAddress(address x) {
    require(x != address(0), "token-zero-address");
    _;
  }

  constructor(address _token, address _owner) public
  nonZeroAddress(_token)
  nonZeroAddress(_owner)
  {
    token = PROS(_token);
    owner = _owner;
  }

  /// @dev Add a new token vesting for user `_recipient`. Only one vesting per user is allowed
  /// The amount of PROS tokens here need to be preapproved for transfer by this `Vesting` contract before this call
  /// @param _recipient Address array of the token recipient entitled to claim the vested funds
  /// @param _startTime Vesting start time array as seconds since unix epoch 
  /// @param _amount Total number of tokens array in vested
  /// @param _vestingDuration Number of Periods in array.
  /// @param _vestingPeriodInDays Array of Number of days in each Period
  /// @param _upFront array of Amount of tokens `_recipient[i]` will get  right away
  function addTokenVesting(address[] memory _recipient, uint64[] memory _startTime, uint256[] memory _amount, uint64[] memory _vestingDuration, uint64[] memory _vestingPeriodInDays, uint256[] memory _upFront) public 
  onlyOwner
  {

    require(_recipient.length == _startTime.length, "Different array length");
    require(_recipient.length == _amount.length, "Different array length");
    require(_recipient.length == _vestingDuration.length, "Different array length");
    require(_recipient.length == _vestingPeriodInDays.length, "Different array length");
    require(_recipient.length == _upFront.length, "Different array length");

    for(uint i=0;i<_recipient.length;i++) {
      require(tokenAllocations[_recipient[i]].startTime == 0, "token-user-grant-exists");
      require(_startTime[i] != 0, "should be positive");
      uint256 amountVestedPerPeriod = _amount[i].div(_vestingDuration[i]);
      require(amountVestedPerPeriod > 0, "0-amount-vested-per-period");

      Allocation memory _allocation = Allocation({
        startTime: _startTime[i], 
        amount: _amount[i],
        vestingDuration: _vestingDuration[i],
        periodInDays: _vestingPeriodInDays[i],
        periodClaimed: 0,
        totalClaimed: 0
      });
      tokenAllocations[_recipient[i]] = _allocation;

      if(_upFront[i] > 0) {
        token.transfer(_recipient[i], _upFront[i]);
      }

      emit Allocated(_recipient[i], _startTime[i], _amount[i], _vestingDuration[i], _vestingPeriodInDays[i], _upFront[i]);
    }
  }

  /// @dev Allows a vesting recipient to claim their vested tokens. Errors if no tokens have vested
  /// It is advised recipients check they are entitled to claim via `calculateVestingClaim` before calling this
  function claimVestedTokens() public {
    uint64 periodVested;
    uint256 amountVested;
    (periodVested, amountVested) = calculateVestingClaim(msg.sender);
    require(amountVested > 0, "token-zero-amount-vested");

    Allocation storage _tokenAllocated = tokenAllocations[msg.sender];
    _tokenAllocated.periodClaimed = _tokenAllocated.periodClaimed.add(periodVested);
    _tokenAllocated.totalClaimed = _tokenAllocated.totalClaimed.add(amountVested);
    
    require(token.transfer(msg.sender, amountVested), "token-sender-transfer-failed");
    emit TokensClaimed(msg.sender, amountVested);
  }

  /// @dev Calculate the vested and unclaimed period and tokens available for `_recepient` to claim
  /// Due to rounding errors once grant duration is reached, returns the entire left grant amount
  function calculateVestingClaim(address _recipient) public view returns (uint64, uint256) {
    Allocation memory _tokenAllocations = tokenAllocations[_recipient];

    // For vesting created with a future start date, that hasn't been reached, return 0, 0
    if (now < _tokenAllocations.startTime) {
      return (0, 0);
    }

    uint256 elapsedTime = now.sub(_tokenAllocations.startTime);
    uint64 elapsedDays = uint64(elapsedTime / SECONDS_PER_DAY);
    
    
    // If over vesting duration, all tokens vested
    if (elapsedDays >= _tokenAllocations.vestingDuration.mul(_tokenAllocations.periodInDays)) {
      uint256 remainingTokens = _tokenAllocations.amount.sub(_tokenAllocations.totalClaimed);
      return (_tokenAllocations.vestingDuration.sub(_tokenAllocations.periodClaimed), remainingTokens);
    } else {
      uint64 elapsedPeriod = elapsedDays.div(_tokenAllocations.periodInDays);
      uint64 periodVested = elapsedPeriod.sub(_tokenAllocations.periodClaimed);
      uint256 amountVestedPerPeriod = _tokenAllocations.amount.div(_tokenAllocations.vestingDuration);
      uint256 amountVested = uint(periodVested).mul(amountVestedPerPeriod);
      return (periodVested, amountVested);
    }
  }

  /// @dev Returns unclaimed allocation of user. 
  function unclaimedAllocation(address _user) external view returns(uint) {
    return tokenAllocations[_user].amount.sub(tokenAllocations[_user].totalClaimed);
  }
}

// SPDX-License-Identifier: MIT
// Creator: OpenZeppelin

pragma solidity ^0.6.5;

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(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);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// Creator: OpenZeppelin

pragma solidity ^0.6.5;

import "./Initializable.sol";

/*
 * @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.
 */
contract ContextUpgradeSafe is Initializable {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.

    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {


    }


    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;
    }

    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// Creator: OpenZeppelin

pragma solidity ^0.6.5;

import "./Address.sol";
import "./ContextUpgradeSafe.sol";
import "./IERC20.sol";
import "./Initializable.sol";
import "./SafeMath.sol";

/**
 * @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 {ERC20MinterPauser}.
 *
 * 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 ERC20UpgradeSafe is Initializable, ContextUpgradeSafe, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    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.
     */

    function __ERC20_init(string memory name, string memory symbol) internal initializer {
        __Context_init_unchained();
        __ERC20_init_unchained(name, symbol);
    }

    function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {


        _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 is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal 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 { }

    uint256[44] private __gap;
}

// SPDX-License-Identifier: MIT
// Creator: OpenZeppelin

pragma solidity ^0.6.5;

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

// SPDX-License-Identifier: MIT
// Creator: OpenZeppelin

pragma solidity ^0.6.5;

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

// SPDX-License-Identifier: MIT
// Creator: Prosper

pragma solidity 0.6.5;

import "./ERC20UpgradeSafe.sol";
import "./Initializable.sol";


contract PROS is Initializable, ERC20UpgradeSafe {

    function initialize(string memory name, string memory symbol) public initializer {
    	__ERC20_init(name, symbol);
    	uint totalSupply = 100000000 * (10 ** 18);
    	_mint(_msgSender(), totalSupply);
    }
}

// SPDX-License-Identifier: MIT
// Creator: OpenZeppelin

pragma solidity ^0.6.5;

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

library SafeMath64 {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint64 a, uint64 b) internal pure returns (uint64) {
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint64 c = a - b;

        return c;
    }

    /**
     * @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.
     *
     * _Available since v2.4.0._
     */
    function sub(uint64 a, uint64 b, string memory errorMessage) internal pure returns (uint64) {
        require(b <= a, errorMessage);
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        // 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;
        }

        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint64","name":"startTime","type":"uint64"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"vestingDuration","type":"uint64"},{"indexed":false,"internalType":"uint64","name":"vestingPeriodInDays","type":"uint64"},{"indexed":false,"internalType":"uint256","name":"_upfront","type":"uint256"}],"name":"Allocated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountClaimed","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"inputs":[{"internalType":"address[]","name":"_recipient","type":"address[]"},{"internalType":"uint64[]","name":"_startTime","type":"uint64[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"},{"internalType":"uint64[]","name":"_vestingDuration","type":"uint64[]"},{"internalType":"uint64[]","name":"_vestingPeriodInDays","type":"uint64[]"},{"internalType":"uint256[]","name":"_upFront","type":"uint256[]"}],"name":"addTokenVesting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"}],"name":"calculateVestingClaim","outputs":[{"internalType":"uint64","name":"","type":"uint64"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimVestedTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract PROS","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenAllocations","outputs":[{"internalType":"uint64","name":"vestingDuration","type":"uint64"},{"internalType":"uint64","name":"periodClaimed","type":"uint64"},{"internalType":"uint64","name":"periodInDays","type":"uint64"},{"internalType":"uint64","name":"startTime","type":"uint64"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"totalClaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"unclaimedAllocation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000008642a849d0dcb7a15a974794668adcfbe4794b560000000000000000000000001e7f67468e6e7789fcb0ae66de90b10e8b7d4026

-----Decoded View---------------
Arg [0] : _token (address): 0x8642A849D0dcb7a15a974794668ADcfbe4794B56
Arg [1] : _owner (address): 0x1E7f67468E6E7789fCB0ae66de90B10E8B7d4026

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000008642a849d0dcb7a15a974794668adcfbe4794b56
Arg [1] : 0000000000000000000000001e7f67468e6e7789fcb0ae66de90b10e8b7d4026

104:5733:8:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;104:5733:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;688:55:8;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;688:55:8;-1:-1:-1;;;;;688:55:8;;:::i;:::-;;;;-1:-1:-1;;;;;688:55:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1784:1552;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;1784:1552:8;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;1784:1552:8;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;1784:1552:8;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;1784:1552:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1784:1552:8;;;;;;;;-1:-1:-1;1784:1552:8;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;1784:1552:8;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;1784:1552:8;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;1784:1552:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1784:1552:8;;;;;;;;-1:-1:-1;1784:1552:8;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;1784:1552:8;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;1784:1552:8;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;1784:1552:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1784:1552:8;;;;;;;;-1:-1:-1;1784:1552:8;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;1784:1552:8;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;1784:1552:8;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;1784:1552:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1784:1552:8;;;;;;;;-1:-1:-1;1784:1552:8;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;1784:1552:8;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;1784:1552:8;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;1784:1552:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1784:1552:8;;;;;;;;-1:-1:-1;1784:1552:8;;-1:-1:-1;;;;;11:28;;8:2;;;52:1;49;42:12;8:2;1784:1552:8;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;1784:1552:8;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;1784:1552:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;1784:1552:8;;-1:-1:-1;1784:1552:8;;-1:-1:-1;;;;;1784:1552:8:i;:::-;;4377:1236;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4377:1236:8;-1:-1:-1;;;;;4377:1236:8;;:::i;:::-;;;;-1:-1:-1;;;;;4377:1236:8;;;;;;;;;;;;;;;;;;;;;5670:164;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;5670:164:8;-1:-1:-1;;;;;5670:164:8;;:::i;:::-;;;;;;;;;;;;;;;;213:20;;;:::i;:::-;;;;-1:-1:-1;;;;;213:20:8;;;;;;;;;;;;;;3556:615;;;:::i;191:17::-;;;:::i;688:55::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;688:55:8;;;;-1:-1:-1;;;688:55:8;;;;;-1:-1:-1;;;688:55:8;;;;;-1:-1:-1;;;688:55:8;;;;;;;;;:::o;1784:1552::-;798:5;;-1:-1:-1;;;;;798:5:8;784:10;:19;776:44;;;;;-1:-1:-1;;;776:44:8;;;;;;;;;;;;-1:-1:-1;;;776:44:8;;;;;;;;;;;;;;;2053:10:::1;:17;2032:10;:17;:38;2024:73;;;::::0;;-1:-1:-1;;;2024:73:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2024:73:8;;;;;;;;;;;;;::::1;;2133:7;:14;2112:10;:17;:35;2104:70;;;::::0;;-1:-1:-1;;;2104:70:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2104:70:8;;;;;;;;;;;;;::::1;;2210:16;:23;2189:10;:17;:44;2181:79;;;::::0;;-1:-1:-1;;;2181:79:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2181:79:8;;;;;;;;;;;;;::::1;;2296:20;:27;2275:10;:17;:48;2267:83;;;::::0;;-1:-1:-1;;;2267:83:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2267:83:8;;;;;;;;;;;;;::::1;;2386:8;:15;2365:10;:17;:36;2357:71;;;::::0;;-1:-1:-1;;;2357:71:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2357:71:8;;;;;;;;;;;;;::::1;;2441:6;2437:894;2452:10;:17;2450:1;:19;2437:894;;;2492:16;:31;2509:10;2520:1;2509:13;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;2492:31:8::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;2492:31:8;:41;-1:-1:-1;;;2492:41:8;::::1;-1:-1:-1::0;;;;;2492:41:8::1;:46:::0;2484:82:::1;;;::::0;;-1:-1:-1;;;2484:82:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;2583:10;2594:1;2583:13;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2583:18:8::1;2600:1;2583:18;;2575:49;;;::::0;;-1:-1:-1;;;2575:49:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2575:49:8;;;;;;;;;;;;;::::1;;2633:29;2665:35;2680:16;2697:1;2680:19;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2665:35:8::1;:7;2673:1;2665:10;;;;;;;;;;;;;;:14;;:35;;;;:::i;:::-;2633:67;;2741:1;2717:21;:25;2709:64;;;::::0;;-1:-1:-1;;;2709:64:8;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;2784:29;;:::i;:::-;2816:234;;;;;;;;2920:16;2937:1;2920:19;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2816:234:8::1;;;;;3013:1;-1:-1:-1::0;;;;;2816:234:8::1;;;;;2964:20;2985:1;2964:23;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2816:234:8::1;;;;;2849:10;2860:1;2849:13;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2816:234:8::1;;;;;2882:7;2890:1;2882:10;;;;;;;;;;;;;;2816:234;;;;3039:1;2816:234;;::::0;2784:266:::1;;3093:11;3059:16;:31;3076:10;3087:1;3076:13;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;3059:31:8::1;::::0;;;;::::1;::::0;;;;;;;;-1:-1:-1;3059:31:8;;;:45;;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;-1:-1:-1;;3059:45:8;;::::1;-1:-1:-1::0;;;;;3059:45:8;;::::1;;-1:-1:-1::0;;;;3059:45:8::1;-1:-1:-1::0;;;3059:45:8;;::::1;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;;;3059:45:8::1;-1:-1:-1::0;;;3059:45:8;;::::1;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;;;;3059:45:8::1;-1:-1:-1::0;;;3059:45:8;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;::::0;::::1;::::0;-1:-1:-1;3059:45:8;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;;;3118:11;;;;3127:1;;3118:11;::::1;;;;;;;;;;;:15;3115:83;;;3146:5;::::0;3161:13;;-1:-1:-1;;;;;3146:5:8;;::::1;::::0;:14:::1;::::0;3161:10;;3172:1;;3161:13;::::1;;;;;;;;;;;3176:8;3185:1;3176:11;;;;;;;;;;;;;;3146:42;;;;;;;;;;;;;-1:-1:-1::0;;;;;3146:42:8::1;-1:-1:-1::0;;;;;3146:42:8::1;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;3146:42:8;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;3146:42:8;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;;3115:83:8::1;3213:110;3223:10;3234:1;3223:13;;;;;;;;;;;;;;3238:10;3249:1;3238:13;;;;;;;;;;;;;;3253:7;3261:1;3253:10;;;;;;;;;;;;;;3265:16;3282:1;3265:19;;;;;;;;;;;;;;3286:20;3307:1;3286:23;;;;;;;;;;;;;;3311:8;3320:1;3311:11;;;;;;;;;::::0;;::::1;::::0;;;;;;;3213:110:::1;::::0;;-1:-1:-1;;;;;3213:110:8;;::::1;::::0;;-1:-1:-1;;;;;3213:110:8;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;::::1;::::0;;;;;;::::1;::::0;;;;;;;;;;;;;;;;::::1;-1:-1:-1::0;;2470:3:8::1;;2437:894;;;;1784:1552:::0;;;;;;:::o;4377:1236::-;4449:6;4457:7;4473:35;;:::i;:::-;-1:-1:-1;;;;;;4511:28:8;;;;;;:16;:28;;;;;;;;;4473:66;;;;;;;;;-1:-1:-1;;;;;4473:66:8;;;;;-1:-1:-1;;;4473:66:8;;;;;;;;;;;-1:-1:-1;;;4473:66:8;;;;;;;;;;;-1:-1:-1;;;4473:66:8;;;;;;;;;;;;;;;;;;;;;;;;;;;4644:3;:33;4640:69;;;-1:-1:-1;4696:1:8;;-1:-1:-1;4696:1:8;;-1:-1:-1;4688:13:8;;4640:69;4717:19;4739:36;4747:17;:27;;;-1:-1:-1;;;;;4739:36:8;:3;:7;;:36;;;;:::i;:::-;4968:30;;;;4930:33;;4717:58;;-1:-1:-1;281:6:8;4810:29;;;4930:69;;-1:-1:-1;;;;;4930:37:8;;;;:69;:37;:69;:::i;:::-;-1:-1:-1;;;;;4915:84:8;:11;-1:-1:-1;;;;;4915:84:8;;4911:697;;5010:23;5036:60;5065:17;:30;;;5036:17;:24;;;:28;;:60;;;;:::i;:::-;5151:31;;;;5113:33;;5010:86;;-1:-1:-1;5113:70:8;;-1:-1:-1;;;;;5113:37:8;;:70;:37;:70;:::i;:::-;5105:96;-1:-1:-1;5185:15:8;-1:-1:-1;5105:96:8;;-1:-1:-1;;;5105:96:8;4911:697;5224:20;5247:47;5263:17;:30;;;5247:11;-1:-1:-1;;;;;5247:15:8;;;:47;;;;:::i;:::-;5224:70;;5303:19;5325:50;5343:17;:31;;;5325:13;-1:-1:-1;;;;;5325:17:8;;;:50;;;;:::i;:::-;5445:33;;5416:24;;;;5303:72;;-1:-1:-1;5384:29:8;;5416:63;;-1:-1:-1;;;;;5416:63:8;;:28;:63;:::i;:::-;5384:95;-1:-1:-1;5488:20:8;5511:45;-1:-1:-1;;;;;5511:18:8;;5384:95;5511:45;:22;:45;:::i;:::-;5573:12;;-1:-1:-1;5488:68:8;;-1:-1:-1;5565:35:8;;-1:-1:-1;;;;;;5565:35:8;4377:1236;;;;:::o;5670:164::-;-1:-1:-1;;;;;5791:23:8;;5736:4;5791:23;;;:16;:23;;;;;;;:36;;;;5756:30;;;;;:72;;;:34;:72;:::i;:::-;5749:79;5670:164;-1:-1:-1;;5670:164:8:o;213:20::-;;;-1:-1:-1;;;;;213:20:8;;:::o;3556:615::-;3599:19;3625:20;3683:33;3705:10;3683:21;:33::i;:::-;3652:64;;-1:-1:-1;3652:64:8;-1:-1:-1;3731:16:8;3723:53;;;;;-1:-1:-1;;;3723:53:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;3839:10;3785:34;3822:28;;;:16;:28;;;;;3889:29;;:47;;-1:-1:-1;;;3889:29:8;;-1:-1:-1;;;;;3889:29:8;3923:12;3889:33;:47::i;:::-;3857:79;;-1:-1:-1;;;;;3857:79:8;;;;-1:-1:-1;;;3857:79:8;-1:-1:-1;;;;3857:79:8;;;;;;3974:28;;;;:46;;4007:12;3974:46;:32;:46;:::i;:::-;3943:28;;;:77;4041:5;;;:40;;;-1:-1:-1;;;4041:40:8;;4056:10;4041:40;;;;;;;;;;;;-1:-1:-1;;;;;4041:5:8;;;;:14;;:40;;;;;;;;;;;;;;;;;:5;:40;;;2:2:-1;;;;27:1;24;17:12;2:2;4041:40:8;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;4041:40:8;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;4041:40:8;4033:81;;;;;-1:-1:-1;;;4033:81:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;4126:39;;;4140:10;4126:39;;;;;;;;;;;;;;;;;;;;;3556:615;;;:::o;191:17::-;;;-1:-1:-1;;;;;191:17:8;;:::o;3229:132:6:-;3287:7;3314:39;3318:1;3321;3314:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;3307:46;3229:132;-1:-1:-1;;;3229:132:6:o;1392:136::-;1450:7;1477:43;1481:1;1484;1477:43;;;;;;;;;;;;;;;;;:3;:43::i;1665:467:7:-;1721:6;-1:-1:-1;;;;;1965:6:7;;1961:47;;-1:-1:-1;1995:1:7;1988:8;;1961:47;2031:5;;;-1:-1:-1;;;;;2055:10:7;;;;:5;;;;;;;;;;;;-1:-1:-1;;;;;2055:10:7;;2047:56;;;;-1:-1:-1;;;2047:56:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;709:180;765:6;797:1;-1:-1:-1;;;;;792:6:7;:1;-1:-1:-1;;;;;792:6:7;;;784:49;;;;;-1:-1:-1;;;784:49:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;855:5:7;;;709:180::o;2600:329::-;2656:6;2754:1;2750;-1:-1:-1;;;;;2750:5:7;;2742:44;;;;;-1:-1:-1;;;2742:44:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;2797:8;2812:1;-1:-1:-1;;;;;2808:5:7;:1;-1:-1:-1;;;;;2808:5:7;;;;;;;;2600:329;-1:-1:-1;;;;2600:329:7:o;2282:471:6:-;2340:7;2585:6;2581:47;;-1:-1:-1;2615:1:6;2608:8;;2581:47;2652:5;;;2656:1;2652;:5;:1;2676:5;;;;;:10;2668:56;;;;-1:-1:-1;;;2668:56:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;257:177:7;313:6;343:5;;;-1:-1:-1;;;;;367:6:7;;;;;;;;359:46;;;;;-1:-1:-1;;;359:46:7;;;;;;;;;;;;;;;;;;;;;;;;;;;928:181:6;986:7;1018:5;;;1042:6;;;;1034:46;;;;;-1:-1:-1;;;1034:46:6;;;;;;;;;;;;;;;;;;;;;;;;;;;3857:278;3943:7;3978:12;3971:5;3963:28;;;;-1:-1:-1;;;3963:28:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;3963:28:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4002:9;4018:1;4014;:5;;;;;;;3857:278;-1:-1:-1;;;;;3857:278:6:o;1831:192::-;1917:7;1953:12;1945:6;;;;1937:29;;;;-1:-1:-1;;;1937:29:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1937:29:6;-1:-1:-1;;;1989:5:6;;;1831:192::o;104:5733:8:-;;;;;;;;;-1:-1:-1;104:5733:8;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://b221c53be8e52b1605065cbd5b1ff019bbcd577c4c4e5c813dcdd12e7f6d28e1