private List<PseudoInstruction> parseDelaySlots(Instruction inst, MemBuffer blockMemBuffer,
			InstructionBlock block) throws NestedDelaySlotException {

		int minDelaySlotBytes = inst.getPrototype().getDelaySlotByteCount();
		if (minDelaySlotBytes == 0) {
			return null; // no delay slots
		}

		if (inst.isInDelaySlot()) {
			throw new NestedDelaySlotException();
		}

		Address instAddr = inst.getMinAddress();
		Address addr = instAddr;
		int length = inst.getLength();

		List<PseudoInstruction> instrList = new ArrayList<>();
		try {
			while (minDelaySlotBytes > 0) {

				try {
					addr = addr.addNoWrap(length);
				}
				catch (AddressOverflowException e) {
					block.setInstructionMemoryError(addr, inst.getAddress(),
						"Failed to properly process delay slot at end of address space");
					break;
				}

				disassemblerContext.flowToAddress(addr);

				MemBuffer dsInstrMemBuffer = new WrappedMemBuffer(blockMemBuffer,
					(int) addr.subtract(blockMemBuffer.getAddress()));

				// create one instruction
				InstructionPrototype prototype =
					language.parse(dsInstrMemBuffer, disassemblerContext, true);
				RegisterValue contextValue = null;
				if (baseContextRegister != null) {
					contextValue = disassemblerContext.getRegisterValue(baseContextRegister);
				}

				PseudoInstruction dsInstr =
					getPseudoInstruction(dsInstrMemBuffer, prototype, contextValue, block);

				if (repeatInstructionByteTracker.exceedsRepeatBytePattern(dsInstr)) {
					block.setParseConflict(addr, contextValue, instAddr,
						"Maximum run of repeated byte instructions exceeded");
				}

				instrList.add(dsInstr);

				length = dsInstr.getLength();
				minDelaySlotBytes -= length;
			}
			return instrList;
		}
		catch (NestedDelaySlotException e) {
			throw e; // avoid UnknownInstructionException catch below
		}
		catch (AddressOutOfBoundsException | AddressOverflowException e) {
			block.setInstructionMemoryError(addr, instAddr,
				"Instruction does not fit within address space constraint");
		}
		catch (InsufficientBytesException e) {
			block.setInstructionMemoryError(addr, instAddr, e.getMessage());
		}
		catch (UnknownInstructionException e) {
			block.setParseConflict(addr,
				disassemblerContext.getRegisterValue(disassemblerContext.getBaseContextRegister()),
				instAddr, e.getMessage());
		}
		return null; // error occurred
	}
Process a new instruction which has just been parsed.  This method is responsible for
adding the instruction to the current block as well as any delay-slotted instructions.
This method may be overridden and the instruction re-parsed if necessary. 

@param inst instruction to process
@param blockMemBuffer buffer to get bytes
@param block current block of instructions
@param instructionSet address set of current instructions in block
@return instruction fallthrough address or null if no fallthrough
@throws InsufficientBytesException if a memory error occurs during instruction processing 
@throws UnknownInstructionException if an error occurs during a modified re-parse of
the instruction.
@throws AddressOverflowException if address goes out of address space
@throws NestedDelaySlotException if delay slot found in a delay slot
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/disassemble/Disassembler.java