dest = ret.append(fact.createBranchInstruction(Constants.GOTO, end));
dest = ret.append(InstructionFactory.createBranchInstruction(Constants.GOTO, end));
	static InstructionList genInlineInstructions(		LazyMethodGen donor,		LazyMethodGen recipient,		IntMap frameEnv,		InstructionFactory fact,		boolean keepReturns) 	{		InstructionList footer = new InstructionList();		InstructionHandle end = footer.append(fact.NOP);		InstructionList ret = new InstructionList();		InstructionList sourceList = donor.getBody();		Map srcToDest  = new HashMap();		ConstantPoolGen donorCpg = donor.getEnclosingClass().getConstantPoolGen();		ConstantPoolGen recipientCpg = recipient.getEnclosingClass().getConstantPoolGen();				boolean isAcrossClass = donorCpg != recipientCpg;				// first pass: copy the instructions directly, populate the srcToDest map,		// fix frame instructions		for (InstructionHandle src = sourceList.getStart();			src != null;			src = src.getNext()) 		{			Instruction fresh = Utility.copyInstruction(src.getInstruction());			InstructionHandle dest;			if (fresh instanceof CPInstruction) {				// need to reset index to go to new constant pool.  This is totally				// a computation leak... we're testing this LOTS of times.  Sigh.				if (isAcrossClass) {					CPInstruction cpi = (CPInstruction) fresh;					cpi.setIndex(recipientCpg.addConstant(donorCpg.getConstant(cpi.getIndex()), donorCpg));				}			}			if (src.getInstruction() == Range.RANGEINSTRUCTION) {				dest = ret.append(Range.RANGEINSTRUCTION);			} else if (fresh instanceof ReturnInstruction) {				if (keepReturns) {					dest = ret.append(fresh);				} else {					dest = ret.append(fact.createBranchInstruction(Constants.GOTO, end));				}			} else if (fresh instanceof BranchInstruction) {				dest = ret.append((BranchInstruction) fresh);			} else if (				fresh instanceof LocalVariableInstruction || fresh instanceof RET) {				IndexedInstruction indexed = (IndexedInstruction) fresh;				int oldIndex = indexed.getIndex();				int freshIndex;				if (!frameEnv.hasKey(oldIndex)) {					freshIndex = recipient.allocateLocal(2);					frameEnv.put(oldIndex, freshIndex);				} else {					freshIndex = frameEnv.get(oldIndex);				}				indexed.setIndex(freshIndex);				dest = ret.append(fresh);			} else {				dest = ret.append(fresh);			}			srcToDest.put(src, dest);		}				// second pass: retarget branch instructions, copy ranges and tags		Map tagMap = new HashMap();		Map shadowMap = new HashMap();				for (InstructionHandle dest = ret.getStart(), src = sourceList.getStart(); 				dest != null; 				dest = dest.getNext(), src = src.getNext()) {			Instruction inst = dest.getInstruction();						// retarget branches			if (inst instanceof BranchInstruction) {				BranchInstruction branch = (BranchInstruction) inst;				InstructionHandle oldTarget = branch.getTarget();				InstructionHandle newTarget =					(InstructionHandle) srcToDest.get(oldTarget);				if (newTarget == null) {					// assert this is a GOTO					// this was a return instruction we previously replaced				} else {					branch.setTarget(newTarget);					if (branch instanceof Select) {						Select select = (Select) branch;						InstructionHandle[] oldTargets = select.getTargets();						for (int k = oldTargets.length - 1; k >= 0; k--) {							select.setTarget(								k,								(InstructionHandle) srcToDest.get(oldTargets[k]));						}					}				}			}									//copy over tags and range attributes	        InstructionTargeter[] srcTargeters = src.getTargeters();	        if (srcTargeters != null) { 	            for (int j = srcTargeters.length - 1; j >= 0; j--) {	                InstructionTargeter old = srcTargeters[j];	                if (old instanceof Tag) {	                	Tag oldTag = (Tag) old;	                	Tag fresh = (Tag) tagMap.get(oldTag);	                	if (fresh == null) {	                		fresh = oldTag.copy();	                		tagMap.put(oldTag, fresh);	                	}	                	dest.addTargeter(fresh);	                } else if (old instanceof ExceptionRange) {	                	ExceptionRange er = (ExceptionRange) old;	                	if (er.getStart() == src) {	                		ExceptionRange freshEr =	                			new ExceptionRange(	                				recipient.getBody(),	                				er.getCatchType(),	                				er.getPriority());	                		freshEr.associateWithTargets(								dest,								(InstructionHandle)srcToDest.get(er.getEnd()),								(InstructionHandle)srcToDest.get(er.getHandler()));	                	}					} else if (old instanceof ShadowRange) {						ShadowRange oldRange = (ShadowRange) old;						if (oldRange.getStart() == src) {							BcelShadow oldShadow = oldRange.getShadow();							BcelShadow freshEnclosing =								oldShadow.getEnclosingShadow() == null									? null									: (BcelShadow) shadowMap.get(oldShadow.getEnclosingShadow());							BcelShadow freshShadow =								oldShadow.copyInto(recipient, freshEnclosing);							ShadowRange freshRange = new ShadowRange(recipient.getBody());							freshRange.associateWithShadow(freshShadow);							freshRange.associateWithTargets(								dest,								(InstructionHandle) srcToDest.get(oldRange.getEnd()));							shadowMap.put(oldRange, freshRange);							//recipient.matchedShadows.add(freshShadow);							// XXX should go through the NEW copied shadow and update							// the thisVar, targetVar, and argsVar							// ??? Might want to also go through at this time and add							// "extra" vars to the shadow. 						}					}	            }	        }					}		if (!keepReturns) ret.append(footer);		return ret;	}