if (i == (numNewTraces - 1))
if (input.getWidth() % maxWidth != 0 && i == (numNewTraces - 1))
    private void breakUpJoin(Trace trace, LinkedList<Trace> traces) {        //the old input trace node, it will get replaced!        InputTraceNode input = trace.getHead();        //nothing to do, so return...        if (input.getWidth() <= maxWidth)            return;                CType type = input.getType();                //the number of new input trace nodes (and thus slices needed)...        int numNewTraces = input.getWidth() / maxWidth +             (input.getWidth() % maxWidth > 0 ? 1 : 0);                 //create the new input trace nodes        InputTraceNode[] newInputs = new InputTraceNode[numNewTraces];        for (int i = 0; i < numNewTraces; i++)            newInputs[i] = new InputTraceNode();                 //now assign each of the original edges to one of the new         //input trace nodes        HashMap<Edge, Integer> assignment = new HashMap<Edge, Integer>();        Iterator<Edge> sources = input.getSourceSequence().iterator();        for (int i = 0; i < numNewTraces; i++) {            int count = maxWidth;            if (i == (numNewTraces - 1))                count = input.getWidth() % maxWidth;            for (int j = 0; j < count; j++) {                 Edge edge = sources.next();                //System.out.println("Assignment: " + edge + " " + i);                assignment.put(edge, new Integer(i));            }        }        //make sure there is nothing left to assign        assert !sources.hasNext();                //the weights array of each new inputs trace node        LinkedList<Integer>[] newInputsWeights = new LinkedList[numNewTraces];        //the source array of each new input trace node        LinkedList<Edge>[] newInputsSources = new LinkedList[numNewTraces];        for (int i = 0; i < numNewTraces; i++) {            newInputsWeights[i] = new LinkedList<Integer>();            newInputsSources[i] = new LinkedList<Edge>();         }                    //the weights array of the new input trace node of the orignal trace        LinkedList<Integer> origTraceInputWeights = new LinkedList<Integer>();        //the source array of the new input trace node of the orignal trace        //right now it is just the index of the new trace, because we don't have        //the edges right now        LinkedList<Integer> origTraceInputSources = new LinkedList<Integer>();                for (int i = 0; i < input.getSources().length; i++) {            int index = assignment.get(input.getSources()[i]).intValue();                        newInputsWeights[index].add(new Integer(input.getWeights()[i]));            newInputsSources[index].add(input.getSources()[i]);                        origTraceInputWeights.add(new Integer(input.getWeights()[i]));            origTraceInputSources.add(new Integer(index));        }                //set the weights and sources of the new input trace nodes        for (int i = 0; i < numNewTraces; i++) {            newInputs[i].set(newInputsWeights[i], newInputsSources[i]);            newInputs[i].canonicalize();        }         //ok so now we have all the new input trace nodes, create the new traces        Trace[] newTraces = new Trace[numNewTraces];                        //now we have to create the new input trace node that will replace the        //old one of the original trace        InputTraceNode newInput = new InputTraceNode();                        //we have to fix the edges and create the new traces...        for (int i = 0; i < numNewTraces; i++) {            newTraces[i] = fixEdgesAndCreateTrace(newInputs[i], newInput, type);            //add the new traces to the trace list...            traces.add(newTraces[i]);        }                //now we can create the pattern of source edges from the index list        //we built above        LinkedList<Edge> origTraceInputEdges = new LinkedList<Edge>();        for (int i = 0; i < origTraceInputSources.size(); i++) {            Trace source = newTraces[origTraceInputSources.get(i).intValue()];            origTraceInputEdges.add(source.getTail().getSingleEdge());        }        //set the pattern of the new input trace        newInput.set(origTraceInputWeights, origTraceInputEdges);        newInput.canonicalize();        //now install the new input trace node in the old trace        newInput.setNext(trace.getHead().getNext());        trace.getHead().getNext().setPrevious(newInput);        newInput.setParent(trace);        trace.setHead(newInput);                //set the multiplicities of the new identities of the new traces        setMultiplicitiesJoin(newTraces);    }