         // 3) If the element causes a column to expand, update the column width to match.
         if (span == 1)
         {
-           // a) For the single spanning case, we only need to check if this element's 
-           //    required width is larger than the column's current width.
+            // a) For the single spanning case, we only need to check if this element's 
+            //    required width is larger than the column's current width.
             col = _constraintColumns[leftIndex];
             
             if (col.contentSize || !isNaN(col.percentWidth))

    }
    
    /**
     *  @private
     *  Adjusts the widths of percent size columns to fill the constrainedWidth.
     *  This method updates the provided column widths vector in place.
     *  
     *  The percent size column widths are first reset to their minimum width. 
     *  If the given column widths from the content and fixed size columns already
     *  fill the available width, then the percent size column widths stay at their
     *  minimum width. Otherwise, the remaining width is distributed to the percent 
     *  size columns based on the ratio of the percentWidth to the sum of all the 
     *  percent widths.
     */
    private function constrainPercentColumnWidths(colWidths:Vector.<Number>, constrainedWidth:Number):void
    {
        var col:ConstraintColumn;
        var numCols:int = _constraintColumns.length;
        var childInfoArray:Array /* of ConstraintRegionFlexChildInfo */ = [];
        var childInfo:ConstraintRegionFlexChildInfo;
        var remainingWidth:Number = constrainedWidth;
        var percentMinWidths:Number = 0;
        var totalPercent:Number = 0;
        
        // Set percent width columns back to minWidth and
        // find the remaining width.
        for (var i:int = 0; i < numCols; i++)
        {
            col = _constraintColumns[i];
            if (!isNaN(col.percentWidth))
            {
                colWidths[i] = (!isNaN(col.minWidth)) ? Math.ceil(Math.max(col.minWidth, 0)) : 0;
                percentMinWidths += colWidths[i];
                totalPercent += col.percentWidth;
                
                // Fill childInfoArray for distributing the width.
                childInfo = new ConstraintRegionFlexChildInfo();
                childInfo.index = i;
                childInfo.percent = col.percentWidth;
                childInfo.min = col.minWidth;
                childInfo.max = col.maxWidth;
                childInfoArray.push(childInfo);
            }
            else
            {
                remainingWidth -= colWidths[i];
            }
        }
        
        // If there's space remaining, distribute the width to the percent size
        // columns based on their ratio of percentWidth to sum of all the percentWidths.
        if (remainingWidth > percentMinWidths)
        {            
            Flex.flexChildrenProportionally(constrainedWidth, 
                                            remainingWidth,
                                            totalPercent,
                                            childInfoArray);
            

        var numRows:Number = _constraintRows.length;
        var row:ConstraintRow;
        var hasContentSize:Boolean = false;
        var hasPercentSize:Boolean = false;
        var rowHeights:Vector.<Number> = new Vector.<Number>();
        
        // Reset content size rows to 0.
        for (i = 0; i < numRows; i++)
        {
            row = _constraintRows[i];
            
            if (row.contentSize || !isNaN(row.percentHeight))
            {
                hasContentSize ||= row.contentSize;
                hasPercentSize ||= !isNaN(row.percentHeight);
                
                if (!isNaN(row.minHeight))
                    rowHeights[i] = Math.ceil(Math.max(row.minHeight, 0));
