7306 1995 Bytes
This solution runs in log(n) complexity (as far as I can tell).
for n in s[::-1]:t=t.replace(*n)
return []*78+[list(bytearray.fromhex(a))for a in t.split(",")]
g,h=lambda c,n:c+[[,[3,7,78,91]][n[len(c)]%2]+[i*2for i in c[-1]]],lambda n:if n<78 else h((n-[2,179][n%2])//2)+[n]
for o in range(len(v)-1):c=g(c,v)
You can test that
f(2**32 - 1) runs almost instantly
I used this paper on a method for computing it. With this method there is a massive chunk of data for the pre-determined values for n from 78 to 334 without the even numbers after 168. I wanted to turn this data into something small and I didn't know any good compression algorithms so I made my own.
The way I compressed it was by having a list of string replace rules. I created a method which found the string replace rule which would cut down the most content over all taking into account defining the rule. I then recursively applied this until I could create no more rules (I used characters g-z and A-Z). The string I made to replace with was a comma separated list of the hex values for each of the numbers. In retrospect, converting them to their hex values may not have been the wisest choice, it would probably be shorter to leave them in decimal, since having hex would only save for the 3 digit numbers but would add a 0 for single digit numbers.
The line where I set c you can see the list of replace rules and the text which it runs it on. The rules need to be applied in reverse as well because some rules include characters created from other rules.
There are also numerous places in this code where I could probably cut down on syntax, such as turning the list of lists into a single list and then using a different method to access the rules to replace the text with