Token Posts

/**
 *Submitted for verification at Etherscan.io on 2021-08-25
*/

pragma solidity ^0.6.6;
pragma experimental ABIEncoderV2;
// SPDX-License-Identifier: MIT

/**
 * a contract must implement this interface in order to support relayed transaction.
 * It is better to inherit the BaseRelayRecipient as its implementation.
 */
abstract contract IRelayRecipient {

    /**
     * return if the forwarder is trusted to forward relayed transactions to us.
     * the forwarder is required to verify the sender's signature, and verify
     * the call is not a replay.
     */
    function isTrustedForwarder(address forwarder) public virtual view returns(bool);

    /**
     * return the sender of this call.
     * if the call came through our trusted forwarder, then the real sender is appended as the last 20 bytes
     * of the msg.data.
     * otherwise, return `msg.sender`
     * should be used in the contract anywhere instead of msg.sender
     */
    function _msgSender() internal virtual view returns (address payable);

    function versionRecipient() external virtual view returns (string memory);
}

/**
 * A base contract to be inherited by any contract that want to receive relayed transactions
 * A subclass must use "_msgSender()" instead of "msg.sender"
 */
abstract contract BaseRelayRecipient is IRelayRecipient {

    /*
     * Forwarder singleton we accept calls from
     */
    address public trustedForwarder;

    /*
     * require a function to be called through GSN only
     */
    modifier trustedForwarderOnly() {
        require(msg.sender == address(trustedForwarder), "Function can only be called through the trusted Forwarder");
        _;
    }

    function isTrustedForwarder(address forwarder) public override view returns(bool) {
        return forwarder == trustedForwarder;
    }

    /**
     * return the sender of this call.
     * if the call came through our trusted forwarder, return the original sender.
     * otherwise, return `msg.sender`.
     * should be used in the contract anywhere instead of msg.sender
     */
    function _msgSender() internal override virtual view returns (address payable ret) {
        if (msg.data.length >= 24 && isTrustedForwarder(msg.sender)) {
            // At this point we know that the sender is a trusted forwarder,
            // so we trust that the last bytes of msg.data are the verified sender address.
            // extract sender address from the end of msg.data
            assembly {
                ret := shr(96,calldataload(sub(calldatasize(),20)))
            }
        } else {
            return msg.sender;
        }
    }
}

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

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

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

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

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            revert("ECDSA: invalid signature length");
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            revert("ECDSA: invalid signature 's' value");
        }

        if (v != 27 && v != 28) {
            revert("ECDSA: invalid signature 'v' value");
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * replicates the behavior of the
     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
     * JSON-RPC method.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

/**
 * @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 Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transfered 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);
}

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


/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721Relayable is BaseRelayRecipient, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    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;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

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

    /*
     *     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) public {
        _name = name;
        _symbol = symbol;

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

    /**
     * @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() public view override returns (string memory) {
        return _name;
    }

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

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

        string memory _tokenURI = _tokenURIs[tokenId];

        // If there is no base URI, return the token URI.
        if (bytes(_baseURI).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(_baseURI, _tokenURI));
        }
        // 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() public view returns (string memory) {
        return _baseURI;
    }

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

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public 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) public view override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public 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) public 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) public 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) public 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 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 mecanisms 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) internal virtual {
        _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) internal 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) internal view returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev 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) internal virtual {
        _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) internal virtual {
        _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) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _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);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[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`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // 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 Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }

    function versionRecipient() external view override returns (string memory) {
        return "1";
    }
}

interface Maintainer {
    function isMaintainer(address addr) external view returns (bool);
}

contract NFPost is ERC721Relayable {
    address private maintainer;

    constructor(address _maintainer) public ERC721Relayable("Posts", "POST") {
        _setBaseURI("https://arweave.net/");
        maintainer = _maintainer;
        trustedForwarder = 0x86C80a8aa58e0A4fa09A69624c31Ab2a6CAD56b8;
    }

    function mintBatch(address[] memory tos, uint256[] memory tokenIds, string[] memory tokenURIs, bytes[] memory signatures) public {
        require(
            tos.length == tokenIds.length &&
            tos.length == tokenURIs.length &&
            tos.length == signatures.length,
            "NFPost: input length mismatch"
        );
        for (uint256 i = 0; i < tos.length; ++i) {
            bytes32 hash = ECDSA.toEthSignedMessageHash(keccak256(abi.encode(tos[i], tokenIds[i], tokenURIs[i])));
            address signer = ECDSA.recover(hash, signatures[i]);
            require(Maintainer(maintainer).isMaintainer(signer), "NFPost: Only Maintainer");
            _mint(tos[i], tokenIds[i]);
            _setTokenURI(tokenIds[i], tokenURIs[i]);
        }
    }

    function safeMintBatch(address[] memory tos, uint256[] memory tokenIds, string[] memory tokenURIs, bytes[] memory signatures) public {
        require(
            tos.length == tokenIds.length &&
            tos.length == tokenURIs.length &&
            tos.length == signatures.length,
            "NFPost: input length mismatch"
        );
        for (uint256 i = 0; i < tos.length; ++i) {
            bytes32 hash = ECDSA.toEthSignedMessageHash(keccak256(abi.encode(tos[i], tokenIds[i], tokenURIs[i])));
            address signer = ECDSA.recover(hash, signatures[i]);
            require(Maintainer(maintainer).isMaintainer(signer), "NFPost: Only Maintainer");
            _safeMint(tos[i], tokenIds[i]);
            _setTokenURI(tokenIds[i], tokenURIs[i]);
        }
    }

    function approveBatch(address[] memory tos, uint256[] memory tokenIds) public {
        require(tos.length == tokenIds.length, "NFPost: input length mismatch");
        for (uint256 i = 0; i < tos.length; ++i) {
            approve(tos[i], tokenIds[i]);
        }
    }

    function transferFromBatch(address[] memory froms, address[] memory tos, uint256[] memory tokenIds) public {
        require(
            froms.length == tos.length &&
            froms.length == tokenIds.length,
            "NFPost: input length mismatch"
        );
        for (uint256 i = 0; i < froms.length; ++i) {
            transferFrom(froms[i], tos[i], tokenIds[i]);
        }
    }

    function safeTransferFromBatch(address[] memory froms, address[] memory tos, uint256[] memory tokenIds) public {
        require(
            froms.length == tos.length &&
            froms.length == tokenIds.length,
            "NFPost: input length mismatch"
        );
        for (uint256 i = 0; i < froms.length; ++i) {
            safeTransferFrom(froms[i], tos[i], tokenIds[i], "");
        }
    }

    function safeTransferFromWithDataBatch(address[] memory froms, address[] memory tos, uint256[] memory tokenIds, bytes[] memory datas) public {
        require(
            froms.length == tos.length &&
            froms.length == tokenIds.length &&
            froms.length == datas.length,
            "NFPost: input length mismatch"
        );
        for (uint256 i = 0; i < froms.length; ++i) {
            safeTransferFrom(froms[i], tos[i], tokenIds[i], datas[i]);
        }
    }


    function setBaseURI(string memory uri) public {
        require(maintainer == _msgSender(), "NFPost: Only Maintainer");
        _setBaseURI(uri);
    }

    function isApprovedOrOwner(address spender, uint256 tokenId) public view returns (bool) {
        return _isApprovedOrOwner(spender, tokenId);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_maintainer","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"approveBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isApprovedOrOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"forwarder","type":"address"}],"name":"isTrustedForwarder","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"string[]","name":"tokenURIs","type":"string[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"}],"name":"mintBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"string[]","name":"tokenURIs","type":"string[]"},{"internalType":"bytes[]","name":"signatures","type":"bytes[]"}],"name":"safeMintBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"froms","type":"address[]"},{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"safeTransferFromBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"froms","type":"address[]"},{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"safeTransferFromWithDataBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"froms","type":"address[]"},{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"transferFromBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"trustedForwarder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"versionRecipient","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000007903d77993937be9ed62177393d5b15d0f286ca0

-----Decoded View---------------
Arg [0] : _maintainer (address): 0x7903d77993937be9ed62177393d5b15d0f286ca0

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

61263:3849:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43509:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48443:92;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51130:213;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50674:390;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50168:203;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52004:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49938:154;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52380:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64957:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61052:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50448:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64795:154;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1663:137;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48207:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49765:89;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47930:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1369:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62375:793;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48604:96;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51415:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52602:285;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63868:414;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63458:402;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63176:274;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48771:755;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61582:785;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51781:156;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64290:495;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43509:142;43586:4;43610:20;:33;43631:11;43610:33;;;;;;;;;;;;;;;;;;;;;;;;;;;43603:40;;43509:142;;;:::o;48443:92::-;48489:13;48522:5;48515:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48443:92;:::o;51130:213::-;51198:7;51226:16;51234:7;51226;:16::i;:::-;51218:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;51311:15;:24;51327:7;51311:24;;;;;;;;;;;;;;;;;;;;;51304:31;;51130:213;;;:::o;50674:390::-;50755:13;50771:16;50779:7;50771;:16::i;:::-;50755:32;;50812:5;50806:11;;:2;:11;;;;50798:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;50892:5;50876:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;50901:37;50918:5;50925:12;:10;:12::i;:::-;50901:16;:37::i;:::-;50876:62;50868:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;51035:21;51044:2;51048:7;51035:8;:21::i;:::-;50674:390;;;:::o;50168:203::-;50221:7;50342:21;:12;:19;:21::i;:::-;50335:28;;50168:203;:::o;52004:305::-;52165:41;52184:12;:10;:12::i;:::-;52198:7;52165:18;:41::i;:::-;52157:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;52273:28;52283:4;52289:2;52293:7;52273:9;:28::i;:::-;52004:305;;;:::o;49938:154::-;50027:7;50054:30;50078:5;50054:13;:20;50068:5;50054:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;50047:37;;49938:154;;;;:::o;52380:151::-;52484:39;52501:4;52507:2;52511:7;52484:39;;;;;;;;;;;;:16;:39::i;:::-;52380:151;;;:::o;64957:150::-;65039:4;65063:36;65082:7;65091;65063:18;:36::i;:::-;65056:43;;64957:150;;;;:::o;61052:104::-;61112:13;61138:10;;;;;;;;;;;;;;;;;;;61052:104;:::o;50448:164::-;50515:7;50536:15;50557:22;50573:5;50557:12;:15;;:22;;;;:::i;:::-;50535:44;;;50597:7;50590:14;;;50448:164;;;:::o;64795:154::-;64874:12;:10;:12::i;:::-;64860:26;;:10;;;;;;;;;;;:26;;;64852:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;64925:16;64937:3;64925:11;:16::i;:::-;64795:154;:::o;1663:137::-;1739:4;1776:16;;;;;;;;;;;1763:29;;:9;:29;;;1756:36;;1663:137;;;:::o;48207:169::-;48271:7;48298:70;48315:7;48298:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;48291:77;;48207:169;;;:::o;49765:89::-;49805:13;49838:8;49831:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49765:89;:::o;47930:215::-;47994:7;48039:1;48022:19;;:5;:19;;;;48014:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;48108:29;:13;:20;48122:5;48108:20;;;;;;;;;;;;;;;:27;:29::i;:::-;48101:36;;47930:215;;;:::o;1369:31::-;;;;;;;;;;;;:::o;62375:793::-;62555:8;:15;62541:3;:10;:29;:76;;;;;62601:9;:16;62587:3;:10;:30;62541:76;:124;;;;;62648:10;:17;62634:3;:10;:31;62541:124;62519:203;;;;;;;;;;;;:::i;:::-;;;;;;;;;62738:9;62733:428;62757:3;:10;62753:1;:14;62733:428;;;62789:12;62804:86;62854:3;62858:1;62854:6;;;;;;;;;;;;;;62862:8;62871:1;62862:11;;;;;;;;;;;;;;62875:9;62885:1;62875:12;;;;;;;;;;;;;;62843:45;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;62833:56;;;;;;62804:28;:86::i;:::-;62789:101;;62905:14;62922:34;62936:4;62942:10;62953:1;62942:13;;;;;;;;;;;;;;62922;:34::i;:::-;62905:51;;62990:10;;;;;;;;;;;62979:35;;;63015:6;62979:43;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62971:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;63065:30;63075:3;63079:1;63075:6;;;;;;;;;;;;;;63083:8;63092:1;63083:11;;;;;;;;;;;;;;63065:9;:30::i;:::-;63110:39;63123:8;63132:1;63123:11;;;;;;;;;;;;;;63136:9;63146:1;63136:12;;;;;;;;;;;;;;63110;:39::i;:::-;62733:428;;62769:3;;;;;62733:428;;;;62375:793;;;;:::o;48604:96::-;48652:13;48685:7;48678:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48604:96;:::o;51415:295::-;51530:12;:10;:12::i;:::-;51518:24;;:8;:24;;;;51510:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;51630:8;51585:18;:32;51604:12;:10;:12::i;:::-;51585:32;;;;;;;;;;;;;;;:42;51618:8;51585:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;51683:8;51654:48;;51669:12;:10;:12::i;:::-;51654:48;;;51693:8;51654:48;;;;;;:::i;:::-;;;;;;;;51415:295;;:::o;52602:285::-;52734:41;52753:12;:10;:12::i;:::-;52767:7;52734:18;:41::i;:::-;52726:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;52840:39;52854:4;52860:2;52864:7;52873:5;52840:13;:39::i;:::-;52602:285;;;;:::o;63868:414::-;64028:3;:10;64012:5;:12;:26;:74;;;;;64071:8;:15;64055:5;:12;:31;64012:74;63990:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;64159:9;64154:121;64178:5;:12;64174:1;:16;64154:121;;;64212:51;64229:5;64235:1;64229:8;;;;;;;;;;;;;;64239:3;64243:1;64239:6;;;;;;;;;;;;;;64247:8;64256:1;64247:11;;;;;;;;;;;;;;64212:51;;;;;;;;;;;;:16;:51::i;:::-;64192:3;;;;;64154:121;;;;63868:414;;;:::o;63458:402::-;63614:3;:10;63598:5;:12;:26;:74;;;;;63657:8;:15;63641:5;:12;:31;63598:74;63576:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;63745:9;63740:113;63764:5;:12;63760:1;:16;63740:113;;;63798:43;63811:5;63817:1;63811:8;;;;;;;;;;;;;;63821:3;63825:1;63821:6;;;;;;;;;;;;;;63829:8;63838:1;63829:11;;;;;;;;;;;;;;63798:12;:43::i;:::-;63778:3;;;;;63740:113;;;;63458:402;;;:::o;63176:274::-;63287:8;:15;63273:3;:10;:29;63265:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;63352:9;63347:96;63371:3;:10;63367:1;:14;63347:96;;;63403:28;63411:3;63415:1;63411:6;;;;;;;;;;;;;;63419:8;63428:1;63419:11;;;;;;;;;;;;;;63403:7;:28::i;:::-;63383:3;;;;;63347:96;;;;63176:274;;:::o;48771:755::-;48836:13;48870:16;48878:7;48870;:16::i;:::-;48862:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;48951:23;48977:10;:19;48988:7;48977:19;;;;;;;;;;;48951:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49098:1;49078:8;49072:22;;;;;;;;;;;;;;;;:27;49068:76;;;49123:9;49116:16;;;;;49068:76;49274:1;49254:9;49248:23;:27;49244:112;;;49323:8;49333:9;49306:37;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49292:52;;;;;49244:112;49488:8;49498:18;:7;:16;:18::i;:::-;49471:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49457:61;;;48771:755;;;;:::o;61582:785::-;61758:8;:15;61744:3;:10;:29;:76;;;;;61804:9;:16;61790:3;:10;:30;61744:76;:124;;;;;61851:10;:17;61837:3;:10;:31;61744:124;61722:203;;;;;;;;;;;;:::i;:::-;;;;;;;;;61941:9;61936:424;61960:3;:10;61956:1;:14;61936:424;;;61992:12;62007:86;62057:3;62061:1;62057:6;;;;;;;;;;;;;;62065:8;62074:1;62065:11;;;;;;;;;;;;;;62078:9;62088:1;62078:12;;;;;;;;;;;;;;62046:45;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;62036:56;;;;;;62007:28;:86::i;:::-;61992:101;;62108:14;62125:34;62139:4;62145:10;62156:1;62145:13;;;;;;;;;;;;;;62125;:34::i;:::-;62108:51;;62193:10;;;;;;;;;;;62182:35;;;62218:6;62182:43;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62174:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;62268:26;62274:3;62278:1;62274:6;;;;;;;;;;;;;;62282:8;62291:1;62282:11;;;;;;;;;;;;;;62268:5;:26::i;:::-;62309:39;62322:8;62331:1;62322:11;;;;;;;;;;;;;;62335:9;62345:1;62335:12;;;;;;;;;;;;;;62309;:39::i;:::-;61936:424;;61972:3;;;;;61936:424;;;;61582:785;;;;:::o;51781:156::-;51870:4;51894:18;:25;51913:5;51894:25;;;;;;;;;;;;;;;:35;51920:8;51894:35;;;;;;;;;;;;;;;;;;;;;;;;;51887:42;;51781:156;;;;:::o;64290:495::-;64480:3;:10;64464:5;:12;:26;:74;;;;;64523:8;:15;64507:5;:12;:31;64464:74;:119;;;;;64571:5;:12;64555:5;:12;:28;64464:119;64442:198;;;;;;;;;;;;:::i;:::-;;;;;;;;;64656:9;64651:127;64675:5;:12;64671:1;:16;64651:127;;;64709:57;64726:5;64732:1;64726:8;;;;;;;;;;;;;;64736:3;64740:1;64736:6;;;;;;;;;;;;;;64744:8;64753:1;64744:11;;;;;;;;;;;;;;64757:5;64763:1;64757:8;;;;;;;;;;;;;;64709:16;:57::i;:::-;64689:3;;;;;64651:127;;;;64290:495;;;;:::o;54353:119::-;54410:4;54434:30;54456:7;54434:12;:21;;:30;;;;:::i;:::-;54427:37;;54353:119;;;:::o;2060:567::-;2122:19;2177:2;2158:8;;:15;;:21;;:55;;;;;2183:30;2202:10;2183:18;:30::i;:::-;2158:55;2154:466;;;2539:2;2524:14;2520:22;2507:36;2504:2;2500:44;2493:51;;2474:85;;;2598:10;2591:17;;;;2154:466;2060:567;;:::o;60180:158::-;60273:2;60246:15;:24;60262:7;60246:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;60322:7;60318:2;60291:39;;60300:16;60308:7;60300;:16::i;:::-;60291:39;;;;;;;;;;;;60180:158;;:::o;29225:123::-;29294:7;29321:19;29329:3;:10;;29321:7;:19::i;:::-;29314:26;;29225:123;;;:::o;54639:333::-;54724:4;54749:16;54757:7;54749;:16::i;:::-;54741:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;54825:13;54841:16;54849:7;54841;:16::i;:::-;54825:32;;54887:5;54876:16;;:7;:16;;;:51;;;;54920:7;54896:31;;:20;54908:7;54896:11;:20::i;:::-;:31;;;54876:51;:87;;;;54931:32;54948:5;54955:7;54931:16;:32::i;:::-;54876:87;54868:96;;;54639:333;;;;:::o;57728:574::-;57846:4;57826:24;;:16;57834:7;57826;:16::i;:::-;:24;;;57818:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;57929:1;57915:16;;:2;:16;;;;57907:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;57985:39;58006:4;58012:2;58016:7;57985:20;:39::i;:::-;58089:29;58106:1;58110:7;58089:8;:29::i;:::-;58131:35;58158:7;58131:13;:19;58145:4;58131:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;58177:30;58199:7;58177:13;:17;58191:2;58177:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;58220:29;58237:7;58246:2;58220:12;:16;;:29;;;;;:::i;:::-;;58286:7;58282:2;58267:27;;58276:4;58267:27;;;;;;;;;;;;57728:574;;;:::o;21919:137::-;21990:7;22025:22;22029:3;:10;;22041:5;22025:3;:22::i;:::-;22017:31;;22010:38;;21919:137;;;;:::o;29687:227::-;29767:7;29776;29797:11;29810:13;29827:22;29831:3;:10;;29843:5;29827:3;:22::i;:::-;29796:53;;;;29876:3;29868:12;;29898:5;29890:14;;29860:46;;;;;;29687:227;;;;;:::o;58903:100::-;58987:8;58976;:19;;;;;;;;;;;;:::i;:::-;;58903:100;:::o;30349:204::-;30456:7;30499:44;30504:3;:10;;30524:3;30516:12;;30530;30499:4;:44::i;:::-;30491:53;;30476:69;;30349:204;;;;;:::o;21461:114::-;21521:7;21548:19;21556:3;:10;;21548:7;:19::i;:::-;21541:26;;21461:114;;;:::o;34661:269::-;34730:7;34916:4;34863:58;;;;;;;;:::i;:::-;;;;;;;;;;;;;34853:69;;;;;;34846:76;;34661:269;;;:::o;32277:2110::-;32355:7;32438:2;32418:9;:16;:22;32414:96;;32457:41;;;;;;;;;;:::i;:::-;;;;;;;;32414:96;32579:9;32599;32619:7;32871:4;32860:9;32856:20;32850:27;32845:32;;32917:4;32906:9;32902:20;32896:27;32891:32;;32971:4;32960:9;32956:20;32950:27;32947:1;32942:36;32937:41;;33901:66;33896:1;33888:10;;:79;33884:156;;;33984:44;;;;;;;;;;:::i;:::-;;;;;;;;33884:156;34061:2;34056:1;:7;;;;:18;;;;;34072:2;34067:1;:7;;;;34056:18;34052:95;;;34091:44;;;;;;;;;;:::i;:::-;;;;;;;;34052:95;34244:14;34261:24;34271:4;34277:1;34280;34283;34261:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34244:41;;34322:1;34304:20;;:6;:20;;;;34296:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;34373:6;34366:13;;;;;;32277:2110;;;;:::o;55315:110::-;55391:26;55401:2;55405:7;55391:26;;;;;;;;;;;;:9;:26::i;:::-;55315:110;;:::o;58458:215::-;58558:16;58566:7;58558;:16::i;:::-;58550:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58656:9;58634:10;:19;58645:7;58634:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;58458:215;;:::o;53768:272::-;53882:28;53892:4;53898:2;53902:7;53882:9;:28::i;:::-;53929:48;53952:4;53958:2;53962:7;53971:5;53929:22;:48::i;:::-;53921:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;53768:272;;;;:::o;30711:744::-;30767:13;30997:1;30988:5;:10;30984:53;;;31015:10;;;;;;;;;;;;;;;;;;;;;30984:53;31047:12;31062:5;31047:20;;31078:14;31103:78;31118:1;31110:4;:9;31103:78;;31136:8;;;;;;;31167:2;31159:10;;;;;;;;;31103:78;;;31191:19;31223:6;31213:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31191:39;;31241:13;31266:1;31257:6;:10;31241:26;;31285:5;31278:12;;31301:115;31316:1;31308:4;:9;31301:115;;31375:2;31368:4;:9;;;;;;31363:2;:14;31352:27;;31334:6;31341:7;;;;;;;31334:15;;;;;;;;;;;:45;;;;;;;;;;;31402:2;31394:10;;;;;;;;;31301:115;;;31440:6;31426:21;;;;;;30711:744;;;;:::o;56238:404::-;56332:1;56318:16;;:2;:16;;;;56310:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;56391:16;56399:7;56391;:16::i;:::-;56390:17;56382:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;56453:45;56482:1;56486:2;56490:7;56453:20;:45::i;:::-;56511:30;56533:7;56511:13;:17;56525:2;56511:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;56554:29;56571:7;56580:2;56554:12;:16;;:29;;;;;:::i;:::-;;56626:7;56622:2;56601:33;;56618:1;56601:33;;;;;;;;;;;;56238:404;;:::o;28986:151::-;29070:4;29094:35;29104:3;:10;;29124:3;29116:12;;29094:9;:35::i;:::-;29087:42;;28986:151;;;;:::o;26608:110::-;26664:7;26691:3;:12;;:19;;;;26684:26;;26608:110;;;:::o;60951:93::-;;;;:::o;21006:137::-;21076:4;21100:35;21108:3;:10;;21128:5;21120:14;;21100:7;:35::i;:::-;21093:42;;21006:137;;;;:::o;20699:131::-;20766:4;20790:32;20795:3;:10;;20815:5;20807:14;;20790:4;:32::i;:::-;20783:39;;20699:131;;;;:::o;28418:176::-;28507:4;28531:55;28536:3;:10;;28556:3;28548:12;;28578:5;28570:14;;28562:23;;28531:4;:55::i;:::-;28524:62;;28418:176;;;;;:::o;18583:204::-;18650:7;18699:5;18678:3;:11;;:18;;;;:26;18670:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;18761:3;:11;;18773:5;18761:18;;;;;;;;;;;;;;;;18754:25;;18583:204;;;;:::o;27073:279::-;27140:7;27149;27199:5;27177:3;:12;;:19;;;;:27;27169:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;27256:22;27281:3;:12;;27294:5;27281:19;;;;;;;;;;;;;;;;;;27256:44;;27319:5;:10;;;27331:5;:12;;;27311:33;;;;;27073:279;;;;;:::o;27775:319::-;27869:7;27889:16;27908:3;:12;;:17;27921:3;27908:17;;;;;;;;;;;;27889:36;;27956:1;27944:8;:13;;27959:12;27936:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;28026:3;:12;;28050:1;28039:8;:12;28026:26;;;;;;;;;;;;;;;;;;:33;;;28019:40;;;27775:319;;;;;:::o;18130:109::-;18186:7;18213:3;:11;;:18;;;;18206:25;;18130:109;;;:::o;55652:250::-;55748:18;55754:2;55758:7;55748:5;:18::i;:::-;55785:54;55816:1;55820:2;55824:7;55833:5;55785:22;:54::i;:::-;55777:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;55652:250;;;:::o;59568:604::-;59689:4;59716:15;:2;:13;;;:15::i;:::-;59711:60;;59755:4;59748:11;;;;59711:60;59781:23;59807:252;59860:45;;;59920:12;:10;:12::i;:::-;59947:4;59966:7;59988:5;59823:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59807:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;59781:278;;60070:13;60097:10;60086:32;;;;;;;;;;;;:::i;:::-;60070:48;;44933:10;60147:16;;60137:26;;;:6;:26;;;;60129:35;;;;59568:604;;;;;;;:::o;26388:125::-;26459:4;26504:1;26483:3;:12;;:17;26496:3;26483:17;;;;;;;;;;;;:22;;26476:29;;26388:125;;;;:::o;16285:1544::-;16351:4;16469:18;16490:3;:12;;:19;16503:5;16490:19;;;;;;;;;;;;16469:40;;16540:1;16526:10;:15;16522:1300;;16888:21;16925:1;16912:10;:14;16888:38;;16941:17;16982:1;16961:3;:11;;:18;;;;:22;16941:42;;17228:17;17248:3;:11;;17260:9;17248:22;;;;;;;;;;;;;;;;17228:42;;17394:9;17365:3;:11;;17377:13;17365:26;;;;;;;;;;;;;;;:38;;;;17513:1;17497:13;:17;17471:3;:12;;:23;17484:9;17471:23;;;;;;;;;;;:43;;;;17623:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;17718:3;:12;;:19;17731:5;17718:19;;;;;;;;;;;17711:26;;;17761:4;17754:11;;;;;;;;16522:1300;17805:5;17798:12;;;16285:1544;;;;;:::o;15695:414::-;15758:4;15780:21;15790:3;15795:5;15780:9;:21::i;:::-;15775:327;;15818:3;:11;;15835:5;15818:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16001:3;:11;;:18;;;;15979:3;:12;;:19;15992:5;15979:19;;;;;;;;;;;:40;;;;16041:4;16034:11;;;;15775:327;16085:5;16078:12;;15695:414;;;;;:::o;23888:692::-;23964:4;24080:16;24099:3;:12;;:17;24112:3;24099:17;;;;;;;;;;;;24080:36;;24145:1;24133:8;:13;24129:444;;;24200:3;:12;;24218:38;;;;;;;;24235:3;24218:38;;;;24248:5;24218:38;;;24200:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24415:3;:12;;:19;;;;24395:3;:12;;:17;24408:3;24395:17;;;;;;;;;;;:39;;;;24456:4;24449:11;;;;;24129:444;24529:5;24493:3;:12;;24517:1;24506:8;:12;24493:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;24556:5;24549:12;;;23888:692;;;;;;:::o;8615:619::-;8675:4;8937:16;8964:19;8986:66;8964:88;;;;9155:7;9143:20;9131:32;;9195:11;9183:8;:23;;:42;;;;;9222:3;9210:15;;:8;:15;;9183:42;9175:51;;;;8615:619;;;:::o;11730:196::-;11833:12;11865:53;11888:6;11896:4;11902:1;11905:12;11865:22;:53::i;:::-;11858:60;;11730:196;;;;;:::o;17915:129::-;17988:4;18035:1;18012:3;:12;;:19;18025:5;18012:19;;;;;;;;;;;;:24;;18005:31;;17915:129;;;;:::o;13107:979::-;13237:12;13270:18;13281:6;13270:10;:18::i;:::-;13262:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;13396:12;13410:23;13437:6;:11;;13457:8;13468:4;13437:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13395:78;;;;13488:7;13484:595;;;13519:10;13512:17;;;;;;13484:595;13653:1;13633:10;:17;:21;13629:439;;;13896:10;13890:17;13957:15;13944:10;13940:2;13936:19;13929:44;13844:148;14039:12;14032:20;;;;;;;;;;;:::i;:::-;;;;;;;;13107:979;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;;85:6;72:20;63:29;;97:33;124:5;97:33;:::i;:::-;57:78;;;;:::o;160:707::-;;277:3;270:4;262:6;258:17;254:27;244:2;;295:1;292;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;:::i;:::-;354:80;:::i;:::-;345:89;;451:5;476:6;469:5;462:21;506:4;498:6;494:17;484:27;;528:4;523:3;519:14;512:21;;581:6;628:3;620:4;612:6;608:17;603:3;599:27;596:36;593:2;;;645:1;642;635:12;593:2;670:1;655:206;680:6;677:1;674:13;655:206;;;738:3;760:37;793:3;781:10;760:37;:::i;:::-;755:3;748:50;821:4;816:3;812:14;805:21;;849:4;844:3;840:14;833:21;;712:149;702:1;699;695:9;690:14;;655:206;;;659:14;237:630;;;;;;;:::o;891:705::-;;1017:3;1010:4;1002:6;998:17;994:27;984:2;;1035:1;1032;1025:12;984:2;1072:6;1059:20;1094:89;1109:73;1175:6;1109:73;:::i;:::-;1094:89;:::i;:::-;1085:98;;1200:5;1225:6;1218:5;1211:21;1255:4;1247:6;1243:17;1233:27;;1277:4;1272:3;1268:14;1261:21;;1330:6;1363:1;1348:242;1373:6;1370:1;1367:13;1348:242;;;1456:3;1443:17;1435:6;1431:30;1480:46;1522:3;1510:10;1480:46;:::i;:::-;1475:3;1468:59;1550:4;1545:3;1541:14;1534:21;;1578:4;1573:3;1569:14;1562:21;;1405:185;1395:1;1392;1388:9;1383:14;;1348:242;;;1352:14;977:619;;;;;;;:::o;1621:708::-;;1748:3;1741:4;1733:6;1729:17;1725:27;1715:2;;1766:1;1763;1756:12;1715:2;1803:6;1790:20;1825:90;1840:74;1907:6;1840:74;:::i;:::-;1825:90;:::i;:::-;1816:99;;1932:5;1957:6;1950:5;1943:21;1987:4;1979:6;1975:17;1965:27;;2009:4;2004:3;2000:14;1993:21;;2062:6;2095:1;2080:243;2105:6;2102:1;2099:13;2080:243;;;2188:3;2175:17;2167:6;2163:30;2212:47;2255:3;2243:10;2212:47;:::i;:::-;2207:3;2200:60;2283:4;2278:3;2274:14;2267:21;;2311:4;2306:3;2302:14;2295:21;;2137:186;2127:1;2124;2120:9;2115:14;;2080:243;;;2084:14;1708:621;;;;;;;:::o;2355:707::-;;2472:3;2465:4;2457:6;2453:17;2449:27;2439:2;;2490:1;2487;2480:12;2439:2;2527:6;2514:20;2549:80;2564:64;2621:6;2564:64;:::i;:::-;2549:80;:::i;:::-;2540:89;;2646:5;2671:6;2664:5;2657:21;2701:4;2693:6;2689:17;2679:27;;2723:4;2718:3;2714:14;2707:21;;2776:6;2823:3;2815:4;2807:6;2803:17;2798:3;2794:27;2791:36;2788:2;;;2840:1;2837;2830:12;2788:2;2865:1;2850:206;2875:6;2872:1;2869:13;2850:206;;;2933:3;2955:37;2988:3;2976:10;2955:37;:::i;:::-;2950:3;2943:50;3016:4;3011:3;3007:14;3000:21;;3044:4;3039:3;3035:14;3028:21;;2907:149;2897:1;2894;2890:9;2885:14;;2850:206;;;2854:14;2432:630;;;;;;;:::o;3070:124::-;;3147:6;3134:20;3125:29;;3159:30;3183:5;3159:30;:::i;:::-;3119:75;;;;:::o;3201:128::-;;3282:6;3276:13;3267:22;;3294:30;3318:5;3294:30;:::i;:::-;3261:68;;;;:::o;3336:128::-;;3415:6;3402:20;3393:29;;3427:32;3453:5;3427:32;:::i;:::-;3387:77;;;;:::o;3471:132::-;;3554:6;3548:13;3539:22;;3566:32;3592:5;3566:32;:::i;:::-;3533:70;;;;:::o;3611:440::-;;3712:3;3705:4;3697:6;3693:17;3689:27;3679:2;;3730:1;3727;3720:12;3679:2;3767:6;3754:20;3789:64;3804:48;3845:6;3804:48;:::i;:::-;3789:64;:::i;:::-;3780:73;;3873:6;3866:5;3859:21;3909:4;3901:6;3897:17;3942:4;3935:5;3931:16;3977:3;3968:6;3963:3;3959:16;3956:25;3953:2;;;3994:1;3991;3984:12;3953:2;4004:41;4038:6;4033:3;4028;4004:41;:::i;:::-;3672:379;;;;;;;:::o;4060:442::-;;4162:3;4155:4;4147:6;4143:17;4139:27;4129:2;;4180:1;4177;4170:12;4129:2;4217:6;4204:20;4239:65;4254:49;4296:6;4254:49;:::i;:::-;4239:65;:::i;:::-;4230:74;;4324:6;4317:5;4310:21;4360:4;4352:6;4348:17;4393:4;4386:5;4382:16;4428:3;4419:6;4414:3;4410:16;4407:25;4404:2;;;4445:1;4442;4435:12;4404:2;4455:41;4489:6;4484:3;4479;4455:41;:::i;:::-;4122:380;;;;;;;:::o;4510:130::-;;4590:6;4577:20;4568:29;;4602:33;4629:5;4602:33;:::i;:::-;4562:78;;;;:::o;4647:241::-;;4751:2;4739:9;4730:7;4726:23;4722:32;4719:2;;;4767:1;4764;4757:12;4719:2;4802:1;4819:53;4864:7;4855:6;4844:9;4840:22;4819:53;:::i;:::-;4809:63;;4781:97;4713:175;;;;:::o;4895:366::-;;;5016:2;5004:9;4995:7;4991:23;4987:32;4984:2;;;5032:1;5029;5022:12;4984:2;5067:1;5084:53;5129:7;5120:6;5109:9;5105:22;5084:53;:::i;:::-;5074:63;;5046:97;5174:2;5192:53;5237:7;5228:6;5217:9;5213:22;5192:53;:::i;:::-;5182:63;;5153:98;4978:283;;;;;:::o;5268:491::-;;;;5406:2;5394:9;5385:7;5381:23;5377:32;5374:2;;;5422:1;5419;5412:12;5374:2;5457:1;5474:53;5519:7;5510:6;5499:9;5495:22;5474:53;:::i;:::-;5464:63;;5436:97;5564:2;5582:53;5627:7;5618:6;5607:9;5603:22;5582:53;:::i;:::-;5572:63;;5543:98;5672:2;5690:53;5735:7;5726:6;5715:9;5711:22;5690:53;:::i;:::-;5680:63;;5651:98;5368:391;;;;;:::o;5766:721::-;;;;;5930:3;5918:9;5909:7;5905:23;5901:33;5898:2;;;5947:1;5944;5937:12;5898:2;5982:1;5999:53;6044:7;6035:6;6024:9;6020:22;5999:53;:::i;:::-;5989:63;;5961:97;6089:2;6107:53;6152:7;6143:6;6132:9;6128:22;6107:53;:::i;:::-;6097:63;;6068:98;6197:2;6215:53;6260:7;6251:6;6240:9;6236:22;6215:53;:::i;:::-;6205:63;;6176:98;6333:2;6322:9;6318:18;6305:32;6357:18;6349:6;6346:30;6343:2;;;6389:1;6386;6379:12;6343:2;6409:62;6463:7;6454:6;6443:9;6439:22;6409:62;:::i;:::-;6399:72;;6284:193;5892:595;;;;;;;:::o;6494:360::-;;;6612:2;6600:9;6591:7;6587:23;6583:32;6580:2;;;6628:1;6625;6618:12;6580:2;6663:1;6680:53;6725:7;6716:6;6705:9;6701:22;6680:53;:::i;:::-;6670:63;;6642:97;6770:2;6788:50;6830:7;6821:6;6810:9;6806:22;6788:50;:::i;:::-;6778:60;;6749:95;6574:280;;;;;:::o;6861:366::-;;;6982:2;6970:9;6961:7;6957:23;6953:32;6950:2;;;6998:1;6995;6988:12;6950:2;7033:1;7050:53;7095:7;7086:6;7075:9;7071:22;7050:53;:::i;:::-;7040:63;;7012:97;7140:2;7158:53;7203:7;7194:6;7183:9;7179:22;7158:53;:::i;:::-;7148:63;;7119:98;6944:283;;;;;:::o;7234:899::-;;;;7447:2;7435:9;7426:7;7422:23;7418:32;7415:2;;;7463:1;7460;7453:12;7415:2;7526:1;7515:9;7511:17;7498:31;7549:18;7541:6;7538:30;7535:2;;;7581:1;7578;7571:12;7535:2;7601:78;7671:7;7662:6;7651:9;7647:22;7601:78;:::i;:::-;7591:88;;7477:208;7744:2;7733:9;7729:18;7716:32;7768:18;7760:6;7757:30;7754:2;;;7800:1;7797;7790:12;7754:2;7820:78;7890:7;7881:6;7870:9;7866:22;7820:78;:::i;:::-;7810:88;;7695:209;7963:2;7952:9;7948:18;7935:32;7987:18;7979:6;7976:30;7973:2;;;8019:1;8016;8009:12;7973:2;8039:78;8109:7;8100:6;8089:9;8085:22;8039:78;:::i;:::-;8029:88;;7914:209;7409:724;;;;;:::o;8140:1179::-;;;;;8404:3;8392:9;8383:7;8379:23;8375:33;8372:2;;;8421:1;8418;8411:12;8372:2;8484:1;8473:9;8469:17;8456:31;8507:18;8499:6;8496:30;8493:2;;;8539:1;8536;8529:12;8493:2;8559:78;8629:7;8620:6;8609:9;8605:22;8559:78;:::i;:::-;8549:88;;8435:208;8702:2;8691:9;8687:18;8674:32;8726:18;8718:6;8715:30;8712:2;;;8758:1;8755;8748:12;8712:2;8778:78;8848:7;8839:6;8828:9;8824:22;8778:78;:::i;:::-;8768:88;;8653:209;8921:2;8910:9;8906:18;8893:32;8945:18;8937:6;8934:30;8931:2;;;8977:1;8974;8967:12;8931:2;8997:78;9067:7;9058:6;9047:9;9043:22;8997:78;:::i;:::-;8987:88;;8872:209;9140:2;9129:9;9125:18;9112:32;9164:18;9156:6;9153:30;9150:2;;;9196:1;9193;9186:12;9150:2;9216:87;9295:7;9286:6;9275:9;9271:22;9216:87;:::i;:::-;9206:97;;9091:218;8366:953;;;;;;;:::o;9326:638::-;;;9497:2;9485:9;9476:7;9472:23;9468:32;9465:2;;;9513:1;9510;9503:12;9465:2;9576:1;9565:9;9561:17;9548:31;9599:18;9591:6;9588:30;9585:2;;;9631:1;9628;9621:12;9585:2;9651:78;9721:7;9712:6;9701:9;9697:22;9651:78;:::i;:::-;9641:88;;9527:208;9794:2;9783:9;9779:18;9766:32;9818:18;9810:6;9807:30;9804:2;;;9850:1;9847;9840:12;9804:2;9870:78;9940:7;9931:6;9920:9;9916:22;9870:78;:::i;:::-;9860:88;;9745:209;9459:505;;;;;:::o;9971:1199::-;;;;;10245:3;10233:9;10224:7;10220:23;10216:33;10213:2;;;10262:1;10259;10252:12;10213:2;10325:1;10314:9;10310:17;10297:31;10348:18;10340:6;10337:30;10334:2;;;10380:1;10377;10370:12;10334:2;10400:78;10470:7;10461:6;10450:9;10446:22;10400:78;:::i;:::-;10390:88;;10276:208;10543:2;10532:9;10528:18;10515:32;10567:18;10559:6;10556:30;10553:2;;;10599:1;10596;10589:12;10553:2;10619:78;10689:7;10680:6;10669:9;10665:22;10619:78;:::i;:::-;10609:88;;10494:209;10762:2;10751:9;10747:18;10734:32;10786:18;10778:6;10775:30;10772:2;;;10818:1;10815;10808:12;10772:2;10838:88;10918:7;10909:6;10898:9;10894:22;10838:88;:::i;:::-;10828:98;;10713:219;10991:2;10980:9;10976:18;10963:32;11015:18;11007:6;11004:30;11001:2;;;11047:1;11044;11037:12;11001:2;11067:87;11146:7;11137:6;11126:9;11122:22;11067:87;:::i;:::-;11057:97;;10942:218;10207:963;;;;;;;:::o;11177:257::-;;11289:2;11277:9;11268:7;11264:23;11260:32;11257:2;;;11305:1;11302;11295:12;11257:2;11340:1;11357:61;11410:7;11401:6;11390:9;11386:22;11357:61;:::i;:::-;11347:71;;11319:105;11251:183;;;;:::o;11441:239::-;;11544:2;11532:9;11523:7;11519:23;11515:32;11512:2;;;11560:1;11557;11550:12;11512:2;11595:1;11612:52;11656:7;11647:6;11636:9;11632:22;11612:52;:::i;:::-;11602:62;;11574:96;11506:174;;;;:::o;11687:261::-;;11801:2;11789:9;11780:7;11776:23;11772:32;11769:2;;;11817:1;11814;11807:12;11769:2;11852:1;11869:63;11924:7;11915:6;11904:9;11900:22;11869:63;:::i;:::-;11859:73;;11831:107;11763:185;;;;:::o;11955:347::-;;12069:2;12057:9;12048:7;12044:23;12040:32;12037:2;;;12085:1;12082;12075:12;12037:2;12148:1;12137:9;12133:17;12120:31;12171:18;12163:6;12160:30;12157:2;;;12203:1;12200;12193:12;12157:2;12223:63;12278:7;12269:6;12258:9;12254:22;12223:63;:::i;:::-;12213:73;;12099:193;12031:271;;;;:::o;12309:241::-;;12413:2;12401:9;12392:7;12388:23;12384:32;12381:2;;;12429:1;12426;12419:12;12381:2;12464:1;12481:53;12526:7;12517:6;12506:9;12502:22;12481:53;:::i;:::-;12471:63;;12443:97;12375:175;;;;:::o;12557:137::-;12656:32;12682:5;12656:32;:::i;:::-;12651:3;12644:45;12638:56;;:::o;12701:113::-;12784:24;12802:5;12784:24;:::i;:::-;12779:3;12772:37;12766:48;;:::o;12821:104::-;12898:21;12913:5;12898:21;:::i;:::-;12893:3;12886:34;12880:45;;:::o;12932:113::-;13015:24;13033:5;13015:24;:::i;:::-;13010:3;13003:37;12997:48;;:::o;13052:152::-;13153:45;13173:24;13191:5;13173:24;:::i;:::-;13153:45;:::i;:::-;13148:3;13141:58;13135:69;;:::o;13211:343::-;;13321:38;13353:5;13321:38;:::i;:::-;13371:70;13434:6;13429:3;13371:70;:::i;:::-;13364:77;;13446:52;13491:6;13486:3;13479:4;13472:5;13468:16;13446:52;:::i;:::-;13519:29;13541:6;13519:29;:::i;:::-;13514:3;13510:39;13503:46;;13301:253;;;;;:::o;13561:356::-;;13689:38;13721:5;13689:38;:::i;:::-;13739:88;13820:6;13815:3;13739:88;:::i;:::-;13732:95;;13832:52;13877:6;13872:3;13865:4;13858:5;13854:16;13832:52;:::i;:::-;13905:6;13900:3;13896:16;13889:23;;13669:248;;;;;:::o;13924:347::-;;14036:39;14069:5;14036:39;:::i;:::-;14087:71;14151:6;14146:3;14087:71;:::i;:::-;14080:78;;14163:52;14208:6;14203:3;14196:4;14189:5;14185:16;14163:52;:::i;:::-;14236:29;14258:6;14236:29;:::i;:::-;14231:3;14227:39;14220:46;;14016:255;;;;;:::o;14278:360::-;;14408:39;14441:5;14408:39;:::i;:::-;14459:89;14541:6;14536:3;14459:89;:::i;:::-;14452:96;;14553:52;14598:6;14593:3;14586:4;14579:5;14575:16;14553:52;:::i;:::-;14626:6;14621:3;14617:16;14610:23;;14388:250;;;;;:::o;14670:884::-;;14807:5;14801:12;14841:1;14830:9;14826:17;14854:1;14849:268;;;;15128:1;15123:425;;;;14819:729;;14849:268;14927:4;14923:1;14912:9;14908:17;14904:28;14946:89;15028:6;15023:3;14946:89;:::i;:::-;14939:96;;15073:4;15069:9;15058;15054:25;15049:3;15042:38;15103:6;15098:3;15094:16;15087:23;;14856:261;14849:268;;15123:425;15192:1;15181:9;15177:17;15208:89;15290:6;15285:3;15208:89;:::i;:::-;15201:96;;15319:38;15351:5;15319:38;:::i;:::-;15373:1;15381:130;15395:6;15392:1;15389:13;15381:130;;;15460:7;15454:14;15450:1;15445:3;15441:11;15434:35;15501:1;15492:7;15488:15;15477:26;;15417:4;15414:1;15410:12;15405:17;;15381:130;;;15534:6;15529:3;15525:16;15518:23;;15130:418;;;14819:729;;14777:777;;;;;:::o;15563:324::-;;15723:67;15787:2;15782:3;15723:67;:::i;:::-;15716:74;;15823:26;15819:1;15814:3;15810:11;15803:47;15878:2;15873:3;15869:12;15862:19;;15709:178;;;:::o;15896:371::-;;16056:67;16120:2;16115:3;16056:67;:::i;:::-;16049:74;;16156:34;16152:1;16147:3;16143:11;16136:55;16225:4;16220:2;16215:3;16211:12;16204:26;16258:2;16253:3;16249:12;16242:19;;16042:225;;;:::o;16276:329::-;;16436:67;16500:2;16495:3;16436:67;:::i;:::-;16429:74;;16536:31;16532:1;16527:3;16523:11;16516:52;16596:2;16591:3;16587:12;16580:19;;16422:183;;;:::o;16614:331::-;;16774:67;16838:2;16833:3;16774:67;:::i;:::-;16767:74;;16874:33;16870:1;16865:3;16861:11;16854:54;16936:2;16931:3;16927:12;16920:19;;16760:185;;;:::o;16954:400::-;;17132:85;17214:2;17209:3;17132:85;:::i;:::-;17125:92;;17250:66;17246:1;17241:3;17237:11;17230:87;17345:2;17340:3;17336:12;17329:19;;17118:236;;;:::o;17363:387::-;;17523:67;17587:2;17582:3;17523:67;:::i;:::-;17516:74;;17623:34;17619:1;17614:3;17610:11;17603:55;17692:20;17687:2;17682:3;17678:12;17671:42;17741:2;17736:3;17732:12;17725:19;;17509:241;;;:::o;17759:328::-;;17919:67;17983:2;17978:3;17919:67;:::i;:::-;17912:74;;18019:30;18015:1;18010:3;18006:11;17999:51;18078:2;18073:3;18069:12;18062:19;;17905:182;;;:::o;18096:373::-;;18256:67;18320:2;18315:3;18256:67;:::i;:::-;18249:74;;18356:34;18352:1;18347:3;18343:11;18336:55;18425:6;18420:2;18415:3;18411:12;18404:28;18460:2;18455:3;18451:12;18444:19;;18242:227;;;:::o;18478:325::-;;18638:67;18702:2;18697:3;18638:67;:::i;:::-;18631:74;;18738:27;18734:1;18729:3;18725:11;18718:48;18794:2;18789:3;18785:12;18778:19;;18624:179;;;:::o;18812:371::-;;18972:67;19036:2;19031:3;18972:67;:::i;:::-;18965:74;;19072:34;19068:1;19063:3;19059:11;19052:55;19141:4;19136:2;19131:3;19127:12;19120:26;19174:2;19169:3;19165:12;19158:19;;18958:225;;;:::o;19192:381::-;;19352:67;19416:2;19411:3;19352:67;:::i;:::-;19345:74;;19452:34;19448:1;19443:3;19439:11;19432:55;19521:14;19516:2;19511:3;19507:12;19500:36;19564:2;19559:3;19555:12;19548:19;;19338:235;;;:::o;19582:393::-;;19742:67;19806:2;19801:3;19742:67;:::i;:::-;19735:74;;19842:34;19838:1;19833:3;19829:11;19822:55;19911:26;19906:2;19901:3;19897:12;19890:48;19966:2;19961:3;19957:12;19950:19;;19728:247;;;:::o;19984:379::-;;20144:67;20208:2;20203:3;20144:67;:::i;:::-;20137:74;;20244:34;20240:1;20235:3;20231:11;20224:55;20313:12;20308:2;20303:3;20299:12;20292:34;20354:2;20349:3;20345:12;20338:19;;20130:233;;;:::o;20372:323::-;;20532:67;20596:2;20591:3;20532:67;:::i;:::-;20525:74;;20632:25;20628:1;20623:3;20619:11;20612:46;20686:2;20681:3;20677:12;20670:19;;20518:177;;;:::o;20704:371::-;;20864:67;20928:2;20923:3;20864:67;:::i;:::-;20857:74;;20964:34;20960:1;20955:3;20951:11;20944:55;21033:4;21028:2;21023:3;21019:12;21012:26;21066:2;21061:3;21057:12;21050:19;;20850:225;;;:::o;21084:371::-;;21244:67;21308:2;21303:3;21244:67;:::i;:::-;21237:74;;21344:34;21340:1;21335:3;21331:11;21324:55;21413:4;21408:2;21403:3;21399:12;21392:26;21446:2;21441:3;21437:12;21430:19;;21230:225;;;:::o;21464:332::-;;21624:67;21688:2;21683:3;21624:67;:::i;:::-;21617:74;;21724:34;21720:1;21715:3;21711:11;21704:55;21787:2;21782:3;21778:12;21771:19;;21610:186;;;:::o;21805:381::-;;21965:67;22029:2;22024:3;21965:67;:::i;:::-;21958:74;;22065:34;22061:1;22056:3;22052:11;22045:55;22134:14;22129:2;22124:3;22120:12;22113:36;22177:2;22172:3;22168:12;22161:19;;21951:235;;;:::o;22195:381::-;;22355:67;22419:2;22414:3;22355:67;:::i;:::-;22348:74;;22455:34;22451:1;22446:3;22442:11;22435:55;22524:14;22519:2;22514:3;22510:12;22503:36;22567:2;22562:3;22558:12;22551:19;;22341:235;;;:::o;22585:378::-;;22745:67;22809:2;22804:3;22745:67;:::i;:::-;22738:74;;22845:34;22841:1;22836:3;22832:11;22825:55;22914:11;22909:2;22904:3;22900:12;22893:33;22954:2;22949:3;22945:12;22938:19;;22731:232;;;:::o;22972:384::-;;23132:67;23196:2;23191:3;23132:67;:::i;:::-;23125:74;;23232:34;23228:1;23223:3;23219:11;23212:55;23301:17;23296:2;23291:3;23287:12;23280:39;23347:2;23342:3;23338:12;23331:19;;23118:238;;;:::o;23365:370::-;;23525:67;23589:2;23584:3;23525:67;:::i;:::-;23518:74;;23625:34;23621:1;23616:3;23612:11;23605:55;23694:3;23689:2;23684:3;23680:12;23673:25;23726:2;23721:3;23717:12;23710:19;;23511:224;;;:::o;23744:386::-;;23904:67;23968:2;23963:3;23904:67;:::i;:::-;23897:74;;24004:34;24000:1;23995:3;23991:11;23984:55;24073:19;24068:2;24063:3;24059:12;24052:41;24121:2;24116:3;24112:12;24105:19;;23890:240;;;:::o;24139:329::-;;24299:67;24363:2;24358:3;24299:67;:::i;:::-;24292:74;;24399:31;24395:1;24390:3;24386:11;24379:52;24459:2;24454:3;24450:12;24443:19;;24285:183;;;:::o;24476:113::-;24559:24;24577:5;24559:24;:::i;:::-;24554:3;24547:37;24541:48;;:::o;24596:107::-;24675:22;24691:5;24675:22;:::i;:::-;24670:3;24663:35;24657:46;;:::o;24710:271::-;;24863:93;24952:3;24943:6;24863:93;:::i;:::-;24856:100;;24973:3;24966:10;;24844:137;;;;:::o;24988:430::-;;25188:92;25276:3;25267:6;25188:92;:::i;:::-;25181:99;;25298:95;25389:3;25380:6;25298:95;:::i;:::-;25291:102;;25410:3;25403:10;;25169:249;;;;;:::o;25425:520::-;;25661:148;25805:3;25661:148;:::i;:::-;25654:155;;25820:75;25891:3;25882:6;25820:75;:::i;:::-;25917:2;25912:3;25908:12;25901:19;;25937:3;25930:10;;25642:303;;;;:::o;25952:222::-;;26079:2;26068:9;26064:18;26056:26;;26093:71;26161:1;26150:9;26146:17;26137:6;26093:71;:::i;:::-;26050:124;;;;:::o;26181:672::-;;26426:3;26415:9;26411:19;26403:27;;26441:87;26525:1;26514:9;26510:17;26501:6;26441:87;:::i;:::-;26539:72;26607:2;26596:9;26592:18;26583:6;26539:72;:::i;:::-;26622;26690:2;26679:9;26675:18;26666:6;26622:72;:::i;:::-;26742:9;26736:4;26732:20;26727:2;26716:9;26712:18;26705:48;26767:76;26838:4;26829:6;26767:76;:::i;:::-;26759:84;;26397:456;;;;;;;:::o;26860:532::-;;27063:2;27052:9;27048:18;27040:26;;27077:71;27145:1;27134:9;27130:17;27121:6;27077:71;:::i;:::-;27159:72;27227:2;27216:9;27212:18;27203:6;27159:72;:::i;:::-;27279:9;27273:4;27269:20;27264:2;27253:9;27249:18;27242:48;27304:78;27377:4;27368:6;27304:78;:::i;:::-;27296:86;;27034:358;;;;;;:::o;27399:210::-;;27520:2;27509:9;27505:18;27497:26;;27534:65;27596:1;27585:9;27581:17;27572:6;27534:65;:::i;:::-;27491:118;;;;:::o;27616:548::-;;27823:3;27812:9;27808:19;27800:27;;27838:71;27906:1;27895:9;27891:17;27882:6;27838:71;:::i;:::-;27920:68;27984:2;27973:9;27969:18;27960:6;27920:68;:::i;:::-;27999:72;28067:2;28056:9;28052:18;28043:6;27999:72;:::i;:::-;28082;28150:2;28139:9;28135:18;28126:6;28082:72;:::i;:::-;27794:370;;;;;;;:::o;28171:310::-;;28318:2;28307:9;28303:18;28295:26;;28368:9;28362:4;28358:20;28354:1;28343:9;28339:17;28332:47;28393:78;28466:4;28457:6;28393:78;:::i;:::-;28385:86;;28289:192;;;;:::o;28488:416::-;;28688:2;28677:9;28673:18;28665:26;;28738:9;28732:4;28728:20;28724:1;28713:9;28709:17;28702:47;28763:131;28889:4;28763:131;:::i;:::-;28755:139;;28659:245;;;:::o;28911:416::-;;29111:2;29100:9;29096:18;29088:26;;29161:9;29155:4;29151:20;29147:1;29136:9;29132:17;29125:47;29186:131;29312:4;29186:131;:::i;:::-;29178:139;;29082:245;;;:::o;29334:416::-;;29534:2;29523:9;29519:18;29511:26;;29584:9;29578:4;29574:20;29570:1;29559:9;29555:17;29548:47;29609:131;29735:4;29609:131;:::i;:::-;29601:139;;29505:245;;;:::o;29757:416::-;;29957:2;29946:9;29942:18;29934:26;;30007:9;30001:4;29997:20;29993:1;29982:9;29978:17;29971:47;30032:131;30158:4;30032:131;:::i;:::-;30024:139;;29928:245;;;:::o;30180:416::-;;30380:2;30369:9;30365:18;30357:26;;30430:9;30424:4;30420:20;30416:1;30405:9;30401:17;30394:47;30455:131;30581:4;30455:131;:::i;:::-;30447:139;;30351:245;;;:::o;30603:416::-;;30803:2;30792:9;30788:18;30780:26;;30853:9;30847:4;30843:20;30839:1;30828:9;30824:17;30817:47;30878:131;31004:4;30878:131;:::i;:::-;30870:139;;30774:245;;;:::o;31026:416::-;;31226:2;31215:9;31211:18;31203:26;;31276:9;31270:4;31266:20;31262:1;31251:9;31247:17;31240:47;31301:131;31427:4;31301:131;:::i;:::-;31293:139;;31197:245;;;:::o;31449:416::-;;31649:2;31638:9;31634:18;31626:26;;31699:9;31693:4;31689:20;31685:1;31674:9;31670:17;31663:47;31724:131;31850:4;31724:131;:::i;:::-;31716:139;;31620:245;;;:::o;31872:416::-;;32072:2;32061:9;32057:18;32049:26;;32122:9;32116:4;32112:20;32108:1;32097:9;32093:17;32086:47;32147:131;32273:4;32147:131;:::i;:::-;32139:139;;32043:245;;;:::o;32295:416::-;;32495:2;32484:9;32480:18;32472:26;;32545:9;32539:4;32535:20;32531:1;32520:9;32516:17;32509:47;32570:131;32696:4;32570:131;:::i;:::-;32562:139;;32466:245;;;:::o;32718:416::-;;32918:2;32907:9;32903:18;32895:26;;32968:9;32962:4;32958:20;32954:1;32943:9;32939:17;32932:47;32993:131;33119:4;32993:131;:::i;:::-;32985:139;;32889:245;;;:::o;33141:416::-;;33341:2;33330:9;33326:18;33318:26;;33391:9;33385:4;33381:20;33377:1;33366:9;33362:17;33355:47;33416:131;33542:4;33416:131;:::i;:::-;33408:139;;33312:245;;;:::o;33564:416::-;;33764:2;33753:9;33749:18;33741:26;;33814:9;33808:4;33804:20;33800:1;33789:9;33785:17;33778:47;33839:131;33965:4;33839:131;:::i;:::-;33831:139;;33735:245;;;:::o;33987:416::-;;34187:2;34176:9;34172:18;34164:26;;34237:9;34231:4;34227:20;34223:1;34212:9;34208:17;34201:47;34262:131;34388:4;34262:131;:::i;:::-;34254:139;;34158:245;;;:::o;34410:416::-;;34610:2;34599:9;34595:18;34587:26;;34660:9;34654:4;34650:20;34646:1;34635:9;34631:17;34624:47;34685:131;34811:4;34685:131;:::i;:::-;34677:139;;34581:245;;;:::o;34833:416::-;;35033:2;35022:9;35018:18;35010:26;;35083:9;35077:4;35073:20;35069:1;35058:9;35054:17;35047:47;35108:131;35234:4;35108:131;:::i;:::-;35100:139;;35004:245;;;:::o;35256:416::-;;35456:2;35445:9;35441:18;35433:26;;35506:9;35500:4;35496:20;35492:1;35481:9;35477:17;35470:47;35531:131;35657:4;35531:131;:::i;:::-;35523:139;;35427:245;;;:::o;35679:416::-;;35879:2;35868:9;35864:18;35856:26;;35929:9;35923:4;35919:20;35915:1;35904:9;35900:17;35893:47;35954:131;36080:4;35954:131;:::i;:::-;35946:139;;35850:245;;;:::o;36102:416::-;;36302:2;36291:9;36287:18;36279:26;;36352:9;36346:4;36342:20;36338:1;36327:9;36323:17;36316:47;36377:131;36503:4;36377:131;:::i;:::-;36369:139;;36273:245;;;:::o;36525:416::-;;36725:2;36714:9;36710:18;36702:26;;36775:9;36769:4;36765:20;36761:1;36750:9;36746:17;36739:47;36800:131;36926:4;36800:131;:::i;:::-;36792:139;;36696:245;;;:::o;36948:416::-;;37148:2;37137:9;37133:18;37125:26;;37198:9;37192:4;37188:20;37184:1;37173:9;37169:17;37162:47;37223:131;37349:4;37223:131;:::i;:::-;37215:139;;37119:245;;;:::o;37371:416::-;;37571:2;37560:9;37556:18;37548:26;;37621:9;37615:4;37611:20;37607:1;37596:9;37592:17;37585:47;37646:131;37772:4;37646:131;:::i;:::-;37638:139;;37542:245;;;:::o;37794:416::-;;37994:2;37983:9;37979:18;37971:26;;38044:9;38038:4;38034:20;38030:1;38019:9;38015:17;38008:47;38069:131;38195:4;38069:131;:::i;:::-;38061:139;;37965:245;;;:::o;38217:222::-;;38344:2;38333:9;38329:18;38321:26;;38358:71;38426:1;38415:9;38411:17;38402:6;38358:71;:::i;:::-;38315:124;;;;:::o;38446:256::-;;38508:2;38502:9;38492:19;;38546:4;38538:6;38534:17;38645:6;38633:10;38630:22;38609:18;38597:10;38594:34;38591:62;38588:2;;;38666:1;38663;38656:12;38588:2;38686:10;38682:2;38675:22;38486:216;;;;:::o;38709:304::-;;38868:18;38860:6;38857:30;38854:2;;;38900:1;38897;38890:12;38854:2;38935:4;38927:6;38923:17;38915:25;;38998:4;38992;38988:15;38980:23;;38791:222;;;:::o;39020:313::-;;39188:18;39180:6;39177:30;39174:2;;;39220:1;39217;39210:12;39174:2;39255:4;39247:6;39243:17;39235:25;;39318:4;39312;39308:15;39300:23;;39111:222;;;:::o;39340:314::-;;39509:18;39501:6;39498:30;39495:2;;;39541:1;39538;39531:12;39495:2;39576:4;39568:6;39564:17;39556:25;;39639:4;39633;39629:15;39621:23;;39432:222;;;:::o;39661:304::-;;39820:18;39812:6;39809:30;39806:2;;;39852:1;39849;39842:12;39806:2;39887:4;39879:6;39875:17;39867:25;;39950:4;39944;39940:15;39932:23;;39743:222;;;:::o;39972:321::-;;40115:18;40107:6;40104:30;40101:2;;;40147:1;40144;40137:12;40101:2;40214:4;40210:9;40203:4;40195:6;40191:17;40187:33;40179:41;;40278:4;40272;40268:15;40260:23;;40038:255;;;:::o;40300:322::-;;40444:18;40436:6;40433:30;40430:2;;;40476:1;40473;40466:12;40430:2;40543:4;40539:9;40532:4;40524:6;40520:17;40516:33;40508:41;;40607:4;40601;40597:15;40589:23;;40367:255;;;:::o;40629:158::-;;40697:3;40689:11;;40734:3;40731:1;40724:14;40766:4;40763:1;40753:18;40745:26;;40683:104;;;:::o;40794:121::-;;40887:5;40881:12;40871:22;;40852:63;;;:::o;40922:122::-;;41016:5;41010:12;41000:22;;40981:63;;;:::o;41052:162::-;;41166:6;41161:3;41154:19;41203:4;41198:3;41194:14;41179:29;;41147:67;;;;:::o;41223:144::-;;41358:3;41343:18;;41336:31;;;;:::o;41376:163::-;;41491:6;41486:3;41479:19;41528:4;41523:3;41519:14;41504:29;;41472:67;;;;:::o;41548:145::-;;41684:3;41669:18;;41662:31;;;;:::o;41701:91::-;;41763:24;41781:5;41763:24;:::i;:::-;41752:35;;41746:46;;;:::o;41799:99::-;;41869:24;41887:5;41869:24;:::i;:::-;41858:35;;41852:46;;;:::o;41905:85::-;;41978:5;41971:13;41964:21;41953:32;;41947:43;;;:::o;41997:72::-;;42059:5;42048:16;;42042:27;;;:::o;42076:144::-;;42148:66;42141:5;42137:78;42126:89;;42120:100;;;:::o;42227:121::-;;42300:42;42293:5;42289:54;42278:65;;42272:76;;;:::o;42355:72::-;;42417:5;42406:16;;42400:27;;;:::o;42434:81::-;;42505:4;42498:5;42494:16;42483:27;;42477:38;;;:::o;42523:145::-;42604:6;42599:3;42594;42581:30;42660:1;42651:6;42646:3;42642:16;42635:27;42574:94;;;:::o;42677:268::-;42742:1;42749:101;42763:6;42760:1;42757:13;42749:101;;;42839:1;42834:3;42830:11;42824:18;42820:1;42815:3;42811:11;42804:39;42785:2;42782:1;42778:10;42773:15;;42749:101;;;42865:6;42862:1;42859:13;42856:2;;;42930:1;42921:6;42916:3;42912:16;42905:27;42856:2;42726:219;;;;:::o;42953:74::-;;43017:5;43006:16;;43000:27;;;:::o;43034:97::-;;43122:2;43118:7;43113:2;43106:5;43102:14;43098:28;43088:38;;43082:49;;;:::o;43139:117::-;43208:24;43226:5;43208:24;:::i;:::-;43201:5;43198:35;43188:2;;43247:1;43244;43237:12;43188:2;43182:74;:::o;43263:111::-;43329:21;43344:5;43329:21;:::i;:::-;43322:5;43319:32;43309:2;;43365:1;43362;43355:12;43309:2;43303:71;:::o;43381:115::-;43449:23;43466:5;43449:23;:::i;:::-;43442:5;43439:34;43429:2;;43487:1;43484;43477:12;43429:2;43423:73;:::o;43503:117::-;43572:24;43590:5;43572:24;:::i;:::-;43565:5;43562:35;43552:2;;43611:1;43608;43601:12;43552:2;43546:74;:::o

ipfs://d2e7b497f0ce557744df22a28da97efec177f200d851126cfbf1b8fdfcd191a0