private void mapComplexTypesByPath(Map<SymbolPath, Deque<NumFwdRef>> typeFIFOsByPath,
			int indexNumber, AbstractComplexMsType complexType) {

		SymbolPath symbolPath = new SymbolPath(SymbolPathParser.parse(complexType.getName()));
		boolean isFwdRef = complexType.getMsProperty().isForwardReference();
		RecordNumber recordNumber = complexType.getRecordNumber();

		Deque<NumFwdRef> numTypeFIFO = typeFIFOsByPath.get(symbolPath);
		if (numTypeFIFO == null) {
			numTypeFIFO = new ArrayDeque<>();
			typeFIFOsByPath.put(symbolPath, numTypeFIFO);

			// Putting forward reference or definition (doesn't matter which it is)
			if (!numTypeFIFO.add(new NumFwdRef(recordNumber, isFwdRef))) {
				// Error
			}
		}
		else {
			NumFwdRef firstNumFwdRef = numTypeFIFO.peekFirst();

			// If same in FIFO, then add to bottom of the FIFO, as all records on this FIFO
			//  will be the same per this algorithm.
			if (firstNumFwdRef.isFwd() == isFwdRef) {
				if (!numTypeFIFO.add(new NumFwdRef(recordNumber, isFwdRef))) {
					// Error
				}
			}
			else {
				numTypeFIFO.removeFirst();

				// ORIGINAL THOUGHT AND CODE
				// It doesn't matter now if first is fwdref and second is def or vice versa, as we
				//  are always storing the new incoming (larger) index as the key and the existing
				//  index as the value
				//map.put(indexNumber, firstNumFwdRef.number());

				// NEW THOUGHT AND CODE
				// Here we are always mapping fwdref to definition.  This is because there are
				//  times when we need the definition record number to be part of the fixed
				//  symbol path and we need the fwdref symbol path to be the same.  Thus we
				//  want to be able to have ready access to the def record.
				if (isFwdRef) {
					map.put(recordNumber, firstNumFwdRef.number());
//					// Following is just temporary during development to compare with
//					//  previous mapping capability.  TODO remove
//					System.out.println(String.format("%d %s %d -> %d",
//					(complexType instanceof AbstractEnumMsType) ? 1 : 0, symbolPath.toString(),
//					indexNumber, firstNumFwdRef.number()));
				}
				else {
					map.put(firstNumFwdRef.number(), recordNumber);
//					// Following is just temporary during development to compare with
//					//  previous mapping capability.  TODO remove
//					System.out.println(String.format("%d %s %d <- %d",
//					(complexType instanceof AbstractEnumMsType) ? 1 : 0, symbolPath.toString(),
//					firstNumFwdRef.number(), indexNumber));
				}

				// Do not need to keep all of these around.  Might come back but will regenerate
				if (numTypeFIFO.isEmpty()) {
					typeFIFOsByPath.remove(symbolPath);
				}
			}
		}
	}
Returns map to alternate record number or argument record number if no map.  Result is
 RecordNumber of alternative record for the complex type.  Map is of fwdref to definition
 RecordNumbers.  The fwdref number is generally, but not always, the lower number
@param recordNumber the record number for which to do the lookup
@return the mapped record number or the original record number if no mapped entry
Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ComplexTypeMapper.java