1:

  553  1447073137021     11:53:33.600					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:

program GMP_Test;
//testet die Laufzeit von mpz_probab_prime_p bei
//verschiedenen Stellenzahlen
{$IFNDEF FPC}
  {$Apptype CONSOLE}
{$ELSE}
  {$MODE DELPHI}
{$ENDIF}

uses
  sysutils,gmp,mp_base, mp_numth, mp_prng, mp_prime, mp_types;
type
  tTestWerte = record
                 twSZ,              //Stellenzahl
                 twVs : NativeUint; //Verschiebung aka Offset
               end;
const
 {cTestwerte : array[1..10] of tTestWerte =
              ((twSz: 100;twVs:349781731),
               (twSz: 200;twVs:21156403891),
               (twSz: 300;twVs:140159459341),
               (twSz: 400;twVs:34993836001),
               (twSz: 500;twVs:883750143961),
               (twSz: 600;twVs:1394283756151),
               (twSz: 700;twVs:547634621251),
               (twSz: 800;twVs:3125423484751),
               (twSz: 900;twVs:430772369311),
               (twSz:1000;twVs:1657378832463));
}
cTestwerte : array[1..10] of tTestWerte =
              ((twSz: 100;twVs:2191),
               (twSz: 200;twVs:5491),
               (twSz: 300;twVs:4681),
               (twSz: 400;twVs:7081),
               (twSz: 500;twVs:15721),
               (twSz: 600;twVs:2161),
               (twSz: 700;twVs:20251),
               (twSz: 800;twVs:9511),
               (twSz: 900;twVs:6991),
               (twSz:1000;twVs:19411));
{$IFDEF CPU32}
  runden = 25;
{$ENDIF}
{$IFDEF CPU64}
  runden = 100;
{$ENDIF}
var
   x :mpz_t;
   y: mp_int;

procedure TestlaufMpArith(var TestZahl:mp_int);
var
   T1,T0: TDateTime;
   i: integer;
Begin
 t0:= time;
 For i := 1 to runden do
   s_mp_is_psp2(TestZahl);
 t1:= time;
 Writeln(86400*1000*(T1-T0)/runden:8:6,' ms');
end;

procedure TestlaufGMP(var TestZahl:mpz_t);
var
   T1,T0: TDateTime;
   i: integer;
Begin
 t0:= time;
 i := 1;
 For i := 1 to runden do
   mpz_probab_prime_p(TestZahl, 0);
 t1:= time;
 Writeln(86400*1000*(T1-T0)/runden:8:6,' ms');
end;

var
  i : integer;
begin

 mpz_init(x);
 writeln('GMP');
 For i := low(cTestwerte) to High(cTestwerte) do
 Begin
   mpz_set_ui(x,10);
   with cTestwerte[i] do
   Begin
     mpz_pow_ui(x,x,twSz-1);
     mpz_add_ui(x,x,twVs);
     write(twSz:5,'  ');
   end;
   TestlaufGMP(x);
 end;
 mpz_clear(x);

 writeln;
 writeln('MpArith');
 mp_init(y);
 For i := low(cTestwerte) to High(cTestwerte) do
 Begin
   mp_set(y, 10);
   with cTestwerte[i] do
   Begin
     mp_expt_int(y,twSz-1,y);
     mp_add_d(y,twVs,y);
     write(twSz:5,'  ');
   end;
   TestlaufMpArith(y);
 end;
 mp_clear(y);

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:

CPU64
# ./GMP_Test
GMP
  100  0.030000 ms
  200  0.170000 ms
  300  0.500000 ms
  400  1.080000 ms
  500  2.050000 ms
  600  3.590000 ms
  700  5.340000 ms
  800  7.630000 ms
  900  10.660000 ms
 1000  14.320000 ms

MpArith
  100  0.150000 ms
  200  0.880000 ms
  300  3.400000 ms
  400  6.990000 ms
  500  12.950000 ms
  600  29.610000 ms
  700  39.780000 ms
  800  52.050000 ms
  900  77.090000 ms
 1000  104.640000 ms

CPU32
# ./GMP_Test
GMP
  100  0.120000 ms
  200  0.880000 ms
  300  2.760000 ms
  400  5.920000 ms
  500  10.720000 ms
  600  18.560000 ms
  700  28.560000 ms
  800  33.480000 ms
  900  50.280000 ms
 1000  82.480000 ms

MpArith
  100  0.440000 ms
  200  3.000000 ms
  300  10.720000 ms
  400  22.400000 ms
  500  40.600000 ms
  600  184.160000 ms
  700  215.800000 ms
  800  278.840000 ms
  900  554.600000 ms
 1000  674.480000 ms					

1:
2:
3:

 10^500 = 1661 Bits =  53 mp_digits
 10^600 = 1994 Bits =  64 mp_digits;
10^1000 = 3322 Bits = 107 mp_digits					

1:
2:

 mp_t3m_cutoff  := 2*mp_mul_cutoff;
 mp_t3s_cutoff  := 2*mp_sqr_cutoff;					

1:
2:

 mp_t3m_cutoff  := 4*mp_mul_cutoff;
 mp_t3s_cutoff  := 4*mp_sqr_cutoff;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

         D3/16    FPC32   D18/32    FPC64    FPC32/T=4K
  100    1.342    1.938    2.459    1.093    1.950
  200    6.541    6.042    7.057    4.074    5.551
  300   17.410   14.102   20.856    7.424   14.079
  400   39.333   28.126   45.369   14.153   28.101
  500   77.455   52.632   86.937   24.796   52.558
  600  128.781   95.760  150.708   48.929   98.861
  700  199.945  142.172  227.475   69.307  147.441
  800  293.470  205.109  336.141   98.148  210.664
  900  424.481  327.736  476.608  170.889  287.117
 1000  568.588  456.911  642.765  207.466  385.704					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:

program FindeQuadrupel;
//Sieben nach Quadrupeln der Form 30*n+(11,13,17,19)
//also muss Mod30 aus Menge [11,13,17,19] sein
//die Faktoren bestimmen den Abstand zum nächsten Element aus der Menge
//Beispiel 1 -> 0R 1 hat bei *11, *13, *17, *19, einen Treffer,
//wieder bei *(30+11-19) = *22
//faktorenmässig Start bei +11,dann +2+4+2+22,+2+4+2+22 ....
//Also 4 Treffer bei einem Schritt von 30.
//ich bestimme die Faktoren einmal und dann wird nur noch addiert
//
//Vergleich mit https://oeis.org/A007530/b007530.txt

{$IFDEF FPC}
  {$MODE DELPHI}
  {$OPTIMIZATION ON,REGVAR,CSE,PEEPHOLE}
  //{$R+,I+,O+} //gibt kein mecker mehr...
{$ELSE}
  {$APPTYPE CONSOLE}
{$ENDIF}
uses
  sysutils;
type
  tSieveElem = NativeUint;

  tDelta30 = array[0..3] of  NativeUint;
  tMulOfs = record
              moMul,moOfs: byte;
            end;
  tMulPosArr = array[0..3] of  tMulOfs;

  tPrimMod30   =packed record
//                 deltaP     : p[n-1]-p[n] (delta DIV30 + delta MOD30 )
                   pm30Offset   : LongWord;  //Uebertrag bis 22 * p DIV 30
                   pmNextSivbNr : word;
                   pm30AktIdx,
                   pm30Delta  : byte;//delta DIV30 shl 3 + delta MOD30Idx
                 end;
  tpPrimMod30 = ^tPrimMod30;

const
  cMulOfs : array [0..7]of tMulPosArr =
    (((moMul: 2;moOfs:0),(moMul: 4;moOfs: 0),(moMul: 2;moOfs:0),(moMul:22;moOfs: 1)), // 1
     ((moMul: 4;moOfs:1),(moMul: 8;moOfs: 2),(moMul: 4;moOfs:1),(moMul:14;moOfs: 3)), // 7
     ((moMul: 6;moOfs:2),(moMul:16;moOfs: 6),(moMul: 6;moOfs:2),(moMul: 2;moOfs: 1)), //11
     ((moMul:12;moOfs:5),(moMul: 4;moOfs: 2),(moMul:12;moOfs:5),(moMul: 2;moOfs: 1)), //13
     ((moMul:12;moOfs:7),(moMul: 4;moOfs: 2),(moMul:12;moOfs:7),(moMul: 2;moOfs: 1)), //17
     ((moMul: 6;moOfs:4),(moMul:16;moOfs:10),(moMul: 6;moOfs:4),(moMul: 2;moOfs: 1)), //19
     ((moMul: 4;moOfs:3),(moMul: 8;moOfs: 6),(moMul: 4;moOfs:3),(moMul:14;moOfs:11)), //23
     ((moMul: 2;moOfs:2),(moMul: 4;moOfs: 4),(moMul: 2;moOfs:2),(moMul:22;moOfs:21)));//29

  cMod30ToIdx : array[0..29] of byte =
                 (111,0,111,111,111,111,111,1,111,111,111,2,111,3,111,
                  111,111,4,111,5,111,111,111,6,111,111,111,111,111,7);

  cIdxToMod30 : array[0..7] of byte = (1,7,11,13,17,19,23,29);

//Anzahl der Bits eines Sieb-Elementes
  cBitSize = SizeOf(tSieveElem)*8;
  cAndMask = cBitSize-1;


//Abfolge der Streichpositionen
//Nextpos = k*p DIV 30
//idx = cMod30ToIdx[p MOD 30]
//i = 0;
//repeat
//  NextPos = Lastpos + (cStartOffset[idx][i] + (p DIV 30)*cFaktoren[idx][i]);
//  i = (i+1) AND 3;
//until JetztIstAberGut;

//1*151 == 5*30+1
//idx -> 0
//Ausnahme erster Wert dort NextPos = NextPos shr 1;
// 11*151 = 1661 = 55*30+11
// i:= 3;
//  NextPos = (1 + 5* 22) shr 1;//(1 +110) shr 1 -> 55
//  i = (i+1) AND 3 => 0
// 13*151 = 1963 = 65*30+13
//  NextPos = 55+(0 + 5* 2);//55+10 -> 65
//  i = (i+1) AND 3 => 1
// 17*151 = 1963 = 85*30+17
//  NextPos = 55+(0 + 10* 2);//65+20 -> 85
//  i = (i+1) AND 3 => 2
// 19*151 = 1963 = 65*30+19
//  NextPos = 85+(0 + 5* 2);//85+10 -> 95
//  i = (i+1) AND 3 => 3
// (30+11)*151 = 6191 = 206*30+11
//  NextPos = 95+(1 + 5* 22);//95+111 -> 206
//  i = (i+1) AND 3 => 0
// (30+13)*151 = 6493 = 216*30+13
//  NextPos = 206+(0 + 5* 2);//206+10 -> 216

//Ein Sieb x64-bit
//  cSiebGroesse = 500*1000*1000*1000;//->4671000 in 521s/57089 Primz

//mehrfach mit Übertrag gesiebt 2000*cSiebgroesse
//Anzahl Primzahlen 57089  Anzahl      : 4671012    210s

// etwa 1 MB
  cSiebGroesse  = 64*30*130208;//2.5e8-640

  cPrimeMax =63245;//trunc(sqrt(MaxZahl))+1;
var
  SiebMod30 : array[0..(cSiebGroesse-1) DIV 30 DIV cBitSize] of tSieveElem;
  Prim30List :array[0..11895200] of tPrimMod30;
  PrimSieb  : array of boolean;
  T0,T1: TDAteTime;
  gblP30,
  Prim30idx,
  LastPrime : longWord;

  tmpDelta30:tDelta30;

function Auszaehlen:Longint;
var
  i:NativeUInt;
  elem:tSieveElem;
begin
  result := 0;
  Begin
    For i := Low(SiebMod30) to High(SiebMod30)-1 do
    Begin
      //Bits umkehren
      elem := NOT SiebMod30[i];
      repeat
        inc(result,elem AND 1);
        elem := elem shr 1;
      until elem  = 0;
    end;
    // die letzten Bits zaehlen
    elem := NOT SiebMod30[High(SiebMod30)];
    i := High(SiebMod30)*30*cBitsize;
    while i < cSiebGroesse do
    Begin
      inc(result,elem AND 1);
      elem := elem shr 1;
      inc(i,30);
    end;
  end;
end;

procedure MulListErstellen(p30:LongWord);
var
  pMulPos : ^tMulOfs;
begin
  pMulPos := @cMulOfs[p30 AND 7][0];
  //p30 zu p DIV 30
  p30 := p30 shr 3;
  with pMulPos^ do
    tmpDelta30[0] := moOfs+p30*moMul;
  inc(pMulPos);
  with pMulPos^ do
    tmpDelta30[1] := moOfs+p30*moMul;
  inc(pMulPos);
  with pMulPos^ do
    tmpDelta30[2] := moOfs+p30*moMul;
  inc(pMulPos);
  with pMulPos^ do
    tmpDelta30[3] := moOfs+p30*moMul;
end;
procedure PrimSieben;
var
  i,p: NativeInt;
Begin
  p := 2;
  repeat
    i := p*p;
    while i <= cPrimeMax do
    Begin
      PrimSieb[i] := true;
      inc(i,p);
    end;
    repeat
      inc(p);
    until NOT PrimSieb[p]
  until (p*p) >cPrimeMax;
end;

procedure PrimListeErstellen;
var
  i: NativeInt;
  p30,p30Idx,DIV30,Aktidx,Last30Prime: NativeUInt;
Begin
  T0 := now;
  setlength(PrimSieb,cPrimeMax+1);
  PrimSieben;

  Prim30idx   := 0;
  LastPrime   := 1;
  Last30Prime := 0;//==  1;
  For i := 7 to cPrimeMax do
    IF Not PrimSieb[i] then
    Begin
      DIV30 := i DIV 30;
      p30Idx := cMod30ToIdx[i-30*DIV30];
      p30 := DIV30 shl 3+p30Idx;
      MulListErstellen(p30);
      //>>ersten Offset bestimmen
      IF cMulOfs[p30Idx][3].moMul = 2 then
      Begin
        inc(DIV30,tmpDelta30[0]);
        Aktidx:= 1
      end
      else
      Begin
        DIV30:= tmpDelta30[3] shr 1;
        Aktidx:= 0;
      end;
       //<<ersten Offset bestimmen

      with Prim30List[Prim30idx] do
      Begin
        pm30Offset:= Div30;
        pm30Delta := p30-Last30Prime;
        pm30AktIdx:= Aktidx;
      end;
      inc(Prim30idx);
      if Prim30idx>High(Prim30List) then
      Begin
        BREAK;
      end;
      Last30Prime:= p30;
      LastPrime := i;
    end;
  dec(Prim30idx);
  setlength(PrimSieb,0);
  T1 := now;
  writeln('Anzahl Primzahlen ',Prim30idx,' Letzte PrimZahl ', lastPrime);
  Writeln('Laufzeit sieben',FormatDateTime('S.ZZZ',T1-T0));
end;

procedure EinmalSieben(var Prim30:tPrimMod30);
var
  p30,mytmp,AktIdx: NativeUInt;
begin
   with Prim30 do
   Begin
     MulListErstellen(gblP30);
     p30 := pm30Offset;
     AktIdx := pm30AktIdx;
   end;
  //Jetzt einfaches markieren und addieren
  //number of the highest Bit (High(SiebMod30)+1)*cBitSize-1
  while p30 < cSiebGroesse DIV 30 do
  Begin
    mytmp := p30 DIV cBitSize;
    SiebMod30[mytmp]:= SiebMod30[mytmp] OR (tSieveElem(1) shl (p30 AND cAndMask));
    inc(p30,tmpDelta30[AktIdx]);
    AktIdx := (AktIdx + 1) AND 3;
  end;
  with Prim30 do
  Begin
     pm30Offset:= p30-cSiebGroesse DIV 30;
     pm30AktIdx := AktIdx;
   end;

end;

function AlleSieben:longint;
var
  pPL : tpPrimMod30;
  i,k,cnt : NativeInt;

begin
  k := 0;
  cnt := 0;
repeat
  fillchar(SiebMod30,SizeOf(SiebMod30),0);
  i := 0;
  pPL := @Prim30List[0];
  gblP30 := 0;// == 1
  repeat
      inc(gblP30,pPL^.pm30Delta);
      If pPL^.pm30Offset < cSiebGroesse DIV 30 then
        EinmalSieben(pPl^)
      else
        dec(pPl^.pm30Offset,cSiebGroesse DIV 30);
    inc(pPL);
    inc(i);
  until i > Prim30idx;
  inc(cnt,Auszaehlen);
  inc(k);
until k >=8;//2000;
  result := cnt;
end;

var
  cnt:NativeUInt;
BEGIN
  PrimListeErstellen;
  cnt := AlleSieben;

  writeln('Limit         : ',cSiebGroesse);
  writeln('Suchfeldlimit : ',(High(SiebMod30)+1)*30*cBitSize);
  writeln('Anzahl        : ',cnt);
end.
(*
//i386
Limit         :16*(250e6-640)
Suchfeldlimit : 4000000320
Anzahl        : 85911

real  0m1.451s


Anzahl Primzahlen 57089 Letzte PrimZahl 707197
Laufzeit sieben 0.004
499.99e9 fast 500e9
Anzahl        : 4670987
real  3m31.657s -> 212 Sekunden

*)					

1:
2:
3:
4:
5:
6:
7:
8:

type
tPrimMod30   =packed record
//                 p30   = (p DIV 30 shl 3)+ cMod30ToIdx[p Mod 30]
                   pm30Offset   : LongWord;  //Uebertrag bis 22 * p DIV 30
                   pmNextSivbNr : word;      // Wenn siebnr erreicht dann erst damit sieben
                   pm30AktIdx,
                   pm30Delta  : byte;//delta DIV30 shl 3 + delta MOD30Idx (== p30[n]-p30[n-1] )
                 end;					

1:
2:

while liste.count>50 do begin
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:

#INCLUDE "windows.bi"
#INCLUDE "vbcompat.bi" 
  

 DIM AS INTEGER i,j,C,COUNT,XX,TT,A,PP,QZ,U,RR ,CON , n ,maxP , STC
 DIM AS LONGINT Start,ST,STT
 DIM AS STRING FF,FF1,FF2,FF3
 DIM AS BYTE zaehler
 
 FF=CURDIR
 FF2=FF+"\primes.txt"
 FF3=FF+"\QuadR.txt" //Quelldatei der 4Tupel 101 bis 9699690 , welche ab 23 erst Teiler haben, sind 36855 Stück

 
 REDIM Q(36855) AS INTEGER
 REDIM QC(36855) AS INTEGER
 
 INPUT " - 10^n+.... - Exponent n";n
 INPUT "Start Milliarden";Start:Start=Start*1000000000
 INPUT "Stop  Milliarde ";ST:St=St*1000000000
 INPUT "Primzahlen ins Sieb ab 100000 bis 80 M";maxP
 maxP=INT (maxP/log(maxP)) // Abschätzung der Anzahl für maxP
 
 RR=1
 FOR J=1 TO n
 RR=(RR*10) MOD 96996900   // 10 ^ n MOD 96996900  = 10 Block a 9699690 wegen Rasterversatz 
 NEXT J
 
 Start= (Start \ 96996900) * 96996900 - RR <- siehe hier
 
 OPEN FF3 FOR INPUT AS #1  //einlesen der 4Tupel
 FOR C=1 TO 36855
 INPUT #1,A:Q(C)=A+8
 
 NEXT C
 CLOSE #1

 
 
 REDIM P(maxP) AS INTEGER   // einlesen der Primteiler bis maxP
 
 OPEN FF2 FOR INPUT AS #2
 FOR C=1 TO maxP
 INPUT #2,A
 P(C)=A
 NEXT C
 CLOSE #2
 REM Erstellung der RESTTABELLE
 
 REDIM R(maxP) AS INTEGER
 
 FOR I=1 TO maxP   // ermitteln der Resttabelle aller Primteiler für 10^n+Startwert, für Verschiebungsstart des Blockes nötig
 RR=1
 FOR J=1 TO n
 RR=(RR*10) MOD P(I)
 NEXT J
 R(i)=(RR+Start) MOD P(I)   // Der Restwert für 10^n+Start MOD Primteiler 
 NEXT I
  
 
 REDIM R2(maxP) AS INTEGER  // ersten 3000 Teiler Restwert für 96996900 Primteiler für die Unterblockverschiebung 9699690
 
 FOR I=1 TO 3000
 R2(I)=9699690 MOD P(I)
 NEXT I 
 
 FOR I=3001 TO maxP // ab 3001 Teiler Restwert für 96996900 Primteiler für die Unterblockverschiebung 96996900
 
 R2(I)=96996900 MOD P(I)
 NEXT I 
 
 REM ENDE
 
 REM Erstellung der RESTTABELLE 2  - 9699690 MOD P
 
 REM BEGIN SIEBEN
 CLS
 
 B0:
 STC=INT(Start/10^11) // Schnitt volle 100 Mrd Blöcke für paralelles PRPing mit PFGW.exe
 FF1=FF+"\"+STR(n)+"."+STR(STC)
 
 // Datei PFGW Style erstellung

 IF FILEEXISTS(FF1) THEN OPEN FF1 FOR APPEND AS #9 ELSE OPEN FF1 FOR OUTPUT AS #9
 
 PRINT #9,"ABC 10^";n;"+$a & 10^";n;"+$a+2 & 10^";n;"+$a+6 & 10^";n;"+$a+8"
 
 
 BEGIN:
 LOCATE 1,1:PRINT "10^";n;"+";Start
 
 REDIM F(96996900) AS BYTE  

 FOR zaehler=0 TO 9 // 10 mal 9699690 Block 
 
 FOR I=1 TO 36855  //Konstantes Feld Q - Feld für jeden Blockdurchlauf  in QC kopiert, weil im QC Feld  hier reduziert wird
 QC(I)=Q(I)
 NEXT I

 count=36855
 
 FOR i=1 TO 3000
 U=1
 XX=R(I)
 PP=P(i)
 
  
 WHILE u<count  // und das hier ist das Meisterstück ! REST (Primzahl bzgl Block ) MOD Primzahl
 soll hier 0,2,6, oder 8 sein, damit der 4er ungültig wird bei einer Bedingung 
 QZ=(QC(u) + XX ) MOD PP 
 IF QZ>8 THEN GOTO WEITER 
 IF QZ MOD 2 = 1 OR QZ=4 THEN GOTO WEITER // <10 und ungerade fallen auch raus
 QC(u)=QC(COUNT):COUNT-=1:u-=1 // Primärsieb ! Hole das letzte 4Tupel ins erste, wenn das 1. rausfällt, reduziere Anzahl der 4er im Block um 1
 WEITER:
 u+=1
 WEND
 
 R(I)=(R(I)+R2(I)) MOD PP // Errechne neuen Rest bei Blockverschiebung 9699690
 
  
 NEXT i
 
  
 

 // kopiere die übrigen in ein BYTE Feld der Größe 96996900 für weiteres Sieben, weil hier erstmals die 96996900 / Primteiler die Anzahl der Restkandidaten unterschreitet
F() ist das neue Siebfeld, der Endblock als Raster

 FOR j=1 TO count
    F(QC(j)+zaehler*9699690)=1
  F(QC(j)-2+zaehler*9699690)=1
  F(QC(j)-6+zaehler*9699690)=1
    F(QC(j)-8+zaehler*9699690)=1
 NEXT j
 

NEXT zaehler

// Siebe alle Primteiler ab der 3001. bis maxP wie gewohnt durch
 
 FOR i=3001 TO maxP
 U=1
 RR=P(i)-R(i)
 IF RR MOD 2= 0 THEN RR+=P(i)
 FOR j=RR TO 96996900 STEP P(i)*2
 F(j)=0
 NEXT j
 R(I)=(R(I)+R2(I)) MOD P(i)  // Auch hier die Restblock bzgl Primteiler bei Verschiebung Block 96996900
 
 NEXT i
 
 // Ausgabe aller übrigen 4er ab 41 in 30er Block aussuchen und in Datei fürs PRPing schreiben
 FOR i=41 TO 96996900 STEP 30
 IF F(i)=1 AND F(i+2)=1 AND F(i+6)=1 AND F(i+8 )=1 THEN PRINT #9,I+Start
 NEXT i
 
 
 STC=INT(Start/10^11)
 Start+=96996900
 IF START>ST THEN CLOSE #9:STOP
 // Prüft ob Datei abgeschlossen wird bei volle 100 Mrd
 IF INT(Start/10^11)>STC THEN CLOSE #9:GOTO B0
 
 GOTO BEGIN