Coverage for /usr/lib/python3/dist-packages/mpmath/functions/zetazeros.py: 6%

1""" 

2The function zetazero(n) computes the n-th nontrivial zero of zeta(s). 

3 

4The general strategy is to locate a block of Gram intervals B where we 

5know exactly the number of zeros contained and which of those zeros 

6is that which we search. 

7 

8If n <= 400 000 000 we know exactly the Rosser exceptions, contained 

9in a list in this file. Hence for n<=400 000 000 we simply 

10look at these list of exceptions. If our zero is implicated in one of 

11these exceptions we have our block B. In other case we simply locate 

12the good Rosser block containing our zero. 

13 

14For n > 400 000 000 we apply the method of Turing, as complemented by 

15Lehman, Brent and Trudgian to find a suitable B. 

16""" 

17 

18from .functions import defun, defun_wrapped 

19 

20def find_rosser_block_zero(ctx, n): 

21 """for n<400 000 000 determines a block were one find our zero""" 

22 for k in range(len(_ROSSER_EXCEPTIONS)//2): 

23 a=_ROSSER_EXCEPTIONS[2*k][0] 

24 b=_ROSSER_EXCEPTIONS[2*k][1] 

25 if ((a<= n-2) and (n-1 <= b)): 

26 t0 = ctx.grampoint(a) 

27 t1 = ctx.grampoint(b) 

28 v0 = ctx._fp.siegelz(t0) 

29 v1 = ctx._fp.siegelz(t1) 

30 my_zero_number = n-a-1 

31 zero_number_block = b-a 

32 pattern = _ROSSER_EXCEPTIONS[2*k+1] 

33 return (my_zero_number, [a,b], [t0,t1], [v0,v1]) 

34 k = n-2 

35 t,v,b = compute_triple_tvb(ctx, k) 

36 T = [t] 

37 V = [v] 

38 while b < 0: 

39 k -= 1 

40 t,v,b = compute_triple_tvb(ctx, k) 

41 T.insert(0,t) 

42 V.insert(0,v) 

43 my_zero_number = n-k-1 

44 m = n-1 

45 t,v,b = compute_triple_tvb(ctx, m) 

46 T.append(t) 

47 V.append(v) 

48 while b < 0: 

49 m += 1 

50 t,v,b = compute_triple_tvb(ctx, m) 

51 T.append(t) 

52 V.append(v) 

53 return (my_zero_number, [k,m], T, V) 

54 

55def wpzeros(t): 

56 """Precision needed to compute higher zeros""" 

57 wp = 53 

58 if t > 3*10**8: 

59 wp = 63 

60 if t > 10**11: 

61 wp = 70 

62 if t > 10**14: 

63 wp = 83 

64 return wp 

65 

66def separate_zeros_in_block(ctx, zero_number_block, T, V, limitloop=None, 

67 fp_tolerance=None): 

68 """Separate the zeros contained in the block T, limitloop 

69 determines how long one must search""" 

70 if limitloop is None: 

71 limitloop = ctx.inf 

72 loopnumber = 0 

73 variations = count_variations(V) 

74 while ((variations < zero_number_block) and (loopnumber <limitloop)): 

75 a = T[0] 

76 v = V[0] 

77 newT = [a] 

78 newV = [v] 

79 variations = 0 

80 for n in range(1,len(T)): 

81 b2 = T[n] 

82 u = V[n] 

83 if (u*v>0): 

84 alpha = ctx.sqrt(u/v) 

85 b= (alpha*a+b2)/(alpha+1) 

86 else: 

87 b = (a+b2)/2 

88 if fp_tolerance < 10: 

89 w = ctx._fp.siegelz(b) 

90 if abs(w)<fp_tolerance: 

91 w = ctx.siegelz(b) 

92 else: 

93 w=ctx.siegelz(b) 

94 if v*w<0: 

95 variations += 1 

96 newT.append(b) 

97 newV.append(w) 

98 u = V[n] 

99 if u*w <0: 

100 variations += 1 

101 newT.append(b2) 

102 newV.append(u) 

103 a = b2 

104 v = u 

105 T = newT 

106 V = newV 

107 loopnumber +=1 

108 if (limitloop>ITERATION_LIMIT)and(loopnumber>2)and(variations+2==zero_number_block): 

109 dtMax=0 

110 dtSec=0 

111 kMax = 0 

112 for k1 in range(1,len(T)): 

113 dt = T[k1]-T[k1-1] 

114 if dt > dtMax: 

115 kMax=k1 

116 dtSec = dtMax 

117 dtMax = dt 

118 elif (dt<dtMax) and(dt >dtSec): 

119 dtSec = dt 

120 if dtMax>3*dtSec: 

121 f = lambda x: ctx.rs_z(x,derivative=1) 

122 t0=T[kMax-1] 

123 t1 = T[kMax] 

124 t=ctx.findroot(f, (t0,t1), solver ='illinois',verify=False, verbose=False) 

125 v = ctx.siegelz(t) 

126 if (t0<t) and (t<t1) and (v*V[kMax]<0): 

127 T.insert(kMax,t) 

128 V.insert(kMax,v) 

129 variations = count_variations(V) 

130 if variations == zero_number_block: 

131 separated = True 

132 else: 

133 separated = False 

134 return (T,V, separated) 

135 

136def separate_my_zero(ctx, my_zero_number, zero_number_block, T, V, prec): 

137 """If we know which zero of this block is mine, 

138 the function separates the zero""" 

139 variations = 0 

140 v0 = V[0] 

141 for k in range(1,len(V)): 

142 v1 = V[k] 

143 if v0*v1 < 0: 

144 variations +=1 

145 if variations == my_zero_number: 

146 k0 = k 

147 leftv = v0 

148 rightv = v1 

149 v0 = v1 

150 t1 = T[k0] 

151 t0 = T[k0-1] 

152 ctx.prec = prec 

153 wpz = wpzeros(my_zero_number*ctx.log(my_zero_number)) 

154 

155 guard = 4*ctx.mag(my_zero_number) 

156 precs = [ctx.prec+4] 

157 index=0 

158 while precs[0] > 2*wpz: 

159 index +=1 

160 precs = [precs[0] // 2 +3+2*index] + precs 

161 ctx.prec = precs[0] + guard 

162 r = ctx.findroot(lambda x:ctx.siegelz(x), (t0,t1), solver ='illinois', verbose=False) 

163 #print "first step at", ctx.dps, "digits" 

164 z=ctx.mpc(0.5,r) 

165 for prec in precs[1:]: 

166 ctx.prec = prec + guard 

167 #print "refining to", ctx.dps, "digits" 

168 znew = z - ctx.zeta(z) / ctx.zeta(z, derivative=1) 

169 #print "difference", ctx.nstr(abs(z-znew)) 

170 z=ctx.mpc(0.5,ctx.im(znew)) 

171 return ctx.im(z) 

172 

173def sure_number_block(ctx, n): 

174 """The number of good Rosser blocks needed to apply 

175 Turing method 

176 References: 

177 R. P. Brent, On the Zeros of the Riemann Zeta Function 

178 in the Critical Strip, Math. Comp. 33 (1979) 1361--1372 

179 T. Trudgian, Improvements to Turing Method, Math. Comp.""" 

180 if n < 9*10**5: 

181 return(2) 

182 g = ctx.grampoint(n-100) 

183 lg = ctx._fp.ln(g) 

184 brent = 0.0061 * lg**2 +0.08*lg 

185 trudgian = 0.0031 * lg**2 +0.11*lg 

186 N = ctx.ceil(min(brent,trudgian)) 

187 N = int(N) 

188 return N 

189 

190def compute_triple_tvb(ctx, n): 

191 t = ctx.grampoint(n) 

192 v = ctx._fp.siegelz(t) 

193 if ctx.mag(abs(v))<ctx.mag(t)-45: 

194 v = ctx.siegelz(t) 

195 b = v*(-1)**n 

196 return t,v,b 

197 

198 

199 

200ITERATION_LIMIT = 4 

201 

202def search_supergood_block(ctx, n, fp_tolerance): 

203 """To use for n>400 000 000""" 

204 sb = sure_number_block(ctx, n) 

205 number_goodblocks = 0 

206 m2 = n-1 

207 t, v, b = compute_triple_tvb(ctx, m2) 

208 Tf = [t] 

209 Vf = [v] 

210 while b < 0: 

211 m2 += 1 

212 t,v,b = compute_triple_tvb(ctx, m2) 

213 Tf.append(t) 

214 Vf.append(v) 

215 goodpoints = [m2] 

216 T = [t] 

217 V = [v] 

218 while number_goodblocks < 2*sb: 

219 m2 += 1 

220 t, v, b = compute_triple_tvb(ctx, m2) 

221 T.append(t) 

222 V.append(v) 

223 while b < 0: 

224 m2 += 1 

225 t,v,b = compute_triple_tvb(ctx, m2) 

226 T.append(t) 

227 V.append(v) 

228 goodpoints.append(m2) 

229 zn = len(T)-1 

230 A, B, separated =\ 

231 separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT, 

232 fp_tolerance=fp_tolerance) 

233 Tf.pop() 

234 Tf.extend(A) 

235 Vf.pop() 

236 Vf.extend(B) 

237 if separated: 

238 number_goodblocks += 1 

239 else: 

240 number_goodblocks = 0 

241 T = [t] 

242 V = [v] 

243 # Now the same procedure to the left 

244 number_goodblocks = 0 

245 m2 = n-2 

246 t, v, b = compute_triple_tvb(ctx, m2) 

247 Tf.insert(0,t) 

248 Vf.insert(0,v) 

249 while b < 0: 

250 m2 -= 1 

251 t,v,b = compute_triple_tvb(ctx, m2) 

252 Tf.insert(0,t) 

253 Vf.insert(0,v) 

254 goodpoints.insert(0,m2) 

255 T = [t] 

256 V = [v] 

257 while number_goodblocks < 2*sb: 

258 m2 -= 1 

259 t, v, b = compute_triple_tvb(ctx, m2) 

260 T.insert(0,t) 

261 V.insert(0,v) 

262 while b < 0: 

263 m2 -= 1 

264 t,v,b = compute_triple_tvb(ctx, m2) 

265 T.insert(0,t) 

266 V.insert(0,v) 

267 goodpoints.insert(0,m2) 

268 zn = len(T)-1 

269 A, B, separated =\ 

270 separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance) 

271 A.pop() 

272 Tf = A+Tf 

273 B.pop() 

274 Vf = B+Vf 

275 if separated: 

276 number_goodblocks += 1 

277 else: 

278 number_goodblocks = 0 

279 T = [t] 

280 V = [v] 

281 r = goodpoints[2*sb] 

282 lg = len(goodpoints) 

283 s = goodpoints[lg-2*sb-1] 

284 tr, vr, br = compute_triple_tvb(ctx, r) 

285 ar = Tf.index(tr) 

286 ts, vs, bs = compute_triple_tvb(ctx, s) 

287 as1 = Tf.index(ts) 

288 T = Tf[ar:as1+1] 

289 V = Vf[ar:as1+1] 

290 zn = s-r 

291 A, B, separated =\ 

292 separate_zeros_in_block(ctx, zn,T,V,limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance) 

293 if separated: 

294 return (n-r-1,[r,s],A,B) 

295 q = goodpoints[sb] 

296 lg = len(goodpoints) 

297 t = goodpoints[lg-sb-1] 

298 tq, vq, bq = compute_triple_tvb(ctx, q) 

299 aq = Tf.index(tq) 

300 tt, vt, bt = compute_triple_tvb(ctx, t) 

301 at = Tf.index(tt) 

302 T = Tf[aq:at+1] 

303 V = Vf[aq:at+1] 

304 return (n-q-1,[q,t],T,V) 

305 

306def count_variations(V): 

307 count = 0 

308 vold = V[0] 

309 for n in range(1, len(V)): 

310 vnew = V[n] 

311 if vold*vnew < 0: 

312 count +=1 

313 vold = vnew 

314 return count 

315 

316def pattern_construct(ctx, block, T, V): 

317 pattern = '(' 

318 a = block[0] 

319 b = block[1] 

320 t0,v0,b0 = compute_triple_tvb(ctx, a) 

321 k = 0 

322 k0 = 0 

323 for n in range(a+1,b+1): 

324 t1,v1,b1 = compute_triple_tvb(ctx, n) 

325 lgT =len(T) 

326 while (k < lgT) and (T[k] <= t1): 

327 k += 1 

328 L = V[k0:k] 

329 L.append(v1) 

330 L.insert(0,v0) 

331 count = count_variations(L) 

332 pattern = pattern + ("%s" % count) 

333 if b1 > 0: 

334 pattern = pattern + ')(' 

335 k0 = k 

336 t0,v0,b0 = t1,v1,b1 

337 pattern = pattern[:-1] 

338 return pattern 

339 

340@defun 

341def zetazero(ctx, n, info=False, round=True): 

342 r""" 

343 Computes the `n`-th nontrivial zero of `\zeta(s)` on the critical line, 

344 i.e. returns an approximation of the `n`-th largest complex number 

345 `s = \frac{1}{2} + ti` for which `\zeta(s) = 0`. Equivalently, the 

346 imaginary part `t` is a zero of the Z-function (:func:`~mpmath.siegelz`). 

347 

348 **Examples** 

349 

350 The first few zeros:: 

351 

352 >>> from mpmath import * 

353 >>> mp.dps = 25; mp.pretty = True 

354 >>> zetazero(1) 

355 (0.5 + 14.13472514173469379045725j) 

356 >>> zetazero(2) 

357 (0.5 + 21.02203963877155499262848j) 

358 >>> zetazero(20) 

359 (0.5 + 77.14484006887480537268266j) 

360 

361 Verifying that the values are zeros:: 

362 

363 >>> for n in range(1,5): 

364 ... s = zetazero(n) 

365 ... chop(zeta(s)), chop(siegelz(s.imag)) 

366 ... 

367 (0.0, 0.0) 

368 (0.0, 0.0) 

369 (0.0, 0.0) 

370 (0.0, 0.0) 

371 

372 Negative indices give the conjugate zeros (`n = 0` is undefined):: 

373 

374 >>> zetazero(-1) 

375 (0.5 - 14.13472514173469379045725j) 

376 

377 :func:`~mpmath.zetazero` supports arbitrarily large `n` and arbitrary precision:: 

378 

379 >>> mp.dps = 15 

380 >>> zetazero(1234567) 

381 (0.5 + 727690.906948208j) 

382 >>> mp.dps = 50 

383 >>> zetazero(1234567) 

384 (0.5 + 727690.9069482075392389420041147142092708393819935j) 

385 >>> chop(zeta(_)/_) 

386 0.0 

387 

388 with *info=True*, :func:`~mpmath.zetazero` gives additional information:: 

389 

390 >>> mp.dps = 15 

391 >>> zetazero(542964976,info=True) 

392 ((0.5 + 209039046.578535j), [542964969, 542964978], 6, '(013111110)') 

393 

394 This means that the zero is between Gram points 542964969 and 542964978; 

395 it is the 6-th zero between them. Finally (01311110) is the pattern 

396 of zeros in this interval. The numbers indicate the number of zeros 

397 in each Gram interval (Rosser blocks between parenthesis). In this case 

398 there is only one Rosser block of length nine. 

399 """ 

400 n = int(n) 

401 if n < 0: 

402 return ctx.zetazero(-n).conjugate() 

403 if n == 0: 

404 raise ValueError("n must be nonzero") 

405 wpinitial = ctx.prec 

406 try: 

407 wpz, fp_tolerance = comp_fp_tolerance(ctx, n) 

408 ctx.prec = wpz 

409 if n < 400000000: 

410 my_zero_number, block, T, V =\ 

411 find_rosser_block_zero(ctx, n) 

412 else: 

413 my_zero_number, block, T, V =\ 

414 search_supergood_block(ctx, n, fp_tolerance) 

415 zero_number_block = block[1]-block[0] 

416 T, V, separated = separate_zeros_in_block(ctx, zero_number_block, T, V, 

417 limitloop=ctx.inf, fp_tolerance=fp_tolerance) 

418 if info: 

419 pattern = pattern_construct(ctx,block,T,V) 

420 prec = max(wpinitial, wpz) 

421 t = separate_my_zero(ctx, my_zero_number, zero_number_block,T,V,prec) 

422 v = ctx.mpc(0.5,t) 

423 finally: 

424 ctx.prec = wpinitial 

425 if round: 

426 v =+v 

427 if info: 

428 return (v,block,my_zero_number,pattern) 

429 else: 

430 return v 

431 

432def gram_index(ctx, t): 

433 if t > 10**13: 

434 wp = 3*ctx.log(t, 10) 

435 else: 

436 wp = 0 

437 prec = ctx.prec 

438 try: 

439 ctx.prec += wp 

440 h = int(ctx.siegeltheta(t)/ctx.pi) 

441 finally: 

442 ctx.prec = prec 

443 return(h) 

444 

445def count_to(ctx, t, T, V): 

446 count = 0 

447 vold = V[0] 

448 told = T[0] 

449 tnew = T[1] 

450 k = 1 

451 while tnew < t: 

452 vnew = V[k] 

453 if vold*vnew < 0: 

454 count += 1 

455 vold = vnew 

456 k += 1 

457 tnew = T[k] 

458 a = ctx.siegelz(t) 

459 if a*vold < 0: 

460 count += 1 

461 return count 

462 

463def comp_fp_tolerance(ctx, n): 

464 wpz = wpzeros(n*ctx.log(n)) 

465 if n < 15*10**8: 

466 fp_tolerance = 0.0005 

467 elif n <= 10**14: 

468 fp_tolerance = 0.1 

469 else: 

470 fp_tolerance = 100 

471 return wpz, fp_tolerance 

472 

473@defun 

474def nzeros(ctx, t): 

475 r""" 

476 Computes the number of zeros of the Riemann zeta function in 

477 `(0,1) \times (0,t]`, usually denoted by `N(t)`. 

478 

479 **Examples** 

480 

481 The first zero has imaginary part between 14 and 15:: 

482 

483 >>> from mpmath import * 

484 >>> mp.dps = 15; mp.pretty = True 

485 >>> nzeros(14) 

486 0 

487 >>> nzeros(15) 

488 1 

489 >>> zetazero(1) 

490 (0.5 + 14.1347251417347j) 

491 

492 Some closely spaced zeros:: 

493 

494 >>> nzeros(10**7) 

495 21136125 

496 >>> zetazero(21136125) 

497 (0.5 + 9999999.32718175j) 

498 >>> zetazero(21136126) 

499 (0.5 + 10000000.2400236j) 

500 >>> nzeros(545439823.215) 

501 1500000001 

502 >>> zetazero(1500000001) 

503 (0.5 + 545439823.201985j) 

504 >>> zetazero(1500000002) 

505 (0.5 + 545439823.325697j) 

506 

507 This confirms the data given by J. van de Lune, 

508 H. J. J. te Riele and D. T. Winter in 1986. 

509 """ 

510 if t < 14.1347251417347: 

511 return 0 

512 x = gram_index(ctx, t) 

513 k = int(ctx.floor(x)) 

514 wpinitial = ctx.prec 

515 wpz, fp_tolerance = comp_fp_tolerance(ctx, k) 

516 ctx.prec = wpz 

517 a = ctx.siegelz(t) 

518 if k == -1 and a < 0: 

519 return 0 

520 elif k == -1 and a > 0: 

521 return 1 

522 if k+2 < 400000000: 

523 Rblock = find_rosser_block_zero(ctx, k+2) 

524 else: 

525 Rblock = search_supergood_block(ctx, k+2, fp_tolerance) 

526 n1, n2 = Rblock[1] 

527 if n2-n1 == 1: 

528 b = Rblock[3][0] 

529 if a*b > 0: 

530 ctx.prec = wpinitial 

531 return k+1 

532 else: 

533 ctx.prec = wpinitial 

534 return k+2 

535 my_zero_number,block, T, V = Rblock 

536 zero_number_block = n2-n1 

537 T, V, separated = separate_zeros_in_block(ctx,\ 

538 zero_number_block, T, V,\ 

539 limitloop=ctx.inf,\ 

540 fp_tolerance=fp_tolerance) 

541 n = count_to(ctx, t, T, V) 

542 ctx.prec = wpinitial 

543 return n+n1+1 

544 

545@defun_wrapped 

546def backlunds(ctx, t): 

547 r""" 

548 Computes the function 

549 `S(t) = \operatorname{arg} \zeta(\frac{1}{2} + it) / \pi`. 

550 

551 See Titchmarsh Section 9.3 for details of the definition. 

552 

553 **Examples** 

554 

555 >>> from mpmath import * 

556 >>> mp.dps = 15; mp.pretty = True 

557 >>> backlunds(217.3) 

558 0.16302205431184 

559 

560 Generally, the value is a small number. At Gram points it is an integer, 

561 frequently equal to 0:: 

562 

563 >>> chop(backlunds(grampoint(200))) 

564 0.0 

565 >>> backlunds(extraprec(10)(grampoint)(211)) 

566 1.0 

567 >>> backlunds(extraprec(10)(grampoint)(232)) 

568 -1.0 

569 

570 The number of zeros of the Riemann zeta function up to height `t` 

571 satisfies `N(t) = \theta(t)/\pi + 1 + S(t)` (see :func:nzeros` and 

572 :func:`siegeltheta`):: 

573 

574 >>> t = 1234.55 

575 >>> nzeros(t) 

576 842 

577 >>> siegeltheta(t)/pi+1+backlunds(t) 

578 842.0 

579 

580 """ 

581 return ctx.nzeros(t)-1-ctx.siegeltheta(t)/ctx.pi 

582 

583 

584""" 

585_ROSSER_EXCEPTIONS is a list of all exceptions to 

586Rosser's rule for n <= 400 000 000. 

587 

588Alternately the entry is of type [n,m], or a string. 

589The string is the zero pattern of the Block and the relevant 

590adjacent. For example (010)3 corresponds to a block 

591composed of three Gram intervals, the first ant third without 

592a zero and the intermediate with a zero. The next Gram interval 

593contain three zeros. So that in total we have 4 zeros in 4 Gram 

594blocks. n and m are the indices of the Gram points of this 

595interval of four Gram intervals. The Rosser exception is therefore 

596formed by the three Gram intervals that are signaled between 

597parenthesis. 

598 

599We have included also some Rosser's exceptions beyond n=400 000 000 

600that are noted in the literature by some reason. 

601 

602The list is composed from the data published in the references: 

603 

604R. P. Brent, J. van de Lune, H. J. J. te Riele, D. T. Winter, 

605'On the Zeros of the Riemann Zeta Function in the Critical Strip. II', 

606Math. Comp. 39 (1982) 681--688. 

607See also Corrigenda in Math. Comp. 46 (1986) 771. 

608 

609J. van de Lune, H. J. J. te Riele, 

610'On the Zeros of the Riemann Zeta Function in the Critical Strip. III', 

611Math. Comp. 41 (1983) 759--767. 

612See also Corrigenda in Math. Comp. 46 (1986) 771. 

613 

614J. van de Lune, 

615'Sums of Equal Powers of Positive Integers', 

616Dissertation, 

617Vrije Universiteit te Amsterdam, Centrum voor Wiskunde en Informatica, 

618Amsterdam, 1984. 

619 

620Thanks to the authors all this papers and those others that have 

621contributed to make this possible. 

622""" 

623 

624 

625 

626 

627 

628 

629 

630_ROSSER_EXCEPTIONS = \ 

631[[13999525, 13999528], '(00)3', 

632[30783329, 30783332], '(00)3', 

633[30930926, 30930929], '3(00)', 

634[37592215, 37592218], '(00)3', 

635[40870156, 40870159], '(00)3', 

636[43628107, 43628110], '(00)3', 

637[46082042, 46082045], '(00)3', 

638[46875667, 46875670], '(00)3', 

639[49624540, 49624543], '3(00)', 

640[50799238, 50799241], '(00)3', 

641[55221453, 55221456], '3(00)', 

642[56948779, 56948782], '3(00)', 

643[60515663, 60515666], '(00)3', 

644[61331766, 61331770], '(00)40', 

645[69784843, 69784846], '3(00)', 

646[75052114, 75052117], '(00)3', 

647[79545240, 79545243], '3(00)', 

648[79652247, 79652250], '3(00)', 

649[83088043, 83088046], '(00)3', 

650[83689522, 83689525], '3(00)', 

651[85348958, 85348961], '(00)3', 

652[86513820, 86513823], '(00)3', 

653[87947596, 87947599], '3(00)', 

654[88600095, 88600098], '(00)3', 

655[93681183, 93681186], '(00)3', 

656[100316551, 100316554], '3(00)', 

657[100788444, 100788447], '(00)3', 

658[106236172, 106236175], '(00)3', 

659[106941327, 106941330], '3(00)', 

660[107287955, 107287958], '(00)3', 

661[107532016, 107532019], '3(00)', 

662[110571044, 110571047], '(00)3', 

663[111885253, 111885256], '3(00)', 

664[113239783, 113239786], '(00)3', 

665[120159903, 120159906], '(00)3', 

666[121424391, 121424394], '3(00)', 

667[121692931, 121692934], '3(00)', 

668[121934170, 121934173], '3(00)', 

669[122612848, 122612851], '3(00)', 

670[126116567, 126116570], '(00)3', 

671[127936513, 127936516], '(00)3', 

672[128710277, 128710280], '3(00)', 

673[129398902, 129398905], '3(00)', 

674[130461096, 130461099], '3(00)', 

675[131331947, 131331950], '3(00)', 

676[137334071, 137334074], '3(00)', 

677[137832603, 137832606], '(00)3', 

678[138799471, 138799474], '3(00)', 

679[139027791, 139027794], '(00)3', 

680[141617806, 141617809], '(00)3', 

681[144454931, 144454934], '(00)3', 

682[145402379, 145402382], '3(00)', 

683[146130245, 146130248], '3(00)', 

684[147059770, 147059773], '(00)3', 

685[147896099, 147896102], '3(00)', 

686[151097113, 151097116], '(00)3', 

687[152539438, 152539441], '(00)3', 

688[152863168, 152863171], '3(00)', 

689[153522726, 153522729], '3(00)', 

690[155171524, 155171527], '3(00)', 

691[155366607, 155366610], '(00)3', 

692[157260686, 157260689], '3(00)', 

693[157269224, 157269227], '(00)3', 

694[157755123, 157755126], '(00)3', 

695[158298484, 158298487], '3(00)', 

696[160369050, 160369053], '3(00)', 

697[162962787, 162962790], '(00)3', 

698[163724709, 163724712], '(00)3', 

699[164198113, 164198116], '3(00)', 

700[164689301, 164689305], '(00)40', 

701[164880228, 164880231], '3(00)', 

702[166201932, 166201935], '(00)3', 

703[168573836, 168573839], '(00)3', 

704[169750763, 169750766], '(00)3', 

705[170375507, 170375510], '(00)3', 

706[170704879, 170704882], '3(00)', 

707[172000992, 172000995], '3(00)', 

708[173289941, 173289944], '(00)3', 

709[173737613, 173737616], '3(00)', 

710[174102513, 174102516], '(00)3', 

711[174284990, 174284993], '(00)3', 

712[174500513, 174500516], '(00)3', 

713[175710609, 175710612], '(00)3', 

714[176870843, 176870846], '3(00)', 

715[177332732, 177332735], '3(00)', 

716[177902861, 177902864], '3(00)', 

717[179979095, 179979098], '(00)3', 

718[181233726, 181233729], '3(00)', 

719[181625435, 181625438], '(00)3', 

720[182105255, 182105259], '22(00)', 

721[182223559, 182223562], '3(00)', 

722[191116404, 191116407], '3(00)', 

723[191165599, 191165602], '3(00)', 

724[191297535, 191297539], '(00)22', 

725[192485616, 192485619], '(00)3', 

726[193264634, 193264638], '22(00)', 

727[194696968, 194696971], '(00)3', 

728[195876805, 195876808], '(00)3', 

729[195916548, 195916551], '3(00)', 

730[196395160, 196395163], '3(00)', 

731[196676303, 196676306], '(00)3', 

732[197889882, 197889885], '3(00)', 

733[198014122, 198014125], '(00)3', 

734[199235289, 199235292], '(00)3', 

735[201007375, 201007378], '(00)3', 

736[201030605, 201030608], '3(00)', 

737[201184290, 201184293], '3(00)', 

738[201685414, 201685418], '(00)22', 

739[202762875, 202762878], '3(00)', 

740[202860957, 202860960], '3(00)', 

741[203832577, 203832580], '3(00)', 

742[205880544, 205880547], '(00)3', 

743[206357111, 206357114], '(00)3', 

744[207159767, 207159770], '3(00)', 

745[207167343, 207167346], '3(00)', 

746[207482539, 207482543], '3(010)', 

747[207669540, 207669543], '3(00)', 

748[208053426, 208053429], '(00)3', 

749[208110027, 208110030], '3(00)', 

750[209513826, 209513829], '3(00)', 

751[212623522, 212623525], '(00)3', 

752[213841715, 213841718], '(00)3', 

753[214012333, 214012336], '(00)3', 

754[214073567, 214073570], '(00)3', 

755[215170600, 215170603], '3(00)', 

756[215881039, 215881042], '3(00)', 

757[216274604, 216274607], '3(00)', 

758[216957120, 216957123], '3(00)', 

759[217323208, 217323211], '(00)3', 

760[218799264, 218799267], '(00)3', 

761[218803557, 218803560], '3(00)', 

762[219735146, 219735149], '(00)3', 

763[219830062, 219830065], '3(00)', 

764[219897904, 219897907], '(00)3', 

765[221205545, 221205548], '(00)3', 

766[223601929, 223601932], '(00)3', 

767[223907076, 223907079], '3(00)', 

768[223970397, 223970400], '(00)3', 

769[224874044, 224874048], '22(00)',