diff --git a/Source/Charts/Renderers/BarLineScatterCandleBubbleRenderer.swift b/Source/Charts/Renderers/BarLineScatterCandleBubbleRenderer.swift
index 796c757290..5ff9a87305 100644
--- a/Source/Charts/Renderers/BarLineScatterCandleBubbleRenderer.swift
+++ b/Source/Charts/Renderers/BarLineScatterCandleBubbleRenderer.swift
@@ -26,15 +26,7 @@ open class BarLineScatterCandleBubbleRenderer: DataRenderer
     @objc internal func isInBoundsX(entry e: ChartDataEntry, dataSet: IBarLineScatterCandleBubbleChartDataSet) -> Bool
     {
         let entryIndex = dataSet.entryIndex(entry: e)
-        
-        if Double(entryIndex) >= Double(dataSet.entryCount) * (animator?.phaseX ?? 1.0)
-        {
-            return false
-        }
-        else
-        {
-            return true
-        }
+        return Double(entryIndex) < Double(dataSet.entryCount) * (animator?.phaseX ?? 1.0)
     }
 
     /// Calculates and returns the x-bounds for the given DataSet in terms of index in their values array.
@@ -94,5 +86,4 @@ open class BarLineScatterCandleBubbleRenderer: DataRenderer
             range = Int(Double(self.max - self.min) * phaseX)
         }
     }
-
 }
diff --git a/Source/Charts/Renderers/BubbleChartRenderer.swift b/Source/Charts/Renderers/BubbleChartRenderer.swift
index 4f4265db3b..d77311c459 100644
--- a/Source/Charts/Renderers/BubbleChartRenderer.swift
+++ b/Source/Charts/Renderers/BubbleChartRenderer.swift
@@ -35,12 +35,9 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
             let bubbleData = dataProvider.bubbleData
             else { return }
         
-        for set in bubbleData.dataSets as! [IBubbleChartDataSet]
+        for set in bubbleData.dataSets as! [IBubbleChartDataSet] where set.isVisible
         {
-            if set.isVisible
-            {
-                drawDataSet(context: context, dataSet: set)
-            }
+            drawDataSet(context: context, dataSet: set)
         }
     }
     
@@ -84,6 +81,7 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
         trans.pointValuesToPixel(&_sizeBuffer)
         
         context.saveGState()
+        defer { context.restoreGState() }
         
         let normalizeSize = dataSet.isNormalizeSizeEnabled
         
@@ -103,21 +101,13 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
             let shapeSize = getShapeSize(entrySize: entry.size, maxSize: dataSet.maxSize, reference: referenceSize, normalizeSize: normalizeSize)
             let shapeHalf = shapeSize / 2.0
             
-            if !viewPortHandler.isInBoundsTop(_pointBuffer.y + shapeHalf)
-                || !viewPortHandler.isInBoundsBottom(_pointBuffer.y - shapeHalf)
-            {
-                continue
-            }
-            
-            if !viewPortHandler.isInBoundsLeft(_pointBuffer.x + shapeHalf)
-            {
-                continue
-            }
-            
-            if !viewPortHandler.isInBoundsRight(_pointBuffer.x - shapeHalf)
-            {
-                break
-            }
+            guard
+                viewPortHandler.isInBoundsTop(_pointBuffer.y + shapeHalf),
+                viewPortHandler.isInBoundsBottom(_pointBuffer.y - shapeHalf),
+                viewPortHandler.isInBoundsLeft(_pointBuffer.x + shapeHalf)
+                else { continue }
+
+            guard viewPortHandler.isInBoundsRight(_pointBuffer.x - shapeHalf) else { break }
             
             let color = dataSet.color(atIndex: Int(entry.x))
             
@@ -131,100 +121,88 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
             context.setFillColor(color.cgColor)
             context.fillEllipse(in: rect)
         }
-        
-        context.restoreGState()
     }
     
     open override func drawValues(context: CGContext)
     {
-        guard let
-            dataProvider = dataProvider,
+        guard
+            let dataProvider = dataProvider,
             let viewPortHandler = self.viewPortHandler,
             let bubbleData = dataProvider.bubbleData,
-            let animator = animator
+            let animator = animator,
+            isDrawingValuesAllowed(dataProvider: dataProvider),
+            let dataSets = bubbleData.dataSets as? [IBubbleChartDataSet]
             else { return }
-        
-        // if values are drawn
-        if isDrawingValuesAllowed(dataProvider: dataProvider)
+
+        let phaseX = max(0.0, min(1.0, animator.phaseX))
+        let phaseY = animator.phaseY
+
+        var pt = CGPoint()
+
+        for i in 0..<dataSets.count
         {
-            guard let dataSets = bubbleData.dataSets as? [IBubbleChartDataSet] else { return }
-            
-            let phaseX = max(0.0, min(1.0, animator.phaseX))
-            let phaseY = animator.phaseY
-            
-            var pt = CGPoint()
-            
-            for i in 0..<dataSets.count
+            let dataSet = dataSets[i]
+
+            guard
+                shouldDrawValues(forDataSet: dataSet),
+                let formatter = dataSet.valueFormatter
+                else { continue }
+
+            let alpha = phaseX == 1 ? phaseY : phaseX
+
+            _xBounds.set(chart: dataProvider, dataSet: dataSet, animator: animator)
+
+            let trans = dataProvider.getTransformer(forAxis: dataSet.axisDependency)
+            let valueToPixelMatrix = trans.valueToPixelMatrix
+
+            let iconsOffset = dataSet.iconsOffset
+
+            for j in _xBounds.min..._xBounds.range + _xBounds.min
             {
-                let dataSet = dataSets[i]
-                
-                if !shouldDrawValues(forDataSet: dataSet)
+                guard let e = dataSet.entryForIndex(j) as? BubbleChartDataEntry else { break }
+
+                let valueTextColor = dataSet.valueTextColorAt(j).withAlphaComponent(CGFloat(alpha))
+
+                pt.x = CGFloat(e.x)
+                pt.y = CGFloat(e.y * phaseY)
+                pt = pt.applying(valueToPixelMatrix)
+
+                guard viewPortHandler.isInBoundsRight(pt.x) else { break }
+
+                guard
+                    viewPortHandler.isInBoundsLeft(pt.x),
+                    viewPortHandler.isInBoundsY(pt.y)
+                    else { continue }
+
+                let text = formatter.stringForValue(
+                    Double(e.size),
+                    entry: e,
+                    dataSetIndex: i,
+                    viewPortHandler: viewPortHandler)
+
+                // Larger font for larger bubbles?
+                let valueFont = dataSet.valueFont
+                let lineHeight = valueFont.lineHeight
+
+                if dataSet.isDrawValuesEnabled
                 {
-                    continue
+                    ChartUtils.drawText(
+                        context: context,
+                        text: text,
+                        point: CGPoint(
+                            x: pt.x,
+                            y: pt.y - (0.5 * lineHeight)),
+                        align: .center,
+                        attributes: [NSAttributedStringKey.font: valueFont, NSAttributedStringKey.foregroundColor: valueTextColor])
                 }
-                
-                let alpha = phaseX == 1 ? phaseY : phaseX
-                
-                guard let formatter = dataSet.valueFormatter else { continue }
-                
-                _xBounds.set(chart: dataProvider, dataSet: dataSet, animator: animator)
-                
-                let trans = dataProvider.getTransformer(forAxis: dataSet.axisDependency)
-                let valueToPixelMatrix = trans.valueToPixelMatrix
-                
-                let iconsOffset = dataSet.iconsOffset
-                
-                for j in stride(from: _xBounds.min, through: _xBounds.range + _xBounds.min, by: 1)
-                {
-                    guard let e = dataSet.entryForIndex(j) as? BubbleChartDataEntry else { break }
-                    
-                    let valueTextColor = dataSet.valueTextColorAt(j).withAlphaComponent(CGFloat(alpha))
-                    
-                    pt.x = CGFloat(e.x)
-                    pt.y = CGFloat(e.y * phaseY)
-                    pt = pt.applying(valueToPixelMatrix)
-                    
-                    if (!viewPortHandler.isInBoundsRight(pt.x))
-                    {
-                        break
-                    }
-                    
-                    if ((!viewPortHandler.isInBoundsLeft(pt.x) || !viewPortHandler.isInBoundsY(pt.y)))
-                    {
-                        continue
-                    }
-                    
-                    let text = formatter.stringForValue(
-                        Double(e.size),
-                        entry: e,
-                        dataSetIndex: i,
-                        viewPortHandler: viewPortHandler)
-                    
-                    // Larger font for larger bubbles?
-                    let valueFont = dataSet.valueFont
-                    let lineHeight = valueFont.lineHeight
 
-                    if dataSet.isDrawValuesEnabled
-                    {
-                        ChartUtils.drawText(
-                            context: context,
-                            text: text,
-                            point: CGPoint(
-                                x: pt.x,
-                                y: pt.y - (0.5 * lineHeight)),
-                            align: .center,
-                            attributes: [NSAttributedStringKey.font: valueFont, NSAttributedStringKey.foregroundColor: valueTextColor])
-                    }
-                    
-                    if let icon = e.icon, dataSet.isDrawIconsEnabled
-                    {
-                         ChartUtils.drawImage(context: context,
-                                              image: icon,
-                                              x: pt.x + iconsOffset.x,
-                                              y: pt.y + iconsOffset.y,
-                                              size: icon.size)
-                    }
-                    
+                if let icon = e.icon, dataSet.isDrawIconsEnabled
+                {
+                    ChartUtils.drawImage(context: context,
+                                         image: icon,
+                                         x: pt.x + iconsOffset.x,
+                                         y: pt.y + iconsOffset.y,
+                                         size: icon.size)
                 }
             }
         }
@@ -237,28 +215,27 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
     
     open override func drawHighlighted(context: CGContext, indices: [Highlight])
     {
-        guard let
-            dataProvider = dataProvider,
+        guard
+            let dataProvider = dataProvider,
             let viewPortHandler = self.viewPortHandler,
             let bubbleData = dataProvider.bubbleData,
             let animator = animator
             else { return }
         
         context.saveGState()
-        
+        defer { context.restoreGState() }
+
         let phaseY = animator.phaseY
         
         for high in indices
         {
             guard
                 let dataSet = bubbleData.getDataSetByIndex(high.dataSetIndex) as? IBubbleChartDataSet,
-                dataSet.isHighlightEnabled
+                dataSet.isHighlightEnabled,
+                let entry = dataSet.entryForXValue(high.x, closestToY: high.y) as? BubbleChartDataEntry,
+                isInBoundsX(entry: entry, dataSet: dataSet)
                 else { continue }
-                        
-            guard let entry = dataSet.entryForXValue(high.x, closestToY: high.y) as? BubbleChartDataEntry else { continue }
-            
-            if !isInBoundsX(entry: entry, dataSet: dataSet) { continue }
-            
+
             let trans = dataProvider.getTransformer(forAxis: dataSet.axisDependency)
             
             _sizeBuffer[0].x = 0.0
@@ -282,22 +259,14 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
             let shapeSize = getShapeSize(entrySize: entry.size, maxSize: dataSet.maxSize, reference: referenceSize, normalizeSize: normalizeSize)
             let shapeHalf = shapeSize / 2.0
             
-            if !viewPortHandler.isInBoundsTop(_pointBuffer.y + shapeHalf) ||
-                !viewPortHandler.isInBoundsBottom(_pointBuffer.y - shapeHalf)
-            {
-                continue
-            }
-            
-            if !viewPortHandler.isInBoundsLeft(_pointBuffer.x + shapeHalf)
-            {
-                continue
-            }
-            
-            if !viewPortHandler.isInBoundsRight(_pointBuffer.x - shapeHalf)
-            {
-                break
-            }
-            
+            guard
+                viewPortHandler.isInBoundsTop(_pointBuffer.y + shapeHalf),
+                viewPortHandler.isInBoundsBottom(_pointBuffer.y - shapeHalf),
+                viewPortHandler.isInBoundsLeft(_pointBuffer.x + shapeHalf)
+            else { continue }
+
+            guard viewPortHandler.isInBoundsRight(_pointBuffer.x - shapeHalf) else { break }
+
             let originalColor = dataSet.color(atIndex: Int(entry.x))
             
             var h: CGFloat = 0.0
@@ -320,7 +289,5 @@ open class BubbleChartRenderer: BarLineScatterCandleBubbleRenderer
             
             high.setDraw(x: _pointBuffer.x, y: _pointBuffer.y)
         }
-        
-        context.restoreGState()
     }
 }