Contract 0xa74a72a5d7d8fdc33337187c642dedd3af62a7b8

/**
 *Submitted for verification at polygonscan.com on 2021-09-08
*/

// File: Farm2/libs/IRewardLocker.sol


pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;


interface IRewardLocker {
  struct VestingSchedule {
    uint64 startBlock;
    uint64 endBlock;
    uint128 quantity;
    uint128 vestedQuantity;
  }

  event VestingEntryCreated(
    IERC20 indexed token,
    address indexed beneficiary,
    uint256 startBlock,
    uint256 endBlock,
    uint256 quantity,
    uint256 index
  );

  event VestingEntryQueued(
    uint256 indexed index,
    IERC20 indexed token,
    address indexed beneficiary,
    uint256 quantity
  );

  event Vested(
    IERC20 indexed token,
    address indexed beneficiary,
    uint256 vestedQuantity,
    uint256 index
  );

  /**
   * @dev queue a vesting schedule starting from now
   */
  function lock(
    IERC20 token,
    address account,
    uint256 amount
  ) external payable;

  /**
   * @dev queue a vesting schedule
   */
  function lockWithStartBlock(
    IERC20 token,
    address account,
    uint256 quantity,
    uint256 startBlock
  ) external payable;

  /**
   * @dev vest all completed schedules for multiple tokens
   */
  function vestCompletedSchedulesForMultipleTokens(IERC20[] calldata tokens)
    external
    returns (uint256[] memory vestedAmounts);

  /**
   * @dev claim multiple tokens for specific vesting schedule,
   *      if schedule has not ended yet, claiming amounts are linear with vesting blocks
   */
  function vestScheduleForMultipleTokensAtIndices(
    IERC20[] calldata tokens,
    uint256[][] calldata indices
  )
    external
    returns (uint256[] memory vestedAmounts);

  /**
   * @dev for all completed schedule, claim token
   */
  function vestCompletedSchedules(IERC20 token) external returns (uint256);

  /**
   * @dev claim token for specific vesting schedule,
   * @dev if schedule has not ended yet, claiming amount is linear with vesting blocks
   */
  function vestScheduleAtIndices(IERC20 token, uint256[] calldata indexes)
    external
    returns (uint256);

  /**
   * @dev claim token for specific vesting schedule from startIndex to endIndex
   */
  function vestSchedulesInRange(
    IERC20 token,
    uint256 startIndex,
    uint256 endIndex
  ) external returns (uint256);

  /**
   * @dev length of vesting schedules array
   */
  function numVestingSchedules(address account, IERC20 token) external view returns (uint256);

  /**
   * @dev get detailed of each vesting schedule
   */
  function getVestingScheduleAtIndex(
    address account,
    IERC20 token,
    uint256 index
  ) external view returns (VestingSchedule memory);

  /**
   * @dev get vesting shedules array
   */
  function getVestingSchedules(address account, IERC20 token)
    external
    view
    returns (VestingSchedule[] memory schedules);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/GSN/Context.sol



pragma solidity ^0.6.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;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/access/Ownable.sol



pragma solidity ^0.6.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.
 */
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 () internal {
        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;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/IERC20.sol



pragma solidity ^0.6.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);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/ERC20.sol



pragma solidity ^0.6.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;
    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.
     */
    constructor (string memory name, string memory symbol) public {
        _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 { }
}
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/ERC20Burnable.sol



pragma solidity ^0.6.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 {
    /**
     * @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);
    }
}

// File: StarToken.sol



pragma solidity 0.6.12;




contract StarToken is ERC20("StarSeed Token", "STAR"), ERC20Burnable, Ownable {
    uint256 public maxSupply = 111111 * (10 ** 18);

    uint256 public transferFee = 133;
    
    address public feeAddress = 0xE0e44d4E7e61f2f4f990f5F4e2408D2187315C94;

    function transfer(address to, uint256 amount) public override returns (bool) {
        return super.transfer(to, _transferFee(amount));
    }

    function transferFrom(address from, address to, uint256 amount) public override returns (bool) {
        return super.transferFrom(from, to, _transferFee(amount));
    }

    function _transferFee(uint256 amount) internal returns (uint256) {
        uint256 feeAmount = amount.div(transferFee);

        if (feeAmount > 0) {
            _transfer(msg.sender, feeAddress, feeAmount);
        }

        return amount.sub(feeAmount);
    }

    function mint(address _to, uint256 _amount) external onlyOwner {
        _mint(_to, _amount);

        require(totalSupply() <= maxSupply, "total supply should be less or equal than maxSupply");
    }
}
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/utils/ReentrancyGuard.sol



pragma solidity ^0.6.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/utils/Address.sol



pragma solidity ^0.6.2;

/**
 * @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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/token/ERC20/SafeERC20.sol



pragma solidity ^0.6.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.1.0/contracts/math/SafeMath.sol



pragma solidity ^0.6.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;
    }
}

// File: Farm2/MasterChefv2.sol



pragma solidity 0.6.12;







// MasterChef is the master of STAR. He can make STAR and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once STAR is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
// For any questions contact @macatkevin on Telegram
contract MasterChefv2 is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
        uint256 amount;           // How many LP tokens the user has provided.
        uint256 lastStarPerShare;  // Star per share on last update
        uint256 unclaimed;        // Unclaimed reward in Star.
        // pending reward = user.unclaimed + (user.amount * (pool.accStarPerShare - user.lastStarPerShare)
        //
        // Whenever a user deposits or withdraws Staking tokens to a pool. Here's what happens:
        //   1. The pool's `accStarPerShare` (and `lastStarBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `lastStarPerShare` gets updated.
        //   4. User's `amount` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. STAR to distribute per block.
        uint256 totalDeposited;   // The total deposited by users
        uint256 lastRewardBlock;  // Last block number that STAR distribution occurs.
        uint256 accStarPerShare;   // Accumulated STAR per share, times 1e18. See below.
        uint256 depositFee; // Fee percent on each token deposit.
    }

    // The STAR TOKEN!
    StarToken public immutable star;
    address public starTransferOwner;
    address public devAddress;

    // Contract for locking reward
    IRewardLocker public immutable rewardLocker;

    // STAR tokens created per block.
    uint256 public starPerBlock = 8 ether;
    uint256 public constant MAX_EMISSION_RATE = 1000 ether; // Safety check

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    uint256 public constant MAX_ALLOC_POINT = 100000; // Safety check
    // The block number when STAR mining starts.
    uint256 public immutable startBlock;

    event Add(address indexed user, uint256 allocPoint, IERC20 indexed token, bool massUpdatePools);
    event Set(address indexed user, uint256 pid, uint256 allocPoint);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount, bool harvest);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount, bool harvest);
    event Harvest(address indexed user, uint256 indexed pid, uint256 amount);
    event HarvestMultiple(address indexed user, uint256[] _pids, uint256 amount);
    event HarvestAll(address indexed user, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event SetDevAddress(address indexed user, address indexed newAddress);
    event UpdateEmissionRate(address indexed user, uint256 starPerBlock);
    event SetStarTransferOwner(address indexed user, address indexed starTransferOwner);
    event TransferStarOwnership(address indexed user, address indexed newOwner);

    constructor(
        StarToken _star,
        uint256 _startBlock,
        IRewardLocker _rewardLocker,
        address _devAddress,
        address _starTransferOwner
    ) public {
        require(_devAddress != address(0), "!nonzero");
        star = _star;
        startBlock = _startBlock;

        rewardLocker = _rewardLocker;
        devAddress = _devAddress;
        starTransferOwner = _starTransferOwner;
        
        IERC20(_star).safeApprove(address(_rewardLocker), uint256(0));
        IERC20(_star).safeIncreaseAllowance(
            address(_rewardLocker),
            uint256(-1)
        );
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    mapping(IERC20 => bool) public poolExistence;
    modifier nonDuplicated(IERC20 _lpToken) {
        require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated");
        _;
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(uint256 _allocPoint, IERC20 _lpToken, bool _massUpdatePools, uint256 _depositFee) external onlyOwner nonDuplicated(_lpToken) {
        require(_allocPoint <= MAX_ALLOC_POINT, "!overmax");
        if (_massUpdatePools) {
            massUpdatePools(); // This ensures that massUpdatePools will not exceed gas limit
        }
        _lpToken.balanceOf(address(this)); // Check to make sure it's a token
        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolExistence[_lpToken] = true;
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            totalDeposited: 0,
            allocPoint: _allocPoint,
            lastRewardBlock: lastRewardBlock,
            accStarPerShare: 0,
            depositFee: _depositFee
        }));
        emit Add(msg.sender, _allocPoint, _lpToken, _massUpdatePools);
    }

    // Update the given pool's STAR allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint) external onlyOwner {
        require(_allocPoint <= MAX_ALLOC_POINT, "!overmax");
        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        emit Set(msg.sender, _pid, _allocPoint);
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) {
        return _to.sub(_from);
    }

    // View function to see pending STAR on frontend.
    function pendingStar(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accStarPerShare = pool.accStarPerShare;
        if (block.number > pool.lastRewardBlock && pool.totalDeposited != 0 && totalAllocPoint != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
            uint256 starReward = multiplier.mul(starPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
            accStarPerShare = accStarPerShare.add(starReward.mul(1e18).div(pool.totalDeposited));
        }
        return user.amount.mul(accStarPerShare.sub(user.lastStarPerShare)).div(1e18).add(user.unclaimed);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        if (pool.totalDeposited == 0 || pool.allocPoint == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 starReward = multiplier.mul(starPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
        star.mint(address(this), starReward);
        pool.accStarPerShare = pool.accStarPerShare.add(starReward.mul(1e18).div(pool.totalDeposited));
        pool.lastRewardBlock = block.number;
    }

    // Deposit LP tokens to MasterChef for STAR allocation.
    function deposit(uint256 _pid, uint256 _amount, bool _shouldHarvest) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        _updateUserReward(_pid, _shouldHarvest);
        if (_amount > 0) {
            uint256 beforeDeposit = pool.lpToken.balanceOf(address(this));
            uint256 depositFeeAmount = _amount.div(pool.depositFee);
            uint256 depositContractAmount = _amount.sub(depositFeeAmount);
            pool.lpToken.safeTransferFrom(msg.sender, devAddress, depositFeeAmount);
            pool.lpToken.safeTransferFrom(msg.sender, address(this), depositContractAmount);
            uint256 afterDeposit = pool.lpToken.balanceOf(address(this));
            _amount = afterDeposit.sub(beforeDeposit);

            user.amount = user.amount.add(_amount);
            pool.totalDeposited = pool.totalDeposited.add(_amount);
        }
        emit Deposit(msg.sender, _pid, _amount, _shouldHarvest);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount, bool _shouldHarvest) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: not good");
        _updateUserReward(_pid, _shouldHarvest);
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.totalDeposited = pool.totalDeposited.sub(_amount);
            pool.lpToken.safeTransfer(msg.sender, _amount);
        }
        emit Withdraw(msg.sender, _pid, _amount, _shouldHarvest);
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 amount = user.amount;
        user.amount = 0;
        user.lastStarPerShare = 0;
        user.unclaimed = 0;
        pool.totalDeposited = pool.totalDeposited.sub(amount);
        pool.lpToken.safeTransfer(msg.sender, amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);
    }
    
    // Update the rewards of caller, and harvests if needed
    function _updateUserReward(uint256 _pid, bool _shouldHarvest) internal {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount == 0) {
            user.lastStarPerShare = pool.accStarPerShare;
        }
        uint256 pending = user.amount.mul(pool.accStarPerShare.sub(user.lastStarPerShare)).div(1e18).add(user.unclaimed);
        user.unclaimed = _shouldHarvest ? 0 : pending;
        if (_shouldHarvest && pending > 0) {
            _lockReward(msg.sender, pending);
            emit Harvest(msg.sender, _pid, pending);
        }
        user.lastStarPerShare = pool.accStarPerShare;
    }
    
    // Harvest one pool
    function harvest(uint256 _pid) external nonReentrant {
        _updateUserReward(_pid, true);
    }
    
    // Harvest specific pools into one vest
    function harvestMultiple(uint256[] calldata _pids) external nonReentrant {
        uint256 pending = 0;
        for (uint256 i = 0; i < _pids.length; i++) {
            updatePool(_pids[i]);
            PoolInfo storage pool = poolInfo[_pids[i]];
            UserInfo storage user = userInfo[_pids[i]][msg.sender];
            if (user.amount == 0) {
                user.lastStarPerShare = pool.accStarPerShare;
            }
            pending = pending.add(user.amount.mul(pool.accStarPerShare.sub(user.lastStarPerShare)).div(1e18).add(user.unclaimed));
            user.unclaimed = 0;
            user.lastStarPerShare = pool.accStarPerShare;
        }
        if (pending > 0) {
            _lockReward(msg.sender, pending);
        }
        emit HarvestMultiple(msg.sender, _pids, pending);
    }
    
    // Harvest all into one vest. Will probably not be used
    // Can fail if pool length is too big due to massUpdatePools()
    function harvestAll() external nonReentrant {
        massUpdatePools();
        uint256 pending = 0;
        for (uint256 i = 0; i < poolInfo.length; i++) {
            PoolInfo storage pool = poolInfo[i];
            UserInfo storage user = userInfo[i][msg.sender];
            if (user.amount == 0) {
                user.lastStarPerShare = pool.accStarPerShare;
            }
            pending = pending.add(user.amount.mul(pool.accStarPerShare.sub(user.lastStarPerShare)).div(1e18).add(user.unclaimed));
            user.unclaimed = 0;
            user.lastStarPerShare = pool.accStarPerShare;
        }
        if (pending > 0) {
            _lockReward(msg.sender, pending);
        }
        emit HarvestAll(msg.sender, pending);
    }

    /**
    * @dev Call locker contract to lock rewards
    */
    function _lockReward(address _account, uint256 _amount) internal {
        uint256 starBal = star.balanceOf(address(this));
        rewardLocker.lock(star, _account, _amount > starBal ? starBal : _amount);
    }

    // Update dev address by the previous dev.
    function setDevAddress(address _devAddress) external onlyOwner {
        require(_devAddress != address(0), "!nonzero");
        devAddress = _devAddress;
        emit SetDevAddress(msg.sender, _devAddress);
    }
    
    // Should never fail as long as massUpdatePools is called during add
    function updateEmissionRate(uint256 _starPerBlock) external onlyOwner {
        require(_starPerBlock <= MAX_EMISSION_RATE, "!overmax");
        massUpdatePools();
        starPerBlock = _starPerBlock;
        emit UpdateEmissionRate(msg.sender, _starPerBlock);
    }

    // Update star transfer owner. Can only be called by existing starTransferOwner
    function setStarTransferOwner(address _starTransferOwner) external {
        require(msg.sender == starTransferOwner);
        starTransferOwner = _starTransferOwner;
        emit SetStarTransferOwner(msg.sender, _starTransferOwner);
    }

    /**
     * @dev DUE TO THIS CODE THIS CONTRACT MUST BE BEHIND A TIMELOCK (Ideally 7)
     * THIS FUNCTION EXISTS ONLY IF THERE IS AN ISSUE WITH THIS CONTRACT 
     * AND TOKEN MIGRATION MUST HAPPEN
     */
    function transferStarOwnership(address _newOwner) external {
        require(msg.sender == starTransferOwner);
        star.transferOwnership(_newOwner);
        emit TransferStarOwnership(msg.sender, _newOwner);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract StarToken","name":"_star","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"contract IRewardLocker","name":"_rewardLocker","type":"address"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"address","name":"_starTransferOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"bool","name":"massUpdatePools","type":"bool"}],"name":"Add","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"harvest","type":"bool"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"HarvestAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"_pids","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"HarvestMultiple","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":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"}],"name":"Set","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"starTransferOwner","type":"address"}],"name":"SetStarTransferOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"TransferStarOwnership","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"starPerBlock","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"harvest","type":"bool"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MAX_ALLOC_POINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_EMISSION_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_massUpdatePools","type":"bool"},{"internalType":"uint256","name":"_depositFee","type":"uint256"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bool","name":"_shouldHarvest","type":"bool"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_pids","type":"uint256[]"}],"name":"harvestMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingStar","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"totalDeposited","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accStarPerShare","type":"uint256"},{"internalType":"uint256","name":"depositFee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardLocker","outputs":[{"internalType":"contract IRewardLocker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_starTransferOwner","type":"address"}],"name":"setStarTransferOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"star","outputs":[{"internalType":"contract StarToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"starPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"starTransferOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"transferStarOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_starPerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"lastStarPerShare","type":"uint256"},{"internalType":"uint256","name":"unclaimed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bool","name":"_shouldHarvest","type":"bool"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60e0604052676f05b59d3b20000060045560006007553480156200002257600080fd5b5060405162004d1338038062004d13833981810160405281019062000048919062000921565b60006200005a620002fa60201b60201c565b9050806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35060018081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141562000172576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620001699062000cb8565b60405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1660601b815250508360c081815250508273ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1660601b8152505081600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506200029d8360008773ffffffffffffffffffffffffffffffffffffffff166200030260201b6200254e179092919060201c565b620002ef837fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8773ffffffffffffffffffffffffffffffffffffffff166200047460201b620026ac179092919060201c565b505050505062000ead565b600033905090565b6000811480620003a2575060008373ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e30856040518363ffffffff1660e01b81526004016200034c92919062000c18565b60206040518083038186803b1580156200036557600080fd5b505afa1580156200037a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620003a09190620009a3565b145b620003e4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620003db9062000d1e565b60405180910390fd5b6200046f8363095ea7b360e01b84846040516024016200040692919062000c45565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050620005b360201b60201c565b505050565b600062000520828573ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e30876040518363ffffffff1660e01b8152600401620004b892919062000c18565b60206040518083038186803b158015620004d157600080fd5b505afa158015620004e6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200050c9190620009a3565b6200068760201b620027d41790919060201c565b9050620005ad8463095ea7b360e01b85846040516024016200054492919062000c45565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050620005b360201b60201c565b50505050565b60606200061c826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16620006df60201b62002829179092919060201c565b90506000815111156200068257808060200190518101906200063f9190620008f5565b62000681576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620006789062000cfc565b60405180910390fd5b5b505050565b600080828401905083811015620006d5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620006cc9062000c96565b60405180910390fd5b8091505092915050565b6060620006f68484600085620006ff60201b60201c565b90509392505050565b606062000712856200083660201b60201c565b62000754576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016200074b9062000cda565b60405180910390fd5b600060608673ffffffffffffffffffffffffffffffffffffffff16858760405162000780919062000bff565b60006040518083038185875af1925050503d8060008114620007bf576040519150601f19603f3d011682016040523d82523d6000602084013e620007c4565b606091505b50915091508115620007db5780925050506200082e565b600081511115620007ef5780518082602001fd5b836040517f08c379a000000000000000000000000000000000000000000000000000000000815260040162000825919062000c72565b60405180910390fd5b949350505050565b60008060007fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060001b9050833f91508082141580156200087957506000801b8214155b92505050919050565b600081519050620008938162000e2b565b92915050565b600081519050620008aa8162000e45565b92915050565b600081519050620008c18162000e5f565b92915050565b600081519050620008d88162000e79565b92915050565b600081519050620008ef8162000e93565b92915050565b6000602082840312156200090857600080fd5b6000620009188482850162000899565b91505092915050565b600080600080600060a086880312156200093a57600080fd5b60006200094a88828901620008c7565b95505060206200095d88828901620008de565b94505060406200097088828901620008b0565b9350506060620009838882890162000882565b9250506080620009968882890162000882565b9150509295509295909350565b600060208284031215620009b657600080fd5b6000620009c684828501620008de565b91505092915050565b620009da8162000d72565b82525050565b6000620009ed8262000d40565b620009f9818562000d56565b935062000a0b81856020860162000de4565b80840191505092915050565b600062000a248262000d4b565b62000a30818562000d61565b935062000a4281856020860162000de4565b62000a4d8162000e1a565b840191505092915050565b600062000a67601b8362000d61565b91507f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006000830152602082019050919050565b600062000aa960088362000d61565b91507f216e6f6e7a65726f0000000000000000000000000000000000000000000000006000830152602082019050919050565b600062000aeb601d8362000d61565b91507f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006000830152602082019050919050565b600062000b2d602a8362000d61565b91507f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008301527f6f742073756363656564000000000000000000000000000000000000000000006020830152604082019050919050565b600062000b9560368362000d61565b91507f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60008301527f20746f206e6f6e2d7a65726f20616c6c6f77616e6365000000000000000000006020830152604082019050919050565b62000bf98162000dda565b82525050565b600062000c0d8284620009e0565b915081905092915050565b600060408201905062000c2f6000830185620009cf565b62000c3e6020830184620009cf565b9392505050565b600060408201905062000c5c6000830185620009cf565b62000c6b602083018462000bee565b9392505050565b6000602082019050818103600083015262000c8e818462000a17565b905092915050565b6000602082019050818103600083015262000cb18162000a58565b9050919050565b6000602082019050818103600083015262000cd38162000a9a565b9050919050565b6000602082019050818103600083015262000cf58162000adc565b9050919050565b6000602082019050818103600083015262000d178162000b1e565b9050919050565b6000602082019050818103600083015262000d398162000b86565b9050919050565b600081519050919050565b600081519050919050565b600081905092915050565b600082825260208201905092915050565b600062000d7f8262000dba565b9050919050565b60008115159050919050565b600062000d9f8262000d72565b9050919050565b600062000db38262000d72565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60005b8381101562000e0457808201518184015260208101905062000de7565b8381111562000e14576000848401525b50505050565b6000601f19601f8301169050919050565b62000e368162000d72565b811462000e4257600080fd5b50565b62000e508162000d86565b811462000e5c57600080fd5b50565b62000e6a8162000d92565b811462000e7657600080fd5b50565b62000e848162000da6565b811462000e9057600080fd5b50565b62000e9e8162000dda565b811462000eaa57600080fd5b50565b60805160601c60a05160601c60c051613e1062000f036000398061148b5280611f435280611f6a525080610f5952806129fc525080610d07528061155f528061188452806129515280612a385250613e106000f3fe608060405234801561001057600080fd5b50600436106101ef5760003560e01c806348cd4cb11161010f5780638ed955b9116100a2578063d0d41fe111610071578063d0d41fe11461054d578063ddc6326214610569578063f2fde38b14610585578063f958d1f9146105a1576101ef565b80638ed955b9146104c557806393f1a40b146104cf57806396805e5414610501578063cbd258b51461051d576101ef565b806369eb9d15116100de57806369eb9d1514610451578063715018a61461046d5780638da5cb5b146104775780638dbb1e3a14610495576101ef565b806348cd4cb1146103f157806351eb05a61461040f5780635312ea8e1461042b578063630b5ba114610447576101ef565b80632c6dbb1c116101875780633ad10ef6116101565780633ad10ef61461037d578063401474e81461039b578063436cc3d6146103b757806343a0d066146103d5576101ef565b80632c6dbb1c1461030757806333cfcd3b1461032557806337064ee6146103415780633892601c1461035f576101ef565b80631526fe27116101c35780631526fe271461027c57806317caf6f1146102b15780631ab06ee5146102cf578063218e0f73146102eb576101ef565b8062ed8206146101f4578063081e3eda146102125780630ba84cd21461023057806312bdc1ca1461024c575b600080fd5b6101fc6105bf565b6040516102099190613b7e565b60405180910390f35b61021a6105c5565b6040516102279190613b7e565b60405180910390f35b61024a600480360381019061024591906131d6565b6105d2565b005b61026660048036038101906102619190613228565b610713565b6040516102739190613b7e565b60405180910390f35b610296600480360381019061029191906131d6565b6108c1565b6040516102a89695949392919061390e565b60405180910390f35b6102b961092a565b6040516102c69190613b7e565b60405180910390f35b6102e960048036038101906102e491906132c7565b610930565b005b6103056004803603810190610300919061313f565b610acd565b005b61030f610d05565b60405161031c919061398a565b60405180910390f35b61033f600480360381019061033a9190613303565b610d29565b005b610349610f31565b604051610356919061381d565b60405180910390f35b610367610f57565b604051610374919061396f565b60405180910390f35b610385610f7b565b604051610392919061381d565b60405180910390f35b6103b560048036038101906103b09190613116565b610fa1565b005b6103bf611099565b6040516103cc9190613b7e565b60405180910390f35b6103ef60048036038101906103ea9190613303565b6110a6565b005b6103f9611489565b6040516104069190613b7e565b60405180910390f35b610429600480360381019061042491906131d6565b6114ad565b005b610445600480360381019061044091906131d6565b611649565b005b61044f6117fb565b005b61046b60048036038101906104669190613116565b611828565b005b61047561196a565b005b61047f611abd565b60405161048c919061381d565b60405180910390f35b6104af60048036038101906104aa91906132c7565b611ae6565b6040516104bc9190613b7e565b60405180910390f35b6104cd611b03565b005b6104e960048036038101906104e49190613228565b611d00565b6040516104f893929190613beb565b60405180910390f35b61051b60048036038101906105169190613264565b611d37565b005b610537600480360381019061053291906131ad565b61215f565b60405161054491906138f3565b60405180910390f35b61056760048036038101906105629190613116565b61217f565b005b610583600480360381019061057e91906131d6565b612322565b005b61059f600480360381019061059a9190613116565b612385565b005b6105a9612547565b6040516105b69190613b7e565b60405180910390f35b60045481565b6000600580549050905090565b6105da612841565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610667576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065e90613a7e565b60405180910390fd5b683635c9adc5dea000008111156106b3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106aa90613a9e565b60405180910390fd5b6106bb6117fb565b806004819055503373ffffffffffffffffffffffffffffffffffffffff167fe2492e003bbe8afa53088b406f0c1cb5d9e280370fc72a74cf116ffd343c4053826040516107089190613b7e565b60405180910390a250565b6000806005848154811061072357fe5b9060005260206000209060060201905060006006600086815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000826004015490508260030154431180156107a857506000836002015414155b80156107b75750600060075414155b156108595760006107cc846003015443611ae6565b9050600061080f60075461080187600101546107f36004548761284990919063ffffffff16565b61284990919063ffffffff16565b6128b990919063ffffffff16565b90506108546108458660020154610837670de0b6b3a76400008561284990919063ffffffff16565b6128b990919063ffffffff16565b846127d490919063ffffffff16565b925050505b6108b682600201546108a8670de0b6b3a764000061089a61088787600101548761290390919063ffffffff16565b876000015461284990919063ffffffff16565b6128b990919063ffffffff16565b6127d490919063ffffffff16565b935050505092915050565b600581815481106108ce57fe5b90600052602060002090600602016000915090508060000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16908060010154908060020154908060030154908060040154908060050154905086565b60075481565b610938612841565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146109c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109bc90613a7e565b60405180910390fd5b620186a0811115610a0b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a0290613a9e565b60405180910390fd5b610a5081610a4260058581548110610a1f57fe5b90600052602060002090600602016001015460075461290390919063ffffffff16565b6127d490919063ffffffff16565b6007819055508060058381548110610a6457fe5b9060005260206000209060060201600101819055503373ffffffffffffffffffffffffffffffffffffffff167f9eca8f7bcfb868d72b4ed95b71c627c194ab6bcb9b83adb2280e8a0320bb84768383604051610ac1929190613bc2565b60405180910390a25050565b60026001541415610b13576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b0a90613b3e565b60405180910390fd5b60026001819055506000805b83839050811015610c9257610b45848483818110610b3957fe5b905060200201356114ad565b60006005858584818110610b5557fe5b9050602002013581548110610b6657fe5b90600052602060002090600602019050600060066000878786818110610b8857fe5b90506020020135815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050600081600001541415610bf757816004015481600101819055505b610c6a610c5b8260020154610c4d670de0b6b3a7640000610c3f610c2c8760010154896004015461290390919063ffffffff16565b876000015461284990919063ffffffff16565b6128b990919063ffffffff16565b6127d490919063ffffffff16565b856127d490919063ffffffff16565b9350600081600201819055508160040154816001018190555050508080600101915050610b1f565b506000811115610ca757610ca6338261294d565b5b3373ffffffffffffffffffffffffffffffffffffffff167f112209c50e183ea8b99608876ddc6f45b4abe3d7ae3ed1b3c79c23f855d6a352848484604051610cf1939291906138c1565b60405180910390a250600180819055505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b60026001541415610d6f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d6690613b3e565b60405180910390fd5b6002600181905550600060058481548110610d8657fe5b9060005260206000209060060201905060006006600086815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090508381600001541015610e31576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e2890613ade565b60405180910390fd5b610e3b8584612abc565b6000841115610ed257610e5b84826000015461290390919063ffffffff16565b8160000181905550610e7a84836002015461290390919063ffffffff16565b8260020181905550610ed133858460000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612c4e9092919063ffffffff16565b5b843373ffffffffffffffffffffffffffffffffffffffff167fb97e775637eca8401af330efee0810af7079bafae27761741e09caa14db8d2728686604051610f1b929190613b99565b60405180910390a3505060018081905550505050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b7f000000000000000000000000000000000000000000000000000000000000000081565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ffb57600080fd5b80600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fe4a809f8453ab494544f177c3830b496eceb50fb26e6d18b350321bd17c9c88f60405160405180910390a350565b683635c9adc5dea0000081565b600260015414156110ec576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110e390613b3e565b60405180910390fd5b600260018190555060006005848154811061110357fe5b9060005260206000209060060201905060006006600086815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506111718584612abc565b600084111561142a5760008260000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016111d9919061381d565b60206040518083038186803b1580156111f157600080fd5b505afa158015611205573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061122991906131ff565b905060006112448460050154876128b990919063ffffffff16565b9050600061125b828861290390919063ffffffff16565b90506112d033600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848860000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612cd4909392919063ffffffff16565b6113213330838860000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612cd4909392919063ffffffff16565b60008560000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401611380919061381d565b60206040518083038186803b15801561139857600080fd5b505afa1580156113ac573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113d091906131ff565b90506113e5848261290390919063ffffffff16565b97506113fe8886600001546127d490919063ffffffff16565b856000018190555061141d8887600201546127d490919063ffffffff16565b8660020181905550505050505b843373ffffffffffffffffffffffffffffffffffffffff167f6dbb6056a2fff319358e6dd7d0d72cb3baa992cdcc7e120fb0a32cd1601840e58686604051611473929190613b99565b60405180910390a3505060018081905550505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b6000600582815481106114bc57fe5b90600052602060002090600602019050806003015443116114dd5750611646565b6000816002015414806114f4575060008160010154145b156115085743816003018190555050611646565b6000611518826003015443611ae6565b9050600061155b60075461154d856001015461153f6004548761284990919063ffffffff16565b61284990919063ffffffff16565b6128b990919063ffffffff16565b90507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166340c10f1930836040518363ffffffff1660e01b81526004016115b8929190613898565b600060405180830381600087803b1580156115d257600080fd5b505af11580156115e6573d6000803e3d6000fd5b5050505061163161161e8460020154611610670de0b6b3a76400008561284990919063ffffffff16565b6128b990919063ffffffff16565b84600401546127d490919063ffffffff16565b83600401819055504383600301819055505050505b50565b6002600154141561168f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161168690613b3e565b60405180910390fd5b60026001819055506000600582815481106116a657fe5b9060005260206000209060060201905060006006600084815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020905060008160000154905060008260000181905550600082600101819055506000826002018190555061174881846002015461290390919063ffffffff16565b836002018190555061179f33828560000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612c4e9092919063ffffffff16565b833373ffffffffffffffffffffffffffffffffffffffff167fbb757047c2b5f3974fe26b7c10f732e7bce710b0952a71082702781e62ae0595836040516117e69190613b7e565b60405180910390a35050506001808190555050565b6000600580549050905060005b8181101561182457611819816114ad565b806001019050611808565b5050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461188257600080fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663f2fde38b826040518263ffffffff1660e01b81526004016118db919061381d565b600060405180830381600087803b1580156118f557600080fd5b505af1158015611909573d6000803e3d6000fd5b505050508073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f471fc567fbce0dca453f0e4d07766d8294c6e6ce52b0e360f76cbd285f431ac160405160405180910390a350565b611972612841565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146119ff576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119f690613a7e565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a360008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000611afb838361290390919063ffffffff16565b905092915050565b60026001541415611b49576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b4090613b3e565b60405180910390fd5b6002600181905550611b596117fb565b6000805b600580549050811015611c9357600060058281548110611b7957fe5b9060005260206000209060060201905060006006600084815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050600081600001541415611bf857816004015481600101819055505b611c6b611c5c8260020154611c4e670de0b6b3a7640000611c40611c2d8760010154896004015461290390919063ffffffff16565b876000015461284990919063ffffffff16565b6128b990919063ffffffff16565b6127d490919063ffffffff16565b856127d490919063ffffffff16565b9350600081600201819055508160040154816001018190555050508080600101915050611b5d565b506000811115611ca857611ca7338261294d565b5b3373ffffffffffffffffffffffffffffffffffffffff167fb99be208a056eff82108fe5a30bcc952d8d8e29c06a5c16918d61a14da8f7a4682604051611cee9190613b7e565b60405180910390a25060018081905550565b6006602052816000526040600020602052806000526040600020600091509150508060000154908060010154908060020154905083565b611d3f612841565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611dcc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dc390613a7e565b60405180910390fd5b8260001515600860008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16151514611e60576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e5790613afe565b60405180910390fd5b620186a0851115611ea6576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e9d90613a9e565b60405180910390fd5b8215611eb557611eb46117fb565b5b8373ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401611eee919061381d565b60206040518083038186803b158015611f0657600080fd5b505afa158015611f1a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611f3e91906131ff565b5060007f00000000000000000000000000000000000000000000000000000000000000004311611f8e577f0000000000000000000000000000000000000000000000000000000000000000611f90565b435b9050611fa7866007546127d490919063ffffffff16565b6007819055506001600860008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff02191690831515021790555060056040518060c001604052808773ffffffffffffffffffffffffffffffffffffffff168152602001888152602001600081526020018381526020016000815260200185815250908060018154018082558091505060019003906000526020600020906006020160009091909190915060008201518160000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506020820151816001015560408201518160020155606082015181600301556080820151816004015560a0820151816005015550508473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f6bff160bd5aed7481f5b68cfb37186cc022a63f2dec5eca7648178b239ae2892888760405161214f929190613b99565b60405180910390a3505050505050565b60086020528060005260406000206000915054906101000a900460ff1681565b612187612841565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614612214576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161220b90613a7e565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415612284576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161227b90613a3e565b60405180910390fd5b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f618c54559e94f1499a808aad71ee8729f8e74e8c48e979616328ce493a1a52e760405160405180910390a350565b60026001541415612368576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161235f90613b3e565b60405180910390fd5b600260018190555061237b816001612abc565b6001808190555050565b61238d612841565b73ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161461241a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161241190613a7e565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561248a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612481906139fe565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff1660008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a3806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b620186a081565b60008114806125e7575060008373ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e30856040518363ffffffff1660e01b8152600401612595929190613838565b60206040518083038186803b1580156125ad57600080fd5b505afa1580156125c1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125e591906131ff565b145b612626576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161261d90613b5e565b60405180910390fd5b6126a78363095ea7b360e01b8484604051602401612645929190613898565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612d5d565b505050565b600061274b828573ffffffffffffffffffffffffffffffffffffffff1663dd62ed3e30876040518363ffffffff1660e01b81526004016126ed929190613838565b60206040518083038186803b15801561270557600080fd5b505afa158015612719573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061273d91906131ff565b6127d490919063ffffffff16565b90506127ce8463095ea7b360e01b858460405160240161276c929190613898565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612d5d565b50505050565b60008082840190508381101561281f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161281690613a1e565b60405180910390fd5b8091505092915050565b60606128388484600085612e24565b90509392505050565b600033905090565b60008083141561285c57600090506128b3565b600082840290508284828161286d57fe5b04146128ae576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016128a590613a5e565b60405180910390fd5b809150505b92915050565b60006128fb83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612f47565b905092915050565b600061294583836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612fa8565b905092915050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016129a8919061381d565b60206040518083038186803b1580156129c057600080fd5b505afa1580156129d4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129f891906131ff565b90507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16637750c9f07f000000000000000000000000000000000000000000000000000000000000000085848611612a655785612a67565b845b6040518463ffffffff1660e01b8152600401612a85939291906139a5565b600060405180830381600087803b158015612a9f57600080fd5b505af1158015612ab3573d6000803e3d6000fd5b50505050505050565b600060058381548110612acb57fe5b9060005260206000209060060201905060006006600085815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000209050612b38846114ad565b600081600001541415612b5357816004015481600101819055505b6000612bb68260020154612ba8670de0b6b3a7640000612b9a612b878760010154896004015461290390919063ffffffff16565b876000015461284990919063ffffffff16565b6128b990919063ffffffff16565b6127d490919063ffffffff16565b905083612bc35780612bc6565b60005b8260020181905550838015612bdb5750600081115b15612c3a57612bea338261294d565b843373ffffffffffffffffffffffffffffffffffffffff167f71bab65ced2e5750775a0613be067df48ef06cf92a496ebf7663ae066092495483604051612c319190613b7e565b60405180910390a35b826004015482600101819055505050505050565b612ccf8363a9059cbb60e01b8484604051602401612c6d929190613898565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612d5d565b505050565b612d57846323b872dd60e01b858585604051602401612cf593929190613861565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612d5d565b50505050565b6060612dbf826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166128299092919063ffffffff16565b9050600081511115612e1f5780806020019051810190612ddf9190613184565b612e1e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612e1590613b1e565b60405180910390fd5b5b505050565b6060612e2f85613003565b612e6e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612e6590613abe565b60405180910390fd5b600060608673ffffffffffffffffffffffffffffffffffffffff168587604051612e989190613806565b60006040518083038185875af1925050503d8060008114612ed5576040519150601f19603f3d011682016040523d82523d6000602084013e612eda565b606091505b50915091508115612eef578092505050612f3f565b600081511115612f025780518082602001fd5b836040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612f3691906139dc565b60405180910390fd5b949350505050565b60008083118290612f8e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612f8591906139dc565b60405180910390fd5b506000838581612f9a57fe5b049050809150509392505050565b6000838311158290612ff0576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612fe791906139dc565b60405180910390fd5b5060008385039050809150509392505050565b60008060007fc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a47060001b9050833f915080821415801561304557506000801b8214155b92505050919050565b60008135905061305d81613d7e565b92915050565b60008083601f84011261307557600080fd5b8235905067ffffffffffffffff81111561308e57600080fd5b6020830191508360208202830111156130a657600080fd5b9250929050565b6000813590506130bc81613d95565b92915050565b6000815190506130d181613d95565b92915050565b6000813590506130e681613dac565b92915050565b6000813590506130fb81613dc3565b92915050565b60008151905061311081613dc3565b92915050565b60006020828403121561312857600080fd5b60006131368482850161304e565b91505092915050565b6000806020838503121561315257600080fd5b600083013567ffffffffffffffff81111561316c57600080fd5b61317885828601613063565b92509250509250929050565b60006020828403121561319657600080fd5b60006131a4848285016130c2565b91505092915050565b6000602082840312156131bf57600080fd5b60006131cd848285016130d7565b91505092915050565b6000602082840312156131e857600080fd5b60006131f6848285016130ec565b91505092915050565b60006020828403121561321157600080fd5b600061321f84828501613101565b91505092915050565b6000806040838503121561323b57600080fd5b6000613249858286016130ec565b925050602061325a8582860161304e565b9150509250929050565b6000806000806080858703121561327a57600080fd5b6000613288878288016130ec565b9450506020613299878288016130d7565b93505060406132aa878288016130ad565b92505060606132bb878288016130ec565b91505092959194509250565b600080604083850312156132da57600080fd5b60006132e8858286016130ec565b92505060206132f9858286016130ec565b9150509250929050565b60008060006060848603121561331857600080fd5b6000613326868287016130ec565b9350506020613337868287016130ec565b9250506040613348868287016130ad565b9150509250925092565b61335b81613c65565b82525050565b600061336d8385613c38565b93507f07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff83111561339c57600080fd5b6020830292506133ad838584613d2b565b82840190509392505050565b6133c281613c77565b82525050565b60006133d382613c22565b6133dd8185613c49565b93506133ed818560208601613d3a565b80840191505092915050565b61340281613cbf565b82525050565b61341181613ce3565b82525050565b61342081613d07565b82525050565b600061343182613c2d565b61343b8185613c54565b935061344b818560208601613d3a565b61345481613d6d565b840191505092915050565b600061346c602683613c54565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006134d2601b83613c54565b91507f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006000830152602082019050919050565b6000613512600883613c54565b91507f216e6f6e7a65726f0000000000000000000000000000000000000000000000006000830152602082019050919050565b6000613552602183613c54565b91507f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f60008301527f77000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006135b8602083613c54565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b60006135f8600883613c54565b91507f216f7665726d61780000000000000000000000000000000000000000000000006000830152602082019050919050565b6000613638601d83613c54565b91507f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006000830152602082019050919050565b6000613678601283613c54565b91507f77697468647261773a206e6f7420676f6f6400000000000000000000000000006000830152602082019050919050565b60006136b8601983613c54565b91507f6e6f6e4475706c6963617465643a206475706c696361746564000000000000006000830152602082019050919050565b60006136f8602a83613c54565b91507f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008301527f6f742073756363656564000000000000000000000000000000000000000000006020830152604082019050919050565b600061375e601f83613c54565b91507f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006000830152602082019050919050565b600061379e603683613c54565b91507f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60008301527f20746f206e6f6e2d7a65726f20616c6c6f77616e6365000000000000000000006020830152604082019050919050565b61380081613cb5565b82525050565b600061381282846133c8565b915081905092915050565b60006020820190506138326000830184613352565b92915050565b600060408201905061384d6000830185613352565b61385a6020830184613352565b9392505050565b60006060820190506138766000830186613352565b6138836020830185613352565b61389060408301846137f7565b949350505050565b60006040820190506138ad6000830185613352565b6138ba60208301846137f7565b9392505050565b600060408201905081810360008301526138dc818587613361565b90506138eb60208301846137f7565b949350505050565b600060208201905061390860008301846133b9565b92915050565b600060c08201905061392360008301896133f9565b61393060208301886137f7565b61393d60408301876137f7565b61394a60608301866137f7565b61395760808301856137f7565b61396460a08301846137f7565b979650505050505050565b60006020820190506139846000830184613408565b92915050565b600060208201905061399f6000830184613417565b92915050565b60006060820190506139ba6000830186613417565b6139c76020830185613352565b6139d460408301846137f7565b949350505050565b600060208201905081810360008301526139f68184613426565b905092915050565b60006020820190508181036000830152613a178161345f565b9050919050565b60006020820190508181036000830152613a37816134c5565b9050919050565b60006020820190508181036000830152613a5781613505565b9050919050565b60006020820190508181036000830152613a7781613545565b9050919050565b60006020820190508181036000830152613a97816135ab565b9050919050565b60006020820190508181036000830152613ab7816135eb565b9050919050565b60006020820190508181036000830152613ad78161362b565b9050919050565b60006020820190508181036000830152613af78161366b565b9050919050565b60006020820190508181036000830152613b17816136ab565b9050919050565b60006020820190508181036000830152613b37816136eb565b9050919050565b60006020820190508181036000830152613b5781613751565b9050919050565b60006020820190508181036000830152613b7781613791565b9050919050565b6000602082019050613b9360008301846137f7565b92915050565b6000604082019050613bae60008301856137f7565b613bbb60208301846133b9565b9392505050565b6000604082019050613bd760008301856137f7565b613be460208301846137f7565b9392505050565b6000606082019050613c0060008301866137f7565b613c0d60208301856137f7565b613c1a60408301846137f7565b949350505050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000613c7082613c95565b9050919050565b60008115159050919050565b6000613c8e82613c65565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000613cca82613cd1565b9050919050565b6000613cdc82613c95565b9050919050565b6000613cee82613cf5565b9050919050565b6000613d0082613c95565b9050919050565b6000613d1282613d19565b9050919050565b6000613d2482613c95565b9050919050565b82818337600083830152505050565b60005b83811015613d58578082015181840152602081019050613d3d565b83811115613d67576000848401525b50505050565b6000601f19601f8301169050919050565b613d8781613c65565b8114613d9257600080fd5b50565b613d9e81613c77565b8114613da957600080fd5b50565b613db581613c83565b8114613dc057600080fd5b50565b613dcc81613cb5565b8114613dd757600080fd5b5056fea2646970667358221220932710ed69544e6007934d139e56789d5c5790d40cf3b64037066138be9e488764736f6c634300060c0033000000000000000000000000bbe3005089f5979d4d90801d202a5335c93a1d4b00000000000000000000000000000000000000000000000000000000012ebfb7000000000000000000000000daf3aa95303698b9e904d8e3854c2997a711fd82000000000000000000000000e0e44d4e7e61f2f4f990f5f4e2408d2187315c94000000000000000000000000e0e44d4e7e61f2f4f990f5f4e2408d2187315c94

000000000000000000000000bbe3005089f5979d4d90801d202a5335c93a1d4b00000000000000000000000000000000000000000000000000000000012ebfb7000000000000000000000000daf3aa95303698b9e904d8e3854c2997a711fd82000000000000000000000000e0e44d4e7e61f2f4f990f5f4e2408d2187315c94000000000000000000000000e0e44d4e7e61f2f4f990f5f4e2408d2187315c94

-----Decoded View---------------
Arg [0] : _star (address): 0xbbe3005089f5979d4d90801d202a5335c93a1d4b
Arg [1] : _startBlock (uint256): 19840951
Arg [2] : _rewardLocker (address): 0xdaf3aa95303698b9e904d8e3854c2997a711fd82
Arg [3] : _devAddress (address): 0xe0e44d4e7e61f2f4f990f5f4e2408d2187315c94
Arg [4] : _starTransferOwner (address): 0xe0e44d4e7e61f2f4f990f5f4e2408d2187315c94

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000bbe3005089f5979d4d90801d202a5335c93a1d4b
Arg [1] : 00000000000000000000000000000000000000000000000000000000012ebfb7
Arg [2] : 000000000000000000000000daf3aa95303698b9e904d8e3854c2997a711fd82
Arg [3] : 000000000000000000000000e0e44d4e7e61f2f4f990f5f4e2408d2187315c94
Arg [4] : 000000000000000000000000e0e44d4e7e61f2f4f990f5f4e2408d2187315c94

41401:14480:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43094:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45333:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54825:272;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47345:764;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43244:26;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;43485:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46756:329;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52454:821;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42856:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50301:613;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42894:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43003:43;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42933:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55190:243;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43138:54;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49228:1021;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43647:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48448:711;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50985:490;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48192:180;;;:::i;:::-;;55656:222;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5726:148;;;:::i;:::-;;5084:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47161:121;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53416:762;;;:::i;:::-;;43326:64;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;45703:957;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45436:44;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54522:217;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52296:101;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6029:244;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43526:48;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43094:37;;;;:::o;45333:95::-;45378:7;45405:8;:15;;;;45398:22;;45333:95;:::o;54825:272::-;5306:12;:10;:12::i;:::-;5296:22;;:6;;;;;;;;;;:22;;;5288:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43182:10:::1;54914:13;:34;;54906:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;54972:17;:15;:17::i;:::-;55015:13;55000:12;:28;;;;55063:10;55044:45;;;55075:13;55044:45;;;;;;:::i;:::-;;;;;;;;54825:272:::0;:::o;47345:764::-;47418:7;47438:21;47462:8;47471:4;47462:14;;;;;;;;;;;;;;;;;;47438:38;;47487:21;47511:8;:14;47520:4;47511:14;;;;;;;;;;;:21;47526:5;47511:21;;;;;;;;;;;;;;;47487:45;;47543:23;47569:4;:20;;;47543:46;;47619:4;:20;;;47604:12;:35;:63;;;;;47666:1;47643:4;:19;;;:24;;47604:63;:87;;;;;47690:1;47671:15;;:20;;47604:87;47600:395;;;47708:18;47729:49;47743:4;:20;;;47765:12;47729:13;:49::i;:::-;47708:70;;47793:18;47814:70;47868:15;;47814:49;47847:4;:15;;;47814:28;47829:12;;47814:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;47793:91;;47917:66;47937:45;47962:4;:19;;;47937:20;47952:4;47937:10;:14;;:20;;;;:::i;:::-;:24;;:45;;;;:::i;:::-;47917:15;:19;;:66;;;;:::i;:::-;47899:84;;47600:395;;;48012:89;48086:4;:14;;;48012:69;48076:4;48012:59;48028:42;48048:4;:21;;;48028:15;:19;;:42;;;;:::i;:::-;48012:4;:11;;;:15;;:59;;;;:::i;:::-;:63;;:69;;;;:::i;:::-;:73;;:89;;;;:::i;:::-;48005:96;;;;;47345:764;;;;:::o;43244:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43485:34::-;;;;:::o;46756:329::-;5306:12;:10;:12::i;:::-;5296:22;;:6;;;;;;;;;;:22;;;5288:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;43568:6:::1;46842:11;:30;;46834:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;46914:63;46965:11;46914:46;46934:8;46943:4;46934:14;;;;;;;;;;;;;;;;;;:25;;;46914:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;46896:15;:81;;;;47016:11;46988:8;46997:4;46988:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;47047:10;47043:34;;;47059:4;47065:11;47043:34;;;;;;;:::i;:::-;;;;;;;;46756:329:::0;;:::o;52454:821::-;24403:1;25009:7;;:19;;25001:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;24403:1;25142:7;:18;;;;52538:15:::1;52573:9:::0;52568:555:::1;52592:5;;:12;;52588:1;:16;52568:555;;;52626:20;52637:5;;52643:1;52637:8;;;;;;;;;;;;;52626:10;:20::i;:::-;52661:21;52685:8;52694:5;;52700:1;52694:8;;;;;;;;;;;;;52685:18;;;;;;;;;;;;;;;;;;52661:42;;52718:21;52742:8;:18;52751:5;;52757:1;52751:8;;;;;;;;;;;;;52742:18;;;;;;;;;;;:30;52761:10;52742:30;;;;;;;;;;;;;;;52718:54;;52806:1;52791:4;:11;;;:16;52787:101;;;52852:4;:20;;;52828:4;:21;;:44;;;;52787:101;52912:107;52924:94;53003:4;:14;;;52924:74;52993:4;52924:64;52940:47;52965:4;:21;;;52940:4;:20;;;:24;;:47;;;;:::i;:::-;52924:4;:11;;;:15;;:64;;;;:::i;:::-;:68;;:74;;;;:::i;:::-;:78;;:94;;;;:::i;:::-;52912:7;:11;;:107;;;;:::i;:::-;52902:117;;53051:1;53034:4;:14;;:18;;;;53091:4;:20;;;53067:4;:21;;:44;;;;52568:555;;52606:3;;;;;;;52568:555;;;;53147:1;53137:7;:11;53133:76;;;53165:32;53177:10;53189:7;53165:11;:32::i;:::-;53133:76;53240:10;53224:43;;;53252:5;;53259:7;53224:43;;;;;;;;:::i;:::-;;;;;;;;25173:1;24359::::0;25321:7;:22;;;;52454:821;;:::o;42856:31::-;;;:::o;50301:613::-;24403:1;25009:7;;:19;;25001:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;24403:1;25142:7;:18;;;;50404:21:::1;50428:8;50437:4;50428:14;;;;;;;;;;;;;;;;;;50404:38;;50453:21;50477:8;:14;50486:4;50477:14;;;;;;;;;;;:26;50492:10;50477:26;;;;;;;;;;;;;;;50453:50;;50537:7;50522:4;:11;;;:22;;50514:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;50578:39;50596:4;50602:14;50578:17;:39::i;:::-;50642:1;50632:7;:11;50628:212;;;50674:24;50690:7;50674:4;:11;;;:15;;:24;;;;:::i;:::-;50660:4;:11;;:38;;;;50735:32;50759:7;50735:4;:19;;;:23;;:32;;;;:::i;:::-;50713:4;:19;;:54;;;;50782:46;50808:10;50820:7;50782:4;:12;;;;;;;;;;;;:25;;;;:46;;;;;:::i;:::-;50628:212;50876:4;50864:10;50855:51;;;50882:7;50891:14;50855:51;;;;;;;:::i;:::-;;;;;;;;25173:1;;24359::::0;25321:7;:22;;;;50301:613;;;:::o;42894:32::-;;;;;;;;;;;;;:::o;43003:43::-;;;:::o;42933:25::-;;;;;;;;;;;;;:::o;55190:243::-;55290:17;;;;;;;;;;;55276:31;;:10;:31;;;55268:40;;;;;;55339:18;55319:17;;:38;;;;;;;;;;;;;;;;;;55406:18;55373:52;;55394:10;55373:52;;;;;;;;;;;;55190:243;:::o;43138:54::-;43182:10;43138:54;:::o;49228:1021::-;24403:1;25009:7;;:19;;25001:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;24403:1;25142:7;:18;;;;49330:21:::1;49354:8;49363:4;49354:14;;;;;;;;;;;;;;;;;;49330:38;;49379:21;49403:8;:14;49412:4;49403:14;;;;;;;;;;;:26;49418:10;49403:26;;;;;;;;;;;;;;;49379:50;;49440:39;49458:4;49464:14;49440:17;:39::i;:::-;49504:1;49494:7;:11;49490:686;;;49522:21;49546:4;:12;;;;;;;;;;;;:22;;;49577:4;49546:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49522:61;;49598:24;49625:28;49637:4;:15;;;49625:7;:11;;:28;;;;:::i;:::-;49598:55;;49668:29;49700;49712:16;49700:7;:11;;:29;;;;:::i;:::-;49668:61;;49744:71;49774:10;49786;;;;;;;;;;;49798:16;49744:4;:12;;;;;;;;;;;;:29;;;;:71;;;;;;:::i;:::-;49830:79;49860:10;49880:4;49887:21;49830:4;:12;;;;;;;;;;;;:29;;;;:79;;;;;;:::i;:::-;49924:20;49947:4;:12;;;;;;;;;;;;:22;;;49978:4;49947:37;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49924:60;;50009:31;50026:13;50009:12;:16;;:31;;;;:::i;:::-;49999:41;;50071:24;50087:7;50071:4;:11;;;:15;;:24;;;;:::i;:::-;50057:4;:11;;:38;;;;50132:32;50156:7;50132:4;:19;;;:23;;:32;;;;:::i;:::-;50110:4;:19;;:54;;;;49490:686;;;;;50211:4;50199:10;50191:50;;;50217:7;50226:14;50191:50;;;;;;;:::i;:::-;;;;;;;;25173:1;;24359::::0;25321:7;:22;;;;49228:1021;;;:::o;43647:35::-;;;:::o;48448:711::-;48500:21;48524:8;48533:4;48524:14;;;;;;;;;;;;;;;;;;48500:38;;48569:4;:20;;;48553:12;:36;48549:75;;48606:7;;;48549:75;48661:1;48638:4;:19;;;:24;:48;;;;48685:1;48666:4;:15;;;:20;48638:48;48634:137;;;48726:12;48703:4;:20;;:35;;;;48753:7;;;48634:137;48781:18;48802:49;48816:4;:20;;;48838:12;48802:13;:49::i;:::-;48781:70;;48862:18;48883:70;48937:15;;48883:49;48916:4;:15;;;48883:28;48898:12;;48883:10;:14;;:28;;;;:::i;:::-;:32;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;48862:91;;48964:4;:9;;;48982:4;48989:10;48964:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49034:71;49059:45;49084:4;:19;;;49059:20;49074:4;49059:10;:14;;:20;;;;:::i;:::-;:24;;:45;;;;:::i;:::-;49034:4;:20;;;:24;;:71;;;;:::i;:::-;49011:4;:20;;:94;;;;49139:12;49116:4;:20;;:35;;;;48448:711;;;;;:::o;50985:490::-;24403:1;25009:7;;:19;;25001:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;24403:1;25142:7;:18;;;;51059:21:::1;51083:8;51092:4;51083:14;;;;;;;;;;;;;;;;;;51059:38;;51108:21;51132:8;:14;51141:4;51132:14;;;;;;;;;;;:26;51147:10;51132:26;;;;;;;;;;;;;;;51108:50;;51169:14;51186:4;:11;;;51169:28;;51222:1;51208:4;:11;;:15;;;;51258:1;51234:4;:21;;:25;;;;51287:1;51270:4;:14;;:18;;;;51321:31;51345:6;51321:4;:19;;;:23;;:31;;;;:::i;:::-;51299:4;:19;;:53;;;;51363:45;51389:10;51401:6;51363:4;:12;;;;;;;;;;;;:25;;;;:45;;;;;:::i;:::-;51454:4;51442:10;51424:43;;;51460:6;51424:43;;;;;;:::i;:::-;;;;;;;;25173:1;;;24359::::0;25321:7;:22;;;;50985:490;:::o;48192:180::-;48237:14;48254:8;:15;;;;48237:32;;48285:11;48280:85;48308:6;48302:3;:12;48280:85;;;48338:15;48349:3;48338:10;:15::i;:::-;48316:5;;;;;48280:85;;;;48192:180;:::o;55656:222::-;55748:17;;;;;;;;;;;55734:31;;:10;:31;;;55726:40;;;;;;55777:4;:22;;;55800:9;55777:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55860:9;55826:44;;55848:10;55826:44;;;;;;;;;;;;55656:222;:::o;5726:148::-;5306:12;:10;:12::i;:::-;5296:22;;:6;;;;;;;;;;:22;;;5288:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;5833:1:::1;5796:40;;5817:6;::::0;::::1;;;;;;;;5796:40;;;;;;;;;;;;5864:1;5847:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;5726:148::o:0;5084:79::-;5122:7;5149:6;;;;;;;;;;;5142:13;;5084:79;:::o;47161:121::-;47233:7;47260:14;47268:5;47260:3;:7;;:14;;;;:::i;:::-;47253:21;;47161:121;;;;:::o;53416:762::-;24403:1;25009:7;;:19;;25001:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;24403:1;25142:7;:18;;;;53471:17:::1;:15;:17::i;:::-;53499:15;53534:9:::0;53529:509:::1;53553:8;:15;;;;53549:1;:19;53529:509;;;53590:21;53614:8;53623:1;53614:11;;;;;;;;;;;;;;;;;;53590:35;;53640:21;53664:8;:11;53673:1;53664:11;;;;;;;;;;;:23;53676:10;53664:23;;;;;;;;;;;;;;;53640:47;;53721:1;53706:4;:11;;;:16;53702:101;;;53767:4;:20;;;53743:4;:21;;:44;;;;53702:101;53827:107;53839:94;53918:4;:14;;;53839:74;53908:4;53839:64;53855:47;53880:4;:21;;;53855:4;:20;;;:24;;:47;;;;:::i;:::-;53839:4;:11;;;:15;;:64;;;;:::i;:::-;:68;;:74;;;;:::i;:::-;:78;;:94;;;;:::i;:::-;53827:7;:11;;:107;;;;:::i;:::-;53817:117;;53966:1;53949:4;:14;;:18;;;;54006:4;:20;;;53982:4;:21;;:44;;;;53529:509;;53570:3;;;;;;;53529:509;;;;54062:1;54052:7;:11;54048:76;;;54080:32;54092:10;54104:7;54080:11;:32::i;:::-;54048:76;54150:10;54139:31;;;54162:7;54139:31;;;;;;:::i;:::-;;;;;;;;25173:1;24359::::0;25321:7;:22;;;;53416:762::o;43326:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45703:957::-;5306:12;:10;:12::i;:::-;5296:22;;:6;;;;;;;;;;:22;;;5288:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;45831:8:::1;45573:5;45546:32;;:13;:23;45560:8;45546:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;45538:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;43568:6:::2;45860:11;:30;;45852:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;45918:16;45914:129;;;45951:17;:15;:17::i;:::-;45914:129;46053:8;:18;;;46080:4;46053:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46132:23;46173:10;46158:12;:25;:53;;46201:10;46158:53;;;46186:12;46158:53;46132:79;;46240:32;46260:11;46240:15;;:19;;:32;;;;:::i;:::-;46222:15;:50;;;;46309:4;46283:13;:23;46297:8;46283:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;46324:8;46338:241;;;;;;;;46371:8;46338:241;;;;;;46438:11;46338:241;;;;46410:1;46338:241;;;;46481:15;46338:241;;;;46528:1;46338:241;;;;46556:11;46338:241;;::::0;46324:256:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46625:8;46596:56;;46600:10;46596:56;;;46612:11;46635:16;46596:56;;;;;;;:::i;:::-;;;;;;;;45619:1;5366::::1;45703:957:::0;;;;:::o;45436:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;54522:217::-;5306:12;:10;:12::i;:::-;5296:22;;:6;;;;;;;;;;:22;;;5288:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;54627:1:::1;54604:25;;:11;:25;;;;54596:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;54666:11;54653:10;;:24;;;;;;;;;;;;;;;;;;54719:11;54693:38;;54707:10;54693:38;;;;;;;;;;;;54522:217:::0;:::o;52296:101::-;24403:1;25009:7;;:19;;25001:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;24403:1;25142:7;:18;;;;52360:29:::1;52378:4;52384;52360:17;:29::i;:::-;24359:1:::0;25321:7;:22;;;;52296:101;:::o;6029:244::-;5306:12;:10;:12::i;:::-;5296:22;;:6;;;;;;;;;;:22;;;5288:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;6138:1:::1;6118:22;;:8;:22;;;;6110:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;6228:8;6199:38;;6220:6;::::0;::::1;;;;;;;;6199:38;;;;;;;;;;;;6257:8;6248:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;6029:244:::0;:::o;43526:48::-;43568:6;43526:48;:::o;33041:622::-;33420:1;33411:5;:10;33410:62;;;;33470:1;33427:5;:15;;;33451:4;33458:7;33427:39;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;33410:62;33402:152;;;;;;;;;;;;:::i;:::-;;;;;;;;;33565:90;33585:5;33615:22;;;33639:7;33648:5;33592:62;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33565:19;:90::i;:::-;33041:622;;;:::o;33671:286::-;33768:20;33791:50;33835:5;33791;:15;;;33815:4;33822:7;33791:39;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:43;;:50;;;;:::i;:::-;33768:73;;33852:97;33872:5;33902:22;;;33926:7;33935:12;33879:69;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33852:19;:97::i;:::-;33671:286;;;;:::o;36441:181::-;36499:7;36519:9;36535:1;36531;:5;36519:17;;36560:1;36555;:6;;36547:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;36613:1;36606:8;;;36441:181;;;;:::o;29300:196::-;29403:12;29435:53;29458:6;29466:4;29472:1;29475:12;29435:22;:53::i;:::-;29428:60;;29300:196;;;;;:::o;3575:106::-;3628:15;3663:10;3656:17;;3575:106;:::o;37795:471::-;37853:7;38103:1;38098;:6;38094:47;;;38128:1;38121:8;;;;38094:47;38153:9;38169:1;38165;:5;38153:17;;38198:1;38193;38189;:5;;;;;;:10;38181:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;38257:1;38250:8;;;37795:471;;;;;:::o;38742:132::-;38800:7;38827:39;38831:1;38834;38827:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;38820:46;;38742:132;;;;:::o;36905:136::-;36963:7;36990:43;36994:1;36997;36990:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;36983:50;;36905:136;;;;:::o;54252:214::-;54328:15;54346:4;:14;;;54369:4;54346:29;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54328:47;;54386:12;:17;;;54404:4;54410:8;54430:7;54420;:17;:37;;54450:7;54420:37;;;54440:7;54420:37;54386:72;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54252:214;;;:::o;51548:711::-;51630:21;51654:8;51663:4;51654:14;;;;;;;;;;;;;;;;;;51630:38;;51679:21;51703:8;:14;51712:4;51703:14;;;;;;;;;;;:26;51718:10;51703:26;;;;;;;;;;;;;;;51679:50;;51740:16;51751:4;51740:10;:16::i;:::-;51786:1;51771:4;:11;;;:16;51767:93;;;51828:4;:20;;;51804:4;:21;;:44;;;;51767:93;51870:15;51888:94;51967:4;:14;;;51888:74;51957:4;51888:64;51904:47;51929:4;:21;;;51904:4;:20;;;:24;;:47;;;;:::i;:::-;51888:4;:11;;;:15;;:64;;;;:::i;:::-;:68;;:74;;;;:::i;:::-;:78;;:94;;;;:::i;:::-;51870:112;;52010:14;:28;;52031:7;52010:28;;;52027:1;52010:28;51993:4;:14;;:45;;;;52053:14;:29;;;;;52081:1;52071:7;:11;52053:29;52049:148;;;52099:32;52111:10;52123:7;52099:11;:32::i;:::-;52171:4;52159:10;52151:34;;;52177:7;52151:34;;;;;;:::i;:::-;;;;;;;;52049:148;52231:4;:20;;;52207:4;:21;;:44;;;;51548:711;;;;;:::o;32382:177::-;32465:86;32485:5;32515:23;;;32540:2;32544:5;32492:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32465:19;:86::i;:::-;32382:177;;;:::o;32567:205::-;32668:96;32688:5;32718:27;;;32747:4;32753:2;32757:5;32695:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32668:19;:96::i;:::-;32567:205;;;;:::o;34687:761::-;35111:23;35137:69;35165:4;35137:69;;;;;;;;;;;;;;;;;35145:5;35137:27;;;;:69;;;;;:::i;:::-;35111:95;;35241:1;35221:10;:17;:21;35217:224;;;35363:10;35352:30;;;;;;;;;;;;:::i;:::-;35344:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;35217:224;34687:761;;;:::o;30677:979::-;30807:12;30840:18;30851:6;30840:10;:18::i;:::-;30832:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;30966:12;30980:23;31007:6;:11;;31027:8;31038:4;31007:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30965:78;;;;31058:7;31054:595;;;31089:10;31082:17;;;;;;31054:595;31223:1;31203:10;:17;:21;31199:439;;;31466:10;31460:17;31527:15;31514:10;31510:2;31506:19;31499:44;31414:148;31609:12;31602:20;;;;;;;;;;;:::i;:::-;;;;;;;;30677:979;;;;;;;:::o;39370:278::-;39456:7;39488:1;39484;:5;39491:12;39476:28;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;39515:9;39531:1;39527;:5;;;;;;39515:17;;39639:1;39632:8;;;39370:278;;;;;:::o;37344:192::-;37430:7;37463:1;37458;:6;;37466:12;37450:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;37490:9;37506:1;37502;:5;37490:17;;37527:1;37520:8;;;37344:192;;;;;:::o;26185:619::-;26245:4;26507:16;26534:19;26556:66;26534:88;;;;26725:7;26713:20;26701:32;;26765:11;26753:8;:23;;:42;;;;;26792:3;26780:15;;:8;:15;;26753:42;26745:51;;;;26185:619;;;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;:::i;:::-;57:78;;;;:::o;160:352::-;;;290:3;283:4;275:6;271:17;267:27;257:2;;308:1;305;298:12;257:2;341:6;328:20;318:30;;368:18;360:6;357:30;354:2;;;400:1;397;390:12;354:2;434:4;426:6;422:17;410:29;;485:3;477:4;469:6;465:17;455:8;451:32;448:41;445:2;;;502:1;499;492:12;445:2;250:262;;;;;:::o;520:124::-;;597:6;584:20;575:29;;609:30;633:5;609:30;:::i;:::-;569:75;;;;:::o;651:128::-;;732:6;726:13;717:22;;744:30;768:5;744:30;:::i;:::-;711:68;;;;:::o;786:158::-;;880:6;867:20;858:29;;892:47;933:5;892:47;:::i;:::-;852:92;;;;:::o;951:130::-;;1031:6;1018:20;1009:29;;1043:33;1070:5;1043:33;:::i;:::-;1003:78;;;;:::o;1088:134::-;;1172:6;1166:13;1157:22;;1184:33;1211:5;1184:33;:::i;:::-;1151:71;;;;:::o;1229:241::-;;1333:2;1321:9;1312:7;1308:23;1304:32;1301:2;;;1349:1;1346;1339:12;1301:2;1384:1;1401:53;1446:7;1437:6;1426:9;1422:22;1401:53;:::i;:::-;1391:63;;1363:97;1295:175;;;;:::o;1477:397::-;;;1616:2;1604:9;1595:7;1591:23;1587:32;1584:2;;;1632:1;1629;1622:12;1584:2;1695:1;1684:9;1680:17;1667:31;1718:18;1710:6;1707:30;1704:2;;;1750:1;1747;1740:12;1704:2;1778:80;1850:7;1841:6;1830:9;1826:22;1778:80;:::i;:::-;1760:98;;;;1646:218;1578:296;;;;;:::o;1881:257::-;;1993:2;1981:9;1972:7;1968:23;1964:32;1961:2;;;2009:1;2006;1999:12;1961:2;2044:1;2061:61;2114:7;2105:6;2094:9;2090:22;2061:61;:::i;:::-;2051:71;;2023:105;1955:183;;;;:::o;2145:269::-;;2263:2;2251:9;2242:7;2238:23;2234:32;2231:2;;;2279:1;2276;2269:12;2231:2;2314:1;2331:67;2390:7;2381:6;2370:9;2366:22;2331:67;:::i;:::-;2321:77;;2293:111;2225:189;;;;:::o;2421:241::-;;2525:2;2513:9;2504:7;2500:23;2496:32;2493:2;;;2541:1;2538;2531:12;2493:2;2576:1;2593:53;2638:7;2629:6;2618:9;2614:22;2593:53;:::i;:::-;2583:63;;2555:97;2487:175;;;;:::o;2669:263::-;;2784:2;2772:9;2763:7;2759:23;2755:32;2752:2;;;2800:1;2797;2790:12;2752:2;2835:1;2852:64;2908:7;2899:6;2888:9;2884:22;2852:64;:::i;:::-;2842:74;;2814:108;2746:186;;;;:::o;2939:366::-;;;3060:2;3048:9;3039:7;3035:23;3031:32;3028:2;;;3076:1;3073;3066:12;3028:2;3111:1;3128:53;3173:7;3164:6;3153:9;3149:22;3128:53;:::i;:::-;3118:63;;3090:97;3218:2;3236:53;3281:7;3272:6;3261:9;3257:22;3236:53;:::i;:::-;3226:63;;3197:98;3022:283;;;;;:::o;3312:639::-;;;;;3478:3;3466:9;3457:7;3453:23;3449:33;3446:2;;;3495:1;3492;3485:12;3446:2;3530:1;3547:53;3592:7;3583:6;3572:9;3568:22;3547:53;:::i;:::-;3537:63;;3509:97;3637:2;3655:67;3714:7;3705:6;3694:9;3690:22;3655:67;:::i;:::-;3645:77;;3616:112;3759:2;3777:50;3819:7;3810:6;3799:9;3795:22;3777:50;:::i;:::-;3767:60;;3738:95;3864:2;3882:53;3927:7;3918:6;3907:9;3903:22;3882:53;:::i;:::-;3872:63;;3843:98;3440:511;;;;;;;:::o;3958:366::-;;;4079:2;4067:9;4058:7;4054:23;4050:32;4047:2;;;4095:1;4092;4085:12;4047:2;4130:1;4147:53;4192:7;4183:6;4172:9;4168:22;4147:53;:::i;:::-;4137:63;;4109:97;4237:2;4255:53;4300:7;4291:6;4280:9;4276:22;4255:53;:::i;:::-;4245:63;;4216:98;4041:283;;;;;:::o;4331:485::-;;;;4466:2;4454:9;4445:7;4441:23;4437:32;4434:2;;;4482:1;4479;4472:12;4434:2;4517:1;4534:53;4579:7;4570:6;4559:9;4555:22;4534:53;:::i;:::-;4524:63;;4496:97;4624:2;4642:53;4687:7;4678:6;4667:9;4663:22;4642:53;:::i;:::-;4632:63;;4603:98;4732:2;4750:50;4792:7;4783:6;4772:9;4768:22;4750:50;:::i;:::-;4740:60;;4711:95;4428:388;;;;;:::o;4823:113::-;4906:24;4924:5;4906:24;:::i;:::-;4901:3;4894:37;4888:48;;:::o;4974:467::-;;5120:86;5199:6;5194:3;5120:86;:::i;:::-;5113:93;;5233:66;5225:6;5222:78;5219:2;;;5313:1;5310;5303:12;5219:2;5346:4;5338:6;5334:17;5324:27;;5363:43;5399:6;5394:3;5387:5;5363:43;:::i;:::-;5428:6;5423:3;5419:16;5412:23;;5106:335;;;;;:::o;5449:104::-;5526:21;5541:5;5526:21;:::i;:::-;5521:3;5514:34;5508:45;;:::o;5560:356::-;;5688:38;5720:5;5688:38;:::i;:::-;5738:88;5819:6;5814:3;5738:88;:::i;:::-;5731:95;;5831:52;5876:6;5871:3;5864:4;5857:5;5853:16;5831:52;:::i;:::-;5904:6;5899:3;5895:16;5888:23;;5668:248;;;;;:::o;5923:154::-;6020:51;6065:5;6020:51;:::i;:::-;6015:3;6008:64;6002:75;;:::o;6084:168::-;6188:58;6240:5;6188:58;:::i;:::-;6183:3;6176:71;6170:82;;:::o;6259:162::-;6360:55;6409:5;6360:55;:::i;:::-;6355:3;6348:68;6342:79;;:::o;6428:347::-;;6540:39;6573:5;6540:39;:::i;:::-;6591:71;6655:6;6650:3;6591:71;:::i;:::-;6584:78;;6667:52;6712:6;6707:3;6700:4;6693:5;6689:16;6667:52;:::i;:::-;6740:29;6762:6;6740:29;:::i;:::-;6735:3;6731:39;6724:46;;6520:255;;;;;:::o;6783:375::-;;6943:67;7007:2;7002:3;6943:67;:::i;:::-;6936:74;;7043:34;7039:1;7034:3;7030:11;7023:55;7112:8;7107:2;7102:3;7098:12;7091:30;7149:2;7144:3;7140:12;7133:19;;6929:229;;;:::o;7167:327::-;;7327:67;7391:2;7386:3;7327:67;:::i;:::-;7320:74;;7427:29;7423:1;7418:3;7414:11;7407:50;7485:2;7480:3;7476:12;7469:19;;7313:181;;;:::o;7503:307::-;;7663:66;7727:1;7722:3;7663:66;:::i;:::-;7656:73;;7762:10;7758:1;7753:3;7749:11;7742:31;7801:2;7796:3;7792:12;7785:19;;7649:161;;;:::o;7819:370::-;;7979:67;8043:2;8038:3;7979:67;:::i;:::-;7972:74;;8079:34;8075:1;8070:3;8066:11;8059:55;8148:3;8143:2;8138:3;8134:12;8127:25;8180:2;8175:3;8171:12;8164:19;;7965:224;;;:::o;8198:332::-;;8358:67;8422:2;8417:3;8358:67;:::i;:::-;8351:74;;8458:34;8454:1;8449:3;8445:11;8438:55;8521:2;8516:3;8512:12;8505:19;;8344:186;;;:::o;8539:307::-;;8699:66;8763:1;8758:3;8699:66;:::i;:::-;8692:73;;8798:10;8794:1;8789:3;8785:11;8778:31;8837:2;8832:3;8828:12;8821:19;;8685:161;;;:::o;8855:329::-;;9015:67;9079:2;9074:3;9015:67;:::i;:::-;9008:74;;9115:31;9111:1;9106:3;9102:11;9095:52;9175:2;9170:3;9166:12;9159:19;;9001:183;;;:::o;9193:318::-;;9353:67;9417:2;9412:3;9353:67;:::i;:::-;9346:74;;9453:20;9449:1;9444:3;9440:11;9433:41;9502:2;9497:3;9493:12;9486:19;;9339:172;;;:::o;9520:325::-;;9680:67;9744:2;9739:3;9680:67;:::i;:::-;9673:74;;9780:27;9776:1;9771:3;9767:11;9760:48;9836:2;9831:3;9827:12;9820:19;;9666:179;;;:::o;9854:379::-;;10014:67;10078:2;10073:3;10014:67;:::i;:::-;10007:74;;10114:34;10110:1;10105:3;10101:11;10094:55;10183:12;10178:2;10173:3;10169:12;10162:34;10224:2;10219:3;10215:12;10208:19;;10000:233;;;:::o;10242:331::-;;10402:67;10466:2;10461:3;10402:67;:::i;:::-;10395:74;;10502:33;10498:1;10493:3;10489:11;10482:54;10564:2;10559:3;10555:12;10548:19;;10388:185;;;:::o;10582:391::-;;10742:67;10806:2;10801:3;10742:67;:::i;:::-;10735:74;;10842:34;10838:1;10833:3;10829:11;10822:55;10911:24;10906:2;10901:3;10897:12;10890:46;10964:2;10959:3;10955:12;10948:19;;10728:245;;;:::o;10981:113::-;11064:24;11082:5;11064:24;:::i;:::-;11059:3;11052:37;11046:48;;:::o;11101:271::-;;11254:93;11343:3;11334:6;11254:93;:::i;:::-;11247:100;;11364:3;11357:10;;11235:137;;;;:::o;11379:222::-;;11506:2;11495:9;11491:18;11483:26;;11520:71;11588:1;11577:9;11573:17;11564:6;11520:71;:::i;:::-;11477:124;;;;:::o;11608:333::-;;11763:2;11752:9;11748:18;11740:26;;11777:71;11845:1;11834:9;11830:17;11821:6;11777:71;:::i;:::-;11859:72;11927:2;11916:9;11912:18;11903:6;11859:72;:::i;:::-;11734:207;;;;;:::o;11948:444::-;;12131:2;12120:9;12116:18;12108:26;;12145:71;12213:1;12202:9;12198:17;12189:6;12145:71;:::i;:::-;12227:72;12295:2;12284:9;12280:18;12271:6;12227:72;:::i;:::-;12310;12378:2;12367:9;12363:18;12354:6;12310:72;:::i;:::-;12102:290;;;;;;:::o;12399:333::-;;12554:2;12543:9;12539:18;12531:26;;12568:71;12636:1;12625:9;12621:17;12612:6;12568:71;:::i;:::-;12650:72;12718:2;12707:9;12703:18;12694:6;12650:72;:::i;:::-;12525:207;;;;;:::o;12739:501::-;;12954:2;12943:9;12939:18;12931:26;;13004:9;12998:4;12994:20;12990:1;12979:9;12975:17;12968:47;13029:118;13142:4;13133:6;13125;13029:118;:::i;:::-;13021:126;;13158:72;13226:2;13215:9;13211:18;13202:6;13158:72;:::i;:::-;12925:315;;;;;;:::o;13247:210::-;;13368:2;13357:9;13353:18;13345:26;;13382:65;13444:1;13433:9;13429:17;13420:6;13382:65;:::i;:::-;13339:118;;;;:::o;13464:808::-;;13745:3;13734:9;13730:19;13722:27;;13760:85;13842:1;13831:9;13827:17;13818:6;13760:85;:::i;:::-;13856:72;13924:2;13913:9;13909:18;13900:6;13856:72;:::i;:::-;13939;14007:2;13996:9;13992:18;13983:6;13939:72;:::i;:::-;14022;14090:2;14079:9;14075:18;14066:6;14022:72;:::i;:::-;14105:73;14173:3;14162:9;14158:19;14149:6;14105:73;:::i;:::-;14189;14257:3;14246:9;14242:19;14233:6;14189:73;:::i;:::-;13716:556;;;;;;;;;:::o;14279:264::-;;14427:2;14416:9;14412:18;14404:26;;14441:92;14530:1;14519:9;14515:17;14506:6;14441:92;:::i;:::-;14398:145;;;;:::o;14550:258::-;;14695:2;14684:9;14680:18;14672:26;;14709:89;14795:1;14784:9;14780:17;14771:6;14709:89;:::i;:::-;14666:142;;;;:::o;14815:480::-;;15016:2;15005:9;15001:18;14993:26;;15030:89;15116:1;15105:9;15101:17;15092:6;15030:89;:::i;:::-;15130:72;15198:2;15187:9;15183:18;15174:6;15130:72;:::i;:::-;15213;15281:2;15270:9;15266:18;15257:6;15213:72;:::i;:::-;14987:308;;;;;;:::o;15302:310::-;;15449:2;15438:9;15434:18;15426:26;;15499:9;15493:4;15489:20;15485:1;15474:9;15470:17;15463:47;15524:78;15597:4;15588:6;15524:78;:::i;:::-;15516:86;;15420:192;;;;:::o;15619:416::-;;15819:2;15808:9;15804:18;15796:26;;15869:9;15863:4;15859:20;15855:1;15844:9;15840:17;15833:47;15894:131;16020:4;15894:131;:::i;:::-;15886:139;;15790:245;;;:::o;16042:416::-;;16242:2;16231:9;16227:18;16219:26;;16292:9;16286:4;16282:20;16278:1;16267:9;16263:17;16256:47;16317:131;16443:4;16317:131;:::i;:::-;16309:139;;16213:245;;;:::o;16465:416::-;;16665:2;16654:9;16650:18;16642:26;;16715:9;16709:4;16705:20;16701:1;16690:9;16686:17;16679:47;16740:131;16866:4;16740:131;:::i;:::-;16732:139;;16636:245;;;:::o;16888:416::-;;17088:2;17077:9;17073:18;17065:26;;17138:9;17132:4;17128:20;17124:1;17113:9;17109:17;17102:47;17163:131;17289:4;17163:131;:::i;:::-;17155:139;;17059:245;;;:::o;17311:416::-;;17511:2;17500:9;17496:18;17488:26;;17561:9;17555:4;17551:20;17547:1;17536:9;17532:17;17525:47;17586:131;17712:4;17586:131;:::i;:::-;17578:139;;17482:245;;;:::o;17734:416::-;;17934:2;17923:9;17919:18;17911:26;;17984:9;17978:4;17974:20;17970:1;17959:9;17955:17;17948:47;18009:131;18135:4;18009:131;:::i;:::-;18001:139;;17905:245;;;:::o;18157:416::-;;18357:2;18346:9;18342:18;18334:26;;18407:9;18401:4;18397:20;18393:1;18382:9;18378:17;18371:47;18432:131;18558:4;18432:131;:::i;:::-;18424:139;;18328:245;;;:::o;18580:416::-;;18780:2;18769:9;18765:18;18757:26;;18830:9;18824:4;18820:20;18816:1;18805:9;18801:17;18794:47;18855:131;18981:4;18855:131;:::i;:::-;18847:139;;18751:245;;;:::o;19003:416::-;;19203:2;19192:9;19188:18;19180:26;;19253:9;19247:4;19243:20;19239:1;19228:9;19224:17;19217:47;19278:131;19404:4;19278:131;:::i;:::-;19270:139;;19174:245;;;:::o;19426:416::-;;19626:2;19615:9;19611:18;19603:26;;19676:9;19670:4;19666:20;19662:1;19651:9;19647:17;19640:47;19701:131;19827:4;19701:131;:::i;:::-;19693:139;;19597:245;;;:::o;19849:416::-;;20049:2;20038:9;20034:18;20026:26;;20099:9;20093:4;20089:20;20085:1;20074:9;20070:17;20063:47;20124:131;20250:4;20124:131;:::i;:::-;20116:139;;20020:245;;;:::o;20272:416::-;;20472:2;20461:9;20457:18;20449:26;;20522:9;20516:4;20512:20;20508:1;20497:9;20493:17;20486:47;20547:131;20673:4;20547:131;:::i;:::-;20539:139;;20443:245;;;:::o;20695:222::-;;20822:2;20811:9;20807:18;20799:26;;20836:71;20904:1;20893:9;20889:17;20880:6;20836:71;:::i;:::-;20793:124;;;;:::o;20924:321::-;;21073:2;21062:9;21058:18;21050:26;;21087:71;21155:1;21144:9;21140:17;21131:6;21087:71;:::i;:::-;21169:66;21231:2;21220:9;21216:18;21207:6;21169:66;:::i;:::-;21044:201;;;;;:::o;21252:333::-;;21407:2;21396:9;21392:18;21384:26;;21421:71;21489:1;21478:9;21474:17;21465:6;21421:71;:::i;:::-;21503:72;21571:2;21560:9;21556:18;21547:6;21503:72;:::i;:::-;21378:207;;;;;:::o;21592:444::-;;21775:2;21764:9;21760:18;21752:26;;21789:71;21857:1;21846:9;21842:17;21833:6;21789:71;:::i;:::-;21871:72;21939:2;21928:9;21924:18;21915:6;21871:72;:::i;:::-;21954;22022:2;22011:9;22007:18;21998:6;21954:72;:::i;:::-;21746:290;;;;;;:::o;22043:121::-;;22136:5;22130:12;22120:22;;22101:63;;;:::o;22171:122::-;;22265:5;22259:12;22249:22;;22230:63;;;:::o;22301:178::-;;22431:6;22426:3;22419:19;22468:4;22463:3;22459:14;22444:29;;22412:67;;;;:::o;22488:144::-;;22623:3;22608:18;;22601:31;;;;:::o;22641:163::-;;22756:6;22751:3;22744:19;22793:4;22788:3;22784:14;22769:29;;22737:67;;;;:::o;22812:91::-;;22874:24;22892:5;22874:24;:::i;:::-;22863:35;;22857:46;;;:::o;22910:85::-;;22983:5;22976:13;22969:21;22958:32;;22952:43;;;:::o;23002:105::-;;23078:24;23096:5;23078:24;:::i;:::-;23067:35;;23061:46;;;:::o;23114:121::-;;23187:42;23180:5;23176:54;23165:65;;23159:76;;;:::o;23242:72::-;;23304:5;23293:16;;23287:27;;;:::o;23321:149::-;;23414:51;23459:5;23414:51;:::i;:::-;23401:64;;23395:75;;;:::o;23477:122::-;;23570:24;23588:5;23570:24;:::i;:::-;23557:37;;23551:48;;;:::o;23606:163::-;;23706:58;23758:5;23706:58;:::i;:::-;23693:71;;23687:82;;;:::o;23776:129::-;;23876:24;23894:5;23876:24;:::i;:::-;23863:37;;23857:48;;;:::o;23912:157::-;;24009:55;24058:5;24009:55;:::i;:::-;23996:68;;23990:79;;;:::o;24076:126::-;;24173:24;24191:5;24173:24;:::i;:::-;24160:37;;24154:48;;;:::o;24210:145::-;24291:6;24286:3;24281;24268:30;24347:1;24338:6;24333:3;24329:16;24322:27;24261:94;;;:::o;24364:268::-;24429:1;24436:101;24450:6;24447:1;24444:13;24436:101;;;24526:1;24521:3;24517:11;24511:18;24507:1;24502:3;24498:11;24491:39;24472:2;24469:1;24465:10;24460:15;;24436:101;;;24552:6;24549:1;24546:13;24543:2;;;24617:1;24608:6;24603:3;24599:16;24592:27;24543:2;24413:219;;;;:::o;24640:97::-;;24728:2;24724:7;24719:2;24712:5;24708:14;24704:28;24694:38;;24688:49;;;:::o;24745:117::-;24814:24;24832:5;24814:24;:::i;:::-;24807:5;24804:35;24794:2;;24853:1;24850;24843:12;24794:2;24788:74;:::o;24869:111::-;24935:21;24950:5;24935:21;:::i;:::-;24928:5;24925:32;24915:2;;24971:1;24968;24961:12;24915:2;24909:71;:::o;24987:145::-;25070:38;25102:5;25070:38;:::i;:::-;25063:5;25060:49;25050:2;;25123:1;25120;25113:12;25050:2;25044:88;:::o;25139:117::-;25208:24;25226:5;25208:24;:::i;:::-;25201:5;25198:35;25188:2;;25247:1;25244;25237:12;25188:2;25182:74;:::o

ipfs://932710ed69544e6007934d139e56789d5c5790d40cf3b64037066138be9e4887