private void storeOperands(Instruction instruction, SleighDebugLogger logger,
			MaskValue maskValue, CodeUnit cu) {

		// Iterates through all the operands for the currently selected 
		// instruction and stores them.
		for (int i = 1; i <= logger.getNumOperands(); i++) {
			byte[] mask = logger.getOperandValueMask(i - 1);
			byte[] value = logger.getMaskedBytes(mask);

			if (mask == null || value == null) {
				return;
			}

			// Builds case to store the operands mask and value
			OperandMaskValue opMaskValue = new OperandMaskValue(mask, value,
				instruction.getDefaultOperandRepresentation(i - 1));

			// Determines if the given operand is a constant value. If it is 
			// a constant then proper flag is set.
			//
			// NOTE: Addresses and Scalars are both treated as constants.
			if (cu.getScalar(i - 1) != null || cu.getAddress(i - 1) != null) {
				opMaskValue.setConstant(true);
			}

			LinkedHashMap<MaskValue, OperandMaskValue> mnemonicToOpMap = null;

			// Do a check on the size of the instruction map (ops).  The size of ops must be 
			// equal to the max number of operands across all instructions.  ie: if we have an 
			// instruction with 4 operands, then ops.size() better equal 4.  So do a check here - 
			// if ops isn't large enough to handle the number of ops in this instruction, add
			// another map struct.
			if (ops.size() < i) {
				mnemonicToOpMap = new LinkedHashMap<>();
				ops.add(mnemonicToOpMap);
			}
			else {
				mnemonicToOpMap = ops.get(i - 1);
			}

			// Adds the operand to the data-structure with a mapping to the 
			// instruction mnemonic extracted earlier
			mnemonicToOpMap.put(maskValue, opMaskValue);
		}
	}
Populates objects with mask/operand info for future use.

@param instruction
@param logger
@param maskValue
@param cu
Ghidra/Features/Base/src/main/java/ghidra/features/base/memsearch/mnemonic/MaskGenerator.java