WebSVN – corrade-nucleus-nucleons – Blame – Rev 26 – /base/000_base/node

var LOW_PRIMES = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];

15

var LP_LIMIT = (1 << 26) / LOW_PRIMES[LOW_PRIMES.length - 1];

16

17

var BigInteger = forge.jsbn.BigInteger;

18

var BIG_TWO = new BigInteger(null);

19

BIG_TWO.fromInt(2);

20

21

self.addEventListener('message', function(e) {

22

var result = findPrime(e.data);

23

self.postMessage(result);

24

});

25

26

// start receiving ranges to check

27

self.postMessage({found: false});

28

29

// primes are 30k+i for i = 1, 7, 11, 13, 17, 19, 23, 29

30

var GCD_30_DELTA = [6, 4, 2, 4, 2, 4, 6, 2];

31

32

function findPrime(data) {

33

// TODO: abstract based on data.algorithm (PRIMEINC vs. others)

34

35

// create BigInteger from given random bytes

36

var num = new BigInteger(data.hex, 16);

37

38

/* Note: All primes are of the form 30k+i for i < 30 and gcd(30, i)=1. The

39

number we are given is always aligned at 30k + 1. Each time the number is

40

determined not to be prime we add to get to the next 'i', eg: if the number

41

was at 30k + 1 we add 6. */

42

var deltaIdx = 0;

43

44

// find nearest prime

45

var workLoad = data.workLoad;

46

for(var i = 0; i < workLoad; ++i) {

47

< workLoad; ++i) { // do primality test

48

< workLoad; ++i) { if(isProbablePrime(num)) {

49

< workLoad; ++i) { return {found: true, prime: num.toString(16)};

50

< workLoad; ++i) { }

51

< workLoad; ++i) { // get next potential prime

52

< workLoad; ++i) { num.dAddOffset(GCD_30_DELTA[deltaIdx++ % 8], 0);

53

< workLoad; ++i) { }

54

55

< workLoad; ++i) { return {found: false};

56

< workLoad; ++i) {}

57

58

< workLoad; ++i) {function isProbablePrime(n) {

59

< workLoad; ++i) { // divide by low primes, ignore even checks, etc (n alread aligned properly)

60

< workLoad; ++i) { var i = 1;

61

< workLoad; ++i) { while(i < LOW_PRIMES.length) {

62

< workLoad; ++i) {< LOW_PRIMES.length) { var m = LOW_PRIMES[i];

63

< workLoad; ++i) {< LOW_PRIMES.length) { var j = i + 1;

64

< workLoad; ++i) {< LOW_PRIMES.length) { while(j < LOW_PRIMES.length && m < LP_LIMIT) {

65

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) { m *= LOW_PRIMES[j++];

66

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) { }

67

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) { m = n.modInt(m);

68

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) { while(i < j) {

69

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {      if(m % LOW_PRIMES[i++] === 0) {

70

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) { return false;

71

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) { }

72

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) { }

73

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) { }

74

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {  return runMillerRabin(n);

75

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {}

76

77

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {// HAC 4.24, Miller-Rabin

78

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {function runMillerRabin(n) {

79

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) { // n1 = n - 1

80

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {  var n1 = n.subtract(BigInteger.ONE);

81

82

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {  // get s and d such that n1 = 2^s * d

83

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {  var s = n1.getLowestSetBit();

84

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) { if(s <= 0) {

85

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {    return false;

86

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) { }

87

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {  var d = n1.shiftRight(s);

88

89

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {  var k = _getMillerRabinTests(n.bitLength());

90

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {  var prng = getPrng();

91

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) { var a;

92

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {  for(var i = 0; i < k; ++i) {

93

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {    // select witness 'a' at random from between 1 and n - 1

94

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {    do {

95

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {      a = new BigInteger(n.bitLength(), prng);

96

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {    } while(a.compareTo(BigInteger.ONE) <= 0 || a.compareTo(n1) >= 0);

97

98

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    /* See if 'a' is a composite witness. */

99

100

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    // x = a^d mod n

101

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    var x = a.modPow(d, n);

102

103

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    // probably prime

104

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    if(x.compareTo(BigInteger.ONE) === 0 || x.compareTo(n1) === 0) {

105

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      continue;

106

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    }

107

108

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    var j = s;

109

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    while(--j) {

110

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      // x = x^2 mod a

111

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      x = x.modPowInt(2, n);

112

113

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      // 'n' is composite because no previous x == -1 mod n

114

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      if(x.compareTo(BigInteger.ONE) === 0) {

115

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >        return false;

116

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      }

117

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      // x == -1 mod n, so probably prime

118

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      if(x.compareTo(n1) === 0) {

119

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >        break;

120

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      }

121

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    }

122

123

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    // 'x' is first_x^(n1/2) and is not +/- 1, so 'n' is not prime

124

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    if(j === 0) {

125

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      return false;

126

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    }

127

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >  }

128

129

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >  return true;

130

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >}

131

132

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >// get pseudo random number generator

133

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >function getPrng() {

134

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >  // create prng with api that matches BigInteger secure random

135

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >  return {

136

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    // x is an array to fill with bytes

137

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >    nextBytes: function(x) {

138

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >      for(var i = 0; i < x.length; ++i) {

139

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {        x[i] = Math.floor(Math.random() * 0xFF);

140

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {      }

141

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {    }

142

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  };

143

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {}

144

145

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {/**

146

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { * Returns the required number of Miller-Rabin tests to generate a

147

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { * prime with an error probability of (1/2)^80.

148

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { *

149

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { * See Handbook of Applied Cryptography Chapter 4, Table 4.4.

150

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { *

151

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { * @param bits the bit size.

152

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { *

153

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { * @return the required number of iterations.

154

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) { */

155

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {function _getMillerRabinTests(bits) {

156

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 100) return 27;

157

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 150) return 18;

158

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 200) return 15;

159

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 250) return 12;

160

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 300) return 9;

161

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 350) return 8;

162

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 400) return 7;

163

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 500) return 6;

164

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 600) return 5;

165

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 800) return 4;

166

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  if(bits <= 1250) return 3;

167

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {  return 2;

168

< workLoad; ++i) {< LOW_PRIMES.length) {< LOW_PRIMES.length && m < LP_LIMIT) {< LP_LIMIT) {< j) {<= 0) {< k; ++i) {<= 0 || a.compareTo(n1) >< x.length; ++i) {}

corrade-nucleus-nucleons – Blame information for rev 26