             if (virtualRendererIndices.indexOf(index) == -1)
                 virtualRendererIndices.push(index);
             
-            var createdIR:Boolean = false;
             const item:Object = dataProvider.getItemAt(index);
             
+            addedVirtualRenderer = false;  // set by createVirtualRendererForItem()
             if (!elt)
             {
-                if (isRecyclingOK() && (freeRenderers.length > 0))
-                {
-                    elt = freeRenderers.pop();
-                    elt.visible = true;
-                    elt.includeInLayout = true;
-                }
-                else 
-                {
-                    elt = createRendererForItem(item);
-                    createdIR = true;
-                }
-                
+                elt = createVirtualRendererForItem(item);
+                elt.visible = true;
+                elt.includeInLayout = true;
                 indexToRenderer[index] = elt;
-
                 addItemRendererToDisplayList(DisplayObject(elt)); 
                 setUpItemRenderer(elt, index, item);
             }

    
    /**
     *  @private
     * 
     *  Currently, item renderers ("IRs") can only be recycled if they're all
     *  of the same type, they implement IDataRenderer, and they're all
     *  produced - by the itemRenderer factory - with the same initial
     *  configuration.  We can't ever really guarantee this however the case
     *  for which we're assuming that it's true is when just the itemRenderer
     *  is specified.  Even in this case, for recycling to work the
     *  itemRenderer (factory) must be essentially stateless, the IRs
     *  appearance must be based exclusively on its data.  For this reason
     *  we're also defeating recycling of IRs that don't implement
     *  IDataRenderer, see endVirtualLayout().  Although one could recycle
     *  these IRs, doing so would imply that either all of the IRs were
     *  the same, or that some did implement IDataRenderer and others
     *  did not.   We can't handle the latter, and a DataGroup where
     *  all items are the same wouldn't be worth the trouble.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 10
     *  @playerversion AIR 1.5
     *  @productversion Flex 4
     */
    override public function getVirtualElementAt(index:int, eltWidth:Number=NaN, eltHeight:Number=NaN):IVisualElement
    {

    private static const LAYERING_ENABLED:uint =    0x1;
    private static const LAYERING_DIRTY:uint =      0x2;
    
    /**
     *  @private
     *  The following variables are used to track free virtual item renderers.
     *  When an item renderer is created an entry is added to rendererToFactoryMap
     *  so when it's time to move the renderer to the freeRendererMap "free list",
     *  we can store it with the other renderers produced by the same factory (IFactory).
     *  The value of rendererToFactoryMap[renderer] is a factory, the value of 
     *  freeRendererMap[factory] is the vector of free renderers produced by factory.
     */
    private var rendererToFactoryMap:Dictionary = new Dictionary(true);
    private var freeRendererMap:Dictionary = new Dictionary();
    private var addedVirtualRenderer:Boolean = false;  // see createVirtualRendererForItem()
    
    //--------------------------------------------------------------------------
    //
    //  Overridden properties
