public static List<Address> findDirectReferencesCodeUnit(Program program, int alignment,
			CodeUnit codeUnit, TaskMonitor monitor) {

		if (monitor == null) {
			monitor = TaskMonitor.DUMMY;
		}

		AddressSet toAddressSet =
			new AddressSet((codeUnit.getMinAddress()), codeUnit.getMaxAddress());

		List<ReferenceAddressPair> directReferenceList = new ArrayList<>();
		List<Address> results = new ArrayList<>();

		try {
			ProgramMemoryUtil.loadDirectReferenceList(program, alignment,
				toAddressSet.getMinAddress(), toAddressSet, directReferenceList, monitor);
		}
		catch (CancelledException e) {
			return Collections.emptyList();
		}

		for (ReferenceAddressPair rap : directReferenceList) {
			if (monitor.isCancelled()) {
				return null;
			}
			Address fromAddr = rap.getSource();
			if (!results.contains(fromAddr)) {
				results.add(fromAddr);
			}
		}

		return results;
	}
commenting this out is making it find the instances of 46 01's not the 0a 00's - closer though
					// check for the case where the reference includes both the segment and offset
					// and the case where the reference includes only the offset but the address being checked
					// is in the same segment as the current address
					//if ((segmentShort == currentSegment) || (shortSega == currentSegment)) {
					//	addrLong = longCurrentAddress; // this is only so that the check below works
					//}
					addrLong = offsetShort;
					//	}
				}
				else if (addrSize == 16) {
					short addrShort = memory.getShort(a);
					addrLong = addrShort & 0xffffL; // multiply by wordsize because 
					// address offsets are at the byte level,
					// not the addressable word level.
				}
				else if (addrSize == 32) {
					int addrInt = memory.getInt(a);
					addrLong = addrInt & 0xffffffffL;
				}
				else if (addrSize == 64) {
					addrLong = memory.getLong(a);
				}
				else {
					// handle any addrSize the hard way
					byte dest[] = new byte[addrSize / 8];
					int num = memory.getBytes(a, dest);
					if (num != dest.length) {
						continue; // insufficient bytes
					}
					addrLong = 0;
					for (int i = 0; i < dest.length; i++) {
						int destIndex = isBigEndian ? i : (dest.length - i - 1);
						addrLong = (addrLong << 8) | (dest[destIndex] & 0xff);
					}
				}

				Address addr;
				if (toAddress instanceof SegmentedAddress) {
					SegmentedAddressSpace space =
						(SegmentedAddressSpace) toAddress.getAddressSpace();
					addr = space.getAddress(currentSegment, (int) addrLong);
				}
				else {
					addr = toAddress.getNewAddress(addrLong * unitSize);
				}

				Address addrShifted = null;
				int addressShiftAmount =
					program.getDataTypeManager().getDataOrganization().getPointerShift();
				if (addressShiftAmount != 0) {
					// look for addresses that are shifted for those processors who
					// store shifted pointers
					addrLongShifted = addrLong << addressShiftAmount;
					try {
						addrShifted = toAddress.getNewAddress(addrLongShifted * unitSize);
					}
					catch (AddressOutOfBoundsException e) {
						// ignore for now; the null check happens below
					}
				}

				// TODO: This is flawed since the wrong unitSize may have been used to create addr
				//       Each address-space may have a different unitSize - it's a little weird
				//       to have both a toAddress and a toAddressSet specified where toAddress is required
				if (toAddressSet.contains(addr)) {
					accumulator.add(new ReferenceAddressPair(a, addr));
				}
				if (addrShifted != null && toAddressSet.contains(addrShifted)) {
					accumulator.add(new ReferenceAddressPair(a, addrShifted));
				}
			}
			catch (MemoryAccessException e) {
				// ignore (tsk, tsk)
			}
			catch (AddressOutOfBoundsException e) {
				// ignore (tsk, tsk)
			}
		}
	}

	/**
Checks a programs memory for direct references to the CodeUnit indicated.
Direct references are only found at addresses that match the indicated alignment. 
@param program the program whose memory is to be checked.
@param alignment direct references are to only be found at the indicated alignment in memory.
@param codeUnit the code unit to search for references.
@param monitor a task monitor for progress or to allow canceling.
@return list of addresses referring directly to the toAddress.
Ghidra/Features/Base/src/main/java/ghidra/program/util/ProgramMemoryUtil.java