             guard Utils.pairiteration(cc1.left, cc2.right, cc1lb, cc2rb, &results, accuracy, &totalIterations) else { return false }
             guard Utils.pairiteration(cc1.right, cc2.left, cc1rb, cc2lb, &results, accuracy, &totalIterations) else { return false }
             guard Utils.pairiteration(cc1.right, cc2.right, cc1rb, cc2rb, &results, accuracy, &totalIterations) else { return false }
-        } else if let cc1 = cc1 {
+        } else if cc1.shouldRecurse {
             let cc1lb = cc1.left.curve.boundingBox
             let cc1rb = cc1.right.curve.boundingBox
             guard Utils.pairiteration(cc1.left, c2, cc1lb, c2b, &results, accuracy, &totalIterations) else { return false }
             guard Utils.pairiteration(cc1.right, c2, cc1rb, c2b, &results, accuracy, &totalIterations) else { return false }
-        } else if let cc2 = cc2 {
+        } else if cc2.shouldRecurse {
             let cc2lb = cc2.left.curve.boundingBox
             let cc2rb = cc2.right.curve.boundingBox
             guard Utils.pairiteration(c1, cc2.left, c1b, cc2lb, &results, accuracy, &totalIterations) else { return false }

                                                                            _ accuracy: CGFloat,
                                                                            _ totalIterations: inout Int) -> Bool {

        func splitCurveIfWithinAccuracyAndNumericalLimits<C: PointClassifiable>(_ curve: Subcurve<C>, boundingBox: BoundingBox) -> (left: Subcurve<C>, right: Subcurve<C>)? {
            // first check if the curve is small enough that it falls within
            // accuracy threshold and therefore does not require further recursion
            guard boundingBox.size.x + boundingBox.size.y >= accuracy else { return nil }
            // next check if splitting the curve results in either half being a point
            // if so, we've reached numerical precision limits of how far we can split things
            let (left, right) = curve.split(at: 0.5)
            guard left.curve.isPoint == false else { return nil }
            guard right.curve.isPoint == false else { return nil }
            return (left: left, right: right)
        }

        let maximumIterations = 900

        guard results.count <= maximumIntersections else { return false }
        guard c1b.overlaps(c2b) else { return true }

        let cc1 = splitCurveAndCheckIfShouldRecurse(c1, boundingBox: c1b)
        let cc2 = splitCurveAndCheckIfShouldRecurse(c2, boundingBox: c2b)

        if cc1.shouldRecurse == false, cc2.shouldRecurse == false {
            // subcurves are small enough or we simply cannot recurse any more
            let l1 = LineSegment(p0: c1.curve.startingPoint, p1: c1.curve.endingPoint)
            let l2 = LineSegment(p0: c2.curve.startingPoint, p1: c2.curve.endingPoint)
