         guard results.count <= maximumIntersections else { return false }
         guard c1b.overlaps(c2b) else { return true }
 
-        let cc1 = splitCurveIfWithinAccuracyAndNumericalLimits(c1, boundingBox: c1b)
-        let cc2 = splitCurveIfWithinAccuracyAndNumericalLimits(c2, boundingBox: c2b)
-
-        if cc1 == nil, cc2 == nil {
+        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)

                                                                            _ 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

            let t2 = intersection.t2
            results.append(Intersection(t1: t1 * c1.t2 + (1.0 - t1) * c1.t1,
                                        t2: t2 * c2.t2 + (1.0 - t2) * c2.t1))
        } else if cc1.shouldRecurse, cc2.shouldRecurse {
            let cc1lb = cc1.left.curve.boundingBox
            let cc1rb = cc1.right.curve.boundingBox
            let cc2lb = cc2.left.curve.boundingBox
