protected Address processInstruction(PseudoInstruction inst, MemBuffer blockMemBuffer,
			InstructionBlock block, InstructionSet instructionSet)
			throws InsufficientBytesException, UnknownInstructionException,
			AddressOverflowException, NestedDelaySlotException {

		List<PseudoInstruction> delaySlotList = parseDelaySlots(inst, blockMemBuffer, block);

		if (followFlow) {
			processInstructionFlows(inst, block);
		}

		block.addInstruction(inst);

		if (delaySlotList != null) {
			for (PseudoInstruction dsInstr : delaySlotList) {
				block.addInstruction(dsInstr);
				dsInstr.setInstructionBlock(block);
			}
		}

		// NOTE: Don't rely on instruction for fallthrough since this will not work
		// on a pseudo instruction when an instruction has delay slots.
		// Block fallthrough not yet established.
		if (!inst.hasFallthrough()) {
			return null;
		}
		return block.getMaxAddress().next();
	}
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