![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genp2c.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to genp2c.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Generator for planar to chunky conversions
5: *
6: * Copyright 1997 Bernd Schmidt
7: */
8:
9:
10: #include <stdio.h>
11:
12: #include "sysconfig.h"
13: #include "sysdeps.h"
14:
15: #include "custom.h"
16:
17: static char *gen_ind (char *a, int b)
18: {
19: char buf[200];
20: sprintf (buf, "%d(%s)", b, a);
21: return strdup (buf);
22: }
23:
24: static char *gen_indx (char *a, int b, char *c, int d)
25: {
26: char buf[200];
27: sprintf (buf, "%d(%s,%s,%d)", b, a, c, d);
28: return strdup (buf);
29: }
30:
31: static char *gen_indsx (char *a, char *sym, int b, char *c, int d)
32: {
33: char buf[200];
34: sprintf (buf, "%s+%d(%s,%s,%d)", sym, b, a, c, d);
35: return strdup (buf);
36: }
37:
38: #define reg(a) "%" a
39: #define ind(a,b) #b"("a")"
40: #define imm(a) "$"#a
41: #define sym(a) #a
42: #define indx(a,b,c,d) #b"("a","c","#d")"
43: #define indsx(a,s,b,c,d) s"+"#b"("a","c","#d")"
44:
45: static int labelno = 0;
46:
47: static int get_label (void)
48: {
49: return labelno++;
50: }
51: static void declare_label (int nr)
52: {
53: printf (".L%d:\n", nr);
54: }
55: static int new_label (void)
56: {
57: int nr = get_label ();
58: declare_label (nr);
59: return nr;
60: }
61: static void gen_label (int nr) { printf (".L%d", nr); }
62: static void jnz (int nr) { printf ("\tjnz "); gen_label (nr); printf ("\n"); }
63: static void jnc (int nr) { printf ("\tjnc "); gen_label (nr); printf ("\n"); }
64: static void jc (int nr) { printf ("\tjc "); gen_label (nr); printf ("\n"); }
65: static void jmp (int nr) { printf ("\tjmp "); gen_label (nr); printf ("\n"); }
66: static void movl (char *src, char *dst) { printf ("\tmovl %s,%s\n", src, dst); }
67: static void movw (char *src, char *dst) { printf ("\tmovl %s,%s\n", src, dst); }
68: static void movb (char *src, char *dst) { printf ("\tmovl %s,%s\n", src, dst); }
69: static void movzbl (char *src, char *dst) { printf ("\tmovzbl %s,%s\n", src, dst); }
70: static void leal (char *src, char *dst) { printf ("\tleal %s,%s\n", src, dst); }
71: static void addl (char *src, char *dst) { printf ("\taddl %s,%s\n", src, dst); }
72: static void subl (char *src, char *dst) { printf ("\tsubl %s,%s\n", src, dst); }
73: static void cmpl (char *src, char *dst) { printf ("\tcmpl %s,%s\n", src, dst); }
74: static void andl (unsigned long mask, char *dst) { printf ("\tandl $0x%0lx,%s\n", mask, dst); }
75: static void orl (char *src, char *dst) { printf ("\torl %s,%s\n", src, dst); }
76: static void imull (unsigned long val, char *dst) { printf ("\timull $0x%08lx,%s\n", val, dst); }
77: static void decl (char *dst) { printf ("\tdecl %s\n", dst); }
78: static void incl (char *dst) { printf ("\tincl %s\n", dst); }
79: static void bswapl (char *dst) { printf ("\tbswapl %s\n", dst); }
80: static void shrl (int count, char *dst) { printf ("\tshrl $%d,%s\n", count, dst); }
81: static void shll (int count, char *dst) { printf ("\tshll $%d,%s\n", count, dst); }
82: static void pushl (char *src) { printf ("\tpushl %s\n", src); }
83: static void popl (char *dst) { printf ("\tpopl %s\n", dst); }
84: static void ret (void) { printf ("\tret\n"); }
85: static void align (int a) { printf ("\t.align %d\n", 1 << a); }
86: static void shiftleftl (int count, char *dst)
87: {
88: if (count == 0)
89: return;
90: if (count < 0)
91: shrl (-count, dst);
92: else {
93: char *indb0;
94: switch (count) {
95: case 1:
96: addl (dst, dst);
97: break;
98: case 2: case 3:
99: indb0 = gen_indx ("", 0, dst, 1 << count);
100: leal (indb0, dst);
101: free (indb0);
102: break;
103: default:
104: shll (count, dst);
105: }
106: }
107: }
108:
109: static void declare_fn (char *name)
110: {
111: printf ("\t.globl %s\n", name);
112: printf ("\t.type %s,@function\n", name);
113: align (5);
114: printf ("%s:\n", name);
115: }
116:
117: #define esi reg("esi")
118: #define edi reg("edi")
119: #define ebp reg("ebp")
120: #define esp reg("esp")
121: #define eax reg("eax")
122: #define ebx reg("ebx")
123: #define ecx reg("ecx")
124: #define edx reg("edx")
125:
126: /* Modes:
127: * 0: normal
128: * 1: only generate every second plane, set memory
129: * 2: only generate every second plane, starting at second plane, or to memory
130: */
131:
132: /* Normal code: one pixel per bit */
133: static void gen_x86_set_hires_h_toobad_k6_too_slow_someone_try_this_with_a_ppro (int pl, int mode)
134: {
135: int plmul = mode == 0 ? 1 : 2;
136: int ploff = mode == 2 ? 1 : 0;
137: int i;
138: int loop;
139: char buf[40];
140: char *indb0;
141:
142: sprintf (buf, "set_hires_h_%d_%d", pl, mode);
143: declare_fn (buf);
144:
145: pushl (ebp);
146: pushl (esi);
147: pushl (edi);
148: pushl (ebx);
149:
150: if (pl == 0) {
151: movl (ind (esp, 20), ebp);
152: movl (ind (esp, 24), esi);
153: }
154: movl (imm (0), edi);
155:
156: loop = get_label ();
157: jmp (loop);
158: align (5);
159: declare_label (loop);
160:
161: if (pl > 0)
162: movl (ind (esp, 24), esi);
163: if (mode == 2) {
164: if (pl > 0)
165: movl (ind (esp, 20), ebp);
166: movl (indx (ebp, 0, edi, 8), ecx);
167: movl (indx (ebp, 4, edi, 8), ebx);
168: }
169: for (i = 0; i <= pl; i+=2) {
170: int realpl = i * plmul + ploff;
171: char *data1 = (i == 0 && mode != 2 ? ecx : edx);
172: char *data2 = (i == 0 && mode != 2 ? ebx : eax);
173:
174: if (i < pl) {
175: indb0 = gen_indx (esi, (realpl + plmul)*MAX_WORDS_PER_LINE*2, edi, 1);
176: movzbl (indb0, ebp);
177: free (indb0);
178: imull (0x08040201, ebp);
179: }
180:
181: indb0 = gen_indx (esi, realpl*MAX_WORDS_PER_LINE*2, edi, 1);
182: movzbl (indb0, data2);
183: free (indb0);
184:
185: if (i == pl || i == pl - 1)
186: incl (edi);
187: imull (0x08040201, data2);
188: if (i < pl) {
189: movl (ebp, esi);
190: andl (0x08080808, ebp);
191: shiftleftl (realpl + plmul - 7, esi);
192: }
193: movl (data2, data1);
194: andl (0x08080808, data2);
195: shiftleftl (realpl - 7, data1);
196: if (i < pl) {
197: andl (0x01010101 << (realpl + plmul), esi);
198: }
199: andl (0x01010101 << realpl, data1);
200: shiftleftl (realpl - 3, data2);
201: if (i < pl) {
202: shiftleftl (realpl + plmul - 3, ebp);
203: }
204: if (i < pl) {
205: orl (esi, ecx);
206: movl (ind (esp, 24), esi);
207: orl (ebp, ebx);
208: }
209: if (i > 0 || mode == 2) {
210: orl (edx, ecx);
211: orl (eax, ebx);
212: }
213: }
214: if (pl > 0)
215: movl (ind (esp, 20), ebp);
216: cmpl (ind (esp, 28), edi);
217: movl (ecx, indx (ebp, -8, edi, 8));
218: movl (ebx, indx (ebp, -4, edi, 8));
219: jc (loop);
220:
221: popl (reg ("ebx"));
222: popl (reg ("edi"));
223: popl (reg ("esi"));
224: popl (reg ("ebp"));
225: ret ();
226: printf ("\n\n");
227: }
228:
229: static void gen_x86_set_hires_h (int pl, int mode)
230: {
231: int plmul = mode == 0 ? 1 : 2;
232: int ploff = mode == 2 ? 1 : 0;
233: int i;
234: int loop;
235: char buf[40];
236: char *indb0;
237:
238: sprintf (buf, "set_hires_h_%d_%d", pl, mode);
239: declare_fn (buf);
240:
241: pushl (ebp);
242: pushl (esi);
243: pushl (edi);
244: pushl (ebx);
245:
246: if (pl == 0) {
247: movl (ind (esp, 20), ebp);
248: movl (ind (esp, 24), esi);
249: }
250: movl (imm (0), edi);
251:
252: loop = get_label ();
253: jmp (loop);
254: align (5);
255: declare_label (loop);
256:
257: if (pl > 0)
258: movl (ind (esp, 24), esi);
259: if (mode == 2) {
260: if (pl > 0)
261: movl (ind (esp, 20), ebp);
262: movl (indx (ebp, 0, edi, 8), ecx);
263: movl (indx (ebp, 4, edi, 8), ebx);
264: }
265: for (i = 0; i <= pl; i+=2) {
266: int realpl = i * plmul + ploff;
267: char *data1 = (i == 0 && mode != 2 ? ecx : edx);
268: char *data2 = (i == 0 && mode != 2 ? ebx : eax);
269:
270: if (i < pl) {
271: indb0 = gen_indx (esi, (realpl + plmul)*MAX_WORDS_PER_LINE*2, edi, 1);
272: movzbl (indb0, ebp);
273: free (indb0);
274: }
275: indb0 = gen_indx (esi, realpl*MAX_WORDS_PER_LINE*2, edi, 1);
276: movzbl (indb0, data2);
277: free (indb0);
278: if (i < pl) {
279: indb0 = gen_indsx ("", sym (hirestab_h), 0, ebp, 8);
280: movl (indb0, esi);
281: free (indb0);
282: indb0 = gen_indsx ("", sym (hirestab_h), 4, ebp, 8);
283: movl (indb0, ebp);
284: free (indb0);
285: }
286: if (i == pl || i == pl - 1)
287: incl (edi);
288: indb0 = gen_indsx ("", sym (hirestab_h), 0, data2, 8);
289: movl (indb0, data1);
290: free (indb0);
291: indb0 = gen_indsx ("", sym (hirestab_h), 4, data2, 8);
292: movl (indb0, data2);
293: free (indb0);
294: switch (realpl) {
295: case 0:
296: if (i < pl) {
297: addl (esi, esi);
298: addl (ebp, ebp);
299: if (plmul == 2) {
300: addl (esi, esi);
301: addl (ebp, ebp);
302: }
303: }
304: break;
305: case 1:
306: if (i < pl) {
307: indb0 = gen_indx ("", 0, esi, 4*plmul);
308: leal (indb0, esi);
309: free (indb0);
310: indb0 = gen_indx ("", 0, ebp, 4*plmul);
311: leal (indb0, ebp);
312: free (indb0);
313: }
314: addl (data1, data1);
315: addl (data2, data2);
316: break;
317: case 2:
318: if (i < pl) {
319: if (plmul == 1)
320: leal (indx ("", 0, esi, 8), esi);
321: else
322: shll (4, esi);
323: }
324: addl (data1, data1);
325: addl (data2, data2);
326: if (i < pl) {
327: if (plmul == 1)
328: leal (indx ("", 0, ebp, 8), ebp);
329: else
330: shll (4, ebp);
331: }
332: addl (data1, data1);
333: addl (data2, data2);
334: break;
335: case 3:
336: if (i < pl)
337: shll (3 + plmul, esi);
338: indb0 = gen_indx ("", 0, data1, 8);
339: leal (indb0, data1);
340: free (indb0);
341: if (i < pl)
342: shll (3 + plmul, ebp);
343: indb0 = gen_indx ("", 0, data2, 8);
344: leal (indb0, data2);
345: free (indb0);
346: break;
347: case 4: case 5: case 6: case 7:
348: shll (realpl, data1);
349: shll (realpl, data2);
350: if (i < pl) {
351: shll (realpl+plmul, esi);
352: shll (realpl+plmul, ebp);
353: }
354: break;
355: }
356:
357: if (i < pl) {
358: orl (esi, ecx);
359: orl (ebp, ebx);
360: if (i + 2 <= pl)
361: movl (ind (esp, 24), esi);
362: }
363: if (i + 2 > pl && pl > 0)
364: movl (ind (esp, 20), ebp);
365: if (i > 0 || mode == 2) {
366: orl (data1, ecx);
367: orl (data2, ebx);
368: }
369: }
370:
371: cmpl (ind (esp, 28), edi);
372: movl (ecx, indx (ebp, -8, edi, 8));
373: movl (ebx, indx (ebp, -4, edi, 8));
374: jc (loop);
375:
376: popl (reg ("ebx"));
377: popl (reg ("edi"));
378: popl (reg ("esi"));
379: popl (reg ("ebp"));
380: ret ();
381: printf ("\n\n");
382: }
383:
384: /* Squeeze: every second bit does not generate a pixel
385: Not optimized, this mode isn't useful. */
386: static void gen_x86_set_hires_l (int pl, int mode)
387: {
388: int plmul = mode == 0 ? 1 : 2;
389: int ploff = mode == 2 ? 1 : 0;
390: int i;
391: int loop;
392: char buf[40];
393:
394: sprintf (buf, "set_hires_l_%d_%d", pl, mode);
395: declare_fn (buf);
396:
397: pushl (ebp);
398: pushl (esi);
399: pushl (edi);
400: pushl (ebx);
401:
402: movl (ind (esp, 20), ebp);
403: movl (ind (esp, 24), esi);
404: movl (imm (0), edi);
405:
406: align (5);
407: loop = new_label ();
408:
409: if (mode == 2) {
410: movl (indx (ebp, 0, edi, 1), ecx);
411: }
412:
413: for (i = 0; i <= pl; i++) {
414: int realpl = i * plmul + ploff;
415: char *data1 = (i == 0 && mode != 2 ? ecx : edx);
416: char *indb0;
417:
418: indb0 = gen_indx (esi, realpl*MAX_WORDS_PER_LINE*2, edi, 1);
419: movzbl (indb0, data1);
420: free (indb0);
421:
422: indb0 = gen_indsx ("", sym (hirestab_l), 0, data1, 4);
423: movl (indb0, data1);
424: free (indb0);
425: if (i == pl)
426: incl (edi);
427: shiftleftl (realpl, data1);
428: if (i > 0 || mode == 2) {
429: orl (data1, ecx);
430: }
431: }
432: cmpl (ind (esp, 28), edi);
433: movl (ecx, indx (ebp, -4, edi, 4));
434: jc (loop);
435:
436: popl (reg ("ebx"));
437: popl (reg ("edi"));
438: popl (reg ("esi"));
439: popl (reg ("ebp"));
440: ret ();
441: printf ("\n\n");
442: }
443:
444: /* Stretch: two pixels per bit */
445: static void gen_x86_set_lores_h (int pl, int mode)
446: {
447: int plmul = mode == 0 ? 1 : 2;
448: int ploff = mode == 2 ? 1 : 0;
449: int i, j;
450: int loop;
451: char buf[40];
452:
453: sprintf (buf, "set_lores_h_%d_%d", pl, mode);
454: declare_fn (buf);
455:
456: pushl (ebp);
457: pushl (esi);
458: pushl (edi);
459: pushl (ebx);
460:
461: movl (ind (esp, 20), ebp);
462: movl (ind (esp, 24), esi);
463: movl (imm (0), edi);
464:
465: align (5);
466: loop = new_label ();
467:
468: for (j = 0; j < 2; j++) {
469: if (mode == 2) {
470: movl (j ? ind (ebp, 8) : ind (ebp, 0), ecx);
471: movl (j ? ind (ebp, 12) : ind (ebp, 4), ebx);
472: }
473:
474: for (i = 0; i <= pl; i++) {
475: int realpl = i * plmul + ploff;
476: char *data1 = (i == 0 && mode != 2 ? ecx : edx);
477: char *data2 = (i == 0 && mode != 2 ? ebx : eax);
478: char *indb0;
479:
480: indb0 = gen_indx (esi, realpl*MAX_WORDS_PER_LINE*2, edi, 1);
481: movzbl (indb0, data2);
482: free (indb0);
483: addl (data2, data2);
484: indb0 = gen_indsx ("", sym (lorestab_h), 0 + j*8, data2, 8);
485: movl (indb0, data1);
486: free (indb0);
487: indb0 = gen_indsx ("", sym (lorestab_h), 4 + j*8, data2, 8);
488: movl (indb0, data2);
489: free (indb0);
490: shiftleftl (realpl, data1);
491: shiftleftl (realpl, data2);
492: if (i > 0 || mode == 2) {
493: orl (data1, ecx);
494: orl (data2, ebx);
495: }
496: }
497: movl (ecx, j ? ind (ebp, 8) : ind (ebp, 0));
498: movl (ebx, j ? ind (ebp, 12) : ind (ebp, 4));
499: }
500: incl (edi);
501: cmpl (ind (esp, 28), edi);
502: leal (ind (ebp, 16), ebp);
503: jc (loop);
504:
505: popl (reg ("ebx"));
506: popl (reg ("edi"));
507: popl (reg ("esi"));
508: popl (reg ("ebp"));
509: ret ();
510: printf ("\n\n");
511: }
512:
513:
514: /* Normal code: one pixel per bit */
515: static void gen_c_set_hires_h (int pl, int mode, int header)
516: {
517: int plmul = mode == 0 ? 1 : 2;
518: int ploff = mode == 2 ? 1 : 0;
519: int i;
520:
521: if (header)
522: printf("extern ");
523: printf ("void set_hires_h_%d_%d (uae_u32 *app, uae_u8 *ptr, int len)", pl, mode);
524: if (header) {
525: printf (";\n");
526: return;
527: }
528:
529: printf ("\n\{\n\tint i;\n\tfor (i = 0; i < len; i++) {\n\t\tuae_u32 v1, v2;\n");
530:
531: if (mode == 2) {
532: printf ("\t\tv1 = app[i*2 + 0]; v2 = app[i*2 + 1];\n");
533: }
534:
535: for (i = 0; i <= pl; i++) {
536: int realpl = i * plmul + ploff;
537: char *asgn = (i == 0 && mode != 2 ? "=" : "|=");
538:
539: printf ("\t\t{\n");
540: printf ("\t\t\tunsigned int data = *(ptr + i + %d);\n", MAX_WORDS_PER_LINE*2*realpl);
541:
542: printf ("\t\t\tv1 %s hirestab_h[data][0] << %d;\n", asgn, realpl);
543: printf ("\t\t\tv2 %s hirestab_h[data][1] << %d;\n", asgn, realpl);
544: printf ("\t\t}\n");
545: }
546: printf ("\t\tapp[i*2 + 0] = v1;\n");
547: printf ("\t\tapp[i*2 + 1] = v2;\n");
548: printf ("\t}\n");
549: printf ("}\n\n");
550: }
551:
552: /* Squeeze: every second bit does not generate a pixel
553: Not optimized, this mode isn't useful. */
554: static void gen_c_set_hires_l (int pl, int mode, int header)
555: {
556: int plmul = mode == 0 ? 1 : 2;
557: int ploff = mode == 2 ? 1 : 0;
558: int i;
559: int loop;
560:
561: if (header)
562: printf("extern ");
563: printf ("void set_hires_l_%d_%d (uae_u32 *app, uae_u8 *ptr, int len)", pl, mode);
564: if (header) {
565: printf (";\n");
566: return;
567: }
568:
569: printf ("\n\{\n\tint i;\n\tfor (i = 0; i < len; i++) {\n\t\tuae_u32 v1;\n");
570:
571: if (mode == 2) {
572: printf ("\t\tv1 = app[i];\n");
573: }
574:
575: for (i = 0; i <= pl; i++) {
576: int realpl = i * plmul + ploff;
577: char *asgn = (i == 0 && mode != 2 ? "=" : "|=");
578:
579: printf ("\t\t{\n");
580: printf ("\t\t\tunsigned int data = *(ptr + i + %d);\n", MAX_WORDS_PER_LINE*2*realpl);
581:
582: printf ("\t\t\tv1 %s hirestab_l[data][0] << %d;\n", asgn, realpl);
583: printf ("\t\t}\n");
584: }
585: printf ("\t\tapp[i] = v1;\n");
586: printf ("\t}\n");
587: printf ("}\n\n");
588: }
589:
590: /* Stretch: two pixels per bit */
591: static void gen_c_set_lores_h (int pl, int mode, int header)
592: {
593: int plmul = mode == 0 ? 1 : 2;
594: int ploff = mode == 2 ? 1 : 0;
595: int i, j;
596:
597: if (header)
598: printf("extern ");
599: printf ("void set_lores_h_%d_%d (uae_u32 *app, uae_u8 *ptr, int len)", pl, mode);
600: if (header) {
601: printf (";\n");
602: return;
603: }
604:
605: printf ("\n\{\n\tint i;\n\tfor (i = 0; i < len; i++) {\n\t\tuae_u32 v1, v2, v3, v4;\n");
606:
607: if (mode == 2) {
608: printf ("\t\tv1 = app[i*4 + 0]; v2 = app[i*4 + 1]; v3 = app[i*4 + 2]; v4 = app[i*4 + 3];\n");
609: }
610:
611: for (i = 0; i <= pl; i++) {
612: int realpl = i * plmul + ploff;
613: char *asgn = (i == 0 && mode != 2 ? "=" : "|=");
614:
615: printf ("\t\t{\n");
616: printf ("\t\t\tunsigned int data = *(ptr + i + %d);\n", MAX_WORDS_PER_LINE*2*realpl);
617:
618: printf ("\t\t\tv1 %s lorestab_h[data][0] << %d;\n", asgn, realpl);
619: printf ("\t\t\tv2 %s lorestab_h[data][1] << %d;\n", asgn, realpl);
620: printf ("\t\t\tv3 %s lorestab_h[data][2] << %d;\n", asgn, realpl);
621: printf ("\t\t\tv4 %s lorestab_h[data][3] << %d;\n", asgn, realpl);
622: printf ("\t\t}\n");
623: }
624: printf ("\t\tapp[i*4 + 0] = v1;\n");
625: printf ("\t\tapp[i*4 + 1] = v2;\n");
626: printf ("\t\tapp[i*4 + 2] = v3;\n");
627: printf ("\t\tapp[i*4 + 3] = v4;\n");
628: printf ("\t}\n");
629: printf ("}\n\n");
630: }
631:
632: int main(int argc, char **argv)
633: {
634: int pl;
635: int outmode;
636:
637: if (argc != 2)
638: return 1;
639: if (strcmp (argv[1], "C") == 0)
640: outmode = 0;
641: else if (strcmp (argv[1], "H") == 0)
642: outmode = 1;
643: else if (strcmp (argv[1], "x86") == 0)
644: outmode = 2;
645: else
646: return 1;
647:
648: switch (outmode) {
649: case 0:
650: printf ("#include \"sysconfig.h\"\n");
651: printf ("#include \"sysdeps.h\"\n");
652: printf ("#include \"custom.h\"\n");
653: printf ("#include \"p2c.h\"\n");
654: break;
655: case 1:
656: printf ("#define MAX_WORDS_PER_LINE %d\n", MAX_WORDS_PER_LINE);
657: break;
658: case 2:
659: printf ("#define MAX_WORDS_PER_LINE %d\n", MAX_WORDS_PER_LINE);
660: printf (".text\n");
661: break;
662: }
663: for (pl = 0; pl < 8; pl++) {
664: int j;
665: for (j = 0; j < (pl < 4 ? 3 : 1); j++) {
666: switch (outmode) {
667: case 0: case 1:
668: gen_c_set_hires_h (pl, j, outmode);
669: gen_c_set_hires_l (pl, j, outmode);
670: gen_c_set_lores_h (pl, j, outmode);
671: break;
672: case 2:
673: gen_x86_set_hires_h (pl, j);
674: gen_x86_set_hires_l (pl, j);
675: gen_x86_set_lores_h (pl, j);
676: break;
677: }
678: }
679: }
680:
681: return 0;
682: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.