@Override
	public FlowType getFlowType(CodeBlock block) {

		if (!(block.getModel() instanceof SimpleBlockModel)) {
			throw new IllegalArgumentException();
		}

		// don't know the flow type yet, try to get the instruction type
		// of the last address in the block
		Instruction instr = listing.getInstructionContaining(block.getMaxAddress());
		if (instr != null) {

			// search backwards until a non-delay slot instruction is found
			while (instr.isInDelaySlot()) {
				Address fallFrom = instr.getFallFrom();
				if (fallFrom == null) {
					Msg.warn(this, "WARNING: Invalid delay slot instruction found at " +
						instr.getMinAddress());
					break;
				}
				instr = listing.getInstructionContaining(fallFrom);
			}
			FlowType flowType = instr.getFlowType();
			if (block.getStartAddresses().length > 1) {
				// modify flow type to a conditional	
				if (flowType == RefType.UNCONDITIONAL_CALL) {
					flowType = RefType.CONDITIONAL_CALL;
				}
				else if (flowType == RefType.UNCONDITIONAL_JUMP) {
					flowType = RefType.CONDITIONAL_JUMP;
				}
				else if (flowType.isTerminal()) {
					flowType = RefType.CONDITIONAL_TERMINATOR;
				}
			}
			else if (flowType.isFallthrough()) {
				// Use flow type associated with first flow-type reference
				Reference[] refs = referenceMgr.getFlowReferencesFrom(instr.getMinAddress());
				for (Reference ref : refs) {
					RefType refType = ref.getReferenceType();
					if (refType instanceof FlowType) {
						flowType = (FlowType) refType;
						break;
					}
				}
			}
			return flowType;
		}

		Data data = listing.getDefinedDataContaining(block.getMinAddress());
		if (data != null) {
			return RefType.INDIRECTION;
//            
//            // if no label here
//            Symbol sym = program.getSymbolTable().getSymbol(data.getMinAddress());
//            if (sym == null) {
//                return FlowType.INVALID;
//            }
//
//            // look at all refs to symbol, if not referred to by fallthrough
//            //  instruction, must be flow, so return true.
//            Referent refs[] = sym.getReferences();
//            if (refs == null) {
//                return FlowType.INVALID;
//            }
//            for (int i=0; i<refs.length; i++) {
//                Instruction refInstr = listing.getInstructionAt(refs[i].getAddress());
//                if (refInstr == null || refInstr.getFlowType().isFallthrough()) {
//                    continue;
//                }
//                return refInstr.getFlowType();
//            }
		}

		return RefType.INVALID;
	}
Return in general how things flow out of this node.
If there are any abnormal ways to flow out of this node,
(ie: jump, call, etc...) then the flow type of the node
takes on that type.

If there are multiple unique ways out of the node, then we
should return FlowType.UNKNOWN (or FlowType.MULTIFLOW ?).

Fallthrough is returned if that is the only way out.

If this block really has no valid instructions, it can't flow,
so FlowType.INVALID is returned.

@return flow type of this node
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/block/SimpleBlockModel.java