Contract 0x8a0c542ba7bbbab7cf3551ffcc546cdc5362d2a1

 
Txn Hash
Block
From
To
Value [Txn Fee]
0x066983a02789ce5f906aff9abc7c239c004087409de8e56649439e2678a509e282326782021-06-12 12:20:233 mins ago0x60f4c86457c1954c0ca963dc03534c3311967beb IN  Cryptoz: CRYPTOZ Token0 BNB0.001454875
0x7fc624ecbea5b382ad9c70a445f298f70a40e465d40b0f57cfa8766e830bf0a682326772021-06-12 12:20:203 mins ago0x60f4c86457c1954c0ca963dc03534c3311967beb IN  Cryptoz: CRYPTOZ Token0 BNB0.001529255
0x84a58e8674447a7e018d3974d2a084ccfed8fb8ffc5d320e028eabeaee87259e82326722021-06-12 12:20:053 mins ago0x60f4c86457c1954c0ca963dc03534c3311967beb IN  Cryptoz: CRYPTOZ Token0 BNB0.000252995
0xf89322dfb7b7d9d6c4473955e52cc40a59534faa91f32955fe0d3707ade010a882322402021-06-12 11:58:1025 mins ago0x32306ef4574229801ff41a82f7f933d6363e0b7d IN  Cryptoz: CRYPTOZ Token0 BNB0.0002245
0x2f3397705627b008c9cb9c160156491f187bc1e96dc9ddae7e29d7b0c241f3d682320522021-06-12 11:48:4635 mins ago0xc252d48781abb4022dc299bf2767f2b901dcf5f4 IN  Cryptoz: CRYPTOZ Token0 BNB0.000177995
0xe7259747a05f19327e0cf5e69aa8b56cc6a67494075f72a7b15b9a4b5aaf1d4a82310572021-06-12 10:59:011 hr 25 mins ago0xdab1b872e0cad5c6fb98d94610d149bc71aa789f IN  Cryptoz: CRYPTOZ Token0.001 BNB0.001712105
0x0e0fbc674f7ca64a45ccfaed922e621ffeb38b2c19d5579afca42d37a90ddc4782310442021-06-12 10:58:221 hr 25 mins ago0xdab1b872e0cad5c6fb98d94610d149bc71aa789f IN  Cryptoz: CRYPTOZ Token0 BNB0.00166622
0x9f426b8bd5407402f5ea861ddddaf14f507999c3b1a6531ba44baf4ab1fff2b582309622021-06-12 10:54:161 hr 29 mins ago0xdab1b872e0cad5c6fb98d94610d149bc71aa789f IN  Cryptoz: CRYPTOZ Token0.001 BNB0.001712105
0x24f719bfc3c79a98c05cc1dffb19ab993f0e2eace6377649e057e9438f44976782306672021-06-12 10:39:311 hr 44 mins ago0x2136184d88f0e711f59098586511e60005404db8 IN  Cryptoz: CRYPTOZ Token0 BNB0.000177995
0xdec6ec4de1a3b11f9ffb65696b072b9b260f8ce20d5472a5272beb10cb83b3b482294422021-06-12 9:37:272 hrs 46 mins ago0xa958a06015002282cfda768eb4d4910836514d66 IN  Cryptoz: CRYPTOZ Token0 BNB0.001454875
0x7f8178042d3834063b76d5c9e795f6104c2428d5a7efacd5ba27cbce835fe3fb82294362021-06-12 9:37:092 hrs 46 mins ago0xa958a06015002282cfda768eb4d4910836514d66 IN  Cryptoz: CRYPTOZ Token0 BNB0.001529875
0x6ec00dc03aa00d88fa6ffb4388eb65bb3c56b75bf1e1c211d2240ca43b348e6382294152021-06-12 9:36:062 hrs 47 mins ago0xa958a06015002282cfda768eb4d4910836514d66 IN  Cryptoz: CRYPTOZ Token0 BNB0.000252995
0xf727c85b90e68a34f244129e87cbb4944a32b350ddf515f17305fb17b2e869ff82282082021-06-12 8:35:453 hrs 48 mins ago0xa826fad3dfcf189fa8818a4629c357923c5c6d27 IN  Cryptoz: CRYPTOZ Token0 BNB0.000177995
0x9be51c42b5cde10a04c2c8a751d9ecdb2467c7a5a56c4a3a01f48c8bab32167d82279682021-06-12 8:23:454 hrs ago0xe859fb2d6f01172a9f6fb44ca223fea1cd11be1f IN  Cryptoz: CRYPTOZ Token0 BNB0.001454625
0x86953b56cdbbd9179b281ec314d45c82c81b760fbf98bd03da20694998d1480b82279562021-06-12 8:23:094 hrs ago0xe859fb2d6f01172a9f6fb44ca223fea1cd11be1f IN  Cryptoz: CRYPTOZ Token0 BNB0.001529255
0x11c1d2ea245f06e441dd0ad6f2c5f2b62e8fdb066431582a610724e8c24708be82279542021-06-12 8:23:034 hrs 1 min ago0x6fd18ba5580edc3b4669e49753bd86dccdb6b1fe IN  Cryptoz: CRYPTOZ Token0 BNB0.001529875
0x017a08dd7a0f99d77d5bbaa2e17714cb6858eaa22b992bd29422a928b0f9967482279462021-06-12 8:22:394 hrs 1 min ago0xe859fb2d6f01172a9f6fb44ca223fea1cd11be1f IN  Cryptoz: CRYPTOZ Token0 BNB0.000252995
0xdc1d6b7cf1f55cdb7c7d6a2aa7a359ea7b852b2276e966621c8db22731b59ff882279392021-06-12 8:22:184 hrs 1 min ago0x6fd18ba5580edc3b4669e49753bd86dccdb6b1fe IN  Cryptoz: CRYPTOZ Token0 BNB0.000177995
0x60655f683933cf7c1209fc526d0c7cfbc0f44bc58c441de3222afff54b9485da82277702021-06-12 8:13:514 hrs 10 mins ago0xff5685ad020b5d97d80382707c56f68920d793f4 IN  Cryptoz: CRYPTOZ Token0 BNB0.001529875
0x2de3d05b131309295adb18943ab11e4e4c1882385abfeb933c41dae481cdec6582277422021-06-12 8:12:274 hrs 11 mins ago0xff5685ad020b5d97d80382707c56f68920d793f4 IN  Cryptoz: CRYPTOZ Token0 BNB0.000177995
0xacfab68709b7846d055b3636160f0857738a64a7feaf2dab4fddeb65af01670982260852021-06-12 6:49:345 hrs 34 mins ago0xb60f9fbc25b2fbc448187a7b54d1cb9bddb24868 IN  Cryptoz: CRYPTOZ Token0 BNB0.0002245
0x2f7d1304d9184a63219ac03fe1aed1d39bc405a5d3a5a79ee132cfe4838fe8a982258362021-06-12 6:37:045 hrs 46 mins ago0x77ffe92c6547e6e2e5651991ba5804db085769df IN  Cryptoz: CRYPTOZ Token0.002 BNB0.001609755
0x1ed672a7e02bca5aef6a99ba020f66ad184df80bf557349dda196ac532020eb282258182021-06-12 6:36:105 hrs 47 mins ago0x77ffe92c6547e6e2e5651991ba5804db085769df IN  Cryptoz: CRYPTOZ Token0 BNB0.001454255
0x78cb6afc8ec28259be674336823c66858077b6f45c6e10605050fcd3ee9937a382258142021-06-12 6:35:585 hrs 48 mins ago0x77ffe92c6547e6e2e5651991ba5804db085769df IN  Cryptoz: CRYPTOZ Token0 BNB0.001529875
0x75986e93b580e541b99734ac5af1a7262ac596f106a7f66ff28893ae6c06ec5682258102021-06-12 6:35:465 hrs 48 mins ago0x77ffe92c6547e6e2e5651991ba5804db085769df IN  Cryptoz: CRYPTOZ Token0 BNB0.001529875
[ Download CSV Export 

OVERVIEW

CryptoZ offers NFT collection whereby each minted NFT Cryptoz card is a unique token on the BSC. Collectors can buy, sell, and exchange both their Cryptoz NFT cards and CZXP tokens through any standards compliant wallets, markets, game engines, exchanges, DeFi and other future inventions.

Latest 18 internal transactions
Parent Txn Hash Block From To Value
0x4816be92c90021dc5d14942435c12673165334936017e6369f5a5485148facca71135382021-05-03 23:12:0039 days 13 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer3.028 BNB
0x17bfd11f8c2cabb8122650aa7a09c269960f083db6a92d49347efd312ab5a8aa69305752021-04-27 13:04:1645 days 23 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer6.999 BNB
0xc576215089eb0b9cea566015fee4e0b15f1eeb092db2e1a5c1e21d33083281bc67358442021-04-20 16:47:3252 days 19 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer6.7255 BNB
0xedf0cfe37effad19a14d998a732f65f010974061fd6d6c94cda6161a89786e6665339392021-04-13 16:04:5859 days 20 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer5.398 BNB
0xfef15a4d035542d8a879f5b3efbee2261c478400f0cd9684079fa5828eb8edd864318432021-04-10 2:52:5263 days 9 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer6.7705 BNB
0x48f2e0324cac33856d20584161fdc5cb7d85bdf88d0c61e7c06d75f0934ce1d263318932021-04-06 13:18:1866 days 23 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer10.476 BNB
0x118cf9fc0c743c530d64c8d13bcdcc84d162ccbc96039660f9aa1ee84c62bb7961348622021-03-30 15:16:5273 days 21 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer19.2955 BNB
0x0754fe590d00a68b722314f88eb6e6b1276a2b14ab71abdda67b282c2112698659173522021-03-23 0:27:4181 days 11 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer22.678 BNB
0x041d3efc3a9bb6cf5c4eb65eac7b61edf758d26a88cae494410f27579bd21d6c58464332021-03-20 13:00:3483 days 23 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer20.421 BNB
0xa604fd9d441d670f3ce063ec55154b42a3db59f3f8c9571ab33af0230350a87957498102021-03-17 4:24:3487 days 7 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer19.988 BNB
0xde58c01955302fa2f18c9bc9da961a3f8e0e3f928f4d93bd3c67ed2cd75af8e657053562021-03-15 15:19:5388 days 21 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer20.9481 BNB
0xa6ffe47d4a10660162517dd38f5b5e2c55041e537625c760ea398619824c297c56849882021-03-14 22:19:4789 days 14 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer20.104 BNB
0x55d761c918e0b7bff67c7e891f78ecf28afff889ea6bd133a9673f68649bc84656756412021-03-14 14:32:1589 days 21 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer20.5256 BNB
0x353c835776f8d968c3712d3d6bc4cd2ae92b7df855f01bd47f467ec5ad9b1b2856666652021-03-14 7:02:4290 days 5 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer18.0712 BNB
0xbfaab43c9dc11acea953521c2ecc94bc3b1d50cbee82a7f40a756b7207c10a1d56502462021-03-13 17:20:4990 days 19 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer18.6511 BNB
0x4f23999d169d5c4f8d380eaadd51ab41da1c8d65a9734a965a6045192a28d13656283772021-03-12 23:02:4991 days 13 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer1.185 BNB
0x7181e94a3346504f916e51b794d6d25aa089b41d6e605395643005dc25ef680e56257352021-03-12 20:48:2491 days 15 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer3.405 BNB
0xa09260ab3a4bc6d4d1e0a807c6b5850214297ae22a815f5ddfa066a704267ad255767972021-03-11 3:58:1093 days 8 hrs ago Cryptoz: CRYPTOZ TokenCryptoz: Deployer4.458 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Cryptoz

Compiler Version
v0.5.9+commit.c68bc34e

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-11
*/

// 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/token/ERC20/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);

    /**
     * @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: @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/token/ERC20/ERC20.sol

pragma solidity ^0.5.0;




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

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for `sender`'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

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

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }
}

// File: contracts/CZXPToken.sol

pragma solidity ^0.5.0;

/******************************************

Our Matra our Motto for coding The Cryptoz Universe.

      Fail EARLY and Fail LOUD !!!!!!!

1.    First - Check all pre-conditions
2.    Then  - make changes to contract state
3.    Final - interact with other contracts

Pull funds over pushing them
Platform limits like max of 1023 loop interations.

all Events start with Log

******************************************/



contract CzxpToken is Ownable,ERC20 {

//1. Condition
//2. Effects
//3.Interaction
    
    /*
    * We accept payment for the token generation event only
    * Rules:
    *   Founders-pre:        6000000
    *   TGE - max   :     1000000000
    *   start is    :    Mar  9,2021
    *   end is      :        No date
    *   min         :  0.0000001 BNB
    *   max         :          1 BNB
    *   max wallets :            100
    */



// Advisor+team wallets
    address[] advisors = [
         0x60D7a79367B35573B27E4F020794AEF299E9fd49, //owner
         0x591D4Fe5f1e147eac7b144C43e4f2A0d83a4DF84, //M
         0x4b01629a1bAf82D8aB62726776b1332539E51cEc  //R
    ];

// Public variables of the token
    string public name          = "Cryptoz eXPerience";
    string public symbol        = "CZXP";
    uint8  public decimals      = 0;
    uint8  public walletCounter = 0;
    
//Storage
    //supporters
    mapping (address => uint256) public contributions;    // BNB contributed per address

//TGE restrictions
    //Token Generation event
    bool public isTGE = false;
    bool public TGEcomplete = false;
    uint256 maxCap = 1000000000000000000; //in wei
    
//Our external cryptozContract
    address private cryptozContract;
    
    //MODIFIERS
    modifier checkTGE(){
        require(isTGE);
        _;
    }
    
    modifier onlyAuthorizedContract(){
        require(msg.sender == cryptozContract,"Caller not authorized for this action");
        _;
    }
    
    // ALL FUNCTIONS
    function() external {
        revert();
    }

    
    function setCryptozContract(address _cryptozContract) public onlyOwner{
        require(_cryptozContract != address(0x0));
        cryptozContract = _cryptozContract;
    }
    
    function getCrypozContractAddress() public view returns(address){
        return cryptozContract;
    }

    /*
    *   Make sure we accept payment only during TGE
    */
    function buy() payable checkTGE external {
        require(walletCounter < 101, "A maximum of 100 unique wallets has been reached");
        require(msg.sender != address(0));
        
        //We dont offer less than 1 czxp
        require(msg.value >= 0.0000001 ether,"Contribution must be greater than 0.0000001");
        
        //Check contributor is under the cap
        require(contributions[msg.sender] <= maxCap,"Contribution is over the maximum of 1 BNB");
        
        //if contribution+balance is >= cap
        uint allowedContribution = 0;
        if((msg.value+contributions[msg.sender]) >= maxCap){
            allowedContribution = maxCap - contributions[msg.sender];
        }else{
            allowedContribution = msg.value;
        }
        
        //sanity ??
        require(allowedContribution > 0);
        
        //track total wallets
        if(contributions[msg.sender] == 0) {
            walletCounter++;
        }
        
        //Finally increment the contributor
        contributions[msg.sender] = contributions[msg.sender].add(allowedContribution);
        
        //all good ?  give tokens
        _mint(msg.sender, convertWeiToCZXP(allowedContribution));
    }
    
    /**
     *  One time event to give token allocations to our advisors ONCE when TGE is activated
     */
     
    function mintAdvisorTokens() internal checkTGE {
        
        
        //100K to each advisor, update to maxed out
        for(uint8 i=0; i < advisors.length; i++){
            contributions[advisors[i]] = maxCap;
            _mint(advisors[i], 20000000);
        }
    }
    
    /**
     *  Turn on TGE and then lock it forever when turned off
     */
     
    function flipTGE() public onlyOwner returns(bool) {
        require(!TGEcomplete);
        
        if(!isTGE){
            isTGE = true;
            mintAdvisorTokens();
        }else{
            isTGE = false;
            TGEcomplete = true;
        }
        return true;
    }
    
   
   /**
    * Our base conversion rate for the TGE
    */
    function convertWeiToCZXP(uint weiToConvert) pure internal returns (uint) {
        // 1 czxp = 100000000000 wei;
        return weiToConvert/100000000000;
    }
    
    /**
     *  Called in from our ERC721 contract actions
     *
     */
     function awardCzxp(address _to, uint256 _amount) public onlyAuthorizedContract {
         require(_to != address(0));
         require(_amount > 0);
         
         _mint(_to, _amount);
     }
     
    /**
     *  Called in from our ERC721 contract actions
     *
     */
     function burnCzxp(address _wallet, uint256 _amount) public onlyAuthorizedContract {
         require(_wallet != address(0));
         require(_amount > 0);
         
         _burn(_wallet, _amount);
     }
    
    /**
    * @dev Returns the amount contributed so far by a sepecific user.
    * @param _beneficiary Address of contributor
    * @return User contribution so far
    */
    function getUserContribution(address _beneficiary) public view returns (uint256) {
        return contributions[_beneficiary];
    }
    
       
   /**
    * Withdraw balance to wallet
    */
   function withdraw() public onlyOwner returns(bool) {
      msg.sender.transfer(address(this).balance);
      return true;
   }

}

// File: contracts/CryptozUniverse.sol

pragma solidity ^0.5.0;

/******************************************

Our Matra our Motto for coding The Cryptoz Universe.

      Fail EARLY and Fail LOUD !!!!!!!

1.    First - Check all pre-conditions
2.    Then  - make changes to contract state
3.    Final - interact with other contracts

Pull funds over pushing them
Platform limits like max of 1023 loop interations.

all Events start with Log

******************************************/




contract CryptozUniverse is Ownable {
    using SafeMath for uint256;

//Definitons
    struct cardType{
        uint32 cardTypeId;
        string name;
        string set;
        //uint8 assetType; //1=human,2=animal,3=plant, 4=thing
        //uint8 notStoreOrBonus; //0 =inStore, 1 = pack, 2= bonus
        //uint8 rarity; //1 = diamond,6 = common
        //uint16 totalAvailable;
        uint256 weiCost;
        uint256 buyCzxp;
        uint256 transferCzxp;
        uint256 sacrificeCzxp;
        uint256 unlockCzxp;
        uint8 cardLevel;
    }

    struct Card{
        uint32 cardTypeId;
        uint256 editionNumber;
        uint256 transferCount;
    }

    string baseTokenURI = 'https://cryptoz.cards/data/'; //append ID on
//storage

    //Containers for the card types
    mapping(uint256 => uint8) cardAssetType;
    mapping(uint256 => uint8) storeBoosterBonus;
    mapping(uint256 => uint8) public rarity; // lookup cardTypeId return rarity
    mapping(uint256 => uint16) totalAvailable;

    //All the cards in the Cryptoz Universe
    Card[] internal Cards;

    mapping(uint32 => cardType) public allCardTypes;        // All card type definitions
    uint256[] public cardTypesIds; //Just an array of all the id

    //track editionNumberTotal, always increments, starts at 1
    mapping(uint256 => uint256) public cardTypeToEdition;

// Event Logs
    event CZXPGained(address indexed beneficiary, uint256 czxpAmount);

//Other variables we need
    address payable internal CzxpContractAddress_;


    /**
     * Not much going on here so exit.
     */
    function() external{
        revert();
    }

    /**
     *
     */
     function getTotalTypes() public view returns(uint){
         return cardTypesIds.length;
     }

    /**
     *  Internal function called from Cryptoz once all the checks are done
     */
    function awardCzxp(address _beneficiary, uint czxpReward) internal {
        //Give the czxp tokens
        CzxpToken(CzxpContractAddress_).awardCzxp(_beneficiary, czxpReward);
    }

    /**
     * Random as it gets for now. Return a val between 1-10000
     */
    uint nonce = 0;
    function selectRandom(uint256 range) internal returns (uint) {
        uint randomnumber = uint(keccak256(abi.encodePacked(now, msg.sender, nonce))) % range;
        nonce++;
        return randomnumber;
    }
    
    function getProbs(uint wager) internal returns (uint16,uint16,uint16,uint16)  {
        
        uint8[4] memory group = [1,2,3,4];
        uint8[4] memory Fac = [1,2,6,24];
        uint[4] memory DistGroup;
        uint16[4] memory FinalProbs;

        for(uint i=0; i<4; i++){
            DistGroup[i] = (((getLambda(wager)**group[i]) / getLambda(wager)) / Fac[i]) * 100;
        }
        
        uint DistTotal = DistGroup[0] + DistGroup[1] + DistGroup[2] + DistGroup[3];
        
        for(uint j=0; j<4; j++){
            FinalProbs[j] = uint16(DistGroup[j] * 10000 / DistTotal);
        }
        return(FinalProbs[0],FinalProbs[1],FinalProbs[2],FinalProbs[3]);
    }
    
    function getLambda(uint wager) internal returns (uint) {
        uint Dist   = log2(wager / 280000);
        return Dist / 4;
    }
    
    function log2(uint x) internal returns (uint y){
       assembly {
            let arg := x
            x := sub(x,1)
            x := or(x, div(x, 0x02))
            x := or(x, div(x, 0x04))
            x := or(x, div(x, 0x10))
            x := or(x, div(x, 0x100))
            x := or(x, div(x, 0x10000))
            x := or(x, div(x, 0x100000000))
            x := or(x, div(x, 0x10000000000000000))
            x := or(x, div(x, 0x100000000000000000000000000000000))
            x := add(x, 1)
            let m := mload(0x40)
            mstore(m,           0xf8f9cbfae6cc78fbefe7cdc3a1793dfcf4f0e8bbd8cec470b6a28a7a5a3e1efd)
            mstore(add(m,0x20), 0xf5ecf1b3e9debc68e1d9cfabc5997135bfb7a7a3938b7b606b5b4b3f2f1f0ffe)
            mstore(add(m,0x40), 0xf6e4ed9ff2d6b458eadcdf97bd91692de2d4da8fd2d0ac50c6ae9a8272523616)
            mstore(add(m,0x60), 0xc8c0b887b0a8a4489c948c7f847c6125746c645c544c444038302820181008ff)
            mstore(add(m,0x80), 0xf7cae577eec2a03cf3bad76fb589591debb2dd67e0aa9834bea6925f6a4a2e0e)
            mstore(add(m,0xa0), 0xe39ed557db96902cd38ed14fad815115c786af479b7e83247363534337271707)
            mstore(add(m,0xc0), 0xc976c13bb96e881cb166a933a55e490d9d56952b8d4e801485467d2362422606)
            mstore(add(m,0xe0), 0x753a6d1b65325d0c552a4d1345224105391a310b29122104190a110309020100)
            mstore(0x40, add(m, 0x100))
            let magic := 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff
            let shift := 0x100000000000000000000000000000000000000000000000000000000000000
            let a := div(mul(x, magic), shift)
            y := div(mload(add(m,sub(255,a))), shift)
            y := add(y, mul(256, gt(arg, 0x8000000000000000000000000000000000000000000000000000000000000000)))
        }
    }
}

// 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/Strings.sol

pragma solidity ^0.5.0;

library Strings {
  // via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
  function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory) {
      bytes memory _ba = bytes(_a);
      bytes memory _bb = bytes(_b);
      bytes memory _bc = bytes(_c);
      bytes memory _bd = bytes(_d);
      bytes memory _be = bytes(_e);
      string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
      bytes memory babcde = bytes(abcde);
      uint k = 0;
      for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
      for (uint i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
      for (uint i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
      for (uint i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
      for (uint i = 0; i < _be.length; i++) babcde[k++] = _be[i];
      return string(babcde);
    }

    function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory) {
        return strConcat(_a, _b, _c, _d, "");
    }

    function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
        return strConcat(_a, _b, _c, "", "");
    }

    function strConcat(string memory _a, string memory _b) internal pure returns (string memory) {
        return strConcat(_a, _b, "", "", "");
    }

    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
}

// File: contracts/CryptozCard.sol

pragma solidity ^0.5.0;




/*
interface ERC165 {
 /// @notice Query if a contract implements an interface
 /// @param interfaceID The interface identifier, as
 ///  specified in ERC-165
 /// @dev Interface identification is specified in
 ///  ERC-165. This function uses less than 30,000 gas.
 /// @return `true` if the contract implements `interfaceID`
 ///  and `interfaceID` is not 0xffffffff, `false` otherwise
 function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
*/

/**
 * @title Full ERC721 Token
 * This implementation includes all the required and some optional functionality of the ERC721 standard
 * Moreover, it includes approve all functionality using operator terminology
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract CryptozCard is CryptozUniverse, ERC721Enumerable {
    
  // Token name
  string internal name_ = "Cryptoz Cards";

  // Token symbol
  string internal symbol_ = "Cryptoz";

  // Mapping from owner to list of owned token IDs
  mapping(address => uint256[]) internal ownedTokens;

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

  // Array with all token ids, used for enumeration
  uint256[] internal allTokens;

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

  // Optional mapping for token URIs
  mapping(uint256 => string) internal tokenURIs;
  
  //Track all tokens by rarity
  uint[7] public tokensByRarity = [0,0,0,0,0,0,0]; //[rarity] = total

  /*CRYPTOZ Overrides*/

  //Event Logs
  event LogCardCreated(address indexed owner, uint indexed cardTokenId, uint editionNumber, uint indexed cardTypeId, uint8 rarity, uint CzxpGained);
  event SacrificeCardEvent(address indexed owner, uint indexed cardTokenId, uint indexed cardTypeId, uint CzxpGained);

  // Track ownership of Card Type purchases from store to enforce 1 type per person once
  mapping (address => mapping(uint => bool)) public cardTypesOwned; //    [address][CardTypeId] = bool

  /**
   * @dev Gets the token name
   * @return string representing the token name
   */
  function name() external view returns (string memory _name) {
    return name_;
  }

  /**
   * @dev Gets the token symbol
   * @return string representing the token symbol
   */
  function symbol() external view returns (string memory _symbol) {
    return symbol_;
  }

  /**
   * @dev Returns an URI for a given token ID
   * @dev Throws if the token ID does not exist. May return an empty string.
   * @param _tokenId uint256 ID of the token to query
   */
  function tokenURI(uint256 _tokenId) external view returns (string memory) {
    return Strings.strConcat(
        baseTokenURI,
        Strings.uint2str(_tokenId)
    );
  }

  /**
   * @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));
    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
   * @dev 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());
    return allTokens[_index];
  }

  /**
   * @dev Internal function to set the token URI for a given token
   * @dev Reverts if the token ID does not exist
   * @param _tokenId uint256 ID of the token to set its URI
   * @param _uri string URI to assign
   */
  function _setTokenURI(uint256 _tokenId, string memory _uri) internal {
    require(_exists(_tokenId));
    tokenURIs[_tokenId] = _uri;
  }

  /**
   * @dev Internal function to mint a new token
   * @dev 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 by the msg.sender
   */
  function _mint(address _to, uint256 _tokenId) internal {
    super._mint(_to, _tokenId);

    allTokensIndex[_tokenId] = allTokens.length;
    allTokens.push(_tokenId);
  }

  /**
   * @dev Internal function to burn a specific token
   * @dev Reverts if the token does not exist
   * @param _owner owner of the token to burn
   * @param _tokenId uint256 ID of the token being burned by the msg.sender
   */
  function _burn(address _owner, uint256 _tokenId) internal {
    
    super._burn(_owner, _tokenId);

    // Clear metadata (if any)
    if (bytes(tokenURIs[_tokenId]).length != 0) {
      delete tokenURIs[_tokenId];
    }

    // Reorg all tokens array
    uint256 tokenIndex = allTokensIndex[_tokenId];
    uint256 lastTokenIndex = allTokens.length.sub(1);
    uint256 lastToken = allTokens[lastTokenIndex];

    allTokens[tokenIndex] = lastToken;
    allTokens[lastTokenIndex] = 0;

    allTokens.length--;
    allTokensIndex[_tokenId] = 0;
    allTokensIndex[lastToken] = tokenIndex;

    //track rarity totals
    tokensByRarity[rarity[Cards[_tokenId].cardTypeId]] = tokensByRarity[rarity[Cards[_tokenId].cardTypeId]] - 1;

    // Gain czxp for sacrificing card
    uint256 sacrificeCzxp = allCardTypes[Cards[_tokenId].cardTypeId].sacrificeCzxp;
    awardCzxp(msg.sender,sacrificeCzxp);
    
     //remove from universe
    delete Cards[_tokenId];
    
    emit SacrificeCardEvent(msg.sender, _tokenId, Cards[_tokenId].cardTypeId, sacrificeCzxp);
  }

    /*CRYPTOZ Overrides */

    function _transferFrom(address from, address to, uint256 tokenId) internal {
        super._transferFrom(from, to, tokenId);
    }
    
    

    /**
     *  Public method to allow file transfer, we call our internal function
     */
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isApprovedOrOwner(msg.sender, tokenId));
        
        //Lets track the card transfers
        Cards[tokenId].transferCount += 1;
        
        _transferFrom(from, to, tokenId);
    }

    /**
    *   Create the Card for the owner
    */
    function _createCard(uint32 _cardTypeId, address _owner, uint czxpGained) internal returns (uint){
        //make sure we have a definition for this card
        require(allCardTypes[_cardTypeId].cardTypeId == _cardTypeId);

        //Increment edition number
        cardTypeToEdition[_cardTypeId] = cardTypeToEdition[_cardTypeId].add(1);

        //Create the card!
        Card memory _tempCard = Card({
            cardTypeId:_cardTypeId,
            editionNumber:cardTypeToEdition[_cardTypeId],
            transferCount:0
        });

        //add to the universe and get the ID, -1 for array offset
        uint256 _newCardId = Cards.push(_tempCard) - 1;

        //Give the ERC721 Card
        _mint(_owner,_newCardId);

        //Set the Metadata for this new token
        _setTokenURI(_newCardId, baseTokenURI);
        
        //track rarity
        uint8 _temp_rarity = rarity[_cardTypeId];
        tokensByRarity[_temp_rarity] = tokensByRarity[_temp_rarity] + 1;
        
        //Emit card created owner,tokenId,Edition of Token,Card type,czxp gained
        emit LogCardCreated(_owner, _newCardId, cardTypeToEdition[_cardTypeId], _cardTypeId, rarity[_cardTypeId], czxpGained);
        
        return _newCardId;
    }
    

    //Get a list of all the CardIDs( tokenIDs ) this user owns
    function tokensOfOwner(address _owner) external view returns(uint256[] memory ownerTokens) {
        return _tokensOfOwner(_owner);
    }
    
    //Get total tokens by rarity. diamond,platinum,epic,rare,uncommon,common
    function getTokensByRarity() external view returns(uint,uint,uint,uint,uint,uint) {
        return(tokensByRarity[1],tokensByRarity[2],tokensByRarity[3],tokensByRarity[4],tokensByRarity[5],tokensByRarity[6]);
    }
    
    //Get the info about the card
    function getOwnedCard(uint256 _tokenId) public view returns(uint32, uint, uint) {
        require(_exists(_tokenId));
        return (Cards[_tokenId].cardTypeId,Cards[_tokenId].editionNumber,Cards[_tokenId].transferCount);
    }
}

// File: contracts/Cryptoz.sol

pragma solidity ^0.5.0;

/******************************************

Our Matra our Motto for coding The Cryptoz Universe.buy

      Fail EARLY and Fail LOUD !!!!!!!

1.    First - Check all pre-conditions
2.    Then  - make changes to contract state
3.    Final - interact with other contracts

Pull funds over pushing them
Platform limits like max of 1023 loop interations.

all Events start with Log

******************************************/


contract Cryptoz is CryptozCard {

//Constants
    uint constant public weiCostOfCard = 2000000000000000; //booster in wei = 0.002 ETH
    uint constant public czxpGainedBoosterPurchase = 120;
    uint constant public maxCardTypes = 5000; //allowed types in the Universe
    uint constant public maxBoostersReward = 50000; // Promotional boosters for airdrop rewards

//Event Logs
    event LogCardTypeLoaded(uint32 indexed cardTypeId, string cardName);
    event LogCardPurchased(uint32 indexed cardTypeId, uint editionNumber, address indexed buyer);
    event LogPackOpened(address indexed buyer, uint packsOpened);
    event LogSponsorLinked(address sponsor, address affiliate);
    event LogSponsorReward(address sponsor, address affiliate, uint CzxpReward);
    event LogDailyReward(address player, uint newBonusBalance);
    event LogRewardBoosters(address winner, uint boostersAwarded);

//storage

    //Track the total amount of Booster rewards
    uint public totalBoostersRewarded = 0;
    
    //Tracking affiliate sponsors
    mapping(address => address) public sponsors; // 1 sponsor can have many affiliates, but only 1 sponsor, returns sponsor
    
    //Track the timestamps for users to get their daily pull
    mapping(address => uint) private timeToCardsPull; //address to timestamp
    
    //Tracking booster pack count ownership. These are NOT tokens, Play can mint a random card
    mapping (address => uint256) public boosterPacksOwned;
    
    //where we hold inventory of the  booster packs
    mapping(uint8 => uint32[]) private allBoosterCardIds; // [rarityId][cardId]
    
    //check if cardType exists
    modifier isValidCard(uint32 _cardTypeId) {
//TIGHTEN   //Make sure cardType exists and we dont have bad data coming in
        require(allCardTypes[_cardTypeId].cardTypeId == _cardTypeId);
        require(storeBoosterBonus[_cardTypeId] < 1); //you cant get cards marked for booster pack or bonus
        _;
    }
    
    function() external {
        revert();
    }

    //Set our cxzp contract in the constructor
    function initialize(address payable _czxpContractAddress) onlyOwner public {
        CzxpContractAddress_ = _czxpContractAddress;
    }

    function loadNewCardType(
            uint8 _cardTypeId,
            string calldata _name,
            string calldata _set,
            uint8 _assetType,
            uint8 _notStoreOrBonus,
            uint8 _rarity,
            uint16 _totalAvailable,
            uint256 _weiCost,
            uint256 _buyCzxp
        ) external onlyOwner returns(bool){
            
        //what requires should we add ?
        
        //a max. of 5000 types in the universe ever
        require(cardTypesIds.length <= maxCardTypes);
        
        //not allowed to update existing cardTypeIds
        require(allCardTypes[_cardTypeId].cardTypeId == 0);
        
        allCardTypes[_cardTypeId].cardTypeId    = _cardTypeId;
        allCardTypes[_cardTypeId].name          = _name;
        allCardTypes[_cardTypeId].set           = _set;
        cardAssetType[_cardTypeId]              = _assetType;
        storeBoosterBonus[_cardTypeId]          = _notStoreOrBonus;
        rarity[_cardTypeId]                     = _rarity;
        totalAvailable[_cardTypeId]             = _totalAvailable;
        allCardTypes[_cardTypeId].weiCost       = _weiCost;
        allCardTypes[_cardTypeId].buyCzxp       = _buyCzxp;
    
        //If she be booster worthy
        if(_notStoreOrBonus == 1){ // 0=store,1=booster,2=bonus
            allBoosterCardIds[_rarity].push(_cardTypeId);
        }
        
        //Track the cardTypeIds count
        cardTypesIds.push(_cardTypeId);
        return true;
    }

    function addTocardType(
                        uint32  _cardTypeId,
                        uint256 _transferCzxp,
                        uint256 _sacrificeCzxp,
                        uint256 _unlockCzxp,
                        uint8 _cardLevel
                      ) external onlyOwner returns(bool){
                          
        //not allowed to update existing cardTypeIds
//TODO check for NULL in case we push 0 for a property
        require(allCardTypes[_cardTypeId].transferCzxp == 0);
        require(allCardTypes[_cardTypeId].sacrificeCzxp == 0);
        require(allCardTypes[_cardTypeId].unlockCzxp == 0);
        require(allCardTypes[_cardTypeId].cardLevel == 0);
                          
        require(allCardTypes[_cardTypeId].cardTypeId == _cardTypeId);
        
        
        allCardTypes[_cardTypeId].transferCzxp  = _transferCzxp;
        allCardTypes[_cardTypeId].sacrificeCzxp = _sacrificeCzxp;
        allCardTypes[_cardTypeId].unlockCzxp    = _unlockCzxp;
        allCardTypes[_cardTypeId].cardLevel     = _cardLevel;
        
        //initialize editionNumber
        cardTypeToEdition[_cardTypeId] = 0;
        
        //Card type is defined, now emit a Log of it
        emit LogCardTypeLoaded(_cardTypeId,allCardTypes[_cardTypeId].name);
        return true;
    }
    
    
/**
    /**
     *  Public interface to purchase a card, probablly the most insecure entry point !
     */
    function buyCard(uint32 _cardTypeId) external payable isValidCard(_cardTypeId) returns(bool) {
        
        // dont even bother if no ETH sent
        require(msg.value > 0, "Pay up!");
        
        //check for valid cardType
        require(allCardTypes[_cardTypeId].cardTypeId == _cardTypeId, "Cannot buy cards that are not defined");
        
        cardType memory _tempCard = allCardTypes[_cardTypeId];
        
        //check if store only
        require(storeBoosterBonus[_cardTypeId] == 0, "Can only buy cards from Store");
        
        //CHECKS-EFFECT, Can't buy cards you own
        require(cardTypesOwned[msg.sender][_cardTypeId] == false, "Only 1 Card Type purchase per wallet");
         
        //Check if this card amount we sell is more than edition+1 for this card type
        require((totalAvailable[_cardTypeId] >= cardTypeToEdition[_cardTypeId] + 1 ), "Maximum edition reached for this Card Type");
        
        //check if they have paid enough for it
        require(msg.value >= _tempCard.weiCost, "Not enough Ether sent to purchase this card");
        
        //check if we have enough czxp to unlock this card
        uint czxp = CzxpToken(CzxpContractAddress_).balanceOf(msg.sender);
        require(czxp >= _tempCard.unlockCzxp, "Wallet does not have enough czxp to unlock this Card Type");
        
    //Clear ? to buy the card
    
        //stop re-entrancy. Track the type of card puchased for this owner, so they cant buy again
        cardTypesOwned[msg.sender][_cardTypeId] = true;
        
        //Let the universe award our friend
        super.awardCzxp(msg.sender, allCardTypes[_cardTypeId].buyCzxp);
        
        //and award their sponsor
        rewardAffiliate(allCardTypes[_cardTypeId].buyCzxp);
    
        //Mint the real token and pass czxp gained for logging
        super._createCard(_cardTypeId, msg.sender,allCardTypes[_cardTypeId].buyCzxp);
        
        
        return true;
    }
    
    //every 8 hours, the address can get 2 free booster cards
    function getBonusBoosters() external {
        //this only runs if time to get new cards
        require(now > getTimeToDailyBonus(msg.sender), "Can't claim before time to claim next bonus");
        
        //Stop re-entrancy, update the lastpull value
        timeToCardsPull[msg.sender] = now + 8 hours;
        
        // add the boosters and emit event
        boosterPacksOwned[msg.sender] = boosterPacksOwned[msg.sender].add(2);
        emit LogDailyReward(msg.sender, boosterPacksOwned[msg.sender]);
    }
    
    /**
     *  Public interface to get card at no cost
     */
    function getFreeCard(uint32 _cardTypeId) external isValidCard(_cardTypeId) {
        //check if store only
        require(storeBoosterBonus[_cardTypeId] == 0);
        
        // ensure there is enough of a supply left
        require(totalAvailable[_cardTypeId] > (cardTypeToEdition[_cardTypeId]+1));
        
        //Can't get cards From shop that you own
        require(cardTypesOwned[msg.sender][_cardTypeId] == false);
        
        //check if we have enough czxp to unlock this card
        uint czxp = CzxpToken(CzxpContractAddress_).balanceOf(msg.sender);
        require(czxp >= allCardTypes[_cardTypeId].unlockCzxp);
        
        //Only cards that are Free
        require(allCardTypes[_cardTypeId].weiCost == 0);

//ALL CLEAR ???????? claim a new card
    
        //Stop re-entrancy, Track the type of card puchased for this owner, so they cant buy again
        cardTypesOwned[msg.sender][_cardTypeId] = true;
        
        //Let the universe award our friend
        super.awardCzxp(msg.sender, allCardTypes[_cardTypeId].buyCzxp);
        
        //reward the sponsor
        rewardAffiliate(allCardTypes[_cardTypeId].buyCzxp);
        
        //now mint the card
        super._createCard(_cardTypeId, msg.sender, allCardTypes[_cardTypeId].buyCzxp);
    
    }
    
    /**
     *  Any user can sacrifice any card they own. Please don't burn down the universe :'(
     */
     function sacrifice(uint256 _tokenId) external {
         //Call our internal burn function does all our owner checks
         _burn(msg.sender, _tokenId);
     }
    
//Booster Pack functions

    /**
     *  Public interface to award booster credits from Airdrops - restricted to Owner
    */
    function awardBoosterCredits(address _winner, uint _amount) external onlyOwner returns(bool) {
        
        //Check max. for Universe
        require((totalBoostersRewarded + _amount) <= maxBoostersReward, "Reached max. number of Booster credit rewards");
        
        //All good
        //stop re-entrance, increase universe total
        totalBoostersRewarded.add(_amount);
        
        //All good increase the number owned for this winner
        boosterPacksOwned[_winner] = boosterPacksOwned[_winner].add(_amount);
        
        //Log the event
        emit LogRewardBoosters(_winner, _amount);

        return true;
    }

 
    /**
     *  Public interface to buy booster card(s)
    */
    function buyBoosterCard(uint _amount) payable external returns(bool) {
        
        // is there enough wei sent 1 pack = 0.002 ETH ?
        require(msg.value >= weiCostOfCard.mul(_amount));
        
        //All good increase the number owned
        boosterPacksOwned[msg.sender] = boosterPacksOwned[msg.sender].add(_amount);

        //Award czxp for booster
        super.awardCzxp(msg.sender, uint(czxpGainedBoosterPurchase.mul(_amount)));
        
        rewardAffiliate(uint(czxpGainedBoosterPurchase.mul(_amount)));

        return true;
    }
    
    /**
     *  Public interface to buy booster pack(s) and open them - NO burn option
     */
    function buyBoosterCardAndOpen() payable external {
        // is there enough wei sent 1 pack = 0.005 ETH ?
        require(msg.value >= weiCostOfCard);
        
        //All good increase the number owned
        boosterPacksOwned[msg.sender] = boosterPacksOwned[msg.sender].add(1);

        //Award czxp per pack
        super.awardCzxp(msg.sender, czxpGainedBoosterPurchase);
        
        rewardAffiliate(czxpGainedBoosterPurchase);
        
        //Now open the pack
        openBoosterCard(0);
    }
    
    /**
     *  Public interface to open already purchased booster pack(s) - User can wager an amount
     */
    function openBoosterCard(uint czxpWager) public returns(bool) {
        //Ensure user owns unopened packs
        require(boosterPacksOwned[msg.sender] > 0);
        
        //czxpWager check czxpWager
        require(czxpWager >= 0);
        
        //STOP re-entrancy , decrement number of packs
        boosterPacksOwned[msg.sender] = boosterPacksOwned[msg.sender].sub(1);
        
        //Pull the card
        uint8 rarity = getRarity(czxpWager);
        pullCard(rarity);
        
        //Send a log event
        emit LogPackOpened(msg.sender, rarity);
        return true;
    }
   
    /**
     * Public interface to allow a player to forever link their 1 sponsor
     */
    function linkMySponsor(address mySponsor) external {
        //check that mySponsor arg is not 0x0
        require(mySponsor != address(0));
        
        //ensure the sponsor isn't Linked
        require(sponsors[msg.sender] == address(0));
        
        //Check they are not linking to themselves
        require(msg.sender != mySponsor);
        
        //All clear?  stop re-entrancy, set the association
        sponsors[msg.sender] = mySponsor;
        
        //Mint the Platinum Sponsor Card
        pullCard(2);
    }

//Private

    /**
     * We always pay our affiliates 20% of the czxp
     */
     function rewardAffiliate(uint totalCZXP) private  {
         //first check if the caller has a sponsor
         if(sponsors[msg.sender] != address(0)){
             uint reward = totalCZXP / 20;
             if(reward == 0){
                 reward = 1;
             }
             super.awardCzxp(sponsors[msg.sender], reward);
             emit LogSponsorReward(sponsors[msg.sender], msg.sender, reward);
         }
     }

    /**
     *
     */
     function pullCard(uint8 rarity) private {
         
         //Get a random number for the card to pull
         uint rand = selectRandom(allBoosterCardIds[rarity].length);
         
         //hit up the cardTypes
         uint32 pulledId = allBoosterCardIds[rarity][rand];
         
        //Give the player this cardType
        super._createCard(pulledId, msg.sender, 100);
     }
    
    /**
     *  Private function to diceroll the rarity pull Only from booster packs
     */
    function getRarity(uint czxpWager) private returns(uint8){
        
        //Check if below upper limit
        require(czxpWager <= 1649267441667000);
        
        //FIRST ensure, player can back their wager
        uint _playerCZXPBalance = CzxpToken(CzxpContractAddress_).balanceOf(msg.sender);
        require(_playerCZXPBalance >= czxpWager);
        
        //Check effects - Take their czxp
        if(czxpWager > 0){
            CzxpToken(CzxpContractAddress_).burnCzxp(msg.sender, czxpWager);
        }
        
        //ALL CLEAR - grab a random number
        uint rand = selectRandom(10000);

        //get our probabilty distribution
        uint16[7] memory probs = burnAndBoost(czxpWager);
        
        //Get the rarity for this pull from the probs
        // 3=epic, 4=rare, 5=uncommon, 6=commmon
        for(uint8 i=2; i < probs.length; i++){
            if(rand <= probs[i]){
                return i;
            }
        }
//REMOVE THIS !!!!
        return 6;
    }
    
    
    /**
     * Private Booster distribution function
     */
     function burnAndBoost(uint czxpWager) private returns(uint16[7] memory) {
        
        //buyBoosterCardAndOpen will pass a zero, set a default
        if(czxpWager == 0){
            return [0,0,0,1,50,2700,10000];
        }
         
        (uint16 c, uint16 u, uint16 r, uint16 e) = super.getProbs(czxpWager);
        
        //default distribution is 1,50,2700,10000
         uint16[7] memory probs = [0,0,0,e,r,u,c];
         
        return probs;
     }
     
     /**
      * Return the timestamp of the next daily bonus for a player
      */
      function getTimeToDailyBonus(address _player) public view returns(uint timeStamp){
          
          //check if address exists
          if(timeToCardsPull[_player] == 0){
              return now - 2 seconds;
          }else{
              return timeToCardsPull[_player];
          }
      }


//Thanks! for supporting the Cryptoz universe <3 <3 <3
    /**
    * Withdraw balance to wallet ONLY for the owner to call this
    */
   function withdraw() external onlyOwner {
      msg.sender.transfer(address(this).balance);
   }
}

Contract ABI

[{"constant":true,"inputs":[{"name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"_name","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_cardTypeId","type":"uint32"}],"name":"getFreeCard","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxCardTypes","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"czxpGainedBoosterPurchase","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":"from","type":"address"},{"name":"to","type":"address"},{"name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint32"}],"name":"allCardTypes","outputs":[{"name":"cardTypeId","type":"uint32"},{"name":"name","type":"string"},{"name":"set","type":"string"},{"name":"weiCost","type":"uint256"},{"name":"buyCzxp","type":"uint256"},{"name":"transferCzxp","type":"uint256"},{"name":"sacrificeCzxp","type":"uint256"},{"name":"unlockCzxp","type":"uint256"},{"name":"cardLevel","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"tokensByRarity","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"czxpWager","type":"uint256"}],"name":"openBoosterCard","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_cardTypeId","type":"uint32"},{"name":"_transferCzxp","type":"uint256"},{"name":"_sacrificeCzxp","type":"uint256"},{"name":"_unlockCzxp","type":"uint256"},{"name":"_cardLevel","type":"uint8"}],"name":"addTocardType","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"boosterPacksOwned","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"getBonusBoosters","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getTotalTypes","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"uint256"}],"name":"cardTypesOwned","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"name":"ownerTokens","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"weiCostOfCard","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"rarity","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_cardTypeId","type":"uint8"},{"name":"_name","type":"string"},{"name":"_set","type":"string"},{"name":"_assetType","type":"uint8"},{"name":"_notStoreOrBonus","type":"uint8"},{"name":"_rarity","type":"uint8"},{"name":"_totalAvailable","type":"uint16"},{"name":"_weiCost","type":"uint256"},{"name":"_buyCzxp","type":"uint256"}],"name":"loadNewCardType","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"mySponsor","type":"address"}],"name":"linkMySponsor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"cardTypesIds","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"_symbol","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxBoostersReward","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"getOwnedCard","outputs":[{"name":"","type":"uint32"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_winner","type":"address"},{"name":"_amount","type":"uint256"}],"name":"awardBoosterCredits","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getTokensByRarity","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"cardTypeToEdition","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"tokenId","type":"uint256"},{"name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_czxpContractAddress","type":"address"}],"name":"initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_cardTypeId","type":"uint32"}],"name":"buyCard","outputs":[{"name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"sponsors","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_amount","type":"uint256"}],"name":"buyBoosterCard","outputs":[{"name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"_tokenId","type":"uint256"}],"name":"sacrifice","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"owner","type":"address"},{"name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalBoostersRewarded","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_player","type":"address"}],"name":"getTimeToDailyBonus","outputs":[{"name":"timeStamp","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"buyBoosterCardAndOpen","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"payable":false,"stateMutability":"nonpayable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"cardTypeId","type":"uint32"},{"indexed":false,"name":"cardName","type":"string"}],"name":"LogCardTypeLoaded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"cardTypeId","type":"uint32"},{"indexed":false,"name":"editionNumber","type":"uint256"},{"indexed":true,"name":"buyer","type":"address"}],"name":"LogCardPurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"buyer","type":"address"},{"indexed":false,"name":"packsOpened","type":"uint256"}],"name":"LogPackOpened","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sponsor","type":"address"},{"indexed":false,"name":"affiliate","type":"address"}],"name":"LogSponsorLinked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sponsor","type":"address"},{"indexed":false,"name":"affiliate","type":"address"},{"indexed":false,"name":"CzxpReward","type":"uint256"}],"name":"LogSponsorReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"player","type":"address"},{"indexed":false,"name":"newBonusBalance","type":"uint256"}],"name":"LogDailyReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"winner","type":"address"},{"indexed":false,"name":"boostersAwarded","type":"uint256"}],"name":"LogRewardBoosters","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"cardTokenId","type":"uint256"},{"indexed":false,"name":"editionNumber","type":"uint256"},{"indexed":true,"name":"cardTypeId","type":"uint256"},{"indexed":false,"name":"rarity","type":"uint8"},{"indexed":false,"name":"CzxpGained","type":"uint256"}],"name":"LogCardCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"cardTokenId","type":"uint256"},{"indexed":true,"name":"cardTypeId","type":"uint256"},{"indexed":false,"name":"CzxpGained","type":"uint256"}],"name":"SacrificeCardEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"to","type":"address"},{"indexed":true,"name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"approved","type":"address"},{"indexed":true,"name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"owner","type":"address"},{"indexed":true,"name":"operator","type":"address"},{"indexed":false,"name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"beneficiary","type":"address"},{"indexed":false,"name":"czxpAmount","type":"uint256"}],"name":"CZXPGained","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

Deployed ByteCode Sourcemap

79513:16334:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79513:16334:0;81547:8;;;42227:135;;8:9:-1;5:2;;;30:1;27;20:12;5:2;42227:135:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42227:135:0;-1:-1:-1;;;;;;42227:135:0;;:::i;:::-;;;;;;;;;;;;;;;;;;72178:85;;8:9:-1;5:2;;;30:1;27;20:12;5:2;72178:85: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;72178:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47189:204;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47189:204:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47189:204:0;;:::i;:::-;;;;-1:-1:-1;;;;;47189:204:0;;;;;;;;;;;;;;46471:425;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46471:425:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;46471:425:0;;;;;;;;:::i;:::-;;87459:1323;;8:9:-1;5:2;;;30:1;27;20:12;5:2;87459:1323:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;87459:1323:0;;;;:::i;73566:89::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73566:89:0;;;:::i;:::-;;;;;;;;;;;;;;;;76581:287;;8:9:-1;5:2;;;30:1;27;20:12;5:2;76581:287:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;76581:287:0;;;;;;;;;;;;;;;;;:::i;73205:213::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73205:213:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;73205:213:0;;;;;;;;:::i;79715:40::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79715:40:0;;;:::i;79656:52::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79656:52:0;;;:::i;95747:97::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;95747:97:0;;;:::i;49826:134::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49826:134:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;49826:134:0;;;;;;;;;;;;;;;;;:::i;27940:47::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27940:47:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;27940:47:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;27940:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27940:47: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;27940:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71500;;8:9:-1;5:2;;;30:1;27;20:12;5:2;71500:47:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;71500:47:0;;:::i;91279:609::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;91279:609:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;91279:609:0;;:::i;73992:143::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;73992:143:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;73992:143:0;;:::i;45812:228::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45812:228:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45812:228:0;;:::i;83304:1339::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;83304:1339:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;83304:1339:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;45375:211::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45375:211:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45375:211:0;-1:-1:-1;;;;;45375:211:0;;:::i;2963:140::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2963:140:0;;;:::i;80949:53::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;80949:53:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;80949:53:0;-1:-1:-1;;;;;80949:53:0;;:::i;86855:525::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;86855:525:0;;;:::i;28534:97::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28534:97:0;;;:::i;71978:64::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;71978:64:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;71978:64:0;;;;;;;;:::i;78279:139::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;78279:139:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;78279:139:0;-1:-1:-1;;;;;78279:139: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;78279:139:0;;;;;;;;;;;;;;;;;79567:53;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79567:53:0;;;:::i;27734:39::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27734:39:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;27734:39:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;2152:79;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2152:79:0;;;:::i;81764:1532::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;81764:1532:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;81764:1532:0;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;81764:1532:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;81764:1532:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;81764:1532:0;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;81764:1532:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;81764:1532:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;81764:1532:0;;-1:-1:-1;81764:1532:0;-1:-1:-1;81764:1532:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2518:94::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2518:94:0;;;:::i;91992:549::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;91992:549:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;91992:549:0;-1:-1:-1;;;;;91992:549:0;;:::i;28030:29::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28030:29:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;28030:29:0;;:::i;72367:91::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;72367:91:0;;;:::i;79794:46::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;79794:46:0;;;:::i;47694:254::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47694:254:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;47694:254:0;;;;;;;;;;:::i;78771:231::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;78771:231:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;78771:231:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89212:658;;8:9:-1;5:2;;;30:1;27;20:12;5:2;89212:658:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;89212:658:0;;;;;;;;:::i;78508:216::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;78508:216:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28162:52;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28162:52:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;28162:52:0;;:::i;50697:272::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50697:272:0;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;50697:272:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;50697:272:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;50697:272:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;50697:272:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;50697:272:0;;-1:-1:-1;50697:272:0;;-1:-1:-1;;;;;50697:272:0:i;81619:137::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;81619:137:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;81619:137:0;-1:-1:-1;;;;;81619:137:0;;:::i;72658:178::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;72658:178:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;72658:178:0;;:::i;84772:2008::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;84772:2008:0;;;;:::i;80576:43::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;80576:43:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;80576:43:0;-1:-1:-1;;;;;80576:43:0;;:::i;89947:571::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;89947:571:0;;:::i;88904:164::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;88904:164:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;88904:164:0;;:::i;48278:147::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48278:147:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;48278:147:0;;;;;;;;;;:::i;3258:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3258:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3258:109:0;-1:-1:-1;;;;;3258:109:0;;:::i;80491:37::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;80491:37:0;;;:::i;95295:304::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;95295:304:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;95295:304:0;-1:-1:-1;;;;;95295:304:0;;:::i;90628:526::-;;;:::i;42227:135::-;-1:-1:-1;;;;;;42321:33:0;;42297:4;42321:33;;;:20;:33;;;;;;;;42227:135;;;;:::o;72178:85::-;72252:5;72245:12;;;;;;;;-1:-1:-1;;72245:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72217:19;;72245:12;;72252:5;;72245:12;;72252:5;72245:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72178:85;;:::o;47189:204::-;47248:7;47276:16;47284:7;47276;:16::i;:::-;47268:73;;;;-1:-1:-1;;;47268:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47361:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;47361:24:0;;47189:204::o;46471:425::-;46535:13;46551:16;46559:7;46551;:16::i;:::-;46535:32;;46592:5;-1:-1:-1;;;;;46586:11:0;:2;-1:-1:-1;;;;;46586:11:0;;;46578:57;;;;-1:-1:-1;;;46578:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46672:5;-1:-1:-1;;;;;46656:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;46656:21:0;;:62;;;;46681:37;46698:5;46705:12;:10;:12::i;:::-;46681:16;:37::i;:::-;46648:154;;;;-1:-1:-1;;;46648:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46815:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;46815:29:0;-1:-1:-1;;;;;46815:29:0;;;;;;;;;46860:28;;46815:24;;46860:28;;;;;;;46471:425;;;:::o;87459:1323::-;81324:51;;;;:25;;;;:12;:25;;;;;:36;87521:11;;81324:36;:51;81316:60;;;;;;81395:30;;;;;;;:17;:30;;;;;;81428:1;81395:30;;;;:34;81387:43;;;;;;87584:30;;;;;;;:17;:30;;;;;;;;:35;87576:44;;;;;;87732:30;;;;;;;:17;:30;;;;;;;;;87701:14;:27;;;;;;;87763:1;87732:32;;;87701:27;;;;:64;87693:73;;;;;;87860:10;87845:26;;;;:14;:26;;;;;;;;:39;;;;;;;;;;;;;:48;87837:57;;;;;;87997:20;;87987:53;;;-1:-1:-1;;;87987:53:0;;88029:10;87987:53;;;;;;87975:9;;-1:-1:-1;;;;;87997:20:0;;87987:41;;:53;;;;;;;;;;;;;;87997:20;87987:53;;;5:2:-1;;;;30:1;27;20:12;5:2;87987:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;87987:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;87987:53:0;88067:25;;;;;;;:12;87987:53;88067:25;;;;;;;:36;;87987:53;;-1:-1:-1;88059:44:0;;;88051:53;;;;;;88169:25;;;;;;;:12;:25;;;;;:33;;;:38;88161:47;;;;;;88381:10;88366:26;;;;:14;:26;;;;;;;;:39;;;;;;;;;;:46;;-1:-1:-1;;88366:46:0;88408:4;88366:46;;;88506:12;:25;;;;;:33;;;88478:62;;88381:10;88478:15;:62::i;:::-;88607:25;;;;;;;:12;:25;;;;;:33;;;88591:50;;:15;:50::i;:::-;88734:25;;;;;;;:12;:25;;;;;:33;;;88691:77;;88709:11;;88722:10;;88691:17;:77::i;:::-;;81495:1;87459:1323;;:::o;73566:89::-;73633:9;:16;73566:89;:::o;76581:287::-;76672:39;76691:10;76703:7;76672:18;:39::i;:::-;76664:48;;;;;;76806:1;76774:5;76780:7;76774:14;;;;;;;;;;;;;;;;:28;:14;;;;;:28;:33;;;;;;;76828:32;76842:4;76848:2;76852:7;76828:13;:32::i;:::-;76581:287;;;:::o;73205:213::-;73317:7;73353:17;73363:6;73353:9;:17::i;:::-;73344:6;:26;73336:35;;;;;;-1:-1:-1;;;;;73385:19:0;;;;;;:11;:19;;;;;:27;;73405:6;;73385:27;;;;;;;;;;;;;;73378:34;;73205:213;;;;;:::o;79715:40::-;79751:4;79715:40;:::o;79656:52::-;79705:3;79656:52;:::o;95747:97::-;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;95795:42;;:10;;95823:4;95815:21;95795:42;;;;;;;;;95815:21;95795:10;:42;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;95795:42:0;95747:97::o;49826:134::-;49913:39;49930:4;49936:2;49940:7;49913:39;;;;;;;;;;;;:16;:39::i;27940:47::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;27940:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;27940:47:0;;;;;;;;;;;-1:-1:-1;;27940:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27940:47:0;;-1:-1:-1;27940:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;27940:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27940:47:0;;-1:-1:-1;27940:47:0;;;;;:::o;71500:::-;;;;;;;;;;;;;-1:-1:-1;71500:47:0;:::o;91279:609::-;91421:10;91335:4;91403:29;;;:17;:29;;;;;;91395:42;;;;;;91645:10;91627:29;;;;:17;:29;;;;;;:36;;91661:1;91627:36;:33;:36;:::i;:::-;91613:10;91595:29;;;;:17;:29;;;;;:68;;;;91724:20;91734:9;91724;:20::i;:::-;91709:35;;91755:16;91764:6;91755:8;:16::i;:::-;91825:33;;;;;;;;;;91839:10;;91825:33;;;;;;;;;;-1:-1:-1;91876:4:0;;91279:609;-1:-1:-1;;91279:609:0:o;73992:143::-;74051:7;74084:13;:11;:13::i;:::-;74075:6;:22;74067:31;;;;;;74112:9;74122:6;74112:17;;;;;;;;;;;;;;;;74105:24;;73992:143;;;:::o;45812:228::-;45867:7;45903:20;;;:11;:20;;;;;;-1:-1:-1;;;;;45903:20:0;45942:19;45934:73;;;;-1:-1:-1;;;45934:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83304:1339;83611:4;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;83773:25;;;;;;;:12;:25;;;;;:38;;;:43;83765:52;;;;;;83836:25;;;;;;;:12;:25;;;;;:39;;;:44;83828:53;;;;;;83900:25;;;;;;;:12;:25;;;;;;;;:36;;:41;83892:50;;;;;;83961:25;;;;;;;:12;:25;;;;;:35;;;;;:40;83953:49;;;;;;84049:51;;;;:25;;;;:12;:25;;;;;:36;;;;:51;84041:60;;;;;;84132:25;;;;;;;:12;:25;;;;;;;;:38;;;:55;;;84198:39;;;:56;;;84265:36;;;:53;;;84329:35;;;:52;;;;;-1:-1:-1;;84329:52:0;;;;;;84438:17;:30;;;;;:34;;;;84582:25;;;84552:61;;;;;84329:52;84582:30;;;84552:61;;;;;;;84329:52;84552:61;-1:-1:-1;;84552:61:0;;;;;;;;;;;;;;84582:30;84552:61;;;;;;;84582:30;;84552:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;84631:4:0;83304:1339;;;;;;;:::o;45375:211::-;45430:7;-1:-1:-1;;;;;45458:19:0;;45450:74;;;;-1:-1:-1;;;45450:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45544:24:0;;;;;;:17;:24;;;;;:34;;:32;:34::i;2963:140::-;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;3062:1;3046:6;;3025:40;;-1:-1:-1;;;;;3046:6:0;;;;3025:40;;3062:1;;3025:40;3093:1;3076:19;;-1:-1:-1;;;;;;3076:19:0;;;2963:140::o;80949:53::-;;;;;;;;;;;;;:::o;86855:525::-;86968:31;86988:10;86968:19;:31::i;:::-;86962:3;:37;86954:93;;;;-1:-1:-1;;;86954:93:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87139:10;87123:27;;;;:15;:27;;;;;;;;87159:7;87153:3;:13;87123:43;;87263:17;:29;;;;;;:36;;87297:1;87263:36;:33;:36;:::i;:::-;87249:10;87231:29;;;;:17;:29;;;;;;;;;:68;;;87315:57;;;;;;;;;;;;;;;;;;;;;;;;86855:525::o;28534:97::-;28603:12;:19;28534:97;:::o;71978:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;78279:139::-;78340:28;78388:22;78403:6;78388:14;:22::i;:::-;78381:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78279:139;;;:::o;79567:53::-;79604:16;79567:53;:::o;27734:39::-;;;;;;;;;;;;;;;:::o;2152:79::-;2190:7;2217:6;-1:-1:-1;;;;;2217:6:0;2152:79;:::o;81764:1532::-;82125:4;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;82267:12;:19;79751:4;-1:-1:-1;82267:35:0;82259:44;;;;;;82386:25;;;;;;;:12;:25;;;;;:36;:25;:36;:41;82378:50;;;;;;82449:53;;;:25;;;;:12;:25;;;;;:53;;-1:-1:-1;;82449:53:0;;;;;;82513:47;;82449:53;82513:30;82555:5;;82513:47;:::i;:::-;-1:-1:-1;82571:25:0;;;;;;;:12;:25;;;;;:46;;:29;;82613:4;;82571:46;:::i;:::-;-1:-1:-1;82628:26:0;;;;;;;;:13;:26;;;;;;;;:52;;-1:-1:-1;;82628:52:0;;;;;;;;;;82691:17;:30;;;;;;:58;;;;;;;;;;;;;82760:6;:19;;;;;;:49;;;;;;;;;;;;;;;82820:14;:27;;;;;:57;;-1:-1:-1;;82820:57:0;;;;;;;82888:12;:25;;;;;:33;;;:50;;;82949:33;;;:50;;;-1:-1:-1;83055:21:0;83052:125;;;83121:26;;;;;;;;:17;:26;;;;;;;27:10:-1;;39:1;23:18;;45:23;;83121:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83052:125;-1:-1:-1;83236:12:0;27:10:-1;;39:1;23:18;;;45:23;;-1:-1;83236:30:0;;;;;;;;;;;;81764:1532;;;;;;;;;;;;;:::o;2518:94::-;2558:4;2598:6;;-1:-1:-1;;;;;2598:6:0;2582:12;:10;:12::i;:::-;-1:-1:-1;;;;;2582:22:0;;2575:29;;2518:94;:::o;91992:549::-;-1:-1:-1;;;;;92109:23:0;;92101:32;;;;;;92214:10;92237:1;92205:20;;;:8;:20;;;;;;-1:-1:-1;;;;;92205:20:0;:34;92197:43;;;;;;92321:10;-1:-1:-1;;;;;92321:23:0;;;;92313:32;;;;;;92436:10;92427:20;;;;:8;:20;;;;;:32;;-1:-1:-1;;;;;;92427:32:0;-1:-1:-1;;;;;92427:32:0;;;;;92522:11;92531:1;92522:8;:11::i;28030:29::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28030:29:0;:::o;72367:91::-;72445:7;72438:14;;;;;;;;-1:-1:-1;;72438:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72408:21;;72438:14;;72445:7;;72438:14;;72445:7;72438:14;;;;;;;;;;;;;;;;;;;;;;;;79794:46;79835:5;79794:46;:::o;47694:254::-;47780:12;:10;:12::i;:::-;-1:-1:-1;;;;;47774:18:0;:2;-1:-1:-1;;;;;47774:18:0;;;47766:56;;;;;-1:-1:-1;;;47766:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;47874:8;47835:18;:32;47854:12;:10;:12::i;:::-;-1:-1:-1;;;;;47835:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;47835:32:0;;;:36;;;;;;;;;;;;:47;;-1:-1:-1;;47835:47:0;;;;;;;;;;;47913:12;:10;:12::i;:::-;47898:42;;;;;;;;;;-1:-1:-1;;;;;47898:42:0;;;;;;;;;;;;;;47694:254;;:::o;78771:231::-;78831:6;78839:4;78845;78870:17;78878:8;78870:7;:17::i;:::-;78862:26;;;;;;78907:5;78913:8;78907:15;;;;;;;;;;;;;;;;;;;;;:26;78934:5;:15;;78907:26;;;;;78940:8;;78934:15;;;;;;;;;;;;;;;;:29;;;78964:5;78970:8;78964:15;;;;;;;;;;;;;;;;;;:29;;;78899:95;;;;;;78771:231;;;;;:::o;89212:658::-;89299:4;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;79835:5;89394:7;89370:21;;:31;89369:54;;89361:112;;;;-1:-1:-1;;;89361:112:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89567:21;;:34;;89593:7;89567:34;:25;:34;:::i;:::-;-1:-1:-1;;;;;;89713:26:0;;;;;;:17;:26;;;;;;:39;;89744:7;89713:39;:30;:39;:::i;:::-;-1:-1:-1;;;;;89684:26:0;;;;;;:17;:26;;;;;;;;;:68;;;;89803:35;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;89858:4:0;89212:658;;;;:::o;78508:216::-;78608:17;;78626;;78644;;78662;;78680;;78698;;78608;;78626;;78644;;78662;;78680;;78508:216::o;28162:52::-;;;;;;;;;;;;;:::o;50697:272::-;50812:41;50831:12;:10;:12::i;:::-;50845:7;50812:18;:41::i;:::-;50804:103;;;;-1:-1:-1;;;50804:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50918:43;50936:4;50942:2;50946:7;50955:5;50918:17;:43::i;81619:137::-;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;81705:20;:43;;-1:-1:-1;;;;;;81705:43:0;-1:-1:-1;;;;;81705:43:0;;;;;;;;;;81619:137::o;72658:178::-;72774:12;72746:84;;;;;;;;;;;;;-1:-1:-1;;72746:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;72717:13;;72746:84;;;;72774:12;;72746:84;;72774:12;72746:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72797:26;72814:8;72797:16;:26::i;:::-;72746:17;:84::i;84772:2008::-;81324:51;;;;84859:4;81324:25;;;:12;:25;;;;;:36;84859:4;;84838:11;;81324:36;;:51;81316:60;;;;;;81395:30;;;;;;;:17;:30;;;;;;81428:1;81395:30;;;;:34;81387:43;;;;;;84950:1;84938:9;:13;84930:33;;;;;-1:-1:-1;;;84930:33:0;;;;;;;;;;;;-1:-1:-1;;;84930:33:0;;;;;;;;;;;;;;;85028:51;;;;:25;;;;:12;:25;;;;;:36;;;;:51;85020:101;;;;-1:-1:-1;;;85020:101:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85142:25;;:::i;:::-;85170;;;;;;;;:12;:25;;;;;;;;;85142:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;85142:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;85170:25;;85142:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;85142:53:0;;;-1:-1:-1;;85142:53:0;;;;;;;;;;;;;;;;-1:-1:-1;;85142:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;85142:53:0;;;-1:-1:-1;;85142:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85255:30;;;-1:-1:-1;85255:30:0;;;;;;;;;;;85142:53;;-1:-1:-1;85255:30:0;:35;85247:77;;;;;-1:-1:-1;;;85247:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;85418:10;85403:26;;;;:14;:26;;;;;;;;:39;;;;;;;;;;;;;:48;85395:97;;;;-1:-1:-1;;;85395:97:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85641:30;;;;;;;:17;:30;;;;;;;;;85610:14;:27;;;;;;;85674:1;85641:34;;;85610:27;;;;:65;;85601:123;;;;-1:-1:-1;;;85601:123:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85815:9;:17;;;85802:9;:30;;85794:86;;;;-1:-1:-1;;;85794:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85983:20;;85973:53;;;-1:-1:-1;;;85973:53:0;;86015:10;85973:53;;;;;;85961:9;;-1:-1:-1;;;;;85983:20:0;;85973:41;;:53;;;;;;;;;;;;;;85983:20;85973:53;;;5:2:-1;;;;30:1;27;20:12;5:2;85973:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;85973:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;85973:53:0;86053:20;;;;85973:53;;-1:-1:-1;86045:28:0;;;86037:98;;;;-1:-1:-1;;;86037:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86308:10;86293:26;;;;:14;:26;;;;;;;;:39;;;;;;;;;;:46;;-1:-1:-1;;86293:46:0;86335:4;86293:46;;;86433:12;:25;;;;;:33;;;86405:62;;86308:10;86405:15;:62::i;:::-;86539:25;;;;;;;:12;:25;;;;;:33;;;86523:50;;:15;:50::i;:::-;86696:25;;;;;;;:12;:25;;;;;:33;;;86654:76;;86672:11;;86685:10;;86654:17;:76::i;:::-;-1:-1:-1;86768:4:0;;84772:2008;-1:-1:-1;;;;;84772:2008:0:o;80576:43::-;;;;;;;;;;;;-1:-1:-1;;;;;80576:43:0;;:::o;89947:571::-;90010:4;90116:26;79604:16;90134:7;90116:26;:17;:26;:::i;:::-;90103:9;:39;;90095:48;;;;;;90260:10;90242:29;;;;:17;:29;;;;;;:42;;90276:7;90242:42;:33;:42;:::i;:::-;90228:10;90210:29;;;;:17;:29;;;;;:74;;;;90331:73;;90364:38;79705:3;90394:7;90364:38;:29;:38;:::i;:::-;90331:15;:73::i;:::-;90425:61;90446:38;79705:3;90476:7;90446:38;:29;:38;:::i;:::-;90425:15;:61::i;:::-;-1:-1:-1;90506:4:0;89947:571;;;:::o;88904:164::-;89032:27;89038:10;89050:8;89032:5;:27::i;48278:147::-;-1:-1:-1;;;;;48382:25:0;;;48358:4;48382:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;48278:147::o;3258:109::-;2364:9;:7;:9::i;:::-;2356:54;;;;;-1:-1:-1;;;2356:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2356:54:0;;;;;;;;;;;;;;;3331:28;3350:8;3331:18;:28::i;80491:37::-;;;;:::o;95295:304::-;-1:-1:-1;;;;;95441:24:0;;95361:14;95441:24;;;:15;:24;;;;;;95438:152;;-1:-1:-1;;;95495:3:0;:15;95488:22;;95438:152;-1:-1:-1;;;;;;95552:24:0;;;;;;:15;:24;;;;;;95545:31;;90628:526;79604:16;90755:9;:26;;90747:35;;;;;;90899:10;90881:29;;;;:17;:29;;;;;;:36;;90915:1;90881:36;:33;:36;:::i;:::-;90867:10;90849:29;;;;:17;:29;;;;;:68;;;;90961:54;;79705:3;90961:15;:54::i;:::-;91036:42;79705:3;91036:15;:42::i;:::-;91128:18;91144:1;91128:15;:18::i;52162:155::-;52219:4;52252:20;;;:11;:20;;;;;;-1:-1:-1;;;;;52252:20:0;52290:19;;;52162:155::o;858:98::-;938:10;858:98;:::o;28733:185::-;28853:20;;28843:67;;;-1:-1:-1;;;28843:67:0;;-1:-1:-1;;;;;28843:67:0;;;;;;;;;;;;;;;28853:20;;;;;28843:41;;:67;;;;;28853:20;;28843:67;;;;;;;28853:20;;28843:67;;;5:2:-1;;;;30:1;27;20:12;5:2;28843:67:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;28843:67:0;;;;28733:185;;:::o;92634:434::-;92760:10;92783:1;92751:20;;;:8;:20;;;;;;-1:-1:-1;;;;;92751:20:0;:34;92748:312;;92828:2;92816:14;;;92846:62;;-1:-1:-1;92890:1:0;92846:62;92948:10;92939:20;;;;:8;:20;;;;;;92923:45;;-1:-1:-1;;;;;92939:20:0;92961:6;92923:15;:45::i;:::-;93015:10;93006:20;;;;:8;:20;;;;;;;;;;92989:58;;-1:-1:-1;;;;;93006:20:0;;;;92989:58;;;;;;;;;;;;;;;;;;;;;;;;;92748:312;92634:434;:::o;76932:1269::-;77104:51;;;;77024:4;77104:25;;;:12;:25;;;;;:36;77024:4;;77104:36;:51;77096:60;;;;;;77238:30;;;;;;;;:17;:30;;;;;;:37;;77273:1;;77238:34;:37;:::i;:::-;77205:30;;;;;;;:17;:30;;;;;:70;77316:21;;:::i;:::-;-1:-1:-1;77340:143:0;;;;;;;;;;;;;;;-1:-1:-1;77411:30:0;;;:17;77340:143;77411:30;;;;;;;77340:143;;;;;;;;;;;;77584:5;27:10:-1;;77608:1:0;23:18:-1;;45:23;;77584:21:0;;;;;;;;;;;;;-1:-1:-1;;77584:21:0;;;;;;;;;;;;;;;;;;;;;;;;;77340:143;77654:24;77660:6;27:10:-1;77654:5:0;:24::i;:::-;77763:12;77738:38;;;;;;;;;;;;;-1:-1:-1;;77738:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;77751:10;;77738:38;;77763:12;;77738:38;;77763:12;77738:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:12;:38::i;:::-;77842:19;;;77821:18;77842:19;;;:6;:19;;;;;;;;77903:14;77842:19;77903:28;;;;;;;;;77934:1;77903:32;77872:14;77887:12;77872:28;;;;;;;;;;:63;78043:112;;;78078:30;;;;:17;:30;;;;;;;;;78123:6;:19;;;;;;;78043:112;;;;;78123:19;;78043:112;;;;;;;;;;;;;;78066:10;;-1:-1:-1;;;;;78043:112:0;;;;;;;;;;;;-1:-1:-1;78183:10:0;76932:1269;-1:-1:-1;;;;;76932:1269:0:o;52687:333::-;52772:4;52797:16;52805:7;52797;:16::i;:::-;52789:73;;;;-1:-1:-1;;;52789:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52873:13;52889:16;52897:7;52889;:16::i;:::-;52873:32;;52935:5;-1:-1:-1;;;;;52924:16:0;:7;-1:-1:-1;;;;;52924:16:0;;:51;;;;52968:7;-1:-1:-1;;;;;52944:31:0;:20;52956:7;52944:11;:20::i;:::-;-1:-1:-1;;;;;52944:31:0;;52924:51;:87;;;;52979:32;52996:5;53003:7;52979:16;:32::i;:::-;52916:96;52687:333;-1:-1:-1;;;;52687:333:0:o;76334:132::-;76420:38;76440:4;76446:2;76450:7;76420:19;:38::i;7958:136::-;8016:7;8043:43;8047:1;8050;8043:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;8036:50;7958:136;-1:-1:-1;;;7958:136:0:o;93606:1026::-;93657:5;93743:16;93730:9;:29;;93722:38;;;;;;93870:20;;93860:53;;;-1:-1:-1;;;93860:53:0;;93902:10;93860:53;;;;;;93834:23;;-1:-1:-1;;;;;93870:20:0;;93860:41;;:53;;;;;;;;;;;;;;93870:20;93860:53;;;5:2:-1;;;;30:1;27;20:12;5:2;93860:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;93860:53:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;93860:53:0;;-1:-1:-1;93932:31:0;;;;93924:40;;;;;;94031:13;;94028:107;;94070:20;;94060:63;;;-1:-1:-1;;;94060:63:0;;94101:10;94060:63;;;;;;;;;;;;-1:-1:-1;;;;;94070:20:0;;;;94060:40;;:63;;;;;94070:20;;94060:63;;;;;;;;94070:20;;94060:63;;;5:2:-1;;;;30:1;27;20:12;5:2;94060:63:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;94060:63:0;;;;94028:107;94199:9;94211:19;94224:5;94211:12;:19::i;:::-;94199:31;;94286:22;;:::i;:::-;94311:23;94324:9;94311:12;:23::i;:::-;94286:48;-1:-1:-1;94472:1:0;94460:126;94479:12;94475:1;:16;;;94460:126;;;94523:5;94529:1;94523:8;;;;;;;;;;;;;94515:16;;:4;:16;94512:63;;94558:1;-1:-1:-1;94551:8:0;;-1:-1:-1;;;94551:8:0;94512:63;94493:3;;94460:126;;;-1:-1:-1;94623:1:0;;93606:1026;-1:-1:-1;;;;;93606:1026:0:o;93103:395::-;93244:25;;;93219:9;93244:25;;;:17;:25;;;;;:32;93231:46;;:12;:46::i;:::-;93351:25;;;93333:15;93351:25;;;:17;:25;;;;;:31;;93219:58;;-1:-1:-1;93333:15:0;;93219:58;;93351:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93333:49;;93445:44;93463:8;93473:10;93485:3;93445:17;:44::i;40816:114::-;40908:14;;40816:114::o;7502:181::-;7560:7;7592:5;;;7616:6;;;;7608:46;;;;;-1:-1:-1;;;7608:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;63697:126;-1:-1:-1;;;;;63796:19:0;63759:17;63796:19;;;:12;:19;;;;;;63697:126::o;51688:272::-;51798:32;51812:4;51818:2;51822:7;51798:13;:32::i;:::-;51849:48;51872:4;51878:2;51882:7;51891:5;51849:22;:48::i;:::-;51841:111;;;;-1:-1:-1;;;51841:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69401:482;69451:27;69495:7;69491:50;;-1:-1:-1;69519:10:0;;;;;;;;;;;;-1:-1:-1;;;69519:10:0;;;;;;69491:50;69560:2;69551:6;69592:69;69599:6;;69592:69;;69622:5;;69647:2;69642:7;;;;69592:69;;;69671:17;69701:3;69691:14;;;;;;;;;;;;;;;;;;;;;;;;;21:6:-1;;104:10;69691:14:0;87:34:-1;135:17;;-1:-1;69691:14:0;-1:-1:-1;69671:34:0;-1:-1:-1;;;69725:7:0;;69743:103;69750:7;;69743:103;;69807:2;69802;:7;69797:2;:12;69786:25;;69774:4;69779:3;;;;;;;69774:9;;;;;;;;;;;:37;-1:-1:-1;;;;;69774:37:0;;;;;;;;-1:-1:-1;69832:2:0;69826:8;;;;69743:103;;;-1:-1:-1;69870:4:0;69401:482;-1:-1:-1;;;;69401:482:0:o;69245:148::-;69323:13;69356:29;69366:2;69370;69356:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:9;:29::i;8874:471::-;8932:7;9177:6;9173:47;;-1:-1:-1;9207:1:0;9200:8;;9173:47;9244:5;;;9248:1;9244;:5;:1;9268:5;;;;;:10;9260:56;;;;-1:-1:-1;;;9260:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75210:1086;75281:29;75293:6;75301:8;75281:11;:29::i;:::-;75361:19;;;;:9;:19;;;;;75355:33;;-1:-1:-1;;75355:33:0;;;;;;;;;;;:38;75351:87;;75411:19;;;;:9;:19;;;;;75404:26;;;:::i;:::-;75477:18;75498:24;;;:14;:24;;;;;;75554:9;:16;75498:24;;75477:18;75554:23;;75575:1;75554:23;:20;:23;:::i;:::-;75529:48;;75584:17;75604:9;75614:14;75604:25;;;;;;;;;;;;;;;;75584:45;;75662:9;75638;75648:10;75638:21;;;;;;;;;;;;;;;:33;;;;75706:1;75678:9;75688:14;75678:25;;;;;;;;;;;;;;;;;:29;75716:9;:18;;;;;-1:-1:-1;;75716:18:0;;;:::i;:::-;-1:-1:-1;75768:1:0;75741:24;;;:14;:24;;;;;;:28;;;75776:25;;;;;:38;;;75925:5;:15;;75956:1;;75903:14;;75918:6;;75756:8;;75925:15;;;;;;;;;;;;;;;;;;;;;:26;;;75918:34;;;;;;;;;;;;;;;75903:50;;;;;;;;;:54;75850:14;75865:6;:34;75872:5;75878:8;75872:15;;;;;;;;;;;;;;;;;;;;;;;:26;;;75865:34;;;;;;;;;;;;;;;75850:50;;;;;;;;:107;;;;76005:21;76029:12;:40;76042:5;76048:8;76042:15;;;;;;;;;;;;;;;;;;;;;;;:26;;;76029:40;;;;;;;;;;;;:54;;;;-1:-1:-1;76090:35:0;76100:10;76029:54;76090:9;:35::i;:::-;76174:5;76180:8;76174:15;;;;;;;;;;;;;;;;;;;;76167:22;;-1:-1:-1;;76167:22:0;;;;;;;;;;;;76248:5;:15;;76254:8;;76248:15;;;;;;;;;;;;;;;;;;;;:26;76207:83;;;;;;;;76248:26;;;;;76238:8;;76226:10;;76207:83;;;;;;;;;75210:1086;;;;;;:::o;3473:229::-;-1:-1:-1;;;;;3547:22:0;;3539:73;;;;-1:-1:-1;;;3539:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3649:6;;;3628:38;;-1:-1:-1;;;;;3628:38:0;;;;3649:6;;;3628:38;;;3677:6;:17;;-1:-1:-1;;;;;;3677:17:0;-1:-1:-1;;;;;3677:17:0;;;;;;;;;;3473:229::o;74788:177::-;74850:26;74862:3;74867:8;74850:11;:26::i;:::-;74912:9;:16;;74885:24;;;;:14;:24;;;;;:43;;;39:1:-1;23:18;;45:23;;74935:24:0;;;;;;;-1:-1:-1;74788:177:0:o;74373:141::-;74457:17;74465:8;74457:7;:17::i;:::-;74449:26;;;;;;74482:19;;;;:9;:19;;;;;;;;:26;;;;;;;;:::i;62117:245::-;62203:38;62223:4;62229:2;62233:7;62203:19;:38::i;:::-;62254:47;62287:4;62293:7;62254:32;:47::i;:::-;62314:40;62342:2;62346:7;62314:27;:40::i;8431:192::-;8517:7;8553:12;8545:6;;;;8537:29;;;;-1:-1:-1;;;8537: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;8537:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;8589:5:0;;;8431:192::o;29029:213::-;29170:5;;29136:40;;;29153:3;29136:40;;;;;;;;29158:10;29136:40;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;29136:40:0;;;;;;;29126:51;;;;;29084:4;;;;29181:5;;;29121:65;;;;29197:5;:7;;;;;;29121:65;;29029:213;-1:-1:-1;;;29029:213:0:o;94715:478::-;94769:16;;:::i;:::-;94876:14;94873:75;;-1:-1:-1;94906:30:0;;;;;;;;-1:-1:-1;94906:30:0;;;;;;;;;;;;;;;;94920:1;94906:30;;;;94922:2;94906:30;;;;94925:4;94906:30;;;;94930:5;94906:30;;;;;;94873:75;94970:8;94980;94990;95000;95012:25;95027:9;95012:14;:25::i;:::-;94969:68;;;;;;;;95110:22;;:::i;:::-;-1:-1:-1;95110:40:0;;;;;;;;-1:-1:-1;95110:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94715:478;-1:-1:-1;;94715:478:0:o;57494:1079::-;57616:4;57643:15;:2;-1:-1:-1;;;;;57643:13:0;;:15::i;:::-;57638:60;;-1:-1:-1;57682:4:0;57675:11;;57638:60;57769:12;57783:23;-1:-1:-1;;;;;57810:7:0;;-1:-1:-1;;;57915:12:0;:10;:12::i;:::-;57942:4;57961:7;57983:5;57818:181;;;;;;-1:-1:-1;;;;;57818:181:0;-1:-1:-1;;;;;57818:181:0;;;;;;-1:-1:-1;;;;;57818:181:0;-1:-1:-1;;;;;57818:181: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;57818:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57818:181:0;;;-1:-1:-1;;26:21;;;22:32;6:49;;57818:181:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;57818:181:0;;;179:29:-1;;;;160:49;;57810:190:0;;;57818:181;;57810:190;;-1:-1:-1;57810:190:0;;-1:-1:-1;25:18;-1:-1;57810:190:0;-1:-1:-1;57810:190:0;;-1:-1:-1;57810:190:0;;-1:-1:-1;25:18;36:153;66:2;61:3;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;;;57810:190: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;;57768:232:0;;;;58016:7;58011:555;;58044:17;;:21;58040:384;;58212:10;58206:17;58273:15;58260:10;58256:2;58252:19;58245:44;58160:148;58348:60;;-1:-1:-1;;;58348:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58011:555;58456:13;58483:10;58472:32;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;58472:32:0;-1:-1:-1;;;;;;58527:26:0;-1:-1:-1;;;58527:26:0;;-1:-1:-1;58519:35:0;;-1:-1:-1;;;58519:35:0;67999:872;68131:13;68155:16;68180:2;68155:28;;68192:16;68217:2;68192:28;;68229:16;68254:2;68229:28;;68266:16;68291:2;68266:28;;68303:16;68328:2;68303:28;;68340:19;68425:3;:10;68412:3;:10;68399:3;:10;68386:3;:10;68373:3;:10;:23;:36;:49;:62;68362:74;;;;;;;;;;;;;;;;;;;;;;;;;21:6:-1;;104:10;68362:74:0;87:34:-1;135:17;;-1:-1;68362:74:0;-1:-1:-1;68340:96:0;-1:-1:-1;68340:96:0;68488:6;;68507:58;68528:3;:10;68524:1;:14;68507:58;;;68559:3;68563:1;68559:6;;;;;;;;;;;;;;;;68545;68552:3;;;;;;68545:11;;;;;;;;;;;:20;-1:-1:-1;;;;;68545:20:0;;;;;;;;-1:-1:-1;68540:3:0;;68507:58;;;-1:-1:-1;68579:6:0;68574:58;68595:3;:10;68591:1;:14;68574:58;;;68626:3;68630:1;68626:6;;;;;;;;;;;;;;;;68612;68619:3;;;;;;68612:11;;;;;;;;;;;:20;-1:-1:-1;;;;;68612:20:0;;;;;;;;-1:-1:-1;68607:3:0;;68574:58;;;-1:-1:-1;68646:6:0;68641:58;68662:3;:10;68658:1;:14;68641:58;;;68693:3;68697:1;68693:6;;;;;;;;;;;;;;;;68679;68686:3;;;;;;68679:11;;;;;;;;;;;:20;-1:-1:-1;;;;;68679:20:0;;;;;;;;-1:-1:-1;68674:3:0;;68641:58;;;-1:-1:-1;68713:6:0;68708:58;68729:3;:10;68725:1;:14;68708:58;;;68760:3;68764:1;68760:6;;;;;;;;;;;;;;;;68746;68753:3;;;;;;68746:11;;;;;;;;;;;:20;-1:-1:-1;;;;;68746:20:0;;;;;;;;-1:-1:-1;68741:3:0;;68708:58;;;-1:-1:-1;68780:6:0;68775:58;68796:3;:10;68792:1;:14;68775:58;;;68827:3;68831:1;68827:6;;;;;;;;;;;;;;;;68813;68820:3;;;;;;68813:11;;;;;;;;;;;:20;-1:-1:-1;;;;;68813:20:0;;;;;;;;-1:-1:-1;68808:3:0;;68775:58;;;-1:-1:-1;68856:6:0;;67999:872;-1:-1:-1;;;;;;;;;;;;;67999:872:0:o;63113:372::-;63180:27;63192:5;63199:7;63180:11;:27::i;:::-;63220:48;63253:5;63260:7;63220:32;:48::i;:::-;63418:1;63389:26;;;:17;:26;;;;;:30;63432:45;63407:7;63432:36;:45::i;:::-;63113:372;;:::o;62627:202::-;62691:24;62703:2;62707:7;62691:11;:24::i;:::-;62728:40;62756:2;62760:7;62728:27;:40::i;:::-;62781;62813:7;62781:31;:40::i;56383:459::-;56497:4;-1:-1:-1;;;;;56477:24:0;:16;56485:7;56477;:16::i;:::-;-1:-1:-1;;;;;56477:24:0;;56469:78;;;;-1:-1:-1;;;56469:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56566:16:0;;56558:65;;;;-1:-1:-1;;;56558:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56636:23;56651:7;56636:14;:23::i;:::-;-1:-1:-1;;;;;56672:23:0;;;;;;:17;:23;;;;;:35;;:33;:35::i;:::-;-1:-1:-1;;;;;56718:21:0;;;;;;:17;:21;;;;;:33;;:31;:33::i;:::-;56764:20;;;;:11;:20;;;;;;:25;;-1:-1:-1;;;;;;56764:25:0;-1:-1:-1;;;;;56764:25:0;;;;;;;;;56807:27;;56764:20;;56807:27;;;;;;;56383:459;;;:::o;65302:1148::-;-1:-1:-1;;;;;65593:18:0;;65568:22;65593:18;;;:12;:18;;;;;:25;:32;;65623:1;65593:32;:29;:32;:::i;:::-;65636:18;65657:26;;;:17;:26;;;;;;65568:57;;-1:-1:-1;65790:28:0;;;65786:328;;-1:-1:-1;;;;;65857:18:0;;65835:19;65857:18;;;:12;:18;;;;;:34;;65876:14;;65857:34;;;;;;;;;;;;;;65835:56;;65941:11;65908:12;:18;65921:4;-1:-1:-1;;;;;65908:18:0;-1:-1:-1;;;;;65908:18:0;;;;;;;;;;;;65927:10;65908:30;;;;;;;;;;;;;;;;;;;:44;;;;66025:30;;;:17;:30;;;;;:43;;;65786:328;-1:-1:-1;;;;;66203:18:0;;;;;;:12;:18;;;;;:27;;;;;-1:-1:-1;;66203:27:0;;;:::i;:::-;;65302:1148;;;;:::o;64124:186::-;-1:-1:-1;;;;;64238:16:0;;;;;;;:12;:16;;;;;;;;:23;;64209:26;;;:17;:26;;;;;:52;;;64272:16;;;39:1:-1;23:18;;45:23;;64272:30:0;;;;;;;;64124:186::o;29254:694::-;29302:6;29309;29316;29323;29353:21;;:::i;:::-;-1:-1:-1;29353:33:0;;;;;;;;29378:1;29353:33;;29380:1;29353:33;;;;29382:1;29353:33;;;;;;;29384:1;29353:33;;;;29397:19;;:::i;:::-;-1:-1:-1;29397:32:0;;;;;;;;29420:1;29397:32;;29422:1;29397:32;;;;29424:1;29397:32;;;;;;;29426:2;29397:32;;;;29440:24;;:::i;:::-;29475:27;;:::i;:::-;29519:6;29515:131;29531:1;29529;:3;29515:131;;;29621:3;29625:1;29621:6;;;;;;;;;;;29569:58;;29601:16;29611:5;29601:9;:16::i;:::-;29589:5;29595:1;29589:8;;;;;;;;;;;29571:26;;:16;29581:5;29571:9;:16::i;:::-;:26;29570:47;;;;;;29569:58;;;;;;29631:3;29568:66;29553:9;29563:1;29553:12;;;;;;;;;;:81;29534:3;;29515:131;;;-1:-1:-1;29728:12:0;;;;29713;;;;29728;29698;;;29683;;:27;:42;:57;29666:14;29761:106;29777:1;29775;:3;29761:106;;;29845:9;29822;29832:1;29822:12;;;;;;;;;;;29837:5;29822:20;:32;;;;;;29799:10;29810:1;29799:13;;;;;;;:56;;;;:13;;;;;;:56;29780:3;;29761:106;;;-1:-1:-1;;29884:13:0;;;29898;;;29912;;;;29926;;;;;29884;;29898;;-1:-1:-1;29912:13:0;;-1:-1:-1;29926:13:0;-1:-1:-1;29254:694:0;-1:-1:-1;;;;;29254:694:0:o;37384:619::-;37444:4;37912:20;;37755:66;37952:23;;;;;;:42;;-1:-1:-1;;37979:15:0;;;37944:51;-1:-1:-1;;37384:619:0:o;55384:333::-;55479:5;-1:-1:-1;;;;;55459:25:0;:16;55467:7;55459;:16::i;:::-;-1:-1:-1;;;;;55459:25:0;;55451:75;;;;-1:-1:-1;;;55451:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55539:23;55554:7;55539:14;:23::i;:::-;-1:-1:-1;;;;;55575:24:0;;;;;;:17;:24;;;;;:36;;:34;:36::i;:::-;55653:1;55622:20;;;:11;:20;;;;;;:33;;-1:-1:-1;;;;;;55622:33:0;;;55673:36;55634:7;;55653:1;-1:-1:-1;;;;;55673:36:0;;;;;55653:1;;55673:36;55384:333;;:::o;66745:1082::-;67023:10;:17;66998:22;;67023:24;;67045:1;67023:24;:21;:24;:::i;:::-;67058:18;67079:24;;;:15;:24;;;;;;67452:10;:26;;66998:49;;-1:-1:-1;67079:24:0;;66998:49;;67452:26;;;;;;;;;;;;;;67430:48;;67516:11;67491:10;67502;67491:22;;;;;;;;;;;;;;;;;;;:36;;;;67596:28;;;:15;:28;;;;;;:41;;;67761:10;:19;;;;;-1:-1:-1;;67761:19:0;;;:::i;:::-;-1:-1:-1;;;67818:1:0;67791:24;;;-1:-1:-1;67791:15:0;:24;;;;;:28;66745:1082::o;54772:335::-;-1:-1:-1;;;;;54844:16:0;;54836:61;;;;;-1:-1:-1;;;54836:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54917:16;54925:7;54917;:16::i;:::-;54916:17;54908:58;;;;;-1:-1:-1;;;54908:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54979:20;;;;:11;:20;;;;;;;;:25;;-1:-1:-1;;;;;;54979:25:0;-1:-1:-1;;;;;54979:25:0;;;;;;;;55015:21;;:17;:21;;;;;:33;;:31;:33::i;:::-;55066;;55091:7;;-1:-1:-1;;;;;55066:33:0;;;55083:1;;55066:33;;55083:1;;55066:33;54772:335;;:::o;64511:164::-;64615:10;:17;;64588:24;;;;:15;:24;;;;;:44;;;39:1:-1;23:18;;45:23;;64643:24:0;;;;;;;64511:164::o;58741:175::-;58841:1;58805:24;;;:15;:24;;;;;;-1:-1:-1;;;;;58805:24:0;:38;58801:108;;58895:1;58860:24;;;:15;:24;;;;;:37;;-1:-1:-1;;;;;;58860:37:0;;;58741:175::o;41127:110::-;41208:14;;:21;;41227:1;41208:21;:18;:21;:::i;:::-;41191:38;;41127:110::o;40938:181::-;41092:19;;41110:1;41092:19;;;40938:181::o;29960:134::-;30009:4;;30040:20;30053:6;30045:5;:14;30040:4;:20::i;:::-;30085:1;30078:8;;;;-1:-1:-1;;;29960:134:0:o;30106:1808::-;30644:4;30638:11;;30683:66;30663:87;;30784:66;30777:4;30771:11;;30764:87;30885:66;30872:11;;;30865:87;30986:66;30979:4;30973:11;;30966:87;31087:66;31080:4;31074:11;;31067:87;31188:66;31181:4;31175:11;;31168:87;31289:66;31282:4;31276:11;;31269:87;31390:66;31383:4;31377:11;;31370:87;30372:5;31484:13;;;31471:27;;;-1:-1:-1;;;30224:1:0;-1:-1:-1;;;30497:19:0;-1:-1:-1;;;30411:7:0;30334:4;30296;30258;-1:-1:-1;;30218:8:0;;30251:12;;;30245:19;30289:12;;;30283:19;30327:12;;;30321:19;30365:13;;;30359:20;30404:15;;;30398:22;30445:19;;;30439:26;30490:27;;;30484:34;30543:43;;;30537:50;30606:9;31525:64;31708:13;31704:25;;;31768:3;31764:10;31758:17;;;31752:24;31748:36;-1:-1:-1;;;31819:75:0;;;31810:85;31803:93;;30172:1735::o;79513:16334::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;79513:16334:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79513:16334:0;;;-1:-1:-1;79513:16334:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;-1:-1;79513:16334:0;;;-1:-1:-1;;79513:16334:0:o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;-1:-1;79513:16334:0;;;-1:-1:-1;;79513:16334:0:o;:::-;;;;;;;;;;;;;;;;;

Swarm Source

bzzr://c9e817698a057934e22880c94c1deb0c8c11ede3b646d6735cef33ef22692a19
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.