private boolean processDeletingDestructor(RecoveredClass recoveredClass, Function vfunction,
			List<Address> allVftables)
			throws CancelledException, DuplicateNameException, InvalidInputException {

		// if the virtual function IS ALSO on the class constructor/destructor list
		// then it is a deleting destructor with and inlined destructor and we need to 
		// determine if the inline is the class or parent/grandparent class destructor
		boolean isDeletingDestructor = false;

		if (getAllClassFunctionsWithVtableRef(allVftables).contains(vfunction)) {

			recoveredClass.addDeletingDestructor(vfunction);
			recoveredClass.removeFromConstructorDestructorList(vfunction);
			recoveredClass.removeIndeterminateConstructorOrDestructor(vfunction);

			List<Address> vftableReferences = getVftableReferences(vfunction);
			if (vftableReferences == null) {
				return false;
			}
			for (Address vftableReference : vftableReferences) {
				monitor.checkCancelled();
				Address vftableAddress = getVftableAddress(vftableReference);
				if (vftableAddress == null) {
					continue;
				}
				// Type 1
				if (recoveredClass.getVftableAddresses().contains(vftableAddress)) {
					recoveredClass.addInlinedDestructor(vfunction);

					isDeletingDestructor = true;
				}
				// Type 2
				else {
					RecoveredClass parentClass = getVftableClass(vftableAddress);
					parentClass.addInlinedDestructor(vfunction);

					parentClass.removeFromConstructorDestructorList(vfunction);
					parentClass.removeIndeterminateConstructorOrDestructor(vfunction);
					isDeletingDestructor = true;
				}
			}

		}
		// else, if the virtual function CALLS a function on the current class constructor/destructor list
		// then it is a deleting destructor and we have identified a destructor function for the class
		else {
			List<Function> classConstructorOrDestructorFunctions =
				recoveredClass.getConstructorOrDestructorFunctions();

			for (Function function : classConstructorOrDestructorFunctions) {
				monitor.checkCancelled();

				if (extendedFlatAPI.doesFunctionACallFunctionB(vfunction, function)) {
					recoveredClass.addDeletingDestructor(vfunction);

					addDestructorToClass(recoveredClass, function);

					recoveredClass.removeIndeterminateConstructorOrDestructor(function);
					isDeletingDestructor = true;
				}
			}
		}
		return isDeletingDestructor;

	}
Method to find deleting destructors that do one of the following:
	1. reference their own vftable (ie on own c/d list) which means function
      is both a deleting destructor and has inlined the class destructor
  2. reference their parent vftable (ie on parent c/d list) which means function
      is a deleting destructor for class and inlined destructor for parent class
  3. do not reference a vftable but call own destructor (call func on own c/d list) which
      means it is just a deleting destructor for class but has no inlined destructor
@param recoveredClass the given class
@throws CancelledException if cancelled
@throws DuplicateNameException if try to create same symbol name already in namespace
@throws InvalidInputException if issues setting return type
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RecoveredClassHelper.java