| """ |
| The function zetazero(n) computes the n-th nontrivial zero of zeta(s). |
| |
| The general strategy is to locate a block of Gram intervals B where we |
| know exactly the number of zeros contained and which of those zeros |
| is that which we search. |
| |
| If n <= 400 000 000 we know exactly the Rosser exceptions, contained |
| in a list in this file. Hence for n<=400 000 000 we simply |
| look at these list of exceptions. If our zero is implicated in one of |
| these exceptions we have our block B. In other case we simply locate |
| the good Rosser block containing our zero. |
| |
| For n > 400 000 000 we apply the method of Turing, as complemented by |
| Lehman, Brent and Trudgian to find a suitable B. |
| """ |
|
|
| from .functions import defun, defun_wrapped |
|
|
| def find_rosser_block_zero(ctx, n): |
| """for n<400 000 000 determines a block were one find our zero""" |
| for k in range(len(_ROSSER_EXCEPTIONS)//2): |
| a=_ROSSER_EXCEPTIONS[2*k][0] |
| b=_ROSSER_EXCEPTIONS[2*k][1] |
| if ((a<= n-2) and (n-1 <= b)): |
| t0 = ctx.grampoint(a) |
| t1 = ctx.grampoint(b) |
| v0 = ctx._fp.siegelz(t0) |
| v1 = ctx._fp.siegelz(t1) |
| my_zero_number = n-a-1 |
| zero_number_block = b-a |
| pattern = _ROSSER_EXCEPTIONS[2*k+1] |
| return (my_zero_number, [a,b], [t0,t1], [v0,v1]) |
| k = n-2 |
| t,v,b = compute_triple_tvb(ctx, k) |
| T = [t] |
| V = [v] |
| while b < 0: |
| k -= 1 |
| t,v,b = compute_triple_tvb(ctx, k) |
| T.insert(0,t) |
| V.insert(0,v) |
| my_zero_number = n-k-1 |
| m = n-1 |
| t,v,b = compute_triple_tvb(ctx, m) |
| T.append(t) |
| V.append(v) |
| while b < 0: |
| m += 1 |
| t,v,b = compute_triple_tvb(ctx, m) |
| T.append(t) |
| V.append(v) |
| return (my_zero_number, [k,m], T, V) |
|
|
| def wpzeros(t): |
| """Precision needed to compute higher zeros""" |
| wp = 53 |
| if t > 3*10**8: |
| wp = 63 |
| if t > 10**11: |
| wp = 70 |
| if t > 10**14: |
| wp = 83 |
| return wp |
|
|
| def separate_zeros_in_block(ctx, zero_number_block, T, V, limitloop=None, |
| fp_tolerance=None): |
| """Separate the zeros contained in the block T, limitloop |
| determines how long one must search""" |
| if limitloop is None: |
| limitloop = ctx.inf |
| loopnumber = 0 |
| variations = count_variations(V) |
| while ((variations < zero_number_block) and (loopnumber <limitloop)): |
| a = T[0] |
| v = V[0] |
| newT = [a] |
| newV = [v] |
| variations = 0 |
| for n in range(1,len(T)): |
| b2 = T[n] |
| u = V[n] |
| if (u*v>0): |
| alpha = ctx.sqrt(u/v) |
| b= (alpha*a+b2)/(alpha+1) |
| else: |
| b = (a+b2)/2 |
| if fp_tolerance < 10: |
| w = ctx._fp.siegelz(b) |
| if abs(w)<fp_tolerance: |
| w = ctx.siegelz(b) |
| else: |
| w=ctx.siegelz(b) |
| if v*w<0: |
| variations += 1 |
| newT.append(b) |
| newV.append(w) |
| u = V[n] |
| if u*w <0: |
| variations += 1 |
| newT.append(b2) |
| newV.append(u) |
| a = b2 |
| v = u |
| T = newT |
| V = newV |
| loopnumber +=1 |
| if (limitloop>ITERATION_LIMIT)and(loopnumber>2)and(variations+2==zero_number_block): |
| dtMax=0 |
| dtSec=0 |
| kMax = 0 |
| for k1 in range(1,len(T)): |
| dt = T[k1]-T[k1-1] |
| if dt > dtMax: |
| kMax=k1 |
| dtSec = dtMax |
| dtMax = dt |
| elif (dt<dtMax) and(dt >dtSec): |
| dtSec = dt |
| if dtMax>3*dtSec: |
| f = lambda x: ctx.rs_z(x,derivative=1) |
| t0=T[kMax-1] |
| t1 = T[kMax] |
| t=ctx.findroot(f, (t0,t1), solver ='illinois',verify=False, verbose=False) |
| v = ctx.siegelz(t) |
| if (t0<t) and (t<t1) and (v*V[kMax]<0): |
| T.insert(kMax,t) |
| V.insert(kMax,v) |
| variations = count_variations(V) |
| if variations == zero_number_block: |
| separated = True |
| else: |
| separated = False |
| return (T,V, separated) |
|
|
| def separate_my_zero(ctx, my_zero_number, zero_number_block, T, V, prec): |
| """If we know which zero of this block is mine, |
| the function separates the zero""" |
| variations = 0 |
| v0 = V[0] |
| for k in range(1,len(V)): |
| v1 = V[k] |
| if v0*v1 < 0: |
| variations +=1 |
| if variations == my_zero_number: |
| k0 = k |
| leftv = v0 |
| rightv = v1 |
| v0 = v1 |
| t1 = T[k0] |
| t0 = T[k0-1] |
| ctx.prec = prec |
| wpz = wpzeros(my_zero_number*ctx.log(my_zero_number)) |
|
|
| guard = 4*ctx.mag(my_zero_number) |
| precs = [ctx.prec+4] |
| index=0 |
| while precs[0] > 2*wpz: |
| index +=1 |
| precs = [precs[0] // 2 +3+2*index] + precs |
| ctx.prec = precs[0] + guard |
| r = ctx.findroot(lambda x:ctx.siegelz(x), (t0,t1), solver ='illinois', verbose=False) |
| |
| z=ctx.mpc(0.5,r) |
| for prec in precs[1:]: |
| ctx.prec = prec + guard |
| |
| znew = z - ctx.zeta(z) / ctx.zeta(z, derivative=1) |
| |
| z=ctx.mpc(0.5,ctx.im(znew)) |
| return ctx.im(z) |
|
|
| def sure_number_block(ctx, n): |
| """The number of good Rosser blocks needed to apply |
| Turing method |
| References: |
| R. P. Brent, On the Zeros of the Riemann Zeta Function |
| in the Critical Strip, Math. Comp. 33 (1979) 1361--1372 |
| T. Trudgian, Improvements to Turing Method, Math. Comp.""" |
| if n < 9*10**5: |
| return(2) |
| g = ctx.grampoint(n-100) |
| lg = ctx._fp.ln(g) |
| brent = 0.0061 * lg**2 +0.08*lg |
| trudgian = 0.0031 * lg**2 +0.11*lg |
| N = ctx.ceil(min(brent,trudgian)) |
| N = int(N) |
| return N |
|
|
| def compute_triple_tvb(ctx, n): |
| t = ctx.grampoint(n) |
| v = ctx._fp.siegelz(t) |
| if ctx.mag(abs(v))<ctx.mag(t)-45: |
| v = ctx.siegelz(t) |
| b = v*(-1)**n |
| return t,v,b |
|
|
|
|
|
|
| ITERATION_LIMIT = 4 |
|
|
| def search_supergood_block(ctx, n, fp_tolerance): |
| """To use for n>400 000 000""" |
| sb = sure_number_block(ctx, n) |
| number_goodblocks = 0 |
| m2 = n-1 |
| t, v, b = compute_triple_tvb(ctx, m2) |
| Tf = [t] |
| Vf = [v] |
| while b < 0: |
| m2 += 1 |
| t,v,b = compute_triple_tvb(ctx, m2) |
| Tf.append(t) |
| Vf.append(v) |
| goodpoints = [m2] |
| T = [t] |
| V = [v] |
| while number_goodblocks < 2*sb: |
| m2 += 1 |
| t, v, b = compute_triple_tvb(ctx, m2) |
| T.append(t) |
| V.append(v) |
| while b < 0: |
| m2 += 1 |
| t,v,b = compute_triple_tvb(ctx, m2) |
| T.append(t) |
| V.append(v) |
| goodpoints.append(m2) |
| zn = len(T)-1 |
| A, B, separated =\ |
| separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT, |
| fp_tolerance=fp_tolerance) |
| Tf.pop() |
| Tf.extend(A) |
| Vf.pop() |
| Vf.extend(B) |
| if separated: |
| number_goodblocks += 1 |
| else: |
| number_goodblocks = 0 |
| T = [t] |
| V = [v] |
| |
| number_goodblocks = 0 |
| m2 = n-2 |
| t, v, b = compute_triple_tvb(ctx, m2) |
| Tf.insert(0,t) |
| Vf.insert(0,v) |
| while b < 0: |
| m2 -= 1 |
| t,v,b = compute_triple_tvb(ctx, m2) |
| Tf.insert(0,t) |
| Vf.insert(0,v) |
| goodpoints.insert(0,m2) |
| T = [t] |
| V = [v] |
| while number_goodblocks < 2*sb: |
| m2 -= 1 |
| t, v, b = compute_triple_tvb(ctx, m2) |
| T.insert(0,t) |
| V.insert(0,v) |
| while b < 0: |
| m2 -= 1 |
| t,v,b = compute_triple_tvb(ctx, m2) |
| T.insert(0,t) |
| V.insert(0,v) |
| goodpoints.insert(0,m2) |
| zn = len(T)-1 |
| A, B, separated =\ |
| separate_zeros_in_block(ctx, zn, T, V, limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance) |
| A.pop() |
| Tf = A+Tf |
| B.pop() |
| Vf = B+Vf |
| if separated: |
| number_goodblocks += 1 |
| else: |
| number_goodblocks = 0 |
| T = [t] |
| V = [v] |
| r = goodpoints[2*sb] |
| lg = len(goodpoints) |
| s = goodpoints[lg-2*sb-1] |
| tr, vr, br = compute_triple_tvb(ctx, r) |
| ar = Tf.index(tr) |
| ts, vs, bs = compute_triple_tvb(ctx, s) |
| as1 = Tf.index(ts) |
| T = Tf[ar:as1+1] |
| V = Vf[ar:as1+1] |
| zn = s-r |
| A, B, separated =\ |
| separate_zeros_in_block(ctx, zn,T,V,limitloop=ITERATION_LIMIT, fp_tolerance=fp_tolerance) |
| if separated: |
| return (n-r-1,[r,s],A,B) |
| q = goodpoints[sb] |
| lg = len(goodpoints) |
| t = goodpoints[lg-sb-1] |
| tq, vq, bq = compute_triple_tvb(ctx, q) |
| aq = Tf.index(tq) |
| tt, vt, bt = compute_triple_tvb(ctx, t) |
| at = Tf.index(tt) |
| T = Tf[aq:at+1] |
| V = Vf[aq:at+1] |
| return (n-q-1,[q,t],T,V) |
|
|
| def count_variations(V): |
| count = 0 |
| vold = V[0] |
| for n in range(1, len(V)): |
| vnew = V[n] |
| if vold*vnew < 0: |
| count +=1 |
| vold = vnew |
| return count |
|
|
| def pattern_construct(ctx, block, T, V): |
| pattern = '(' |
| a = block[0] |
| b = block[1] |
| t0,v0,b0 = compute_triple_tvb(ctx, a) |
| k = 0 |
| k0 = 0 |
| for n in range(a+1,b+1): |
| t1,v1,b1 = compute_triple_tvb(ctx, n) |
| lgT =len(T) |
| while (k < lgT) and (T[k] <= t1): |
| k += 1 |
| L = V[k0:k] |
| L.append(v1) |
| L.insert(0,v0) |
| count = count_variations(L) |
| pattern = pattern + ("%s" % count) |
| if b1 > 0: |
| pattern = pattern + ')(' |
| k0 = k |
| t0,v0,b0 = t1,v1,b1 |
| pattern = pattern[:-1] |
| return pattern |
|
|
| @defun |
| def zetazero(ctx, n, info=False, round=True): |
| r""" |
| Computes the `n`-th nontrivial zero of `\zeta(s)` on the critical line, |
| i.e. returns an approximation of the `n`-th largest complex number |
| `s = \frac{1}{2} + ti` for which `\zeta(s) = 0`. Equivalently, the |
| imaginary part `t` is a zero of the Z-function (:func:`~mpmath.siegelz`). |
| |
| **Examples** |
| |
| The first few zeros:: |
| |
| >>> from mpmath import * |
| >>> mp.dps = 25; mp.pretty = True |
| >>> zetazero(1) |
| (0.5 + 14.13472514173469379045725j) |
| >>> zetazero(2) |
| (0.5 + 21.02203963877155499262848j) |
| >>> zetazero(20) |
| (0.5 + 77.14484006887480537268266j) |
| |
| Verifying that the values are zeros:: |
| |
| >>> for n in range(1,5): |
| ... s = zetazero(n) |
| ... chop(zeta(s)), chop(siegelz(s.imag)) |
| ... |
| (0.0, 0.0) |
| (0.0, 0.0) |
| (0.0, 0.0) |
| (0.0, 0.0) |
| |
| Negative indices give the conjugate zeros (`n = 0` is undefined):: |
| |
| >>> zetazero(-1) |
| (0.5 - 14.13472514173469379045725j) |
| |
| :func:`~mpmath.zetazero` supports arbitrarily large `n` and arbitrary precision:: |
| |
| >>> mp.dps = 15 |
| >>> zetazero(1234567) |
| (0.5 + 727690.906948208j) |
| >>> mp.dps = 50 |
| >>> zetazero(1234567) |
| (0.5 + 727690.9069482075392389420041147142092708393819935j) |
| >>> chop(zeta(_)/_) |
| 0.0 |
| |
| with *info=True*, :func:`~mpmath.zetazero` gives additional information:: |
| |
| >>> mp.dps = 15 |
| >>> zetazero(542964976,info=True) |
| ((0.5 + 209039046.578535j), [542964969, 542964978], 6, '(013111110)') |
| |
| This means that the zero is between Gram points 542964969 and 542964978; |
| it is the 6-th zero between them. Finally (01311110) is the pattern |
| of zeros in this interval. The numbers indicate the number of zeros |
| in each Gram interval (Rosser blocks between parenthesis). In this case |
| there is only one Rosser block of length nine. |
| """ |
| n = int(n) |
| if n < 0: |
| return ctx.zetazero(-n).conjugate() |
| if n == 0: |
| raise ValueError("n must be nonzero") |
| wpinitial = ctx.prec |
| try: |
| wpz, fp_tolerance = comp_fp_tolerance(ctx, n) |
| ctx.prec = wpz |
| if n < 400000000: |
| my_zero_number, block, T, V =\ |
| find_rosser_block_zero(ctx, n) |
| else: |
| my_zero_number, block, T, V =\ |
| search_supergood_block(ctx, n, fp_tolerance) |
| zero_number_block = block[1]-block[0] |
| T, V, separated = separate_zeros_in_block(ctx, zero_number_block, T, V, |
| limitloop=ctx.inf, fp_tolerance=fp_tolerance) |
| if info: |
| pattern = pattern_construct(ctx,block,T,V) |
| prec = max(wpinitial, wpz) |
| t = separate_my_zero(ctx, my_zero_number, zero_number_block,T,V,prec) |
| v = ctx.mpc(0.5,t) |
| finally: |
| ctx.prec = wpinitial |
| if round: |
| v =+v |
| if info: |
| return (v,block,my_zero_number,pattern) |
| else: |
| return v |
|
|
| def gram_index(ctx, t): |
| if t > 10**13: |
| wp = 3*ctx.log(t, 10) |
| else: |
| wp = 0 |
| prec = ctx.prec |
| try: |
| ctx.prec += wp |
| h = int(ctx.siegeltheta(t)/ctx.pi) |
| finally: |
| ctx.prec = prec |
| return(h) |
|
|
| def count_to(ctx, t, T, V): |
| count = 0 |
| vold = V[0] |
| told = T[0] |
| tnew = T[1] |
| k = 1 |
| while tnew < t: |
| vnew = V[k] |
| if vold*vnew < 0: |
| count += 1 |
| vold = vnew |
| k += 1 |
| tnew = T[k] |
| a = ctx.siegelz(t) |
| if a*vold < 0: |
| count += 1 |
| return count |
|
|
| def comp_fp_tolerance(ctx, n): |
| wpz = wpzeros(n*ctx.log(n)) |
| if n < 15*10**8: |
| fp_tolerance = 0.0005 |
| elif n <= 10**14: |
| fp_tolerance = 0.1 |
| else: |
| fp_tolerance = 100 |
| return wpz, fp_tolerance |
|
|
| @defun |
| def nzeros(ctx, t): |
| r""" |
| Computes the number of zeros of the Riemann zeta function in |
| `(0,1) \times (0,t]`, usually denoted by `N(t)`. |
| |
| **Examples** |
| |
| The first zero has imaginary part between 14 and 15:: |
| |
| >>> from mpmath import * |
| >>> mp.dps = 15; mp.pretty = True |
| >>> nzeros(14) |
| 0 |
| >>> nzeros(15) |
| 1 |
| >>> zetazero(1) |
| (0.5 + 14.1347251417347j) |
| |
| Some closely spaced zeros:: |
| |
| >>> nzeros(10**7) |
| 21136125 |
| >>> zetazero(21136125) |
| (0.5 + 9999999.32718175j) |
| >>> zetazero(21136126) |
| (0.5 + 10000000.2400236j) |
| >>> nzeros(545439823.215) |
| 1500000001 |
| >>> zetazero(1500000001) |
| (0.5 + 545439823.201985j) |
| >>> zetazero(1500000002) |
| (0.5 + 545439823.325697j) |
| |
| This confirms the data given by J. van de Lune, |
| H. J. J. te Riele and D. T. Winter in 1986. |
| """ |
| if t < 14.1347251417347: |
| return 0 |
| x = gram_index(ctx, t) |
| k = int(ctx.floor(x)) |
| wpinitial = ctx.prec |
| wpz, fp_tolerance = comp_fp_tolerance(ctx, k) |
| ctx.prec = wpz |
| a = ctx.siegelz(t) |
| if k == -1 and a < 0: |
| return 0 |
| elif k == -1 and a > 0: |
| return 1 |
| if k+2 < 400000000: |
| Rblock = find_rosser_block_zero(ctx, k+2) |
| else: |
| Rblock = search_supergood_block(ctx, k+2, fp_tolerance) |
| n1, n2 = Rblock[1] |
| if n2-n1 == 1: |
| b = Rblock[3][0] |
| if a*b > 0: |
| ctx.prec = wpinitial |
| return k+1 |
| else: |
| ctx.prec = wpinitial |
| return k+2 |
| my_zero_number,block, T, V = Rblock |
| zero_number_block = n2-n1 |
| T, V, separated = separate_zeros_in_block(ctx,\ |
| zero_number_block, T, V,\ |
| limitloop=ctx.inf,\ |
| fp_tolerance=fp_tolerance) |
| n = count_to(ctx, t, T, V) |
| ctx.prec = wpinitial |
| return n+n1+1 |
|
|
| @defun_wrapped |
| def backlunds(ctx, t): |
| r""" |
| Computes the function |
| `S(t) = \operatorname{arg} \zeta(\frac{1}{2} + it) / \pi`. |
| |
| See Titchmarsh Section 9.3 for details of the definition. |
| |
| **Examples** |
| |
| >>> from mpmath import * |
| >>> mp.dps = 15; mp.pretty = True |
| >>> backlunds(217.3) |
| 0.16302205431184 |
| |
| Generally, the value is a small number. At Gram points it is an integer, |
| frequently equal to 0:: |
| |
| >>> chop(backlunds(grampoint(200))) |
| 0.0 |
| >>> backlunds(extraprec(10)(grampoint)(211)) |
| 1.0 |
| >>> backlunds(extraprec(10)(grampoint)(232)) |
| -1.0 |
| |
| The number of zeros of the Riemann zeta function up to height `t` |
| satisfies `N(t) = \theta(t)/\pi + 1 + S(t)` (see :func:nzeros` and |
| :func:`siegeltheta`):: |
| |
| >>> t = 1234.55 |
| >>> nzeros(t) |
| 842 |
| >>> siegeltheta(t)/pi+1+backlunds(t) |
| 842.0 |
| |
| """ |
| return ctx.nzeros(t)-1-ctx.siegeltheta(t)/ctx.pi |
|
|
|
|
| """ |
| _ROSSER_EXCEPTIONS is a list of all exceptions to |
| Rosser's rule for n <= 400 000 000. |
| |
| Alternately the entry is of type [n,m], or a string. |
| The string is the zero pattern of the Block and the relevant |
| adjacent. For example (010)3 corresponds to a block |
| composed of three Gram intervals, the first ant third without |
| a zero and the intermediate with a zero. The next Gram interval |
| contain three zeros. So that in total we have 4 zeros in 4 Gram |
| blocks. n and m are the indices of the Gram points of this |
| interval of four Gram intervals. The Rosser exception is therefore |
| formed by the three Gram intervals that are signaled between |
| parenthesis. |
| |
| We have included also some Rosser's exceptions beyond n=400 000 000 |
| that are noted in the literature by some reason. |
| |
| The list is composed from the data published in the references: |
| |
| R. P. Brent, J. van de Lune, H. J. J. te Riele, D. T. Winter, |
| 'On the Zeros of the Riemann Zeta Function in the Critical Strip. II', |
| Math. Comp. 39 (1982) 681--688. |
| See also Corrigenda in Math. Comp. 46 (1986) 771. |
| |
| J. van de Lune, H. J. J. te Riele, |
| 'On the Zeros of the Riemann Zeta Function in the Critical Strip. III', |
| Math. Comp. 41 (1983) 759--767. |
| See also Corrigenda in Math. Comp. 46 (1986) 771. |
| |
| J. van de Lune, |
| 'Sums of Equal Powers of Positive Integers', |
| Dissertation, |
| Vrije Universiteit te Amsterdam, Centrum voor Wiskunde en Informatica, |
| Amsterdam, 1984. |
| |
| Thanks to the authors all this papers and those others that have |
| contributed to make this possible. |
| """ |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| _ROSSER_EXCEPTIONS = \ |
| [[13999525, 13999528], '(00)3', |
| [30783329, 30783332], '(00)3', |
| [30930926, 30930929], '3(00)', |
| [37592215, 37592218], '(00)3', |
| [40870156, 40870159], '(00)3', |
| [43628107, 43628110], '(00)3', |
| [46082042, 46082045], '(00)3', |
| [46875667, 46875670], '(00)3', |
| [49624540, 49624543], '3(00)', |
| [50799238, 50799241], '(00)3', |
| [55221453, 55221456], '3(00)', |
| [56948779, 56948782], '3(00)', |
| [60515663, 60515666], '(00)3', |
| [61331766, 61331770], '(00)40', |
| [69784843, 69784846], '3(00)', |
| [75052114, 75052117], '(00)3', |
| [79545240, 79545243], '3(00)', |
| [79652247, 79652250], '3(00)', |
| [83088043, 83088046], '(00)3', |
| [83689522, 83689525], '3(00)', |
| [85348958, 85348961], '(00)3', |
| [86513820, 86513823], '(00)3', |
| [87947596, 87947599], '3(00)', |
| [88600095, 88600098], '(00)3', |
| [93681183, 93681186], '(00)3', |
| [100316551, 100316554], '3(00)', |
| [100788444, 100788447], '(00)3', |
| [106236172, 106236175], '(00)3', |
| [106941327, 106941330], '3(00)', |
| [107287955, 107287958], '(00)3', |
| [107532016, 107532019], '3(00)', |
| [110571044, 110571047], '(00)3', |
| [111885253, 111885256], '3(00)', |
| [113239783, 113239786], '(00)3', |
| [120159903, 120159906], '(00)3', |
| [121424391, 121424394], '3(00)', |
| [121692931, 121692934], '3(00)', |
| [121934170, 121934173], '3(00)', |
| [122612848, 122612851], '3(00)', |
| [126116567, 126116570], '(00)3', |
| [127936513, 127936516], '(00)3', |
| [128710277, 128710280], '3(00)', |
| [129398902, 129398905], '3(00)', |
| [130461096, 130461099], '3(00)', |
| [131331947, 131331950], '3(00)', |
| [137334071, 137334074], '3(00)', |
| [137832603, 137832606], '(00)3', |
| [138799471, 138799474], '3(00)', |
| [139027791, 139027794], '(00)3', |
| [141617806, 141617809], '(00)3', |
| [144454931, 144454934], '(00)3', |
| [145402379, 145402382], '3(00)', |
| [146130245, 146130248], '3(00)', |
| [147059770, 147059773], '(00)3', |
| [147896099, 147896102], '3(00)', |
| [151097113, 151097116], '(00)3', |
| [152539438, 152539441], '(00)3', |
| [152863168, 152863171], '3(00)', |
| [153522726, 153522729], '3(00)', |
| [155171524, 155171527], '3(00)', |
| [155366607, 155366610], '(00)3', |
| [157260686, 157260689], '3(00)', |
| [157269224, 157269227], '(00)3', |
| [157755123, 157755126], '(00)3', |
| [158298484, 158298487], '3(00)', |
| [160369050, 160369053], '3(00)', |
| [162962787, 162962790], '(00)3', |
| [163724709, 163724712], '(00)3', |
| [164198113, 164198116], '3(00)', |
| [164689301, 164689305], '(00)40', |
| [164880228, 164880231], '3(00)', |
| [166201932, 166201935], '(00)3', |
| [168573836, 168573839], '(00)3', |
| [169750763, 169750766], '(00)3', |
| [170375507, 170375510], '(00)3', |
| [170704879, 170704882], '3(00)', |
| [172000992, 172000995], '3(00)', |
| [173289941, 173289944], '(00)3', |
| [173737613, 173737616], '3(00)', |
| [174102513, 174102516], '(00)3', |
| [174284990, 174284993], '(00)3', |
| [174500513, 174500516], '(00)3', |
| [175710609, 175710612], '(00)3', |
| [176870843, 176870846], '3(00)', |
| [177332732, 177332735], '3(00)', |
| [177902861, 177902864], '3(00)', |
| [179979095, 179979098], '(00)3', |
| [181233726, 181233729], '3(00)', |
| [181625435, 181625438], '(00)3', |
| [182105255, 182105259], '22(00)', |
| [182223559, 182223562], '3(00)', |
| [191116404, 191116407], '3(00)', |
| [191165599, 191165602], '3(00)', |
| [191297535, 191297539], '(00)22', |
| [192485616, 192485619], '(00)3', |
| [193264634, 193264638], '22(00)', |
| [194696968, 194696971], '(00)3', |
| [195876805, 195876808], '(00)3', |
| [195916548, 195916551], '3(00)', |
| [196395160, 196395163], '3(00)', |
| [196676303, 196676306], '(00)3', |
| [197889882, 197889885], '3(00)', |
| [198014122, 198014125], '(00)3', |
| [199235289, 199235292], '(00)3', |
| [201007375, 201007378], '(00)3', |
| [201030605, 201030608], '3(00)', |
| [201184290, 201184293], '3(00)', |
| [201685414, 201685418], '(00)22', |
| [202762875, 202762878], '3(00)', |
| [202860957, 202860960], '3(00)', |
| [203832577, 203832580], '3(00)', |
| [205880544, 205880547], '(00)3', |
| [206357111, 206357114], '(00)3', |
| [207159767, 207159770], '3(00)', |
| [207167343, 207167346], '3(00)', |
| [207482539, 207482543], '3(010)', |
| [207669540, 207669543], '3(00)', |
| [208053426, 208053429], '(00)3', |
| [208110027, 208110030], '3(00)', |
| [209513826, 209513829], '3(00)', |
| [212623522, 212623525], '(00)3', |
| [213841715, 213841718], '(00)3', |
| [214012333, 214012336], '(00)3', |
| [214073567, 214073570], '(00)3', |
| [215170600, 215170603], '3(00)', |
| [215881039, 215881042], '3(00)', |
| [216274604, 216274607], '3(00)', |
| [216957120, 216957123], '3(00)', |
| [217323208, 217323211], '(00)3', |
| [218799264, 218799267], '(00)3', |
| [218803557, 218803560], '3(00)', |
| [219735146, 219735149], '(00)3', |
| [219830062, 219830065], '3(00)', |
| [219897904, 219897907], '(00)3', |
| [221205545, 221205548], '(00)3', |
| [223601929, 223601932], '(00)3', |
| [223907076, 223907079], '3(00)', |
| [223970397, 223970400], '(00)3', |
| [224874044, 224874048], '22(00)', |
| [225291157, 225291160], '(00)3', |
| [227481734, 227481737], '(00)3', |
| [228006442, 228006445], '3(00)', |
| [228357900, 228357903], '(00)3', |
| [228386399, 228386402], '(00)3', |
| [228907446, 228907449], '(00)3', |
| [228984552, 228984555], '3(00)', |
| [229140285, 229140288], '3(00)', |
| [231810024, 231810027], '(00)3', |
| [232838062, 232838065], '3(00)', |
| [234389088, 234389091], '3(00)', |
| [235588194, 235588197], '(00)3', |
| [236645695, 236645698], '(00)3', |
| [236962876, 236962879], '3(00)', |
| [237516723, 237516727], '04(00)', |
| [240004911, 240004914], '(00)3', |
| [240221306, 240221309], '3(00)', |
| [241389213, 241389217], '(010)3', |
| [241549003, 241549006], '(00)3', |
| [241729717, 241729720], '(00)3', |
| [241743684, 241743687], '3(00)', |
| [243780200, 243780203], '3(00)', |
| [243801317, 243801320], '(00)3', |
| [244122072, 244122075], '(00)3', |
| [244691224, 244691227], '3(00)', |
| [244841577, 244841580], '(00)3', |
| [245813461, 245813464], '(00)3', |
| [246299475, 246299478], '(00)3', |
| [246450176, 246450179], '3(00)', |
| [249069349, 249069352], '(00)3', |
| [250076378, 250076381], '(00)3', |
| [252442157, 252442160], '3(00)', |
| [252904231, 252904234], '3(00)', |
| [255145220, 255145223], '(00)3', |
| [255285971, 255285974], '3(00)', |
| [256713230, 256713233], '(00)3', |
| [257992082, 257992085], '(00)3', |
| [258447955, 258447959], '22(00)', |
| [259298045, 259298048], '3(00)', |
| [262141503, 262141506], '(00)3', |
| [263681743, 263681746], '3(00)', |
| [266527881, 266527885], '(010)3', |
| [266617122, 266617125], '(00)3', |
| [266628044, 266628047], '3(00)', |
| [267305763, 267305766], '(00)3', |
| [267388404, 267388407], '3(00)', |
| [267441672, 267441675], '3(00)', |
| [267464886, 267464889], '(00)3', |
| [267554907, 267554910], '3(00)', |
| [269787480, 269787483], '(00)3', |
| [270881434, 270881437], '(00)3', |
| [270997583, 270997586], '3(00)', |
| [272096378, 272096381], '3(00)', |
| [272583009, 272583012], '(00)3', |
| [274190881, 274190884], '3(00)', |
| [274268747, 274268750], '(00)3', |
| [275297429, 275297432], '3(00)', |
| [275545476, 275545479], '3(00)', |
| [275898479, 275898482], '3(00)', |
| [275953000, 275953003], '(00)3', |
| [277117197, 277117201], '(00)22', |
| [277447310, 277447313], '3(00)', |
| [279059657, 279059660], '3(00)', |
| [279259144, 279259147], '3(00)', |
| [279513636, 279513639], '3(00)', |
| [279849069, 279849072], '3(00)', |
| [280291419, 280291422], '(00)3', |
| [281449425, 281449428], '3(00)', |
| [281507953, 281507956], '3(00)', |
| [281825600, 281825603], '(00)3', |
| [282547093, 282547096], '3(00)', |
| [283120963, 283120966], '3(00)', |
| [283323493, 283323496], '(00)3', |
| [284764535, 284764538], '3(00)', |
| [286172639, 286172642], '3(00)', |
| [286688824, 286688827], '(00)3', |
| [287222172, 287222175], '3(00)', |
| [287235534, 287235537], '3(00)', |
| [287304861, 287304864], '3(00)', |
| [287433571, 287433574], '(00)3', |
| [287823551, 287823554], '(00)3', |
| [287872422, 287872425], '3(00)', |
| [288766615, 288766618], '3(00)', |
| [290122963, 290122966], '3(00)', |
| [290450849, 290450853], '(00)22', |
| [291426141, 291426144], '3(00)', |
| [292810353, 292810356], '3(00)', |
| [293109861, 293109864], '3(00)', |
| [293398054, 293398057], '3(00)', |
| [294134426, 294134429], '3(00)', |
| [294216438, 294216441], '(00)3', |
| [295367141, 295367144], '3(00)', |
| [297834111, 297834114], '3(00)', |
| [299099969, 299099972], '3(00)', |
| [300746958, 300746961], '3(00)', |
| [301097423, 301097426], '(00)3', |
| [301834209, 301834212], '(00)3', |
| [302554791, 302554794], '(00)3', |
| [303497445, 303497448], '3(00)', |
| [304165344, 304165347], '3(00)', |
| [304790218, 304790222], '3(010)', |
| [305302352, 305302355], '(00)3', |
| [306785996, 306785999], '3(00)', |
| [307051443, 307051446], '3(00)', |
| [307481539, 307481542], '3(00)', |
| [308605569, 308605572], '3(00)', |
| [309237610, 309237613], '3(00)', |
| [310509287, 310509290], '(00)3', |
| [310554057, 310554060], '3(00)', |
| [310646345, 310646348], '3(00)', |
| [311274896, 311274899], '(00)3', |
| [311894272, 311894275], '3(00)', |
| [312269470, 312269473], '(00)3', |
| [312306601, 312306605], '(00)40', |
| [312683193, 312683196], '3(00)', |
| [314499804, 314499807], '3(00)', |
| [314636802, 314636805], '(00)3', |
| [314689897, 314689900], '3(00)', |
| [314721319, 314721322], '3(00)', |
| [316132890, 316132893], '3(00)', |
| [316217470, 316217474], '(010)3', |
| [316465705, 316465708], '3(00)', |
| [316542790, 316542793], '(00)3', |
| [320822347, 320822350], '3(00)', |
| [321733242, 321733245], '3(00)', |
| [324413970, 324413973], '(00)3', |
| [325950140, 325950143], '(00)3', |
| [326675884, 326675887], '(00)3', |
| [326704208, 326704211], '3(00)', |
| [327596247, 327596250], '3(00)', |
| [328123172, 328123175], '3(00)', |
| [328182212, 328182215], '(00)3', |
| [328257498, 328257501], '3(00)', |
| [328315836, 328315839], '(00)3', |
| [328800974, 328800977], '(00)3', |
| [328998509, 328998512], '3(00)', |
| [329725370, 329725373], '(00)3', |
| [332080601, 332080604], '(00)3', |
| [332221246, 332221249], '(00)3', |
| [332299899, 332299902], '(00)3', |
| [332532822, 332532825], '(00)3', |
| [333334544, 333334548], '(00)22', |
| [333881266, 333881269], '3(00)', |
| [334703267, 334703270], '3(00)', |
| [334875138, 334875141], '3(00)', |
| [336531451, 336531454], '3(00)', |
| [336825907, 336825910], '(00)3', |
| [336993167, 336993170], '(00)3', |
| [337493998, 337494001], '3(00)', |
| [337861034, 337861037], '3(00)', |
| [337899191, 337899194], '(00)3', |
| [337958123, 337958126], '(00)3', |
| [342331982, 342331985], '3(00)', |
| [342676068, 342676071], '3(00)', |
| [347063781, 347063784], '3(00)', |
| [347697348, 347697351], '3(00)', |
| [347954319, 347954322], '3(00)', |
| [348162775, 348162778], '3(00)', |
| [349210702, 349210705], '(00)3', |
| [349212913, 349212916], '3(00)', |
| [349248650, 349248653], '(00)3', |
| [349913500, 349913503], '3(00)', |
| [350891529, 350891532], '3(00)', |
| [351089323, 351089326], '3(00)', |
| [351826158, 351826161], '3(00)', |
| [352228580, 352228583], '(00)3', |
| [352376244, 352376247], '3(00)', |
| [352853758, 352853761], '(00)3', |
| [355110439, 355110442], '(00)3', |
| [355808090, 355808094], '(00)40', |
| [355941556, 355941559], '3(00)', |
| [356360231, 356360234], '(00)3', |
| [356586657, 356586660], '3(00)', |
| [356892926, 356892929], '(00)3', |
| [356908232, 356908235], '3(00)', |
| [357912730, 357912733], '3(00)', |
| [358120344, 358120347], '3(00)', |
| [359044096, 359044099], '(00)3', |
| [360819357, 360819360], '3(00)', |
| [361399662, 361399666], '(010)3', |
| [362361315, 362361318], '(00)3', |
| [363610112, 363610115], '(00)3', |
| [363964804, 363964807], '3(00)', |
| [364527375, 364527378], '(00)3', |
| [365090327, 365090330], '(00)3', |
| [365414539, 365414542], '3(00)', |
| [366738474, 366738477], '3(00)', |
| [368714778, 368714783], '04(010)', |
| [368831545, 368831548], '(00)3', |
| [368902387, 368902390], '(00)3', |
| [370109769, 370109772], '3(00)', |
| [370963333, 370963336], '3(00)', |
| [372541136, 372541140], '3(010)', |
| [372681562, 372681565], '(00)3', |
| [373009410, 373009413], '(00)3', |
| [373458970, 373458973], '3(00)', |
| [375648658, 375648661], '3(00)', |
| [376834728, 376834731], '3(00)', |
| [377119945, 377119948], '(00)3', |
| [377335703, 377335706], '(00)3', |
| [378091745, 378091748], '3(00)', |
| [379139522, 379139525], '3(00)', |
| [380279160, 380279163], '(00)3', |
| [380619442, 380619445], '3(00)', |
| [381244231, 381244234], '3(00)', |
| [382327446, 382327450], '(010)3', |
| [382357073, 382357076], '3(00)', |
| [383545479, 383545482], '3(00)', |
| [384363766, 384363769], '(00)3', |
| [384401786, 384401790], '22(00)', |
| [385198212, 385198215], '3(00)', |
| [385824476, 385824479], '(00)3', |
| [385908194, 385908197], '3(00)', |
| [386946806, 386946809], '3(00)', |
| [387592175, 387592179], '22(00)', |
| [388329293, 388329296], '(00)3', |
| [388679566, 388679569], '3(00)', |
| [388832142, 388832145], '3(00)', |
| [390087103, 390087106], '(00)3', |
| [390190926, 390190930], '(00)22', |
| [390331207, 390331210], '3(00)', |
| [391674495, 391674498], '3(00)', |
| [391937831, 391937834], '3(00)', |
| [391951632, 391951636], '(00)22', |
| [392963986, 392963989], '(00)3', |
| [393007921, 393007924], '3(00)', |
| [393373210, 393373213], '3(00)', |
| [393759572, 393759575], '(00)3', |
| [394036662, 394036665], '(00)3', |
| [395813866, 395813869], '(00)3', |
| [395956690, 395956693], '3(00)', |
| [396031670, 396031673], '3(00)', |
| [397076433, 397076436], '3(00)', |
| [397470601, 397470604], '3(00)', |
| [398289458, 398289461], '3(00)', |
| |
| [368714778, 368714783], '04(010)', |
| [437953499, 437953504], '04(010)', |
| [526196233, 526196238], '032(00)', |
| [744719566, 744719571], '(010)40', |
| [750375857, 750375862], '032(00)', |
| [958241932, 958241937], '04(010)', |
| [983377342, 983377347], '(00)410', |
| [1003780080, 1003780085], '04(010)', |
| [1070232754, 1070232759], '(00)230', |
| [1209834865, 1209834870], '032(00)', |
| [1257209100, 1257209105], '(00)410', |
| [1368002233, 1368002238], '(00)230' |
| ] |
|
|
