Return to timesop.c CVS log

Up to [Research Unix] / researchv10no / cmd / lcc / ph

Annotation of researchv10no/cmd/lcc/ph/timesop.c, revision 1.1

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:        auto CHAR Cc = 7;
        !            16:        auto CHAR *pCc = &Cc;
        !            17:        auto CHAR **ppCc = &pCc;
        !            18: #if ANSI
        !            19:        auto SCHAR Csc = 8;
        !            20:        auto SCHAR *pCsc = &Csc;
        !            21:        auto SCHAR **ppCsc = &pCsc;
        !            22: #endif
        !            23:        auto SHORT Cs = 9;
        !            24:        auto SHORT *pCs = &Cs;
        !            25:        auto SHORT **ppCs = &pCs;
        !            26:        auto INT Ci = 10;
        !            27:        auto INT *pCi = &Ci;
        !            28:        auto INT **ppCi = &pCi;
        !            29:        auto UCHAR Cuc = 11;
        !            30:        auto UCHAR *pCuc = &Cuc;
        !            31:        auto UCHAR **ppCuc = &pCuc;
        !            32:        auto USHORT Cus = 12;
        !            33:        auto USHORT *pCus = &Cus;
        !            34:        auto USHORT **ppCus = &pCus;
        !            35:        auto UINT Cui = 13;
        !            36:        auto UINT *pCui = &Cui;
        !            37:        auto UINT **ppCui = &pCui;
        !            38:        auto LONG Cl = 14;
        !            39:        auto LONG *pCl = &Cl;
        !            40:        auto LONG **ppCl = &pCl;
        !            41:        auto ULONG Cul = 15;
        !            42:        auto ULONG *pCul = &Cul;
        !            43:        auto ULONG **ppCul = &pCul;
        !            44:        auto FLOAT Cf = 16;
        !            45:        auto FLOAT *pCf = &Cf;
        !            46:        auto FLOAT **ppCf = &pCf;
        !            47:        auto DOUBLE Cd = 17;
        !            48:        auto DOUBLE *pCd = &Cd;
        !            49:        auto DOUBLE **ppCd = &pCd;
        !            50: #if ANSI
        !            51:        auto LDOUBLE Cld = 18;
        !            52:        auto LDOUBLE *pCld = &Cld;
        !            53:        auto LDOUBLE **ppCld = &pCld;
        !            54: #endif
        !            55:        {
        !            56:        typedef union {
        !            57:                CHAR c;
        !            58:                SHORT s;
        !            59:                INT i;
        !            60:                UCHAR uc;
        !            61:                USHORT us;
        !            62:                UINT ui;
        !            63:                LONG l;
        !            64:                ULONG ul;
        !            65:                FLOAT f;
        !            66:                DOUBLE d;
        !            67: #if ANSI
        !            68:                SCHAR sc;
        !            69:                LDOUBLE ld;
        !            70: #endif
        !            71:                } D;
        !            72:        auto D D1;
        !            73: #if ANSI
        !            74:        auto D D2;
        !            75: #endif
        !            76:        auto D D3;
        !            77:        auto D D4;
        !            78:        auto D D5;
        !            79:        auto D D6;
        !            80:        auto D D7;
        !            81:        auto D D8;
        !            82:        auto D D9;
        !            83:        auto D D10;
        !            84:        auto D D11;
        !            85: #if ANSI
        !            86:        auto D D12;
        !            87: #endif
        !            88:        D1.c = 7;
        !            89: #if ANSI
        !            90:        D2.sc = 8;
        !            91: #endif
        !            92:        D3.s = 9;
        !            93:        D4.i = 10;
        !            94:        D5.uc = 11;
        !            95:        D6.us = 12;
        !            96:        D7.ui = 13;
        !            97:        D8.l = 14;
        !            98:        D9.ul = 15;
        !            99:        D10.f = 16;
        !           100:        D11.d = 17;
        !           101: #if ANSI
        !           102:        D12.ld = 18;
        !           103: #endif
        !           104:        {
        !           105:        int true = 1, false = 0;
        !           106:        Filename =  " auto pscalar2 auto union times ";
        !           107:        iequals(__LINE__, **ppCc * D1.c, 49);
        !           108:        iequals(__LINE__, D1.c * **ppCc, 49);
        !           109: #if ANSI
        !           110:        iequals(__LINE__, **ppCc * D2.sc, 56);
        !           111:        iequals(__LINE__, D2.sc * **ppCc, 56);
        !           112: #endif
        !           113:        iequals(__LINE__, **ppCc * D3.s, 63);
        !           114:        iequals(__LINE__, D3.s * **ppCc, 63);
        !           115:        iequals(__LINE__, **ppCc * D4.i, 70);
        !           116:        iequals(__LINE__, D4.i * **ppCc, 70);
        !           117:        iequals(__LINE__, **ppCc * D5.uc, 77);
        !           118:        iequals(__LINE__, D5.uc * **ppCc, 77);
        !           119:        iequals(__LINE__, **ppCc * D6.us, 84);
        !           120:        iequals(__LINE__, D6.us * **ppCc, 84);
        !           121:        iequals(__LINE__, **ppCc * D7.ui, 91);
        !           122:        iequals(__LINE__, D7.ui * **ppCc, 91);
        !           123:        lequals(__LINE__, **ppCc * D8.l, 98L);
        !           124:        lequals(__LINE__, D8.l * **ppCc, 98L);
        !           125:        lequals(__LINE__, **ppCc * D9.ul, 105L);
        !           126:        lequals(__LINE__, D9.ul * **ppCc, 105L);
        !           127:        dequals(__LINE__, **ppCc * D10.f, 112.);
        !           128:        dequals(__LINE__, D10.f * **ppCc, 112.);
        !           129:        dequals(__LINE__, **ppCc * D11.d, 119.);
        !           130:        dequals(__LINE__, D11.d * **ppCc, 119.);
        !           131: #if ANSI
        !           132:        ldequals(__LINE__, **ppCc * D12.ld, 126.L);
        !           133:        ldequals(__LINE__, D12.ld * **ppCc, 126.L);
        !           134: #endif
        !           135: #if ANSI
        !           136:        iequals(__LINE__, **ppCsc * D1.c, 56);
        !           137:        iequals(__LINE__, D1.c * **ppCsc, 56);
        !           138: #endif
        !           139: #if ANSI
        !           140:        iequals(__LINE__, **ppCsc * D2.sc, 64);
        !           141:        iequals(__LINE__, D2.sc * **ppCsc, 64);
        !           142: #endif
        !           143: #if ANSI
        !           144:        iequals(__LINE__, **ppCsc * D3.s, 72);
        !           145:        iequals(__LINE__, D3.s * **ppCsc, 72);
        !           146: #endif
        !           147: #if ANSI
        !           148:        iequals(__LINE__, **ppCsc * D4.i, 80);
        !           149:        iequals(__LINE__, D4.i * **ppCsc, 80);
        !           150: #endif
        !           151: #if ANSI
        !           152:        iequals(__LINE__, **ppCsc * D5.uc, 88);
        !           153:        iequals(__LINE__, D5.uc * **ppCsc, 88);
        !           154: #endif
        !           155: #if ANSI
        !           156:        iequals(__LINE__, **ppCsc * D6.us, 96);
        !           157:        iequals(__LINE__, D6.us * **ppCsc, 96);
        !           158: #endif
        !           159: #if ANSI
        !           160:        iequals(__LINE__, **ppCsc * D7.ui, 104);
        !           161:        iequals(__LINE__, D7.ui * **ppCsc, 104);
        !           162: #endif
        !           163: #if ANSI
        !           164:        lequals(__LINE__, **ppCsc * D8.l, 112L);
        !           165:        lequals(__LINE__, D8.l * **ppCsc, 112L);
        !           166: #endif
        !           167: #if ANSI
        !           168:        lequals(__LINE__, **ppCsc * D9.ul, 120L);
        !           169:        lequals(__LINE__, D9.ul * **ppCsc, 120L);
        !           170: #endif
        !           171: #if ANSI
        !           172:        dequals(__LINE__, **ppCsc * D10.f, 128.);
        !           173:        dequals(__LINE__, D10.f * **ppCsc, 128.);
        !           174: #endif
        !           175: #if ANSI
        !           176:        dequals(__LINE__, **ppCsc * D11.d, 136.);
        !           177:        dequals(__LINE__, D11.d * **ppCsc, 136.);
        !           178: #endif
        !           179: #if ANSI
        !           180:        ldequals(__LINE__, **ppCsc * D12.ld, 144.L);
        !           181:        ldequals(__LINE__, D12.ld * **ppCsc, 144.L);
        !           182: #endif
        !           183:        iequals(__LINE__, **ppCs * D1.c, 63);
        !           184:        iequals(__LINE__, D1.c * **ppCs, 63);
        !           185: #if ANSI
        !           186:        iequals(__LINE__, **ppCs * D2.sc, 72);
        !           187:        iequals(__LINE__, D2.sc * **ppCs, 72);
        !           188: #endif
        !           189:        iequals(__LINE__, **ppCs * D3.s, 81);
        !           190:        iequals(__LINE__, D3.s * **ppCs, 81);
        !           191:        iequals(__LINE__, **ppCs * D4.i, 90);
        !           192:        iequals(__LINE__, D4.i * **ppCs, 90);
        !           193:        iequals(__LINE__, **ppCs * D5.uc, 99);
        !           194:        iequals(__LINE__, D5.uc * **ppCs, 99);
        !           195:        iequals(__LINE__, **ppCs * D6.us, 108);
        !           196:        iequals(__LINE__, D6.us * **ppCs, 108);
        !           197:        iequals(__LINE__, **ppCs * D7.ui, 117);
        !           198:        iequals(__LINE__, D7.ui * **ppCs, 117);
        !           199:        lequals(__LINE__, **ppCs * D8.l, 126L);
        !           200:        lequals(__LINE__, D8.l * **ppCs, 126L);
        !           201:        lequals(__LINE__, **ppCs * D9.ul, 135L);
        !           202:        lequals(__LINE__, D9.ul * **ppCs, 135L);
        !           203:        dequals(__LINE__, **ppCs * D10.f, 144.);
        !           204:        dequals(__LINE__, D10.f * **ppCs, 144.);
        !           205:        dequals(__LINE__, **ppCs * D11.d, 153.);
        !           206:        dequals(__LINE__, D11.d * **ppCs, 153.);
        !           207: #if ANSI
        !           208:        ldequals(__LINE__, **ppCs * D12.ld, 162.L);
        !           209:        ldequals(__LINE__, D12.ld * **ppCs, 162.L);
        !           210: #endif
        !           211:        iequals(__LINE__, **ppCi * D1.c, 70);
        !           212:        iequals(__LINE__, D1.c * **ppCi, 70);
        !           213: #if ANSI
        !           214:        iequals(__LINE__, **ppCi * D2.sc, 80);
        !           215:        iequals(__LINE__, D2.sc * **ppCi, 80);
        !           216: #endif
        !           217:        iequals(__LINE__, **ppCi * D3.s, 90);
        !           218:        iequals(__LINE__, D3.s * **ppCi, 90);
        !           219:        iequals(__LINE__, **ppCi * D4.i, 100);
        !           220:        iequals(__LINE__, D4.i * **ppCi, 100);
        !           221:        iequals(__LINE__, **ppCi * D5.uc, 110);
        !           222:        iequals(__LINE__, D5.uc * **ppCi, 110);
        !           223:        iequals(__LINE__, **ppCi * D6.us, 120);
        !           224:        iequals(__LINE__, D6.us * **ppCi, 120);
        !           225:        iequals(__LINE__, **ppCi * D7.ui, 130);
        !           226:        iequals(__LINE__, D7.ui * **ppCi, 130);
        !           227:        lequals(__LINE__, **ppCi * D8.l, 140L);
        !           228:        lequals(__LINE__, D8.l * **ppCi, 140L);
        !           229:        lequals(__LINE__, **ppCi * D9.ul, 150L);
        !           230:        lequals(__LINE__, D9.ul * **ppCi, 150L);
        !           231:        dequals(__LINE__, **ppCi * D10.f, 160.);
        !           232:        dequals(__LINE__, D10.f * **ppCi, 160.);
        !           233:        dequals(__LINE__, **ppCi * D11.d, 170.);
        !           234:        dequals(__LINE__, D11.d * **ppCi, 170.);
        !           235: #if ANSI
        !           236:        ldequals(__LINE__, **ppCi * D12.ld, 180.L);
        !           237:        ldequals(__LINE__, D12.ld * **ppCi, 180.L);
        !           238: #endif
        !           239:        iequals(__LINE__, **ppCuc * D1.c, 77);
        !           240:        iequals(__LINE__, D1.c * **ppCuc, 77);
        !           241: #if ANSI
        !           242:        iequals(__LINE__, **ppCuc * D2.sc, 88);
        !           243:        iequals(__LINE__, D2.sc * **ppCuc, 88);
        !           244: #endif
        !           245:        iequals(__LINE__, **ppCuc * D3.s, 99);
        !           246:        iequals(__LINE__, D3.s * **ppCuc, 99);
        !           247:        iequals(__LINE__, **ppCuc * D4.i, 110);
        !           248:        iequals(__LINE__, D4.i * **ppCuc, 110);
        !           249:        iequals(__LINE__, **ppCuc * D5.uc, 121);
        !           250:        iequals(__LINE__, D5.uc * **ppCuc, 121);
        !           251:        iequals(__LINE__, **ppCuc * D6.us, 132);
        !           252:        iequals(__LINE__, D6.us * **ppCuc, 132);
        !           253:        iequals(__LINE__, **ppCuc * D7.ui, 143);
        !           254:        iequals(__LINE__, D7.ui * **ppCuc, 143);
        !           255:        lequals(__LINE__, **ppCuc * D8.l, 154L);
        !           256:        lequals(__LINE__, D8.l * **ppCuc, 154L);
        !           257:        lequals(__LINE__, **ppCuc * D9.ul, 165L);
        !           258:        lequals(__LINE__, D9.ul * **ppCuc, 165L);
        !           259:        dequals(__LINE__, **ppCuc * D10.f, 176.);
        !           260:        dequals(__LINE__, D10.f * **ppCuc, 176.);
        !           261:        dequals(__LINE__, **ppCuc * D11.d, 187.);
        !           262:        dequals(__LINE__, D11.d * **ppCuc, 187.);
        !           263: #if ANSI
        !           264:        ldequals(__LINE__, **ppCuc * D12.ld, 198.L);
        !           265:        ldequals(__LINE__, D12.ld * **ppCuc, 198.L);
        !           266: #endif
        !           267:        iequals(__LINE__, **ppCus * D1.c, 84);
        !           268:        iequals(__LINE__, D1.c * **ppCus, 84);
        !           269: #if ANSI
        !           270:        iequals(__LINE__, **ppCus * D2.sc, 96);
        !           271:        iequals(__LINE__, D2.sc * **ppCus, 96);
        !           272: #endif
        !           273:        iequals(__LINE__, **ppCus * D3.s, 108);
        !           274:        iequals(__LINE__, D3.s * **ppCus, 108);
        !           275:        iequals(__LINE__, **ppCus * D4.i, 120);
        !           276:        iequals(__LINE__, D4.i * **ppCus, 120);
        !           277:        iequals(__LINE__, **ppCus * D5.uc, 132);
        !           278:        iequals(__LINE__, D5.uc * **ppCus, 132);
        !           279:        iequals(__LINE__, **ppCus * D6.us, 144);
        !           280:        iequals(__LINE__, D6.us * **ppCus, 144);
        !           281:        iequals(__LINE__, **ppCus * D7.ui, 156);
        !           282:        iequals(__LINE__, D7.ui * **ppCus, 156);
        !           283:        lequals(__LINE__, **ppCus * D8.l, 168L);
        !           284:        lequals(__LINE__, D8.l * **ppCus, 168L);
        !           285:        lequals(__LINE__, **ppCus * D9.ul, 180L);
        !           286:        lequals(__LINE__, D9.ul * **ppCus, 180L);
        !           287:        dequals(__LINE__, **ppCus * D10.f, 192.);
        !           288:        dequals(__LINE__, D10.f * **ppCus, 192.);
        !           289:        dequals(__LINE__, **ppCus * D11.d, 204.);
        !           290:        dequals(__LINE__, D11.d * **ppCus, 204.);
        !           291: #if ANSI
        !           292:        ldequals(__LINE__, **ppCus * D12.ld, 216.L);
        !           293:        ldequals(__LINE__, D12.ld * **ppCus, 216.L);
        !           294: #endif
        !           295:        iequals(__LINE__, **ppCui * D1.c, 91);
        !           296:        iequals(__LINE__, D1.c * **ppCui, 91);
        !           297: #if ANSI
        !           298:        iequals(__LINE__, **ppCui * D2.sc, 104);
        !           299:        iequals(__LINE__, D2.sc * **ppCui, 104);
        !           300: #endif
        !           301:        iequals(__LINE__, **ppCui * D3.s, 117);
        !           302:        iequals(__LINE__, D3.s * **ppCui, 117);
        !           303:        iequals(__LINE__, **ppCui * D4.i, 130);
        !           304:        iequals(__LINE__, D4.i * **ppCui, 130);
        !           305:        iequals(__LINE__, **ppCui * D5.uc, 143);
        !           306:        iequals(__LINE__, D5.uc * **ppCui, 143);
        !           307:        iequals(__LINE__, **ppCui * D6.us, 156);
        !           308:        iequals(__LINE__, D6.us * **ppCui, 156);
        !           309:        iequals(__LINE__, **ppCui * D7.ui, 169);
        !           310:        iequals(__LINE__, D7.ui * **ppCui, 169);
        !           311:        lequals(__LINE__, **ppCui * D8.l, 182L);
        !           312:        lequals(__LINE__, D8.l * **ppCui, 182L);
        !           313:        lequals(__LINE__, **ppCui * D9.ul, 195L);
        !           314:        lequals(__LINE__, D9.ul * **ppCui, 195L);
        !           315:        dequals(__LINE__, **ppCui * D10.f, 208.);
        !           316:        dequals(__LINE__, D10.f * **ppCui, 208.);
        !           317:        dequals(__LINE__, **ppCui * D11.d, 221.);
        !           318:        dequals(__LINE__, D11.d * **ppCui, 221.);
        !           319: #if ANSI
        !           320:        ldequals(__LINE__, **ppCui * D12.ld, 234.L);
        !           321:        ldequals(__LINE__, D12.ld * **ppCui, 234.L);
        !           322: #endif
        !           323:        lequals(__LINE__, **ppCl * D1.c, 98L);
        !           324:        lequals(__LINE__, D1.c * **ppCl, 98L);
        !           325: #if ANSI
        !           326:        lequals(__LINE__, **ppCl * D2.sc, 112L);
        !           327:        lequals(__LINE__, D2.sc * **ppCl, 112L);
        !           328: #endif
        !           329:        lequals(__LINE__, **ppCl * D3.s, 126L);
        !           330:        lequals(__LINE__, D3.s * **ppCl, 126L);
        !           331:        lequals(__LINE__, **ppCl * D4.i, 140L);
        !           332:        lequals(__LINE__, D4.i * **ppCl, 140L);
        !           333:        lequals(__LINE__, **ppCl * D5.uc, 154L);
        !           334:        lequals(__LINE__, D5.uc * **ppCl, 154L);
        !           335:        lequals(__LINE__, **ppCl * D6.us, 168L);
        !           336:        lequals(__LINE__, D6.us * **ppCl, 168L);
        !           337:        lequals(__LINE__, **ppCl * D7.ui, 182L);
        !           338:        lequals(__LINE__, D7.ui * **ppCl, 182L);
        !           339:        lequals(__LINE__, **ppCl * D8.l, 196L);
        !           340:        lequals(__LINE__, D8.l * **ppCl, 196L);
        !           341:        lequals(__LINE__, **ppCl * D9.ul, 210L);
        !           342:        lequals(__LINE__, D9.ul * **ppCl, 210L);
        !           343:        dequals(__LINE__, **ppCl * D10.f, 224.);
        !           344:        dequals(__LINE__, D10.f * **ppCl, 224.);
        !           345:        dequals(__LINE__, **ppCl * D11.d, 238.);
        !           346:        dequals(__LINE__, D11.d * **ppCl, 238.);
        !           347: #if ANSI
        !           348:        ldequals(__LINE__, **ppCl * D12.ld, 252.L);
        !           349:        ldequals(__LINE__, D12.ld * **ppCl, 252.L);
        !           350: #endif
        !           351:        lequals(__LINE__, **ppCul * D1.c, 105L);
        !           352:        lequals(__LINE__, D1.c * **ppCul, 105L);
        !           353: #if ANSI
        !           354:        lequals(__LINE__, **ppCul * D2.sc, 120L);
        !           355:        lequals(__LINE__, D2.sc * **ppCul, 120L);
        !           356: #endif
        !           357:        lequals(__LINE__, **ppCul * D3.s, 135L);
        !           358:        lequals(__LINE__, D3.s * **ppCul, 135L);
        !           359:        lequals(__LINE__, **ppCul * D4.i, 150L);
        !           360:        lequals(__LINE__, D4.i * **ppCul, 150L);
        !           361:        lequals(__LINE__, **ppCul * D5.uc, 165L);
        !           362:        lequals(__LINE__, D5.uc * **ppCul, 165L);
        !           363:        lequals(__LINE__, **ppCul * D6.us, 180L);
        !           364:        lequals(__LINE__, D6.us * **ppCul, 180L);
        !           365:        lequals(__LINE__, **ppCul * D7.ui, 195L);
        !           366:        lequals(__LINE__, D7.ui * **ppCul, 195L);
        !           367:        lequals(__LINE__, **ppCul * D8.l, 210L);
        !           368:        lequals(__LINE__, D8.l * **ppCul, 210L);
        !           369:        lequals(__LINE__, **ppCul * D9.ul, 225L);
        !           370:        lequals(__LINE__, D9.ul * **ppCul, 225L);
        !           371:        dequals(__LINE__, **ppCul * D10.f, 240.);
        !           372:        dequals(__LINE__, D10.f * **ppCul, 240.);
        !           373:        dequals(__LINE__, **ppCul * D11.d, 255.);
        !           374:        dequals(__LINE__, D11.d * **ppCul, 255.);
        !           375: #if ANSI
        !           376:        ldequals(__LINE__, **ppCul * D12.ld, 270.L);
        !           377:        ldequals(__LINE__, D12.ld * **ppCul, 270.L);
        !           378: #endif
        !           379:        dequals(__LINE__, **ppCf * D1.c, 112.);
        !           380:        dequals(__LINE__, D1.c * **ppCf, 112.);
        !           381: #if ANSI
        !           382:        dequals(__LINE__, **ppCf * D2.sc, 128.);
        !           383:        dequals(__LINE__, D2.sc * **ppCf, 128.);
        !           384: #endif
        !           385:        dequals(__LINE__, **ppCf * D3.s, 144.);
        !           386:        dequals(__LINE__, D3.s * **ppCf, 144.);
        !           387:        dequals(__LINE__, **ppCf * D4.i, 160.);
        !           388:        dequals(__LINE__, D4.i * **ppCf, 160.);
        !           389:        dequals(__LINE__, **ppCf * D5.uc, 176.);
        !           390:        dequals(__LINE__, D5.uc * **ppCf, 176.);
        !           391:        dequals(__LINE__, **ppCf * D6.us, 192.);
        !           392:        dequals(__LINE__, D6.us * **ppCf, 192.);
        !           393:        dequals(__LINE__, **ppCf * D7.ui, 208.);
        !           394:        dequals(__LINE__, D7.ui * **ppCf, 208.);
        !           395:        dequals(__LINE__, **ppCf * D8.l, 224.);
        !           396:        dequals(__LINE__, D8.l * **ppCf, 224.);
        !           397:        dequals(__LINE__, **ppCf * D9.ul, 240.);
        !           398:        dequals(__LINE__, D9.ul * **ppCf, 240.);
        !           399:        dequals(__LINE__, **ppCf * D10.f, 256.);
        !           400:        dequals(__LINE__, D10.f * **ppCf, 256.);
        !           401:        dequals(__LINE__, **ppCf * D11.d, 272.);
        !           402:        dequals(__LINE__, D11.d * **ppCf, 272.);
        !           403: #if ANSI
        !           404:        ldequals(__LINE__, **ppCf * D12.ld, 288.L);
        !           405:        ldequals(__LINE__, D12.ld * **ppCf, 288.L);
        !           406: #endif
        !           407:        dequals(__LINE__, **ppCd * D1.c, 119.);
        !           408:        dequals(__LINE__, D1.c * **ppCd, 119.);
        !           409: #if ANSI
        !           410:        dequals(__LINE__, **ppCd * D2.sc, 136.);
        !           411:        dequals(__LINE__, D2.sc * **ppCd, 136.);
        !           412: #endif
        !           413:        dequals(__LINE__, **ppCd * D3.s, 153.);
        !           414:        dequals(__LINE__, D3.s * **ppCd, 153.);
        !           415:        dequals(__LINE__, **ppCd * D4.i, 170.);
        !           416:        dequals(__LINE__, D4.i * **ppCd, 170.);
        !           417:        dequals(__LINE__, **ppCd * D5.uc, 187.);
        !           418:        dequals(__LINE__, D5.uc * **ppCd, 187.);
        !           419:        dequals(__LINE__, **ppCd * D6.us, 204.);
        !           420:        dequals(__LINE__, D6.us * **ppCd, 204.);
        !           421:        dequals(__LINE__, **ppCd * D7.ui, 221.);
        !           422:        dequals(__LINE__, D7.ui * **ppCd, 221.);
        !           423:        dequals(__LINE__, **ppCd * D8.l, 238.);
        !           424:        dequals(__LINE__, D8.l * **ppCd, 238.);
        !           425:        dequals(__LINE__, **ppCd * D9.ul, 255.);
        !           426:        dequals(__LINE__, D9.ul * **ppCd, 255.);
        !           427:        dequals(__LINE__, **ppCd * D10.f, 272.);
        !           428:        dequals(__LINE__, D10.f * **ppCd, 272.);
        !           429:        dequals(__LINE__, **ppCd * D11.d, 289.);
        !           430:        dequals(__LINE__, D11.d * **ppCd, 289.);
        !           431: #if ANSI
        !           432:        ldequals(__LINE__, **ppCd * D12.ld, 306.L);
        !           433:        ldequals(__LINE__, D12.ld * **ppCd, 306.L);
        !           434: #endif
        !           435: #if ANSI
        !           436:        ldequals(__LINE__, **ppCld * D1.c, 126.L);
        !           437:        ldequals(__LINE__, D1.c * **ppCld, 126.L);
        !           438: #endif
        !           439: #if ANSI
        !           440:        ldequals(__LINE__, **ppCld * D2.sc, 144.L);
        !           441:        ldequals(__LINE__, D2.sc * **ppCld, 144.L);
        !           442: #endif
        !           443: #if ANSI
        !           444:        ldequals(__LINE__, **ppCld * D3.s, 162.L);
        !           445:        ldequals(__LINE__, D3.s * **ppCld, 162.L);
        !           446: #endif
        !           447: #if ANSI
        !           448:        ldequals(__LINE__, **ppCld * D4.i, 180.L);
        !           449:        ldequals(__LINE__, D4.i * **ppCld, 180.L);
        !           450: #endif
        !           451: #if ANSI
        !           452:        ldequals(__LINE__, **ppCld * D5.uc, 198.L);
        !           453:        ldequals(__LINE__, D5.uc * **ppCld, 198.L);
        !           454: #endif
        !           455: #if ANSI
        !           456:        ldequals(__LINE__, **ppCld * D6.us, 216.L);
        !           457:        ldequals(__LINE__, D6.us * **ppCld, 216.L);
        !           458: #endif
        !           459: #if ANSI
        !           460:        ldequals(__LINE__, **ppCld * D7.ui, 234.L);
        !           461:        ldequals(__LINE__, D7.ui * **ppCld, 234.L);
        !           462: #endif
        !           463: #if ANSI
        !           464:        ldequals(__LINE__, **ppCld * D8.l, 252.L);
        !           465:        ldequals(__LINE__, D8.l * **ppCld, 252.L);
        !           466: #endif
        !           467: #if ANSI
        !           468:        ldequals(__LINE__, **ppCld * D9.ul, 270.L);
        !           469:        ldequals(__LINE__, D9.ul * **ppCld, 270.L);
        !           470: #endif
        !           471: #if ANSI
        !           472:        ldequals(__LINE__, **ppCld * D10.f, 288.L);
        !           473:        ldequals(__LINE__, D10.f * **ppCld, 288.L);
        !           474: #endif
        !           475: #if ANSI
        !           476:        ldequals(__LINE__, **ppCld * D11.d, 306.L);
        !           477:        ldequals(__LINE__, D11.d * **ppCld, 306.L);
        !           478: #endif
        !           479: #if ANSI
        !           480:        ldequals(__LINE__, **ppCld * D12.ld, 324.L);
        !           481:        ldequals(__LINE__, D12.ld * **ppCld, 324.L);
        !           482: #endif
        !           483:        }}
        !           484:        return  report(Filename);
        !           485:        }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.