dong report

8/3/2019 Dong Report

1/25

Generating strong prime numbers for RSA using probabilistic Rabin-Miller algorithm

An integer p > 1 is called a prime number in case there is no divisor d of p satisfying 1 < d < p. Ifan integer a > 1 is not a prime, it is called a composite number.

Characteristics of primes

Every integer n greater than 1 can be expressed as a product of primes (with perhaps only onefactor).

There are arbitrarily large gaps in the series of primes. The number of primes is infinite. That is, there is no end to the sequence of primes. The factoring of any integer n > 1 into primes is unique apart from the order of the prime

factors.

The RSA cryptographic algorithm uses a lot of prime numbers in generating its keys. These keysin turn will hold the strength of the encryption. In this paper I will discuss how a large number oflarge primes can be generated.

Public-key algorithms need prime numbers. Any reasonably sized network needs lots of them.Before discussing the mathematics of prime number generation, some of common questions areanswered.

1.If everyone needs a different prime number, wont we run out? No. In fact, there areapproximately 10151 primes 512-bits in length or less. For numbers near n, the probability that arandom number is prime is approximately one in ln n. So the total number of primes less that n isn/(ln n).

2.What if two people accidentally pick up the same prime number? It wont happen. With over10151 prime numbers to choose from, the odds of that happening are significantly less than theodds of your computer spontaneously combusting at the exact moment you win the lottery.

3.If someone creates a database of all primes, wont he be able to use that database to breakpublic-key algorithms? Yes, but he cant do it. If you could store one gigabyte of information ona drive weighing one gram, then a list of just the 512-bit primes would weight so much that itwould exceed the Chandrasekhar limit and collapse into a black hole &ldots; so you couldntretrieve the data anyway.

There are several probabilistic primality tests; tests that determine whether a number is prime

with a given degree of confidence. Assuming this "degree of confidence" is large enough, thesesorts of tests are good enough.

Various probabilistic primality-testing algorithms include:

Rabin-Miller Test Lucas-Lehmer Algorithm Fermats Test


2/25

Frobenius-GranthamThe algorithm everyone uses was developed by Michael Rabin, based in part on Gary Millersideas. Actually, this is a simplified version of the algorithm recommended in the DSS proposal.Therefore, we start out with Rabin-Miller algorithm.


3/25

Rabin Miller Algorithm

Rabin-Miller algorithm has following characteristics

Uses exponentiations mod p to declare that p is probably prime Each iteration has worst case failure rate of ()^c For randomly selected large numbers this failure rate is much lower One can construct numbers which achieve worst caseAlgorithm

Input : an odd integer n >= 3 and number of iterations t >= 1Output : Prime or Composite

1. Write n 1 = 2sr such that r is odd2. For i from 1 to t do the following

2.1Choose a random integer a, 2


4/25

Millers Test. Let n 1 = 2rm where r 1 and m is odd. Let gcd(b, n) = 1.If either bm (mod n) or b2^k - 1 (mod n) for some k r, then, we say that n passes MillersTest to base b.

All primes p pass Miller's Test for 1


5/25

Lucas Test(Lucas Pseduoprimes)

We state that a number passes Lucas Test with parameter (P,Q) if it passes the algorithmillustrated below with p and q satisfies D = p2 4q. Here we used Lucas Test with parameterLucas(1, Q). D is determined by finding a number that satisfies (D/n) = -1 in {5, -7, 9, -11, 13, -15, 17. } Although theoretically, we can spend infinite time looking for D that satisfies this(as

with n = 9), based on the experiment, we found out that D is mostly single or two decimaldigits(most of time, D is in {5, -7, 9, -11, -13, 15, -17, 19} Therefore, time spent looking for Dwas not significant.

Input:

n large odd number tested for primality,

Output:

composite or probably prime

Operations:

1. Find first din the sequence {5, 7, 9, 11, 13, 15, 17, } such that the Jacobi symbol (d/n)= 1.

2. Set p:=1, q:=(1d)/4.Ifun+1 = 0 mod n, then n is probably prime. To compute uk, where k=n+1 you need to performthe following operations.

3. Set d=(p2 4q) = 1 4q4. Let krkr-1k0 denote the binary representation of k5. Set u=1 and v:=p6. For i:=r1 to 0 do

6.1 Set (u, v) = (uv mod n, (v2+du2)*2-1 mod n)6.2 Ifki = 1 do

(u, v) = ((pu+v)* 2-1 mod n, (pv+du)* 2-1 mod n)7. uk=u, vk= v8. Ifuk= 0 mod n return probably prime,

otherwise return composite.

Experiment

Size of Number( in bits ) Lucas Test

130 0.125 sec

512 0.6 sec

1024 5 sec

2048 35 sec

When we applied Lucas Test to our test vectors that passed 20 iterations of Miller-Rabin, some ofthem were determined to be Composites. Here we show some list of 1024 bit numbers thatpassed Miller-Rabin(20 iterations) but didnt pass Lucas Test.

943663967303341733831073530494149595215288153105481870301659362295789602095234218089124597953290352035102845761871600763866437004412165477329142505789342618


6/25

91510827140267043592007225160798348913639472564715055445201512461359359488795427875530231001298552452230535485049737222714000227878890892901228389026881

138028649176899647846076023812164793645371887571371559091892986639999096471811910222267538577825033963552683101137782650479906670021895135954212738694784814783986671046107023185842481502719762055887490765764329237651328922972514308635

045190654896041748716218441926626988737664133219271115413563418353821396401

123301261697053560451930527879636974557474268923771832437126939266601921428796348203611050423256894847735769138870460373141723679005090549101566289920247264982095246187318303659027201708559916949810035265951104246512008259674244307851578647894027803356820480862664695522389066327012330793517771435385653616841

119432521682023078841121052226157857003721669633106050345198988740042219728400958282159638484144822421840470442893056822510584029066504295892189315912923804894933736660559950053226576719285711831138657839435060908151231090715952576998400120335346005544083959311246562842277496260598128781581003807229557518839

132082885240291678440073580124226578272473600569147812319294626601995619845059779715619475871419551319029519794232989255381829366374647864619189704922722431776563860747714706040922215308646535910589305924065089149684429555813953571007126408164577035854428632242206880193165045777949624510896312005014225526731

153410708946188157980279532372610756837706984448408515364579602515073276538040155990230789600191915021209039203172105094957316552912585741177975853552299222501069267567888742458519569317286299134843250075228359900070009684517875782331709619287588451883575354340318132216817231993558066067063143257425853927599

103130593592068072608023213244858971741946977638988649427937324034014356815504971087381663169829571046157738503075005527471064224791270584831779395959349442

093395294980019731027051356344056416276026592333932610954020105156667883269888206386119513058400355612571198438511950152690467372712488391425876725831041

It is known that Lucas Test is independent of Miller-Rabin test. Therefore by combining thesetwo algorithms, we present a powerful algorithm in the next section that utilizes one iteration ofMiller-Rabin with Lucas Test.(we also noticed that if the number passed a single iterations ofMiller-Rabin, its most likely to pass more iterations of Miller-Rabin - > Increasing Miller-Rabinincreases worst case probability of error; however, in practice, Miller-Rabin yields substantiallybetter probability of error(than worst case error) and each subsequent iteration improves thealgorithm moderately)


7/25

Lucas-Lehmer Test

Pomerance, Selfridge and Wagstaff have proposed a test, based on a combination of the StrongProbable Prime Test and the Lucas Probable Test, that seems very powerful. Indeed, nobody yetclaimed the $620 that they offer for a composite that passes it, even though they have relaxed theconditions of the offer so that the Probable Prime Test no longer need be Strong. In this

section, we present a test that combines Probable Prime Test(Miller Rabin test) and the LucasProbable Test.

MillerRabin test = new MillerRabin(a, 1);if (test.isPrime() == true) {

lt = new LucasTest(a);if (lt.isPrime()) System.out.println("prime1");

}

We measure a time taken by applying a single iteration of Miller-Rabin followed by Lucas Test.

Size of Number( in bits ) Lucas-Lehmer Test130 0.125 sec

512 0.72 sec

1024 6.12 sec

2048 40 sec


8/25

Grantham-Frobenius

This is a test based on Frobenius pseudoprimes developed by Grantham which is passed byComposite Numbers with probability at most 1/7710. Algorithm is presented below.

1. Choose pairs (b,c) at random with 1


9/25

Generating Prime Numbers

To generate n-bit prime, we first generate a random number of n-bit( 2^n+1 < x < 2^n ). Startingfrom that point, we implement either a sequential or random search. Here we present a sequentialapproach.

Algorithm consists of following

1. Generate an odd random number of n-bitx = one.shiftLeft( n ) // x = 2^n

//generate random number uniformly distributed on [0, 2**numBits - 1]rand_num = new BigInteger( n, rndSrc)x = x.add(rand_num)

//make sure its an odd numberif (x.testBit(0))

//ok

elsex = x.add( one )

2. Test for Primality3. If not prime, increment by two(or by random even number) and test for primality again

For primes of bit length n, mean gap distance is just ln(2^n) = n ln(2)Therefore on the average, for exhaustive search of odd numbers between two primes n* ln(2).But we note that since our starting point is random, we assume that on the average, we land in themiddle of two primes. Therefore, we need to check n*ln(2)/2 numbers on the average.

Here we do an experiment for 130, 256, 512, and 1024 bits

Number of Tests required(Theoretical)

n = 256 89n = 512 178n = 1024 355

bit(# of primes) 256 bit(20) 512 bit(2) 1024 bit(1)Time # Tested Time # Tested Time # Tested

MillerRabin(20) 35 1869 73 742 420 504

Lucas-Lehmer 43 2488 70 742 850 1175

Normalizing for single prime,

256 bit 512 bit 1024 bit

Time # Tested Time # Tested Time # Tested

MillerRabin(20) 1.75 94 36.5 371 210 504Lucas-Lehmer 2.15 125 35 371 425 1175

* were we very unlucky?(theoretical states that we need to check substantially less numbers)


10/25

In the code, we have a fixed seed for Random number generatorRandom rndSrc = new Random(5);

Therefore, each time we run the experiment, it generates same random number.So, why theres a discrepancy in number of Numbers tested to find primes? For 256 and 1024 bitcases, we see that Lucas-Lehmer requires more numbers. Since we are generating same random

number for each test(MillerRabin and Lucas-Lehmer), we conclude that some numbers that wasdeclared as probable prime by Miller-Rabin(20) was found to be Composite by Lucas-Lehmer,thus yielding to more # Tested. Therefore, we can see that Lucas-Lehmer was more accurate thanMiller-Rabin(20)

Now, lets compare the speed of these algorithms. We know that Lucas-Lehmer is faster to test aPrime number(that is if the number is a prime number); however, if a number was not declared aComposite on the first iteration of Miller-Rabin, we perform Lucas Test for Lucas-Lehmer.Lucas Test typically takes approximately time it takes for 6 iterations of Miller-Rabin. Therefore,Time spent on Lucas-Lehmer test is equivalent to 7 iterations of Miller-Rabin.

However, as shown on the table, Lucas-Lehmer test was not necessarily faster. This is because if

a number is found to be composite less than two iterations of Miller-Rabin, we stop there.Nevertheless, with Lucas-Lehmer test, if a number passes first iteration of Miller-Rabin, wecontinue with Lucas Test, which takes about same time as 6 iterations of Miller-Rabin.Therefore, actual speed depends on following factors.

1. Number of Composites that fail one iteration of Miller-Rabin- This definitely will speed up both algorithms; however, it does not affect our comparison of

Lucas-Lehmer and Rabin-Miller.

2. Number of Composites that takes 2-5 iterations of Miller-Rabin before being declaredComposite

- if we have more numbers that falls in this category, clearly Miller-Rabin algorithm is better.3. Number of Composites that takes more than 6 iterations of Miller-Rabin before being

declared Composite.- in this case, Lucas-Lehmer is a better choice


11/25

PROJECT590 Finding Prime Numbers

class PROJECT590 {

final static int MillerRabin = 0;final static int LucasLemer = 1;

public static void main( String argv[] ) {int bitLength = 256;int typeOfMethod = LucasLemer;int mrIteration = 20;int count = 0, i = 0;int numPrimes = 20;

// make this random deterministic so that repeated experiment// yields same resultRandom rndSrc = new Random(5);BigInteger one = new BigInteger("1"), two = new BigInteger("2");

BigInteger x, rand_num, start;

MillerRabin MR;LucasTest LT;

start = one.shiftLeft( bitLength ); //start = 2^n

while (count


12/25

}}

}x = x.add( two );}

count ++;

}System.out.println(i + " number tested to find " + numPrimes + " primes ");

}

}


13/25

Miller Rabin Test

import java.math.*;import java.util.*;

class MillerRabin {

final int COMPOSITE = 0, PRIME = 1;final BigInteger _one = new BigInteger("1");

BigInteger testVector;

BigInteger _r;int _s;

private int _isPrime;

/**

* constructs a class MillerRabin with a number to be tested with iteration*/

public MillerRabin(BigInteger n, int t) {int result;testVector = n;result = start(n, t);_isPrime = result;

}

/*** getNumber() returns number that is tested using MillerRabin

*/public BigInteger getNumber() {

return testVector;}

protected int start(BigInteger n, int t) {BigInteger y, n_minus_one, a, r;int i, j;int s;

findS_R( n );// n - 1 = 2^r x s

s = _s;r = _r;

y = new BigInteger("0");n_minus_one = n.subtract( _one );

for (i=1;i


14/25

//creates odd big integer {2,....,n-1)a = createOddBigInteger( n );

y = a.modPow(r, n);if ( !(y.intValue() == 1) && !(y.equals(n_minus_one)) ) {

j = 1;

while ( (j 2) && (result.compareTo(n) == -1) )

isOdd = true;}

return result;}


15/25

protected void findS_R( BigInteger n) {

// temp = n-1BigInteger temp = n.subtract(_one);int length, i;

length = temp.bitLength();

// ex.1011100 i = 2i = temp.getLowestSetBit();

//should be true all the time as long as it's even numberif (i


16/25

Lucas Test

import java.math.*;

class LucasTest {

final int COMPOSITE = 0, PRIME = 1;final BigInteger _zero = new BigInteger("0");final BigInteger _one = new BigInteger("1");final BigInteger _two = new BigInteger("2");final BigInteger _three = new BigInteger("3");final BigInteger _four = new BigInteger("4");final BigInteger _five = new BigInteger("5");final BigInteger _seven = new BigInteger("7");final BigInteger _eight = new BigInteger("8");final BigInteger _negativeOne = new BigInteger("-1");

BigInteger _u, _v, testVector;

boolean _isPrime;

public LucasTest() {

}

/*** returns number being tested*/

public BigInteger getNumber() {return testVector;

}

public LucasTest(BigInteger n) {BigInteger d, p, q, one, four, temp;int result;

testVector = n;

d = findValueOfD( n );System.out.println("d = " + d.toString());

q = new BigInteger("0");p = new BigInteger("1");

//q = 1-d/4q = q.subtract(d);q = q.divide( _four );

d = p.multiply(p);temp = q.multiply(_four);


17/25

d = d.subtract(temp);

result = findUk(p,q,d,n);

if (result == COMPOSITE )_isPrime = false;

else_isPrime = true;

}

/*** isPrime() returns true if it passes Lucas test* otherwise, returns false*/

public boolean isPrime() {return _isPrime;

}

protected BigInteger findValueOfD(BigInteger n) {int i = 1;Integer candidate = new Integer(5);BigInteger d;BigInteger temp;//generate candidate dd = new BigInteger( candidate.toString() );

while ( true ) {temp = findJacobi3(d, n);if (temp.intValue() == -1) {

return d;

}i = i*(-1);candidate = new Integer( (candidate.intValue()*i*(-1) + 2) * i );d = new BigInteger( candidate.toString() );

}

}

protected int findUk(BigInteger p, BigInteger q, BigInteger d, BigInteger n) {BigInteger u, v, temp, k;int r, i;

k = n.add(_one);r = k.bitLength();

// u =1, v = pu = new BigInteger("1");v = new BigInteger("0");v = v.add(p);//System.out.println("u = " + u.toString());//System.out.println("v = " + v.toString());


18/25

_u = u;_v = v;

for(i=r-2; i >= 0; i--) {

setUV( d, p, n);

if (k.testBit(i)) {setUV2(d, p, n);

}}

u = _u;v = _v;

temp = u.mod(n);if (temp.intValue() == 0)

return PRIME;

elsereturn COMPOSITE;

}

protected void setUV( BigInteger d, BigInteger p, BigInteger n ) {BigInteger u, v, u_o, v_o, temp, invTwo;

invTwo = _two.modInverse( n );

u = _u;v = _v;

// Save original valuesu_o = new BigInteger("0");v_o = new BigInteger("0");u_o = u_o.add(u);v_o = v_o.add(v);

u = u.multiply(v);u = u.mod(n);

v = v.multiply(v);temp = d.multiply(u_o);temp = temp.multiply(u_o);

temp = temp.add(v);temp = temp.multiply( invTwo );

v = temp.mod(n);

_u = u;_v = v;

}


19/25

protected void setUV2( BigInteger d, BigInteger p, BigInteger n ) {

BigInteger u, v, u_o, v_o, temp, invTwo;

invTwo = _two.modInverse( n );u = _u;

v = _v;// Save original valuesu_o = new BigInteger("0");v_o = new BigInteger("0");u_o = u_o.add(u);v_o = v_o.add(v);

u = u.multiply(p);u = u.add(v_o);

u = u.multiply( invTwo );u = u.mod(n);

v = v.multiply(p);temp = d.multiply(u_o);temp = temp.add(v);temp = temp.multiply( invTwo );v = temp.mod(n);

_u = u;_v = v;

}

public BigInteger findJacobi3(BigInteger a, BigInteger n) {

BigInteger j;BigInteger x, y, temp;

temp = a.gcd(n);

if (a.gcd(n).intValue() > 1) {return _zero;

}

j = _one;

x = a;

y = n;

while (true) {

temp = y.abs();x = x.mod(temp);temp = y.divide(_two);

if ( x.compareTo(temp) == 1) {


20/25

x = y.subtract(x);if (y.mod(_four).intValue() == 3) {

j = j.negate();}

}while (true) {

if (x.remainder(_four).intValue() == 0) {x = x.divide(_four);

}else

break;}

if (x.testBit(0) == false) {x = x.shiftRight(1);

if ( (y.mod(_eight).intValue() == 3) || (y.mod(_eight).intValue()== 5) ) {

j = j.negate();}

}

if (x.intValue() == 1)return j;

if ( (x.mod(_four).intValue() == 3) && (y.mod(_four).intValue() == 3) ) {j = j.negate();

}

temp = x;

x = y;y = temp;

}

}

public BigInteger findJacobi2(BigInteger a, BigInteger n) {BigInteger j;BigInteger temp, temp1, temp2;

j = _one;

while (a.intValue() != 0) {temp = a.mod(_two);while (temp.intValue()==0) {

a = a.divide(_two);temp1 = n.mod(_eight);temp = a.mod(_two);


21/25

if ( (temp1.compareTo( _three ) == 0 ) || (temp1.compareTo( _five ) ==0 ) )j = j.negate();

}temp = a;a = n;n = temp;

temp1 = a.mod(_four);temp2 = n.mod(_four);

if ( ( temp1.intValue() == 3 ) && (temp2.intValue() == 3) )j = j.negate();

a = a.mod( n.abs() );

}

if (n.intValue() == 1)return (j);

elsereturn(_zero);

}}


22/25

Test Vectors for 130 bit

12001613076142281325871243449113198888471217061394045440770272863028410128226539921108606988933429616620315810400467517853317530370104012409598527522730700651

6808524558322864122349592663392941719897558747216136808683503755807624720581637088452333793652371385143212487095952719705791209760070476066979884551110513071078975318520442677247975877914475852561132066756565139587238656296136561240268971832522724316409810524100553412983150313469981273080363337964161799763142351871210728443503156319623535316310907871307128432999501136636234590434567479661573711313326413161968787382367813134161669596832968059908478128021223334250961208531092286847468566817841840658247701405267


23/25

Test Vectors for 512 bit

1340601848585271822610510612456191010796692783283169350522389868580151405184633487451611811977871257356339625265114480545265852708725241237818621057451312311110430765698277397232281375065147003250781009141881192433209450406066052913879569977

9978676469347825092082596883259610156542769008696815958950406977160771180661275898530765317486030704354172716887216991288008511012518718831500816904193915899074619556696132548287020645696062398555482934001079772785551767957776368104530370928941669763979323918295792552347649175734129694103347060681575840312688264547333736782553489472281706669237451172832660455099611514623160578217108735547633248928945383072732625972810016872882410983095241540371194606629601631322285074660331028910462762507189124859650982129406755093565061585947122667647851650301627293870812967209934721431616931704668207790032755264163142733600031365622188540606174218777940555755357828786992414748428714728702497331172882817694786912590596992307945216664096419801478715046160670183070511589508746191081971047141692081350708864474590252355640557512305711293478226442568777242370223737068975281247525279827689805491420383621463993732717430696633093986804006279609765686988959651488150185323433227681416709201721924225245779776760636969162029518661036987553854971908050457194544105801456165011200776400363662242124241874678420217535968762300086119980152984412283003045093077015403117738726790297189886101331667859638183452566776426975674916618231133080971322275029352787554715313245785185628117406660700198190473199899155002712265453678855476145908697845903737351136077125319384965963019746363826630690430194136124673726185476477659359773159241087241671571856937283706143788223282514554017792405211236290298693617618148174679543677931484497716425070481642275129947306679005606061741556930080400458697123056924597591908322102027713149314958429192275948624727149808202698084428113934047304457338998404950033929249251889341223835305859274835645466398896849565608428626074837595507932558655272421212817501592564187655321191368470637366382408858531339946873524331647129005406684681388220600896913707458760041452877269085583130556114395631972053194867150397


24/25

TestVector for 1024 bit(5 vectors)

943663967303341733831073530494149595215288153105481870301659362295789602095234218089124597953290352035102845761871600763866437004412165477329142505789342618915108271402670435920072251607983489136394725647150554452015124613593594887954278755302310012985524522

30535485049737222714000227878890892901228389026881141042326390935490933549826211084478751699451363768729974777355591759073930361163528982080938640451285107339394311503889010084443638831171139527077223795544048944924445121879647156884834769908268810030211770076290037462181390777337909091903142919610023579610612355809815098951461960436805335178146468594497053113606101111793063882239480101353850104479151100377093301810268934539732492321689981032567226622623957153523225328631881081241616212270943207600497544632660747936549552481148466692479681327569567487876744209771481314457618208860179484415611981619594638107773332491673281796678206353605333616952366511645578797108226341463854811285640704097476003833287579879155073516325412151992968120892110974757261670881424647935018935108116567014141299008998343748380632593898208038394303117316930792853237173668056388546970193755585997027783952123851174026560693740233106410211387525683988797378505561609104502259722551424163822821131987576583239074351780315422861391005863733198502184390840617869289696453803639648836683448848489044397822815653937429267202961430366115354378807818247407689316400773213861885428867838814872547009946100126907624284479881920021341634731228098247065866684397494312971820820784312389551449748365108896731559199


25/25

TestVector for 2048 bit(5 vectors)

221932714130267379082251568132200501455333824536989831184759991906431453362656145400133698584672029304879687476695840117479678729693932667508999816378499123642146082539891476014525511071352741507660029294646990581006341539256878528501158808777962857723409378

473188712469300182653710449598665214105572373090532405030183276218333944433033129336407892301106868774007531618751873906873351036043859687128509151302857112245794256699256874934300475706183989361921613289202732944676474640281186444660507931202480142049949931266963552794748920536638048145775013158871499391137641925536168057265616241992130027160596845409069492828841823404669752848113680696728450209231684370420070464962335215534907231260963086885271049492907435683898524170518405879339292633441125348104703717405419550982118925336349013200545281510731879832358398417748360111783728994202340929488143281811410829059700097452006312651336220687126289828743301988652487090739716618943925417022109239011389373423325288612064898533160596110714156480914134561391860079190895868476482329858919570952413180870836688263022663969956304367986123217788613873969211916379164223862344670610410132260937943188439782956171450404113759096606478144006017661459418498386630524315417988973556849717219460483763251778847637508172301586065461824572446337315073355226530777773807181263

789556609074519645699025248688838076721682039362527314976010803713210408973161680837826683825020102448898939606246752482311546505140354818757460242409598798757214071180614871664182058967157393479905526762887156900138277266142493684891977179604464122151430180752603341903640550833038263470219561694270299301804340679680741086855278501271505159319408296186881815746449435849037957844024674819960600842349920193998090448373587310621404172013854294301133172651002988321812367533980697404811723031959214502523836192442148818218852584543294841575378481212503461981510327080920760621701829259340045840823118838823687970941639359522774342446845480134829700831181306033708316939943933696809193726336643215544912243368506121440732356940798309452934680916202322476709212844991461134675129903381263714578781854814714903973121284035217658067124194407049491507960980768096607932033807943073096795989890307705157143189243150320066128784084935191096210325270754584279016970346774210211120965136320154340732112797663067362844416161282946246799081546723800789224390

7259578011134495061733366911886620946861377274420462600218834323530246735040467131003193323506546498724570655503854253483199253095297472205829110065137932349929197635791431104817306878549391052154250394037917641247944333950179182554106530078640679659574853907424207343528717800425258744955071443162151389942772623166560861447999077819850870177689525762836207704497018443865471253661943512155118664929306838159575880186389947176731183947235607201472836746968096685087771272398964422671434509420453792523428713542681578548070912404383517786349844261370238239402372386395490883346109635074006906835518212020527106850872662555928463020018146067254240394873363721889615687626486016230122037470335967462409245674828403490711

dong report

Documents