while ( subnetworkLts.getLeftTupleSource() != riaNode.getStartTupleSource()) {

                        subnetworkLts = subnetworkLts.getLeftTupleSource();

                    }

                    if ( subNetworkSegmentMemory == null ) {

                        // we need to stop recursion here

                        createSegmentMemory( ( LeftTupleSource ) subnetworkLts, wm );

                    }

    public static void createChildSegments(final InternalWorkingMemory wm,

                                            SegmentMemory smem,

                                            LeftTupleSinkPropagator sinkProp) {

        for ( LeftTupleSinkNode sink = ( LeftTupleSinkNode ) sinkProp.getFirstLeftTupleSink(); sink != null; sink = sink.getNextLeftTupleSinkNode() ) {

             if ( !( NodeTypeEnums.isTerminalNode( sink  ) || sink.getType() == NodeTypeEnums.RightInputAdaterNode ) ) {

                    SegmentUtilities.createSegmentMemory( (LeftTupleSource ) sink, wm );

                }

            } else {

                // RTNS and RiaNode's have their own segment, if they are the child of a split.

                    SegmentMemory childSmem = new SegmentMemory(sink);

                    PathMemory rmem;

                    if ( NodeTypeEnums.isTerminalNode( sink  ) ) {

                        rmem = (PathMemory) memory;

                    } else {

                        rmem =  ((RiaNodeMemory) memory ).getRiaPathMemory();

                    }

                    rmem.getSegmentMemories()[ rmem.getSegmentMemories().length -1 ] = childSmem;

                    rmem.setSegmentMemory( childSmem );

                    childSmem.getPathMemories().add( rmem );

                    childSmem.setTipNode( sink );

                    childSmem.setSinkFactory( sink );

                }

            }

        }

    }

        ((DefaultAgenda)ksession.getAgenda()).getGarbageCollector().forceGcUnlinkedRules();

        NodeMemories nm = ( (StatefulKnowledgeSessionImpl) ksession ).getNodeMemories();

        for ( int j = 0; j < nm.length(); j++ ) {

            if ( mem != null && mem instanceof PathMemory) {

                PathMemory pathMemory = (PathMemory) mem;

                StreamTupleEntryQueue kiu = pathMemory.getStreamQueue();

                System.out.println( kiu + " >> " + kiu.size() );

                assertEquals( 0, kiu.size() );

            List<String[]> cmds = step.getCommands();

            List<InternalFactHandle> handles = (List<InternalFactHandle>) context.get( "Handles" );

            BetaMemory bm;

            if ( node.getType() == NodeTypeEnums.AccumulateNode ) {

                bm =  ((AccumulateMemory) childMemory).getBetaMemory();

            } else {

                bm =  (BetaMemory) childMemory;

            }

        ((DefaultAgenda)ksession.getAgenda()).getGarbageCollector().forceGcUnlinkedRules();

        NodeMemories nm = ( (StatefulKnowledgeSessionImpl) ksession ).getNodeMemories();

        for ( int j = 0; j < nm.length(); j++ ) {

            if ( mem != null && mem instanceof PathMemory) {

                PathMemory pathMemory = (PathMemory) mem;

                StreamTupleEntryQueue kiu = pathMemory.getStreamQueue();

                System.out.println( kiu + " >> " + kiu.size() );

                assertEquals( 0, kiu.size() );

                } else {

                    // rtn or rian

                    // While not technically in a segment, we want to be able to iterate easily from the last node memory to the ria/rtn memory

                    // we don't use createNodeMemory, as these may already have been created by, but not added, by the method updateRiaAndTerminalMemory

                    if (sink.getType() == NodeTypeEnums.RightInputAdaterNode) {

                        PathMemory riaPmem = ((RiaNodeMemory)memory).getRiaPathMemory();

                        smem.getNodeMemories().add( riaPmem );

                        RightInputAdapterNode rian = ( RightInputAdapterNode ) sink;

                        ObjectSink[] nodes = rian.getSinkPropagator().getSinks();

                        for ( ObjectSink node : nodes ) {

                            if ( NodeTypeEnums.isLeftTupleSource(node) )  {

                                SegmentMemory parentSmem = createSegmentMemory( (LeftTupleSource) node, wm );

                            }

                        }

                    } else if (NodeTypeEnums.isTerminalNode(sink)) {

                        smem.getNodeMemories().add((PathMemory)memory);

                    }

                    smem.setTipNode(sink);

                    break;

                }

            } else {

                // not in same segment

            while (subnetworkLts.getLeftTupleSource() != riaNode.getStartTupleSource()) {

                subnetworkLts = subnetworkLts.getLeftTupleSource();

            }

            if (subNetworkSegmentMemory == null) {

                // we need to stop recursion here

                createSegmentMemory((LeftTupleSource) subnetworkLts, wm);

            }

        if ( !smem.isEmpty() ) {

              return; // this can happen when multiple threads are trying to initialize the segment

        }

        for (LeftTupleSinkNode sink = (LeftTupleSinkNode) sinkProp.getFirstLeftTupleSink(); sink != null; sink = sink.getNextLeftTupleSinkNode()) {

            SegmentMemory childSmem = createChildSegment(wm, sink, memory);

            smem.add(childSmem);

        }

    }

        NodeMemories memories = wm.getNodeMemories();

        // only some of the node memories require special serialization handling

        // so we iterate over all of them and process only those that require it

        for ( int i = 0; i < memories.length(); i++ ) {

            // some nodes have no memory, so we need to check for nulls

            if ( memory != null ) {

                ProtobufMessages.NodeMemory _node = null;

                    case NodeTypeEnums.AccumulateNode : {

                        _node = writeAccumulateNodeMemory( i, memory );

                        break;

                    }

                    case NodeTypeEnums.RightInputAdaterNode : {

        ObjectSink[] sinks = riaNode.getSinkPropagator().getSinks();

        BetaNode betaNode = (BetaNode) sinks[0];

        if ( betaMemory == null ) {

            return null;

        }

        BetaMemory bm;

        if ( betaNode.getType() == NodeTypeEnums.AccumulateNode ) {