         {
             if fullRandomize
             {
-                blackHolesRandomizations(ctx, randomize1: randomize1, randomize2: randomize2, randomize3: randomize3, randomize4: randomize4)
-            }
-            
-            CGContextRotateCTM(ctx, angle)
-            CGContextBeginPath(ctx)
-            CGContextMoveToPoint(ctx, startPoint.x, startPoint.y)
-            CGContextAddLineToPoint(ctx, endPoint.x, endPoint.y)
+                blackHolesRandomizations(ctx: ctx, randomize1: randomize1, randomize2: randomize2, randomize3: randomize3, randomize4: randomize4)
+            }
+            
+            ctx.rotate(by: angle)
+            ctx.beginPath()
+            ctx.move(to: startPoint)
+            ctx.addLine(to: endPoint)
             
             if drawFillStroke
             {
-                CGContextDrawPath(ctx, CGPathDrawingMode.FillStroke)
-            }
-            else
-            {
-                CGContextStrokePath(ctx)
+                ctx.drawPath(using: .fillStroke)
+            }
+            else
+            {
+                ctx.strokePath()
             }
             
             start += angle

            if Helper.fiftyFifty()
            {
                // NOTE: Squares rotated!
                let angleRotate:CGFloat = (2.0 * CGFloat(M_PI)) / CGFloat(holes.count)
                let centerBack = CGPointMake(BackRect.midX, BackRect.midY)
                
                CGContextSaveGState(ctx)
                CGContextTranslateCTM(ctx, centerBack.x, centerBack.y)
                
                for h in holes
                {
                    blackHolesRandomizations(ctx, randomize1: randomize1, randomize2: randomize2, randomize3: randomize3, randomize4: randomize4)
                    
                    let r = CGRectMake(h.minX - centerBack.x, h.minY - centerBack.y, h.width, h.height)
                    CGContextFillRect(ctx, r)
                    CGContextStrokeRect(ctx, r)
                    CGContextRotateCTM(ctx, angleRotate)
                }
                
                CGContextRestoreGState(ctx)
            }
            else
            {
                for h in holes
                {
                    blackHolesRandomizations(ctx, randomize1: randomize1, randomize2: randomize2, randomize3: randomize3, randomize4: randomize4)
                    
                    CGContextFillRect(ctx, h)
                    CGContextStrokeRect(ctx, h)
                }
            }
        }
    }
    
    private func drawBlackHole(ctx:CGContextRef)
    {
        let angle:CGFloat = CGFloat((M_PI * 2.0)) / CGFloat(Helper.randomBetween(FactorBlackHoleMin, max: FactorBlackHoleMax, includeMax: false))
        let randomize = Helper.fiftyFifty()
        let randomize2 = Helper.fiftyFifty()
        
        if Helper.fiftyFifty()
        {
            setRandomStroke(ctx)
        }
        else
        {
            setRandomStroke2(ctx)
        }
        setRandomLineWidth(ctx)
        
        let centerBack = CGPointMake(BackRect.midX, BackRect.midY)
        let howLong:CGFloat = CGFloat(M_PI) * 2.0
        var start:CGFloat = 0.0
        
        CGContextSaveGState(ctx)
        CGContextTranslateCTM(ctx, centerBack.x, centerBack.y)
        
        let startPoint = CGPointMake(BackRect.minX - centerBack.x, BackRect.minY - centerBack.y)
        let endPoint = CGPointMake(BackRect.maxX - centerBack.x, BackRect.maxY - centerBack.y)
        
        while start <= howLong
        {
            if randomize
            {
                setRandomShadow(ctx)
            }
            
            if randomize2
            {
                setRandomLineWidth(ctx)
            }
            
            CGContextRotateCTM(ctx, angle)
            CGContextBeginPath(ctx)
            CGContextMoveToPoint(ctx, startPoint.x, startPoint.y)
            CGContextAddLineToPoint(ctx, endPoint.x, endPoint.y)
            CGContextStrokePath(ctx)
            start += angle
        }
        CGContextRestoreGState(ctx)
    }
    
    // NOTE: First layer variant
    private func drawFirstLayerVariant(ctx:CGContextRef)
    {
        let angle:CGFloat = CGFloat((M_PI * 2.0)) / CGFloat(Helper.randomBetween(FactorLinesAnglesMin, max: FactorLinesAnglesMax, includeMax: false))
        let randomize = Helper.fiftyFifty()
        let randomize2 = Helper.fiftyFifty()
        
        if Helper.fiftyFifty()
        {
            setRandomStroke(ctx)
        }
        else
        {
            setRandomStroke2(ctx)
        }
        setRandomLineWidth(ctx)
        
        let centerBack = CGPointMake(BackRect.midX, BackRect.midY)
        let howLong:CGFloat = CGFloat(M_PI) * 2.0
        var start:CGFloat = 0.0
        
        CGContextSaveGState(ctx)
        CGContextTranslateCTM(ctx, centerBack.x, centerBack.y)
        
        let startPoint = CGPointMake(BackRect.minX - centerBack.x, BackRect.minY - centerBack.y)
        let endPoint = CGPointMake(BackRect.maxX - centerBack.x, BackRect.maxY - centerBack.y)
        
        while start <= howLong
        {
            if randomize
            {
                setRandomShadow(ctx)
            }
            
            if randomize2
            {
                setRandomLineWidth(ctx)
            }
            
            CGContextRotateCTM(ctx, angle)
            CGContextBeginPath(ctx)
            CGContextMoveToPoint(ctx, startPoint.x, startPoint.y)
            CGContextAddLineToPoint(ctx, endPoint.x, endPoint.y)
            CGContextStrokePath(ctx)
            start += angle
        }
        
        CGContextRestoreGState(ctx)
    }
    
    private func drawCirclesOrSquaresOverlay(ctx:CGContextRef)
    {
        let circles = Helper.fiftyFifty()
        
        for _ in 0..<Helper.randomBetween(1, max: FactorInsidersOverlays, includeMax: true)
        {
            if Helper.fiftyFifty()
            {
                setRandomStroke(ctx)
            }
            else
            {
                setRandomStroke2(ctx)
            }
            
            setRandomLineWidth(ctx)
            setRandomFill(ctx)
            let inset:CGFloat = (BackRect.width / 2.1) - (Helper.random01CGFloat() * (BackRect.width / 5.0))
            
            let r = CGRectInset(BackRect, inset, inset)
            
            if circles
            {
                CGContextFillEllipseInRect(ctx, r)
                CGContextStrokeEllipseInRect(ctx, r)
            }
            else
            {
                CGContextFillRect(ctx, r)
                CGContextStrokeRect(ctx, r)
            }
        }
    }
    
    private func drawFullRectLayer(ctx:CGContextRef)
    {
        setRandomFill(ctx)
        CGContextFillRect(ctx, BackRect)
    }
    
    private func drawSpace(ctx:CGContextRef)
    {
        let angle:CGFloat = CGFloat((M_PI * 2.0)) / CGFloat(Helper.randomBetween(FactorBlackHoleMin2, max: FactorBlackHoleMax2, includeMax: false))
        
        if Helper.fiftyFifty()
        {
            setRandomStroke(ctx)
        }
        else
        {
            setRandomStroke2(ctx)
        }
        
        setRandomFillLighter(ctx)
        setRandomLineWidth(ctx)
        
        let centerBack = CGPointMake(BackRect.midX, BackRect.midY)
        let howLong:CGFloat = CGFloat(M_PI) * 2.0
        var start:CGFloat = 0.0
        
        CGContextSaveGState(ctx)
        CGContextTranslateCTM(ctx, centerBack.x, centerBack.y)
        
        let startPoint = CGPointMake(BackRect.minX - centerBack.x, BackRect.minY - centerBack.y)
        let endPoint = CGPointMake(BackRect.maxX - centerBack.x, BackRect.maxY - centerBack.y)
        let controlPointX:CGFloat = BackRect.minX + (Helper.random01CGFloat() * BackRect.width)
        let controlPointY:CGFloat = BackRect.minY + (Helper.random01CGFloat() * BackRect.height)
        let controlPoint = CGPointMake(controlPointX - centerBack.x, controlPointY - centerBack.y)
        
        var drawFillStroke = Helper.fiftyFifty()
        var fullRandomize = Helper.fiftyFifty()

            {
                for h in holes
                {
                    blackHolesRandomizations(ctx: ctx, randomize1: randomize1, randomize2: randomize2, randomize3: randomize3, randomize4: randomize4)
                    
                    ctx.saveGState()
                    ctx.translateBy(x: getPossibleBlackHoleOffsetForTranslate(), y: getPossibleBlackHoleOffsetForTranslate())
                    ctx.fillEllipse(in: h)
                    ctx.strokeEllipse(in: h)
                    ctx.restoreGState()
                }
                
            }
