                 let currentMax = byDay[fastStartDay] ?? duration
                 byDay.updateValue(currentMax >= duration ? currentMax : duration, forKey: fastStartDay)
                 nextFast = e.0
+            } else if iStart && prevFast == nil {
+                nextFast = e.0
             }
             return (!acc.0, nextFast, e.0, byDay)
         }

            let zst : ([Event], Bool, Event!) = ([], true, nil)
            let intervals = sortedEvents.reduce(zst, combine: { (acc, e) in
                guard acc.2 != nil else {
                    return ((e.0 == startDate ? [e] : [(startDate, CircadianEvent.Fast), (e.0, CircadianEvent.Fast), e]), !acc.1, e)
                }

                // Skip a fasting interval for back-to-back events
                if (acc.1 && acc.2.0 == e.0) {
                    return (acc.0 + [(e.0+epsilon, e.1)], !acc.1, e)
                } else if acc.1 {
                    return (acc.0 + [(acc.2.0+epsilon, .Fast), (e.0-epsilon, .Fast), e], !acc.1, e)
                } else {
                    return (acc.0 + [e], !acc.1, e)
                }

                                                  aggregator: ((T, (NSDate, CircadianEvent)) -> T), initial: T, final: (T -> [(NSDate, Double)]),
                                                  completion: HMCircadianAggregateBlock)
    {
        fetchCircadianEventIntervals(NSDate.distantPast()) { (intervals, error) in
            guard error == nil else {
                completion(aggregates: [], error: error)
                return
