Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-10-25
*/

// SPDX-License-Identifier: MIT AND UNLICENSED

pragma solidity ^0.6.2;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = byte(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}


/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        return _get(map, key, "EnumerableMap: nonexistent key");
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

   /**
    * @dev Returns the element stored at position `index` in the set. O(1).
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint256(value)));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint256(_get(map._inner, bytes32(key))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
    }
}


/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}




/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}




/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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


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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}




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

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

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

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

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

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

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

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

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

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

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

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


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

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

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


/**
 * @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) public view override 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 virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

/**
 * @dev Contract module that can be used to recover ERC20 compatible tokens stuck in the contract.
 */
contract ERC20Recoverable is Ownable {
    /**
     * @dev Used to transfer tokens stuck on this contract to another address.
     */
    function recoverERC20(address token, address recipient, uint256 amount) external onlyOwner returns (bool) {
        return IERC20(token).transfer(recipient, amount);
    }

    /**
     * @dev Used to approve recovery of stuck tokens. May also be used to approve token transfers in advance.
     */
     function recoverERC20Approve(address token, address spender, uint256 amount) external onlyOwner returns (bool) {
        return IERC20(token).approve(spender, amount);
    }
}


/**
 * @dev Contract module that can be used to recover ERC20 compatible tokens stuck in the contract.
 */
contract ERC721Recoverable is Ownable {
    /**
     * @dev Used to recover a stuck token.
     */
    function recoverERC721(address token, address recipient, uint256 tokenId) external onlyOwner {
        return IERC721(token).transferFrom(address(this), recipient, tokenId);
    }

    /**
     * @dev Used to recover a stuck token using the safe transfer function of ERC721.
     */
    function recoverERC721Safe(address token, address recipient, uint256 tokenId) external onlyOwner {
        return IERC721(token).safeTransferFrom(address(this), recipient, tokenId);
    }

    /**
     * @dev Used to approve the recovery of a stuck token.
     */
    function recoverERC721Approve(address token, address recipient, uint256 tokenId) external onlyOwner {
        return IERC721(token).approve(recipient, tokenId);
    }

    /**
     * @dev Used to approve the recovery of stuck token, also in future.
     */
    function recoverERC721ApproveAll(address token, address recipient, bool approved) external onlyOwner {
        return IERC721(token).setApprovalForAll(recipient, approved);
    }
}

/**
 * @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
 */
contract T2 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // 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 holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Base URI
    string private _baseURI;

    // Specified if tokens are transferable. Can be flipped by the owner.
    bool private _transferable;

    // Price per token. Is chosen and can be changed by contract owner.
    uint256 private _tokenPrice;

    // Counter for token id
    uint256 private _nextId = 1;

    /*
     *     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 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     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 Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor (string memory name, string memory symbol, string memory baseURI, bool transferable, uint256 tokenPrice) public {
        _name = name;
        _symbol = symbol;
        _baseURI = baseURI;
        _transferable = transferable;
        _tokenPrice = tokenPrice;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

// public functions:
    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) external view override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");

        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() external view override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() external view override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) external view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(_baseURI, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() external view returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev Returns if tokens are globally transferable currently. That may be decided by the contract owner.
     */
    function transferable() external view returns (bool) {
        return _transferable;
    }

    /**
     * @dev Price per token for public purchase.
     */
    function tokenPrice() external view returns (uint256) {
        return _tokenPrice;
    }

    /**
     * @dev Next token id.
     */
    function nextTokenId() public view returns (uint256) {
        return _nextId;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() external view override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) external view override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) external virtual override {
        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"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) external virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) external virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    function buyToken() external payable returns (bool)
    {
        uint256 paidAmount = msg.value;
        require(paidAmount == _tokenPrice, "Invalid amount for token purchase");
        _mint(msg.sender, nextTokenId());
        _incrementTokenId();
        payable(owner()).transfer(paidAmount);
        return true;
    }

    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public returns (bool) {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved");
        _burn(tokenId);
        return true;
    }

    function burnAnyFrom(address burner) public returns (bool) {
        require(_holderTokens[burner].length() > 0, "Address does not have any tokens to burn");
        return burn(_holderTokens[burner].at(0));
    }

    function burnAny() external returns (bool) {
        return burnAnyFrom(msg.sender);
    }

// owner functions:
    /**
     * @dev Function to set the base URI for all token IDs. It is automatically added as a prefix to the token id in {tokenURI} to retrieve the token URI.
     */
    function setBaseURI(string calldata baseURI_) external onlyOwner {
        _baseURI = baseURI_;
    }

    /**
     * @dev Function for the contract owner to allow or disallow token transfers.
     */
    function setTransferable(bool allowed) external onlyOwner {
        _transferable = allowed;
    }

    /**
     * @dev Sets a new token price.
     */
    function setTokenPrice(uint256 newPrice) external onlyOwner {
        _tokenPrice = newPrice;
    }

// internal functions:
    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) private {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) private view returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) private 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 Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) private {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) private {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) private {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ownerOf(tokenId);

        // Clear approvals
        _approve(address(0), tokenId);
        _holderTokens[owner].remove(tokenId);
        _tokenOwners.remove(tokenId);

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - contract owner must have transfer globally allowed.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) private {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");
        require(_transferable == true, "ERC721 transfer not permitted by contract owner");

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(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.
     *
     * @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) private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

    function _incrementTokenId() private {
        _nextId = _nextId.add(1);
    }
}


/**
 * @dev Most credited to OpenZeppelin ERC721.sol, but with some adjustments.
 */
contract T1 is Context, Ownable, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, ERC20Recoverable, ERC721Recoverable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // 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 holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // ERC721 token contract address serving as "ticket" to flip the bool in additional data
    address private _ticketContract;

    // Base URI
    string private _baseURI;

    // Price per token. Is chosen and can be changed by contract owner.
    uint256 private _tokenPrice;

    struct AdditionalData {
        bool isA; // A (true) or B (false)
        bool someBool; // may be flipped by token owner if he owns T2; default value in _mint
        uint8 power;
    }

    // Mapping from token ID to its additional data
    mapping (uint256 => AdditionalData) private _additionalData;

    // Counter for token id, and types
    uint256 private _nextId = 1;
    uint32 private _countA = 0; // count of B is implicit and not needed

    mapping (address => bool) public freeBoolSetters; // addresses which do not need to pay to set the bool variable

    // limits
    uint256 public constant MAX_SUPPLY = 7000;
    uint32 public constant MAX_A = 1000;
    uint32 public constant MAX_B = 6000;

    /*
     *     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 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     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 Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor (string memory name, string memory symbol, string memory baseURI, uint256 tokenPrice, address ticketContract) public {
        _name = name;
        _symbol = symbol;
        _baseURI = baseURI;
        _tokenPrice = tokenPrice;
        _ticketContract = ticketContract;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

// public functions:
    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");

        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() external view override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() external view override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) external view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(_baseURI, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() external view returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev Retrieves address of the ticket token contract.
     */
    function ticketContract() external view returns (address) {
        return _ticketContract;
    }

    /**
     * @dev Price per token for public purchase.
     */
    function tokenPrice() external view returns (uint256) {
        return _tokenPrice;
    }

    /**
     * @dev Next token id.
     */
    function nextTokenId() public view returns (uint256) {
        return _nextId;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view override returns (uint256) {
        require(index < balanceOf(owner), "Invalid token index for holder");
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() external view override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev Supply of A tokens.
     */
    function supplyOfA() external view returns (uint256) {
        return _countA;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) external view override returns (uint256) {
        require(index < _tokenOwners.length(), "Invalid token index");
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) external virtual override {
        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"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) external virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) external virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Buys a token. Needs to be supplied the correct amount of ether.
     */
    function buyToken() external payable returns (bool)
    {
        uint256 paidAmount = msg.value;
        require(paidAmount == _tokenPrice, "Invalid amount for token purchase");
        address to = msg.sender;
        uint256 nextToken = nextTokenId();
        uint256 remainingTokens = 1 + MAX_SUPPLY - nextToken;
        require(remainingTokens > 0, "Maximum supply already reached");

        _holderTokens[to].add(nextToken);
        _tokenOwners.set(nextToken, to);

        uint256 remainingA = MAX_A - _countA;
        bool a = (uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), now, nextToken))) % remainingTokens) < remainingA;
        uint8 pow = uint8(uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), now + 1, nextToken))) % (a ? 21 : 79) + (a ? 80 : 1));
        _additionalData[nextToken] = AdditionalData(a, false, pow);

        if (a) {
            _countA = _countA + 1;
        }

        emit Transfer(address(0), to, nextToken);
        _nextId = nextToken.add(1);

        payable(owner()).transfer(paidAmount);
        return true;
    }

    function buy6Tokens() external payable returns (bool)
    {
        uint256 paidAmount = msg.value;
        require(paidAmount == (_tokenPrice * 5 + _tokenPrice / 2), "Invalid amount for token purchase"); // price for 6 tokens is 5.5 times the price for one token
        address to = msg.sender;
        uint256 nextToken = nextTokenId();
        uint256 remainingTokens = 1 + MAX_SUPPLY - nextToken;
        require(remainingTokens > 5, "Maximum supply already reached");
        uint256 endLoop = nextToken.add(6);

        while (nextToken < endLoop) {
            _holderTokens[to].add(nextToken);
            _tokenOwners.set(nextToken, to);

            uint256 remainingA = MAX_A - _countA;
            bool a = (uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), now, nextToken))) % remainingTokens) < remainingA;
            uint8 pow = uint8(uint256(keccak256(abi.encodePacked(blockhash(block.number - 1), now + 1, nextToken))) % (a ? 21 : 79) + (a ? 80 : 1));
            _additionalData[nextToken] = AdditionalData(a, false, pow);

            if (a) {
                _countA = _countA + 1;
            }

            emit Transfer(address(0), to, nextToken);
            nextToken = nextToken.add(1);
            remainingTokens = remainingTokens.sub(1);
        }

        _nextId = _nextId.add(6);

        payable(owner()).transfer(paidAmount);
        return true;
    }

    /**
     * @dev Retrieves if the specified token is of A type.
     */
    function isA(uint256 tokenId) external view returns (bool) {
        require(_exists(tokenId), "Token ID does not exist");
        return _additionalData[tokenId].isA;
    }

    /**
     * @dev Retrieves if the specified token has its someBool attribute set.
     */
    function someBool(uint256 tokenId) external view returns (bool) {
        require(_exists(tokenId), "Token ID does not exist");
        return _additionalData[tokenId].someBool;
    }

    /**
     * @dev Sets someBool for the specified token. Can only be used by the owner of the token (not an approved account).
     * Owner needs to also own a ticket token to set the someBool attribute.
     */
    function setSomeBool(uint256 tokenId, bool newValue) external {
        require(_exists(tokenId), "Token ID does not exist");
        require(ownerOf(tokenId) == msg.sender, "Only token owner can set attribute");

        if (freeBoolSetters[msg.sender] == false && _additionalData[tokenId].someBool != newValue) {
            require(T2(_ticketContract).burnAnyFrom(msg.sender), "Token owner ticket could not be burned");
        }

        _additionalData[tokenId].someBool = newValue;
    }

    /**
     * @dev Retrieves the power value for a specified token.
     */
    function power(uint256 tokenId) external view returns (uint8) {
        require(_exists(tokenId), "Token ID does not exist");
        return _additionalData[tokenId].power;
    }

// owner functions:
    /**
     * @dev Function to set the base URI for all token IDs. It is automatically added as a prefix to the token id in {tokenURI} to retrieve the token URI.
     */
    function setBaseURI(string calldata baseURI_) external onlyOwner {
        _baseURI = baseURI_;
    }

    /**
     * @dev Sets a new token price.
     */
    function setTokenPrice(uint256 newPrice) external onlyOwner {
        _tokenPrice = newPrice;
    }

    function setFreeBoolSetter(address holder, bool setForFree) external onlyOwner {
        freeBoolSetters[holder] = setForFree;
    }

// internal functions:
    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) private {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`).
     */
    function _exists(uint256 tokenId) private view returns (bool) {
        return tokenId < _nextId && _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) private 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 Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - contract owner must have transfer globally allowed.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) private {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(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.
     *
     * @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) private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }
}


/**
 *
 */
contract NFTeGG_Farm_1 is Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    event StakeERC20(address indexed user, address indexed token, uint256 value);
    event UnstakeERC20(address indexed user, address indexed token, uint256 value);
    event StakeT1(address indexed user, uint256 indexed tokenid);
    event UnstakeT1(address indexed user, uint256 indexed tokenid);
    event Payout(address indexed user, uint256 value);

    uint public constant BLOCKTIME_PENALTY_THRESHOLD = 3600 * 72; // minimum time (in seconds) for staking to receive payout without penalty

    address public constant T1_ADDRESS = address(0x10a7ecF97c46e3229fE1B801a5943153762e0cF0); // address of T1 contract (ERC721) used for staking
    address public constant T3_ADDRESS = address(0xD821E91DB8aED33641ac5D122553cf10de49c8eF); // address of T3 contract (ERC20) used for distributing rewards

    uint256 public constant T1_BOOL_MUL_TRUE = 12;
    uint256 public constant T1_BOOL_MUL_FALSE = 8;
    uint256 public constant T1_BOOL_DIVI = 10;

    uint256 public t1StakeFactor; // stake payout per power and block for staked T1

    mapping (address => uint256) public accumulatedPayouts; // mapping from address to current accumulated payouts; only updated on new stakes on top of an already staked erc20 token and unstakes

    struct StakingDataERC20 {
        uint256 tokenStaked;
        uint setupBlock;
        uint setupTime;
    }

    struct StakeFactorERC20 {
        uint128 multi;
        uint128 divi;
    }

    address[] public supportedTokensERC20;
    mapping (address => StakeFactorERC20) public erc20StakeFactors; // maps ERC20 token address to its stake factor
    mapping (address => mapping (address => StakingDataERC20)) public erc20Stakes; // mapping (<user address> => mapping (<token address> => <stake data>))

    struct StakingDataT1 {
        uint setupBlock;
        uint setupTime;
    }

    mapping (uint256 => address) public stakedT1Holders; // maps which token id is staked by which user
    mapping (address => mapping (uint256 => StakingDataT1)) public t1Stakes; // maps staker address onto a mapping from tokenid to the struct specifying when the stake was made
    mapping(address => uint256[]) public _nftStake;
    mapping(uint256 => uint256) public _nftMapIndex;

    // ctor
    constructor (uint256 t1StakeFactor_) public {
        t1StakeFactor = t1StakeFactor_;
    }

    // views
    function calcCurrentPayoutERC20(address user, address token) public view returns (uint256) {
        uint stakeBlock = erc20Stakes[user][token].setupBlock;
        require(stakeBlock != 0, "User has no stake");

        if ((block.timestamp - erc20Stakes[user][token].setupTime) >= BLOCKTIME_PENALTY_THRESHOLD) { // normal payout if minimum time was reached
            return (block.number - stakeBlock) * erc20Stakes[user][token].tokenStaked * erc20StakeFactors[token].multi / erc20StakeFactors[token].divi;
        } else { // 90% payout if minimum time was not reached
            return (block.number - stakeBlock) * erc20Stakes[user][token].tokenStaked * erc20StakeFactors[token].multi / erc20StakeFactors[token].divi * 9 / 10;
        }
    }

    function calcCurrentPayoutT1(address user, uint256 tokenid) public view returns (uint256) {
        uint stakeBlock = t1Stakes[user][tokenid].setupBlock;
        require(stakeBlock != 0, "User did not stake that token");

        if ((block.timestamp - t1Stakes[user][tokenid].setupTime) >= BLOCKTIME_PENALTY_THRESHOLD) { // normal payout if minimum time was reached
            return (block.number - stakeBlock) * T1(T1_ADDRESS).power(tokenid) * t1StakeFactor * (T1(T1_ADDRESS).someBool(tokenid) ? T1_BOOL_MUL_TRUE : T1_BOOL_MUL_FALSE) / T1_BOOL_DIVI;
        } else { // 90% payout if minimum time was not reached
            return (block.number - stakeBlock) * T1(T1_ADDRESS).power(tokenid) * t1StakeFactor * 9 * (T1(T1_ADDRESS).someBool(tokenid) ? T1_BOOL_MUL_TRUE : T1_BOOL_MUL_FALSE) / T1_BOOL_DIVI / 10;
        }
    }

    // user stuff
    function processAccumulatedPayout() external {
        address user = msg.sender;
        uint256 payout = accumulatedPayouts[user];
        require(payout > 0, "No payout pending");
        uint256 reserve = IERC20(T3_ADDRESS).balanceOf(address(this));
        require(reserve > 0, "Unable to process any more payouts");

        if (reserve >= payout) {
            delete accumulatedPayouts[user];
            IERC20(T3_ADDRESS).safeTransfer(user, payout);
            Payout(user, payout);
        } else {
            accumulatedPayouts[user] = payout - reserve;
            IERC20(T3_ADDRESS).safeTransfer(user, reserve);
            Payout(user, reserve);
        }
    }

    function stakeERC20(address token, uint256 value) external {
        require(erc20StakeFactors[token].multi != 0, "ERC20 token not stakeable");
        address user = msg.sender;
        uint256 currentStake = erc20Stakes[user][token].tokenStaked;

        if (currentStake > 0) { // there already was a current stake, so the payout since last time has to be accumulated
            accumulatedPayouts[user] = accumulatedPayouts[user].add(calcCurrentPayoutERC20(user, token));
        }

        IERC20(token).safeTransferFrom(user, address(this), value);
        erc20Stakes[user][token].tokenStaked = currentStake.add(value);
        erc20Stakes[user][token].setupBlock = block.number;
        erc20Stakes[user][token].setupTime = block.timestamp;
        StakeERC20(user, token, value);
    }

    function unstakeERC20(address token) external {
        address user = msg.sender;
        require(erc20Stakes[user][token].tokenStaked != 0, "User did not stake any token");

        uint256 payout = accumulatedPayouts[user] + calcCurrentPayoutERC20(user, token);
        uint256 currentStake = erc20Stakes[user][token].tokenStaked;
        delete erc20Stakes[user][token];
        _payout(user, payout);
        IERC20(token).safeTransfer(user, currentStake);
        UnstakeERC20(user, token, currentStake);
    }

    function payoutRewardERC20(address token) external {
        address user = msg.sender;
        require(erc20Stakes[user][token].tokenStaked != 0, "User did not stake any token");

        uint256 payout = accumulatedPayouts[user] + calcCurrentPayoutERC20(user, token);
        erc20Stakes[user][token].setupBlock = block.number;
        _payout(user, payout);
    }

    function stakeT1(uint256 tokenid) external {
        address user = msg.sender;
        IERC721(T1_ADDRESS).transferFrom(user, address(this), tokenid);
        stakedT1Holders[tokenid] = user;
        t1Stakes[user][tokenid] = StakingDataT1(block.number, block.timestamp);
        uint256[] storage nftIds = _nftStake[msg.sender];
        if (nftIds.length == 0) {
        nftIds.push(0);    
        _nftMapIndex[0] = 0;
        }
        nftIds.push(tokenid);
        _nftMapIndex[tokenid] = nftIds.length - 1;
        StakeT1(user, tokenid);
    }

    function unstakeT1(uint256 tokenid) external {
        address user = msg.sender;
        require(stakedT1Holders[tokenid] == user, "User did not stake the specified token");
        delete stakedT1Holders[tokenid];
        uint256 payout = accumulatedPayouts[user] + calcCurrentPayoutT1(user, tokenid);
        delete t1Stakes[user][tokenid];
        _payout(user, payout);
        T1(T1_ADDRESS).setSomeBool(tokenid, false);
        IERC721(T1_ADDRESS).transferFrom(address(this), user, tokenid);
        
        uint256[] memory gegoIds = _nftStake[msg.sender];
        uint256 nftIndex = _nftMapIndex[tokenid]; 
        uint256 gegoArrayLength = gegoIds.length-1;
        uint256 tailId = gegoIds[gegoArrayLength];
        _nftStake[msg.sender][nftIndex] = tailId;
        _nftStake[msg.sender][gegoArrayLength] = 0;
        _nftStake[msg.sender].pop();
        _nftMapIndex[tailId] = nftIndex;
        _nftMapIndex[tokenid] = 0;
        
        UnstakeT1(user, tokenid);
    }

    function payoutRewardT1(uint256 tokenid) external {
        address user = msg.sender;
        require(stakedT1Holders[tokenid] == user, "User did not stake the specified token");
        uint256 payout = accumulatedPayouts[user] + calcCurrentPayoutT1(user, tokenid);
        t1Stakes[user][tokenid].setupBlock = block.number;
        _payout(user, payout);
    }

    // owner stuff
    function addERC20ForStaking(address erc20ContractAddress, uint128 stakeFactorMulti, uint128 stakeFactorDivi) onlyOwner external {
        require(stakeFactorDivi != 0, "Divi cannot be 0");

        if (erc20StakeFactors[erc20ContractAddress].divi == 0) {
            supportedTokensERC20.push(erc20ContractAddress);
        }

        erc20StakeFactors[erc20ContractAddress] = StakeFactorERC20(stakeFactorMulti, stakeFactorDivi);
    }

    function changeFactorT1(uint256 newFactor) onlyOwner external {
        t1StakeFactor = newFactor;
    }

    // internal
    function _payout(address user, uint256 payout) internal {
        uint256 reserve = IERC20(T3_ADDRESS).balanceOf(address(this));

        if (reserve >= payout) {
            delete accumulatedPayouts[user];
            IERC20(T3_ADDRESS).safeTransfer(user, payout);
            Payout(user, payout);
        } else {
            accumulatedPayouts[user] = payout - reserve;

            if (reserve > 0) {
                IERC20(T3_ADDRESS).safeTransfer(user, reserve);
                Payout(user, reserve);
            }
        }
    }
    
    function getNftIDs( address account ) public view returns( uint256[] memory tokenid )
    {
        tokenid = _nftStake[account];
    }
    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"t1StakeFactor_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Payout","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"StakeERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenid","type":"uint256"}],"name":"StakeT1","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"UnstakeERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenid","type":"uint256"}],"name":"UnstakeT1","type":"event"},{"inputs":[],"name":"BLOCKTIME_PENALTY_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T1_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T1_BOOL_DIVI","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T1_BOOL_MUL_FALSE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T1_BOOL_MUL_TRUE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T3_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_nftMapIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"_nftStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"accumulatedPayouts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"erc20ContractAddress","type":"address"},{"internalType":"uint128","name":"stakeFactorMulti","type":"uint128"},{"internalType":"uint128","name":"stakeFactorDivi","type":"uint128"}],"name":"addERC20ForStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"token","type":"address"}],"name":"calcCurrentPayoutERC20","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"tokenid","type":"uint256"}],"name":"calcCurrentPayoutT1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newFactor","type":"uint256"}],"name":"changeFactorT1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"erc20StakeFactors","outputs":[{"internalType":"uint128","name":"multi","type":"uint128"},{"internalType":"uint128","name":"divi","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"erc20Stakes","outputs":[{"internalType":"uint256","name":"tokenStaked","type":"uint256"},{"internalType":"uint256","name":"setupBlock","type":"uint256"},{"internalType":"uint256","name":"setupTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getNftIDs","outputs":[{"internalType":"uint256[]","name":"tokenid","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"payoutRewardERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenid","type":"uint256"}],"name":"payoutRewardT1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"processAccumulatedPayout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"stakeERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenid","type":"uint256"}],"name":"stakeT1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakedT1Holders","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"supportedTokensERC20","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"t1StakeFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"t1Stakes","outputs":[{"internalType":"uint256","name":"setupBlock","type":"uint256"},{"internalType":"uint256","name":"setupTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"unstakeERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenid","type":"uint256"}],"name":"unstakeT1","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : t1StakeFactor_ (uint256): 0

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000

88273:9838:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92402:694;;;:::i;:::-;;90772:758;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;90252:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;95407:1004;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;88888:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;89300:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;90005:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94455:373;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;89248:45;;;:::i;:::-;;;;;;;;;;;;;;;;;;;97267:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;90535:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;94836:563;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;89350:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;96816:443;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;89035:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;37543:148;;;:::i;:::-;;97964:138;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96419:369;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;36901:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;90588:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;88744:60;;;:::i;:::-;;;;;;;;;;;;;;;;;;;91538:837;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;89844:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;89196:45;;;:::i;:::-;;;;;;;;;;;;;;;;;;;89437:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;93104:809;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;89888:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90357:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;37846:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;93921:526;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;92402:694;92458:12;92473:10;92458:25;;92494:14;92511:18;:24;92530:4;92511:24;;;;;;;;;;;;;;;;92494:41;;92563:1;92554:6;:10;92546:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92597:15;89080:42;92615:28;;;92652:4;92615:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92597:61;;92687:1;92677:7;:11;92669:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92755:6;92744:7;:17;92740:349;;92785:18;:24;92804:4;92785:24;;;;;;;;;;;;;;;92778:31;;;92824:45;92856:4;92862:6;89080:42;92824:31;;;;:45;;;;;:::i;:::-;92891:4;92884:20;;;92897:6;92884:20;;;;;;;;;;;;;;;;;;92740:349;;;92973:7;92964:6;:16;92937:18;:24;92956:4;92937:24;;;;;;;;;;;;;;;:43;;;;92995:46;93027:4;93033:7;89080:42;92995:31;;;;:46;;;;;:::i;:::-;93063:4;93056:21;;;93069:7;93056:21;;;;;;;;;;;;;;;;;;92740:349;92402:694;;;:::o;90772:758::-;90854:7;90874:15;90892:11;:17;90904:4;90892:17;;;;;;;;;;;;;;;:24;90910:5;90892:24;;;;;;;;;;;;;;;:35;;;90874:53;;90960:1;90946:10;:15;;90938:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88795:9;91019:11;:17;91031:4;91019:17;;;;;;;;;;;;;;;:24;91037:5;91019:24;;;;;;;;;;;;;;;:34;;;91001:15;:52;91000:85;90996:527;;91256:17;:24;91274:5;91256:24;;;;;;;;;;;;;;;:29;;;;;;;;;;;;91154:131;;91223:17;:24;91241:5;91223:24;;;;;;;;;;;;;;;:30;;;;;;;;;;;;91154:99;;91184:11;:17;91196:4;91184:17;;;;;;;;;;;;;;;:24;91202:5;91184:24;;;;;;;;;;;;;;;:36;;;91170:10;91155:12;:25;91154:66;:99;:131;;;;;;91147:138;;;;;90996:527;91509:2;91505:1;91473:17;:24;91491:5;91473:24;;;;;;;;;;;;;;;:29;;;;;;;;;;;;91371:131;;91440:17;:24;91458:5;91440:24;;;;;;;;;;;;;;;:30;;;;;;;;;;;;91371:99;;91401:11;:17;91413:4;91401:17;;;;;;;;;;;;;;;:24;91419:5;91401:24;;;;;;;;;;;;;;;:36;;;91387:10;91372:12;:25;91371:66;:99;:131;;;;;;:135;:140;;;;;;91364:147;;;90772:758;;;;;:::o;90252:51::-;;;;;;;;;;;;;;;;;;;;;;:::o;95407:1004::-;95463:12;95478:10;95463:25;;95535:4;95507:32;;:15;:24;95523:7;95507:24;;;;;;;;;;;;;;;;;;;;;:32;;;95499:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95600:15;:24;95616:7;95600:24;;;;;;;;;;;;95593:31;;;;;;;;;;;95635:14;95679:34;95699:4;95705:7;95679:19;:34::i;:::-;95652:18;:24;95671:4;95652:24;;;;;;;;;;;;;;;;:61;95635:78;;95731:8;:14;95740:4;95731:14;;;;;;;;;;;;;;;:23;95746:7;95731:23;;;;;;;;;;;;95724:30;;;;;;;;;;;;;;95765:21;95773:4;95779:6;95765:7;:21::i;:::-;88933:42;95797:26;;;95824:7;95833:5;95797:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88933;95850:32;;;95891:4;95898;95904:7;95850:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95933:24;95960:9;:21;95970:10;95960:21;;;;;;;;;;;;;;;95933:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95992:16;96011:12;:21;96024:7;96011:21;;;;;;;;;;;;95992:40;;96044:23;96085:1;96070:7;:14;:16;96044:42;;96097:14;96114:7;96122:15;96114:24;;;;;;;;;;;;;;96097:41;;96183:6;96149:9;:21;96159:10;96149:21;;;;;;;;;;;;;;;96171:8;96149:31;;;;;;;;;;;;;;;:40;;;;96241:1;96200:9;:21;96210:10;96200:21;;;;;;;;;;;;;;;96222:15;96200:38;;;;;;;;;;;;;;;:42;;;;96253:9;:21;96263:10;96253:21;;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;;;;;;;96314:8;96291:12;:20;96304:6;96291:20;;;;;;;;;;;:31;;;;96357:1;96333:12;:21;96346:7;96333:21;;;;;;;;;;;:25;;;;96395:7;96389:4;96379:24;;;;;;;;;;;;95407:1004;;;;;;;:::o;88888:88::-;88933:42;88888:88;:::o;89300:41::-;89339:2;89300:41;:::o;90005:77::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;94455:373::-;94517:12;94532:10;94517:25;;94601:1;94561:11;:17;94573:4;94561:17;;;;;;;;;;;;;;;:24;94579:5;94561:24;;;;;;;;;;;;;;;:36;;;:41;;94553:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94648:14;94692:35;94715:4;94721:5;94692:22;:35::i;:::-;94665:18;:24;94684:4;94665:24;;;;;;;;;;;;;;;;:62;94648:79;;94776:12;94738:11;:17;94750:4;94738:17;;;;;;;;;;;;;;;:24;94756:5;94738:24;;;;;;;;;;;;;;;:35;;:50;;;;94799:21;94807:4;94813:6;94799:7;:21::i;:::-;94455:373;;;:::o;89248:45::-;89292:1;89248:45;:::o;97267:106::-;37123:12;:10;:12::i;:::-;37113:22;;:6;;;;;;;;;;:22;;;37105:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97356:9:::1;97340:13;:25;;;;97267:106:::0;:::o;90535:46::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;94836:563::-;94890:12;94905:10;94890:25;;88933:42;94926:32;;;94959:4;94973;94980:7;94926:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95026:4;94999:15;:24;95015:7;94999:24;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;95067:44;;;;;;;;95081:12;95067:44;;;;95095:15;95067:44;;;95041:8;:14;95050:4;95041:14;;;;;;;;;;;;;;;:23;95056:7;95041:23;;;;;;;;;;;:70;;;;;;;;;;;;;;;;;;;95122:24;95149:9;:21;95159:10;95149:21;;;;;;;;;;;;;;;95122:48;;95202:1;95185:6;:13;;;;:18;95181:95;;;95216:6;95228:1;95216:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95263:1;95245:12;:15;95258:1;95245:15;;;;;;;;;;;:19;;;;95181:95;95286:6;95298:7;95286:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95357:1;95341:6;:13;;;;:17;95317:12;:21;95330:7;95317:21;;;;;;;;;;;:41;;;;95383:7;95377:4;95369:22;;;;;;;;;;;;94836:563;;;:::o;89350:28::-;;;;:::o;96816:443::-;37123:12;:10;:12::i;:::-;37113:22;;:6;;;;;;;;;;:22;;;37105:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96982:1:::1;96963:15;:20;;;;96955:49;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;97069:1;97021:17;:39;97039:20;97021:39;;;;;;;;;;;;;;;:44;;;;;;;;;;;;:49;;;97017:129;;;97087:20;97113;97087:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97017:129;97200:51;;;;;;;;97217:16;97200:51;;;;;;97235:15;97200:51;;;;::::0;97158:17:::1;:39;97176:20;97158:39;;;;;;;;;;;;;;;:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96816:443:::0;;;:::o;89035:88::-;89080:42;89035:88;:::o;37543:148::-;37123:12;:10;:12::i;:::-;37113:22;;:6;;;;;;;;;;:22;;;37105:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37650:1:::1;37613:40;;37634:6;::::0;::::1;;;;;;;;37613:40;;;;;;;;;;;;37681:1;37664:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;37543:148::o:0;97964:138::-;98023:24;98076:9;:18;98086:7;98076:18;;;;;;;;;;;;;;;98066:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97964:138;;;:::o;96419:369::-;96480:12;96495:10;96480:25;;96552:4;96524:32;;:15;:24;96540:7;96524:24;;;;;;;;;;;;;;;;;;;;;:32;;;96516:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;96610:14;96654:34;96674:4;96680:7;96654:19;:34::i;:::-;96627:18;:24;96646:4;96627:24;;;;;;;;;;;;;;;;:61;96610:78;;96736:12;96699:8;:14;96708:4;96699:14;;;;;;;;;;;;;;;:23;96714:7;96699:23;;;;;;;;;;;:34;;:49;;;;96759:21;96767:4;96773:6;96759:7;:21::i;:::-;96419:369;;;:::o;36901:79::-;36939:7;36966:6;;;;;;;;;;;36959:13;;36901:79;:::o;90588:47::-;;;;;;;;;;;;;;;;;:::o;88744:60::-;88795:9;88744:60;:::o;91538:837::-;91619:7;91639:15;91657:8;:14;91666:4;91657:14;;;;;;;;;;;;;;;:23;91672:7;91657:23;;;;;;;;;;;:34;;;91639:52;;91724:1;91710:10;:15;;91702:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88795:9;91795:8;:14;91804:4;91795:14;;;;;;;;;;;;;;;:23;91810:7;91795:23;;;;;;;;;;;:33;;;91777:15;:51;91776:84;91772:596;;89339:2;88933:42;92008:23;;;92032:7;92008:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:71;;89292:1;92008:71;;;89239:2;92008:71;91991:13;;88933:42;91959:20;;;91980:7;91959:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91929:59;;91945:10;91930:12;:25;91929:59;:75;:151;:166;;;;;;91922:173;;;;;91772:596;92354:2;89339;88933:42;92264:23;;;92288:7;92264:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:71;;89292:1;92264:71;;;89239:2;92264:71;92259:1;92243:13;;88933:42;92211:20;;;92232:7;92211:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92181:59;;92197:10;92182:12;:25;92181:59;:75;:79;:155;:170;;;;;;:175;;;;;;92174:182;;;91538:837;;;;;:::o;89844:37::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;89196:45::-;89239:2;89196:45;:::o;89437:54::-;;;;;;;;;;;;;;;;;:::o;93104:809::-;93216:1;93182:17;:24;93200:5;93182:24;;;;;;;;;;;;;;;:30;;;;;;;;;;;;:35;;;;93174:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;93258:12;93273:10;93258:25;;93294:20;93317:11;:17;93329:4;93317:17;;;;;;;;;;;;;;;:24;93335:5;93317:24;;;;;;;;;;;;;;;:36;;;93294:59;;93385:1;93370:12;:16;93366:231;;;93520:65;93549:35;93572:4;93578:5;93549:22;:35::i;:::-;93520:18;:24;93539:4;93520:24;;;;;;;;;;;;;;;;:28;;:65;;;;:::i;:::-;93493:18;:24;93512:4;93493:24;;;;;;;;;;;;;;;:92;;;;93366:231;93609:58;93640:4;93654;93661:5;93616;93609:30;;;;:58;;;;;;:::i;:::-;93717:23;93734:5;93717:12;:16;;:23;;;;:::i;:::-;93678:11;:17;93690:4;93678:17;;;;;;;;;;;;;;;:24;93696:5;93678:24;;;;;;;;;;;;;;;:36;;:62;;;;93789:12;93751:11;:17;93763:4;93751:17;;;;;;;;;;;;;;;:24;93769:5;93751:24;;;;;;;;;;;;;;;:35;;:50;;;;93849:15;93812:11;:17;93824:4;93812:17;;;;;;;;;;;;;;;:24;93830:5;93812:24;;;;;;;;;;;;;;;:34;;:52;;;;93892:5;93875:30;;93886:4;93875:30;;;93899:5;93875:30;;;;;;;;;;;;;;;;;;93104:809;;;;:::o;89888:62::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;90357:71::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;37846:244::-;37123:12;:10;:12::i;:::-;37113:22;;:6;;;;;;;;;;:22;;;37105:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37955:1:::1;37935:22;;:8;:22;;;;37927:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38045:8;38016:38;;38037:6;::::0;::::1;;;;;;;;38016:38;;;;;;;;;;;;38074:8;38065:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;37846:244:::0;:::o;93921:526::-;93978:12;93993:10;93978:25;;94062:1;94022:11;:17;94034:4;94022:17;;;;;;;;;;;;;;;:24;94040:5;94022:24;;;;;;;;;;;;;;;:36;;;:41;;94014:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94109:14;94153:35;94176:4;94182:5;94153:22;:35::i;:::-;94126:18;:24;94145:4;94126:24;;;;;;;;;;;;;;;;:62;94109:79;;94199:20;94222:11;:17;94234:4;94222:17;;;;;;;;;;;;;;;:24;94240:5;94222:24;;;;;;;;;;;;;;;:36;;;94199:59;;94276:11;:17;94288:4;94276:17;;;;;;;;;;;;;;;:24;94294:5;94276:24;;;;;;;;;;;;;;;;94269:31;;;;;;;;;;;;;;;;;;;;94311:21;94319:4;94325:6;94311:7;:21::i;:::-;94343:46;94370:4;94376:12;94350:5;94343:26;;;;:46;;;;;:::i;:::-;94419:5;94400:39;;94413:4;94400:39;;;94426:12;94400:39;;;;;;;;;;;;;;;;;;93921:526;;;;:::o;38656:177::-;38739:86;38759:5;38789:23;;;38814:2;38818:5;38766:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38739:19;:86::i;:::-;38656:177;;;:::o;97398:554::-;97465:15;89080:42;97483:28;;;97520:4;97483:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;97465:61;;97554:6;97543:7;:17;97539:406;;97584:18;:24;97603:4;97584:24;;;;;;;;;;;;;;;97577:31;;;97623:45;97655:4;97661:6;89080:42;97623:31;;;;:45;;;;;:::i;:::-;97690:4;97683:20;;;97696:6;97683:20;;;;;;;;;;;;;;;;;;97539:406;;;97772:7;97763:6;:16;97736:18;:24;97755:4;97736:24;;;;;;;;;;;;;;;:43;;;;97810:1;97800:7;:11;97796:138;;;97832:46;97864:4;97870:7;89080:42;97832:31;;;;:46;;;;;:::i;:::-;97904:4;97897:21;;;97910:7;97897:21;;;;;;;;;;;;;;;;;;97796:138;97539:406;97398:554;;;:::o;32068:106::-;32121:15;32156:10;32149:17;;32068:106;:::o;26234:181::-;26292:7;26312:9;26328:1;26324;:5;26312:17;;26353:1;26348;:6;;26340:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26406:1;26399:8;;;26234:181;;;;:::o;38841:205::-;38942:96;38962:5;38992:27;;;39021:4;39027:2;39031:5;38969:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38942:19;:96::i;:::-;38841:205;;;;:::o;40961:761::-;41385:23;41411:69;41439:4;41411:69;;;;;;;;;;;;;;;;;41419:5;41411:27;;;;:69;;;;;:::i;:::-;41385:95;;41515:1;41495:10;:17;:21;41491:224;;;41637:10;41626:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41618:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41491:224;40961:761;;;:::o;21051:195::-;21154:12;21186:52;21208:6;21216:4;21222:1;21225:12;21186:21;:52::i;:::-;21179:59;;21051:195;;;;;:::o;22103:530::-;22230:12;22288:5;22263:21;:30;;22255:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22355:18;22366:6;22355:10;:18::i;:::-;22347:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22481:12;22495:23;22522:6;:11;;22542:5;22550:4;22522:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22480:75;;;;22573:52;22591:7;22600:10;22612:12;22573:17;:52::i;:::-;22566:59;;;;22103:530;;;;;;:::o;18133:422::-;18193:4;18401:12;18512:7;18500:20;18492:28;;18546:1;18539:4;:8;18532:15;;;18133:422;;;:::o;24643:742::-;24758:12;24787:7;24783:595;;;24818:10;24811:17;;;;24783:595;24952:1;24932:10;:17;:21;24928:439;;;25195:10;25189:17;25256:15;25243:10;25239:2;25235:19;25228:44;25143:148;25338:12;25331:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24643:742;;;;;;:::o

ipfs://b2fad2e136141192d8b6d9c3921c8ebcf24970a25edb00abccf45abd0d6a2bd0