Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•  contract IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
•  contract IERC721Enumerable is IERC ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
•  contract IERC721Receiver
•    - function onERC721Received(address ope ...
• library Address
•    - function isContract(address account)
•    - function toPayable(address account)
•    - function sendValue(address payable re ...
• library Counters
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
•  contract ERC165 is IERC165
•    - function supportsInterface(bytes4 int ...
•    - function _registerInterface(bytes4 in ...
•  contract ERC721 is Context, ERC165 ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address to ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _safeTransferFrom(address fr ...
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(address owner, uint256 ...
•    - function _burn(uint256 tokenId)
•    - function _transferFrom(address from, ...
•    - function _checkOnERC721Received(addre ...
•    - function _clearApproval(uint256 token ...
•  contract ERC721Enumerable is Conte ...
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function _transferFrom(address from, ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(address owner, uint256 ...
•    - function _tokensOfOwner(address owner ...
•    - function _addTokenToOwnerEnumeration( ...
•    - function _addTokenToAllTokensEnumerat ...
•    - function _removeTokenFromOwnerEnumera ...
•    - function _removeTokenFromAllTokensEnu ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function mint(address account, uint a ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
•  contract Governance
•    - function setGovernance(address govern ...
• interface IPool
•    - function totalSupply( )
•    - function balanceOf( address player )
• interface IPlayerBook
•    - function settleReward( address from,u ...
•    - function bindRefer( address from,stri ...
•    - function hasRefer(address from)
• interface IGegoFactory
•    - function getGego(uint256 tokenId)
•    - function getQualityBase()
•  contract IGegoToken is IERC721
•    - function mint(address to, uint256 tok ...
•    - function burn(uint256 tokenId)
•  contract NFTReward is IPool,Govern ... *
•    - function setMaxStakedDego(uint256 amo ...
•    - function seize(IERC20 token, uint256 ...
•    - function seizeErc721(IERC721 token, u ...
•    - function lastTimeRewardApplicable()
•    - function rewardPerToken()
•    - function earned(address account)
•    - function getFixRate(uint256 grade,uin ...
•    - function getStakeInfo( uint256 gegoId ...
•    - function stakeGego(uint256 gegoId, st ...
•    - function onERC721Received(address ope ...
•    - function withdrawGego(uint256 gegoId)
•    - function withdraw()
•    - function getPlayerIds( address accoun ...
•    - function exit()
•    - function getReward()
•    - function startNFTReward(uint256 start ...
•    - function notifyMintAmount(uint256 rew ...
•    - function setTeamRewardRate( uint256 t ...
•    - function setPoolRewardRate( uint256 ...
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function setWithDrawPunishTime( uint2 ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-09-29
*/

/***
 *    ██████╗ ███████╗ ██████╗  ██████╗ 
 *    ██╔══██╗██╔════╝██╔════╝ ██╔═══██╗
 *    ██║  ██║█████╗  ██║  ███╗██║   ██║
 *    ██║  ██║██╔══╝  ██║   ██║██║   ██║
 *    ██████╔╝███████╗╚██████╔╝╚██████╔╝
 *    ╚═════╝ ╚══════╝ ╚═════╝  ╚═════╝ 
 *    
 * https://dego.finance
                                  
* MIT License
* ===========
*
* Copyright (c) 2020 dego
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*/
// File: @openzeppelin/contracts/math/Math.sol

pragma solidity ^0.5.0;

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

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

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

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.5.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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity ^0.5.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.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

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

// File: @openzeppelin/contracts/ownership/Ownable.sol

pragma solidity ^0.5.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.
 *
 * 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(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: @openzeppelin/contracts/introspection/IERC165.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol

pragma solidity ^0.5.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of NFTs in `owner`'s account.
     */
    function balanceOf(address owner) public view returns (uint256 balance);

    /**
     * @dev Returns the owner of the NFT specified by `tokenId`.
     */
    function ownerOf(uint256 tokenId) public view returns (address owner);

    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     *
     *
     * Requirements:
     * - `from`, `to` cannot be zero.
     * - `tokenId` must be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this
     * NFT by either {approve} or {setApprovalForAll}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public;
    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     * Requirements:
     * - If the caller is not `from`, it must be approved to move this NFT by
     * either {approve} or {setApprovalForAll}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public;
    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);


    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol

pragma solidity ^0.5.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721Enumerable is IERC721 {
    function totalSupply() public view returns (uint256);
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);

    function tokenByIndex(uint256 index) public view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol

pragma solidity ^0.5.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
contract IERC721Receiver {
    /**
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     * after a {IERC721-safeTransferFrom}. This function MUST return the function selector,
     * otherwise the caller will revert the transaction. The selector to be
     * returned can be obtained as `this.onERC721Received.selector`. This
     * function MAY throw to revert and reject the transfer.
     * Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following 
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // 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 Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

// File: @openzeppelin/contracts/drafts/Counters.sol

pragma solidity ^0.5.0;


/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

// File: @openzeppelin/contracts/introspection/ERC165.sol

pragma solidity ^0.5.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol

pragma solidity ^0.5.0;








/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721 {
    using SafeMath for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from token ID to owner
    mapping (uint256 => address) private _tokenOwner;

    // Mapping from token ID to approved address
    mapping (uint256 => address) private _tokenApprovals;

    // Mapping from owner to number of owned token
    mapping (address => Counters.Counter) private _ownedTokensCount;

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    constructor () public {
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param owner address to query the balance of
     * @return uint256 representing the amount owned by the passed address
     */
    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");

        return _ownedTokensCount[owner].current();
    }

    /**
     * @dev Gets the owner of the specified token ID.
     * @param tokenId uint256 ID of the token to query the owner of
     * @return address currently marked as the owner of the given token ID
     */
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _tokenOwner[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");

        return owner;
    }

    /**
     * @dev Approves another address to transfer the given token ID
     * The zero address indicates there is no approved address.
     * There can only be one approved address per token at a given time.
     * Can only be called by the token owner or an approved operator.
     * @param to address to be approved for the given token ID
     * @param tokenId uint256 ID of the token to be approved
     */
    function approve(address to, uint256 tokenId) public {
        address owner = ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Gets the approved address for a token ID, or zero if no address set
     * Reverts if the token ID does not exist.
     * @param tokenId uint256 ID of the token to query the approval of
     * @return address currently approved for the given token ID
     */
    function getApproved(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Sets or unsets the approval of a given operator
     * An operator is allowed to transfer all tokens of the sender on their behalf.
     * @param to operator address to set the approval
     * @param approved representing the status of the approval to be set
     */
    function setApprovalForAll(address to, bool approved) public {
        require(to != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][to] = approved;
        emit ApprovalForAll(_msgSender(), to, approved);
    }

    /**
     * @dev Tells whether an operator is approved by a given owner.
     * @param owner owner address which you want to query the approval of
     * @param operator operator address which you want to query the approval of
     * @return bool whether the given operator is approved by the given owner
     */
    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev Transfers the ownership of a given token ID to another address.
     * Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     * Requires the msg.sender to be the owner, approved, or operator.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function transferFrom(address from, address to, uint256 tokenId) public {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transferFrom(from, to, tokenId);
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the _msgSender() to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransferFrom(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function _safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) internal {
        _transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether the specified token exists.
     * @param tokenId uint256 ID of the token to query the existence of
     * @return bool whether the token exists
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        address owner = _tokenOwner[tokenId];
        return owner != address(0);
    }

    /**
     * @dev Returns whether the given spender can transfer a given token ID.
     * @param spender address of the spender to query
     * @param tokenId uint256 ID of the token to be transferred
     * @return bool whether the msg.sender is approved for the given token ID,
     * is an operator of the owner, or is the owner of the token
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Internal function to safely mint a new token.
     * Reverts if the given token ID already exists.
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Internal function to safely mint a new token.
     * Reverts if the given token ID already exists.
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     * @param _data bytes data to send along with a safe transfer check
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) internal {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Internal function to mint a new token.
     * Reverts if the given token ID already exists.
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _tokenOwner[tokenId] = to;
        _ownedTokensCount[to].increment();

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * Deprecated, use {_burn} instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        require(ownerOf(tokenId) == owner, "ERC721: burn of token that is not own");

        _clearApproval(tokenId);

        _ownedTokensCount[owner].decrement();
        _tokenOwner[tokenId] = address(0);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(uint256 tokenId) internal {
        _burn(ownerOf(tokenId), tokenId);
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _clearApproval(tokenId);

        _ownedTokensCount[from].decrement();
        _ownedTokensCount[to].increment();

        _tokenOwner[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * This is an internal detail of the `ERC721` contract and its use is deprecated.
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        internal returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ));
        if (!success) {
            if (returndata.length > 0) {
                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert("ERC721: transfer to non ERC721Receiver implementer");
            }
        } else {
            bytes4 retval = abi.decode(returndata, (bytes4));
            return (retval == _ERC721_RECEIVED);
        }
    }

    /**
     * @dev Private function to clear current approval of a given token ID.
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _clearApproval(uint256 tokenId) private {
        if (_tokenApprovals[tokenId] != address(0)) {
            _tokenApprovals[tokenId] = address(0);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721Enumerable.sol

pragma solidity ^0.5.0;





/**
 * @title ERC-721 Non-Fungible Token with optional enumeration extension logic
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => uint256[]) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

    /**
     * @dev Constructor function.
     */
    constructor () public {
        // register the supported interface to conform to ERC721Enumerable via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev Gets the token ID at a given index of the tokens list of the requested owner.
     * @param owner address owning the tokens list to be accessed
     * @param index uint256 representing the index to be accessed of the requested tokens list
     * @return uint256 token ID at the given index of the tokens list owned by the requested address
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
        require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev Gets the total amount of tokens stored by the contract.
     * @return uint256 representing the total amount of tokens
     */
    function totalSupply() public view returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev Gets the token ID at a given index of all the tokens in this contract
     * Reverts if the index is greater or equal to the total number of tokens.
     * @param index uint256 representing the index to be accessed of the tokens list
     * @return uint256 token ID at the given index of the tokens list
     */
    function tokenByIndex(uint256 index) public view returns (uint256) {
        require(index < totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to transferFrom, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        super._transferFrom(from, to, tokenId);

        _removeTokenFromOwnerEnumeration(from, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);
    }

    /**
     * @dev Internal function to mint a new token.
     * Reverts if the given token ID already exists.
     * @param to address the beneficiary that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        super._mint(to, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);

        _addTokenToAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * Deprecated, use {ERC721-_burn} instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        _removeTokenFromOwnerEnumeration(owner, tokenId);
        // Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
        _ownedTokensIndex[tokenId] = 0;

        _removeTokenFromAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Gets the list of token IDs of the requested owner.
     * @param owner address owning the tokens
     * @return uint256[] List of token IDs owned by the requested address
     */
    function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
        return _ownedTokens[owner];
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        _ownedTokensIndex[tokenId] = _ownedTokens[to].length;
        _ownedTokens[to].push(tokenId);
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        _ownedTokens[from].length--;

        // Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occupied by
        // lastTokenId, or just over the end of the array if the token was the last one).
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length.sub(1);
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        _allTokens.length--;
        _allTokensIndex[tokenId] = 0;
    }
}

// File: contracts/interface/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
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);
    function mint(address account, uint amount) external;
    /**
     * @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: contracts/library/SafeERC20.sol

pragma solidity ^0.5.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 ERC20;` 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));
    }

    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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "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: contracts/library/Governance.sol

pragma solidity ^0.5.0;

contract Governance {

    address public _governance;

    constructor() public {
        _governance = tx.origin;
    }

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

    modifier onlyGovernance {
        require(msg.sender == _governance, "not governance");
        _;
    }

    function setGovernance(address governance)  public  onlyGovernance
    {
        require(governance != address(0), "new governance the zero address");
        emit GovernanceTransferred(_governance, governance);
        _governance = governance;
    }


}

// File: contracts/interface/IPool.sol

pragma solidity ^0.5.0;


interface IPool {
    function totalSupply( ) external view returns (uint256);
    function balanceOf( address player ) external view returns (uint256);
}

// File: contracts/interface/IPlayerBook.sol

pragma solidity ^0.5.0;


interface IPlayerBook {
    function settleReward( address from,uint256 amount ) external returns (uint256);
    function bindRefer( address from,string calldata  affCode )  external returns (bool);
    function hasRefer(address from) external returns(bool);

}

// File: contracts/interface/IGegoFactory.sol

pragma solidity ^0.5.0;

interface IGegoFactory {
    function getGego(uint256 tokenId)
        external view
        returns (
            uint256 grade,
            uint256 quality,
            uint256 degoAmount,
            uint256 createdTime,
            uint256 blockNum,
            uint256 resId,
            address author
        );


    function getQualityBase() external view 
        returns (uint256 );
}

// File: contracts/interface/IGegoToken.sol

pragma solidity ^0.5.0;



contract IGegoToken is IERC721 {
    function mint(address to, uint256 tokenId) external returns (bool) ;
    function burn(uint256 tokenId) external;
}

// File: contracts/reward/NFTReward.sol

pragma solidity ^0.5.0;





// gego
// import "../interface/IERC20.sol";








    
contract NFTReward is IPool,Governance {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    IERC20 public _dego = IERC20(0x0);
    IGegoFactory public _gegoFactory = IGegoFactory(0x0);
    IGegoToken public _gegoToken = IGegoToken(0x0);
    address public _playerBook = address(0x0);

    address public _teamWallet = 0x3D0a845C5ef9741De999FC068f70E2048A489F2b;
    address public _rewardPool = 0xEA6dEc98e137a87F78495a8386f7A137408f7722;

    uint256 public constant DURATION = 7 days;
    uint256 public _initReward = 52500 * 1e18;
    uint256 public _startTime =  now + 365 days;
    uint256 public _periodFinish = 0;
    uint256 public _rewardRate = 0;
    uint256 public _lastUpdateTime;
    uint256 public _rewardPerTokenStored;

    uint256 public _teamRewardRate = 500;
    uint256 public _poolRewardRate = 1000;
    uint256 public _baseRate = 10000;
    uint256 public _punishTime = 3 days;

    mapping(address => uint256) public _userRewardPerTokenPaid;
    mapping(address => uint256) public _rewards;
    mapping(address => uint256) public _lastStakedTime;

    bool public _hasStart = false;
    uint256 public _fixRateBase = 100000;
    
    uint256 public _totalWeight;
    mapping(address => uint256) public _weightBalances;
    mapping(uint256 => uint256) public _stakeWeightes;
    mapping(uint256 => uint256) public _stakeBalances;

    uint256 public _totalBalance;
    mapping(address => uint256) public _degoBalances;
    uint256 public _maxStakedDego = 200 * 1e18;

    mapping(address => uint256[]) public _playerGego;
    mapping(uint256 => uint256) public _gegoMapIndex;
    


    event RewardAdded(uint256 reward);
    event StakedGEGO(address indexed user, uint256 amount);
    event WithdrawnGego(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
    event NFTReceived(address operator, address from, uint256 tokenId, bytes data);

    constructor(address dego, address gego, address gegoFactory,address playerBook) public {
        _dego = IERC20(dego);
        _gegoToken = IGegoToken(gego);
        _gegoFactory = IGegoFactory(gegoFactory);
        _playerBook = playerBook;
    }
    

    modifier updateReward(address account) {
        _rewardPerTokenStored = rewardPerToken();
        _lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            _rewards[account] = earned(account);
            _userRewardPerTokenPaid[account] = _rewardPerTokenStored;
        }
        _;
    }

    function setMaxStakedDego(uint256 amount) external onlyGovernance{
        _maxStakedDego = amount;
    }

    /* Fee collection for any other token */
    function seize(IERC20 token, uint256 amount) external onlyGovernance{
        require(token != _dego, "reward");
        token.safeTransfer(_governance, amount);
    }
    
    /* Fee collection for any other token */
    function seizeErc721(IERC721 token, uint256 tokenId) external 
    {
        require(token != _gegoToken, "gego stake");
        token.safeTransferFrom(address(this), _governance, tokenId);
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, _periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply() == 0) {
            return _rewardPerTokenStored;
        }
        return
            _rewardPerTokenStored.add(
                lastTimeRewardApplicable()
                    .sub(_lastUpdateTime)
                    .mul(_rewardRate)
                    .mul(1e18)
                    .div(totalSupply())
            );
    }

    function earned(address account) public view returns (uint256) {
        return
            balanceOf(account)
                .mul(rewardPerToken().sub(_userRewardPerTokenPaid[account]))
                .div(1e18)
                .add(_rewards[account]);
    }

    
    //the grade is a number between 1-6
    //the quality is a number between 1-10000
    /*
    1   quality	1.1+ 0.1*quality/5000
    2	quality	1.2+ 0.1*(quality-5000)/3000
    3	quality	1.3+ 0.1*(quality-8000/1000
    4	quality	1.4+ 0.2*(quality-9000)/800
    5	quality	1.6+ 0.2*(quality-9800)/180
    6	quality	1.8+ 0.2*(quality-9980)/20
    */

    function getFixRate(uint256 grade,uint256 quality) public pure returns (uint256){

        require(grade > 0 && grade <7, "the gego not dego");

        uint256 unfold = 0;

        if( grade == 1 ){
            unfold = quality*10000/5000;
            return unfold.add(110000);
        }else if( grade == 2){
            unfold = quality.sub(5000)*10000/3000;
            return unfold.add(120000);
        }else if( grade == 3){
            unfold = quality.sub(8000)*10000/1000;
           return unfold.add(130000);
        }else if( grade == 4){
            unfold = quality.sub(9000)*20000/800;
           return unfold.add(140000);
        }else if( grade == 5){
            unfold = quality.sub(9800)*20000/180;
            return unfold.add(160000);
        }else{
            unfold = quality.sub(9980)*20000/20;
            return unfold.add(180000);
        }
    }

    function getStakeInfo( uint256 gegoId ) public view returns ( uint256 stakeRate, uint256 degoAmount){

        uint256 grade;
        uint256 quality;
        uint256 createdTime;
        uint256 blockNum;
        uint256 resId;
        address author;

        (grade, quality, degoAmount, createdTime,blockNum, resId, author) = _gegoFactory.getGego(gegoId);

        require(degoAmount > 0,"the gego not dego");

        stakeRate = getFixRate(grade,quality);
    }

    // stake GEGO 
    function stakeGego(uint256 gegoId, string memory affCode)
        public
        updateReward(msg.sender)
        checkHalve
        checkStart
    {

        uint256[] storage gegoIds = _playerGego[msg.sender];
        if (gegoIds.length == 0) {
            gegoIds.push(0);    
            _gegoMapIndex[0] = 0;
        }
        gegoIds.push(gegoId);
        _gegoMapIndex[gegoId] = gegoIds.length - 1;

        uint256 stakeRate;
        uint256 degoAmount;
        (stakeRate, degoAmount) = getStakeInfo(gegoId);

        uint256 stakedDegoAmount = _degoBalances[msg.sender];
        uint256 stakingDegoAmount = stakedDegoAmount.add(degoAmount) <= _maxStakedDego?degoAmount:_maxStakedDego.sub(stakedDegoAmount);


        if(stakingDegoAmount > 0){
            uint256 stakeWeight = stakeRate.mul(stakingDegoAmount).div(_fixRateBase);
            _degoBalances[msg.sender] = _degoBalances[msg.sender].add(stakingDegoAmount);

            _weightBalances[msg.sender] = _weightBalances[msg.sender].add(stakeWeight);

            _stakeBalances[gegoId] = stakingDegoAmount;
            _stakeWeightes[gegoId] = stakeWeight;
            
            _totalBalance = _totalBalance.add(stakingDegoAmount);
            _totalWeight = _totalWeight.add(stakeWeight);
        }

        _gegoToken.safeTransferFrom(msg.sender, address(this), gegoId);

        if (!IPlayerBook(_playerBook).hasRefer(msg.sender)) {
            IPlayerBook(_playerBook).bindRefer(msg.sender, affCode);
        }
        _lastStakedTime[msg.sender] = now;
        emit StakedGEGO(msg.sender, gegoId);
        
    }
    
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) public returns (bytes4) {
        if(_hasStart == false) {
            return 0;
        }

        emit NFTReceived(operator, from, tokenId, data);
        return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
    }

    function withdrawGego(uint256 gegoId)
        public
        updateReward(msg.sender)
        checkHalve
        checkStart
    {
        require(gegoId > 0, "the gegoId error");
        
        uint256[] memory gegoIds = _playerGego[msg.sender];
        uint256 gegoIndex = _gegoMapIndex[gegoId];
        
        require(gegoIds[gegoIndex] == gegoId, "not gegoId owner");

        uint256 gegoArrayLength = gegoIds.length-1;
        uint256 tailId = gegoIds[gegoArrayLength];

        _playerGego[msg.sender][gegoIndex] = tailId;
        _playerGego[msg.sender][gegoArrayLength] = 0;
        _playerGego[msg.sender].length--;
        _gegoMapIndex[tailId] = gegoIndex;
        _gegoMapIndex[gegoId] = 0;

        uint256 stakeWeight = _stakeWeightes[gegoId];
        _weightBalances[msg.sender] = _weightBalances[msg.sender].sub(stakeWeight);
        _totalWeight = _totalWeight.sub(stakeWeight);

        uint256 stakeBalance = _stakeBalances[gegoId];
        _degoBalances[msg.sender] = _degoBalances[msg.sender].sub(stakeBalance);
        _totalBalance = _totalBalance.sub(stakeBalance);



        _gegoToken.safeTransferFrom(address(this), msg.sender, gegoId);

        _stakeBalances[gegoId] = 0;
        _stakeWeightes[gegoId] = 0;

        emit WithdrawnGego(msg.sender, gegoId);
    }

    function withdraw()
        public
        checkStart
    {

        uint256[] memory gegoId = _playerGego[msg.sender];
        for (uint8 index = 1; index < gegoId.length; index++) {
            if (gegoId[index] > 0) {
                withdrawGego(gegoId[index]);
            }
        }
    }

    function getPlayerIds( address account ) public view returns( uint256[] memory gegoId )
    {
        gegoId = _playerGego[account];
    }

    function exit() external {
        withdraw();
        getReward();
    }

    function getReward() public updateReward(msg.sender) checkHalve checkStart {
        uint256 reward = earned(msg.sender);
        if (reward > 0) {
            _rewards[msg.sender] = 0;

            uint256 fee = IPlayerBook(_playerBook).settleReward(msg.sender, reward);
            if(fee > 0){
                _dego.safeTransfer(_playerBook, fee);
            }
            
            uint256 teamReward = reward.mul(_teamRewardRate).div(_baseRate);
            if(teamReward>0){
                _dego.safeTransfer(_teamWallet, teamReward);
            }
            uint256 leftReward = reward.sub(fee).sub(teamReward);
            uint256 poolReward = 0;

            //withdraw time check

            if(now  < (_lastStakedTime[msg.sender] + _punishTime) ){
                poolReward = leftReward.mul(_poolRewardRate).div(_baseRate);
            }
            if(poolReward>0){
                _dego.safeTransfer(_rewardPool, poolReward);
                leftReward = leftReward.sub(poolReward);
            }

            if(leftReward>0){
                _dego.safeTransfer(msg.sender, leftReward );
            }
      
            emit RewardPaid(msg.sender, leftReward);
        }
    }

    modifier checkHalve() {
        if (block.timestamp >= _periodFinish) {
            _initReward = _initReward.mul(50).div(100);

            _dego.mint(address(this), _initReward);

            _rewardRate = _initReward.div(DURATION);
            _periodFinish = block.timestamp.add(DURATION);
            emit RewardAdded(_initReward);
        }
        _;
    }
    
    modifier checkStart() {
        require(block.timestamp > _startTime, "not start");
        _;
    }

    // set fix time to start reward
    function startNFTReward(uint256 startTime)
        external
        onlyGovernance
        updateReward(address(0))
    {
        require(_hasStart == false, "has started");
        _hasStart = true;
        
        _startTime = startTime;

        _rewardRate = _initReward.div(DURATION); 
        _dego.mint(address(this), _initReward);

        _lastUpdateTime = _startTime;
        _periodFinish = _startTime.add(DURATION);

        emit RewardAdded(_initReward);
    }

    //

    //for extra reward
    function notifyMintAmount(uint256 reward)
        external
        onlyGovernance
        updateReward(address(0))
    {
        // IERC20(_dego).safeTransferFrom(msg.sender, address(this), reward);
        _dego.mint(address(this), reward);
        if (block.timestamp >= _periodFinish) {
            _rewardRate = reward.div(DURATION);
        } else {
            uint256 remaining = _periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(_rewardRate);
            _rewardRate = reward.add(leftover).div(DURATION);
        }
        _lastUpdateTime = block.timestamp;
        _periodFinish = block.timestamp.add(DURATION);
        emit RewardAdded(reward);
    }

    function setTeamRewardRate( uint256 teamRewardRate ) public onlyGovernance {
        _teamRewardRate = teamRewardRate;
    }

    function setPoolRewardRate( uint256  poolRewardRate ) public onlyGovernance{
        _poolRewardRate = poolRewardRate;
    }

    function totalSupply()  public view returns (uint256) {
        return _totalWeight;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _weightBalances[account];
    }
    
    function setWithDrawPunishTime( uint256  punishTime ) public onlyGovernance{
        _punishTime = punishTime;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"earned","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"gegoId","type":"uint256"}],"name":"getStakeInfo","outputs":[{"name":"stakeRate","type":"uint256"},{"name":"degoAmount","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"teamRewardRate","type":"uint256"}],"name":"setTeamRewardRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_maxStakedDego","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_rewardPerTokenStored","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_periodFinish","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"operator","type":"address"},{"name":"from","type":"address"},{"name":"tokenId","type":"uint256"},{"name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"name":"","type":"bytes4"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"DURATION","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_governance","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"token","type":"address"},{"name":"tokenId","type":"uint256"}],"name":"seizeErc721","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_totalBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_totalWeight","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_teamWallet","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_fixRateBase","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"getReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"_stakeWeightes","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_poolRewardRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"_lastStakedTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"uint256"}],"name":"_playerGego","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"_userRewardPerTokenPaid","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_rewardRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_gegoFactory","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_lastUpdateTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"gegoId","type":"uint256"}],"name":"withdrawGego","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_dego","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_gegoToken","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"poolRewardRate","type":"uint256"}],"name":"setPoolRewardRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"_rewards","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"amount","type":"uint256"}],"name":"setMaxStakedDego","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_baseRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"reward","type":"uint256"}],"name":"notifyMintAmount","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"punishTime","type":"uint256"}],"name":"setWithDrawPunishTime","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_punishTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"governance","type":"address"}],"name":"setGovernance","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"grade","type":"uint256"},{"name":"quality","type":"uint256"}],"name":"getFixRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":false,"inputs":[{"name":"startTime","type":"uint256"}],"name":"startNFTReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rewardPerToken","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"getPlayerIds","outputs":[{"name":"gegoId","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"_gegoMapIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"_weightBalances","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"_stakeBalances","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_rewardPool","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_hasStart","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"exit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"token","type":"address"},{"name":"amount","type":"uint256"}],"name":"seize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_teamRewardRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"_degoBalances","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_playerBook","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"_startTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"gegoId","type":"uint256"},{"name":"affCode","type":"string"}],"name":"stakeGego","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_initReward","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"dego","type":"address"},{"name":"gego","type":"address"},{"name":"gegoFactory","type":"address"},{"name":"playerBook","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"user","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"StakedGEGO","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"user","type":"address"},{"indexed":false,"name":"amount","type":"uint256"}],"name":"WithdrawnGego","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"user","type":"address"},{"indexed":false,"name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"operator","type":"address"},{"indexed":false,"name":"from","type":"address"},{"indexed":false,"name":"tokenId","type":"uint256"},{"indexed":false,"name":"data","type":"bytes"}],"name":"NFTReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"GovernanceTransferred","type":"event"}]

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

56636:13351:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;56636:13351:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60399:267;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;60399:267:0;-1:-1:-1;;;;;60399:267:0;;:::i;:::-;;;;;;;;;;;;;;;;61951:481;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;61951:481:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;69368:126;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69368:126:0;;:::i;:::-;;58138:42;;;:::i;57369:36::-;;;:::i;57256:32::-;;;:::i;64106:340::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;64106:340:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;64106:340:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;64106:340:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;64106:340:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;64106:340:0;;-1:-1:-1;64106:340:0;;-1:-1:-1;;;;;64106:340:0:i;:::-;;;;-1:-1:-1;;;;;;64106:340:0;;;;;;;;;;;;;;69636:92;;;:::i;57110:41::-;;;:::i;54601:26::-;;;:::i;:::-;;;;-1:-1:-1;;;;;54601:26:0;;;;;;;;;;;;;;59620:199;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;59620:199:0;;;;;;;;:::i;58048:28::-;;;:::i;57843:27::-;;;:::i;56952:71::-;;;:::i;57794:36::-;;;:::i;65796:306::-;;;:::i;66343:1234::-;;;:::i;57934:49::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;57934:49:0;;:::i;57457:37::-;;;:::i;57699:50::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;57699:50:0;-1:-1:-1;;;;;57699:50:0;;:::i;58189:48::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;58189:48:0;;;;;;;;:::i;57584:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;57584:58:0;-1:-1:-1;;;;;57584:58:0;;:::i;57295:30::-;;;:::i;56790:52::-;;;:::i;57332:30::-;;;:::i;69736:116::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69736:116:0;-1:-1:-1;;;;;69736:116:0;;:::i;64454:1334::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;64454:1334:0;;:::i;56750:33::-;;;:::i;56849:46::-;;;:::i;69502:126::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69502:126:0;;:::i;57649:43::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;57649:43:0;-1:-1:-1;;;;;57649:43:0;;:::i;59827:132::-;;;:::i;59231:107::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;59231:107:0;;:::i;57501:32::-;;;:::i;68652:708::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68652:708:0;;:::i;69864:118::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;69864:118:0;;:::i;57540:35::-;;;:::i;54915:256::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54915:256:0;-1:-1:-1;;;;;54915:256:0;;:::i;61040:903::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;61040:903:0;;;;;;;:::i;68119:491::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;68119:491:0;;:::i;59967:424::-;;;:::i;66110:141::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;66110:141:0;-1:-1:-1;;;;;66110:141:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;66110:141:0;;;;;;;;;;;;;;;;;58244:48;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;58244:48:0;;:::i;57877:50::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;57877:50:0;-1:-1:-1;;;;;57877:50:0;;:::i;57990:49::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;57990:49:0;;:::i;57030:71::-;;;:::i;57758:29::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;66259:76;;;:::i;59392:170::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;59392:170:0;;;;;;;;:::i;57414:36::-;;;:::i;58083:48::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;58083:48:0;-1:-1:-1;;;;;58083:48:0;;:::i;56902:41::-;;;:::i;57206:43::-;;;:::i;62460:1634::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;62460:1634:0;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;62460:1634:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;62460:1634:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;62460:1634:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;62460:1634:0;;-1:-1:-1;62460:1634:0;;-1:-1:-1;;;;;62460:1634:0:i;57158:41::-;;;:::i;60399:267::-;-1:-1:-1;;;;;60640:17:0;;60453:7;60640:17;;;:8;:17;;;;;;;;;60555:23;:32;;;;;;60493:165;;60640:17;60493:124;;60612:4;;60493:96;;60534:54;;:16;:14;:16::i;:::-;:20;:54;:20;:54;:::i;:::-;60493:18;60503:7;60493:9;:18::i;:::-;:40;:96;:40;:96;:::i;:::-;:118;:124;:118;:124;:::i;:::-;:146;:165;:146;:165;:::i;:::-;60473:185;60399:267;-1:-1:-1;;60399:267:0:o;61951:481::-;62013:17;62032:18;62064:13;62088:15;62114:19;62144:16;62171:13;62195:14;62290:12;;;;;;;;;-1:-1:-1;;;;;62290:12:0;-1:-1:-1;;;;;62290:20:0;;62311:6;62290:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;62290:28:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;62290:28:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;62290:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62290:28:0;;-1:-1:-1;62290:28:0;;-1:-1:-1;62290:28:0;;-1:-1:-1;62290:28:0;;-1:-1:-1;62290:28:0;;-1:-1:-1;62290:28:0;-1:-1:-1;62339:14:0;;;62331:43;;;;;-1:-1:-1;;;;;62331:43:0;;;;;;;;;;;;-1:-1:-1;;;;;62331:43:0;;;;;;;;;;;;;;;62399:25;62410:5;62416:7;62399:10;:25::i;:::-;62387:37;;61951:481;;;;;;;;;:::o;69368:126::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;69454:15;:32;69368:126::o;58138:42::-;;;;:::o;57369:36::-;;;;:::o;57256:32::-;;;;:::o;64106:340::-;64238:9;;64216:6;;64238:9;;:18;;64235:58;;-1:-1:-1;64280:1:0;64273:8;;64235:58;64310:42;64322:8;64332:4;64338:7;64347:4;64310:42;;;;-1:-1:-1;;;;;64310:42:0;-1:-1:-1;;;;;64310:42:0;;;;;;-1:-1:-1;;;;;64310:42:0;-1:-1:-1;;;;;64310:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;64310:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64377:60;;;;;;;;;;;;;;;;;;64363:75;;64106:340;;;;;;;:::o;69636:92::-;69708:12;;69636:92;;:::o;57110:41::-;57145:6;57110:41;:::o;54601:26::-;;;-1:-1:-1;;;;;54601:26:0;;:::o;59620:199::-;59716:10;;-1:-1:-1;;;;;59707:19:0;;;59716:10;;59707:19;;59699:42;;;;;-1:-1:-1;;;;;59699:42:0;;;;;;;;;;;;-1:-1:-1;;;;;59699:42:0;;;;;;;;;;;;;;;59790:11;;;59752:59;;;-1:-1:-1;;;;;59752:59:0;;59783:4;59752:59;;;;-1:-1:-1;;;;;59790:11:0;;;59752:59;;;;;;;;;;;;:22;;;;;;:59;;;;;;;;;;59790:11;59752:22;:59;;;5:2:-1;;;;30:1;27;20:12;5:2;59752:59:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;59752:59:0;;;;59620:199;;:::o;58048:28::-;;;;:::o;57843:27::-;;;;:::o;56952:71::-;;;-1:-1:-1;;;;;56952:71:0;;:::o;57794:36::-;;;;:::o;65796:306::-;68030:10;;68012:15;:28;68004:50;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;;;;65908:10;65896:23;;;;:11;:23;;;;;;;;;65870:49;;;;;;;;;;;;;;;;;:23;;:49;;;65896:23;65870:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65870:49:0;;-1:-1:-1;65949:1:0;;-1:-1:-1;;;;65930:165:0;65960:6;:13;65952:5;:21;;;65930:165;;;66019:1;66003:6;66010:5;66003:13;;;;;;;;;;;;;;;;;;;;:17;65999:85;;;66041:27;66054:6;66061:5;66054:13;;;;;;;;;;;;;;;;;;;;66041:12;:27::i;:::-;65975:7;;65930:165;;;;68065:1;65796:306::o;66343:1234::-;66384:10;58962:16;:14;:16::i;:::-;58938:21;:40;59007:26;:24;:26::i;:::-;58989:15;:44;-1:-1:-1;;;;;59048:21:0;;;59044:160;;59106:15;59113:7;59106:6;:15::i;:::-;-1:-1:-1;;;;;59086:17:0;;;;;;:8;:17;;;;;;;;:35;;;;59171:21;;59136:23;:32;;;;;;:56;59044:160;67641:13;;67622:15;:32;67618:322;;67685:28;67709:3;67685:19;67701:2;67685:11;;:15;;:19;;;;:::i;:28::-;67671:11;:42;;;67730:5;;:38;;;-1:-1:-1;;;;;67730:38:0;;67749:4;67730:38;;;;;;;;;;;;-1:-1:-1;;;;;67730:5:0;;;;:10;;:38;;;;;:5;;:38;;;;;;;:5;;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;67730:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;67799:11:0;;:25;;-1:-1:-1;67799:11:0;-1:-1:-1;57145:6:0;67799:25;:15;:25;:::i;:::-;67785:11;:39;67855:29;:15;57145:6;67855:29;:19;:29;:::i;:::-;67839:13;:45;67916:11;;67904:24;;;;;;;-1:-1:-1;;;;;;;;;;;67904:24:0;;;;;;;;67618:322;68030:10;;68012:15;:28;68004:50;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;;;;66429:14;66446:18;66453:10;66446:6;:18::i;:::-;66429:35;-1:-1:-1;66479:10:0;;66475:1095;;66515:10;66529:1;66506:20;;;:8;:20;;;;;;;;:24;;;66573:11;;;66561:57;;-1:-1:-1;;;;;66561:57:0;;;;;;;;;;;;;;;;;66529:1;;-1:-1:-1;;;;;66573:11:0;;66561:37;;:57;;;;;66506:20;;66561:57;;;;;;66529:1;66573:11;66561:57;;;5:2:-1;;;;30:1;27;20:12;5:2;66561:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;66561:57:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;66561:57:0;;-1:-1:-1;66636:7:0;;66633:82;;66682:11;;;66663:5;:36;;-1:-1:-1;;;;;66663:5:0;;;;66682:11;66695:3;66663:36;:18;:36;:::i;:::-;66743:18;66764:42;66796:9;;66764:27;66775:15;;66764:6;:10;;:27;;;;:::i;:42::-;66743:63;-1:-1:-1;66824:12:0;;66821:94;;66875:11;;;66856:5;:43;;-1:-1:-1;;;;;66856:5:0;;;;66875:11;66888:10;66856:43;:18;:43;:::i;:::-;66929:18;66950:31;66970:10;66950:15;:6;66961:3;66950:15;:10;:15;:::i;:31::-;67113:11;;67099:10;66996:18;67083:27;;;:15;:27;;;;;;66929:52;;-1:-1:-1;66996:18:0;67083:41;67075:3;:50;67072:149;;;67159:46;67195:9;;67159:31;67174:15;;67159:10;:14;;:31;;;;:::i;:46::-;67146:59;;67072:149;67238:12;;67235:152;;67289:11;;;67270:5;:43;;-1:-1:-1;;;;;67270:5:0;;;;67289:11;67302:10;67270:43;:18;:43;:::i;:::-;67345:26;:10;67360;67345:26;:14;:26;:::i;:::-;67332:39;;67235:152;67406:12;;67403:94;;67438:5;;:43;;-1:-1:-1;;;;;67438:5:0;67457:10;67469;67438:43;:18;:43;:::i;:::-;67524:34;;;;;;;;67535:10;;67524:34;;;;;;;;;;66475:1095;;;;68065:1;66343:1234;:::o;57934:49::-;;;;;;;;;;;;;:::o;57457:37::-;;;;:::o;57699:50::-;;;;;;;;;;;;;:::o;58189:48::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57584:58::-;;;;;;;;;;;;;:::o;57295:30::-;;;;:::o;56790:52::-;;;-1:-1:-1;;;;;56790:52:0;;:::o;57332:30::-;;;;:::o;69736:116::-;-1:-1:-1;;;;;69820:24:0;69793:7;69820:24;;;:15;:24;;;;;;;69736:116::o;64454:1334::-;64530:10;58962:16;:14;:16::i;:::-;58938:21;:40;59007:26;:24;:26::i;:::-;58989:15;:44;-1:-1:-1;;;;;59048:21:0;;;59044:160;;59106:15;59113:7;59106:6;:15::i;:::-;-1:-1:-1;;;;;59086:17:0;;;;;;:8;:17;;;;;;;;:35;;;;59171:21;;59136:23;:32;;;;;;:56;59044:160;67641:13;;67622:15;:32;67618:322;;67685:28;67709:3;67685:19;67701:2;67685:11;;:15;;:19;;;;:::i;:28::-;67671:11;:42;;;67730:5;;:38;;;-1:-1:-1;;;;;67730:38:0;;67749:4;67730:38;;;;;;;;;;;;-1:-1:-1;;;;;67730:5:0;;;;:10;;:38;;;;;:5;;:38;;;;;;;:5;;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;67730:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;67799:11:0;;:25;;-1:-1:-1;67799:11:0;-1:-1:-1;57145:6:0;67799:25;:15;:25;:::i;:::-;67785:11;:39;67855:29;:15;57145:6;67855:29;:19;:29;:::i;:::-;67839:13;:45;67916:11;;67904:24;;;;;;;-1:-1:-1;;;;;;;;;;;67904:24:0;;;;;;;;67618:322;68030:10;;68012:15;:28;68004:50;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;;;;64606:10;;;64598:39;;;;;-1:-1:-1;;;;;64598:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;64697:10;64685:23;;;;:11;:23;;;;;;;;;64658:50;;;;;;;;;;;;;;;;;:24;;:50;;;64685:23;64658:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;64719:17:0;64739:21;;;:13;:21;;;;;;64789:18;;64658:50;;-1:-1:-1;64739:21:0;64753:6;;-1:-1:-1;64658:50:0;;-1:-1:-1;64739:21:0;;64789:18;;;;;;;;;;;;;;;:28;64781:57;;;;;-1:-1:-1;;;;;64781:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;64877:14;;-1:-1:-1;;64877:16:0;;;64851:23;;64877:7;;:16;;64921:24;;;;;;;;;;;;;;;;64970:10;64958:23;;;;:11;:23;;;;;;;:34;;64921:24;;-1:-1:-1;64921:24:0;;64982:9;;64958:34;;;;;;;;;;;;;;;;;:43;;;;65024:10;65012:23;;:11;:23;;;;;;:40;;65036:15;;65012:40;;;;;;;;;;;;;;;;;:44;;;;65079:10;65067:23;;:11;:23;;;;;;:32;;;;;-1:-1:-1;;65067:32:0;;;:::i;:::-;-1:-1:-1;65110:21:0;;;;:13;:21;;;;;;;;:33;;;65154:21;;;;;;:25;;;65214:14;:22;;;;;;65293:10;65277:27;;:15;:27;;;;;;;:44;;65214:22;65277:44;:31;:44;:::i;:::-;65263:10;65247:27;;;;:15;:27;;;;;:74;65347:12;;:29;;65364:11;65347:29;:16;:29;:::i;:::-;65332:12;:44;65389:20;65412:22;;;:14;:22;;;;;;;;;65487:10;65473:25;;:13;:25;;;;;;;:43;;65412:22;65473:43;:29;:43;:::i;:::-;65459:10;65445:25;;;;:13;:25;;;;;:71;65543:13;;:31;;65561:12;65543:31;:17;:31;:::i;:::-;65527:13;:47;65591:10;;:62;;;-1:-1:-1;;;;;65591:62:0;;65627:4;65591:62;;;;65634:10;65591:62;;;;;;;;;;;;-1:-1:-1;;;;;65591:10:0;;;;:27;;:62;;;;;:10;;:62;;;;;;;;:10;;:62;;;5:2:-1;;;;30:1;27;20:12;5:2;65591:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;65691:1:0;65666:22;;;:14;:22;;;;;;;;:26;;;65703:14;:22;;;;;:26;;;;65747:33;;;;;;;65761:10;;-1:-1:-1;65747:33:0;;;;;;;;;;68065:1;;;;;;64454:1334;;:::o;56750:33::-;;;-1:-1:-1;;;;;56750:33:0;;:::o;56849:46::-;;;-1:-1:-1;;;;;56849:46:0;;:::o;69502:126::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;69588:15;:32;69502:126::o;57649:43::-;;;;;;;;;;;;;:::o;59827:132::-;59884:7;59911:40;59920:15;59937:13;;59911:8;:40::i;:::-;59904:47;;59827:132;:::o;59231:107::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;59307:14;:23;59231:107::o;57501:32::-;;;;:::o;68652:708::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;68766:1;58962:16;:14;:16::i;:::-;58938:21;:40;59007:26;:24;:26::i;:::-;58989:15;:44;-1:-1:-1;;;;;59048:21:0;;;59044:160;;59106:15;59113:7;59106:6;:15::i;:::-;-1:-1:-1;;;;;59086:17:0;;;;;;:8;:17;;;;;;;;:35;;;;59171:21;;59136:23;:32;;;;;;:56;59044:160;68865:5;;:33;;;-1:-1:-1;;;;;68865:33:0;;68884:4;68865:33;;;;;;;;;;;;-1:-1:-1;;;;;68865:5:0;;;;:10;;:33;;;;;:5;;:33;;;;;;;;:5;;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;68865:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;68865:33:0;;;;68932:13;;68913:15;:32;;68909:309;;;68976:20;:6;57145;68976:20;:10;:20;:::i;:::-;68962:11;:34;68909:309;;;69049:13;;69029:17;;69049:34;;69067:15;69049:34;:17;:34;:::i;:::-;69029:54;;69098:16;69117:26;69131:11;;69117:9;:13;;:26;;;;:::i;:::-;69098:45;-1:-1:-1;69172:34:0;57145:6;69172:20;:6;69098:45;69172:20;:10;:20;:::i;:34::-;69158:11;:48;-1:-1:-1;;68909:309:0;69246:15;69228;:33;;;69288:29;;57145:6;69288:29;:19;:29;:::i;:::-;69272:13;:45;69333:19;;;;;;;;-1:-1:-1;;;;;;;;;;;69333:19:0;;;;;;;;54898:1;68652:708;:::o;69864:118::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;69950:11;:24;69864:118::o;57540:35::-;;;;:::o;54915:256::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;55006:24:0;;;;54998:68;;;;;-1:-1:-1;;;;;54998:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55104:11;;;55082:46;;-1:-1:-1;;;;;55082:46:0;;;;55104:11;;;55082:46;;;55139:11;:24;;-1:-1:-1;;;;;;55139:24:0;-1:-1:-1;;;;;55139:24:0;;;;;;;;;;54915:256::o;61040:903::-;61112:7;61149:1;61141:5;:9;:21;;;;;61161:1;61154:5;:8;61141:21;61133:51;;;;;;;-1:-1:-1;;;;;61133:51:0;;;;;;;;;;;;-1:-1:-1;;;;;61133:51:0;;;;;;;;;;;;;;;61197:14;61241:1;61232:10;;61228:708;;;-1:-1:-1;61282:4:0;61276:5;61268:13;;:18;61308;61268;61319:6;61308:10;:18::i;:::-;61301:25;;;;;61228:708;61347:5;61356:1;61347:10;61343:593;;;61406:4;61382:17;:7;61394:4;61382:17;:11;:17;:::i;:::-;61400:5;61382:23;:28;;;;;;;;;-1:-1:-1;61432:18:0;61382:28;61443:6;61432:18;:10;:18;:::i;61343:593::-;61471:5;61480:1;61471:10;61467:469;;;61530:4;61506:17;:7;61518:4;61506:17;:11;:17;:::i;:::-;61524:5;61506:23;:28;;;;;;;;;-1:-1:-1;61555:18:0;61506:28;61566:6;61555:18;:10;:18;:::i;61467:469::-;61594:5;61603:1;61594:10;61590:346;;;61653:3;61629:17;:7;61641:4;61629:17;:11;:17;:::i;:::-;61647:5;61629:23;:27;;;;;;;;;-1:-1:-1;61677:18:0;61629:27;61688:6;61677:18;:10;:18;:::i;61590:346::-;61716:5;61725:1;61716:10;61712:224;;;61775:3;61751:17;:7;61763:4;61751:17;:11;:17;:::i;:::-;61769:5;61751:23;:27;;;;;;;;;-1:-1:-1;61800:18:0;61751:27;61811:6;61800:18;:10;:18;:::i;61712:224::-;61882:2;61858:17;:7;61870:4;61858:17;:11;:17;:::i;:::-;61876:5;61858:23;:26;;;;;;;;;-1:-1:-1;61906:18:0;61858:26;61917:6;61906:18;:10;:18;:::i;68119:491::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;68234:1;58962:16;:14;:16::i;:::-;58938:21;:40;59007:26;:24;:26::i;:::-;58989:15;:44;-1:-1:-1;;;;;59048:21:0;;;59044:160;;59106:15;59113:7;59106:6;:15::i;:::-;-1:-1:-1;;;;;59086:17:0;;;;;;:8;:17;;;;;;;;:35;;;;59171:21;;59136:23;:32;;;;;;:56;59044:160;68262:9;;;;:18;68254:42;;;;;-1:-1:-1;;;;;68254:42:0;;;;;;;;;;;;-1:-1:-1;;;;;68254:42:0;;;;;;;;;;;;;;;68307:9;:16;;-1:-1:-1;;68307:16:0;68319:4;68307:16;;;68344:10;:22;;;68393:11;;:25;;57145:6;68393:25;:15;:25;:::i;:::-;68379:11;:39;68430:5;;68456:11;;68430:38;;;-1:-1:-1;;;;;68430:38:0;;68449:4;68430:38;;;;;;;;;;;;-1:-1:-1;;;;;68430:5:0;;;;:10;;:38;;;;;:5;;:38;;;;;;;;:5;;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;68430:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;68499:10:0;;68481:15;:28;;;68536:24;;-1:-1:-1;68499:10:0;-1:-1:-1;57145:6:0;68536:24;:14;:24;:::i;:::-;68520:13;:40;68590:11;;68578:24;;;;;;;-1:-1:-1;;;;;;;;;;;68578:24:0;;;;;;;;54898:1;68119:491;:::o;59967:424::-;60014:7;60038:13;:11;:13::i;:::-;:18;60034:79;;;-1:-1:-1;60080:21:0;;60073:28;;60034:79;60143:240;60187:181;60354:13;:11;:13::i;:::-;60187:140;60322:4;60187:108;60283:11;;60187:69;60240:15;;60187:26;:24;:26::i;:181::-;60143:21;;;:240;:25;:240;:::i;66110:141::-;-1:-1:-1;;;;;66223:20:0;;;;;;:11;:20;;;;;;;;;66214:29;;;;;;;;;;;;;;;;;66172:23;;66214:29;;;66223:20;66214:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66110:141;;;:::o;58244:48::-;;;;;;;;;;;;;:::o;57877:50::-;;;;;;;;;;;;;:::o;57990:49::-;;;;;;;;;;;;;:::o;57030:71::-;;;-1:-1:-1;;;;;57030:71:0;;:::o;57758:29::-;;;;;;:::o;66259:76::-;66295:10;:8;:10::i;:::-;66316:11;:9;:11::i;:::-;66259:76::o;59392:170::-;54857:11;;-1:-1:-1;;;;;54857:11:0;54843:10;:25;54835:52;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;-1:-1:-1;;;;;54835:52:0;;;;;;;;;;;;;;;59488:5;;-1:-1:-1;;;;;59479:14:0;;;59488:5;;59479:14;;59471:33;;;;;-1:-1:-1;;;;;59471:33:0;;;;;;;;;;;;-1:-1:-1;;;;;59471:33:0;;;;;;;;;;;;;;;59534:11;;59515:39;;-1:-1:-1;;;;;59515:18:0;;;;59534:11;59547:6;59515:39;:18;:39;:::i;57414:36::-;;;;:::o;58083:48::-;;;;;;;;;;;;;:::o;56902:41::-;;;-1:-1:-1;;;;;56902:41:0;;:::o;57206:43::-;;;;:::o;62460:1634::-;62556:10;58962:16;:14;:16::i;:::-;58938:21;:40;59007:26;:24;:26::i;:::-;58989:15;:44;-1:-1:-1;;;;;59048:21:0;;;59044:160;;59106:15;59113:7;59106:6;:15::i;:::-;-1:-1:-1;;;;;59086:17:0;;;;;;:8;:17;;;;;;;;:35;;;;59171:21;;59136:23;:32;;;;;;:56;59044:160;67641:13;;67622:15;:32;67618:322;;67685:28;67709:3;67685:19;67701:2;67685:11;;:15;;:19;;;;:::i;:28::-;67671:11;:42;;;67730:5;;:38;;;-1:-1:-1;;;;;67730:38:0;;67749:4;67730:38;;;;;;;;;;;;-1:-1:-1;;;;;67730:5:0;;;;:10;;:38;;;;;:5;;:38;;;;;;;:5;;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;67730:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;67799:11:0;;:25;;-1:-1:-1;67799:11:0;-1:-1:-1;57145:6:0;67799:25;:15;:25;:::i;:::-;67785:11;:39;67855:29;:15;57145:6;67855:29;:19;:29;:::i;:::-;67839:13;:45;67916:11;;67904:24;;;;;;;-1:-1:-1;;;;;;;;;;;67904:24:0;;;;;;;;67618:322;68030:10;;68012:15;:28;68004:50;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;-1:-1:-1;;;;;68004:50:0;;;;;;;;;;;;;;;62666:10;62626:25;62654:23;;;:11;:23;;;;;62692:14;;:19;62688:106;;;27:10:-1;;39:1;23:18;;45:23;;62741:1:0;62728:15;;;;;;;;;;;;;62762:16;;;:13;:16;;;;:20;62688:106;27:10:-1;;39:1;23:18;;45:23;;-1:-1;62804:20:0;;;;;;;;;;;;;62859:14;;62835:21;;;:13;:21;;;;;;-1:-1:-1;;62859:18:0;;;62835:42;;;-1:-1:-1;62973:20:0;62804;62973:12;:20::i;:::-;63047:10;63006:24;63033:25;;;:13;:25;;;;;;63133:14;;62947:46;;-1:-1:-1;62947:46:0;;-1:-1:-1;63033:25:0;;63097:32;63033:25;62947:46;63097:32;:20;:32;:::i;:::-;:50;;:98;;63159:14;;:36;;63178:16;63159:36;:18;:36;:::i;:::-;63097:98;;;63148:10;63097:98;63069:126;-1:-1:-1;63213:21:0;;63210:556;;63309:12;;63250:19;;63272:50;;:32;:9;63286:17;63272:32;:13;:32;:::i;:50::-;63379:10;63365:25;;;;:13;:25;;;;;;63250:72;;-1:-1:-1;63365:48:0;;63395:17;63365:48;:29;:48;:::i;:::-;63351:10;63337:25;;;;:13;:25;;;;;;;;:76;;;;63460:15;:27;;;;:44;;63492:11;63460:44;:31;:44;:::i;:::-;63446:10;63430:27;;;;:15;:27;;;;;;;;:74;;;;63521:22;;;:14;:22;;;;;:42;;;63578:14;:22;;;:36;;;63659:13;;:36;;63546:17;63659:36;:17;:36;:::i;:::-;63643:13;:52;63725:12;;:29;;63742:11;63725:29;:16;:29;:::i;:::-;63710:12;:44;-1:-1:-1;63210:556:0;63778:10;;:62;;;-1:-1:-1;;;;;63778:62:0;;63806:10;63778:62;;;;63826:4;63778:62;;;;;;;;;;;;-1:-1:-1;;;;;63778:10:0;;;;:27;;:62;;;;;:10;;:62;;;;;;;;:10;;:62;;;5:2:-1;;;;30:1;27;20:12;5:2;63778:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;63870:11:0;;;63858:45;;;-1:-1:-1;;;;;63858:45:0;;63892:10;63858:45;;;;;;;;-1:-1:-1;;;;;63870:11:0;;;;-1:-1:-1;63858:33:0;;-1:-1:-1;63858:45:0;;;;;;;;;;;;;;63870:11;;63858:45;;;5:2:-1;;;;30:1;27;20:12;5:2;63858:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;63858:45:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;63858:45:0;63857:46;63853:134;;;63932:11;;;63920:55;;;-1:-1:-1;;;;;63920:55:0;;63955:10;63920:55;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63932:11:0;;;;63920:34;;63955:10;;63967:7;;63920:55;;;;;;;;;;;;;;63932:11;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;63920:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;63920:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;63920:55:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;63853:134:0;64013:10;63997:27;;;;:15;:27;;;;;;;;;64027:3;63997:33;;64046:30;;;;;;;;;;;;;;;;;68065:1;;;;;62460:1634;;;:::o;57158:41::-;;;;:::o;4019:136::-;4077:7;4104:43;4108:1;4111;4104:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4097:50;4019:136;-1:-1:-1;;;4019:136:0:o;4935:471::-;4993:7;5238:6;;5234:47;;;-1:-1:-1;5268:1:0;5261:8;;5234:47;5305:5;;;5309:1;5305;:5;5329;;;;;;;;:10;5321:56;;;;-1:-1:-1;;;;;5321:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5874:132;5932:7;5959:39;5963:1;5966;5959:39;;;;;;;;;;;;;;;;;:3;:39::i;3563:181::-;3621:7;3653:5;;;3677:6;;;;3669:46;;;;;-1:-1:-1;;;;;3669:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;51340:176;51449:58;;;-1:-1:-1;;;;;51449:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;51449:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;179:29;160:49;;51423:85:0;;51442:5;;51423:18;:85::i;:::-;51340:176;;;:::o;2225:106::-;2283:7;2314:1;2310;:5;:13;;2322:1;2310:13;;;-1:-1:-1;2318:1:0;;2225:106;-1:-1:-1;2225:106:0:o;4492:192::-;4578:7;4614:12;4606:6;;;;4598:29;;;;-1:-1:-1;;;;;4598:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;4598:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4650:5:0;;;4492:192::o;6536:345::-;6622:7;6724:12;6717:5;;;6709:28;;;;-1:-1:-1;;;;;6709:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;6709:28:0;;6748:9;6764:1;6760;:5;;;;;;;;;6536:345;-1:-1:-1;;;;;6536:345:0:o;53379:1114::-;53983:27;53991:5;-1:-1:-1;;;;;53983:25:0;;:27::i;:::-;53975:71;;;;;;;-1:-1:-1;;;;;53975:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54120:12;54134:23;54169:5;-1:-1:-1;;;;;54161:19:0;54181:4;54161:25;;;;;;;;;;;;;36:153:-1;66:2;58:11;;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;54161:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;54119:67:0;;;;54205:7;54197:52;;;;;;;-1:-1:-1;;;;;54197:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54266:17;;:21;54262:224;;54408:10;54397:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54397:30:0;54389:85;;;;;;-1:-1:-1;;;;;54389:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53379:1114;;;;:::o;17332:619::-;17392:4;17860:20;;17703:66;17900:23;;;;;;:42;;-1:-1:-1;;17927:15:0;;;17892:51;-1:-1:-1;;17332:619:0:o;56636:13351::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

bzzr://d5fac7a3e08588b0564549ba4e6f5d447559ed4757d92d1b7a28853191f3aabf