smem.segmentPosMaskBit = segmentPosMaskBit;

            smem.pos = pos;

            int i = 0;

            for (NetworkNode node : getNodesInSegment(smem)) {

                smem.getNodeMemories().add(mem);

                MemoryPrototype proto = memories.get(i++);

                if (proto != null) {

                    proto.populateMemory(wm, mem);

                }

        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 ) {

                    } 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);

            }

        }

        LinkedList<StackEntry> stack = new LinkedList<StackEntry>();

        NetworkNode node;

        long bit = 1;

        if (liaNode == smem.getTipNode()) {

            // segment only has liaNode in it

            // nothing is staged in the liaNode, so skip to next segment

            smem = smems[++smemIndex]; // 1

    }

    public void evalStackEntry(StackEntry entry, LinkedList<StackEntry> stack, LinkedList<StackEntry> outerStack, RuleExecutor executor, InternalWorkingMemory wm) {

        NetworkNode node = entry.getNode();

        LeftTupleSets trgTuples = entry.getTrgTuples();

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

            // copy across the results, if any from the query node memory

            QueryElementNodeMemory qmem = (QueryElementNodeMemory) nodeMem;

            qmem.setNodeCleanWithoutNotify();

            trgTuples.addAll(qmem.getResultLeftTuples());

        }

        LeftTupleSinkNode sink = entry.getSink();

        PathMemory pmem = entry.getRmem();

        SegmentMemory[] smems = entry.getSmems();

        int smemIndex = entry.getSmemIndex();

        Set<String> visitedRules = entry.getVisitedRules();

        boolean processRian = entry.isProcessRian();

        long bit = entry.getBit();

        if (entry.isResumeFromNextNode()) {

            SegmentMemory smem = smems[smemIndex];

            if (node != smem.getTipNode()) {

                // get next node and node memory in the segment

                LeftTupleSink nextSink = sink.getNextLeftTupleSinkNode();

                if (nextSink == null) {

                    node = sink;

                } else {

                    // there is a nested subnetwork, take out path

                    node = nextSink;

                }

                bit = bit << 1; // update bit to new node

            } else {

                // Reached end of segment, start on new segment.

                SegmentPropagator.propagate(smem,

                                            trgTuples,

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

        BetaNode betaNode = (BetaNode) sinks[0];

        BetaMemory bm;

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

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

        } else {

            bm = (BetaMemory) nodeMem;

        }

        // Build up iteration array for other sinks

        BetaNode[] bns = null;

        BetaMemory[] bms = null;

        int length = sinks.length;

        if (length > 1) {

            bns = new BetaNode[sinks.length - 1];

            bms = new BetaMemory[sinks.length - 1];

            for (int i = 1; i < length; i++) {

                bns[i - 1] = (BetaNode) sinks[i];

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

                    bms[i - 1] = ((AccumulateMemory) nodeMem2).getBetaMemory();

                } else {

                    bms[i - 1] = (BetaMemory) nodeMem2;

                }

         int smemIndex = getSegmentPos(splitStartNode, null); // index before the segments are merged

         SegmentMemory[] smems = pmem.getSegmentMemories();

         SegmentMemory sm;

         LeftTupleSink sink;

         long bit = 1;

         if ( smems.length == 1 ) {

             // there is no sharing

             sm = smems[0];

             if ( sm == null ) {