[woctlwvh] Iterated n log n

let f = product . map floor . takeWhile (1<) . iterate log_2
let g = product . map ceiling . takeWhile (1<) . iterate log_2
(Haskell syntax)

n	f	f product	g	g product
1	1	= 1	1	= 1
2	2	= 2 * 1	2	= 2 * 1
3	3	= 3 * 1	6	= 3 * 2 * 1
4	8	= 4 * 2 * 1	8	= 4 * 2 * 1
5	10	= 5 * 2 * 1	30	= 5 * 3 * 2 * 1
6	12	= 6 * 2 * 1	36	= 6 * 3 * 2 * 1
7	14	= 7 * 2 * 1	42	= 7 * 3 * 2 * 1
8	24	= 8 * 3 * 1	48	= 8 * 3 * 2 * 1
9	27	= 9 * 3 * 1	72	= 9 * 4 * 2 * 1
10	30	= 10 * 3 * 1	80	= 10 * 4 * 2 * 1
11	33	= 11 * 3 * 1	88	= 11 * 4 * 2 * 1
12	36	= 12 * 3 * 1	96	= 12 * 4 * 2 * 1
13	39	= 13 * 3 * 1	104	= 13 * 4 * 2 * 1
14	42	= 14 * 3 * 1	112	= 14 * 4 * 2 * 1
15	45	= 15 * 3 * 1	120	= 15 * 4 * 2 * 1
16	128	= 16 * 4 * 2 * 1	128	= 16 * 4 * 2 * 1
17	136	= 17 * 4 * 2 * 1	510	= 17 * 5 * 3 * 2 * 1
18	144	= 18 * 4 * 2 * 1	540	= 18 * 5 * 3 * 2 * 1
19	152	= 19 * 4 * 2 * 1	570	= 19 * 5 * 3 * 2 * 1
20	160	= 20 * 4 * 2 * 1	600	= 20 * 5 * 3 * 2 * 1
21	168	= 21 * 4 * 2 * 1	630	= 21 * 5 * 3 * 2 * 1
22	176	= 22 * 4 * 2 * 1	660	= 22 * 5 * 3 * 2 * 1
23	184	= 23 * 4 * 2 * 1	690	= 23 * 5 * 3 * 2 * 1
24	192	= 24 * 4 * 2 * 1	720	= 24 * 5 * 3 * 2 * 1
25	200	= 25 * 4 * 2 * 1	750	= 25 * 5 * 3 * 2 * 1
26	208	= 26 * 4 * 2 * 1	780	= 26 * 5 * 3 * 2 * 1
27	216	= 27 * 4 * 2 * 1	810	= 27 * 5 * 3 * 2 * 1
28	224	= 28 * 4 * 2 * 1	840	= 28 * 5 * 3 * 2 * 1
29	232	= 29 * 4 * 2 * 1	870	= 29 * 5 * 3 * 2 * 1
30	240	= 30 * 4 * 2 * 1	900	= 30 * 5 * 3 * 2 * 1
31	248	= 31 * 4 * 2 * 1	930	= 31 * 5 * 3 * 2 * 1
32	320	= 32 * 5 * 2 * 1	960	= 32 * 5 * 3 * 2 * 1
33	330	= 33 * 5 * 2 * 1	1188	= 33 * 6 * 3 * 2 * 1
34	340	= 34 * 5 * 2 * 1	1224	= 34 * 6 * 3 * 2 * 1
35	350	= 35 * 5 * 2 * 1	1260	= 35 * 6 * 3 * 2 * 1
65534	2949030	= 65534 * 15 * 3 * 1	8388352	= 65534 * 16 * 4 * 2 * 1
65535	2949075	= 65535 * 15 * 3 * 1	8388480	= 65535 * 16 * 4 * 2 * 1
65536	8388608	= 65536 * 16 * 4 * 2 * 1	8388608	= 65536 * 16 * 4 * 2 * 1
65537	8388736	= 65537 * 16 * 4 * 2 * 1	33423870	= 65537 * 17 * 5 * 3 * 2 * 1
65538	8388864	= 65538 * 16 * 4 * 2 * 1	33424380	= 65538 * 17 * 5 * 3 * 2 * 1

OEIS A216761 and A216762.

The reciprocals form a very slowly diverging series, perhaps slower than any other integer sequence.

A fibonacci sequence version, which is essentially logarithms base phi?

A real-valued version using natural logarithms is: product . takeWhile (1<) . iterate log, which is continuous but defined piecewise. Is there a non piecewise function?