Contract 0xdf4dbf6536201370f95e06a0f8a7a70fe40e388a

/**
 *Submitted for verification at BscScan.com on 2021-02-04
*/

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

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @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.3.0, sets of type `bytes32` (`Bytes32Set`), `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];
    }

    // Bytes32Set

    struct Bytes32Set {
        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(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, 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(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

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

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set 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(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, 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));
    }
}

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

pragma solidity >=0.6.2 <0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

// File: @openzeppelin/contracts/access/AccessControl.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(
        bytes32 indexed role,
        bytes32 indexed previousAdminRole,
        bytes32 indexed newAdminRole
    );

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index)
        public
        view
        returns (address)
    {
        return _roles[role].members.at(index);
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(
            hasRole(_roles[role].adminRole, _msgSender()),
            "AccessControl: sender must be an admin to grant"
        );

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(
            hasRole(_roles[role].adminRole, _msgSender()),
            "AccessControl: sender must be an admin to revoke"
        );

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        require(
            account == _msgSender(),
            "AccessControl: can only renounce roles for self"
        );

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (_roles[role].members.add(account)) {
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (_roles[role].members.remove(account)) {
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

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

pragma solidity >=0.6.0 <0.8.0;

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

pragma solidity >=0.6.2 <0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

// File: @pancakeswap/pancake-swap-lib/contracts/token/BEP20/IBEP20.sol

pragma solidity >=0.4.0;

interface IBEP20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the token decimals.
     */
    function decimals() external view returns (uint8);

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

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

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external view returns (address);

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

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

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

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

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

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

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

// File: contracts/utils/SafeBEP20.sol

pragma solidity ^0.6.0;

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

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

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

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

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

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

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

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

// File: contracts/PancakeProfile.sol

pragma solidity ^0.6.0;

/** @title PancakeProfile.
@dev It is a contract for users to bind their address 
to a customizable profile by depositing a NFT.
*/
contract PancakeProfile is AccessControl, ERC721Holder {
    using Counters for Counters.Counter;
    using SafeBEP20 for IBEP20;
    using SafeMath for uint256;

    IBEP20 public cakeToken;

    bytes32 public constant NFT_ROLE = keccak256("NFT_ROLE");
    bytes32 public constant POINT_ROLE = keccak256("POINT_ROLE");
    bytes32 public constant SPECIAL_ROLE = keccak256("SPECIAL_ROLE");

    uint256 public numberActiveProfiles;
    uint256 public numberCakeToReactivate;
    uint256 public numberCakeToRegister;
    uint256 public numberCakeToUpdate;
    uint256 public numberTeams;

    mapping(address => bool) public hasRegistered;

    mapping(uint256 => Team) private teams;
    mapping(address => User) private users;

    // Used for generating the teamId
    Counters.Counter private _countTeams;

    // Used for generating the userId
    Counters.Counter private _countUsers;

    // Event to notify a new team is created
    event TeamAdd(uint256 teamId, string teamName);

    // Event to notify that team points are increased
    event TeamPointIncrease(
        uint256 indexed teamId,
        uint256 numberPoints,
        uint256 indexed campaignId
    );

    event UserChangeTeam(
        address indexed userAddress,
        uint256 oldTeamId,
        uint256 newTeamId
    );

    // Event to notify that a user is registered
    event UserNew(
        address indexed userAddress,
        uint256 teamId,
        address nftAddress,
        uint256 tokenId
    );

    // Event to notify a user pausing her profile
    event UserPause(address indexed userAddress, uint256 teamId);

    // Event to notify that user points are increased
    event UserPointIncrease(
        address indexed userAddress,
        uint256 numberPoints,
        uint256 indexed campaignId
    );

    // Event to notify that a list of users have an increase in points
    event UserPointIncreaseMultiple(
        address[] userAddresses,
        uint256 numberPoints,
        uint256 indexed campaignId
    );

    // Event to notify that a user is reactivating her profile
    event UserReactivate(
        address indexed userAddress,
        uint256 teamId,
        address nftAddress,
        uint256 tokenId
    );

    // Event to notify that a user is pausing her profile
    event UserUpdate(
        address indexed userAddress,
        address nftAddress,
        uint256 tokenId
    );

    // Modifier for admin roles
    modifier onlyOwner() {
        require(
            hasRole(DEFAULT_ADMIN_ROLE, _msgSender()),
            "Not the main admin"
        );
        _;
    }

    // Modifier for point roles
    modifier onlyPoint() {
        require(hasRole(POINT_ROLE, _msgSender()), "Not a point admin");
        _;
    }

    // Modifier for special roles
    modifier onlySpecial() {
        require(hasRole(SPECIAL_ROLE, _msgSender()), "Not a special admin");
        _;
    }

    struct Team {
        string teamName;
        string teamDescription;
        uint256 numberUsers;
        uint256 numberPoints;
        bool isJoinable;
    }

    struct User {
        uint256 userId;
        uint256 numberPoints;
        uint256 teamId;
        address nftAddress;
        uint256 tokenId;
        bool isActive;
    }

    constructor(
        IBEP20 _cakeToken,
        uint256 _numberCakeToReactivate,
        uint256 _numberCakeToRegister,
        uint256 _numberCakeToUpdate
    ) public {
        cakeToken = _cakeToken;
        numberCakeToReactivate = _numberCakeToReactivate;
        numberCakeToRegister = _numberCakeToRegister;
        numberCakeToUpdate = _numberCakeToUpdate;
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
    }

    /**
     * @dev To create a user profile. It sends the NFT to the contract
     * and sends CAKE to burn address. Requires 2 token approvals.
     */
    function createProfile(
        uint256 _teamId,
        address _nftAddress,
        uint256 _tokenId
    ) external {
        require(!hasRegistered[_msgSender()], "Already registered");
        require((_teamId <= numberTeams) && (_teamId > 0), "Invalid teamId");
        require(teams[_teamId].isJoinable, "Team not joinable");
        require(hasRole(NFT_ROLE, _nftAddress), "NFT address invalid");

        // Loads the interface to deposit the NFT contract
        IERC721 nftToken = IERC721(_nftAddress);

        require(
            _msgSender() == nftToken.ownerOf(_tokenId),
            "Only NFT owner can register"
        );

        // Transfer NFT to this contract
        nftToken.safeTransferFrom(_msgSender(), address(this), _tokenId);

        // Transfer CAKE tokens to this contract
        cakeToken.safeTransferFrom(
            _msgSender(),
            address(this),
            numberCakeToRegister
        );

        // Increment the _countUsers counter and get userId
        _countUsers.increment();
        uint256 newUserId = _countUsers.current();

        // Add data to the struct for newUserId
        users[_msgSender()] = User({
            userId: newUserId,
            numberPoints: 0,
            teamId: _teamId,
            nftAddress: _nftAddress,
            tokenId: _tokenId,
            isActive: true
        });

        // Update registration status
        hasRegistered[_msgSender()] = true;

        // Update number of active profiles
        numberActiveProfiles = numberActiveProfiles.add(1);

        // Increase the number of users for the team
        teams[_teamId].numberUsers = teams[_teamId].numberUsers.add(1);

        // Emit an event
        emit UserNew(_msgSender(), _teamId, _nftAddress, _tokenId);
    }

    /**
     * @dev To pause user profile. It releases the NFT.
     * Callable only by registered users.
     */
    function pauseProfile() external {
        require(hasRegistered[_msgSender()], "Has not registered");

        // Checks whether user has already paused
        require(users[_msgSender()].isActive, "User not active");

        // Change status of user to make it inactive
        users[_msgSender()].isActive = false;

        // Retrieve the teamId of the user calling
        uint256 userTeamId = users[_msgSender()].teamId;

        // Reduce number of active users and team users
        teams[userTeamId].numberUsers = teams[userTeamId].numberUsers.sub(1);
        numberActiveProfiles = numberActiveProfiles.sub(1);

        // Interface to deposit the NFT contract
        IERC721 nftToken = IERC721(users[_msgSender()].nftAddress);

        // tokenId of NFT redeemed
        uint256 redeemedTokenId = users[_msgSender()].tokenId;

        // Change internal statuses as extra safety
        users[_msgSender()].nftAddress = address(
            0x0000000000000000000000000000000000000000
        );

        users[_msgSender()].tokenId = 0;

        // Transfer the NFT back to the user
        nftToken.safeTransferFrom(address(this), _msgSender(), redeemedTokenId);

        // Emit event
        emit UserPause(_msgSender(), userTeamId);
    }

    /**
     * @dev To update user profile.
     * Callable only by registered users.
     */
    function updateProfile(address _nftAddress, uint256 _tokenId) external {
        require(hasRegistered[_msgSender()], "Has not registered");
        require(hasRole(NFT_ROLE, _nftAddress), "NFT address invalid");
        require(users[_msgSender()].isActive, "User not active");

        address currentAddress = users[_msgSender()].nftAddress;
        uint256 currentTokenId = users[_msgSender()].tokenId;

        // Interface to deposit the NFT contract
        IERC721 nftNewToken = IERC721(_nftAddress);

        require(
            _msgSender() == nftNewToken.ownerOf(_tokenId),
            "Only NFT owner can update"
        );

        // Transfer token to new address
        nftNewToken.safeTransferFrom(_msgSender(), address(this), _tokenId);

        // Transfer CAKE token to this address
        cakeToken.safeTransferFrom(
            _msgSender(),
            address(this),
            numberCakeToUpdate
        );

        // Interface to deposit the NFT contract
        IERC721 nftCurrentToken = IERC721(currentAddress);

        // Transfer old token back to the owner
        nftCurrentToken.safeTransferFrom(
            address(this),
            _msgSender(),
            currentTokenId
        );

        // Update mapping in storage
        users[_msgSender()].nftAddress = _nftAddress;
        users[_msgSender()].tokenId = _tokenId;

        emit UserUpdate(_msgSender(), _nftAddress, _tokenId);
    }

    /**
     * @dev To reactivate user profile.
     * Callable only by registered users.
     */
    function reactivateProfile(address _nftAddress, uint256 _tokenId) external {
        require(hasRegistered[_msgSender()], "Has not registered");
        require(hasRole(NFT_ROLE, _nftAddress), "NFT address invalid");
        require(!users[_msgSender()].isActive, "User is active");

        // Interface to deposit the NFT contract
        IERC721 nftToken = IERC721(_nftAddress);
        require(
            _msgSender() == nftToken.ownerOf(_tokenId),
            "Only NFT owner can update"
        );

        // Transfer to this address
        cakeToken.safeTransferFrom(
            _msgSender(),
            address(this),
            numberCakeToReactivate
        );

        // Transfer NFT to contract
        nftToken.safeTransferFrom(_msgSender(), address(this), _tokenId);

        // Retrieve teamId of the user
        uint256 userTeamId = users[_msgSender()].teamId;

        // Update number of users for the team and number of active profiles
        teams[userTeamId].numberUsers = teams[userTeamId].numberUsers.add(1);
        numberActiveProfiles = numberActiveProfiles.add(1);

        // Update user statuses
        users[_msgSender()].isActive = true;
        users[_msgSender()].nftAddress = _nftAddress;
        users[_msgSender()].tokenId = _tokenId;

        // Emit event
        emit UserReactivate(_msgSender(), userTeamId, _nftAddress, _tokenId);
    }

    /**
     * @dev To increase the number of points for a user.
     * Callable only by point admins
     */
    function increaseUserPoints(
        address _userAddress,
        uint256 _numberPoints,
        uint256 _campaignId
    ) external onlyPoint {
        // Increase the number of points for the user
        users[_userAddress].numberPoints = users[_userAddress].numberPoints.add(
            _numberPoints
        );

        emit UserPointIncrease(_userAddress, _numberPoints, _campaignId);
    }

    /**
     * @dev To increase the number of points for a set of users.
     * Callable only by point admins
     */
    function increaseUserPointsMultiple(
        address[] calldata _userAddresses,
        uint256 _numberPoints,
        uint256 _campaignId
    ) external onlyPoint {
        require(_userAddresses.length < 1001, "Length must be < 1001");
        for (uint256 i = 0; i < _userAddresses.length; i++) {
            users[_userAddresses[i]].numberPoints = users[_userAddresses[i]]
                .numberPoints
                .add(_numberPoints);
        }
        emit UserPointIncreaseMultiple(
            _userAddresses,
            _numberPoints,
            _campaignId
        );
    }

    /**
     * @dev To increase the number of points for a team.
     * Callable only by point admins
     */

    function increaseTeamPoints(
        uint256 _teamId,
        uint256 _numberPoints,
        uint256 _campaignId
    ) external onlyPoint {
        // Increase the number of points for the team
        teams[_teamId].numberPoints = teams[_teamId].numberPoints.add(
            _numberPoints
        );

        emit TeamPointIncrease(_teamId, _numberPoints, _campaignId);
    }

    /**
     * @dev To remove the number of points for a user.
     * Callable only by point admins
     */
    function removeUserPoints(address _userAddress, uint256 _numberPoints)
        external
        onlyPoint
    {
        // Increase the number of points for the user
        users[_userAddress].numberPoints = users[_userAddress].numberPoints.sub(
            _numberPoints
        );
    }

    /**
     * @dev To remove a set number of points for a set of users.
     */
    function removeUserPointsMultiple(
        address[] calldata _userAddresses,
        uint256 _numberPoints
    ) external onlyPoint {
        require(_userAddresses.length < 1001, "Length must be < 1001");
        for (uint256 i = 0; i < _userAddresses.length; i++) {
            users[_userAddresses[i]].numberPoints = users[_userAddresses[i]]
                .numberPoints
                .sub(_numberPoints);
        }
    }

    /**
     * @dev To remove the number of points for a team.
     * Callable only by point admins
     */

    function removeTeamPoints(uint256 _teamId, uint256 _numberPoints)
        external
        onlyPoint
    {
        // Increase the number of points for the team
        teams[_teamId].numberPoints = teams[_teamId].numberPoints.sub(
            _numberPoints
        );
    }

    /**
     * @dev To add a NFT contract address for users to set their profile.
     * Callable only by owner admins.
     */
    function addNftAddress(address _nftAddress) external onlyOwner {
        require(
            IERC721(_nftAddress).supportsInterface(0x80ac58cd),
            "Not ERC721"
        );
        grantRole(NFT_ROLE, _nftAddress);
    }

    /**
     * @dev Add a new teamId
     * Callable only by owner admins.
     */
    function addTeam(
        string calldata _teamName,
        string calldata _teamDescription
    ) external onlyOwner {
        // Verify length is between 3 and 16
        bytes memory strBytes = bytes(_teamName);
        require(strBytes.length < 20, "Must be < 20");
        require(strBytes.length > 3, "Must be > 3");

        // Increment the _countTeams counter and get teamId
        _countTeams.increment();
        uint256 newTeamId = _countTeams.current();

        // Add new team data to the struct
        teams[newTeamId] = Team({
            teamName: _teamName,
            teamDescription: _teamDescription,
            numberUsers: 0,
            numberPoints: 0,
            isJoinable: true
        });

        numberTeams = newTeamId;
        emit TeamAdd(newTeamId, _teamName);
    }

    /**
     * @dev Function to change team.
     * Callable only by special admins.
     */
    function changeTeam(address _userAddress, uint256 _newTeamId)
        external
        onlySpecial
    {
        require(hasRegistered[_userAddress], "User doesn't exist");
        require(
            (_newTeamId <= numberTeams) && (_newTeamId > 0),
            "teamId doesn't exist"
        );
        require(teams[_newTeamId].isJoinable, "Team not joinable");
        require(
            users[_userAddress].teamId != _newTeamId,
            "Already in the team"
        );

        // Get old teamId
        uint256 oldTeamId = users[_userAddress].teamId;

        // Change number of users in old team
        teams[oldTeamId].numberUsers = teams[oldTeamId].numberUsers.sub(1);

        // Change teamId in user mapping
        users[_userAddress].teamId = _newTeamId;

        // Change number of users in new team
        teams[_newTeamId].numberUsers = teams[_newTeamId].numberUsers.add(1);

        emit UserChangeTeam(_userAddress, oldTeamId, _newTeamId);
    }

    /**
     * @dev Claim CAKE to burn later.
     * Callable only by owner admins.
     */
    function claimFee(uint256 _amount) external onlyOwner {
        cakeToken.safeTransfer(_msgSender(), _amount);
    }

    /**
     * @dev Make a team joinable again.
     * Callable only by owner admins.
     */
    function makeTeamJoinable(uint256 _teamId) external onlyOwner {
        require((_teamId <= numberTeams) && (_teamId > 0), "teamId invalid");
        teams[_teamId].isJoinable = true;
    }

    /**
     * @dev Make a team not joinable.
     * Callable only by owner admins.
     */
    function makeTeamNotJoinable(uint256 _teamId) external onlyOwner {
        require((_teamId <= numberTeams) && (_teamId > 0), "teamId invalid");
        teams[_teamId].isJoinable = false;
    }

    /**
     * @dev Rename a team
     * Callable only by owner admins.
     */
    function renameTeam(
        uint256 _teamId,
        string calldata _teamName,
        string calldata _teamDescription
    ) external onlyOwner {
        require((_teamId <= numberTeams) && (_teamId > 0), "teamId invalid");

        // Verify length is between 3 and 16
        bytes memory strBytes = bytes(_teamName);
        require(strBytes.length < 20, "Must be < 20");
        require(strBytes.length > 3, "Must be > 3");

        teams[_teamId].teamName = _teamName;
        teams[_teamId].teamDescription = _teamDescription;
    }

    /**
     * @dev Update the number of CAKE to register
     * Callable only by owner admins.
     */
    function updateNumberCake(
        uint256 _newNumberCakeToReactivate,
        uint256 _newNumberCakeToRegister,
        uint256 _newNumberCakeToUpdate
    ) external onlyOwner {
        numberCakeToReactivate = _newNumberCakeToReactivate;
        numberCakeToRegister = _newNumberCakeToRegister;
        numberCakeToUpdate = _newNumberCakeToUpdate;
    }

    /**
     * @dev Check the user's profile for a given address
     */
    function getUserProfile(address _userAddress)
        external
        view
        returns (
            uint256,
            uint256,
            uint256,
            address,
            uint256,
            bool
        )
    {
        require(hasRegistered[_userAddress], "Not registered");
        return (
            users[_userAddress].userId,
            users[_userAddress].numberPoints,
            users[_userAddress].teamId,
            users[_userAddress].nftAddress,
            users[_userAddress].tokenId,
            users[_userAddress].isActive
        );
    }

    /**
     * @dev Check the user's status for a given address
     */
    function getUserStatus(address _userAddress) external view returns (bool) {
        return (users[_userAddress].isActive);
    }

    /**
     * @dev Check a team's profile
     */
    function getTeamProfile(uint256 _teamId)
        external
        view
        returns (
            string memory,
            string memory,
            uint256,
            uint256,
            bool
        )
    {
        require((_teamId <= numberTeams) && (_teamId > 0), "teamId invalid");
        return (
            teams[_teamId].teamName,
            teams[_teamId].teamDescription,
            teams[_teamId].numberUsers,
            teams[_teamId].numberPoints,
            teams[_teamId].isJoinable
        );
    }
}

[{"inputs":[{"internalType":"contract IBEP20","name":"_cakeToken","type":"address"},{"internalType":"uint256","name":"_numberCakeToReactivate","type":"uint256"},{"internalType":"uint256","name":"_numberCakeToRegister","type":"uint256"},{"internalType":"uint256","name":"_numberCakeToUpdate","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"teamId","type":"uint256"},{"indexed":false,"internalType":"string","name":"teamName","type":"string"}],"name":"TeamAdd","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"teamId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"numberPoints","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"campaignId","type":"uint256"}],"name":"TeamPointIncrease","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldTeamId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newTeamId","type":"uint256"}],"name":"UserChangeTeam","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"teamId","type":"uint256"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"UserNew","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"teamId","type":"uint256"}],"name":"UserPause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"numberPoints","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"campaignId","type":"uint256"}],"name":"UserPointIncrease","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"userAddresses","type":"address[]"},{"indexed":false,"internalType":"uint256","name":"numberPoints","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"campaignId","type":"uint256"}],"name":"UserPointIncreaseMultiple","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"teamId","type":"uint256"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"UserReactivate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"UserUpdate","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NFT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POINT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SPECIAL_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"}],"name":"addNftAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_teamName","type":"string"},{"internalType":"string","name":"_teamDescription","type":"string"}],"name":"addTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cakeToken","outputs":[{"internalType":"contract IBEP20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_newTeamId","type":"uint256"}],"name":"changeTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"claimFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"},{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"createProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"}],"name":"getTeamProfile","outputs":[{"internalType":"string","name":"","type":"string"},{"internalType":"string","name":"","type":"string"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"}],"name":"getUserProfile","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"}],"name":"getUserStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasRegistered","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"},{"internalType":"uint256","name":"_campaignId","type":"uint256"}],"name":"increaseTeamPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"},{"internalType":"uint256","name":"_campaignId","type":"uint256"}],"name":"increaseUserPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_userAddresses","type":"address[]"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"},{"internalType":"uint256","name":"_campaignId","type":"uint256"}],"name":"increaseUserPointsMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"}],"name":"makeTeamJoinable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"}],"name":"makeTeamNotJoinable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"numberActiveProfiles","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberCakeToReactivate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberCakeToRegister","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberCakeToUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberTeams","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"reactivateProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"}],"name":"removeTeamPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_userAddress","type":"address"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"}],"name":"removeUserPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_userAddresses","type":"address[]"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"}],"name":"removeUserPointsMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamId","type":"uint256"},{"internalType":"string","name":"_teamName","type":"string"},{"internalType":"string","name":"_teamDescription","type":"string"}],"name":"renameTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newNumberCakeToReactivate","type":"uint256"},{"internalType":"uint256","name":"_newNumberCakeToRegister","type":"uint256"},{"internalType":"uint256","name":"_newNumberCakeToUpdate","type":"uint256"}],"name":"updateNumberCake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"updateProfile","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000e09fabb73bd3ade0a17ecc321fd13a19e81ce820000000000000000000000000000000000000000000000001bc16d674ec800000000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000001bc16d674ec80000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000e09fabb73bd3ade0a17ecc321fd13a19e81ce82
Arg [1] : 0000000000000000000000000000000000000000000000001bc16d674ec80000
Arg [2] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [3] : 0000000000000000000000000000000000000000000000001bc16d674ec80000

49028:19335:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56358:1475;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56358:1475:0;;;;;;;;:::i;:::-;;62965:832;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62965:832:0;;-1:-1:-1;62965:832:0;-1:-1:-1;62965:832:0;:::i;40869:207::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40869:207:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40869:207:0;;-1:-1:-1;40869:207:0;;-1:-1:-1;;;;;40869:207:0:i;:::-;;;;;;;;;;;;;;;;;;;59489:408;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;59489:408:0;;;;;;;;;;;;;:::i;49563:33::-;;;:::i;:::-;;;;;;;;;;;;;;;;60756:388;;;;;;;;;;;;;;;;-1:-1:-1;60756:388:0;;;;;;;;;;;;:::i;65529:196::-;;;;;;;;;;;;;;;;-1:-1:-1;65529:196:0;;:::i;23187:114::-;;;;;;;;;;;;;;;;-1:-1:-1;23187:114:0;;:::i;66488:363::-;;;;;;;;;;;;;;;;-1:-1:-1;66488:363:0;;;;;;;;;;;;:::i;23563:264::-;;;;;;;;;;;;;;;;-1:-1:-1;23563:264:0;;;;;;-1:-1:-1;;;;;23563:264:0;;:::i;24846:246::-;;;;;;;;;;;;;;;;-1:-1:-1;24846:246:0;;;;;;-1:-1:-1;;;;;24846:246:0;;:::i;49603:26::-;;;:::i;49521:35::-;;;:::i;62635:235::-;;;;;;;;;;;;;;;;-1:-1:-1;62635:235:0;-1:-1:-1;;;;;62635:235:0;;:::i;65817:555::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65817:555:0;;-1:-1:-1;65817:555:0;-1:-1:-1;65817:555:0;:::i;49200:23::-;;;:::i;:::-;;;;-1:-1:-1;;;;;49200:23:0;;;;;;;;;;;;;;22828:170;;;;;;;;;;;;;;;;-1:-1:-1;22828:170:0;;;;;;;:::i;21789:139::-;;;;;;;;;;;;;;;;-1:-1:-1;21789:139:0;;;;;;-1:-1:-1;;;;;21789:139:0;;:::i;:::-;;;;;;;;;;;;;;;;;;66935:602;;;;;;;;;;;;;;;;-1:-1:-1;66935:602:0;-1:-1:-1;;;;;66935:602:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;66935:602:0;;;;;;;;;;;;;;;;;;;;;;;;;;49638:45;;;;;;;;;;;;;;;;-1:-1:-1;49638:45:0;-1:-1:-1;;;;;49638:45:0;;:::i;20432:49::-;;;:::i;57943:1424::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57943:1424:0;;;;;;;;:::i;61653:438::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61653:438:0;-1:-1:-1;61653:438:0;;:::i;67812:548::-;;;;;;;;;;;;;;;;-1:-1:-1;67812:548:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67812:548:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49435:35;;;:::i;49362:64::-;;;:::i;54961:1291::-;;;:::i;49295:60::-;;;:::i;22102:127::-;;;;;;;;;;;;;;;;-1:-1:-1;22102:127:0;;:::i;62213:282::-;;;;;;;;;;;;;;;;-1:-1:-1;62213:282:0;;;;;;;:::i;24072:267::-;;;;;;;;;;;;;;;;-1:-1:-1;24072:267:0;;;;;;-1:-1:-1;;;;;24072:267:0;;:::i;61264:297::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;61264:297:0;;;;;;;;:::i;49477:37::-;;;:::i;60027:605::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60027:605:0;-1:-1:-1;60027:605:0;;;;;;;:::i;63902:1003::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;63902:1003:0;;;;;;;;:::i;67620:130::-;;;;;;;;;;;;;;;;-1:-1:-1;67620:130:0;-1:-1:-1;;;;;67620:130:0;;:::i;65233:192::-;;;;;;;;;;;;;;;;-1:-1:-1;65233:192:0;;:::i;65009:118::-;;;;;;;;;;;;;;;;-1:-1:-1;65009:118:0;;:::i;49232:56::-;;;:::i;53003:1832::-;;;;;;;;;;;;;;;;-1:-1:-1;53003:1832:0;;;-1:-1:-1;;;;;53003:1832:0;;;;;;;;;;:::i;56358:1475::-;56448:13;:27;56462:12;:10;:12::i;:::-;-1:-1:-1;;;;;56448:27:0;;;;;;;;;;;;-1:-1:-1;56448:27:0;;;;56440:58;;;;;-1:-1:-1;;;56440:58:0;;;;;;;;;;;;-1:-1:-1;;;56440:58:0;;;;;;;;;;;;;;;56517:30;49267:21;56535:11;56517:7;:30::i;:::-;56509:62;;;;;-1:-1:-1;;;56509:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;56590:5;:19;56596:12;:10;:12::i;:::-;-1:-1:-1;;;;;56590:19:0;;;;;;;;;;;;-1:-1:-1;56590:19:0;:28;;;;;56582:56;;;;;-1:-1:-1;;;56582:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;56651:22;56676:5;:19;56682:12;:10;:12::i;:::-;-1:-1:-1;;;;;56676:19:0;;;;;;;;;;;;;;-1:-1:-1;56676:19:0;;;:30;;;;;;;-1:-1:-1;56742:5:0;-1:-1:-1;56748:12:0;:10;:12::i;:::-;-1:-1:-1;;;;;56742:19:0;-1:-1:-1;;;;;56742:19:0;;;;;;;;;;;;:27;;;56717:52;;56832:19;56862:11;56832:42;;56925:11;-1:-1:-1;;;;;56925:19:0;;56945:8;56925:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56925:29:0;-1:-1:-1;;;;;56909:45:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;56909:45:0;;56887:120;;;;;-1:-1:-1;;;56887:120:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;57062:11;-1:-1:-1;;;;;57062:28:0;;57091:12;:10;:12::i;:::-;57113:4;57120:8;57062:67;;;;;;;;;;;;;-1:-1:-1;;;;;57062:67:0;;;;;;-1:-1:-1;;;;;57062:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57190:125;57231:12;:10;:12::i;:::-;57286:18;;57190:9;;-1:-1:-1;;;;;57190:9:0;;:125;57266:4;;57190:26;:125::i;:::-;57412:14;-1:-1:-1;;;;;57489:32:0;;;57544:4;57564:12;:10;:12::i;:::-;57591:14;57489:127;;;;;;;;;;;;;-1:-1:-1;;;;;57489:127:0;;;;;;-1:-1:-1;;;;;57489:127:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57700:11;57667:5;:19;57673:12;:10;:12::i;:::-;-1:-1:-1;;;;;57667:19:0;-1:-1:-1;;;;;57667:19:0;;;;;;;;;;;;:30;;;:44;;;;;-1:-1:-1;;;;;57667:44:0;;;;;-1:-1:-1;;;;;57667:44:0;;;;;;57752:8;57722:5;:19;57728:12;:10;:12::i;:::-;-1:-1:-1;;;;;57722:19:0;;;;;;;;;;;;-1:-1:-1;57722:19:0;:27;;:38;57789:12;:10;:12::i;:::-;-1:-1:-1;;;;;57778:47:0;;57803:11;57816:8;57778:47;;;;-1:-1:-1;;;;;57778:47:0;;;;;;;;;;;;;;;;;;;;;56358:1475;;;;;;:::o;62965:832::-;51605:41;20477:4;51633:12;:10;:12::i;:::-;51605:7;:41::i;:::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;63144:21:::1;63174:9;;63144:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;63203:15:0;;63144:40;;-1:-1:-1;;63221:2:0::1;63203:20:::0;;::::1;::::0;-1:-1:-1;63195:45:0::1;;;::::0;;-1:-1:-1;;;63195:45:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;63195:45:0;;;;;;;;;;;;;::::1;;63277:1;63259:8;:15;:19;63251:43;;;::::0;;-1:-1:-1;;;63251:43:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;63251:43:0;;;;;;;;;;;;;::::1;;63368:23;:11;:21;:23::i;:::-;63402:17;63422:21;:11;:19;:21::i;:::-;63519:189;::::0;;;::::1;;::::0;::::1;::::0;;::::1;;::::0;;;;;;;::::1;::::0;::::1;::::0;;;63402:41;;-1:-1:-1;63519:189:0;;;63549:9;;;;;;63519:189;;63549:9;;;;63519:189;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;;;63519:189:0;;;-1:-1:-1;63519:189:0::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;;::::1;::::0;;63590:16;;;;;;63519:189;::::1;63590:16:::0;;;;63519:189;::::1;;::::0;::::1;::::0;;;-1:-1:-1;63519:189:0;;;-1:-1:-1;;;63519:189:0::1;::::0;;::::1;::::0;;;;;;;;;;63692:4:::1;63519:189:::0;;;;;;;;63500:16;;;:5:::1;:16:::0;;;;;:208;;;;:16;;:208:::1;::::0;:16;;:208;;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;63500:208:0::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;63500:208:0::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;-1:-1:-1;;63500:208:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;63721:11:::1;:23:::0;;;63760:29;;;;;::::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;63721:23;;63779:9;;63760:29;;;;;;;63779:9;63760:29;;63779:9;63760:29;::::1;;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;-1:-1:-1::0;;63760:29:0::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;63760:29:0;;-1:-1:-1;;;;;63760:29:0::1;51703:1;;62965:832:::0;;;;:::o;40869:207::-;41038:30;40869:207;;;;;;:::o;59489:408::-;51793:33;49332:23;51813:12;:10;:12::i;51793:33::-;51785:63;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;59737:19:0;::::1;;::::0;;;:5:::1;:19;::::0;;;;:32:::1;;::::0;:75:::1;::::0;59788:13;59737:36:::1;:75::i;:::-;-1:-1:-1::0;;;;;59702:19:0;::::1;;::::0;;;:5:::1;:19;::::0;;;;;;;;:32:::1;;:110:::0;;;;59830:59;;;;;;;59877:11;;59830:59:::1;::::0;;;;;;::::1;59489:408:::0;;;:::o;49563:33::-;;;;:::o;60756:388::-;51793:33;49332:23;51813:12;:10;:12::i;51793:33::-;51785:63;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;;;;60994:14:::1;::::0;;;:5:::1;:14;::::0;;;;:27:::1;;::::0;:70:::1;::::0;61040:13;60994:31:::1;:70::i;:::-;60964:5;:14;60970:7;60964:14;;;;;;;;;;;:27;;:100;;;;61124:11;61100:7;61082:54;61109:13;61082:54;;;;;;;;;;;;;;;;;;60756:388:::0;;;:::o;65529:196::-;51605:41;20477:4;51633:12;:10;:12::i;51605:41::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;65625:11:::1;;65614:7;:22;;65613:41;;;;;65652:1;65642:7;:11;65613:41;65605:68;;;::::0;;-1:-1:-1;;;65605:68:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;65605:68:0;;;;;;;;;;;;;::::1;;65712:5;65684:14:::0;;;:5:::1;:14;::::0;;;;:25:::1;;:33:::0;;-1:-1:-1;;65684:33:0::1;::::0;;65529:196::o;23187:114::-;23244:7;23271:12;;;;;;;;;;:22;;;;23187:114::o;66488:363::-;51605:41;20477:4;51633:12;:10;:12::i;51605:41::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;66680:22:::1;:51:::0;;;;66742:20:::1;:47:::0;66800:18:::1;:43:::0;66488:363::o;23563:264::-;23669:6;:12;;;;;;;;;;:22;;;23661:45;;23693:12;:10;:12::i;23661:45::-;23639:142;;;;-1:-1:-1;;;23639:142:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23794:25;23805:4;23811:7;23794:10;:25::i;:::-;23563:264;;:::o;24846:246::-;24958:12;:10;:12::i;:::-;-1:-1:-1;;;;;24947:23:0;:7;-1:-1:-1;;;;;24947:23:0;;24925:120;;;;-1:-1:-1;;;24925:120:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25058:26;25070:4;25076:7;25058:11;:26::i;49603:::-;;;;:::o;49521:35::-;;;;:::o;62635:235::-;51605:41;20477:4;51633:12;:10;:12::i;51605:41::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;62731:50:::1;::::0;;;;;;::::1;::::0;::::1;::::0;;;-1:-1:-1;;;;;62731:38:0;::::1;::::0;::::1;::::0;:50;;;;;::::1;::::0;;;;;;;;:38;:50;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;62731:50:0;62709:110:::1;;;::::0;;-1:-1:-1;;;62709:110:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;62830:32;49267:21;62850:11;62830:9;:32::i;:::-;62635:235:::0;:::o;65817:555::-;51605:41;20477:4;51633:12;:10;:12::i;51605:41::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;65999:11:::1;;65988:7;:22;;65987:41;;;;;66026:1;66016:7;:11;65987:41;65979:68;;;::::0;;-1:-1:-1;;;65979:68:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;65979:68:0;;;;;;;;;;;;;::::1;;66106:21;66136:9;;66106:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;66165:15:0;;66106:40;;-1:-1:-1;;66183:2:0::1;66165:20:::0;;::::1;::::0;-1:-1:-1;66157:45:0::1;;;::::0;;-1:-1:-1;;;66157:45:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;66157:45:0;;;;;;;;;;;;;::::1;;66239:1;66221:8;:15;:19;66213:43;;;::::0;;-1:-1:-1;;;66213:43:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;66213:43:0;;;;;;;;;;;;;::::1;;66269:14;::::0;;;:5:::1;:14;::::0;;;;:35:::1;::::0;66295:9;;66269:35:::1;:::i;:::-;-1:-1:-1::0;66315:14:0::1;::::0;;;:5:::1;:14;::::0;;;;:49:::1;::::0;:30:::1;;66348:16:::0;;66315:49:::1;:::i;:::-;;51703:1;65817:555:::0;;;;;:::o;49200:23::-;;;-1:-1:-1;;;;;49200:23:0;;:::o;22828:170::-;22928:7;22960:12;;;;;;;;;;:30;;22984:5;22960:23;:30::i;:::-;22953:37;;22828:170;;;;;:::o;21789:139::-;21858:4;21882:12;;;;;;;;;;:38;;21912:7;21882:29;:38::i;66935:602::-;-1:-1:-1;;;;;67195:27:0;;67045:7;67195:27;;;:13;:27;;;;;;67045:7;;;;;;;;;;67195:27;;67187:54;;;;;-1:-1:-1;;;67187:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;67274:19:0;;;;;;;:5;:19;;;;;:26;;67315:32;;;;67362:26;;;;67403:30;;;;67448:27;;;;67490:28;;;;;67274:26;;67315:32;;67362:26;;-1:-1:-1;67403:30:0;;-1:-1:-1;67490:28:0;;;;;66935:602::o;49638:45::-;;;;;;;;;;;;;;;:::o;20432:49::-;20477:4;20432:49;:::o;57943:1424::-;58037:13;:27;58051:12;:10;:12::i;:::-;-1:-1:-1;;;;;58037:27:0;;;;;;;;;;;;-1:-1:-1;58037:27:0;;;;58029:58;;;;;-1:-1:-1;;;58029:58:0;;;;;;;;;;;;-1:-1:-1;;;58029:58:0;;;;;;;;;;;;;;;58106:30;49267:21;58124:11;58106:7;:30::i;:::-;58098:62;;;;;-1:-1:-1;;;58098:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;58180:5;:19;58186:12;:10;:12::i;:::-;-1:-1:-1;;;;;58180:19:0;;;;;;;;;;;;-1:-1:-1;58180:19:0;:28;;;;;58179:29;58171:56;;;;;-1:-1:-1;;;58171:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;58290:16;58317:11;58290:39;;58378:8;-1:-1:-1;;;;;58378:16:0;;58395:8;58378:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58378:26:0;-1:-1:-1;;;;;58362:42:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;58362:42:0;;58340:117;;;;;-1:-1:-1;;;58340:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;58507:129;58548:12;:10;:12::i;:::-;58603:22;;58507:9;;-1:-1:-1;;;;;58507:9:0;;:129;58583:4;;58507:26;:129::i;:::-;58686:8;-1:-1:-1;;;;;58686:25:0;;58712:12;:10;:12::i;:::-;58734:4;58741:8;58686:64;;;;;;;;;;;;;-1:-1:-1;;;;;58686:64:0;;;;;;-1:-1:-1;;;;;58686:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58803:18;58824:5;:19;58830:12;:10;:12::i;:::-;-1:-1:-1;;;;;58824:19:0;-1:-1:-1;;;;;58824:19:0;;;;;;;;;;;;:26;;;58803:47;;58973:36;59007:1;58973:5;:17;58979:10;58973:17;;;;;;;;;;;:29;;;:33;;:36;;;;:::i;:::-;58941:17;;;;:5;:17;;;;;:29;;;;:68;;;;59043:20;:27;;59068:1;59043:24;:27::i;:::-;59020:20;:50;59147:4;59116:5;:19;59122:12;:10;:12::i;:::-;-1:-1:-1;;;;;59116:19:0;-1:-1:-1;;;;;59116:19:0;;;;;;;;;;;;:28;;;:35;;;;;;;;;;;;;;;;;;59195:11;59162:5;:19;59168:12;:10;:12::i;:::-;-1:-1:-1;;;;;59162:19:0;-1:-1:-1;;;;;59162:19:0;;;;;;;;;;;;:30;;;:44;;;;;-1:-1:-1;;;;;59162:44:0;;;;;-1:-1:-1;;;;;59162:44:0;;;;;;59247:8;59217:5;:19;59223:12;:10;:12::i;:::-;-1:-1:-1;;;;;59217:19:0;;;;;;;;;;;;-1:-1:-1;59217:19:0;:27;;:38;59311:12;:10;:12::i;:::-;59296:63;;;;;;-1:-1:-1;;;;;59296:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57943:1424;;;;:::o;61653:438::-;51793:33;49332:23;51813:12;:10;:12::i;51793:33::-;51785:63;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;;;;61832:4:::1;61808:28:::0;::::1;61800:62;;;::::0;;-1:-1:-1;;;61800:62:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;61878:9;61873:211;61893:25:::0;;::::1;61873:211;;;61980:92;62058:13;61980:5;:24;61986:14;;62001:1;61986:17;;;;;;;;;;;;;-1:-1:-1::0;;;;;61986:17:0::1;-1:-1:-1::0;;;;;61980:24:0::1;-1:-1:-1::0;;;;;61980:24:0::1;;;;;;;;;;;;:55;;;:77;;:92;;;;:::i;:::-;61940:5;:24;61946:14;;61961:1;61946:17;;;;;;;;;;;;;-1:-1:-1::0;;;;;61946:17:0::1;-1:-1:-1::0;;;;;61940:24:0::1;-1:-1:-1::0;;;;;61940:24:0::1;;;;;;;;;;;;:37;;:132;;;;61920:3;;;;;;;61873:211;;;;61653:438:::0;;;:::o;67812:548::-;67917:13;67945;67973:7;67995;68017:4;68069:11;;68058:7;:22;;68057:41;;;;;68096:1;68086:7;:11;68057:41;68049:68;;;;;-1:-1:-1;;;68049:68:0;;;;;;;;;;;;-1:-1:-1;;;68049:68:0;;;;;;;;;;;;;;;68150:14;;;;:5;:14;;;;;;;;;68233:26;;;;;68274:27;;;;68316:25;;;;68128:224;;;;;-1:-1:-1;;68188:30:0;68128:224;;;;68316:25;68128:224;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68150:14;;68188:30;;;;68233:26;;68274:27;;68316:25;;;;;68150:14;;68128:224;;;68150:14;68128:224;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68128:224:0;;;;;;;;;;;;;-1:-1:-1;;68128:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68128:224:0;;-1:-1:-1;68128:224:0;-1:-1:-1;68128:224:0;;;-1:-1:-1;68128:224:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68128:224:0;;;;-1:-1:-1;68128:224:0;;-1:-1:-1;68128:224:0;;-1:-1:-1;68128:224:0;;-1:-1:-1;67812:548:0;-1:-1:-1;;;;;;;67812:548:0:o;49435:35::-;;;;:::o;49362:64::-;49401:25;49362:64;:::o;54961:1291::-;55013:13;:27;55027:12;:10;:12::i;:::-;-1:-1:-1;;;;;55013:27:0;;;;;;;;;;;;-1:-1:-1;55013:27:0;;;;55005:58;;;;;-1:-1:-1;;;55005:58:0;;;;;;;;;;;;-1:-1:-1;;;55005:58:0;;;;;;;;;;;;;;;55135:5;:19;55141:12;:10;:12::i;:::-;-1:-1:-1;;;;;55135:19:0;;;;;;;;;;;;-1:-1:-1;55135:19:0;:28;;;;;55127:56;;;;;-1:-1:-1;;;55127:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55281:5;55250;:19;55256:12;:10;:12::i;:::-;-1:-1:-1;;;;;55250:19:0;;;;;;;;;;;;-1:-1:-1;55250:19:0;;;:28;;:36;;-1:-1:-1;;55250:36:0;;;;;;;;;;;55372:5;-1:-1:-1;55378:12:0;:10;:12::i;:::-;-1:-1:-1;;;;;55372:19:0;-1:-1:-1;;;;;55372:19:0;;;;;;;;;;;;:26;;;55351:47;;55500:36;55534:1;55500:5;:17;55506:10;55500:17;;;;;;;;;;;:29;;;:33;;:36;;;;:::i;:::-;55468:17;;;;:5;:17;;;;;:29;;;;:68;;;;55570:20;:27;;55595:1;55570:24;:27::i;:::-;55547:20;:50;55660:16;55687:5;55660:16;55693:12;:10;:12::i;:::-;-1:-1:-1;;;;;55687:19:0;;;;;;;;;;;;;;-1:-1:-1;55687:19:0;;;:30;;;;;;;-1:-1:-1;55793:5:0;-1:-1:-1;55799:12:0;:10;:12::i;:::-;-1:-1:-1;;;;;55793:19:0;-1:-1:-1;;;;;55793:19:0;;;;;;;;;;;;:27;;;55767:53;;55941:42;55886:5;:19;55892:12;:10;:12::i;:::-;-1:-1:-1;;;;;55886:19:0;-1:-1:-1;;;;;55886:19:0;;;;;;;;;;;;:30;;;:108;;;;;-1:-1:-1;;;;;55886:108:0;;;;;-1:-1:-1;;;;;55886:108:0;;;;;;56037:1;56007:5;:19;56013:12;:10;:12::i;:::-;-1:-1:-1;;;;;56007:19:0;-1:-1:-1;;;;;56007:19:0;;;;;;;;;;;;:27;;:31;;;;56097:8;-1:-1:-1;;;;;56097:25:0;;56131:4;56138:12;:10;:12::i;:::-;56152:15;56097:71;;;;;;;;;;;;;-1:-1:-1;;;;;56097:71:0;;;;;;-1:-1:-1;;;;;56097:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56219:12;:10;:12::i;:::-;-1:-1:-1;;;;;56209:35:0;;56233:10;56209:35;;;;;;;;;;;;;;;;;;54961:1291;;;:::o;49295:60::-;49332:23;49295:60;:::o;22102:127::-;22165:7;22192:12;;;;;;;;;;:29;;:27;:29::i;62213:282::-;51793:33;49332:23;51813:12;:10;:12::i;51793:33::-;51785:63;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;;;;62417:14:::1;::::0;;;:5:::1;:14;::::0;;;;:27:::1;;::::0;:70:::1;::::0;62463:13;62417:31:::1;:70::i;:::-;62387:14;::::0;;;:5:::1;:14;::::0;;;;;:27:::1;;:100:::0;;;;-1:-1:-1;62213:282:0:o;24072:267::-;24179:6;:12;;;;;;;;;;:22;;;24171:45;;24203:12;:10;:12::i;24171:45::-;24149:143;;;;-1:-1:-1;;;24149:143:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61264:297;51793:33;49332:23;51813:12;:10;:12::i;51793:33::-;51785:63;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;61478:19:0;::::1;;::::0;;;:5:::1;:19;::::0;;;;:32:::1;;::::0;:75:::1;::::0;61529:13;61478:36:::1;:75::i;:::-;-1:-1:-1::0;;;;;61443:19:0;;::::1;;::::0;;;:5:::1;:19;::::0;;;;:32:::1;;:110:::0;;;;-1:-1:-1;61264:297:0:o;49477:37::-;;;;:::o;60027:605::-;51793:33;49332:23;51813:12;:10;:12::i;51793:33::-;51785:63;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;-1:-1:-1;;;51785:63:0;;;;;;;;;;;;;;;60238:4:::1;60214:28:::0;::::1;60206:62;;;::::0;;-1:-1:-1;;;60206:62:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;60284:9;60279:211;60299:25:::0;;::::1;60279:211;;;60386:92;60464:13;60386:5;:24;60392:14;;60407:1;60392:17;;;;;;;;;;;;;-1:-1:-1::0;;;;;60392:17:0::1;-1:-1:-1::0;;;;;60386:24:0::1;-1:-1:-1::0;;;;;60386:24:0::1;;;;;;;;;;;;:55;;;:77;;:92;;;;:::i;:::-;60346:5;:24;60352:14;;60367:1;60352:17;;;;;;;;;;;;;-1:-1:-1::0;;;;;60352:17:0::1;-1:-1:-1::0;;;;;60346:24:0::1;-1:-1:-1::0;;;;;60346:24:0::1;;;;;;;;;;;;:37;;:132;;;;60326:3;;;;;;;60279:211;;;;60602:11;60505:119;60545:14;;60574:13;60505:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;-1:-1:-1::0;;60505:119:0::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;60505:119:0;;-1:-1:-1;;;;;60505:119:0::1;60027:605:::0;;;;:::o;63902:1003::-;51953:35;49401:25;51975:12;:10;:12::i;51953:35::-;51945:67;;;;;-1:-1:-1;;;51945:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64027:27:0;::::1;;::::0;;;:13:::1;:27;::::0;;;;;::::1;;64019:58;;;::::0;;-1:-1:-1;;;64019:58:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;64125:11;;64111:10;:25;;64110:47;;;;;64155:1;64142:10;:14;64110:47;64088:117;;;::::0;;-1:-1:-1;;;64088:117:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;64224:17;::::0;;;:5:::1;:17;::::0;;;;:28:::1;;::::0;::::1;;64216:58;;;::::0;;-1:-1:-1;;;64216:58:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;;;;64307:19:0;::::1;;::::0;;;:5:::1;:19;::::0;;;;:26:::1;;::::0;:40;::::1;;64285:109;;;::::0;;-1:-1:-1;;;64285:109:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;;;;64454:19:0;::::1;64434:17;64454:19:::0;;;:5:::1;:19;::::0;;;;;;;:26:::1;::::0;;::::1;::::0;64571:16;;;:5:::1;:16:::0;;;;;:28;;::::1;::::0;:35:::1;::::0;64604:1:::1;64571:32;:35::i;:::-;64540:16;::::0;;;:5:::1;:16;::::0;;;;;;;:28:::1;::::0;;::::1;:66:::0;;;;-1:-1:-1;;;;;64661:19:0;::::1;::::0;;:5:::1;:19:::0;;;;;:26;::::1;:39:::0;;;64792:17;;;;;;;;:29:::1;::::0;:36:::1;::::0;64826:1:::1;64792:33;:36::i;:::-;64760:17;::::0;;;:5:::1;:17;::::0;;;;;;;;:29:::1;;:68:::0;;;;64846:51;;;;;;;::::1;::::0;;;;;-1:-1:-1;;;;;64846:51:0;::::1;::::0;::::1;::::0;;;;;;;::::1;52023:1;63902:1003:::0;;:::o;67620:130::-;-1:-1:-1;;;;;67713:19:0;67688:4;67713:19;;;:5;:19;;;;;:28;;;;;;67620:130::o;65233:192::-;51605:41;20477:4;51633:12;:10;:12::i;51605:41::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;65326:11:::1;;65315:7;:22;;65314:41;;;;;65353:1;65343:7;:11;65314:41;65306:68;;;::::0;;-1:-1:-1;;;65306:68:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;65306:68:0;;;;;;;;;;;;;::::1;;65385:14;::::0;;;:5:::1;:14;::::0;;;;:25:::1;;:32:::0;;-1:-1:-1;;65385:32:0::1;65413:4;65385:32;::::0;;65233:192::o;65009:118::-;51605:41;20477:4;51633:12;:10;:12::i;51605:41::-;51583:109;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;-1:-1:-1;;;51583:109:0;;;;;;;;;;;;;;;65074:45:::1;65097:12;:10;:12::i;:::-;65074:9;::::0;-1:-1:-1;;;;;65074:9:0::1;::::0;65111:7;65074:22:::1;:45::i;49232:56::-:0;49267:21;49232:56;:::o;53003:1832::-;53145:13;:27;53159:12;:10;:12::i;:::-;-1:-1:-1;;;;;53145:27:0;;;;;;;;;;;;-1:-1:-1;53145:27:0;;;;53144:28;53136:59;;;;;-1:-1:-1;;;53136:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53226:11;;53215:7;:22;;53214:41;;;;;53253:1;53243:7;:11;53214:41;53206:68;;;;;-1:-1:-1;;;53206:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53293:14;;;;:5;:14;;;;;:25;;;;;53285:55;;;;;-1:-1:-1;;;53285:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53359:30;49267:21;53377:11;53359:7;:30::i;:::-;53351:62;;;;;-1:-1:-1;;;53351:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53486:16;53513:11;53486:39;;53576:8;-1:-1:-1;;;;;53576:16:0;;53593:8;53576:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53576:26:0;-1:-1:-1;;;;;53560:42:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;53560:42:0;;53538:119;;;;;-1:-1:-1;;;53538:119:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53712:8;-1:-1:-1;;;;;53712:25:0;;53738:12;:10;:12::i;:::-;53760:4;53767:8;53712:64;;;;;;;;;;;;;-1:-1:-1;;;;;53712:64:0;;;;;;-1:-1:-1;;;;;53712:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53839:127;53880:12;:10;:12::i;:::-;53935:20;;53839:9;;-1:-1:-1;;;;;53839:9:0;;:127;53915:4;;53839:26;:127::i;:::-;54040:23;:11;:21;:23::i;:::-;54074:17;54094:21;:11;:19;:21::i;:::-;54074:41;;54199:208;;;;;;;;54227:9;54199:208;;;;54265:1;54199:208;;;;54289:7;54199:208;;;;54323:11;-1:-1:-1;;;;;54199:208:0;;;;;54358:8;54199:208;;;;54391:4;54199:208;;;;;54177:5;:19;54183:12;:10;:12::i;:::-;-1:-1:-1;;;;;54177:19:0;;;;;;;;;;;;;;;;;-1:-1:-1;54177:19:0;;;:230;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;54177:230:0;;;;;;;;;;;;54459:13;;54473:12;:10;:12::i;:::-;-1:-1:-1;;;;;54459:27:0;;;;;;;;;;;;-1:-1:-1;54459:27:0;:34;;-1:-1:-1;;54459:34:0;;;;;;;;;;54574:20;;:27;;-1:-1:-1;54574:24:0;:27::i;:::-;54551:20;:50;;;54697:14;;;;:5;:14;;;;;:26;;:33;;54728:1;54697:30;:33::i;:::-;54668:14;;;;:5;:14;;;;;:26;;:62;54782:12;:10;:12::i;:::-;54774:53;;;;;;-1:-1:-1;;;;;54774:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53003:1832;;;;;:::o;6930:166::-;7018:4;7047:41;7052:3;-1:-1:-1;;;;;7072:14:0;;7047:4;:41::i;18376:106::-;18464:10;18376:106;:::o;45298:285::-;45496:68;;;-1:-1:-1;;;;;45496:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45519:27;45496:68;;;45442:133;;45476:5;;45442:19;:133::i;33253:181::-;33407:19;;33425:1;33407:19;;;33253:181::o;33131:114::-;33223:14;;33131:114::o;27450:181::-;27508:7;27540:5;;;27564:6;;;;27556:46;;;;;-1:-1:-1;;;27556:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;26126:188;26200:6;:12;;;;;;;;;;:33;;26225:7;26200:24;:33::i;:::-;26196:111;;;26282:12;:10;:12::i;:::-;-1:-1:-1;;;;;26255:40:0;26273:7;-1:-1:-1;;;;;26255:40:0;26267:4;26255:40;;;;;;;;;;26126:188;;:::o;26322:192::-;26397:6;:12;;;;;;;;;;:36;;26425:7;26397:27;:36::i;:::-;26393:114;;;26482:12;:10;:12::i;:::-;-1:-1:-1;;;;;26455:40:0;26473:7;-1:-1:-1;;;;;26455:40:0;26467:4;26455:40;;;;;;;;;;26322:192;;:::o;8277:181::-;8378:7;8426:22;8430:3;8442:5;8426:3;:22::i;7530:190::-;7637:4;7666:46;7676:3;-1:-1:-1;;;;;7696:14:0;;7666:9;:46::i;27914:136::-;27972:7;27999:43;28003:1;28006;27999:43;;;;;;;;;;;;;;;;;:3;:43::i;7806:117::-;7869:7;7896:19;7904:3;7896:7;:19::i;45042:248::-;45213:58;;;-1:-1:-1;;;;;45213:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45236:23;45213:58;;;45159:123;;45193:5;;45159:19;:123::i;:::-;45042:248;;;:::o;1750:414::-;1813:4;1835:21;1845:3;1850:5;1835:9;:21::i;:::-;1830:327;;-1:-1:-1;1873:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2056:18;;2034:19;;;:12;;;:19;;;;;;:40;;;;2089:11;;1830:327;-1:-1:-1;2140:5:0;2133:12;;47932:885;48356:23;48395:118;48441:4;48395:118;;;;;;;;;;;;;;;;;48403:5;-1:-1:-1;;;;;48395:27:0;;;:118;;;;;:::i;:::-;48528:17;;48356:157;;-1:-1:-1;48528:21:0;48524:286;;48701:10;48690:30;;;;;;;;;;;;;;;-1:-1:-1;48690:30:0;48664:134;;;;-1:-1:-1;;;48664:134:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7272:172;7363:4;7392:44;7400:3;-1:-1:-1;;;;;7420:14:0;;7392:7;:44::i;4693:273::-;4834:18;;4787:7;;4834:26;-1:-1:-1;4812:110:0;;;;-1:-1:-1;;;4812:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4940:3;:11;;4952:5;4940:18;;;;;;;;;;;;;;;;4933:25;;4693:273;;;;:::o;3983:161::-;4083:4;4112:19;;;:12;;;;;:19;;;;;;:24;;;3983:161::o;28353:226::-;28473:7;28509:12;28501:6;;;;28493:29;;;;-1:-1:-1;;;28493:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;28545:5:0;;;28353:226;;;;;;:::o;13974:229::-;14111:12;14143:52;14165:6;14173:4;14179:1;14182:12;14143:21;:52::i;:::-;14136:59;13974:229;-1:-1:-1;;;;13974:229:0:o;2340:1557::-;2406:4;2545:19;;;:12;;;:19;;;;;;2581:15;;2577:1313;;3029:18;;-1:-1:-1;;2980:14:0;;;;3029:22;;;;2956:21;;3029:3;;:22;;3316;;;;;;;;;;;;;;3296:42;;3462:9;3433:3;:11;;3445:13;3433:26;;;;;;;;;;;;;;;;;;;:38;;;;3539:23;;;3581:1;3539:12;;;:23;;;;;;3565:17;;;3539:43;;3691:17;;3539:3;;3691:17;;;;;;;;;;;;;;;;;;;;;;3786:3;:12;;:19;3799:5;3786:19;;;;;;;;;;;3779:26;;;3829:4;3822:11;;;;;;;;2577:1313;3873:5;3866:12;;;;;15190:621;15360:12;15432:5;15407:21;:30;;15385:118;;;;-1:-1:-1;;;15385:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15522:18;15533:6;15522:10;:18::i;:::-;15514:60;;;;;-1:-1:-1;;;15514:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15648:12;15662:23;15702:6;-1:-1:-1;;;;;15702:11:0;15721:5;15728:4;15702:31;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;15702:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15647:86;;;;15751:52;15769:7;15778:10;15790:12;15751:17;:52::i;:::-;15744:59;15190:621;-1:-1:-1;;;;;;;15190:621:0:o;10937:444::-;11317:20;11365:8;;;10937:444::o;16962:777::-;17112:12;17141:7;17137:595;;;-1:-1:-1;17172:10:0;17165:17;;17137:595;17286:17;;:21;17282:439;;17549:10;17543:17;17610:15;17597:10;17593:2;17589:19;17582:44;17497:148;17685:20;;-1:-1:-1;;;17685:20:0;;;;;;;;;;;;;;;;;17692:12;;17685:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://a38e035bc6519699ca270c9ca008a0a26f8cb142a23bb69da77cc614c0cb9025