![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to div.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / ph|
Return to div.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / ph |
1.1 root 1: /* The Plum Hall Validation Suite for C
2: * Unpublished copyright (c) 1986-1991, Chiron Systems Inc and Plum Hall Inc.
3: * VERSION: 4
4: * DATE: 1993-01-01
5: * The "ANSI" mode of the Suite corresponds to the official ANSI C, X3.159-1989.
6: * As per your license agreement, your distribution is not to be moved or copied outside the Designated Site
7: * without specific permission from Plum Hall Inc.
8: */
9:
10: #define ANSI 1 /* This file follows ANSI arithmetic rules, which may not work in non-ANSI modes */
11: #include "types.h"
12: int main()
13: {
14: extern char *Filename;
15: typedef union {
16: CHAR c;
17: SHORT s;
18: INT i;
19: UCHAR uc;
20: USHORT us;
21: UINT ui;
22: LONG l;
23: ULONG ul;
24: FLOAT f;
25: DOUBLE d;
26: #if ANSI
27: SCHAR sc;
28: LDOUBLE ld;
29: #endif
30: } D;
31: auto D D1;
32: #if ANSI
33: auto D D2;
34: #endif
35: auto D D3;
36: auto D D4;
37: auto D D5;
38: auto D D6;
39: auto D D7;
40: auto D D8;
41: auto D D9;
42: auto D D10;
43: auto D D11;
44: #if ANSI
45: auto D D12;
46: #endif
47: D1.c = 7;
48: #if ANSI
49: D2.sc = 8;
50: #endif
51: D3.s = 9;
52: D4.i = 10;
53: D5.uc = 11;
54: D6.us = 12;
55: D7.ui = 13;
56: D8.l = 14;
57: D9.ul = 15;
58: D10.f = 16;
59: D11.d = 17;
60: #if ANSI
61: D12.ld = 18;
62: #endif
63: {
64: typedef union {
65: CHAR c;
66: SHORT s;
67: INT i;
68: UCHAR uc;
69: USHORT us;
70: UINT ui;
71: LONG l;
72: ULONG ul;
73: FLOAT f;
74: DOUBLE d;
75: #if ANSI
76: SCHAR sc;
77: LDOUBLE ld;
78: #endif
79: } E;
80: auto E E1, *pE1 = &E1;
81: #if ANSI
82: auto E E2, *pE2 = &E2;
83: #endif
84: auto E E3, *pE3 = &E3;
85: auto E E4, *pE4 = &E4;
86: auto E E5, *pE5 = &E5;
87: auto E E6, *pE6 = &E6;
88: auto E E7, *pE7 = &E7;
89: auto E E8, *pE8 = &E8;
90: auto E E9, *pE9 = &E9;
91: auto E E10, *pE10 = &E10;
92: auto E E11, *pE11 = &E11;
93: #if ANSI
94: auto E E12, *pE12 = &E12;
95: #endif
96: pE1->c = 7;
97: #if ANSI
98: pE2->sc = 8;
99: #endif
100: pE3->s = 9;
101: pE4->i = 10;
102: pE5->uc = 11;
103: pE6->us = 12;
104: pE7->ui = 13;
105: pE8->l = 14;
106: pE9->ul = 15;
107: pE10->f = 16;
108: pE11->d = 17;
109: #if ANSI
110: pE12->ld = 18;
111: #endif
112: {
113: int true = 1, false = 0;
114: Filename = " auto union auto punion div ";
115: pE1->c = 14;
116: D1.c = 7;
117: iequals(__LINE__, pE1->c / D1.c, 2);
118: D1.c = 14;
119: pE1->c = 7;
120: iequals(__LINE__, D1.c / pE1->c, 2);
121: #if ANSI
122: pE2->sc = 14;
123: D1.c = 7;
124: iequals(__LINE__, pE2->sc / D1.c, 2);
125: D1.c = 16;
126: pE2->sc = 8;
127: iequals(__LINE__, D1.c / pE2->sc, 2);
128: #endif
129: pE3->s = 14;
130: D1.c = 7;
131: iequals(__LINE__, pE3->s / D1.c, 2);
132: D1.c = 18;
133: pE3->s = 9;
134: iequals(__LINE__, D1.c / pE3->s, 2);
135: pE4->i = 14;
136: D1.c = 7;
137: iequals(__LINE__, pE4->i / D1.c, 2);
138: D1.c = 20;
139: pE4->i = 10;
140: iequals(__LINE__, D1.c / pE4->i, 2);
141: pE5->uc = 14;
142: D1.c = 7;
143: iequals(__LINE__, pE5->uc / D1.c, 2);
144: D1.c = 22;
145: pE5->uc = 11;
146: iequals(__LINE__, D1.c / pE5->uc, 2);
147: pE6->us = 14;
148: D1.c = 7;
149: iequals(__LINE__, pE6->us / D1.c, 2);
150: D1.c = 24;
151: pE6->us = 12;
152: iequals(__LINE__, D1.c / pE6->us, 2);
153: pE7->ui = 14;
154: D1.c = 7;
155: iequals(__LINE__, pE7->ui / D1.c, 2);
156: D1.c = 26;
157: pE7->ui = 13;
158: iequals(__LINE__, D1.c / pE7->ui, 2);
159: pE8->l = 14;
160: D1.c = 7;
161: lequals(__LINE__, pE8->l / D1.c, 2L);
162: D1.c = 28;
163: pE8->l = 14;
164: lequals(__LINE__, D1.c / pE8->l, 2L);
165: pE9->ul = 14;
166: D1.c = 7;
167: lequals(__LINE__, pE9->ul / D1.c, 2L);
168: D1.c = 30;
169: pE9->ul = 15;
170: lequals(__LINE__, D1.c / pE9->ul, 2L);
171: pE10->f = 14;
172: D1.c = 7;
173: fequals(__LINE__, pE10->f / D1.c, (float)2.);
174: D1.c = 32;
175: pE10->f = 16;
176: fequals(__LINE__, D1.c / pE10->f, (float)2.);
177: pE11->d = 14;
178: D1.c = 7;
179: dequals(__LINE__, pE11->d / D1.c, 2.);
180: D1.c = 34;
181: pE11->d = 17;
182: dequals(__LINE__, D1.c / pE11->d, 2.);
183: #if ANSI
184: pE12->ld = 14;
185: D1.c = 7;
186: ldequals(__LINE__, pE12->ld / D1.c, 2.L);
187: D1.c = 36;
188: pE12->ld = 18;
189: ldequals(__LINE__, D1.c / pE12->ld, 2.L);
190: #endif
191: #if ANSI
192: pE1->c = 16;
193: D2.sc = 8;
194: iequals(__LINE__, pE1->c / D2.sc, 2);
195: D2.sc = 14;
196: pE1->c = 7;
197: iequals(__LINE__, D2.sc / pE1->c, 2);
198: #endif
199: #if ANSI
200: pE2->sc = 16;
201: D2.sc = 8;
202: iequals(__LINE__, pE2->sc / D2.sc, 2);
203: D2.sc = 16;
204: pE2->sc = 8;
205: iequals(__LINE__, D2.sc / pE2->sc, 2);
206: #endif
207: #if ANSI
208: pE3->s = 16;
209: D2.sc = 8;
210: iequals(__LINE__, pE3->s / D2.sc, 2);
211: D2.sc = 18;
212: pE3->s = 9;
213: iequals(__LINE__, D2.sc / pE3->s, 2);
214: #endif
215: #if ANSI
216: pE4->i = 16;
217: D2.sc = 8;
218: iequals(__LINE__, pE4->i / D2.sc, 2);
219: D2.sc = 20;
220: pE4->i = 10;
221: iequals(__LINE__, D2.sc / pE4->i, 2);
222: #endif
223: #if ANSI
224: pE5->uc = 16;
225: D2.sc = 8;
226: iequals(__LINE__, pE5->uc / D2.sc, 2);
227: D2.sc = 22;
228: pE5->uc = 11;
229: iequals(__LINE__, D2.sc / pE5->uc, 2);
230: #endif
231: #if ANSI
232: pE6->us = 16;
233: D2.sc = 8;
234: iequals(__LINE__, pE6->us / D2.sc, 2);
235: D2.sc = 24;
236: pE6->us = 12;
237: iequals(__LINE__, D2.sc / pE6->us, 2);
238: #endif
239: #if ANSI
240: pE7->ui = 16;
241: D2.sc = 8;
242: iequals(__LINE__, pE7->ui / D2.sc, 2);
243: D2.sc = 26;
244: pE7->ui = 13;
245: iequals(__LINE__, D2.sc / pE7->ui, 2);
246: #endif
247: #if ANSI
248: pE8->l = 16;
249: D2.sc = 8;
250: lequals(__LINE__, pE8->l / D2.sc, 2L);
251: D2.sc = 28;
252: pE8->l = 14;
253: lequals(__LINE__, D2.sc / pE8->l, 2L);
254: #endif
255: #if ANSI
256: pE9->ul = 16;
257: D2.sc = 8;
258: lequals(__LINE__, pE9->ul / D2.sc, 2L);
259: D2.sc = 30;
260: pE9->ul = 15;
261: lequals(__LINE__, D2.sc / pE9->ul, 2L);
262: #endif
263: #if ANSI
264: pE10->f = 16;
265: D2.sc = 8;
266: fequals(__LINE__, pE10->f / D2.sc, (float)2.);
267: D2.sc = 32;
268: pE10->f = 16;
269: fequals(__LINE__, D2.sc / pE10->f, (float)2.);
270: #endif
271: #if ANSI
272: pE11->d = 16;
273: D2.sc = 8;
274: dequals(__LINE__, pE11->d / D2.sc, 2.);
275: D2.sc = 34;
276: pE11->d = 17;
277: dequals(__LINE__, D2.sc / pE11->d, 2.);
278: #endif
279: #if ANSI
280: pE12->ld = 16;
281: D2.sc = 8;
282: ldequals(__LINE__, pE12->ld / D2.sc, 2.L);
283: D2.sc = 36;
284: pE12->ld = 18;
285: ldequals(__LINE__, D2.sc / pE12->ld, 2.L);
286: #endif
287: pE1->c = 18;
288: D3.s = 9;
289: iequals(__LINE__, pE1->c / D3.s, 2);
290: D3.s = 14;
291: pE1->c = 7;
292: iequals(__LINE__, D3.s / pE1->c, 2);
293: #if ANSI
294: pE2->sc = 18;
295: D3.s = 9;
296: iequals(__LINE__, pE2->sc / D3.s, 2);
297: D3.s = 16;
298: pE2->sc = 8;
299: iequals(__LINE__, D3.s / pE2->sc, 2);
300: #endif
301: pE3->s = 18;
302: D3.s = 9;
303: iequals(__LINE__, pE3->s / D3.s, 2);
304: D3.s = 18;
305: pE3->s = 9;
306: iequals(__LINE__, D3.s / pE3->s, 2);
307: pE4->i = 18;
308: D3.s = 9;
309: iequals(__LINE__, pE4->i / D3.s, 2);
310: D3.s = 20;
311: pE4->i = 10;
312: iequals(__LINE__, D3.s / pE4->i, 2);
313: pE5->uc = 18;
314: D3.s = 9;
315: iequals(__LINE__, pE5->uc / D3.s, 2);
316: D3.s = 22;
317: pE5->uc = 11;
318: iequals(__LINE__, D3.s / pE5->uc, 2);
319: pE6->us = 18;
320: D3.s = 9;
321: iequals(__LINE__, pE6->us / D3.s, 2);
322: D3.s = 24;
323: pE6->us = 12;
324: iequals(__LINE__, D3.s / pE6->us, 2);
325: pE7->ui = 18;
326: D3.s = 9;
327: iequals(__LINE__, pE7->ui / D3.s, 2);
328: D3.s = 26;
329: pE7->ui = 13;
330: iequals(__LINE__, D3.s / pE7->ui, 2);
331: pE8->l = 18;
332: D3.s = 9;
333: lequals(__LINE__, pE8->l / D3.s, 2L);
334: D3.s = 28;
335: pE8->l = 14;
336: lequals(__LINE__, D3.s / pE8->l, 2L);
337: pE9->ul = 18;
338: D3.s = 9;
339: lequals(__LINE__, pE9->ul / D3.s, 2L);
340: D3.s = 30;
341: pE9->ul = 15;
342: lequals(__LINE__, D3.s / pE9->ul, 2L);
343: pE10->f = 18;
344: D3.s = 9;
345: fequals(__LINE__, pE10->f / D3.s, (float)2.);
346: D3.s = 32;
347: pE10->f = 16;
348: fequals(__LINE__, D3.s / pE10->f, (float)2.);
349: pE11->d = 18;
350: D3.s = 9;
351: dequals(__LINE__, pE11->d / D3.s, 2.);
352: D3.s = 34;
353: pE11->d = 17;
354: dequals(__LINE__, D3.s / pE11->d, 2.);
355: #if ANSI
356: pE12->ld = 18;
357: D3.s = 9;
358: ldequals(__LINE__, pE12->ld / D3.s, 2.L);
359: D3.s = 36;
360: pE12->ld = 18;
361: ldequals(__LINE__, D3.s / pE12->ld, 2.L);
362: #endif
363: pE1->c = 20;
364: D4.i = 10;
365: iequals(__LINE__, pE1->c / D4.i, 2);
366: D4.i = 14;
367: pE1->c = 7;
368: iequals(__LINE__, D4.i / pE1->c, 2);
369: #if ANSI
370: pE2->sc = 20;
371: D4.i = 10;
372: iequals(__LINE__, pE2->sc / D4.i, 2);
373: D4.i = 16;
374: pE2->sc = 8;
375: iequals(__LINE__, D4.i / pE2->sc, 2);
376: #endif
377: pE3->s = 20;
378: D4.i = 10;
379: iequals(__LINE__, pE3->s / D4.i, 2);
380: D4.i = 18;
381: pE3->s = 9;
382: iequals(__LINE__, D4.i / pE3->s, 2);
383: pE4->i = 20;
384: D4.i = 10;
385: iequals(__LINE__, pE4->i / D4.i, 2);
386: D4.i = 20;
387: pE4->i = 10;
388: iequals(__LINE__, D4.i / pE4->i, 2);
389: pE5->uc = 20;
390: D4.i = 10;
391: iequals(__LINE__, pE5->uc / D4.i, 2);
392: D4.i = 22;
393: pE5->uc = 11;
394: iequals(__LINE__, D4.i / pE5->uc, 2);
395: pE6->us = 20;
396: D4.i = 10;
397: iequals(__LINE__, pE6->us / D4.i, 2);
398: D4.i = 24;
399: pE6->us = 12;
400: iequals(__LINE__, D4.i / pE6->us, 2);
401: pE7->ui = 20;
402: D4.i = 10;
403: iequals(__LINE__, pE7->ui / D4.i, 2);
404: D4.i = 26;
405: pE7->ui = 13;
406: iequals(__LINE__, D4.i / pE7->ui, 2);
407: pE8->l = 20;
408: D4.i = 10;
409: lequals(__LINE__, pE8->l / D4.i, 2L);
410: D4.i = 28;
411: pE8->l = 14;
412: lequals(__LINE__, D4.i / pE8->l, 2L);
413: pE9->ul = 20;
414: D4.i = 10;
415: lequals(__LINE__, pE9->ul / D4.i, 2L);
416: D4.i = 30;
417: pE9->ul = 15;
418: lequals(__LINE__, D4.i / pE9->ul, 2L);
419: pE10->f = 20;
420: D4.i = 10;
421: fequals(__LINE__, pE10->f / D4.i, (float)2.);
422: D4.i = 32;
423: pE10->f = 16;
424: fequals(__LINE__, D4.i / pE10->f, (float)2.);
425: pE11->d = 20;
426: D4.i = 10;
427: dequals(__LINE__, pE11->d / D4.i, 2.);
428: D4.i = 34;
429: pE11->d = 17;
430: dequals(__LINE__, D4.i / pE11->d, 2.);
431: #if ANSI
432: pE12->ld = 20;
433: D4.i = 10;
434: ldequals(__LINE__, pE12->ld / D4.i, 2.L);
435: D4.i = 36;
436: pE12->ld = 18;
437: ldequals(__LINE__, D4.i / pE12->ld, 2.L);
438: #endif
439: pE1->c = 22;
440: D5.uc = 11;
441: iequals(__LINE__, pE1->c / D5.uc, 2);
442: D5.uc = 14;
443: pE1->c = 7;
444: iequals(__LINE__, D5.uc / pE1->c, 2);
445: #if ANSI
446: pE2->sc = 22;
447: D5.uc = 11;
448: iequals(__LINE__, pE2->sc / D5.uc, 2);
449: D5.uc = 16;
450: pE2->sc = 8;
451: iequals(__LINE__, D5.uc / pE2->sc, 2);
452: #endif
453: pE3->s = 22;
454: D5.uc = 11;
455: iequals(__LINE__, pE3->s / D5.uc, 2);
456: D5.uc = 18;
457: pE3->s = 9;
458: iequals(__LINE__, D5.uc / pE3->s, 2);
459: pE4->i = 22;
460: D5.uc = 11;
461: iequals(__LINE__, pE4->i / D5.uc, 2);
462: D5.uc = 20;
463: pE4->i = 10;
464: iequals(__LINE__, D5.uc / pE4->i, 2);
465: pE5->uc = 22;
466: D5.uc = 11;
467: iequals(__LINE__, pE5->uc / D5.uc, 2);
468: D5.uc = 22;
469: pE5->uc = 11;
470: iequals(__LINE__, D5.uc / pE5->uc, 2);
471: pE6->us = 22;
472: D5.uc = 11;
473: iequals(__LINE__, pE6->us / D5.uc, 2);
474: D5.uc = 24;
475: pE6->us = 12;
476: iequals(__LINE__, D5.uc / pE6->us, 2);
477: pE7->ui = 22;
478: D5.uc = 11;
479: iequals(__LINE__, pE7->ui / D5.uc, 2);
480: D5.uc = 26;
481: pE7->ui = 13;
482: iequals(__LINE__, D5.uc / pE7->ui, 2);
483: pE8->l = 22;
484: D5.uc = 11;
485: lequals(__LINE__, pE8->l / D5.uc, 2L);
486: D5.uc = 28;
487: pE8->l = 14;
488: lequals(__LINE__, D5.uc / pE8->l, 2L);
489: pE9->ul = 22;
490: D5.uc = 11;
491: lequals(__LINE__, pE9->ul / D5.uc, 2L);
492: D5.uc = 30;
493: pE9->ul = 15;
494: lequals(__LINE__, D5.uc / pE9->ul, 2L);
495: pE10->f = 22;
496: D5.uc = 11;
497: fequals(__LINE__, pE10->f / D5.uc, (float)2.);
498: D5.uc = 32;
499: pE10->f = 16;
500: fequals(__LINE__, D5.uc / pE10->f, (float)2.);
501: pE11->d = 22;
502: D5.uc = 11;
503: dequals(__LINE__, pE11->d / D5.uc, 2.);
504: D5.uc = 34;
505: pE11->d = 17;
506: dequals(__LINE__, D5.uc / pE11->d, 2.);
507: #if ANSI
508: pE12->ld = 22;
509: D5.uc = 11;
510: ldequals(__LINE__, pE12->ld / D5.uc, 2.L);
511: D5.uc = 36;
512: pE12->ld = 18;
513: ldequals(__LINE__, D5.uc / pE12->ld, 2.L);
514: #endif
515: pE1->c = 24;
516: D6.us = 12;
517: iequals(__LINE__, pE1->c / D6.us, 2);
518: D6.us = 14;
519: pE1->c = 7;
520: iequals(__LINE__, D6.us / pE1->c, 2);
521: #if ANSI
522: pE2->sc = 24;
523: D6.us = 12;
524: iequals(__LINE__, pE2->sc / D6.us, 2);
525: D6.us = 16;
526: pE2->sc = 8;
527: iequals(__LINE__, D6.us / pE2->sc, 2);
528: #endif
529: pE3->s = 24;
530: D6.us = 12;
531: iequals(__LINE__, pE3->s / D6.us, 2);
532: D6.us = 18;
533: pE3->s = 9;
534: iequals(__LINE__, D6.us / pE3->s, 2);
535: pE4->i = 24;
536: D6.us = 12;
537: iequals(__LINE__, pE4->i / D6.us, 2);
538: D6.us = 20;
539: pE4->i = 10;
540: iequals(__LINE__, D6.us / pE4->i, 2);
541: pE5->uc = 24;
542: D6.us = 12;
543: iequals(__LINE__, pE5->uc / D6.us, 2);
544: D6.us = 22;
545: pE5->uc = 11;
546: iequals(__LINE__, D6.us / pE5->uc, 2);
547: pE6->us = 24;
548: D6.us = 12;
549: iequals(__LINE__, pE6->us / D6.us, 2);
550: D6.us = 24;
551: pE6->us = 12;
552: iequals(__LINE__, D6.us / pE6->us, 2);
553: pE7->ui = 24;
554: D6.us = 12;
555: iequals(__LINE__, pE7->ui / D6.us, 2);
556: D6.us = 26;
557: pE7->ui = 13;
558: iequals(__LINE__, D6.us / pE7->ui, 2);
559: pE8->l = 24;
560: D6.us = 12;
561: lequals(__LINE__, pE8->l / D6.us, 2L);
562: D6.us = 28;
563: pE8->l = 14;
564: lequals(__LINE__, D6.us / pE8->l, 2L);
565: pE9->ul = 24;
566: D6.us = 12;
567: lequals(__LINE__, pE9->ul / D6.us, 2L);
568: D6.us = 30;
569: pE9->ul = 15;
570: lequals(__LINE__, D6.us / pE9->ul, 2L);
571: pE10->f = 24;
572: D6.us = 12;
573: fequals(__LINE__, pE10->f / D6.us, (float)2.);
574: D6.us = 32;
575: pE10->f = 16;
576: fequals(__LINE__, D6.us / pE10->f, (float)2.);
577: pE11->d = 24;
578: D6.us = 12;
579: dequals(__LINE__, pE11->d / D6.us, 2.);
580: D6.us = 34;
581: pE11->d = 17;
582: dequals(__LINE__, D6.us / pE11->d, 2.);
583: #if ANSI
584: pE12->ld = 24;
585: D6.us = 12;
586: ldequals(__LINE__, pE12->ld / D6.us, 2.L);
587: D6.us = 36;
588: pE12->ld = 18;
589: ldequals(__LINE__, D6.us / pE12->ld, 2.L);
590: #endif
591: pE1->c = 26;
592: D7.ui = 13;
593: iequals(__LINE__, pE1->c / D7.ui, 2);
594: D7.ui = 14;
595: pE1->c = 7;
596: iequals(__LINE__, D7.ui / pE1->c, 2);
597: #if ANSI
598: pE2->sc = 26;
599: D7.ui = 13;
600: iequals(__LINE__, pE2->sc / D7.ui, 2);
601: D7.ui = 16;
602: pE2->sc = 8;
603: iequals(__LINE__, D7.ui / pE2->sc, 2);
604: #endif
605: pE3->s = 26;
606: D7.ui = 13;
607: iequals(__LINE__, pE3->s / D7.ui, 2);
608: D7.ui = 18;
609: pE3->s = 9;
610: iequals(__LINE__, D7.ui / pE3->s, 2);
611: pE4->i = 26;
612: D7.ui = 13;
613: iequals(__LINE__, pE4->i / D7.ui, 2);
614: D7.ui = 20;
615: pE4->i = 10;
616: iequals(__LINE__, D7.ui / pE4->i, 2);
617: pE5->uc = 26;
618: D7.ui = 13;
619: iequals(__LINE__, pE5->uc / D7.ui, 2);
620: D7.ui = 22;
621: pE5->uc = 11;
622: iequals(__LINE__, D7.ui / pE5->uc, 2);
623: pE6->us = 26;
624: D7.ui = 13;
625: iequals(__LINE__, pE6->us / D7.ui, 2);
626: D7.ui = 24;
627: pE6->us = 12;
628: iequals(__LINE__, D7.ui / pE6->us, 2);
629: pE7->ui = 26;
630: D7.ui = 13;
631: iequals(__LINE__, pE7->ui / D7.ui, 2);
632: D7.ui = 26;
633: pE7->ui = 13;
634: iequals(__LINE__, D7.ui / pE7->ui, 2);
635: pE8->l = 26;
636: D7.ui = 13;
637: lequals(__LINE__, pE8->l / D7.ui, 2L);
638: D7.ui = 28;
639: pE8->l = 14;
640: lequals(__LINE__, D7.ui / pE8->l, 2L);
641: pE9->ul = 26;
642: D7.ui = 13;
643: lequals(__LINE__, pE9->ul / D7.ui, 2L);
644: D7.ui = 30;
645: pE9->ul = 15;
646: lequals(__LINE__, D7.ui / pE9->ul, 2L);
647: pE10->f = 26;
648: D7.ui = 13;
649: fequals(__LINE__, pE10->f / D7.ui, (float)2.);
650: D7.ui = 32;
651: pE10->f = 16;
652: fequals(__LINE__, D7.ui / pE10->f, (float)2.);
653: pE11->d = 26;
654: D7.ui = 13;
655: dequals(__LINE__, pE11->d / D7.ui, 2.);
656: D7.ui = 34;
657: pE11->d = 17;
658: dequals(__LINE__, D7.ui / pE11->d, 2.);
659: #if ANSI
660: pE12->ld = 26;
661: D7.ui = 13;
662: ldequals(__LINE__, pE12->ld / D7.ui, 2.L);
663: D7.ui = 36;
664: pE12->ld = 18;
665: ldequals(__LINE__, D7.ui / pE12->ld, 2.L);
666: #endif
667: pE1->c = 28;
668: D8.l = 14;
669: lequals(__LINE__, pE1->c / D8.l, 2L);
670: D8.l = 14;
671: pE1->c = 7;
672: lequals(__LINE__, D8.l / pE1->c, 2L);
673: #if ANSI
674: pE2->sc = 28;
675: D8.l = 14;
676: lequals(__LINE__, pE2->sc / D8.l, 2L);
677: D8.l = 16;
678: pE2->sc = 8;
679: lequals(__LINE__, D8.l / pE2->sc, 2L);
680: #endif
681: pE3->s = 28;
682: D8.l = 14;
683: lequals(__LINE__, pE3->s / D8.l, 2L);
684: D8.l = 18;
685: pE3->s = 9;
686: lequals(__LINE__, D8.l / pE3->s, 2L);
687: pE4->i = 28;
688: D8.l = 14;
689: lequals(__LINE__, pE4->i / D8.l, 2L);
690: D8.l = 20;
691: pE4->i = 10;
692: lequals(__LINE__, D8.l / pE4->i, 2L);
693: pE5->uc = 28;
694: D8.l = 14;
695: lequals(__LINE__, pE5->uc / D8.l, 2L);
696: D8.l = 22;
697: pE5->uc = 11;
698: lequals(__LINE__, D8.l / pE5->uc, 2L);
699: pE6->us = 28;
700: D8.l = 14;
701: lequals(__LINE__, pE6->us / D8.l, 2L);
702: D8.l = 24;
703: pE6->us = 12;
704: lequals(__LINE__, D8.l / pE6->us, 2L);
705: pE7->ui = 28;
706: D8.l = 14;
707: lequals(__LINE__, pE7->ui / D8.l, 2L);
708: D8.l = 26;
709: pE7->ui = 13;
710: lequals(__LINE__, D8.l / pE7->ui, 2L);
711: pE8->l = 28;
712: D8.l = 14;
713: lequals(__LINE__, pE8->l / D8.l, 2L);
714: D8.l = 28;
715: pE8->l = 14;
716: lequals(__LINE__, D8.l / pE8->l, 2L);
717: pE9->ul = 28;
718: D8.l = 14;
719: lequals(__LINE__, pE9->ul / D8.l, 2L);
720: D8.l = 30;
721: pE9->ul = 15;
722: lequals(__LINE__, D8.l / pE9->ul, 2L);
723: pE10->f = 28;
724: D8.l = 14;
725: fequals(__LINE__, pE10->f / D8.l, (float)2.);
726: D8.l = 32;
727: pE10->f = 16;
728: fequals(__LINE__, D8.l / pE10->f, (float)2.);
729: pE11->d = 28;
730: D8.l = 14;
731: dequals(__LINE__, pE11->d / D8.l, 2.);
732: D8.l = 34;
733: pE11->d = 17;
734: dequals(__LINE__, D8.l / pE11->d, 2.);
735: #if ANSI
736: pE12->ld = 28;
737: D8.l = 14;
738: ldequals(__LINE__, pE12->ld / D8.l, 2.L);
739: D8.l = 36;
740: pE12->ld = 18;
741: ldequals(__LINE__, D8.l / pE12->ld, 2.L);
742: #endif
743: pE1->c = 30;
744: D9.ul = 15;
745: lequals(__LINE__, pE1->c / D9.ul, 2L);
746: D9.ul = 14;
747: pE1->c = 7;
748: lequals(__LINE__, D9.ul / pE1->c, 2L);
749: #if ANSI
750: pE2->sc = 30;
751: D9.ul = 15;
752: lequals(__LINE__, pE2->sc / D9.ul, 2L);
753: D9.ul = 16;
754: pE2->sc = 8;
755: lequals(__LINE__, D9.ul / pE2->sc, 2L);
756: #endif
757: pE3->s = 30;
758: D9.ul = 15;
759: lequals(__LINE__, pE3->s / D9.ul, 2L);
760: D9.ul = 18;
761: pE3->s = 9;
762: lequals(__LINE__, D9.ul / pE3->s, 2L);
763: pE4->i = 30;
764: D9.ul = 15;
765: lequals(__LINE__, pE4->i / D9.ul, 2L);
766: D9.ul = 20;
767: pE4->i = 10;
768: lequals(__LINE__, D9.ul / pE4->i, 2L);
769: pE5->uc = 30;
770: D9.ul = 15;
771: lequals(__LINE__, pE5->uc / D9.ul, 2L);
772: D9.ul = 22;
773: pE5->uc = 11;
774: lequals(__LINE__, D9.ul / pE5->uc, 2L);
775: pE6->us = 30;
776: D9.ul = 15;
777: lequals(__LINE__, pE6->us / D9.ul, 2L);
778: D9.ul = 24;
779: pE6->us = 12;
780: lequals(__LINE__, D9.ul / pE6->us, 2L);
781: pE7->ui = 30;
782: D9.ul = 15;
783: lequals(__LINE__, pE7->ui / D9.ul, 2L);
784: D9.ul = 26;
785: pE7->ui = 13;
786: lequals(__LINE__, D9.ul / pE7->ui, 2L);
787: pE8->l = 30;
788: D9.ul = 15;
789: lequals(__LINE__, pE8->l / D9.ul, 2L);
790: D9.ul = 28;
791: pE8->l = 14;
792: lequals(__LINE__, D9.ul / pE8->l, 2L);
793: pE9->ul = 30;
794: D9.ul = 15;
795: lequals(__LINE__, pE9->ul / D9.ul, 2L);
796: D9.ul = 30;
797: pE9->ul = 15;
798: lequals(__LINE__, D9.ul / pE9->ul, 2L);
799: pE10->f = 30;
800: D9.ul = 15;
801: fequals(__LINE__, pE10->f / D9.ul, (float)2.);
802: D9.ul = 32;
803: pE10->f = 16;
804: fequals(__LINE__, D9.ul / pE10->f, (float)2.);
805: pE11->d = 30;
806: D9.ul = 15;
807: dequals(__LINE__, pE11->d / D9.ul, 2.);
808: D9.ul = 34;
809: pE11->d = 17;
810: dequals(__LINE__, D9.ul / pE11->d, 2.);
811: #if ANSI
812: pE12->ld = 30;
813: D9.ul = 15;
814: ldequals(__LINE__, pE12->ld / D9.ul, 2.L);
815: D9.ul = 36;
816: pE12->ld = 18;
817: ldequals(__LINE__, D9.ul / pE12->ld, 2.L);
818: #endif
819: pE1->c = 32;
820: D10.f = 16;
821: fequals(__LINE__, pE1->c / D10.f, (float)2.);
822: D10.f = 14;
823: pE1->c = 7;
824: fequals(__LINE__, D10.f / pE1->c, (float)2.);
825: #if ANSI
826: pE2->sc = 32;
827: D10.f = 16;
828: fequals(__LINE__, pE2->sc / D10.f, (float)2.);
829: D10.f = 16;
830: pE2->sc = 8;
831: fequals(__LINE__, D10.f / pE2->sc, (float)2.);
832: #endif
833: pE3->s = 32;
834: D10.f = 16;
835: fequals(__LINE__, pE3->s / D10.f, (float)2.);
836: D10.f = 18;
837: pE3->s = 9;
838: fequals(__LINE__, D10.f / pE3->s, (float)2.);
839: pE4->i = 32;
840: D10.f = 16;
841: fequals(__LINE__, pE4->i / D10.f, (float)2.);
842: D10.f = 20;
843: pE4->i = 10;
844: fequals(__LINE__, D10.f / pE4->i, (float)2.);
845: pE5->uc = 32;
846: D10.f = 16;
847: fequals(__LINE__, pE5->uc / D10.f, (float)2.);
848: D10.f = 22;
849: pE5->uc = 11;
850: fequals(__LINE__, D10.f / pE5->uc, (float)2.);
851: pE6->us = 32;
852: D10.f = 16;
853: fequals(__LINE__, pE6->us / D10.f, (float)2.);
854: D10.f = 24;
855: pE6->us = 12;
856: fequals(__LINE__, D10.f / pE6->us, (float)2.);
857: pE7->ui = 32;
858: D10.f = 16;
859: fequals(__LINE__, pE7->ui / D10.f, (float)2.);
860: D10.f = 26;
861: pE7->ui = 13;
862: fequals(__LINE__, D10.f / pE7->ui, (float)2.);
863: pE8->l = 32;
864: D10.f = 16;
865: fequals(__LINE__, pE8->l / D10.f, (float)2.);
866: D10.f = 28;
867: pE8->l = 14;
868: fequals(__LINE__, D10.f / pE8->l, (float)2.);
869: pE9->ul = 32;
870: D10.f = 16;
871: fequals(__LINE__, pE9->ul / D10.f, (float)2.);
872: D10.f = 30;
873: pE9->ul = 15;
874: fequals(__LINE__, D10.f / pE9->ul, (float)2.);
875: pE10->f = 32;
876: D10.f = 16;
877: fequals(__LINE__, pE10->f / D10.f, (float)2.);
878: D10.f = 32;
879: pE10->f = 16;
880: fequals(__LINE__, D10.f / pE10->f, (float)2.);
881: pE11->d = 32;
882: D10.f = 16;
883: fequals(__LINE__, pE11->d / D10.f, (float)2.);
884: D10.f = 34;
885: pE11->d = 17;
886: fequals(__LINE__, D10.f / pE11->d, (float)2.);
887: #if ANSI
888: pE12->ld = 32;
889: D10.f = 16;
890: ldequals(__LINE__, pE12->ld / D10.f, 2.L);
891: D10.f = 36;
892: pE12->ld = 18;
893: ldequals(__LINE__, D10.f / pE12->ld, 2.L);
894: #endif
895: pE1->c = 34;
896: D11.d = 17;
897: dequals(__LINE__, pE1->c / D11.d, 2.);
898: D11.d = 14;
899: pE1->c = 7;
900: dequals(__LINE__, D11.d / pE1->c, 2.);
901: #if ANSI
902: pE2->sc = 34;
903: D11.d = 17;
904: dequals(__LINE__, pE2->sc / D11.d, 2.);
905: D11.d = 16;
906: pE2->sc = 8;
907: dequals(__LINE__, D11.d / pE2->sc, 2.);
908: #endif
909: pE3->s = 34;
910: D11.d = 17;
911: dequals(__LINE__, pE3->s / D11.d, 2.);
912: D11.d = 18;
913: pE3->s = 9;
914: dequals(__LINE__, D11.d / pE3->s, 2.);
915: pE4->i = 34;
916: D11.d = 17;
917: dequals(__LINE__, pE4->i / D11.d, 2.);
918: D11.d = 20;
919: pE4->i = 10;
920: dequals(__LINE__, D11.d / pE4->i, 2.);
921: pE5->uc = 34;
922: D11.d = 17;
923: dequals(__LINE__, pE5->uc / D11.d, 2.);
924: D11.d = 22;
925: pE5->uc = 11;
926: dequals(__LINE__, D11.d / pE5->uc, 2.);
927: pE6->us = 34;
928: D11.d = 17;
929: dequals(__LINE__, pE6->us / D11.d, 2.);
930: D11.d = 24;
931: pE6->us = 12;
932: dequals(__LINE__, D11.d / pE6->us, 2.);
933: pE7->ui = 34;
934: D11.d = 17;
935: dequals(__LINE__, pE7->ui / D11.d, 2.);
936: D11.d = 26;
937: pE7->ui = 13;
938: dequals(__LINE__, D11.d / pE7->ui, 2.);
939: pE8->l = 34;
940: D11.d = 17;
941: dequals(__LINE__, pE8->l / D11.d, 2.);
942: D11.d = 28;
943: pE8->l = 14;
944: dequals(__LINE__, D11.d / pE8->l, 2.);
945: pE9->ul = 34;
946: D11.d = 17;
947: dequals(__LINE__, pE9->ul / D11.d, 2.);
948: D11.d = 30;
949: pE9->ul = 15;
950: dequals(__LINE__, D11.d / pE9->ul, 2.);
951: pE10->f = 34;
952: D11.d = 17;
953: dequals(__LINE__, pE10->f / D11.d, 2.);
954: D11.d = 32;
955: pE10->f = 16;
956: dequals(__LINE__, D11.d / pE10->f, 2.);
957: pE11->d = 34;
958: D11.d = 17;
959: dequals(__LINE__, pE11->d / D11.d, 2.);
960: D11.d = 34;
961: pE11->d = 17;
962: dequals(__LINE__, D11.d / pE11->d, 2.);
963: #if ANSI
964: pE12->ld = 34;
965: D11.d = 17;
966: ldequals(__LINE__, pE12->ld / D11.d, 2.L);
967: D11.d = 36;
968: pE12->ld = 18;
969: ldequals(__LINE__, D11.d / pE12->ld, 2.L);
970: #endif
971: #if ANSI
972: pE1->c = 36;
973: D12.ld = 18;
974: ldequals(__LINE__, pE1->c / D12.ld, 2.L);
975: D12.ld = 14;
976: pE1->c = 7;
977: ldequals(__LINE__, D12.ld / pE1->c, 2.L);
978: #endif
979: #if ANSI
980: pE2->sc = 36;
981: D12.ld = 18;
982: ldequals(__LINE__, pE2->sc / D12.ld, 2.L);
983: D12.ld = 16;
984: pE2->sc = 8;
985: ldequals(__LINE__, D12.ld / pE2->sc, 2.L);
986: #endif
987: #if ANSI
988: pE3->s = 36;
989: D12.ld = 18;
990: ldequals(__LINE__, pE3->s / D12.ld, 2.L);
991: D12.ld = 18;
992: pE3->s = 9;
993: ldequals(__LINE__, D12.ld / pE3->s, 2.L);
994: #endif
995: #if ANSI
996: pE4->i = 36;
997: D12.ld = 18;
998: ldequals(__LINE__, pE4->i / D12.ld, 2.L);
999: D12.ld = 20;
1000: pE4->i = 10;
1001: ldequals(__LINE__, D12.ld / pE4->i, 2.L);
1002: #endif
1003: #if ANSI
1004: pE5->uc = 36;
1005: D12.ld = 18;
1006: ldequals(__LINE__, pE5->uc / D12.ld, 2.L);
1007: D12.ld = 22;
1008: pE5->uc = 11;
1009: ldequals(__LINE__, D12.ld / pE5->uc, 2.L);
1010: #endif
1011: #if ANSI
1012: pE6->us = 36;
1013: D12.ld = 18;
1014: ldequals(__LINE__, pE6->us / D12.ld, 2.L);
1015: D12.ld = 24;
1016: pE6->us = 12;
1017: ldequals(__LINE__, D12.ld / pE6->us, 2.L);
1018: #endif
1019: #if ANSI
1020: pE7->ui = 36;
1021: D12.ld = 18;
1022: ldequals(__LINE__, pE7->ui / D12.ld, 2.L);
1023: D12.ld = 26;
1024: pE7->ui = 13;
1025: ldequals(__LINE__, D12.ld / pE7->ui, 2.L);
1026: #endif
1027: #if ANSI
1028: pE8->l = 36;
1029: D12.ld = 18;
1030: ldequals(__LINE__, pE8->l / D12.ld, 2.L);
1031: D12.ld = 28;
1032: pE8->l = 14;
1033: ldequals(__LINE__, D12.ld / pE8->l, 2.L);
1034: #endif
1035: #if ANSI
1036: pE9->ul = 36;
1037: D12.ld = 18;
1038: ldequals(__LINE__, pE9->ul / D12.ld, 2.L);
1039: D12.ld = 30;
1040: pE9->ul = 15;
1041: ldequals(__LINE__, D12.ld / pE9->ul, 2.L);
1042: #endif
1043: #if ANSI
1044: pE10->f = 36;
1045: D12.ld = 18;
1046: ldequals(__LINE__, pE10->f / D12.ld, 2.L);
1047: D12.ld = 32;
1048: pE10->f = 16;
1049: ldequals(__LINE__, D12.ld / pE10->f, 2.L);
1050: #endif
1051: #if ANSI
1052: pE11->d = 36;
1053: D12.ld = 18;
1054: ldequals(__LINE__, pE11->d / D12.ld, 2.L);
1055: D12.ld = 34;
1056: pE11->d = 17;
1057: ldequals(__LINE__, D12.ld / pE11->d, 2.L);
1058: #endif
1059: #if ANSI
1060: pE12->ld = 36;
1061: D12.ld = 18;
1062: ldequals(__LINE__, pE12->ld / D12.ld, 2.L);
1063: D12.ld = 36;
1064: pE12->ld = 18;
1065: ldequals(__LINE__, D12.ld / pE12->ld, 2.L);
1066: #endif
1067: }}
1068: return report(Filename);
1069: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.