Slowing Down Sped Up Videos Summary
Videos which are sped up every time a particular word is said exist for everything from the Bee Movie to the classic Rick Roll. The goal for this challenge is to figure out how much you'd have to slow down the sped-up video in order to match the duration of the original video.
For example, the original Bee Movie has a duration of 95 minutes. The sped up version is 5:40 or ~5.667 minutes. 95/5.667 = 16.76. We'd have to play the sped up version 16.76x slower in order for the overall duration to match the original movie.
Inputs
Your program must take in 3 inputs:

The duration of the original video (Bee Movie was 95 minutes)
The speedup factor per occurence (Bee Movie was 15% or .15)
A list of timestamps of occurrences (Bee movie has more than I care to look up/list)

The exact way these are passed in is flexible: 3 separate parameters is my default assumption, but if you want to take in a single list of values and pop the duration/speedup factor off the front that's fine, or take a single string in JSON or whatever format floats your boat, etc.
For the duration: seconds, minutes, or some builtin duration type are all fine.
For the speedup factor of the bee movie, any of 15, .15, or 1.15 could be used to represent the 15% speedup.
You can assume the occurrences are ordered in the most convenient manner, but there can be duplicate values (such as multiple characters talking over one another in a movie).
Output
A scaling factor to make the durations of the original and sped-up video match. The exact format is flexible.
Examples
{&quot;duration&quot;: 10, &quot;speedup-factor&quot;: 2, &quot;occurrences&quot;: [1,2,3,4,5,6,7,8,9]} -&gt; {&quot;slowdown-factor&quot;: 5.004887585532747}
{&quot;duration&quot;: 500, &quot;speedup-factor&quot;: 1.15, &quot;occurrences&quot;: [1,2,3, ..., 497, 498, 499]} -&gt; {&quot;slowdown-factor&quot;: 65.21739130434779}
{&quot;duration&quot;: 100, &quot;speedup-factor&quot;: 3, &quot;occurrences&quot;: [0]} -&gt; {&quot;slowdown-factor&quot;: 3}
{&quot;duration&quot;: 100, &quot;speedup-factor&quot;: 3, &quot;occurrences&quot;: [0, 0, 0]} -&gt; {&quot;slowdown-factor&quot;: 27}
{&quot;duration&quot;: 100, &quot;speedup-factor&quot;: 100, &quot;occurrences&quot;: [99.99]} -&gt; {&quot;slowdown-factor&quot;: 1.0000990098}

Notes: First two generated programmatically with 100/(sum(1/(2**i) for i in range(10))) and 500/(sum(1/(1.15**i) for i in range(500))). 4th example: 3 * 3 * 3 = 27x speedup, occurring right at the start of the video. Last example calculated by hand with 100/(99.99 + .01/100)
Note
I've kept most of the examples fairly simple, but I believe they cover all the relevant edge cases (a program which solves all of them should be totally correct). If I've left things ambiguous or difficult to parse, let me know and I'll add comments!
Python 2, 47 bytes

lambda m,r,l:m/reduce(lambda u,x:u/r+x-x/r,l,m)

Try it online!
Takes timestamps sorted in descending order.
The idea is to compute the video duration as a polynomial in the inverse speedup rate 1/r using Horner's method with coefficients given by the sorted timestamps. This avoids needing to explicitly take the differences of consecutive timestamps. We then divide the duration of the original video by the resulting duration to get the desired slowdown factor.
53 bytes

f=lambda m,r,l:l==[]or r/(l.pop()*(r-1)/m+1/f(m,r,l))

Try it online!
An attempt to write the function fully recursively. While the new duration itself has a clean recursive expression, we want to get the slowdown factor which divides the original duration by the new duration, and this is messier to express recursively.