![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printgprof.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / gprof|
Return to printgprof.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / gprof |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that: (1) source distributions retain this entire copyright
7: * notice and comment, and (2) distributions including binaries display
8: * the following acknowledgement: ``This product includes software
9: * developed by the University of California, Berkeley and its contributors''
10: * in the documentation or other materials provided with the distribution
11: * and in all advertising materials mentioning features or use of this
12: * software. Neither the name of the University nor the names of its
13: * contributors may be used to endorse or promote products derived
14: * from this software without specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)printgprof.c 5.7 (Berkeley) 6/1/90";
22: #endif /* not lint */
23:
24: #include "gprof.h"
25: #include "pathnames.h"
26:
27: printprof()
28: {
29: register nltype *np;
30: nltype **sortednlp;
31: int index, timecmp();
32:
33: actime = 0.0;
34: printf( "\f\n" );
35: flatprofheader();
36: /*
37: * Sort the symbol table in by time
38: */
39: sortednlp = (nltype **) calloc( nname , sizeof(nltype *) );
40: if ( sortednlp == (nltype **) 0 ) {
41: fprintf( stderr , "[printprof] ran out of memory for time sorting\n" );
42: }
43: for ( index = 0 ; index < nname ; index += 1 ) {
44: sortednlp[ index ] = &nl[ index ];
45: }
46: qsort( sortednlp , nname , sizeof(nltype *) , timecmp );
47: for ( index = 0 ; index < nname ; index += 1 ) {
48: np = sortednlp[ index ];
49: flatprofline( np );
50: }
51: actime = 0.0;
52: cfree( sortednlp );
53: }
54:
55: timecmp( npp1 , npp2 )
56: nltype **npp1, **npp2;
57: {
58: double timediff;
59: long calldiff;
60:
61: timediff = (*npp2) -> time - (*npp1) -> time;
62: if ( timediff > 0.0 )
63: return 1 ;
64: if ( timediff < 0.0 )
65: return -1;
66: calldiff = (*npp2) -> ncall - (*npp1) -> ncall;
67: if ( calldiff > 0 )
68: return 1;
69: if ( calldiff < 0 )
70: return -1;
71: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
72: }
73:
74: /*
75: * header for flatprofline
76: */
77: flatprofheader()
78: {
79:
80: if ( bflag ) {
81: printblurb( _PATH_FLAT_BLURB );
82: }
83: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
84: (long) scale * sizeof(UNIT) );
85: if ( totime > 0.0 ) {
86: printf( " for %.2f%% of %.2f seconds\n\n" ,
87: 100.0/totime , totime / hz );
88: } else {
89: printf( " no time accumulated\n\n" );
90: /*
91: * this doesn't hurt sinc eall the numerators will be zero.
92: */
93: totime = 1.0;
94: }
95: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
96: "% " , "cumulative" , "self " , "" , "self " , "total " , "" );
97: printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" ,
98: "time" , "seconds " , "seconds" , "calls" ,
99: "ms/call" , "ms/call" , "name" );
100: }
101:
102: flatprofline( np )
103: register nltype *np;
104: {
105:
106: if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) {
107: return;
108: }
109: actime += np -> time;
110: printf( "%5.1f %10.2f %8.2f" ,
111: 100 * np -> time / totime , actime / hz , np -> time / hz );
112: if ( np -> ncall != 0 ) {
113: printf( " %8d %8.2f %8.2f " , np -> ncall ,
114: 1000 * np -> time / hz / np -> ncall ,
115: 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall );
116: } else {
117: printf( " %8.8s %8.8s %8.8s " , "" , "" , "" );
118: }
119: printname( np );
120: printf( "\n" );
121: }
122:
123: gprofheader()
124: {
125:
126: if ( bflag ) {
127: printblurb( _PATH_CALLG_BLURB );
128: }
129: printf( "\ngranularity: each sample hit covers %d byte(s)" ,
130: (long) scale * sizeof(UNIT) );
131: if ( printtime > 0.0 ) {
132: printf( " for %.2f%% of %.2f seconds\n\n" ,
133: 100.0/printtime , printtime / hz );
134: } else {
135: printf( " no time propagated\n\n" );
136: /*
137: * this doesn't hurt, since all the numerators will be 0.0
138: */
139: printtime = 1.0;
140: }
141: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
142: "" , "" , "" , "" , "called" , "total" , "parents");
143: printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" ,
144: "index" , "%time" , "self" , "descendents" ,
145: "called" , "self" , "name" , "index" );
146: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" ,
147: "" , "" , "" , "" , "called" , "total" , "children");
148: printf( "\n" );
149: }
150:
151: gprofline( np )
152: register nltype *np;
153: {
154: char kirkbuffer[ BUFSIZ ];
155:
156: sprintf( kirkbuffer , "[%d]" , np -> index );
157: printf( "%-6.6s %5.1f %7.2f %11.2f" ,
158: kirkbuffer ,
159: 100 * ( np -> propself + np -> propchild ) / printtime ,
160: np -> propself / hz ,
161: np -> propchild / hz );
162: if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
163: printf( " %7d" , np -> ncall );
164: if ( np -> selfcalls != 0 ) {
165: printf( "+%-7d " , np -> selfcalls );
166: } else {
167: printf( " %7.7s " , "" );
168: }
169: } else {
170: printf( " %7.7s %7.7s " , "" , "" );
171: }
172: printname( np );
173: printf( "\n" );
174: }
175:
176: printgprof(timesortnlp)
177: nltype **timesortnlp;
178: {
179: int index;
180: nltype *parentp;
181:
182: /*
183: * Print out the structured profiling list
184: */
185: gprofheader();
186: for ( index = 0 ; index < nname + ncycle ; index ++ ) {
187: parentp = timesortnlp[ index ];
188: if ( zflag == 0 &&
189: parentp -> ncall == 0 &&
190: parentp -> selfcalls == 0 &&
191: parentp -> propself == 0 &&
192: parentp -> propchild == 0 ) {
193: continue;
194: }
195: if ( ! parentp -> printflag ) {
196: continue;
197: }
198: if ( parentp -> name == 0 && parentp -> cycleno != 0 ) {
199: /*
200: * cycle header
201: */
202: printcycle( parentp );
203: printmembers( parentp );
204: } else {
205: printparents( parentp );
206: gprofline( parentp );
207: printchildren( parentp );
208: }
209: printf( "\n" );
210: printf( "-----------------------------------------------\n" );
211: printf( "\n" );
212: }
213: cfree( timesortnlp );
214: }
215:
216: /*
217: * sort by decreasing propagated time
218: * if times are equal, but one is a cycle header,
219: * say that's first (e.g. less, i.e. -1).
220: * if one's name doesn't have an underscore and the other does,
221: * say the one is first.
222: * all else being equal, sort by names.
223: */
224: int
225: totalcmp( npp1 , npp2 )
226: nltype **npp1;
227: nltype **npp2;
228: {
229: register nltype *np1 = *npp1;
230: register nltype *np2 = *npp2;
231: double diff;
232:
233: diff = ( np1 -> propself + np1 -> propchild )
234: - ( np2 -> propself + np2 -> propchild );
235: if ( diff < 0.0 )
236: return 1;
237: if ( diff > 0.0 )
238: return -1;
239: if ( np1 -> name == 0 && np1 -> cycleno != 0 )
240: return -1;
241: if ( np2 -> name == 0 && np2 -> cycleno != 0 )
242: return 1;
243: if ( np1 -> name == 0 )
244: return -1;
245: if ( np2 -> name == 0 )
246: return 1;
247: if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' )
248: return -1;
249: if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
250: return 1;
251: if ( np1 -> ncall > np2 -> ncall )
252: return -1;
253: if ( np1 -> ncall < np2 -> ncall )
254: return 1;
255: return strcmp( np1 -> name , np2 -> name );
256: }
257:
258: printparents( childp )
259: nltype *childp;
260: {
261: nltype *parentp;
262: arctype *arcp;
263: nltype *cycleheadp;
264:
265: if ( childp -> cyclehead != 0 ) {
266: cycleheadp = childp -> cyclehead;
267: } else {
268: cycleheadp = childp;
269: }
270: if ( childp -> parents == 0 ) {
271: printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" ,
272: "" , "" , "" , "" , "" , "" );
273: return;
274: }
275: sortparents( childp );
276: for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) {
277: parentp = arcp -> arc_parentp;
278: if ( childp == parentp ||
279: ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) {
280: /*
281: * selfcall or call among siblings
282: */
283: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
284: "" , "" , "" , "" ,
285: arcp -> arc_count , "" );
286: printname( parentp );
287: printf( "\n" );
288: } else {
289: /*
290: * regular parent of child
291: */
292: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
293: "" , "" ,
294: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
295: arcp -> arc_count , cycleheadp -> ncall );
296: printname( parentp );
297: printf( "\n" );
298: }
299: }
300: }
301:
302: printchildren( parentp )
303: nltype *parentp;
304: {
305: nltype *childp;
306: arctype *arcp;
307:
308: sortchildren( parentp );
309: arcp = parentp -> children;
310: for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
311: childp = arcp -> arc_childp;
312: if ( childp == parentp ||
313: ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) {
314: /*
315: * self call or call to sibling
316: */
317: printf( "%6.6s %5.5s %7.7s %11.11s %7d %7.7s " ,
318: "" , "" , "" , "" , arcp -> arc_count , "" );
319: printname( childp );
320: printf( "\n" );
321: } else {
322: /*
323: * regular child of parent
324: */
325: printf( "%6.6s %5.5s %7.2f %11.2f %7d/%-7d " ,
326: "" , "" ,
327: arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
328: arcp -> arc_count , childp -> cyclehead -> ncall );
329: printname( childp );
330: printf( "\n" );
331: }
332: }
333: }
334:
335: printname( selfp )
336: nltype *selfp;
337: {
338:
339: if ( selfp -> name != 0 ) {
340: printf( "%s" , selfp -> name );
341: # ifdef DEBUG
342: if ( debug & DFNDEBUG ) {
343: printf( "{%d} " , selfp -> toporder );
344: }
345: if ( debug & PROPDEBUG ) {
346: printf( "%5.2f%% " , selfp -> propfraction );
347: }
348: # endif DEBUG
349: }
350: if ( selfp -> cycleno != 0 ) {
351: printf( " <cycle %d>" , selfp -> cycleno );
352: }
353: if ( selfp -> index != 0 ) {
354: if ( selfp -> printflag ) {
355: printf( " [%d]" , selfp -> index );
356: } else {
357: printf( " (%d)" , selfp -> index );
358: }
359: }
360: }
361:
362: sortchildren( parentp )
363: nltype *parentp;
364: {
365: arctype *arcp;
366: arctype *detachedp;
367: arctype sorted;
368: arctype *prevp;
369:
370: /*
371: * unlink children from parent,
372: * then insertion sort back on to sorted's children.
373: * *arcp the arc you have detached and are inserting.
374: * *detachedp the rest of the arcs to be sorted.
375: * sorted arc list onto which you insertion sort.
376: * *prevp arc before the arc you are comparing.
377: */
378: sorted.arc_childlist = 0;
379: for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist);
380: arcp ;
381: (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) {
382: /*
383: * consider *arcp as disconnected
384: * insert it into sorted
385: */
386: for ( prevp = &sorted ;
387: prevp -> arc_childlist ;
388: prevp = prevp -> arc_childlist ) {
389: if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) {
390: break;
391: }
392: }
393: arcp -> arc_childlist = prevp -> arc_childlist;
394: prevp -> arc_childlist = arcp;
395: }
396: /*
397: * reattach sorted children to parent
398: */
399: parentp -> children = sorted.arc_childlist;
400: }
401:
402: sortparents( childp )
403: nltype *childp;
404: {
405: arctype *arcp;
406: arctype *detachedp;
407: arctype sorted;
408: arctype *prevp;
409:
410: /*
411: * unlink parents from child,
412: * then insertion sort back on to sorted's parents.
413: * *arcp the arc you have detached and are inserting.
414: * *detachedp the rest of the arcs to be sorted.
415: * sorted arc list onto which you insertion sort.
416: * *prevp arc before the arc you are comparing.
417: */
418: sorted.arc_parentlist = 0;
419: for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist);
420: arcp ;
421: (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) {
422: /*
423: * consider *arcp as disconnected
424: * insert it into sorted
425: */
426: for ( prevp = &sorted ;
427: prevp -> arc_parentlist ;
428: prevp = prevp -> arc_parentlist ) {
429: if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) {
430: break;
431: }
432: }
433: arcp -> arc_parentlist = prevp -> arc_parentlist;
434: prevp -> arc_parentlist = arcp;
435: }
436: /*
437: * reattach sorted arcs to child
438: */
439: childp -> parents = sorted.arc_parentlist;
440: }
441:
442: /*
443: * print a cycle header
444: */
445: printcycle( cyclep )
446: nltype *cyclep;
447: {
448: char kirkbuffer[ BUFSIZ ];
449:
450: sprintf( kirkbuffer , "[%d]" , cyclep -> index );
451: printf( "%-6.6s %5.1f %7.2f %11.2f %7d" ,
452: kirkbuffer ,
453: 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime ,
454: cyclep -> propself / hz ,
455: cyclep -> propchild / hz ,
456: cyclep -> ncall );
457: if ( cyclep -> selfcalls != 0 ) {
458: printf( "+%-7d" , cyclep -> selfcalls );
459: } else {
460: printf( " %7.7s" , "" );
461: }
462: printf( " <cycle %d as a whole>\t[%d]\n" ,
463: cyclep -> cycleno , cyclep -> index );
464: }
465:
466: /*
467: * print the members of a cycle
468: */
469: printmembers( cyclep )
470: nltype *cyclep;
471: {
472: nltype *memberp;
473:
474: sortmembers( cyclep );
475: for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
476: printf( "%6.6s %5.5s %7.2f %11.2f %7d" ,
477: "" , "" , memberp -> propself / hz , memberp -> propchild / hz ,
478: memberp -> ncall );
479: if ( memberp -> selfcalls != 0 ) {
480: printf( "+%-7d" , memberp -> selfcalls );
481: } else {
482: printf( " %7.7s" , "" );
483: }
484: printf( " " );
485: printname( memberp );
486: printf( "\n" );
487: }
488: }
489:
490: /*
491: * sort members of a cycle
492: */
493: sortmembers( cyclep )
494: nltype *cyclep;
495: {
496: nltype *todo;
497: nltype *doing;
498: nltype *prev;
499:
500: /*
501: * detach cycle members from cyclehead,
502: * and insertion sort them back on.
503: */
504: todo = cyclep -> cnext;
505: cyclep -> cnext = 0;
506: for ( (doing = todo)&&(todo = doing -> cnext);
507: doing ;
508: (doing = todo )&&(todo = doing -> cnext )){
509: for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) {
510: if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) {
511: break;
512: }
513: }
514: doing -> cnext = prev -> cnext;
515: prev -> cnext = doing;
516: }
517: }
518:
519: /*
520: * major sort is on propself + propchild,
521: * next is sort on ncalls + selfcalls.
522: */
523: int
524: membercmp( this , that )
525: nltype *this;
526: nltype *that;
527: {
528: double thistime = this -> propself + this -> propchild;
529: double thattime = that -> propself + that -> propchild;
530: long thiscalls = this -> ncall + this -> selfcalls;
531: long thatcalls = that -> ncall + that -> selfcalls;
532:
533: if ( thistime > thattime ) {
534: return GREATERTHAN;
535: }
536: if ( thistime < thattime ) {
537: return LESSTHAN;
538: }
539: if ( thiscalls > thatcalls ) {
540: return GREATERTHAN;
541: }
542: if ( thiscalls < thatcalls ) {
543: return LESSTHAN;
544: }
545: return EQUALTO;
546: }
547: /*
548: * compare two arcs to/from the same child/parent.
549: * - if one arc is a self arc, it's least.
550: * - if one arc is within a cycle, it's less than.
551: * - if both arcs are within a cycle, compare arc counts.
552: * - if neither arc is within a cycle, compare with
553: * arc_time + arc_childtime as major key
554: * arc count as minor key
555: */
556: int
557: arccmp( thisp , thatp )
558: arctype *thisp;
559: arctype *thatp;
560: {
561: nltype *thisparentp = thisp -> arc_parentp;
562: nltype *thischildp = thisp -> arc_childp;
563: nltype *thatparentp = thatp -> arc_parentp;
564: nltype *thatchildp = thatp -> arc_childp;
565: double thistime;
566: double thattime;
567:
568: # ifdef DEBUG
569: if ( debug & TIMEDEBUG ) {
570: printf( "[arccmp] " );
571: printname( thisparentp );
572: printf( " calls " );
573: printname ( thischildp );
574: printf( " %f + %f %d/%d\n" ,
575: thisp -> arc_time , thisp -> arc_childtime ,
576: thisp -> arc_count , thischildp -> ncall );
577: printf( "[arccmp] " );
578: printname( thatparentp );
579: printf( " calls " );
580: printname( thatchildp );
581: printf( " %f + %f %d/%d\n" ,
582: thatp -> arc_time , thatp -> arc_childtime ,
583: thatp -> arc_count , thatchildp -> ncall );
584: printf( "\n" );
585: }
586: # endif DEBUG
587: if ( thisparentp == thischildp ) {
588: /* this is a self call */
589: return LESSTHAN;
590: }
591: if ( thatparentp == thatchildp ) {
592: /* that is a self call */
593: return GREATERTHAN;
594: }
595: if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 &&
596: thisparentp -> cycleno == thischildp -> cycleno ) {
597: /* this is a call within a cycle */
598: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
599: thatparentp -> cycleno == thatchildp -> cycleno ) {
600: /* that is a call within the cycle, too */
601: if ( thisp -> arc_count < thatp -> arc_count ) {
602: return LESSTHAN;
603: }
604: if ( thisp -> arc_count > thatp -> arc_count ) {
605: return GREATERTHAN;
606: }
607: return EQUALTO;
608: } else {
609: /* that isn't a call within the cycle */
610: return LESSTHAN;
611: }
612: } else {
613: /* this isn't a call within a cycle */
614: if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
615: thatparentp -> cycleno == thatchildp -> cycleno ) {
616: /* that is a call within a cycle */
617: return GREATERTHAN;
618: } else {
619: /* neither is a call within a cycle */
620: thistime = thisp -> arc_time + thisp -> arc_childtime;
621: thattime = thatp -> arc_time + thatp -> arc_childtime;
622: if ( thistime < thattime )
623: return LESSTHAN;
624: if ( thistime > thattime )
625: return GREATERTHAN;
626: if ( thisp -> arc_count < thatp -> arc_count )
627: return LESSTHAN;
628: if ( thisp -> arc_count > thatp -> arc_count )
629: return GREATERTHAN;
630: return EQUALTO;
631: }
632: }
633: }
634:
635: printblurb( blurbname )
636: char *blurbname;
637: {
638: FILE *blurbfile;
639: int input;
640:
641: blurbfile = fopen( blurbname , "r" );
642: if ( blurbfile == NULL ) {
643: perror( blurbname );
644: return;
645: }
646: while ( ( input = getc( blurbfile ) ) != EOF ) {
647: putchar( input );
648: }
649: fclose( blurbfile );
650: }
651:
652: int
653: namecmp( npp1 , npp2 )
654: nltype **npp1, **npp2;
655: {
656: return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
657: }
658:
659: printindex()
660: {
661: nltype **namesortnlp;
662: register nltype *nlp;
663: int index, nnames, todo, i, j;
664: char peterbuffer[ BUFSIZ ];
665:
666: /*
667: * Now, sort regular function name alphbetically
668: * to create an index.
669: */
670: namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) );
671: if ( namesortnlp == (nltype **) 0 ) {
672: fprintf( stderr , "%s: ran out of memory for sorting\n" , whoami );
673: }
674: for ( index = 0 , nnames = 0 ; index < nname ; index++ ) {
675: if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 )
676: continue;
677: namesortnlp[nnames++] = &nl[index];
678: }
679: qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp );
680: for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) {
681: namesortnlp[todo++] = &cyclenl[index];
682: }
683: printf( "\f\nIndex by function name\n\n" );
684: index = ( todo + 2 ) / 3;
685: for ( i = 0; i < index ; i++ ) {
686: for ( j = i; j < todo ; j += index ) {
687: nlp = namesortnlp[ j ];
688: if ( nlp -> printflag ) {
689: sprintf( peterbuffer , "[%d]" , nlp -> index );
690: } else {
691: sprintf( peterbuffer , "(%d)" , nlp -> index );
692: }
693: if ( j < nnames ) {
694: printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name );
695: } else {
696: printf( "%6.6s " , peterbuffer );
697: sprintf( peterbuffer , "<cycle %d>" , nlp -> cycleno );
698: printf( "%-19.19s" , peterbuffer );
699: }
700: }
701: printf( "\n" );
702: }
703: cfree( namesortnlp );
704: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.