| line |
true |
false |
branch |
|
77
|
1309 |
55 |
if (n < 259) { |
|
78
|
0 |
1309 |
if (n == 0) { *size = 0; return 0; } |
|
80
|
28196 |
0 |
for (lsize = 0; lsize < 48 && _small_lucky[lsize] <= n; lsize++) |
|
|
26887 |
1309 |
for (lsize = 0; lsize < 48 && _small_lucky[lsize] <= n; lsize++) |
|
92
|
215061 |
55 |
for (i = 1, m = 1; i <= n; i += 6) { |
|
93
|
163896 |
51165 |
if (_lmask63[m ]) { |
|
94
|
12605 |
151291 |
if (++c13 == 13) c13 = 0; else lucky[lsize++] = i; |
|
96
|
163857 |
51204 |
if (_lmask63[m+2] && (i+2) <= n) { |
|
|
163851 |
6 |
if (_lmask63[m+2] && (i+2) <= n) { |
|
97
|
12577 |
151274 |
if (++c13 == 13) c13 = 0; else lucky[lsize++] = i+2; |
|
99
|
20459 |
194602 |
if ((m += 6) >= 63) m -= 63; |
|
104
|
8305 |
0 |
for (level = init_level; level < lsize && lucky[level]-1 < lsize; level++) { |
|
|
8305 |
0 |
for (level = init_level; level < lsize && lucky[level]-1 < lsize; level++) { |
|
106
|
55 |
8250 |
if (2*(skip+1) > lsize) break; /* Only single skips left */ |
|
107
|
176539 |
8250 |
for (i = skip+1; i < lsize; i += skip+1) { |
|
115
|
55 |
0 |
if (level < lsize && lucky[level]-1 < lsize) { |
|
|
55 |
0 |
if (level < lsize && lucky[level]-1 < lsize) { |
|
117
|
6247 |
55 |
while (skip < lsize) { |
|
119
|
33 |
6214 |
if (ncopy > lsize-skip) ncopy = lsize - skip; |
|
221
|
0 |
3 |
sln = (n <= 200000000) ? 21 : |
|
|
0 |
0 |
sln = (n <= 200000000) ? 21 : |
|
223
|
6 |
0 |
for (lbeg = lend = 5; lend < 48; lend++) |
|
224
|
3 |
3 |
if (_small_lucky[lend] >= sln) |
|
227
|
0 |
3 |
if (_verbose) printf("bitmask lucky pre-sieve using %u lucky numbers up to %u\n", lend, _small_lucky[lend]); |
|
230
|
505293 |
3 |
for (i = 1, m = 0; i <= n; i += 2, m += 1) { |
|
231
|
615 |
504678 |
if (m >= 819) m -= 819; /* m = (i>>1) % 819 */ |
|
232
|
236918 |
268375 |
if (_lmask5[m >> 5] & (1U << (m & 0x1F))) { |
|
233
|
458043 |
210597 |
for (ln = lbeg; ln <= lend; ln++) { |
|
234
|
26321 |
431722 |
if (++count[ln] == _small_lucky[ln]) { |
|
239
|
210597 |
26321 |
if (ln > lend) |
|
247
|
0 |
3 |
if (_verbose) printf("bitmask lucky done inserting. values: %lu\n",lsize); |
|
249
|
3 |
0 |
if (init_level < lsize) { |
|
251
|
7625 |
0 |
for (level = init_level; level < lsize; level++) { |
|
253
|
3 |
7622 |
if (skip >= lsize) break; |
|
254
|
132793 |
7622 |
for (i = skip; i < lsize; i += skip) { |
|
259
|
0 |
3 |
if (_verbose) printf("bitmask lucky done sieving. values: %lu\n",lsize); |
|
269
|
1 |
1366 |
if (n == 0) { *size = 0; return 0; } |
|
270
|
0 |
1366 |
if (n > 4294967275U) n = 4294967275U; /* Max 32-bit lucky number */ |
|
272
|
1364 |
2 |
if (n <= 240000U) return _small_lucky_sieve32(size, n); |
|
277
|
0 |
2 |
if (_verbose) printf("lucky_sieve32 done copying.\n"); |
|
286
|
0 |
0 |
if (n == 0) { *size = 0; return 0; } |
|
291
|
0 |
0 |
if (_verbose) printf("lucky_sieve64 done copying.\n"); |
|
301
|
1 |
0 |
if (end == 0 || beg > end) { *size = 0; return 0; } |
|
|
0 |
1 |
if (end == 0 || beg > end) { *size = 0; return 0; } |
|
303
|
0 |
1 |
if (beg <= 1) return lucky_sieve64(size, end); |
|
307
|
0 |
1 |
New(0, lucky, *size - startcount, UV); |
|
309
|
31 |
1 |
for (i = startcount, nlucky = 0; i < *size; i++) { |
|
311
|
6 |
25 |
if (l >= beg) |
|
327
|
0 |
0 |
if (n == 0) { *size = 0; return 0; } |
|
330
|
0 |
0 |
lmax = (n < 1000) ? 153 : 100 + n/log(n); |
|
331
|
0 |
0 |
New(0, lucky, lmax, UV); |
|
332
|
0 |
0 |
New(0, count, lmax, UV); |
|
340
|
0 |
0 |
for (i = 3; i <= n; i += 2) { |
|
341
|
0 |
0 |
if (!--c3) { c3 = 3; continue; } /* Shortcut count[1] */ |
|
342
|
0 |
0 |
for (j = 2; j < lindex; j++) { |
|
343
|
0 |
0 |
if (--count[j] == 0) { |
|
348
|
0 |
0 |
if (j < lindex) continue; |
|
350
|
0 |
0 |
if (lsize >= lmax) { /* Given the estimate, we probably never do this. */ |
|
352
|
0 |
0 |
Renew(lucky, lmax, UV); |
|
353
|
0 |
0 |
Renew(count, lmax, UV); |
|
358
|
0 |
0 |
if (lucky[lindex] == lsize) { |
|
375
|
0 |
26 |
: (n <= 10000) ? 1.03591 * n/logn |
|
|
0 |
26 |
: (n <= 10000) ? 1.03591 * n/logn |
|
|
21 |
5 |
: (n <= 10000) ? 1.03591 * n/logn |
|
|
2 |
3 |
: (n <= 10000) ? 1.03591 * n/logn |
|
|
0 |
3 |
: (n <= 10000) ? 1.03591 * n/logn |
|
|
0 |
3 |
: (n <= 10000) ? 1.03591 * n/logn |
|
385
|
0 |
1164 |
if (n <= 6) return (n > 0) + (n > 2); |
|
386
|
1111 |
53 |
if (n <= 7000) return 5 + 1.039 * n/logn; |
|
389
|
50 |
3 |
a = (n < 10017000) ? 0.58003 - 3.00e-9 * (n-7000) : 0.55; |
|
393
|
0 |
134 |
if (n <= 6) return (n > 0) + (n > 2); |
|
394
|
108 |
26 |
if (n <= 9000) return 1.028 * n/log(n) - 1; |
|
400
|
48 |
66 |
if (n < 48) return _small_lucky_count[n]; |
|
408
|
48 |
1085 |
if (n < 48) return _small_lucky_count[n]; |
|
410
|
1084 |
1 |
if (n < 40000000) return _simple_lucky_count_upper(n); |
|
412
|
0 |
1 |
if (n > UVCONST(18428297000000000000)) |
|
421
|
48 |
67 |
if (n < 48) return _small_lucky_count[n]; |
|
422
|
54 |
13 |
if (n < 9000) return _simple_lucky_count_lower(n); |
|
430
|
0 |
1960 |
if (hi < lo) |
|
432
|
957 |
1003 |
if (hi < 48) |
|
433
|
820 |
137 |
return _small_lucky_count[hi] - (lo == 0 ? 0 : _small_lucky_count[lo-1]); |
|
441
|
0 |
1003 |
if ((lo & 1)) lo--; /* Both lo and hi will be even */ |
|
442
|
501 |
502 |
if ((hi & 1)) hi++; |
|
445
|
1003 |
0 |
if (hi <= UVCONST(2000000000)) { |
|
448
|
1003 |
0 |
for (i = 1; i < nlucky && lucky32[i] <= lo; i++) { |
|
|
0 |
1003 |
for (i = 1; i < nlucky && lucky32[i] <= lo; i++) { |
|
452
|
18967 |
337 |
for ( ; i < nlucky && lucky32[i] <= hicount; i++) |
|
|
18301 |
666 |
for ( ; i < nlucky && lucky32[i] <= hicount; i++) |
|
461
|
0 |
0 |
for (i = 1; i < nlucky; i++) { |
|
463
|
0 |
0 |
if (l <= lo) locount -= locount/l; |
|
464
|
0 |
0 |
if (l > hicount) break; |
|
477
|
232 |
396 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
|
232 |
0 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
486
|
294 |
102 |
if (n <= 65536) { |
|
487
|
38 |
256 |
if (n >= 16384) /* 16384 -- 65536 */ |
|
489
|
28 |
228 |
else if (n >= 2048) /* 2048 -- 16384 */ |
|
491
|
12 |
216 |
else if (n >= 256) /* 256 -- 2048 */ |
|
500
|
28 |
74 |
if (fn >= 1099511627776.0) /* 2^40 -- 2^43 */ |
|
502
|
0 |
74 |
else if (fn >= 68719476736.0) /* 2^36 -- 2^40 */ |
|
504
|
0 |
74 |
else if (fn >= 4294967296.0) /* 2^32 -- 2^36 */ |
|
506
|
4 |
70 |
else if (fn >= 67108864) /* 2^26 -- 2^32 */ |
|
508
|
8 |
62 |
else if (fn >= 1048576) /* 2^20 -- 2^26 */ |
|
510
|
62 |
0 |
else if (n >= 65536) /* 2^16 -- 2^20 */ |
|
512
|
0 |
0 |
else if (n >= 512) /* 2^9 -- 2^16 */ |
|
519
|
0 |
396 |
if (est >= MPU_MAX_LUCKY) return MPU_MAX_LUCKY; |
|
524
|
48 |
123 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
|
48 |
0 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
525
|
70 |
53 |
corr = (n <= 1000) ? 1.01 : |
|
526
|
19 |
51 |
(n <= 8200) ? 1.005 : |
|
529
|
0 |
123 |
if (est >= MPU_MAX_LUCKY) return MPU_MAX_LUCKY; |
|
534
|
48 |
74 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
|
48 |
0 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
536
|
21 |
53 |
corr = (n <= 122) ? 0.95 : |
|
537
|
19 |
2 |
(n <= 4096) ? 0.97 : |
|
538
|
8 |
11 |
(n <= 115000) ? 0.998 : |
|
547
|
48 |
116 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
|
48 |
0 |
if (n <= 48) return (n == 0) ? 0 : _small_lucky[n-1]; |
|
550
|
116 |
0 |
if (n <= UVCONST(100000000)) { |
|
552
|
38519 |
116 |
for (i = nlucky-1, k = n-1; i >= 1; i--) |
|
558
|
0 |
0 |
for (i = nlucky-1, k = n-1; i >= 1; i--) |
|
570
|
42 |
0 |
if (lsize <= 700000000U) { |
|
572
|
89536 |
27 |
while (i < nlucky) { |
|
574
|
13 |
89523 |
if (pos < l) { ret = 1; break; } |
|
576
|
2 |
89521 |
if (pos == quo*l) { ret = 0; break; } |
|
583
|
0 |
0 |
if (i < nlucky) { |
|
585
|
0 |
0 |
while (i < nlucky) { |
|
588
|
0 |
0 |
if (pos < l) { ret = 1; break; } |
|
590
|
0 |
0 |
if (pos == quo*l) { ret = 0; break; } |
|
607
|
117 |
101 |
if ( !(n & 1) || (n%6) == 5 || !_lmask63[n % 63]) return 0; |
|
|
84 |
33 |
if ( !(n & 1) || (n%6) == 5 || !_lmask63[n % 63]) return 0; |
|
|
15 |
69 |
if ( !(n & 1) || (n%6) == 5 || !_lmask63[n % 63]) return 0; |
|
608
|
12 |
57 |
if (n < 45) return 1; |
|
609
|
0 |
57 |
if (n > MPU_MAX_LUCKY) return 0; |
|
614
|
1062 |
16 |
for (i = 1; i < 48; i++) { |
|
616
|
27 |
1035 |
if (pos < l) return 1; |
|
618
|
14 |
1021 |
if (pos == quo*l) return 0; |
|
626
|
27 |
15 |
while (psize < lsize/3) { |
|
628
|
1 |
26 |
if (res != -1) return res; |