![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vax.mar CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to vax.mar CVS log | Up to [PGP] / pgp / src |
1.1 root 1: ;Last Modified: 16-APR-1992 09:06:30.46
2: .title fprims Fast Multiple Precision Primitives
3: .ident /V1.7B/
4: ;+
5: ; **-FPRIMS-Fast Multiple Precision Primitives
6: ;
7: ; Facility: PGP
8: ;
9: ; Language: Macro-32
10: ;
11: ; Functional Description:
12: ;
13: ; This module contains fast multiple precision routines for operating on arrays
14: ; of long words. Error checking is minimised at the expense of speed.
15: ;
16: ; Restrictions:
17: ;
18: ; This code is shareable but NOT reentrant as written because of static data.
19: ; A reentrant version of this module could be written but it would be slower!
20: ;
21: ; Version: 1
22: ;
23: ; Original: 00A Date: 17-Sep-1991 Author: Hugh A.J. Kennedy
24: ;
25: ; Based on FPRIMS.ASM written by Zhahai Stewart for the Intel 8086
26: ; architecture.
27: ;
28: ; Modification: 02A Date: 27-Sep-1991 Author: Hugh A.J. Kennedy.
29: ;
30: ; Add fast multiply routine, P_SMUL.
31: ; Re-organise code slightly.
32: ; Ammend/clarify copyright and license statement.
33: ; Add checking for maximum precision exceeded, display a warning message
34: ; and bomb!
35: ;
36: ; Modification: 03A Date: 16-Mar-1992 Author: Hugh A.J. Kennedy.
37: ;
38: ; Sniff for MSB in P_SMUL. In this way, avoid multiplies by leading zeroes
39: ; (not efficient).
40: ;
41: ; Modification: 05A Date: 17-Mar-1992 Author: Hugh A.J. Kennedy.
42: ;
43: ; Encode entire double precision multiply in VAX assembler.
44: ; Correct some minor problems with handling embedded zeroes.
45: ;
46: ; Modification: 06A Date: 17-Mar-1992 Author: Hugh A.J. Kennedy
47: ;
48: ; Align everything for speed. VAXen like stuff on 64-bit, or at least 32-bit
49: ; boundaries. Therefore, we align the add, subtract and rotate tables and then
50: ; we align the multiply loops. The extra NOPs used to pad these loops are of
51: ; negligable cost because they already exist in the memory buffer. When the
52: ; following instruction is aligned, it executes MUCH faster.
53: ;
54: ; Modification: 07A Date: 24-Mar-1991 Author: Hugh A.J. Kennedy.
55: ;
56: ; Implement fast compare.
57: ;-
58:
59: .sbttl Copyright Notice And License To Use
60: ;
61: ; Copyright (c) 1991-1992, All Rights Reserved by
62: ; Hugh A.J. Kennedy.
63: ;
64: ; A license to use and adapt this software without payment is hereby
65: ; granted subject to the following conditions:
66: ;
67: ; 1) It may only be copied with the inclusion of this copyright
68: ; notice in the program source with these associated conditions.
69: ;
70: ; 2) No title to or ownership of this software is hereby
71: ; transferred.
72: ;
73: ; 3) The information in this software is subject to change
74: ; without notice and should not be construed as a commitment by
75: ; Hugh Kennedy.
76: ;
77: ; 4) The author assumes no liability for any damages arising from the
78: ; use of this software, even if said damages arises from defects in
79: ; this software.
80: ;
81: ; 5) No warranty as to merchantability or fitness of purpose is
82: ; expressed or implied.
83: ;
84: ; 6) Any modifications to this source must be clearly identified as
85: ; such and added to the modification history.
86: ;
87: ; 7) These routines may not be incorporated in a commercial cryptographic
88: ; product.
89: ;
90: ; If you can not comply with these conditions, you *must* contact the author
91: ; and obtain permission other wise you are in violation of copyright.
92:
93: .sbttl Misc Macros & Definitions
94: ;
95: ; Assembly Parameters
96: ;
97: max_unit_prec = 72 ; Maximum unit precision
98: supersniffer = 1 ; Enable bit msb locator.
99: ;
100: ; The following parameter is dependent on the kind of VAX you are running on
101: ; and should be defined if the execution time of the SOBGTR loop control
102: ; instruction and the appropriate operation (ADWC or SBWC) from cache is much
103: ; less than the execution time in main memory. If you have a slow VAX you
104: ; should comment the following line out to use a vector of instructions.
105: ;
106: novector = 1 ; Use loops rather than vectors.
107:
108: .macro ascid .string
109: ;+
110: ; *-ASCID-Build An ASCII String Referenced By Descriptor
111: ;
112: ; Functional Description:
113: ;
114: ; This macro is a little like the system supplied .ASCID directive
115: ; but it uses a separate program section to store the ASCII data.
116: ;
117: ; Arguments:
118: ;
119: ; STRING String to create
120: ;-
121: .nocross
122:
123: .save_psect
124:
125: .psect puret
126:
127: $$$t0 = .
128: .ascii @.string@
129: $$$t1 = .-$$$t0
130:
131: .restore_psect
132:
133: .word $$$t1
134: .byte dsc$k_dtype_t
135: .byte dsc$k_class_s
136: .address -
137: $$$t0
138: .cross
139:
140: .endm ascid
141:
142: .sbttl Misc Data Areas
143: ;
144: ; Misc. Data Areas
145: ;
146: .psect impurd,con,lcl,noshr,exe,rd,wrt,long
147:
148: ;
149: ; This data is static and is used to hold the current precision established
150: ; by P_SETP for other calls to this library.
151: ;
152: .if not_defined novector
153:
154: addoff: ; Offset into add table.
155: .blkl 1 ; also for sub and rot.
156: .endc
157:
158: precis: ; Precision in longwords.
159: .blkl 1
160:
161: .psect pure,con,rel,shr,exe,rd,nowrt,quad
162:
163: .align quad
164:
165: .ifndef novector
166:
167: prectoobig:
168: ascid <PGP (FPRIMS) - Requested precision (!ZL) exceeds capacity (!ZL)>
169:
170: .endc
171:
172: .sbttl Start of Code
173:
174: .sbttl P_CMP Compare two very long integers
175: ;+
176: ; **-P_COMP-Compare two very long integers
177: ;
178: ; Functional Description:
179: ;
180: ; This procedure is invoked to compare two extended precision unsigned
181: ; integers.
182: ;
183: ; Calling Sequence
184: ;
185: ; short P_CMP ( r1, r2)
186: ;
187: ; Parameters:
188: ;
189: ; R1 -> Extended Precision Integer 1
190: ; R2 -> Extended Precision Integer 2
191: ;
192: ; Implicit Inputs:
193: ;
194: ; PRECIS lr*r Precision expresses in longs.
195: ;
196: ; Returns:
197: ;
198: ; -1 if r1 < r2
199: ; 0 if r1 = r2
200: ; +1 if r1 > r2
201: ;
202:
203: ;-
204:
205: .align long
206:
207: .entry p_cmp,^m<r2>
208:
209: movl 4(ap),r1 ; R1 -> Sum.
210: movl 8(ap),r2 ; R2 -> Addend.
211: movl precis,r0 ; R0 = Precision.
212: moval (r1)[r0],r1 ; Get MS longwords.
213: moval (r2)[r0],r2 ; Get MS longwords.
214: .align long 1 ; Align loop with NOPS.
215: 10$: cmpl -(r1),-(r2) ; Compare.
216: bnequ 20$ ; If ne, then exit loop.
217: sobgtr r0,10$ ; Loop until done.
218: ret ; R0 = zero so R1 = R2.
219: 20$:
220: bgtru 30$ ; If R1 > R2 then branch.
221: movw #-1,r0 ; Flag <.
222: ret
223: 30$:
224: movw #1,r0 ; Flag >.
225: ret
226:
227: .sbttl P_ADDC Add two very long integers with carry
228: ;+
229: ; **-P_ADDC-Add very long integers
230: ;
231: ; Functional Description:
232: ;
233: ; This procedure is invoked to add two very long integers with carry. Each
234: ; integer is represented as an array of longwords, least significant first.
235: ;
236: ; Calling Sequence:
237: ;
238: ; P_ADDC sum,addend,carry
239: ;
240: ; Parameters:
241: ;
242: ; sum lm*r Sum.
243: ; addend lr*r Addend.
244: ; carry lr*v Carry bit.
245: ;
246: ; Implicit Inputs:
247: ;
248: ; Addoff This is used as an offset into the various tables
249: ; of adds, subtracts and rotates to implement the
250: ; operation to the requested precsion.
251: ;
252: ; Status Returns:
253: ;
254: ; R0 Resulting carry bit.
255: ;-
256:
257: .align long
258:
259: .entry p_addc,^m<r2,r3>
260:
261: movl 4(ap),r1 ; R1 -> Sum.
262: movl 8(ap),r2 ; R2 -> Addend.
263:
264: .if defined novector
265:
266: movl precis,r3 ; R3 = Precision.
267: subl3 12(ap),#0,r0 ; Set carry bit.
268: .align quad,1 ; Align loop with NOPs
269: 10$: adwc (r2)+,(r1)+ ; Add with carry one longword.
270: .align quad,1 ; Align next instruction.
271: sobgtr r3,10$ ; Loop until done.
272:
273: .iff ; novector
274:
275: moval 10$,r3
276: addl2 addoff,r3 ; Jump into table.
277: subl3 12(ap),#0,r0 ; Set carry bit.
278: jmp (r3)
279:
280: .align quad
281:
282: 10$:
283: .rept max_unit_prec
284: $$$ = .
285: adwc (r2)+,(r1)+ ; Add with carry one longword.
286: nop
287: addsiz = .-$$$
288: .endr
289:
290: .endc ; novector
291:
292: clrl r0 ; Assume carry clear.
293: bcc 20$ ; Carry set?
294: incl r0 ; Flag carry was set.
295: 20$: ret
296:
297: .sbttl P_SUBB Subtract very long integers with borrow
298: ;+
299: ; **-P_SUBB-Subtract very long integers
300: ;
301: ; Functional Description:
302: ;
303: ; This procedure is invoked to add subtract very long integers with carry. Each
304: ; integer is represented as an array of longwords, least significant first.
305: ;
306: ; Calling Sequence:
307: ;
308: ; P_SUBB diff,sub,borrow
309: ;
310: ; Parameters:
311: ;
312: ; diff lm*r Difference
313: ; sub lr*r Subtrahend.
314: ; borrow lr*v Borrow bit.
315: ;
316: ; Implicit Inputs:
317: ;
318: ; Addoff This is used as an offset into the various tables
319: ; of adds, subtracts and rotates to implement the
320: ; operation to the requested precsion.
321: ;
322: ; Status Returns:
323: ;
324: ; R0 Resulting carry bit.
325: ;-
326:
327: .align long
328:
329: .entry p_subb,^m<r2,r3>
330:
331: movl 4(ap),r1 ; R1 -> Difference.
332: movl 8(ap),r2 ; R2 -> Minuend.
333:
334: .if defined novector
335:
336: movl precis,r3 ; R3 = No. of longs.
337: subl3 12(ap),#0,r0 ; Set borrow bit.
338: .align quad,1 ; Align loop with NOPs.
339: 10$: sbwc (r2)+,(r1)+ ; Subtract with borrow one long.
340: .align quad,1 ; Align with NOPs.
341: sobgtr r3,10$ ; Loop through.
342:
343: .iff ; novector
344:
345: moval 10$,r3
346: addl2 addoff,r3 ; Jump into table.
347: subl3 12(ap),#0,r0 ; Set borrow bit.
348: jmp (r3)
349:
350: .align quad
351: 10$:
352: .rept max_unit_prec
353: sbwc (r2)+,(r1)+ ; Subtract w/carry one longword.
354: nop
355: .endr
356:
357: .endc ; novector
358:
359: clrl r0 ; Assume carry clear.
360: bcc 20$ ; Carry set?
361: incl r0 ; Flag carry was set.
362: 20$: ret
363:
364: .sbttl P_ROTL Rotate left a very long integer with carry.
365: ;+
366: ; **-P_ROTL-Rotate left one bit very long integers
367: ;
368: ; Functional Description:
369: ;
370: ; This procedure is invoked to rotate left one bit (e.g. divide by 2) very
371: ; long integers with carry. Each integer is represented as an array of
372: ; longwords, least significant first. Note that we use the add with carry
373: ; instruction here because the VAX (unlike the dear old PDP-11) lacks a
374: ; rotate instruction that includes the carry bit.
375: ;
376: ; Calling Sequence:
377: ;
378: ; P_ROTL num,carry
379: ;
380: ; Parameters:
381: ;
382: ; num lm*r Number to be shifted
383: ; carry lr*v Carry bit.
384: ;
385: ; Implicit Inputs:
386: ;
387: ; Addoff This is used as an offset into the various tables
388: ; of adds, subtracts and rotates to implement the
389: ; operation to the requested precsion.
390: ;
391: ; Status Returns:
392: ;
393: ; R0 Resulting carry bit.
394: ;-
395:
396: .align long
397:
398: .entry p_rotl,^m<r3>
399:
400: movl 4(ap),r1 ; R1 -> Sum.
401:
402: .if defined novector
403:
404: movl precis,r3 ; R3 = No. of longwords.
405: subl3 8(ap),#0,r0 ; Set carry bit.
406: .align quad,1 ; Align loop with NOPs
407: 10$: adwc (r1),(r1)+ ; Add to itself with carry.
408: .align quad,1 ; Align with NOPs.
409: sobgtr r3,10$ ; Loop until done.
410:
411: .iff ; novector
412:
413: moval 10$,r3
414: addl2 addoff,r3 ; Jump into table.
415: subl3 8(ap),#0,r0 ; Set carry bit.
416: jmp (r3)
417:
418: .align quad
419: 10$:
420: .rept max_unit_prec
421: adwc (r1),(r1)+ ; *2+carry.
422: nop
423: .endr
424:
425: .endc ; novector
426: clrl r0 ; Assume carry clear.
427: bcc 20$ ; Carry set?
428: incl r0 ; Flag carry was set.
429: 20$: ret
430:
431: .sbttl P_DMUL Extended Multiple Precision Multiply
432: ;*
433: ; **-P_DMUL-Extended Multiple Precision Multiply
434: ;
435: ; Functional Description:
436: ;
437: ; This procedure multiplies an unsigned single precision multiplier by a
438: ; single precision multiplicand. The product register is double precision.
439: ; It is expected that the length of the single precision multiplier and
440: ; multiplicand has been previously set by a call to P_SETP. Note that the
441: ; entire length of the product register is zeroed - so it must be a full
442: ; double precision size.
443: ;
444: ; Calling Sequence:
445: ;
446: ; P_DMUL prod, multiplicand, multiplier
447: ;
448: ; Parameters:
449: ;
450: ; prod lw*r Product.
451: ; multuplicand lr*r Multiplicand
452: ; multiplier lr*r Multiplier
453: ;
454: ; Implicit Inputs:
455: ;
456: ; PRECIS lr*r Precision expresses in longs.
457: ;
458: ; Status Returns:
459: ;
460: ; None.
461: ;-
462:
463: .align long
464:
465: .entry p_dmul,^m<r2,r3,r4,r5,r6,r7,r8,r9,r10,r11>
466:
467: movl 4(ap),r8 ; R8 -> Product.
468: beql 49$ ; If eq, not specified.
469: movl precis,r10 ; R10 = Precision (longs)
470: ashl #3,r10,r2 ; R0 = No. of bytes to zero.
471: movc5 #0,#0,#0,r2,(r8) ; Zero product buffer.
472: movl 8(ap),r3 ; R3 -> Multiplicand.
473: beql 49$ ; If eq, not specified.
474: pushl r3 ; Save for posterity.
475: movl 12(ap),r11 ; R11 -> Multiplier.
476: beql 49$ ; If eq, not specified.
477: movl r10,r12 ; R12 = Multiplicand prec.
478:
479: .if defined SUPERSNIFFER
480:
481: ;
482: ; Here we calculate the effective maximum precision for the multiply by
483: ; locating the long containing the most significant bit of the multiplier
484: ; and the multiplicand.
485: ;
486: moval (r11)[r10],r0 ; Supersniffer...
487: .align quad,1 ; Align with nops
488: 45$: tstl -(r0) ; Examine next long.
489: bneq 50$ ; If ne, then we found msb.
490: sobgtr r10,45$ ; Loop until done.
491: 49$: ret ; Multiplier = 0!
492: 50$:
493: moval (r3)[r12],r0 ; Supersniffer...
494: .align quad,1 ; Align with nops
495: 55$: tstl -(r0) ; Examine next long.
496: bneq 200$ ; If ne, then we found msb.
497: sobgtr r12,55$ ; Loop until done.
498: ret ; Multiplicand = 0!
499: .iff
500:
501: brb 200$
502: 49$:
503: ret
504:
505: .endc ; SUPERSNIFFER
506:
507: ;
508: ; Multiplier Loop
509: ;
510: ; R12 = Count of multiplicand longs to process.
511: ; R11 -> Next long of multiplier.
512: ; R10 = Count of multiplier longs to process.
513: ; R8 -> Next long of product.
514: ;
515: .align quad,1 ; Align with nops
516: 200$: movl r12,r5 ; Multiplicand precision.
517: moval (r8)+,r4 ; R4 -> Next long of product.
518: movl (sp),r3 ; R3 -> 1st multiplier long.
519: movl (r4),r0 ; R0,R1 = Partial Sum.
520: movl 4(r4),r1
521: clrl r7 ; Zero look-ahead carry.
522: ;
523: ; Perform an extended multiply of two unsigned numbers. This means that
524: ; we have to compensate the hi-order product because either the multiplier
525: ; or the multiplicand may be apparently a negative number. EMUL is a signed
526: ; multiply - so we must be careful. Also, the EMUL longword addend is sign
527: ; extended before adding into the product so we have to add the hard way.
528: ;
529: ; R6 = Current Multiplicand
530: ; R2 = Multiplier
531: ; R4 -> Current quadword of partial product.
532: ; R0,R1 = Partial sum to which product is added
533: ; R7 = Lookahead carry. This gets set if we try to carry after adding
534: ; the partial product to the partial sum. This gets a little more
535: ; complicated because here we are setting the high-order long of
536: ; the next quadword to be operated on.
537: ;
538: ; Essentially the algorithm is as follows:
539: ;
540: ; 0) R0,R1 = (R4) ; Save current partial sum.
541: ; 1) R6 = Next longword of multiplicand.
542: ; 2) (R4) = R6 * R2 ; quad result compensating for negative numbers)
543: ; 3) (R4) = (R4) + R0,R1 ; add back partial sum.
544: ; 4) R7 = Carry bit.
545: ; 5) R4 = R4 + 4 ; Point to next long.
546: ; 6) R1 = 4(R4) + R7 ; Propagate carry to high order of next partial
547: ; ; sum.
548: ; 7) Loop back to step 1 until multiplicand completely processed.
549: ;
550: movl (r11)+,r2 ; R2 = Multiplier.
551: beql 999$ ; If eq, not specified.
552: blss 1500$ ; This unfolds the compensation
553: ; test out of the loop.
554: ;
555: ; This version of the multiply loop is entered when the multiplier is positive
556: ; saving three instructions per unit of precision.
557: ;
558: .align quad,1 ; Align with NOPs.
559: 500$: movl (r3)+,r6 ; R6 = Current multplicand.
560: emul r2,r6,#0,(r4) ; Multiply (64-bit result).
561: ;
562: ; Because we have removed leading zeroes, multiplication by zero is very
563: ; unlikely, 1 in 2^32 or so. It is therefore easier to perform the test after
564: ; the EMUL (looking at the zero product) that the multiplicand was zero so we
565: ; don't need any special case logic later to adjust the product pointer.
566: ;
567: beql 550$ ; If result eq, skip.
568: tstl r6 ; Was multiplicand negative?
569: bgeq 550$ ; No, skip.
570: addl2 r2,4(r4) ; Yes, compensate.
571: 550$: addl2 r0,(r4)+ ; Accumulate.
572: adwc r1,(r4)+
573: movl (r4),r1 ; R1 = Next hi-end partial sum.
574: adwc r7,r1 ; Add carry if needed.
575: clrl r7 ; Reset lookahead register.
576: adwc #0,r7 ; Save lookahead carry.
577: movl -(r4),r0 ; R0 = Next lo-end partial.
578: sobgtr r5,500$ ; More units?
579: 999$: sobgtr r10,200$ ; Nope, go get next multiplier
580: ret
581: ;
582: ; This version of the above multiply loop is entered when the multiplier is
583: ; negative - and we must compensate by adding the multiplicand to the hi-order
584: ; product. This saves a test and a conditional branch per unit of precision.
585: ;
586: .align quad,1 ; Align with NOPs.
587: 1500$:
588: movl (r3)+,r6 ; R6 = Current multplicand.
589: emul r2,r6,#0,(r4) ; Multiply (64-bit result).
590: ;
591: ; Because we have removed leading zeroes, multiplication by zero is very
592: ; unlikely, 1 in 2^32 or so. It is therefore easier to perform the test after
593: ; the EMUL (looking at the zero product) that the multiplicand was zero so we
594: ; don't need any special case logic later to adjust the product pointer.
595: ;
596: beql 1560$ ; If result eq, skip.
597: tstl r6 ; Was multiplicand negative?
598: bgeq 1550$ ; No, skip.
599: addl2 r2,4(r4) ; Yes, compensate.
600: 1550$:
601: ; As documented above, we unfolded the following to save instructions
602: ; tstl r2 ; Multiplier negative?
603: ; bgeq 1560$ ; No, skip.
604: addl2 r6,4(r4) ; Yes, compensate.
605: 1560$: addl2 r0,(r4)+ ; Accumulate.
606: adwc r1,(r4)+ ; R1 = High-end partial sum.
607: movl (r4),r1 ; R1 = Next hi-end partial sum.
608: adwc r7,r1 ; Add carry if needed.
609: clrl r7 ; Reset lookahead register.
610: adwc #0,r7 ; Save lookahead carry.
611: movl -(r4),r0 ; R0 = Next lo-end partial.
612: sobgtr r5,1500$ ; More units?
613: sobgtr r10,200$ ; Nope, go get next multiplier
614: ret
615:
616: .sbttl P_SETP Set Precison.
617: ;+
618: ; **-P_SETP-Set Precision
619: ;
620: ; Functional Description:
621: ;
622: ; This procedure is invoked to set the operating precision of the package.
623: ;
624: ; Calling Sequence:
625: ;
626: ; P_SETP nbits
627: ;
628: ; Parameters:
629: ;
630: ; nbits rw*v Number of bits in number.
631: ;
632: ; Implicit Outputs:
633: ;
634: ; Precis Set to the number of longwords required to implement
635: ; the requested precision.
636: ; Addoff This is used as an offset into the various tables
637: ; of adds, subtracts and rotates to implement the
638: ; operation to the requested precsion.
639: ;
640: ; Status Returns:
641: ;
642: ; None.
643: ;
644: ; Side Effects:
645: ;
646: ; If the maximum precision set in 32-bit units by the assembly
647: ; parameter "max_unit_prec" is exceeded, a message to that effect will
648: ; be displayed and the program will terminate with a fatal error.
649: ;-
650:
651: .entry p_setp,^m<>
652:
653: movzwl 4(ap),r1 ; R1 = No. of bits.
654: addl2 #31,r1 ; Round up to next long word.
655: ashl #-5,r1,r1 ; R1 = No. of 32 bit words.
656: movl r1,precis ; Save precision.
657:
658: .if not_defined novector
659:
660: subl3 r1,#max_unit_prec,r0 ; R0 = Number of steps reqd.
661: blss 10$ ; If > 0 then exit.
662: mull3 #addsiz,r0,addoff ; Get add table offset.
663:
664: .iftf ; novector
665:
666: ret
667:
668: .ift ; novector
669:
670: 10$: ; Table size exceeded!
671: movab -80(sp),sp ; Output buffer.
672: pushab (sp) ; Build descriptor
673: movzwl #80,-(sp)
674: clrl -(sp) ; Receive return length.
675: pushl #max_unit_prec ; Compiled max table size.
676: pushl r1 ; Requested table size.
677: pushaq 8+4(sp) ; -> Output buffer descriptor.
678: pushaw 12(sp) ; -> Returned length.
679: pushaq prectoobig ; -> FAO control string.
680: calls #5,g^sys$fao ; Format output string.
681: movl (sp)+,(sp) ; Set actual buffer size.
682: pushaq (sp) ; -> Output buffer descr.
683: calls #1,g^lib$put_output ; Output message.
684: $exit_s - ; Exit with severe error.
685: code=#4
686:
687: .endc ; novector
688:
689: .end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.