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

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

            Memory mem = nm.peekNodeMemory( j );

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

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

                assertEquals( 0, kiu.size() );

            }

        }

    }

        }

        List<PathMemory> pmems =  lmem.getSegmentMemory().getPathMemories();

        for ( int i = 0, length = pmems.size(); i < length; i++ ) {

            evaluator.getRuleExecutor().setDirty(true);

            evaluator.getRuleExecutor().evaluateNetworkAndFire(this, null, 0, -1);

        }

        return tnodes;

            LeftInputAdapterNode.doDeleteObject( childLeftTuple, childLeftTuple.getPropagationContext(),  lsmem, this, lian, false, lmem );

            List<PathMemory> pmems =  lmem.getSegmentMemory().getPathMemories();

            for ( int i = 0, length = pmems.size(); i < length; i++ ) {

                evaluator.getRuleExecutor().setDirty(true);

                evaluator.getRuleExecutor().evaluateNetworkAndFire(this, null, 0, -1);

            }

            getFactHandleFactory().destroyFactHandle( factHandle );

                    // 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

                    Memory memory = wm.getNodeMemory((MemoryFactory) sink);

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

                        smem.getNodeMemories().add( riaPmem );

                        RightInputAdapterNode rian = ( RightInputAdapterNode ) sink;

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

                        for ( ObjectSink node : nodes ) {

                    // If LiaNode is in it's own segment, then the segment first after that must use SynchronizedLeftTupleSets

                    childSmem.setStagedTuples( new SynchronizedLeftTupleSets() );

                }

                if (NodeTypeEnums.isTerminalNode(sink)) {

                    pmem = (PathMemory) memory;

                } else {

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

                }

                childSmem.getPathMemories().add(pmem);

                childSmem.setTipNode(sink);

                childSmem.setSinkFactory(sink);

            }

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

                // Only add the RIANode, if the LeftTupleSource is part of the RIANode subnetwork.

                if (inSubNetwork((RightInputAdapterNode) sink, originalLt)) {

                    RiaNodeMemory riaMem = (RiaNodeMemory) wm.getNodeMemory((MemoryFactory) sink);

                    smem.getPathMemories().add(pmem);

                    if (fromPrototype) {

                        ObjectSink[] nodes = ((RightInputAdapterNode) sink).getSinkPropagator().getSinks();

                        for ( ObjectSink node : nodes ) {

                            // check if the SegmentMemory has been already created by the BetaNode and if so avoid to build it twice

                            if ( NodeTypeEnums.isLeftTupleSource(node) && wm.getNodeMemory((MemoryFactory) node).getSegmentMemory() == null )  {

                                restoreSegmentFromPrototype(wm, (LeftTupleSource) node, nodeTypesInSegment);

                            }

                        }

                        // must eagerly initialize child segment memories

                        ObjectSink[] nodes = ((RightInputAdapterNode) sink).getSinkPropagator().getSinks();

                        for ( ObjectSink node : nodes ) {

                            if ( NodeTypeEnums.isLeftTupleSource(node) )  {

                                createSegmentMemory( (LeftTupleSource) node, wm );

                            }

                        }

                    }

                }

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

                smem.getPathMemories().add(pmem);

                if (smem.isSegmentLinked()) {

                    // not's can cause segments to be linked, and the rules need to be notified for evaluation

                    smem.notifyRuleLinkSegment(wm);

                }

                checkEagerSegmentCreation(((TerminalNode) sink).getLeftTupleSource(), wm, nodeTypesInSegment);

                // iterate the first child sink, we only need the first, as all reach the same outer rtn

                queue = initAndGetTupleQueue((LeftTupleSource) nodes[0], wm);

            }

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

            if ( queue == null ) {

            }

        }

        return queue;

    }

        public void execute(JobContext ctx) {

            final TimerNodeJobContext timerJobCtx = (TimerNodeJobContext) ctx;

            Trigger trigger = timerJobCtx.getTrigger();

            LeftTupleList leftTuples = timerJobCtx.getTimerNodeMemory().getInsertOrUpdateLeftTuples();

            LeftTuple lt = timerJobCtx.getLeftTuple();

            if ( log.isTraceEnabled() ) {

                log.trace( "Timer Executor {} {}", timerJobCtx.getTrigger(), lt );

            }

            synchronized ( leftTuples ) {

                if ( timerJobCtx.getJobHandle().isCancel() ) {

                    // this is to force a sync point, as during update propagate it can cancel the FH

                    // we cannot have an update processed at the same timer is firing

                    return;

                }

                if ( lt.getMemory() == null ) {

                    // don't add it, if it's already added, which could happen with interval or cron timers

                    leftTuples.add( lt );

                }

            }

            timerJobCtx.getTimerNodeMemory().setNodeDirtyWithoutNotify();

            final TimedRuleExecutionFilter filter = timerJobCtx.getWorkingMemory().getSessionConfiguration().getTimedRuleExecutionFilter();

            if (filter != null) {

                ExecutorHolder.executor.execute( new Runnable() {

                    @Override

                    public void run() {

                            new Executor(pmem,

                                         timerJobCtx.getWorkingMemory(),

                                         timerJobCtx.getSink(),

                                         timerJobCtx.getTimerNodeMemory()).evauateAndFireRule();

                        }

            trgTuples.addAll(((QueryElementNodeMemory) nodeMem).getResultLeftTuples());

        }

        LeftTupleSinkNode sink = entry.getSink();

        SegmentMemory[] smems = entry.getSmems();

        int smemIndex = entry.getSmemIndex();

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

        boolean processRian;

            List<PathMemory> qpmems = qsmem.getPathMemories();

            // Build the evaluation information for each 'or' branch

            for (int i = 0; i < qpmems.size() ; i++) {

                pmem = qpmem;

                smemIndex = 0;

                SegmentMemory smem = smems[smemIndex]; // 0

                liaNode = (LeftInputAdapterNode) smem.getRootNode();

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