#include <perms.h>

                                                                //      1  !!! %option  stack=40
                                                                //      2  !! 17/1/78
                                                                //      3  {Modified 25-Feb-82 to run on new subsystem}
                                                                //      4  
                                                                //      5  !!!!  %CONTROL 1;        ! CHECK SWITCHES ONLY
                                                                //      6  
                                                                //      7  ! PASS 3 OF 7/32 IMP COMPILER - VERSION FOR MOUSES AND OS-32MT SUBSYSTEM
                                                                //      8  
                                                                //      9  %CONSTINTEGER  MAX PERM = 54
                                                                //     10  %CONSTINTEGERARRAY PERMS(1: 733) = %C
#line 10 "regression-compile-tmp/gens400.imp"
const int PERMS[733] = { 55, 398, 410, 420, 440, 587, 494, 507, 463, 0, 132, 163, 198, 70, 219, 0, 0, 708, 693, 678, 670, 664, 658, 642, 528, 60, 94, 89, 536, 321, 388, 80, 75, 119, 112, 105, 99, 127, 65, 361, 544, 549, 554, 559, 590, 85, 87, 565, 570, 575, 581, 366, 378, 623, 4, 9280, 22589, 4, 771, 4, 9281, 22589, 4, 771, 4, 9285, 22589, 4, 771, 4, 9282, 22589, 4, 771, 4, 9283, 22589, 4, 771, 4, 9284, 22589, 4, 771, 1, 0, 1, 0, 4, 9289, 22589, 4, 771, 4, 9290, 22589, 4, 771, 5, 9322, 9285, 22589, 4, 771, 6, 2134, 9322, 9287, 22589, 4, 771, 6, 51296, 32, 9285, 22589, 4, 771, 7, 2134, 51296, 32, 9287, 22589, 4, 771, 4, 9286, 22589, 4, 771, 30, 18433, 0, 50432, 32896, 8501, 9217, 9232, 34952, 1, 37888, 37680, 4097, 8584, 54017, 17152, 0, 53762, 17152, 0, 8968, 10033, 18433, 17152, 0, 16386, 17152, 0, 10034, 8727, 776, 34, 18433, 0, 50432, 32896, 8501, 9217, 9232, 34952, 1, 37888, 37632, 54098, 0, 2149, 2658, 2640, 50512, 255, 8997, 9221, 9244, 34952, 1, 53842, 0, 9985, 536, 9825, 9745, 54065, 0, 53814, 0, 8712, 20, 2146, 54017, 0, 54098, 0, 2896, 8984, 2565, 8966, 54070, 0, 54321, 0, 568, 9745, 9825, 9985, 8728, 2133, 776, 93, 53431, 256, 2226, 18641, 0, 50640, 32896, 9016, 38109, 37853, 18434, 0, 50432, 32896, 8501, 9217, 9232, 34952, 1, 37888, 37632, 2829, 16912, 32802, 2251, 2273, 2301, 10225, 16912, 32798, 9921, 9953, 54076, 0, 54334, 0, 8761, 9905, 9985, 17152, 65498, 53687, 256, 2049, 776, 2150, 8501, 1458, 8247, 17152, 32796, 2107, 2866, 53814, 0, 2252, 1468, 9016, 9825, 9921, 54070, 0, 53820, 0, 8712, 2133, 8502, 2048, 16944, 65478, 17152, 32802, 2749, 54018, 0, 2562, 2096, 2875, 53813, 0, 1456, 9016, 9905, 9809, 54069, 0, 53819, 0, 8712, 53687, 0, 1501, 776, 7, 2087, 51216, 256, 37473, 16402, 0, 776, 39, 18486, 0, 50480, 32896, 8501, 9217, 9232, 34952, 1, 37939, 37683, 2133, 9000, 22535, 44, 1283, 8484, 2821, 9729, 8981, 9221, 9241, 34952, 1, 51255, 44, 2067, 53763, 0, 2661, 9985, 536, 9777, 54054, 0, 53795, 0, 9825, 8712, 4, 9288, 22589, 4, 771, 11, 26663, 44, 22631, 48, 22615, 52, 51264, 22, 22589, 4, 771, 9, 26663, 44, 22631, 48, 51264, 23, 22589, 4, 771, 9, 22631, 44, 22615, 48, 51264, 21, 22589, 4, 771, 11, 2096, 2611, 10036, 536, 22529, 17152, 0, 20482, 17152, 0, 8712, 9, 2096, 2611, 9216, 10036, 536, 20482, 17152, 0, 8709, 19, 2097, 18738, 2, 8491, 19250, 0, 8472, 2611, 29491, 16896, 4, 9011, 2622, 563, 2081, 9221, 9236, 34952, 1, 22, 20502, 8, 20534, 4, 20566, 0, 52021, 65535, 8485, 9221, 9238, 34952, 1, 7201, 7173, 9216, 2817, 51219, 3, 50192, 65532, 776, 30, 20595, 0, 20739, 0, 20579, 4, 2087, 2673, 22589, 0, 51571, 65024, 8999, 2929, 2081, 9218, 9232, 34952, 1, 22622, 16, 62800, 32896, 32896, 568, 20561, 17151, 65532, 10004, 8245, 12, 2099, 8982, 2083, 9221, 9242, 34952, 1, 9233, 10033, 536, 7170, 8707, 13, 9217, 12032, 2049, 8982, 11522, 10272, 9216, 51969, 1, 824, 11266, 9985, 8707, 2, 2070, 776, 3, 2070, 2581, 776, 7, 51223, 44, 51264, 17, 22589, 4, 771, 7, 51223, 44, 51264, 18, 22589, 4, 771, 4, 9293, 22589, 4, 771, 4, 9294, 22589, 4, 771, 4, 9295, 22589, 4, 771, 5, 51264, 16, 22589, 4, 771, 4, 9291, 22589, 4, 771, 4, 9292, 22589, 4, 771, 5, 51264, 19, 22589, 4, 771, 5, 51264, 20, 22589, 4, 771, 2, 12033, 776, 8, 22557, 0, 2839, 792, 9218, 9232, 34952, 1, 11, 26631, 44, 63504, 16512, 0, 20503, 44, 27143, 44, 11792, 776, 4, 26631, 44, 11792, 776, 6, 26631, 44, 11792, 12065, 11010, 776, 18, 22551, 44, 50272, 15, 4452, 50784, 57601, 16487, 0, 9312, 16487, 2, 51296, 776, 16487, 4, 17159, 0, 15, 2082, 9018, 2832, 2049, 60928, 31, 7426, 9745, 8467, 2048, 824, 9221, 9233, 34952, 1, 5, 824, 9222, 9233, 34952, 1, 5, 840, 9222, 9233, 34952, 1, 7, 54273, 0, 904, 9222, 9233, 34952, 1, 14, 22802, 0, 8471, 22802, 4, 8484, 23554, 8, 776, 2081, 9222, 9234, 34952, 1, 14, 19064, 0, 22541, 0, 50439, 512, 17288, 2, 19320, 0, 9218, 9232, 34952, 1, 25, 2119, 19016, 0, 19064, 2, 22541, 0, 50439, 512, 9095, 19320, 2, 9218, 9232, 34952, 1, 22542, 16, 20484, 0, 9796, 1351, 8740, 17160, 4,  };
                                                                //     11  X'0037',X'018E',X'019A',X'01A4',X'01B8',X'024B',X'01EE',X'01FB',X'01CF',
                                                                //     12  X'0000',X'0084',X'00A3',X'00C6',X'0046',X'00DB',X'0000',X'0000',X'02C4',
                                                                //     13  X'02B5',X'02A6',X'029E',X'0298',X'0292',X'0282',X'0210',X'003C',X'005E',
                                                                //     14  X'0059',X'0218',X'0141',X'0184',X'0050',X'004B',X'0077',X'0070',X'0069',
                                                                //     15  X'0063',X'007F',X'0041',X'0169',X'0220',X'0225',X'022A',X'022F',X'024E',
                                                                //     16  X'0055',X'0057',X'0235',X'023A',X'023F',X'0245',X'016E',X'017A',X'026F',
                                                                //     17  X'0004',X'2440',X'583D',X'0004',X'0303',X'0004',X'2441',X'583D',X'0004',
                                                                //     18  X'0303',X'0004',X'2445',X'583D',X'0004',X'0303',X'0004',X'2442',X'583D',
                                                                //     19  X'0004',X'0303',X'0004',X'2443',X'583D',X'0004',X'0303',X'0004',X'2444',
                                                                //     20  X'583D',X'0004',X'0303',X'0001',X'0000',X'0001',X'0000',X'0004',X'2449',
                                                                //     21  X'583D',X'0004',X'0303',X'0004',X'244A',X'583D',X'0004',X'0303',X'0005',
                                                                //     22  X'246A',X'2445',X'583D',X'0004',X'0303',X'0006',X'0856',X'246A',X'2447',
                                                                //     23  X'583D',X'0004',X'0303',X'0006',X'C860',X'0020',X'2445',X'583D',X'0004',
                                                                //     24  X'0303',X'0007',X'0856',X'C860',X'0020',X'2447',X'583D',X'0004',X'0303',
                                                                //     25  X'0004',X'2446',X'583D',X'0004',X'0303',X'001E',X'4801',X'0000',X'C500',
                                                                //     26  X'8080',X'2135',X'2401',X'2410',X'8888',X'0001',X'9400',X'9330',X'1001',
                                                                //     27  X'2188',X'D301',X'4300',X'0000',X'D202',X'4300',X'0000',X'2308',X'2731',
                                                                //     28  X'4801',X'4300',X'0000',X'4002',X'4300',X'0000',X'2732',X'2217',X'0308',
                                                                //     29  X'0022',X'4801',X'0000',X'C500',X'8080',X'2135',X'2401',X'2410',X'8888',
                                                                //     30  X'0001',X'9400',X'9300',X'D352',X'0000',X'0865',X'0A62',X'0A50',X'C550',
                                                                //     31  X'00FF',X'2325',X'2405',X'241C',X'8888',X'0001',X'D252',X'0000',X'2701',
                                                                //     32  X'0218',X'2661',X'2611',X'D331',X'0000',X'D236',X'0000',X'2208',X'0014',
                                                                //     33  X'0862',X'D301',X'0000',X'D352',X'0000',X'0B50',X'2318',X'0A05',X'2306',
                                                                //     34  X'D336',X'0000',X'D431',X'0000',X'0238',X'2611',X'2661',X'2701',X'2218',
                                                                //     35  X'0855',X'0308',X'005D',X'D0B7',X'0100',X'08B2',X'48D1',X'0000',X'C5D0',
                                                                //     36  X'8080',X'2338',X'94DD',X'93DD',X'4802',X'0000',X'C500',X'8080',X'2135',
                                                                //     37  X'2401',X'2410',X'8888',X'0001',X'9400',X'9300',X'0B0D',X'4210',X'8022',
                                                                //     38  X'08CB',X'08E1',X'08FD',X'27F1',X'4210',X'801E',X'26C1',X'26E1',X'D33C',
                                                                //     39  X'0000',X'D43E',X'0000',X'2239',X'26B1',X'2701',X'4300',X'FFDA',X'D1B7',
                                                                //     40  X'0100',X'0801',X'0308',X'0866',X'2135',X'05B2',X'2037',X'4300',X'801C',
                                                                //     41  X'083B',X'0B32',X'D236',X'0000',X'08CC',X'05BC',X'2338',X'2661',X'26C1',
                                                                //     42  X'D336',X'0000',X'D23C',X'0000',X'2208',X'0855',X'2136',X'0800',X'4230',
                                                                //     43  X'FFC6',X'4300',X'8022',X'0ABD',X'D302',X'0000',X'0A02',X'0830',X'0B3B',
                                                                //     44  X'D235',X'0000',X'05B0',X'2338',X'26B1',X'2651',X'D335',X'0000',X'D23B',
                                                                //     45  X'0000',X'2208',X'D1B7',X'0000',X'05DD',X'0308',X'0007',X'0827',X'C810',
                                                                //     46  X'0100',X'9261',X'4012',X'0000',X'0308',X'0027',X'4836',X'0000',X'C530',
                                                                //     47  X'8080',X'2135',X'2401',X'2410',X'8888',X'0001',X'9433',X'9333',X'0855',
                                                                //     48  X'2328',X'5807',X'002C',X'0503',X'2124',X'0B05',X'2601',X'2315',X'2405',
                                                                //     49  X'2419',X'8888',X'0001',X'C837',X'002C',X'0813',X'D203',X'0000',X'0A65',
                                                                //     50  X'2701',X'0218',X'2631',X'D326',X'0000',X'D223',X'0000',X'2661',X'2208',
                                                                //     51  X'0004',X'2448',X'583D',X'0004',X'0303',X'000B',X'6827',X'002C',X'5867',
                                                                //     52  X'0030',X'5857',X'0034',X'C840',X'0016',X'583D',X'0004',X'0303',X'0009',
                                                                //     53  X'6827',X'002C',X'5867',X'0030',X'C840',X'0017',X'583D',X'0004',X'0303',
                                                                //     54  X'0009',X'5867',X'002C',X'5857',X'0030',X'C840',X'0015',X'583D',X'0004',
                                                                //     55  X'0303',X'000B',X'0830',X'0A33',X'2734',X'0218',X'5801',X'4300',X'0000',
                                                                //     56  X'5002',X'4300',X'0000',X'2208',X'0009',X'0830',X'0A33',X'2400',X'2734',
                                                                //     57  X'0218',X'5002',X'4300',X'0000',X'2205',X'0013',X'0831',X'4932',X'0002',
                                                                //     58  X'212B',X'4B32',X'0000',X'2118',X'0A33',X'7333',X'4200',X'0004',X'2333',
                                                                //     59  X'0A3E',X'0233',X'0821',X'2405',X'2414',X'8888',X'0001',X'0016',X'5016',
                                                                //     60  X'0008',X'5036',X'0004',X'5056',X'0000',X'CB35',X'FFFF',X'2125',X'2405',
                                                                //     61  X'2416',X'8888',X'0001',X'1C21',X'1C05',X'2400',X'0B01',X'C813',X'0003',
                                                                //     62  X'C410',X'FFFC',X'0308',X'001E',X'5073',X'0000',X'5103',X'0000',X'5063',
                                                                //     63  X'0004',X'0827',X'0A71',X'583D',X'0000',X'C973',X'FE00',X'2327',X'0B71',
                                                                //     64  X'0821',X'2402',X'2410',X'8888',X'0001',X'585E',X'0010',X'F550',X'8080',
                                                                //     65  X'8080',X'0238',X'5051',X'42FF',X'FFFC',X'2714',X'2035',X'000C',X'0833',
                                                                //     66  X'2316',X'0823',X'2405',X'241A',X'8888',X'0001',X'2411',X'2731',X'0218',
                                                                //     67  X'1C02',X'2203',X'000D',X'2401',X'2F00',X'0801',X'2316',X'2D02',X'2820',
                                                                //     68  X'2400',X'CB01',X'0001',X'0338',X'2C02',X'2701',X'2203',X'0002',X'0816',
                                                                //     69  X'0308',X'0003',X'0816',X'0A15',X'0308',X'0007',X'C817',X'002C',X'C840',
                                                                //     70  X'0011',X'583D',X'0004',X'0303',X'0007',X'C817',X'002C',X'C840',X'0012',
                                                                //     71  X'583D',X'0004',X'0303',X'0004',X'244D',X'583D',X'0004',X'0303',X'0004',
                                                                //     72  X'244E',X'583D',X'0004',X'0303',X'0004',X'244F',X'583D',X'0004',X'0303',
                                                                //     73  X'0005',X'C840',X'0010',X'583D',X'0004',X'0303',X'0004',X'244B',X'583D',
                                                                //     74  X'0004',X'0303',X'0004',X'244C',X'583D',X'0004',X'0303',X'0005',X'C840',
                                                                //     75  X'0013',X'583D',X'0004',X'0303',X'0005',X'C840',X'0014',X'583D',X'0004',
                                                                //     76  X'0303',X'0002',X'2F01',X'0308',X'0008',X'581D',X'0000',X'0B17',X'0318',
                                                                //     77  X'2402',X'2410',X'8888',X'0001',X'000B',X'6807',X'002C',X'F810',X'4080',
                                                                //     78  X'0000',X'5017',X'002C',X'6A07',X'002C',X'2E10',X'0308',X'0004',X'6807',
                                                                //     79  X'002C',X'2E10',X'0308',X'0006',X'6807',X'002C',X'2E10',X'2F21',X'2B02',
                                                                //     80  X'0308',X'0012',X'5817',X'002C',X'C460',X'000F',X'1164',X'C660',X'E101',
                                                                //     81  X'4067',X'0000',X'2460',X'4067',X'0002',X'C860',X'0308',X'4067',X'0004',
                                                                //     82  X'4307',X'0000',X'000F',X'0822',X'233A',X'0B10',X'0801',X'EE00',X'001F',
                                                                //     83  X'1D02',X'2611',X'2113',X'0800',X'0338',X'2405',X'2411',X'8888',X'0001',
                                                                //     84  X'0005',X'0338',X'2406',X'2411',X'8888',X'0001',X'0005',X'0348',X'2406',
                                                                //     85  X'2411',X'8888',X'0001',X'0007',X'D401',X'0000',X'0388',X'2406',X'2411',
                                                                //     86  X'8888',X'0001',X'000E',X'5912',X'0000',X'2117',X'5912',X'0004',X'2124',
                                                                //     87  X'5C02',X'0008',X'0308',X'0821',X'2406',X'2412',X'8888',X'0001',X'000E',
                                                                //     88  X'4A78',X'0000',X'580D',X'0000',X'C507',X'0200',X'4388',X'0002',X'4B78',
                                                                //     89  X'0000',X'2402',X'2410',X'8888',X'0001',X'0019',X'0847',X'4A48',X'0000',
                                                                //     90  X'4A78',X'0002',X'580D',X'0000',X'C507',X'0200',X'2387',X'4B78',X'0002',
                                                                //     91  X'2402',X'2410',X'8888',X'0001',X'580E',X'0010',X'5004',X'0000',X'2644',
                                                                //     92  X'0547',X'2224',X'4308',X'0004'
                                                                //     93  !
                                                                //     94  !  FAULT MESSAGES
                                                                //     95  !   1  -  NO CODE REFS LEFT
                                                                //     96  !   2  -  TOO MANY LABELS
                                                                //     97  !   3  -  SPURIOUS PERM CALL
                                                                //     98  !   4  -  TOO MANY PATCHES
                                                                //     99  !   5  -  CORRUPT JUMP
                                                                //    100  !   6  -  CORRUPT PERM ROUTINE
                                                                //    101  !   7  -  PHASE ERROR
                                                                //    102  !   8  -  CORRUPT PERM ADDRESS
                                                                //    103  !   9  -  CODE INCOMPLETE
                                                                //    104  !  10  -  GLAP INCOMPLETE
                                                                //    105  !
                                                                //    106  %CONSTINTEGER PSEUDO OBJ = 2, DIRECT = 3;! INPUT STREAMS
                                                                //    107  %CONSTINTEGER  REPORT = 0, OBJECT = 2;      ! OUTPUT
                                                                //    108  
                                                                //    109  %CONSTINTEGERARRAY NOT(0:12) = 1,0,5,4,3,2,7,6,11,10,9,8,12
#line 109 "regression-compile-tmp/gens400.imp"
const int NOT[13] = { 1, 0, 5, 4, 3, 2, 7, 6, 11, 10, 9, 8, 12,  };
                                                                //    110  %CONSTINTEGERARRAY SB(0:12) =
#line 110 "regression-compile-tmp/gens400.imp"
const int SB[13] = { 8752, 8240, 8208, 8224, 8736, 8720, 8752, 8240, 8224, 8208, 8720, 8736, 8704,  };
                                                                //    111  X'2230', X'2030', X'2010', X'2020', X'2220', X'2210',
                                                                //    112  X'2230', X'2030', X'2020', X'2010', X'2210', X'2220', X'2200'
                                                                //    113  %CONSTINTEGERARRAY SF(0:12) =
#line 113 "regression-compile-tmp/gens400.imp"
const int SF[13] = { 9008, 8496, 8464, 8480, 8992, 8976, 9008, 8496, 8480, 8464, 8976, 8992, 8960,  };
                                                                //    114  X'2330', X'2130', X'2110', X'2120', X'2320', X'2310',
                                                                //    115  X'2330', X'2130', X'2120', X'2110', X'2310', X'2320', X'2300'
                                                                //    116  %CONSTINTEGERARRAY LJ(0:12) =
#line 116 "regression-compile-tmp/gens400.imp"
const int LJ[13] = { 17214, 16958, 16926, 16942, 17198, 17182, 17214, 16958, 16942, 16926, 17182, 17198, 17166,  };
                                                                //    117  X'433E', X'423E', X'421E', X'422E', X'432E', X'431E',
                                                                //    118  X'433E', X'423E', X'422E', X'421E', X'431E', X'432E', X'430E'
                                                                //    119  %CONSTINTEGER MAX PATCH = 450
                                                                //    120  %CONSTINTEGER MAX JUMPS = 3000
                                                                //    121  %CONSTINTEGER MAX LABELS= 2000
                                                                //    122  %BEGIN
#line 122 "regression-compile-tmp/gens400.imp"
int main(int argc, char **argv) {
  _imp_initialise(argc, argv);
                                                                //    123  
                                                                //    124     %RECORDFORMAT PFM(%INTEGER WHAT, WHERE)
#line 124 "regression-compile-tmp/gens400.imp"
typedef struct PFM PFM;
struct PFM {
  int WHAT;
  int WHERE;
};
                                                                //    125     %RECORDFORMAT LFM(%INTEGER LAB, CA)
#line 125 "regression-compile-tmp/gens400.imp"
typedef struct LFM LFM;
struct LFM {
  int LAB;
  int CA;
};
                                                                //    126                      !  LAB =  MODE(3)+LABEL(12)
                                                                //    127                      !  MODE= LONG+CONDITIONAL+PERM+RT
                                                                //    128     %RECORD(LFM)%ARRAY JUMP(1 : MAXJUMPS+1)
#line 128 "regression-compile-tmp/gens400.imp"
 LFM JUMP[3001];
                                                                //    129     %RECORD(PFM)%ARRAY PATCH(1 : MAX PATCH)
#line 129 "regression-compile-tmp/gens400.imp"
 PFM PATCH[450];
                                                                //    130     %INTEGERARRAY LAB(0 : MAXLABELS)
#line 130 "regression-compile-tmp/gens400.imp"
int LAB[2001];
                                                                //    131     %INTEGERARRAY LTEMP(0:9)
#line 131 "regression-compile-tmp/gens400.imp"
int LTEMP[10];
                                                                //    132     %INTEGERARRAY PEP, PADDR(1:MAX PERM)
#line 132 "regression-compile-tmp/gens400.imp"
int PEP[54];
#line 132 "regression-compile-tmp/gens400.imp"
int PADDR[54];
                                                                //    133     %INTEGER CA, GA, LA, DA
#line 133 "regression-compile-tmp/gens400.imp"
int CA;
#line 133 "regression-compile-tmp/gens400.imp"
int GA;
#line 133 "regression-compile-tmp/gens400.imp"
int LA;
#line 133 "regression-compile-tmp/gens400.imp"
int DA;
                                                                //    134     %INTEGER LINE SIZE
#line 134 "regression-compile-tmp/gens400.imp"
int LINESIZE;
                                                                //    135     %INTEGER CODE SIZE, GLA SIZE, LOAD SIZE, PERM SIZE, DIAG SIZE
#line 135 "regression-compile-tmp/gens400.imp"
int CODESIZE;
#line 135 "regression-compile-tmp/gens400.imp"
int GLASIZE;
#line 135 "regression-compile-tmp/gens400.imp"
int LOADSIZE;
#line 135 "regression-compile-tmp/gens400.imp"
int PERMSIZE;
#line 135 "regression-compile-tmp/gens400.imp"
int DIAGSIZE;
                                                                //    136     %CONSTINTEGER EMARK = X'8888'
                                                                //    137     %CONSTINTEGER NEVER = X'7FFF'
                                                                //    138     %CONSTINTEGER LONG = X'800000'
                                                                //    139     %CONSTINTEGER COND = X'400000'
                                                                //    140     %CONSTINTEGER PERM = X'200000'
                                                                //    141     %CONSTINTEGER RT   = X'100000'
                                                                //    142     %CONSTINTEGER VERY = X'080000'
                                                                //    143     %CONSTINTEGER LABEL= X'FFFF'
                                                                //    144     %OWNINTEGER MAX LABEL = 1
#line 144 "regression-compile-tmp/gens400.imp"
static int MAXLABEL = 1;
                                                                //    145     %OWNINTEGER INIT GLA = 0
#line 145 "regression-compile-tmp/gens400.imp"
static int INITGLA = 0;
                                                                //    146     %INTEGER REF EXTRA, IGNORE, FLAG
#line 146 "regression-compile-tmp/gens400.imp"
int REFEXTRA;
#line 146 "regression-compile-tmp/gens400.imp"
int IGNORE;
#line 146 "regression-compile-tmp/gens400.imp"
int FLAG;
                                                                //    147     %INTEGER REFS, CURRENT LINE
#line 147 "regression-compile-tmp/gens400.imp"
int REFS;
#line 147 "regression-compile-tmp/gens400.imp"
int CURRENTLINE;
                                                                //    148     %INTEGER J,K,L,z
#line 148 "regression-compile-tmp/gens400.imp"
int J;
#line 148 "regression-compile-tmp/gens400.imp"
int K;
#line 148 "regression-compile-tmp/gens400.imp"
int L;
#line 148 "regression-compile-tmp/gens400.imp"
int Z;
                                                                //    149     %INTEGER CP, GP, CODE, TAG, EXTRA
#line 149 "regression-compile-tmp/gens400.imp"
int CP;
#line 149 "regression-compile-tmp/gens400.imp"
int GP;
#line 149 "regression-compile-tmp/gens400.imp"
int CODE;
#line 149 "regression-compile-tmp/gens400.imp"
int TAG;
#line 149 "regression-compile-tmp/gens400.imp"
int EXTRA;
                                                                //    150     %RECORD(PFM)%NAME PAT
#line 150 "regression-compile-tmp/gens400.imp"
 PFM /*name*/*PAT;
                                                                //    151     %INTEGER CTAG, CCA, UCA, DEFMOD, LAST
#line 151 "regression-compile-tmp/gens400.imp"
int CTAG;
#line 151 "regression-compile-tmp/gens400.imp"
int CCA;
#line 151 "regression-compile-tmp/gens400.imp"
int UCA;
#line 151 "regression-compile-tmp/gens400.imp"
int DEFMOD;
#line 151 "regression-compile-tmp/gens400.imp"
int LAST;
                                                                //    152     %INTEGER MODE, CADDR, CVAL, GADDR, GVAL
#line 152 "regression-compile-tmp/gens400.imp"
int MODE;
#line 152 "regression-compile-tmp/gens400.imp"
int CADDR;
#line 152 "regression-compile-tmp/gens400.imp"
int CVAL;
#line 152 "regression-compile-tmp/gens400.imp"
int GADDR;
#line 152 "regression-compile-tmp/gens400.imp"
int GVAL;
                                                                //    153     %SWITCH D(1:8), C(2:11)
#line 153 "regression-compile-tmp/gens400.imp"
static int sw1_D_idx;
static const void * /*SWITCH*/ sw1_D[8] = { &&sw1_D_1, &&sw1_D_2, &&sw1_D_3, &&sw1_D_4, &&sw1_D_5, &&sw1_D_6, &&sw1_D_7, &&sw1_D_8,  };
#line 153 "regression-compile-tmp/gens400.imp"
static int sw2_C_idx;
static const void * /*SWITCH*/ sw2_C[10] = { &&sw2_C_2, &&sw2_C_3, &&sw2_C_4, &&sw2_C_5, &&sw2_C_6, &&sw2_C_7, &&sw2_C_8, &&sw2_C_9, &&sw2_C_10, &&sw2_C_11,  };
                                                                //    154     %RECORD(LFM)%NAME UREF, CREF
#line 154 "regression-compile-tmp/gens400.imp"
 LFM /*name*/*UREF;
#line 154 "regression-compile-tmp/gens400.imp"
 LFM /*name*/*CREF;
                                                                //    155     %RECORD(LFM)%NAME  R,B
#line 155 "regression-compile-tmp/gens400.imp"
 LFM /*name*/*R;
#line 155 "regression-compile-tmp/gens400.imp"
 LFM /*name*/*B;
                                                                //    156     %INTEGERNAME V
#line 156 "regression-compile-tmp/gens400.imp"
int /*name*/*V;
                                                                //    157     %INTEGER PHASE
#line 157 "regression-compile-tmp/gens400.imp"
int PHASE;
                                                                //    158     %INTEGER  RX1,RX2,RX3,SJ;  RX1=0;  RX2=0;  RX3=0;  SJ=0
#line 158 "regression-compile-tmp/gens400.imp"
int RX1;
#line 158 "regression-compile-tmp/gens400.imp"
int RX2;
#line 158 "regression-compile-tmp/gens400.imp"
int RX3;
#line 158 "regression-compile-tmp/gens400.imp"
int SJ;
#line 158 "regression-compile-tmp/gens400.imp"
RX1 = 0;
#line 158 "regression-compile-tmp/gens400.imp"
RX2 = 0;
#line 158 "regression-compile-tmp/gens400.imp"
RX3 = 0;
#line 158 "regression-compile-tmp/gens400.imp"
SJ = 0;
                                                                //    159     %INTEGER RTNCALLS, PERMCALLS;  RTNCALLS=0;  PERMCALLS=0
#line 159 "regression-compile-tmp/gens400.imp"
int RTNCALLS;
#line 159 "regression-compile-tmp/gens400.imp"
int PERMCALLS;
#line 159 "regression-compile-tmp/gens400.imp"
RTNCALLS = 0;
#line 159 "regression-compile-tmp/gens400.imp"
PERMCALLS = 0;
                                                                //    160  !
                                                                //    161  !
                                                                //    162  !
                                                                //    163  %SHORTINTEGER  CBP, GBP, LBP, DBP, TBP
#line 163 "regression-compile-tmp/gens400.imp"
short CBP;
#line 163 "regression-compile-tmp/gens400.imp"
short GBP;
#line 163 "regression-compile-tmp/gens400.imp"
short LBP;
#line 163 "regression-compile-tmp/gens400.imp"
short DBP;
#line 163 "regression-compile-tmp/gens400.imp"
short TBP;
                                                                //    164  
                                                                //    165  !  N.B.   'GLABUFFSIZE' MUST BE A POWER OF 2 -- SEE LINE 562 ISH
                                                                //    166  %CONSTINTEGER  CODEBUFFSIZE=200, GLABUFFSIZE=256, LD BUFF SIZE=200
                                                                //    167  %CONSTINTEGER DIAG BUFF SIZE = 256
                                                                //    168  %SHORTINTEGERARRAY TBUFF,DBUFF(1:DIAG BUFF SIZE)
#line 168 "regression-compile-tmp/gens400.imp"
short TBUFF[256];
#line 168 "regression-compile-tmp/gens400.imp"
short DBUFF[256];
                                                                //    169  %SHORTINTEGERARRAY CBUFF(1:CODE BUFFSIZE), GBUFF(1:GLA BUFFSIZE)
#line 169 "regression-compile-tmp/gens400.imp"
short CBUFF[200];
#line 169 "regression-compile-tmp/gens400.imp"
short GBUFF[256];
                                                                //    170  %SHORTINTEGERARRAY LBUFF(1:LD BUFFSIZE);   ! ... LD = 'LOADER DATA'
#line 170 "regression-compile-tmp/gens400.imp"
short LBUFF[200];
                                                                //    171  !
                                                                //    172  !   -------OBJECT BLOCK TYPE CODES-------
                                                                //    173  %CONSTINTEGER END OF FILE BLOCK = 0
                                                                //    174  %CONSTINTEGER NONDIAG CODE BLOCK = 1
                                                                //    175  %CONSTINTEGER DIAG CODE BLOCK = 2
                                                                //    176  %CONSTINTEGER STATIC DATA BLOCK = 3;  ! ...'GLA' IN IMP CONTEXT
                                                                //    177  %CONSTINTEGER DIAGS DATA BLOCK = 4
                                                                //    178  %CONSTINTEGER DIAG TABLE     = 5
                                                                //    179  %CONSTINTEGER ENTRY POINT BLOCK = 6
                                                                //    180  %CONSTINTEGER EXTERNAL REF BLOCK = 7
                                                                //    181  %CONSTINTEGER SEGMENT SIZE BLOCK = 15
                                                                //    182  !
                                                                //    183     %ROUTINE  GET(%INTEGERNAME  N)
#line 183 "regression-compile-tmp/gens400.imp"
void GET( int /*name*/*N )
#line 183 "regression-compile-tmp/gens400.imp"
{
                                                                //    184        %INTEGER S
#line 184 "regression-compile-tmp/gens400.imp"
int S;
                                                                //    185        READSYMBOL(N);  READSYMBOL(S)
#line 185 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(N);
#line 185 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&S);
                                                                //    186        N = N<<8!S
#line 186 "regression-compile-tmp/gens400.imp"
*N = ((((*N) << (8))) | (S));
                                                                //    187     %END
#line 187 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block GET at level 2
                                                                //    188  !
                                                                //    189  %ROUTINE  PUT HALF(%SHORTINTEGER N)
#line 189 "regression-compile-tmp/gens400.imp"
void PUTHALF( short N )
#line 189 "regression-compile-tmp/gens400.imp"
{
                                                                //    190     PRINT SYMBOL((N>>8)&255)
#line 190 "regression-compile-tmp/gens400.imp"
_imp_PRINTSYMBOL((((short)((((unsigned short)(N)) >> (8)))) & (255)));
                                                                //    191     PRINT SYMBOL(N&255)
#line 191 "regression-compile-tmp/gens400.imp"
_imp_PRINTSYMBOL(((N) & (255)));
                                                                //    192  %END
#line 192 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PUTHALF at level 2
                                                                //    193  !
                                                                //    194  %ROUTINE  PUT BLOCK(%SHORTINTEGER HEADER, %SHORTINTEGERARRAYNAME BLOCK)
#line 194 "regression-compile-tmp/gens400.imp"
void PUTBLOCK( short HEADER, short /*arrayname*/*BLOCK )
#line 194 "regression-compile-tmp/gens400.imp"
{
                                                                //    195  %SHORTINTEGER I,J
#line 195 "regression-compile-tmp/gens400.imp"
short I;
#line 195 "regression-compile-tmp/gens400.imp"
short J;
                                                                //    196     PUT HALF(HEADER)
#line 196 "regression-compile-tmp/gens400.imp"
PUTHALF(HEADER);
                                                                //    197     %CYCLE I = 1,1,(HEADER>>4)&X'0FFF';   ! ...EXTRACT LENGTH
#line 197 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = (((short)((((unsigned short)(HEADER)) >> (4)))) & (4095)); I = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle I = 1, 1, (((short)((((unsigned short)(HEADER)) >> (4)))) & (4095))");
I -= _increment; _control -= _increment;
L_0002:;
if (I == _final) goto L_0003;
I += _increment; _control += _increment;
if (I != _control) _imp_signal(4,2,0,"Corrupt control variable I"); /* FOR loop control variable corrupted */
}
                                                                //    198        J = BLOCK(I)
#line 198 "regression-compile-tmp/gens400.imp"
J = BLOCK[I];
                                                                //    199        HEADER = HEADER+J;    ! ...ACCUMULATE CHECKSUM
#line 199 "regression-compile-tmp/gens400.imp"
HEADER = (((short)(HEADER)) + (J));
                                                                //    200        PUT HALF(J)
#line 200 "regression-compile-tmp/gens400.imp"
PUTHALF(J);
                                                                //    201     %REPEAT
#line 201 "regression-compile-tmp/gens400.imp"
goto L_0002;
#line 201 "regression-compile-tmp/gens400.imp"
L_0003:;
                                                                //    202     PUT HALF(-HEADER-1);   ! ...CHECKSUM
#line 202 "regression-compile-tmp/gens400.imp"
PUTHALF((((-(HEADER))) - (1)));
                                                                //    203  %END
#line 203 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PUTBLOCK at level 2
                                                                //    204  !
                                                                //    205  %ROUTINE  COPY BLOCK(%SHORTINTEGER  HEADER)
#line 205 "regression-compile-tmp/gens400.imp"
void COPYBLOCK( short HEADER )
#line 205 "regression-compile-tmp/gens400.imp"
{
                                                                //    206  %SHORTINTEGER I;  %INTEGER N
#line 206 "regression-compile-tmp/gens400.imp"
short I;
#line 206 "regression-compile-tmp/gens400.imp"
int N;
                                                                //    207     PUT HALF(HEADER)
#line 207 "regression-compile-tmp/gens400.imp"
PUTHALF(HEADER);
                                                                //    208     %CYCLE I = 1,1,(HEADER>>4)&X'0FFF'
#line 208 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = (((short)((((unsigned short)(HEADER)) >> (4)))) & (4095)); I = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle I = 1, 1, (((short)((((unsigned short)(HEADER)) >> (4)))) & (4095))");
I -= _increment; _control -= _increment;
L_0005:;
if (I == _final) goto L_0006;
I += _increment; _control += _increment;
if (I != _control) _imp_signal(4,2,0,"Corrupt control variable I"); /* FOR loop control variable corrupted */
}
                                                                //    209        GET(N); HEADER = HEADER+N
#line 209 "regression-compile-tmp/gens400.imp"
GET(&N);
#line 209 "regression-compile-tmp/gens400.imp"
HEADER = (((int)(HEADER)) + (N));
                                                                //    210        PUT HALF(N)
#line 210 "regression-compile-tmp/gens400.imp"
PUTHALF(N);
                                                                //    211     %REPEAT
#line 211 "regression-compile-tmp/gens400.imp"
goto L_0005;
#line 211 "regression-compile-tmp/gens400.imp"
L_0006:;
                                                                //    212     PUT HALF(-HEADER-1)
#line 212 "regression-compile-tmp/gens400.imp"
PUTHALF((((-(HEADER))) - (1)));
                                                                //    213  %END
#line 213 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block COPYBLOCK at level 2
                                                                //    214  %ROUTINE  CFLUSH
#line 214 "regression-compile-tmp/gens400.imp"
void CFLUSH( void )
#line 214 "regression-compile-tmp/gens400.imp"
{
                                                                //    215  !   OUTPUT BUFFER IF THERE IS ANYTHING IN IT -- OTHERWISE JUST
                                                                //    216  !   INITIALISE.   BUFFER IS EMPTY IF CBP=1
                                                                //    217     PUT BLOCK( (CBP<<4)!DIAG CODE BLOCK, CBUFF ) %IF CBP # 1
#line 217 "regression-compile-tmp/gens400.imp"
if (((CBP) == (1))) goto L_0008;
#line 217 "regression-compile-tmp/gens400.imp"
PUTBLOCK(((((CBP) << (4))) | (2)), &CBUFF[-(1)]);
#line 217 "regression-compile-tmp/gens400.imp"
L_0008:;
                                                                //    218     CBP = 1;  CBUFF(1) = CURRENT LINE
#line 218 "regression-compile-tmp/gens400.imp"
CBP = 1;
#line 218 "regression-compile-tmp/gens400.imp"
CBUFF[0] = CURRENTLINE;
                                                                //    219  %END
#line 219 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block CFLUSH at level 2
                                                                //    220  !
                                                                //    221  %ROUTINE  GFLUSH
#line 221 "regression-compile-tmp/gens400.imp"
void GFLUSH( void )
#line 221 "regression-compile-tmp/gens400.imp"
{
                                                                //    222     PUT BLOCK( (GBP<<4)!STATIC DATA BLOCK, GBUFF) %UNLESS GBP = 0
#line 222 "regression-compile-tmp/gens400.imp"
if (((GBP) == (0))) goto L_0009;
#line 222 "regression-compile-tmp/gens400.imp"
PUTBLOCK(((((GBP) << (4))) | (3)), &GBUFF[-(1)]);
#line 222 "regression-compile-tmp/gens400.imp"
L_0009:;
                                                                //    223     GBP = 0
#line 223 "regression-compile-tmp/gens400.imp"
GBP = 0;
                                                                //    224  %END
#line 224 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block GFLUSH at level 2
                                                                //    225  !
                                                                //    226  %ROUTINE  LFLUSH
#line 226 "regression-compile-tmp/gens400.imp"
void LFLUSH( void )
#line 226 "regression-compile-tmp/gens400.imp"
{
                                                                //    227     PUT BLOCK( (LBP<<4)!EXTERNAL REF BLOCK, LBUFF) %IF LBP # 0
#line 227 "regression-compile-tmp/gens400.imp"
if (((LBP) == (0))) goto L_000a;
#line 227 "regression-compile-tmp/gens400.imp"
PUTBLOCK(((((LBP) << (4))) | (7)), &LBUFF[-(1)]);
#line 227 "regression-compile-tmp/gens400.imp"
L_000a:;
                                                                //    228     LBP = 0
#line 228 "regression-compile-tmp/gens400.imp"
LBP = 0;
                                                                //    229  %END
#line 229 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block LFLUSH at level 2
                                                                //    230  !
                                                                //    231  %ROUTINE DFLUSH
#line 231 "regression-compile-tmp/gens400.imp"
void DFLUSH( void )
#line 231 "regression-compile-tmp/gens400.imp"
{
                                                                //    232     %RETURN %IF DBP = 0
#line 232 "regression-compile-tmp/gens400.imp"
if (((DBP) != (0))) goto L_000b;
#line 232 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
#line 232 "regression-compile-tmp/gens400.imp"
L_000b:;
                                                                //    233     PUT BLOCK(DBP<<4+DIAGS DATA BLOCK, DBUFF)
#line 233 "regression-compile-tmp/gens400.imp"
PUTBLOCK((((int)(((DBP) << (4)))) + (4)), &DBUFF[-(1)]);
                                                                //    234     DBP = 0
#line 234 "regression-compile-tmp/gens400.imp"
DBP = 0;
                                                                //    235  %END
#line 235 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block DFLUSH at level 2
                                                                //    236  %ROUTINE T FLUSH
#line 236 "regression-compile-tmp/gens400.imp"
void TFLUSH( void )
#line 236 "regression-compile-tmp/gens400.imp"
{
                                                                //    237     PUT BLOCK((TBP<<4)!DIAG TABLE, T BUFF) %UNLESS TBP = 0
#line 237 "regression-compile-tmp/gens400.imp"
if (((TBP) == (0))) goto L_000c;
#line 237 "regression-compile-tmp/gens400.imp"
PUTBLOCK(((((TBP) << (4))) | (5)), &TBUFF[-(1)]);
#line 237 "regression-compile-tmp/gens400.imp"
L_000c:;
                                                                //    238     TBP = 0
#line 238 "regression-compile-tmp/gens400.imp"
TBP = 0;
                                                                //    239  %END
#line 239 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block TFLUSH at level 2
                                                                //    240  %ROUTINE  CPUT(%SHORTINTEGER  N)
#line 240 "regression-compile-tmp/gens400.imp"
void CPUT( short N )
#line 240 "regression-compile-tmp/gens400.imp"
{
                                                                //    241     CBP = CBP+1;  CBUFF(CBP) = N
#line 241 "regression-compile-tmp/gens400.imp"
CBP = (((int)(CBP)) + (1));
#line 241 "regression-compile-tmp/gens400.imp"
CBUFF[(((int)(CBP)) - (1))] = N;
                                                                //    242     CA = CA+2
#line 242 "regression-compile-tmp/gens400.imp"
CA = (((int)(CA)) + (2));
                                                                //    243  %END
#line 243 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block CPUT at level 2
                                                                //    244  !
                                                                //    245  %ROUTINE  GPUT(%SHORTINTEGER  N)
#line 245 "regression-compile-tmp/gens400.imp"
void GPUT( short N )
#line 245 "regression-compile-tmp/gens400.imp"
{
                                                                //    246     GFLUSH %IF GBP = GLA BUFF SIZE
#line 246 "regression-compile-tmp/gens400.imp"
if (((GBP) != (256))) goto L_000d;
#line 246 "regression-compile-tmp/gens400.imp"
GFLUSH();
#line 246 "regression-compile-tmp/gens400.imp"
L_000d:;
                                                                //    247     GBP = GBP+1;  GBUFF(GBP) = N
#line 247 "regression-compile-tmp/gens400.imp"
GBP = (((int)(GBP)) + (1));
#line 247 "regression-compile-tmp/gens400.imp"
GBUFF[(((int)(GBP)) - (1))] = N;
                                                                //    248     GA = GA+2
#line 248 "regression-compile-tmp/gens400.imp"
GA = (((int)(GA)) + (2));
                                                                //    249  %END
#line 249 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block GPUT at level 2
                                                                //    250  !
                                                                //    251  %ROUTINE  LPUT(%SHORTINTEGER  N)
#line 251 "regression-compile-tmp/gens400.imp"
void LPUT( short N )
#line 251 "regression-compile-tmp/gens400.imp"
{
                                                                //    252     LFLUSH %IF LBP = LD BUFFSIZE
#line 252 "regression-compile-tmp/gens400.imp"
if (((LBP) != (200))) goto L_000e;
#line 252 "regression-compile-tmp/gens400.imp"
LFLUSH();
#line 252 "regression-compile-tmp/gens400.imp"
L_000e:;
                                                                //    253     LBP = LBP+1;  LBUFF(LBP) = N
#line 253 "regression-compile-tmp/gens400.imp"
LBP = (((int)(LBP)) + (1));
#line 253 "regression-compile-tmp/gens400.imp"
LBUFF[(((int)(LBP)) - (1))] = N;
                                                                //    254     LA = LA+2
#line 254 "regression-compile-tmp/gens400.imp"
LA = (((int)(LA)) + (2));
                                                                //    255  %END
#line 255 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block LPUT at level 2
                                                                //    256  !
                                                                //    257  %ROUTINE  LSYM(%SHORTINTEGER N)
#line 257 "regression-compile-tmp/gens400.imp"
void LSYM( short N )
#line 257 "regression-compile-tmp/gens400.imp"
{
                                                                //    258  %OWNINTEGER  FLAG,V
#line 258 "regression-compile-tmp/gens400.imp"
static int FLAG;
#line 258 "regression-compile-tmp/gens400.imp"
static int V;
                                                                //    259     FLAG = \FLAG
#line 259 "regression-compile-tmp/gens400.imp"
FLAG = (~(FLAG));
                                                                //    260     %IF FLAG = 0 %START
#line 260 "regression-compile-tmp/gens400.imp"
if (((FLAG) != (0))) goto L_000f;
                                                                //    261        LPUT(N<<8+V)
#line 261 "regression-compile-tmp/gens400.imp"
LPUT((((int)(((N) << (8)))) + (V)));
                                                                //    262     %ELSE
#line 262 "regression-compile-tmp/gens400.imp"
goto L_0010;
#line 262 "regression-compile-tmp/gens400.imp"
L_000f:;
                                                                //    263        V = N
#line 263 "regression-compile-tmp/gens400.imp"
V = N;
                                                                //    264     %FINISH
#line 264 "regression-compile-tmp/gens400.imp"
L_0010:;
                                                                //    265  %END
#line 265 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block LSYM at level 2
                                                                //    266  !
                                                                //    267  %ROUTINE DPUT(%SHORTINTEGER N)
#line 267 "regression-compile-tmp/gens400.imp"
void DPUT( short N )
#line 267 "regression-compile-tmp/gens400.imp"
{
                                                                //    268     DBP = DBP+1;  DBUFF(DBP) = N
#line 268 "regression-compile-tmp/gens400.imp"
DBP = (((int)(DBP)) + (1));
#line 268 "regression-compile-tmp/gens400.imp"
DBUFF[(((int)(DBP)) - (1))] = N;
                                                                //    269     DFLUSH %IF DBP = DIAG BUFF SIZE
#line 269 "regression-compile-tmp/gens400.imp"
if (((DBP) != (256))) goto L_0011;
#line 269 "regression-compile-tmp/gens400.imp"
DFLUSH();
#line 269 "regression-compile-tmp/gens400.imp"
L_0011:;
                                                                //    270     DA = DA+2
#line 270 "regression-compile-tmp/gens400.imp"
DA = (((int)(DA)) + (2));
                                                                //    271  %END
#line 271 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block DPUT at level 2
                                                                //    272  %ROUTINE  DIAG LINE
#line 272 "regression-compile-tmp/gens400.imp"
void DIAGLINE( void )
#line 272 "regression-compile-tmp/gens400.imp"
{
                                                                //    273  %OWNINTEGER  HERE = 0
#line 273 "regression-compile-tmp/gens400.imp"
static int HERE = 0;
                                                                //    274     %RETURN %IF HERE = CURRENT LINE
#line 274 "regression-compile-tmp/gens400.imp"
if (((HERE) != (CURRENTLINE))) goto L_0012;
#line 274 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
#line 274 "regression-compile-tmp/gens400.imp"
L_0012:;
                                                                //    275     HERE = CURRENT LINE
#line 275 "regression-compile-tmp/gens400.imp"
HERE = CURRENTLINE;
                                                                //    276     DPUT(CURRENT LINE);  DPUT(CA)
#line 276 "regression-compile-tmp/gens400.imp"
DPUT(CURRENTLINE);
#line 276 "regression-compile-tmp/gens400.imp"
DPUT(CA);
                                                                //    277  %END
#line 277 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block DIAGLINE at level 2
                                                                //    278  %ROUTINE T PUT(%SHORTINTEGER V)
#line 278 "regression-compile-tmp/gens400.imp"
void TPUT( short V )
#line 278 "regression-compile-tmp/gens400.imp"
{
                                                                //    279     TBP = TBP+1;  TBUFF(TBP) = V
#line 279 "regression-compile-tmp/gens400.imp"
TBP = (((int)(TBP)) + (1));
#line 279 "regression-compile-tmp/gens400.imp"
TBUFF[(((int)(TBP)) - (1))] = V;
                                                                //    280     T FLUSH %IF TBP = DIAG BUFF SIZE
#line 280 "regression-compile-tmp/gens400.imp"
if (((TBP) != (256))) goto L_0013;
#line 280 "regression-compile-tmp/gens400.imp"
TFLUSH();
#line 280 "regression-compile-tmp/gens400.imp"
L_0013:;
                                                                //    281  %END
#line 281 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block TPUT at level 2
                                                                //    282  %ROUTINE  CLOSE OBJECT FILE
#line 282 "regression-compile-tmp/gens400.imp"
void CLOSEOBJECTFILE( void )
#line 282 "regression-compile-tmp/gens400.imp"
{
                                                                //    283     CFLUSH;  GFLUSH;  LFLUSH
#line 283 "regression-compile-tmp/gens400.imp"
CFLUSH();
#line 283 "regression-compile-tmp/gens400.imp"
GFLUSH();
#line 283 "regression-compile-tmp/gens400.imp"
LFLUSH();
                                                                //    284     DPUT(0);  DPUT(0);  D FLUSH ;  ! ... MARK END OF TABLE THEN FLUSH
#line 284 "regression-compile-tmp/gens400.imp"
DPUT(0);
#line 284 "regression-compile-tmp/gens400.imp"
DPUT(0);
#line 284 "regression-compile-tmp/gens400.imp"
DFLUSH();
                                                                //    285     TPUT(X'8800');  TPUT(CA+2)
#line 285 "regression-compile-tmp/gens400.imp"
TPUT(34816);
#line 285 "regression-compile-tmp/gens400.imp"
TPUT((((int)(CA)) + (2)));
                                                                //    286     TPUT(0);  TPUT(0)
#line 286 "regression-compile-tmp/gens400.imp"
TPUT(0);
#line 286 "regression-compile-tmp/gens400.imp"
TPUT(0);
                                                                //    287     TPUT(0);  TPUT(0)
#line 287 "regression-compile-tmp/gens400.imp"
TPUT(0);
#line 287 "regression-compile-tmp/gens400.imp"
TPUT(0);
                                                                //    288     TPUT(0);  TPUT(0); T FLUSH;   ! .... DITTO ....
#line 288 "regression-compile-tmp/gens400.imp"
TPUT(0);
#line 288 "regression-compile-tmp/gens400.imp"
TPUT(0);
#line 288 "regression-compile-tmp/gens400.imp"
TFLUSH();
                                                                //    289     PUT HALF( (0<<4)!END OF FILE BLOCK );  ! ...ZERO DATA CONTENT
#line 289 "regression-compile-tmp/gens400.imp"
PUTHALF(((((0) << (4))) | (0)));
                                                                //    290     PUT HALF(-END OF FILE BLOCK-1);   ! ...CHECK SUM
#line 290 "regression-compile-tmp/gens400.imp"
PUTHALF((-1));
                                                                //    291  %END
#line 291 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block CLOSEOBJECTFILE at level 2
                                                                //    292  !
                                                                //    293  !
                                                                //    294  !
                                                                //    295  !
                                                                //    296  !
                                                                //    297     %ROUTINE MONITOR(%INTEGER N)
#line 297 "regression-compile-tmp/gens400.imp"
void MONITOR( int N )
#line 297 "regression-compile-tmp/gens400.imp"
{
                                                                //    298        SELECTOUTPUT(REPORT)
#line 298 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(0);
                                                                //    299        PRINTSTRING("FAULT");  WRITE(N, 1)
#line 299 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("FAULT"));
#line 299 "regression-compile-tmp/gens400.imp"
_imp_WRITE(N, 1);
                                                                //    300        PRINTSTRING("   PHASE");  WRITE(PHASE, 1);  NEWLINE
#line 300 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("   PHASE"));
#line 300 "regression-compile-tmp/gens400.imp"
_imp_WRITE(PHASE, 1);
#line 300 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    301        WRITE(REFS, 1);  PRINTSTRING(" REFS");  NEWLINE
#line 301 "regression-compile-tmp/gens400.imp"
_imp_WRITE(REFS, 1);
#line 301 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" REFS"));
#line 301 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    302        PRINTSTRING("MAX LABEL");  WRITE(MAX LABEL, 1);  NEWLINE
#line 302 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("MAX LABEL"));
#line 302 "regression-compile-tmp/gens400.imp"
_imp_WRITE(MAXLABEL, 1);
#line 302 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    303        %SIGNAL 15,15
#line 303 "regression-compile-tmp/gens400.imp"
_imp_signal(15, 15, 0, "");
                                                                //    304     %END
#line 304 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block MONITOR at level 2
                                                                //    305  !
                                                                //    306     %ROUTINE SORT(%INTEGER FROM, TO)
#line 306 "regression-compile-tmp/gens400.imp"
void SORT( int FROM, int TO )
#line 306 "regression-compile-tmp/gens400.imp"
{
                                                                //    307        %INTEGER FLAG, J, T
#line 307 "regression-compile-tmp/gens400.imp"
int FLAG;
#line 307 "regression-compile-tmp/gens400.imp"
int J;
#line 307 "regression-compile-tmp/gens400.imp"
int T;
                                                                //    308        %RECORD(PFM)%NAME A, B
#line 308 "regression-compile-tmp/gens400.imp"
 PFM /*name*/*A;
#line 308 "regression-compile-tmp/gens400.imp"
 PFM /*name*/*B;
                                                                //    309        %WHILE TO > FROM %CYCLE
#line 309 "regression-compile-tmp/gens400.imp"
L_0014:;
#line 309 "regression-compile-tmp/gens400.imp"
if (((TO) <= (FROM))) goto L_0015;
                                                                //    310           FLAG = 0
#line 310 "regression-compile-tmp/gens400.imp"
FLAG = 0;
                                                                //    311           A == PATCH(FROM)
#line 311 "regression-compile-tmp/gens400.imp"
A = &PATCH[(((int)(FROM)) - (1))];
                                                                //    312           %CYCLE J = FROM+1, 1, TO
#line 312 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = (((int)(FROM)) + (1)); _increment = 1; _final = TO; J = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle J = (((int)(FROM)) + (1)), 1, TO");
J -= _increment; _control -= _increment;
L_0017:;
if (J == _final) goto L_0018;
J += _increment; _control += _increment;
if (J != _control) _imp_signal(4,2,0,"Corrupt control variable J"); /* FOR loop control variable corrupted */
}
                                                                //    313              B == PATCH(J)
#line 313 "regression-compile-tmp/gens400.imp"
B = &PATCH[(((int)(J)) - (1))];
                                                                //    314              %IF A_WHERE > B_WHERE %START
#line 314 "regression-compile-tmp/gens400.imp"
if (((A->WHERE) <= (B->WHERE))) goto L_001a;
                                                                //    315                 T = A_WHERE;  A_WHERE = B_WHERE;  B_WHERE = T
#line 315 "regression-compile-tmp/gens400.imp"
T = A->WHERE;
#line 315 "regression-compile-tmp/gens400.imp"
A->WHERE = B->WHERE;
#line 315 "regression-compile-tmp/gens400.imp"
B->WHERE = T;
                                                                //    316                 T = B_WHAT;  B_WHAT = A_WHAT;  A_WHAT = T
#line 316 "regression-compile-tmp/gens400.imp"
T = B->WHAT;
#line 316 "regression-compile-tmp/gens400.imp"
B->WHAT = A->WHAT;
#line 316 "regression-compile-tmp/gens400.imp"
A->WHAT = T;
                                                                //    317                 FLAG = 1
#line 317 "regression-compile-tmp/gens400.imp"
FLAG = 1;
                                                                //    318              %ELSE %IF A_WHERE = B_WHERE
#line 318 "regression-compile-tmp/gens400.imp"
goto L_001b;
#line 318 "regression-compile-tmp/gens400.imp"
L_001a:;
#line 318 "regression-compile-tmp/gens400.imp"
if (((A->WHERE) != (B->WHERE))) goto L_001c;
                                                                //    319                 FLAG = 1
#line 319 "regression-compile-tmp/gens400.imp"
FLAG = 1;
                                                                //    320                 A_WHERE = -10
#line 320 "regression-compile-tmp/gens400.imp"
A->WHERE = (-10);
                                                                //    321              %FINISH
#line 321 "regression-compile-tmp/gens400.imp"
L_001c:;
#line 321 "regression-compile-tmp/gens400.imp"
L_001b:;
                                                                //    322              A == B
#line 322 "regression-compile-tmp/gens400.imp"
A = B;
                                                                //    323           %REPEAT
#line 323 "regression-compile-tmp/gens400.imp"
goto L_0017;
#line 323 "regression-compile-tmp/gens400.imp"
L_0018:;
                                                                //    324           %EXIT %IF FLAG = 0
#line 324 "regression-compile-tmp/gens400.imp"
if (((FLAG) != (0))) goto L_001d;
#line 324 "regression-compile-tmp/gens400.imp"
goto L_0015;
#line 324 "regression-compile-tmp/gens400.imp"
L_001d:;
                                                                //    325           TO = TO-1
#line 325 "regression-compile-tmp/gens400.imp"
TO = (((int)(TO)) - (1));
                                                                //    326        %REPEAT
#line 326 "regression-compile-tmp/gens400.imp"
goto L_0014;
#line 326 "regression-compile-tmp/gens400.imp"
L_0015:;
                                                                //    327     %END
#line 327 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block SORT at level 2
                                                                //    328     %ROUTINE NEXT CODE
#line 328 "regression-compile-tmp/gens400.imp"
void NEXTCODE( void )
#line 328 "regression-compile-tmp/gens400.imp"
{
                                                                //    329        %OWNINTEGER P = 1, J = 1
#line 329 "regression-compile-tmp/gens400.imp"
static int P = 1;
#line 329 "regression-compile-tmp/gens400.imp"
static int J = 1;
                                                                //    330        %INTEGER C, BV
#line 330 "regression-compile-tmp/gens400.imp"
int C;
#line 330 "regression-compile-tmp/gens400.imp"
int BV;
                                                                //    331        %RECORD(PFM)%NAME PP
#line 331 "regression-compile-tmp/gens400.imp"
 PFM /*name*/*PP;
                                                                //    332        C = NEVER;  BV = NEVER;  MODE = NEVER
#line 332 "regression-compile-tmp/gens400.imp"
C = 32767;
#line 332 "regression-compile-tmp/gens400.imp"
BV = 32767;
#line 332 "regression-compile-tmp/gens400.imp"
MODE = 32767;
                                                                //    333        %IF P <= CP %START;! CODE PATCHES LEFT
#line 333 "regression-compile-tmp/gens400.imp"
if (((P) > (CP))) goto L_001e;
                                                                //    334           %CYCLE
#line 334 "regression-compile-tmp/gens400.imp"
L_001f:;
                                                                //    335              PP == PATCH(P)
#line 335 "regression-compile-tmp/gens400.imp"
PP = &PATCH[(((int)(P)) - (1))];
                                                                //    336              %EXIT %IF PP_WHERE # -10
#line 336 "regression-compile-tmp/gens400.imp"
if (((PP->WHERE) == ((-10)))) goto L_0022;
#line 336 "regression-compile-tmp/gens400.imp"
goto L_0020;
#line 336 "regression-compile-tmp/gens400.imp"
L_0022:;
                                                                //    337              P = P+1
#line 337 "regression-compile-tmp/gens400.imp"
P = (((int)(P)) + (1));
                                                                //    338           %REPEAT
#line 338 "regression-compile-tmp/gens400.imp"
goto L_001f;
#line 338 "regression-compile-tmp/gens400.imp"
L_0020:;
                                                                //    339           C = PP_WHERE>>1
#line 339 "regression-compile-tmp/gens400.imp"
C = (int)((((unsigned int)(PP->WHERE)) >> (1)));
                                                                //    340        %FINISH
#line 340 "regression-compile-tmp/gens400.imp"
L_001e:;
                                                                //    341        %IF J < REFS %START;!  JUMPS LEFT
#line 341 "regression-compile-tmp/gens400.imp"
if (((J) >= (REFS))) goto L_0023;
                                                                //    342           B == JUMP(J)
#line 342 "regression-compile-tmp/gens400.imp"
B = &JUMP[(((int)(J)) - (1))];
                                                                //    343           BV = B_CA>>1
#line 343 "regression-compile-tmp/gens400.imp"
BV = (int)((((unsigned int)(B->CA)) >> (1)));
                                                                //    344        %FINISH
#line 344 "regression-compile-tmp/gens400.imp"
L_0023:;
                                                                //    345        CADDR = NEVER
#line 345 "regression-compile-tmp/gens400.imp"
CADDR = 32767;
                                                                //    346        %RETURN %IF BV = NEVER = C
#line 346 "regression-compile-tmp/gens400.imp"
if ((((BV) != (32767))) || (((32767) != (C)))) goto L_0024;
#line 346 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
#line 346 "regression-compile-tmp/gens400.imp"
L_0024:;
                                                                //    347        %IF BV > C %START
#line 347 "regression-compile-tmp/gens400.imp"
if (((BV) <= (C))) goto L_0025;
                                                                //    348           P = P+1
#line 348 "regression-compile-tmp/gens400.imp"
P = (((int)(P)) + (1));
                                                                //    349           CADDR = PP_WHERE;  CVAL = PP_WHAT
#line 349 "regression-compile-tmp/gens400.imp"
CADDR = PP->WHERE;
#line 349 "regression-compile-tmp/gens400.imp"
CVAL = PP->WHAT;
                                                                //    350           %RETURN
#line 350 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
                                                                //    351        %FINISH
#line 351 "regression-compile-tmp/gens400.imp"
L_0025:;
                                                                //    352        %IF C > BV %START
#line 352 "regression-compile-tmp/gens400.imp"
if (((C) <= (BV))) goto L_0026;
                                                                //    353           J = J+1
#line 353 "regression-compile-tmp/gens400.imp"
J = (((int)(J)) + (1));
                                                                //    354           MODE = 0;  CADDR = B_CA
#line 354 "regression-compile-tmp/gens400.imp"
MODE = 0;
#line 354 "regression-compile-tmp/gens400.imp"
CADDR = B->CA;
                                                                //    355           %RETURN
#line 355 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
                                                                //    356        %FINISH
#line 356 "regression-compile-tmp/gens400.imp"
L_0026:;
                                                                //    357        MONITOR(1)
#line 357 "regression-compile-tmp/gens400.imp"
MONITOR(1);
                                                                //    358     %END
#line 358 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block NEXTCODE at level 2
                                                                //    359     %ROUTINE NEXT GLA
#line 359 "regression-compile-tmp/gens400.imp"
void NEXTGLA( void )
#line 359 "regression-compile-tmp/gens400.imp"
{
                                                                //    360        GADDR = NEVER %AND %RETURN %IF GP > MAX PATCH
#line 360 "regression-compile-tmp/gens400.imp"
if (((GP) <= (450))) goto L_0027;
#line 360 "regression-compile-tmp/gens400.imp"
GADDR = 32767;
#line 360 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
#line 360 "regression-compile-tmp/gens400.imp"
L_0027:;
                                                                //    361        PAT == PATCH(GP) %AND GP = GP+1 %UNTIL PAT_WHERE >= 0
#line 361 "regression-compile-tmp/gens400.imp"
L_0028:;
#line 361 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(GP)) - (1))];
#line 361 "regression-compile-tmp/gens400.imp"
GP = (((int)(GP)) + (1));
#line 361 "regression-compile-tmp/gens400.imp"
if (((PAT->WHERE) >= (0))) goto L_0029;
#line 361 "regression-compile-tmp/gens400.imp"
goto L_0028;
#line 361 "regression-compile-tmp/gens400.imp"
L_0029:;
                                                                //    362        GADDR = PAT_WHERE;  GVAL = PAT_WHAT
#line 362 "regression-compile-tmp/gens400.imp"
GADDR = PAT->WHERE;
#line 362 "regression-compile-tmp/gens400.imp"
GVAL = PAT->WHAT;
                                                                //    363     %END
#line 363 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block NEXTGLA at level 2
                                                                //    364     %ROUTINE SET PERM(%INTEGER N)
#line 364 "regression-compile-tmp/gens400.imp"
void SETPERM( int N )
#line 364 "regression-compile-tmp/gens400.imp"
{
                                                                //    365        %INTEGER J,K
#line 365 "regression-compile-tmp/gens400.imp"
int J;
#line 365 "regression-compile-tmp/gens400.imp"
int K;
                                                                //    366        %RETURN %UNLESS PEP(N) = 1
#line 366 "regression-compile-tmp/gens400.imp"
if (((PEP[(((int)(N)) - (1))]) == (1))) goto L_002b;
#line 366 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
#line 366 "regression-compile-tmp/gens400.imp"
L_002b:;
                                                                //    367        PEP(N) = 2
#line 367 "regression-compile-tmp/gens400.imp"
PEP[(((int)(N)) - (1))] = 2;
                                                                //    368        K = PERMS(N)
#line 368 "regression-compile-tmp/gens400.imp"
K = (PERMS-1)[N];
                                                                //    369        %IF K = 0 %START
#line 369 "regression-compile-tmp/gens400.imp"
if (((K) != (0))) goto L_002c;
                                                                //    370           SELECTOUTPUT(REPORT)
#line 370 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(0);
                                                                //    371           PRINTSTRING("NO ENTRY FOR PERM");  WRITE(N, 1);  NEWLINE
#line 371 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("NO ENTRY FOR PERM"));
#line 371 "regression-compile-tmp/gens400.imp"
_imp_WRITE(N, 1);
#line 371 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    372           PEP(N) = 0
#line 372 "regression-compile-tmp/gens400.imp"
PEP[(((int)(N)) - (1))] = 0;
                                                                //    373           SELECTOUTPUT(OBJECT)
#line 373 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(2);
                                                                //    374           %RETURN
#line 374 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
                                                                //    375        %FINISH
#line 375 "regression-compile-tmp/gens400.imp"
L_002c:;
                                                                //    376        %CYCLE J = 1, 1, PERMS(K)
#line 376 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = (PERMS-1)[K]; J = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle J = 1, 1, (PERMS-1)[K]");
J -= _increment; _control -= _increment;
L_002d:;
if (J == _final) goto L_002e;
J += _increment; _control += _increment;
if (J != _control) _imp_signal(4,2,0,"Corrupt control variable J"); /* FOR loop control variable corrupted */
}
                                                                //    377           K = K+1
#line 377 "regression-compile-tmp/gens400.imp"
K = (((int)(K)) + (1));
                                                                //    378           %IF PERMS(K) = EMARK %START
#line 378 "regression-compile-tmp/gens400.imp"
if ((((PERMS-1)[K]) != (34952))) goto L_0030;
                                                                //    379              N = PERMS(K+1)
#line 379 "regression-compile-tmp/gens400.imp"
N = (PERMS-1)[(((int)(K)) + (1))];
                                                                //    380              %IF PEP(N) # 2 %START
#line 380 "regression-compile-tmp/gens400.imp"
if (((PEP[(((int)(N)) - (1))]) == (2))) goto L_0031;
                                                                //    381                 PEP(N) = 1;  SET PERM(N)
#line 381 "regression-compile-tmp/gens400.imp"
PEP[(((int)(N)) - (1))] = 1;
#line 381 "regression-compile-tmp/gens400.imp"
SETPERM(N);
                                                                //    382              %FINISH
#line 382 "regression-compile-tmp/gens400.imp"
L_0031:;
                                                                //    383           %FINISH
#line 383 "regression-compile-tmp/gens400.imp"
L_0030:;
                                                                //    384        %REPEAT
#line 384 "regression-compile-tmp/gens400.imp"
goto L_002d;
#line 384 "regression-compile-tmp/gens400.imp"
L_002e:;
                                                                //    385     %END
#line 385 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block SETPERM at level 2
                                                                //    386  
                                                                //    387  %ROUTINE  PLANT LONG JUMP
#line 387 "regression-compile-tmp/gens400.imp"
void PLANTLONGJUMP( void )
#line 387 "regression-compile-tmp/gens400.imp"
{
                                                                //    388     %INTEGER N
#line 388 "regression-compile-tmp/gens400.imp"
int N;
                                                                //    389  !  PLANT A BRANCH OR BAL INSTRUCTION WHICH IS ASSUMED TO BE DESCRIBED
                                                                //    390  !  BY 'L'(OP CODE + BASE REG), 'TAG'(DESTINATION ADDRESS),
                                                                //    391  !  'B'(NAME OF RECORD CONTAINING FLAG BITS) AND 'CA'(CURRENT CODE
                                                                //    392  !  ADDRESS).
                                                                //    393     %IF B_LAB&VERY = 0 %START;    ! ...CAN USE A 32 BIT FORM
#line 393 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (524288))) != (0))) goto L_0032;
                                                                //    394        N = TAG-(CA+4)
#line 394 "regression-compile-tmp/gens400.imp"
N = ((TAG) - ((int)((((int)(CA)) + (4)))));
                                                                //    395        %IF -16*1024 <= N < 16*1024 %START;      ! USE PC RELATIVE
#line 395 "regression-compile-tmp/gens400.imp"
if (((((-((((int)(16)) * (1024))))) > (N))) || (((N) >= ((((int)(16)) * (1024)))))) goto L_0033;
                                                                //    396           L = L&X'FFF0';          ! STRIP OFF BASE REGISTER
#line 396 "regression-compile-tmp/gens400.imp"
L = ((L) & (65520));
                                                                //    397           CPUT(L);  CPUT(N!X'8000' )
#line 397 "regression-compile-tmp/gens400.imp"
CPUT(L);
#line 397 "regression-compile-tmp/gens400.imp"
CPUT(((N) | (32768)));
                                                                //    398           RX2 = RX2+1
#line 398 "regression-compile-tmp/gens400.imp"
RX2 = (((int)(RX2)) + (1));
                                                                //    399        %ELSE;          !USE BASE+DISP
#line 399 "regression-compile-tmp/gens400.imp"
goto L_0034;
#line 399 "regression-compile-tmp/gens400.imp"
L_0033:;
                                                                //    400           CPUT(L);  CPUT(TAG)
#line 400 "regression-compile-tmp/gens400.imp"
CPUT(L);
#line 400 "regression-compile-tmp/gens400.imp"
CPUT(TAG);
                                                                //    401           RX1 = RX1+1
#line 401 "regression-compile-tmp/gens400.imp"
RX1 = (((int)(RX1)) + (1));
                                                                //    402        %FINISH
#line 402 "regression-compile-tmp/gens400.imp"
L_0034:;
                                                                //    403     %ELSE;                        ! ...48 BIT ADDRESS REQ'D
#line 403 "regression-compile-tmp/gens400.imp"
goto L_0035;
#line 403 "regression-compile-tmp/gens400.imp"
L_0032:;
                                                                //    404        CPUT(L)
#line 404 "regression-compile-tmp/gens400.imp"
CPUT(L);
                                                                //    405        CPUT((TAG>>16&X'FF')+X'4000')
#line 405 "regression-compile-tmp/gens400.imp"
CPUT((((int)((((int)((((unsigned int)(TAG)) >> (16)))) & (255)))) + (16384)));
                                                                //    406        CPUT(TAG);      ! ...N.B. 'CPUT' ONLY PUTS 16 BITS
#line 406 "regression-compile-tmp/gens400.imp"
CPUT(TAG);
                                                                //    407        RX3 = RX3+1
#line 407 "regression-compile-tmp/gens400.imp"
RX3 = (((int)(RX3)) + (1));
                                                                //    408     %FINISH
#line 408 "regression-compile-tmp/gens400.imp"
L_0035:;
                                                                //    409  %END
#line 409 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return;
} // End of block PLANTLONGJUMP at level 2
                                                                //    410  
                                                                //    411  
                                                                //    412  
                                                                //    413  !
                                                                //    414  ! PHASE 1 - INPUT PROGRAM & GENERATE JUMP TABLES + PATCH TABLES
                                                                //    415  !
                                                                //    416     PHASE = 1
#line 416 "regression-compile-tmp/gens400.imp"
PHASE = 1;
                                                                //    417     PEP(J) = 0 %AND PADDR(J) = 0 %FOR J = 1, 1, MAX PERM
#line 417 "regression-compile-tmp/gens400.imp"
J = 0;
if ((((54)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle J = 1, 1, 54");
L_0036:;
if (J == 54) goto L_0037;
J += 1;
#line 417 "regression-compile-tmp/gens400.imp"
PEP[(((int)(J)) - (1))] = 0;
#line 417 "regression-compile-tmp/gens400.imp"
PADDR[(((int)(J)) - (1))] = 0;
#line 417 "regression-compile-tmp/gens400.imp"
goto L_0036;
#line 417 "regression-compile-tmp/gens400.imp"
L_0037:;
                                                                //    418     CP = 0;  GP = MAX PATCH+1
#line 418 "regression-compile-tmp/gens400.imp"
CP = 0;
#line 418 "regression-compile-tmp/gens400.imp"
GP = 451;
                                                                //    419     REFS = 0;  DEFMOD = 0;  UCA = 0;  CCA = 0;  CTAG = 0
#line 419 "regression-compile-tmp/gens400.imp"
REFS = 0;
#line 419 "regression-compile-tmp/gens400.imp"
DEFMOD = 0;
#line 419 "regression-compile-tmp/gens400.imp"
UCA = 0;
#line 419 "regression-compile-tmp/gens400.imp"
CCA = 0;
#line 419 "regression-compile-tmp/gens400.imp"
CTAG = 0;
                                                                //    420     LAB(J) = 0 %FOR J = 1,1,MAX LABELS
#line 420 "regression-compile-tmp/gens400.imp"
J = 0;
if ((((2000)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle J = 1, 1, 2000");
L_0039:;
if (J == 2000) goto L_003a;
J += 1;
#line 420 "regression-compile-tmp/gens400.imp"
LAB[J] = 0;
#line 420 "regression-compile-tmp/gens400.imp"
goto L_0039;
#line 420 "regression-compile-tmp/gens400.imp"
L_003a:;
                                                                //    421     SELECTINPUT(DIRECT)
#line 421 "regression-compile-tmp/gens400.imp"
_imp_SELECTINPUT(3);
                                                                //    422     READ SYMBOL(INIT GLA);  ! MINIMUM POSSIBLE SIZE OF GLA - FROM PASS 2
#line 422 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&INITGLA);
                                                                //    423     %CYCLE
#line 423 "regression-compile-tmp/gens400.imp"
L_003c:;
                                                                //    424        READSYMBOL(CODE);  ->D(CODE)
#line 424 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&CODE);
#line 424 "regression-compile-tmp/gens400.imp"
sw1_D_idx = CODE; if ((1 <= sw1_D_idx) && (sw1_D_idx <= 8)) goto *(sw1_D-1)[sw1_D_idx];  /* Bounds=1:8 */ else {
   /*_imp_signal(8, 2, sw1_D_idx);*/
   fprintf(stderr, "%%SWITCH index D(%d) not in range 1:8 at %s:%d\n",
           sw1_D_idx, (_imp_current_file != 0 ? _imp_current_file : __FILE__),
           (_imp_current_line != 0 ? _imp_current_line : __LINE__));
           exit(1);
}
                                                                //    425  D(1):! TAG DEF <REF>, <CA>
#line 425 "regression-compile-tmp/gens400.imp"
sw1_D_1:;
                                                                //    426        GET(TAG);  GET(CA)
#line 426 "regression-compile-tmp/gens400.imp"
GET(&TAG);
#line 426 "regression-compile-tmp/gens400.imp"
GET(&CA);
                                                                //    427        MONITOR(2) %IF TAG > MAX LABELS
#line 427 "regression-compile-tmp/gens400.imp"
if (((TAG) <= (2000))) goto L_003f;
#line 427 "regression-compile-tmp/gens400.imp"
MONITOR(2);
#line 427 "regression-compile-tmp/gens400.imp"
L_003f:;
                                                                //    428        MAX LABEL = TAG %IF TAG > MAX LABEL
#line 428 "regression-compile-tmp/gens400.imp"
if (((TAG) <= (MAXLABEL))) goto L_0040;
#line 428 "regression-compile-tmp/gens400.imp"
MAXLABEL = TAG;
#line 428 "regression-compile-tmp/gens400.imp"
L_0040:;
                                                                //    429        %IF TAG = CTAG %AND CCA = CA %AND UCA = CA %START
#line 429 "regression-compile-tmp/gens400.imp"
if (((TAG) != (CTAG))) goto L_0041;
#line 429 "regression-compile-tmp/gens400.imp"
if (((CCA) != (CA))) goto L_0041;
#line 429 "regression-compile-tmp/gens400.imp"
if (((UCA) != (CA))) goto L_0041;
                                                                //    430           DEFMOD = DEFMOD+2
#line 430 "regression-compile-tmp/gens400.imp"
DEFMOD = (((int)(DEFMOD)) + (2));
                                                                //    431           UREF_LAB = UREF_LAB!PERM!COND
#line 431 "regression-compile-tmp/gens400.imp"
UREF->LAB = ((((UREF->LAB) | (2097152))) | (4194304));
                                                                //    432           CREF_LAB = CREF_LAB!VERY!RT
#line 432 "regression-compile-tmp/gens400.imp"
CREF->LAB = ((((CREF->LAB) | (524288))) | (1048576));
                                                                //    433           CTAG = UREF_LAB&LABEL
#line 433 "regression-compile-tmp/gens400.imp"
CTAG = ((UREF->LAB) & (65535));
                                                                //    434           CREF == UREF
#line 434 "regression-compile-tmp/gens400.imp"
CREF = UREF;
                                                                //    435           CCA = CA+2
#line 435 "regression-compile-tmp/gens400.imp"
CCA = (((int)(CA)) + (2));
                                                                //    436        %ELSE
#line 436 "regression-compile-tmp/gens400.imp"
goto L_0042;
#line 436 "regression-compile-tmp/gens400.imp"
L_0041:;
                                                                //    437           CTAG = 0
#line 437 "regression-compile-tmp/gens400.imp"
CTAG = 0;
                                                                //    438        %FINISH
#line 438 "regression-compile-tmp/gens400.imp"
L_0042:;
                                                                //    439        LAB(TAG) = CA
#line 439 "regression-compile-tmp/gens400.imp"
LAB[TAG] = CA;
                                                                //    440        %CONTINUE
#line 440 "regression-compile-tmp/gens400.imp"
goto L_003e;
                                                                //    441  D(2):! CREF <REF>, <CA>
#line 441 "regression-compile-tmp/gens400.imp"
sw1_D_2:;
                                                                //    442        FLAG = COND;  ->CURP
#line 442 "regression-compile-tmp/gens400.imp"
FLAG = 4194304;
#line 442 "regression-compile-tmp/gens400.imp"
goto U_1000;
                                                                //    443  D(3):! UREF <REF>, <CA>
#line 443 "regression-compile-tmp/gens400.imp"
sw1_D_3:;
                                                                //    444        FLAG = 0;     ->CURP
#line 444 "regression-compile-tmp/gens400.imp"
FLAG = 0;
#line 444 "regression-compile-tmp/gens400.imp"
goto U_1000;
                                                                //    445  D(4):! RREF <REF>, <CA>
#line 445 "regression-compile-tmp/gens400.imp"
sw1_D_4:;
                                                                //    446        FLAG = RT+LONG
#line 446 "regression-compile-tmp/gens400.imp"
FLAG = 9437184;
                                                                //    447        RTNCALLS = RTNCALLS+1
#line 447 "regression-compile-tmp/gens400.imp"
RTNCALLS = (((int)(RTNCALLS)) + (1));
                                                                //    448        -> CURP
#line 448 "regression-compile-tmp/gens400.imp"
goto U_1000;
                                                                //    449  
                                                                //    450  D(5):! PREF <REF>, <CA>
#line 450 "regression-compile-tmp/gens400.imp"
sw1_D_5:;
                                                                //    451        FLAG = PERM+LONG
#line 451 "regression-compile-tmp/gens400.imp"
FLAG = 10485760;
                                                                //    452        PERMCALLS = PERMCALLS+1
#line 452 "regression-compile-tmp/gens400.imp"
PERMCALLS = (((int)(PERMCALLS)) + (1));
                                                                //    453  
                                                                //    454  CURP: GET(TAG);  GET(CA)
#line 454 "regression-compile-tmp/gens400.imp"
U_1000:;
#line 454 "regression-compile-tmp/gens400.imp"
GET(&TAG);
#line 454 "regression-compile-tmp/gens400.imp"
GET(&CA);
                                                                //    455        REFS = REFS+1;  R == JUMP(REFS)
#line 455 "regression-compile-tmp/gens400.imp"
REFS = (((int)(REFS)) + (1));
#line 455 "regression-compile-tmp/gens400.imp"
R = &JUMP[(((int)(REFS)) - (1))];
                                                                //    456        MONITOR(1) %IF REFS > MAX JUMPS
#line 456 "regression-compile-tmp/gens400.imp"
if (((REFS) <= (3000))) goto L_0043;
#line 456 "regression-compile-tmp/gens400.imp"
MONITOR(1);
#line 456 "regression-compile-tmp/gens400.imp"
L_0043:;
                                                                //    457        R_LAB = TAG+FLAG
#line 457 "regression-compile-tmp/gens400.imp"
R->LAB = (((int)(TAG)) + (FLAG));
                                                                //    458        R_CA = CA
#line 458 "regression-compile-tmp/gens400.imp"
R->CA = CA;
                                                                //    459        %IF FLAG = 0 %START;       ! UNCONDITIONAL
#line 459 "regression-compile-tmp/gens400.imp"
if (((FLAG) != (0))) goto L_0044;
                                                                //    460           UCA = CA+2;  UREF == R
#line 460 "regression-compile-tmp/gens400.imp"
UCA = (((int)(CA)) + (2));
#line 460 "regression-compile-tmp/gens400.imp"
UREF = R;
                                                                //    461        %ELSE %IF FLAG = COND;     ! CONDITIONAL
#line 461 "regression-compile-tmp/gens400.imp"
goto L_0045;
#line 461 "regression-compile-tmp/gens400.imp"
L_0044:;
#line 461 "regression-compile-tmp/gens400.imp"
if (((FLAG) != (4194304))) goto L_0046;
                                                                //    462           CCA = CA+4;  CTAG = TAG;  CREF == R
#line 462 "regression-compile-tmp/gens400.imp"
CCA = (((int)(CA)) + (4));
#line 462 "regression-compile-tmp/gens400.imp"
CTAG = TAG;
#line 462 "regression-compile-tmp/gens400.imp"
CREF = R;
                                                                //    463        %FINISH
#line 463 "regression-compile-tmp/gens400.imp"
L_0046:;
#line 463 "regression-compile-tmp/gens400.imp"
L_0045:;
                                                                //    464        %IF FLAG&PERM # 0 %START
#line 464 "regression-compile-tmp/gens400.imp"
if (((((FLAG) & (2097152))) == (0))) goto L_0047;
                                                                //    465           %IF TAG > MAX PERM %OR PERMS(TAG) = 0 %START
#line 465 "regression-compile-tmp/gens400.imp"
if (((TAG) > (54))) goto L_0048;
#line 465 "regression-compile-tmp/gens400.imp"
if ((((PERMS-1)[TAG]) != (0))) goto L_0049;
#line 465 "regression-compile-tmp/gens400.imp"
L_0048:;
                                                                //    466              SELECTOUTPUT(REPORT)
#line 466 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(0);
                                                                //    467              PRINTSTRING("NO PERM");  WRITE(TAG, 1);  NEWLINE
#line 467 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("NO PERM"));
#line 467 "regression-compile-tmp/gens400.imp"
_imp_WRITE(TAG, 1);
#line 467 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    468              SELECTOUTPUT(OBJECT)
#line 468 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(2);
                                                                //    469           %ELSE
#line 469 "regression-compile-tmp/gens400.imp"
goto L_004a;
#line 469 "regression-compile-tmp/gens400.imp"
L_0049:;
                                                                //    470              PEP(TAG) = 1
#line 470 "regression-compile-tmp/gens400.imp"
PEP[(((int)(TAG)) - (1))] = 1;
                                                                //    471           %FINISH
#line 471 "regression-compile-tmp/gens400.imp"
L_004a:;
                                                                //    472        %FINISH
#line 472 "regression-compile-tmp/gens400.imp"
L_0047:;
                                                                //    473        %CONTINUE
#line 473 "regression-compile-tmp/gens400.imp"
goto L_003e;
                                                                //    474  D(6):! GPATCH <WHAT>, <WHERE>
#line 474 "regression-compile-tmp/gens400.imp"
sw1_D_6:;
                                                                //    475        GP = GP-1;  PAT == PATCH(GP);  ->PWW
#line 475 "regression-compile-tmp/gens400.imp"
GP = (((int)(GP)) - (1));
#line 475 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(GP)) - (1))];
#line 475 "regression-compile-tmp/gens400.imp"
goto U_1001;
                                                                //    476  D(7):! CPATCH <WHAT>, <WHERE>
#line 476 "regression-compile-tmp/gens400.imp"
sw1_D_7:;
                                                                //    477        CP = CP+1;  PAT == PATCH(CP)
#line 477 "regression-compile-tmp/gens400.imp"
CP = (((int)(CP)) + (1));
#line 477 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(CP)) - (1))];
                                                                //    478  PWW:  GET(TAG);  GET(CA)
#line 478 "regression-compile-tmp/gens400.imp"
U_1001:;
#line 478 "regression-compile-tmp/gens400.imp"
GET(&TAG);
#line 478 "regression-compile-tmp/gens400.imp"
GET(&CA);
                                                                //    479        PAT_WHAT = TAG;  PAT_WHERE = CA
#line 479 "regression-compile-tmp/gens400.imp"
PAT->WHAT = TAG;
#line 479 "regression-compile-tmp/gens400.imp"
PAT->WHERE = CA;
                                                                //    480        MONITOR(4) %IF CP = GP
#line 480 "regression-compile-tmp/gens400.imp"
if (((CP) != (GP))) goto L_004b;
#line 480 "regression-compile-tmp/gens400.imp"
MONITOR(4);
#line 480 "regression-compile-tmp/gens400.imp"
L_004b:;
                                                                //    481     %REPEAT
#line 481 "regression-compile-tmp/gens400.imp"
L_003e:;
#line 481 "regression-compile-tmp/gens400.imp"
goto L_003c;
                                                                //    482  D(8):! END MARKER
#line 482 "regression-compile-tmp/gens400.imp"
sw1_D_8:;
                                                                //    483     GET(CODE SIZE);  GET(GLA SIZE);  GET(LINE SIZE);  GET(DIAG SIZE)
#line 483 "regression-compile-tmp/gens400.imp"
GET(&CODESIZE);
#line 483 "regression-compile-tmp/gens400.imp"
GET(&GLASIZE);
#line 483 "regression-compile-tmp/gens400.imp"
GET(&LINESIZE);
#line 483 "regression-compile-tmp/gens400.imp"
GET(&DIAGSIZE);
                                                                //    484     CODE SIZE = CODE SIZE-DEF MOD
#line 484 "regression-compile-tmp/gens400.imp"
CODESIZE = (((int)(CODESIZE)) - (DEFMOD));
                                                                //    485     REFS = REFS+1;  JUMP(REFS) = 0
#line 485 "regression-compile-tmp/gens400.imp"
REFS = (((int)(REFS)) + (1));
#line 485 "regression-compile-tmp/gens400.imp"
JUMP[(((int)(REFS)) - (1))] = (LFM){ 0 } /* Assign 0's to all fields of record */;
                                                                //    486     %IF DEF MOD # 0 %START
#line 486 "regression-compile-tmp/gens400.imp"
if (((DEFMOD) == (0))) goto L_003d;
                                                                //    487        REF EXTRA = 0
#line 487 "regression-compile-tmp/gens400.imp"
REFEXTRA = 0;
                                                                //    488        %CYCLE L = 1, 1, REFS-1
#line 488 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = (((int)(REFS)) - (1)); L = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle L = 1, 1, (((int)(REFS)) - (1))");
L -= _increment; _control -= _increment;
L_004c:;
if (L == _final) goto L_004d;
L += _increment; _control += _increment;
if (L != _control) _imp_signal(4,2,0,"Corrupt control variable L"); /* FOR loop control variable corrupted */
}
                                                                //    489           R == JUMP (L)
#line 489 "regression-compile-tmp/gens400.imp"
R = &JUMP[(((int)(L)) - (1))];
                                                                //    490           R_CA = R_CA-REF EXTRA
#line 490 "regression-compile-tmp/gens400.imp"
R->CA = (((int)(R->CA)) - (REFEXTRA));
                                                                //    491           %IF R_LAB&COND # 0 %AND R_LAB&RT # 0 %START
#line 491 "regression-compile-tmp/gens400.imp"
if (((((R->LAB) & (4194304))) == (0))) goto L_004f;
#line 491 "regression-compile-tmp/gens400.imp"
if (((((R->LAB) & (1048576))) == (0))) goto L_004f;
                                                                //    492              REF EXTRA = REF EXTRA+2
#line 492 "regression-compile-tmp/gens400.imp"
REFEXTRA = (((int)(REFEXTRA)) + (2));
                                                                //    493              %CYCLE K = 1, 1, CP
#line 493 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = CP; K = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle K = 1, 1, CP");
K -= _increment; _control -= _increment;
L_0050:;
if (K == _final) goto L_0051;
K += _increment; _control += _increment;
if (K != _control) _imp_signal(4,2,0,"Corrupt control variable K"); /* FOR loop control variable corrupted */
}
                                                                //    494                 PAT == PATCH(K)
#line 494 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(K)) - (1))];
                                                                //    495                 PAT_WHERE = PAT_WHERE-2 %IF PAT_WHERE > R_CA
#line 495 "regression-compile-tmp/gens400.imp"
if (((PAT->WHERE) <= (R->CA))) goto L_0053;
#line 495 "regression-compile-tmp/gens400.imp"
PAT->WHERE = (((int)(PAT->WHERE)) - (2));
#line 495 "regression-compile-tmp/gens400.imp"
L_0053:;
                                                                //    496              %REPEAT
#line 496 "regression-compile-tmp/gens400.imp"
goto L_0050;
#line 496 "regression-compile-tmp/gens400.imp"
L_0051:;
                                                                //    497              %IF GP <= MAX PATCH %START
#line 497 "regression-compile-tmp/gens400.imp"
if (((GP) > (450))) goto L_0054;
                                                                //    498                 %CYCLE K = GP, 1, MAX PATCH
#line 498 "regression-compile-tmp/gens400.imp"
K = (((int)(GP)) - (1));
if ((((450)-(GP)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle K = GP, 1, 450");
L_0055:;
if (K == 450) goto L_0056;
K += 1;
                                                                //    499                    PAT == PATCH(K)
#line 499 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(K)) - (1))];
                                                                //    500                    PAT_WHAT = PAT_WHAT-2 %IF PAT_WHAT > R_CA
#line 500 "regression-compile-tmp/gens400.imp"
if (((PAT->WHAT) <= (R->CA))) goto L_0058;
#line 500 "regression-compile-tmp/gens400.imp"
PAT->WHAT = (((int)(PAT->WHAT)) - (2));
#line 500 "regression-compile-tmp/gens400.imp"
L_0058:;
                                                                //    501                    PAT_WHERE = PAT_WHERE-2 %IF PAT_WHERE&1 # 0 %AND  %C
#line 501 "regression-compile-tmp/gens400.imp"
if (((((PAT->WHERE) & (1))) == (0))) goto L_0059;
#line 501 "regression-compile-tmp/gens400.imp"
if (((PAT->WHERE) <= (R->CA))) goto L_0059;
#line 501 "regression-compile-tmp/gens400.imp"
PAT->WHERE = (((int)(PAT->WHERE)) - (2));
#line 501 "regression-compile-tmp/gens400.imp"
L_0059:;
                                                                //    502                                             PAT_WHERE > R_CA
                                                                //    503                 %REPEAT
#line 503 "regression-compile-tmp/gens400.imp"
goto L_0055;
#line 503 "regression-compile-tmp/gens400.imp"
L_0056:;
                                                                //    504              %FINISH
#line 504 "regression-compile-tmp/gens400.imp"
L_0054:;
                                                                //    505              %CYCLE K = 1, 1, MAX LABEL
#line 505 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = MAXLABEL; K = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle K = 1, 1, MAXLABEL");
K -= _increment; _control -= _increment;
L_005a:;
if (K == _final) goto L_005b;
K += _increment; _control += _increment;
if (K != _control) _imp_signal(4,2,0,"Corrupt control variable K"); /* FOR loop control variable corrupted */
}
                                                                //    506                 LAB(K) = LAB(K)-2 %IF LAB(K) > R_CA
#line 506 "regression-compile-tmp/gens400.imp"
if (((LAB[K]) <= (R->CA))) goto L_005d;
#line 506 "regression-compile-tmp/gens400.imp"
LAB[K] = (((int)(LAB[K])) - (2));
#line 506 "regression-compile-tmp/gens400.imp"
L_005d:;
                                                                //    507              %REPEAT
#line 507 "regression-compile-tmp/gens400.imp"
goto L_005a;
#line 507 "regression-compile-tmp/gens400.imp"
L_005b:;
                                                                //    508              DEFMOD = DEFMOD-2
#line 508 "regression-compile-tmp/gens400.imp"
DEFMOD = (((int)(DEFMOD)) - (2));
                                                                //    509           %FINISH
#line 509 "regression-compile-tmp/gens400.imp"
L_004f:;
                                                                //    510        %REPEAT
#line 510 "regression-compile-tmp/gens400.imp"
goto L_004c;
#line 510 "regression-compile-tmp/gens400.imp"
L_004d:;
                                                                //    511        MONITOR(5) %IF DEFMOD # 0
#line 511 "regression-compile-tmp/gens400.imp"
if (((DEFMOD) == (0))) goto L_005e;
#line 511 "regression-compile-tmp/gens400.imp"
MONITOR(5);
#line 511 "regression-compile-tmp/gens400.imp"
L_005e:;
                                                                //    512     %FINISH
#line 512 "regression-compile-tmp/gens400.imp"
L_003d:;
                                                                //    513  
                                                                //    514  
                                                                //    515  ! IDENTIFY THOSE PERM ROUTINES WHICH ARE REQUIRED.
                                                                //    516     PERM SIZE = 0
#line 516 "regression-compile-tmp/gens400.imp"
PERMSIZE = 0;
                                                                //    517     SET PERM(J) %FOR J = 1,1,MAX PERM
#line 517 "regression-compile-tmp/gens400.imp"
J = 0;
if ((((54)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle J = 1, 1, 54");
L_005f:;
if (J == 54) goto L_0060;
J += 1;
#line 517 "regression-compile-tmp/gens400.imp"
SETPERM(J);
#line 517 "regression-compile-tmp/gens400.imp"
goto L_005f;
#line 517 "regression-compile-tmp/gens400.imp"
L_0060:;
                                                                //    518     %CYCLE  J = 1,1,MAX PERM
#line 518 "regression-compile-tmp/gens400.imp"
J = 0;
if ((((54)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle J = 1, 1, 54");
L_0062:;
if (J == 54) goto L_0063;
J += 1;
                                                                //    519        %IF PEP(J) # 0 %START
#line 519 "regression-compile-tmp/gens400.imp"
if (((PEP[(((int)(J)) - (1))]) == (0))) goto L_0065;
                                                                //    520           PADDR(J) = CODE SIZE
#line 520 "regression-compile-tmp/gens400.imp"
PADDR[(((int)(J)) - (1))] = CODESIZE;
                                                                //    521           L = PERMS(PERMS(J))*2
#line 521 "regression-compile-tmp/gens400.imp"
L = (((int)((PERMS-1)[(PERMS-1)[J]])) * (2));
                                                                //    522           CODE SIZE = CODE SIZE + L
#line 522 "regression-compile-tmp/gens400.imp"
CODESIZE = (((int)(CODESIZE)) + (L));
                                                                //    523           PERM SIZE = PERM SIZE + L
#line 523 "regression-compile-tmp/gens400.imp"
PERMSIZE = (((int)(PERMSIZE)) + (L));
                                                                //    524        %FINISH
#line 524 "regression-compile-tmp/gens400.imp"
L_0065:;
                                                                //    525     %REPEAT
#line 525 "regression-compile-tmp/gens400.imp"
goto L_0062;
#line 525 "regression-compile-tmp/gens400.imp"
L_0063:;
                                                                //    526  
                                                                //    527  
                                                                //    528  ! PHASE 2 - IDENTIFY LONG JUMPS
                                                                //    529  !
                                                                //    530     PHASE = 2
#line 530 "regression-compile-tmp/gens400.imp"
PHASE = 2;
                                                                //    531     %IF REFS > 1 %START
#line 531 "regression-compile-tmp/gens400.imp"
if (((REFS) <= (1))) goto L_0066;
                                                                //    532     %CYCLE
#line 532 "regression-compile-tmp/gens400.imp"
L_0067:;
                                                                //    533        FLAG = 0;  REF EXTRA = 0
#line 533 "regression-compile-tmp/gens400.imp"
FLAG = 0;
#line 533 "regression-compile-tmp/gens400.imp"
REFEXTRA = 0;
                                                                //    534        %CYCLE L = 1, 1, REFS-1
#line 534 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = (((int)(REFS)) - (1)); L = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle L = 1, 1, (((int)(REFS)) - (1))");
L -= _increment; _control -= _increment;
L_006a:;
if (L == _final) goto L_006b;
L += _increment; _control += _increment;
if (L != _control) _imp_signal(4,2,0,"Corrupt control variable L"); /* FOR loop control variable corrupted */
}
                                                                //    535           R == JUMP(L);! JUMP REFERENCE
#line 535 "regression-compile-tmp/gens400.imp"
R = &JUMP[(((int)(L)) - (1))];
                                                                //    536           R_CA = R_CA+REF EXTRA
#line 536 "regression-compile-tmp/gens400.imp"
R->CA = (((int)(R->CA)) + (REFEXTRA));
                                                                //    537           %CONTINUE %IF R_LAB&VERY # 0;! ALREADY VERY LONG
#line 537 "regression-compile-tmp/gens400.imp"
if (((((R->LAB) & (524288))) == (0))) goto L_006d;
#line 537 "regression-compile-tmp/gens400.imp"
goto L_006c;
#line 537 "regression-compile-tmp/gens400.imp"
L_006d:;
                                                                //    538           EXTRA = 0
#line 538 "regression-compile-tmp/gens400.imp"
EXTRA = 0;
                                                                //    539           J = R_LAB&LABEL
#line 539 "regression-compile-tmp/gens400.imp"
J = ((R->LAB) & (65535));
                                                                //    540           %IF R_LAB&PERM = 0 %OR R_LAB&COND # 0 %C
#line 540 "regression-compile-tmp/gens400.imp"
if (((((R->LAB) & (2097152))) == (0))) goto L_005c;
#line 540 "regression-compile-tmp/gens400.imp"
if (((((R->LAB) & (4194304))) == (0))) goto L_006e;
#line 540 "regression-compile-tmp/gens400.imp"
L_005c:;
#line 540 "regression-compile-tmp/gens400.imp"
K = LAB[J];
#line 540 "regression-compile-tmp/gens400.imp"
goto L_006f;
#line 540 "regression-compile-tmp/gens400.imp"
L_006e:;
#line 540 "regression-compile-tmp/gens400.imp"
K = PADDR[(((int)(J)) - (1))];
#line 540 "regression-compile-tmp/gens400.imp"
L_006f:;
                                                                //    541                  %THEN K = LAB(J) %ELSE K = PADDR(J)
                                                                //    542           %UNLESS -30 <= K-R_CA <= 30 %START;  ! ...CAN'T BE SHORT
#line 542 "regression-compile-tmp/gens400.imp"
if (((((-30)) > ((((int)(K)) - (R->CA))))) || ((((((int)(K)) - (R->CA))) <= (30)))) goto L_0071;
#line 542 "regression-compile-tmp/gens400.imp"
L_0070:;
                                                                //    543              %IF R_LAB&LONG=0 %START;          ! ...BUT IT IS...
#line 543 "regression-compile-tmp/gens400.imp"
if (((((R->LAB) & (8388608))) != (0))) goto L_0072;
                                                                //    544                 %IF K < 16*1024 %OR -16*1024<=K-(R_CA+4)<16*1024 %START
#line 544 "regression-compile-tmp/gens400.imp"
if (((K) < ((((int)(16)) * (1024))))) goto L_0073;
#line 544 "regression-compile-tmp/gens400.imp"
if (((((-((((int)(16)) * (1024))))) > (((K) - ((int)((((int)(R->CA)) + (4)))))))) || (((((K) - ((int)((((int)(R->CA)) + (4)))))) >= ((((int)(16)) * (1024)))))) goto L_0074;
#line 544 "regression-compile-tmp/gens400.imp"
L_0073:;
                                                                //    545                 ! 32 BIT FORM:  BASE+DISPLACEMENT  OR  PC RELATIVE
                                                                //    546                    EXTRA = 2;  R_LAB = R_LAB!LONG;  ! SHORT -> LONG
#line 546 "regression-compile-tmp/gens400.imp"
EXTRA = 2;
#line 546 "regression-compile-tmp/gens400.imp"
R->LAB = ((R->LAB) | (8388608));
                                                                //    547                 %ELSE
#line 547 "regression-compile-tmp/gens400.imp"
goto L_0075;
#line 547 "regression-compile-tmp/gens400.imp"
L_0074:;
                                                                //    548                 ! 48 BIT FORM REQ'D:  BASE+DISP
                                                                //    549                    EXTRA = 4;  R_LAB = R_LAB!VERY;  ! SHORT -> VERY
#line 549 "regression-compile-tmp/gens400.imp"
EXTRA = 4;
#line 549 "regression-compile-tmp/gens400.imp"
R->LAB = ((R->LAB) | (524288));
                                                                //    550                 %FINISH
#line 550 "regression-compile-tmp/gens400.imp"
L_0075:;
                                                                //    551              %ELSE
#line 551 "regression-compile-tmp/gens400.imp"
goto L_0076;
#line 551 "regression-compile-tmp/gens400.imp"
L_0072:;
                                                                //    552                 %UNLESS K<16*1024 %OR -16*1024<=K-(R_CA+4)<16*1024 %START
#line 552 "regression-compile-tmp/gens400.imp"
if (((K) < ((((int)(16)) * (1024))))) goto L_0077;
#line 552 "regression-compile-tmp/gens400.imp"
if (((((-((((int)(16)) * (1024))))) > (((K) - ((int)((((int)(R->CA)) + (4)))))))) || (((((K) - ((int)((((int)(R->CA)) + (4)))))) < ((((int)(16)) * (1024)))))) goto L_0077;
#line 552 "regression-compile-tmp/gens400.imp"
L_0078:;
                                                                //    553                    EXTRA = 2;  R_LAB = R_LAB!!(LONG!VERY); ! LONG -> VERY
#line 553 "regression-compile-tmp/gens400.imp"
EXTRA = 2;
#line 553 "regression-compile-tmp/gens400.imp"
R->LAB = ((R->LAB) ^ (((8388608) | (524288))));
                                                                //    554                 %FINISH
#line 554 "regression-compile-tmp/gens400.imp"
L_0077:;
                                                                //    555              %FINISH
#line 555 "regression-compile-tmp/gens400.imp"
L_0076:;
                                                                //    556              %CONTINUE %IF EXTRA = 0;  ! ...NO CHANGES REQ'D
#line 556 "regression-compile-tmp/gens400.imp"
if (((EXTRA) != (0))) goto L_0079;
#line 556 "regression-compile-tmp/gens400.imp"
goto L_006c;
#line 556 "regression-compile-tmp/gens400.imp"
L_0079:;
                                                                //    557              FLAG = 1
#line 557 "regression-compile-tmp/gens400.imp"
FLAG = 1;
                                                                //    558              ! ADJUST PATCHES
                                                                //    559              %IF CP > 0 %START
#line 559 "regression-compile-tmp/gens400.imp"
if (((CP) <= (0))) goto L_007a;
                                                                //    560                 %CYCLE K = 1, 1, CP
#line 560 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = CP; K = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle K = 1, 1, CP");
K -= _increment; _control -= _increment;
L_007b:;
if (K == _final) goto L_007c;
K += _increment; _control += _increment;
if (K != _control) _imp_signal(4,2,0,"Corrupt control variable K"); /* FOR loop control variable corrupted */
}
                                                                //    561                    PAT == PATCH(K)
#line 561 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(K)) - (1))];
                                                                //    562                    PAT_WHERE = PAT_WHERE+EXTRA %IF PAT_WHERE > R_CA
#line 562 "regression-compile-tmp/gens400.imp"
if (((PAT->WHERE) <= (R->CA))) goto L_007e;
#line 562 "regression-compile-tmp/gens400.imp"
PAT->WHERE = (((int)(PAT->WHERE)) + (EXTRA));
#line 562 "regression-compile-tmp/gens400.imp"
L_007e:;
                                                                //    563                 %REPEAT
#line 563 "regression-compile-tmp/gens400.imp"
goto L_007b;
#line 563 "regression-compile-tmp/gens400.imp"
L_007c:;
                                                                //    564              %FINISH
#line 564 "regression-compile-tmp/gens400.imp"
L_007a:;
                                                                //    565              %IF GP <= MAX PATCH %START
#line 565 "regression-compile-tmp/gens400.imp"
if (((GP) > (450))) goto L_007f;
                                                                //    566                 %CYCLE K = GP, 1, MAX PATCH
#line 566 "regression-compile-tmp/gens400.imp"
K = (((int)(GP)) - (1));
if ((((450)-(GP)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle K = GP, 1, 450");
L_0080:;
if (K == 450) goto L_0081;
K += 1;
                                                                //    567                    PAT == PATCH(K)
#line 567 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(K)) - (1))];
                                                                //    568                    PAT_WHAT = PAT_WHAT+EXTRA %IF PAT_WHAT > R_CA
#line 568 "regression-compile-tmp/gens400.imp"
if (((PAT->WHAT) <= (R->CA))) goto L_0083;
#line 568 "regression-compile-tmp/gens400.imp"
PAT->WHAT = (((int)(PAT->WHAT)) + (EXTRA));
#line 568 "regression-compile-tmp/gens400.imp"
L_0083:;
                                                                //    569                 %REPEAT
#line 569 "regression-compile-tmp/gens400.imp"
goto L_0080;
#line 569 "regression-compile-tmp/gens400.imp"
L_0081:;
                                                                //    570              %FINISH
#line 570 "regression-compile-tmp/gens400.imp"
L_007f:;
                                                                //    571              ! ADJUST REMAINING REFS
                                                                //    572              %CYCLE K = 1, 1, MAX LABEL
#line 572 "regression-compile-tmp/gens400.imp"
{static int _initial, _increment, _final, _control;
_initial = 1; _increment = 1; _final = MAXLABEL; K = _control = _initial;
if (((_final-_initial) % _increment) != 0) _imp_signal(5,1,0,"Illegal cycle K = 1, 1, MAXLABEL");
K -= _increment; _control -= _increment;
L_0084:;
if (K == _final) goto L_0085;
K += _increment; _control += _increment;
if (K != _control) _imp_signal(4,2,0,"Corrupt control variable K"); /* FOR loop control variable corrupted */
}
                                                                //    573                 V == LAB(K)
#line 573 "regression-compile-tmp/gens400.imp"
V = &LAB[K];
                                                                //    574                 V = V+EXTRA %IF V > R_CA
#line 574 "regression-compile-tmp/gens400.imp"
if (((*V) <= (R->CA))) goto L_0087;
#line 574 "regression-compile-tmp/gens400.imp"
*V = ((*(int *)(V)) + (EXTRA));
#line 574 "regression-compile-tmp/gens400.imp"
L_0087:;
                                                                //    575              %REPEAT
#line 575 "regression-compile-tmp/gens400.imp"
goto L_0084;
#line 575 "regression-compile-tmp/gens400.imp"
L_0085:;
                                                                //    576              %CYCLE K = 1, 1, MAX PERM
#line 576 "regression-compile-tmp/gens400.imp"
K = 0;
if ((((54)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle K = 1, 1, 54");
L_0088:;
if (K == 54) goto L_0089;
K += 1;
                                                                //    577                 PADDR(K) = PADDR(K)+EXTRA %IF PADDR(K) # 0
#line 577 "regression-compile-tmp/gens400.imp"
if (((PADDR[(((int)(K)) - (1))]) == (0))) goto L_008b;
#line 577 "regression-compile-tmp/gens400.imp"
PADDR[(((int)(K)) - (1))] = (((int)(PADDR[(((int)(K)) - (1))])) + (EXTRA));
#line 577 "regression-compile-tmp/gens400.imp"
L_008b:;
                                                                //    578              %REPEAT
#line 578 "regression-compile-tmp/gens400.imp"
goto L_0088;
#line 578 "regression-compile-tmp/gens400.imp"
L_0089:;
                                                                //    579              REF EXTRA = REF EXTRA+EXTRA
#line 579 "regression-compile-tmp/gens400.imp"
REFEXTRA = (((int)(REFEXTRA)) + (EXTRA));
                                                                //    580              CODE SIZE = CODE SIZE+EXTRA
#line 580 "regression-compile-tmp/gens400.imp"
CODESIZE = (((int)(CODESIZE)) + (EXTRA));
                                                                //    581           %FINISH
#line 581 "regression-compile-tmp/gens400.imp"
L_0071:;
                                                                //    582        %REPEAT
#line 582 "regression-compile-tmp/gens400.imp"
L_006c:;
#line 582 "regression-compile-tmp/gens400.imp"
goto L_006a;
#line 582 "regression-compile-tmp/gens400.imp"
L_006b:;
                                                                //    583     %REPEAT %until flag = 0
#line 583 "regression-compile-tmp/gens400.imp"
if (((FLAG) == (0))) goto L_0068;
#line 583 "regression-compile-tmp/gens400.imp"
goto L_0067;
#line 583 "regression-compile-tmp/gens400.imp"
L_0068:;
                                                                //    584     %FINISH
#line 584 "regression-compile-tmp/gens400.imp"
L_0066:;
                                                                //    585  !
                                                                //    586  ! PHASE 3 - GENERATE OBJECT FILE
                                                                //    587  !
                                                                //    588     PHASE = 3
#line 588 "regression-compile-tmp/gens400.imp"
PHASE = 3;
                                                                //    589     J = MAX PATCH+1;  K = J
#line 589 "regression-compile-tmp/gens400.imp"
J = 451;
#line 589 "regression-compile-tmp/gens400.imp"
K = J;
                                                                //    590     %WHILE J > GP %CYCLE
#line 590 "regression-compile-tmp/gens400.imp"
L_008c:;
#line 590 "regression-compile-tmp/gens400.imp"
if (((J) <= (GP))) goto L_008d;
                                                                //    591        J = J-1
#line 591 "regression-compile-tmp/gens400.imp"
J = (((int)(J)) - (1));
                                                                //    592        PAT == PATCH(J)
#line 592 "regression-compile-tmp/gens400.imp"
PAT = &PATCH[(((int)(J)) - (1))];
                                                                //    593        %IF PAT_WHERE&1 # 0 %START
#line 593 "regression-compile-tmp/gens400.imp"
if (((((PAT->WHERE) & (1))) == (0))) goto L_008f;
                                                                //    594           PAT_WHERE = PAT_WHERE&(\1)
#line 594 "regression-compile-tmp/gens400.imp"
PAT->WHERE = ((PAT->WHERE) & ((~(1))));
                                                                //    595           CP = CP+1;  PATCH(CP) = PAT
#line 595 "regression-compile-tmp/gens400.imp"
CP = (((int)(CP)) + (1));
#line 595 "regression-compile-tmp/gens400.imp"
PATCH[(((int)(CP)) - (1))] = *PAT;
                                                                //    596        %ELSE
#line 596 "regression-compile-tmp/gens400.imp"
goto L_0090;
#line 596 "regression-compile-tmp/gens400.imp"
L_008f:;
                                                                //    597           K = K-1;  PATCH(K) = PAT
#line 597 "regression-compile-tmp/gens400.imp"
K = (((int)(K)) - (1));
#line 597 "regression-compile-tmp/gens400.imp"
PATCH[(((int)(K)) - (1))] = *PAT;
                                                                //    598        %FINISH
#line 598 "regression-compile-tmp/gens400.imp"
L_0090:;
                                                                //    599     %REPEAT
#line 599 "regression-compile-tmp/gens400.imp"
goto L_008c;
#line 599 "regression-compile-tmp/gens400.imp"
L_008d:;
                                                                //    600     GP = K
#line 600 "regression-compile-tmp/gens400.imp"
GP = K;
                                                                //    601     SORT(1, CP)
#line 601 "regression-compile-tmp/gens400.imp"
SORT(1, CP);
                                                                //    602     SORT(GP, MAX PATCH)
#line 602 "regression-compile-tmp/gens400.imp"
SORT(GP, 450);
                                                                //    603  !
                                                                //    604  !
                                                                //    605     SELECT OUTPUT(OBJECT);  PUT HALF(X'8282')
#line 605 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(2);
#line 605 "regression-compile-tmp/gens400.imp"
PUTHALF(33410);
                                                                //    606  !
                                                                //    607  ! OUTPUT A CONTROL BLOCK GIVING CODE  AND GLA SEGMENT SIZES(IN
                                                                //    608  ! HALF-WORDS).  OTHER PARAMETERS MAY BE ADDED AS REQ'D.
                                                                //    609  !  USES 'GBUFF' AS WORKSPACE.
                                                                //    610     GBUFF(1) = (CODE SIZE + 1)>>1
#line 610 "regression-compile-tmp/gens400.imp"
GBUFF[0] = (((((((int)(CODESIZE)) + (1)))) >> (1)));
                                                                //    611     GBUFF(2) = (GLA SIZE + 1)>>1
#line 611 "regression-compile-tmp/gens400.imp"
GBUFF[1] = (((((((int)(GLASIZE)) + (1)))) >> (1)));
                                                                //    612     GBUFF(3) = (DIAG SIZE+16)>>1;    ! ... +16 FOR EXTRA WORD AS TERMINATOR
#line 612 "regression-compile-tmp/gens400.imp"
GBUFF[2] = (((((((int)(DIAGSIZE)) + (16)))) >> (1)));
                                                                //    613     GBUFF(4) = (LINE SIZE+16)>>1
#line 613 "regression-compile-tmp/gens400.imp"
GBUFF[3] = (((((((int)(LINESIZE)) + (16)))) >> (1)));
                                                                //    614  ! -------REQUIRES LOADER DATA SIZE-----------
                                                                //    615     PUT BLOCK((4<<4)!SEGMENT SIZE BLOCK,GBUFF)
#line 615 "regression-compile-tmp/gens400.imp"
PUTBLOCK(((((4) << (4))) | (15)), &GBUFF[-(1)]);
                                                                //    616  !
                                                                //    617     SELECT INPUT(PSEUDO OBJ)
#line 617 "regression-compile-tmp/gens400.imp"
_imp_SELECTINPUT(2);
                                                                //    618     CA = 0;  GA = INITGLA;  LA = 0;  DA = 0
#line 618 "regression-compile-tmp/gens400.imp"
CA = 0;
#line 618 "regression-compile-tmp/gens400.imp"
GA = INITGLA;
#line 618 "regression-compile-tmp/gens400.imp"
LA = 0;
#line 618 "regression-compile-tmp/gens400.imp"
DA = 0;
                                                                //    619     CURRENT LINE = 0;  CBP = 1;  CFLUSH
#line 619 "regression-compile-tmp/gens400.imp"
CURRENTLINE = 0;
#line 619 "regression-compile-tmp/gens400.imp"
CBP = 1;
#line 619 "regression-compile-tmp/gens400.imp"
CFLUSH();
                                                                //    620     GBP = INIT GLA>>1;  LBP = 0;  DBP = 0;  TBP = 0
#line 620 "regression-compile-tmp/gens400.imp"
GBP = (int)((((unsigned int)(INITGLA)) >> (1)));
#line 620 "regression-compile-tmp/gens400.imp"
LBP = 0;
#line 620 "regression-compile-tmp/gens400.imp"
DBP = 0;
#line 620 "regression-compile-tmp/gens400.imp"
TBP = 0;
                                                                //    621     NEXT CODE;  NEXT GLA
#line 621 "regression-compile-tmp/gens400.imp"
NEXTCODE();
#line 621 "regression-compile-tmp/gens400.imp"
NEXTGLA();
                                                                //    622  
                                                                //    623     READSYMBOL(CODE);! = 1
#line 623 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&CODE);
                                                                //    624     IGNORE = 0;  LAST = 0
#line 624 "regression-compile-tmp/gens400.imp"
IGNORE = 0;
#line 624 "regression-compile-tmp/gens400.imp"
LAST = 0;
                                                                //    625     %CYCLE
#line 625 "regression-compile-tmp/gens400.imp"
L_0091:;
                                                                //    626        READ SYMBOL(CODE);  -> C(CODE+IGNORE)
#line 626 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&CODE);
#line 626 "regression-compile-tmp/gens400.imp"
sw2_C_idx = (((int)(CODE)) + (IGNORE)); if ((2 <= sw2_C_idx) && (sw2_C_idx <= 11)) goto *(sw2_C-2)[sw2_C_idx];  /* Bounds=2:11 */ else {
   /*_imp_signal(8, 2, sw2_C_idx);*/
   fprintf(stderr, "%%SWITCH index C(%d) not in range 2:11 at %s:%d\n",
           sw2_C_idx, (_imp_current_file != 0 ? _imp_current_file : __FILE__),
           (_imp_current_line != 0 ? _imp_current_line : __LINE__));
           exit(1);
}
                                                                //    627  C(2):! CODE <VAL>
#line 627 "regression-compile-tmp/gens400.imp"
sw2_C_2:;
                                                                //    628        GET(L)
#line 628 "regression-compile-tmp/gens400.imp"
GET(&L);
                                                                //    629        %IF CA = CADDR %START
#line 629 "regression-compile-tmp/gens400.imp"
if (((CA) != (CADDR))) goto L_0094;
                                                                //    630           %IF MODE # 0 %START;! CODE PATCH
#line 630 "regression-compile-tmp/gens400.imp"
if (((MODE) == (0))) goto L_0095;
                                                                //    631              CPUT(CVAL)
#line 631 "regression-compile-tmp/gens400.imp"
CPUT(CVAL);
                                                                //    632           %ELSE;!  JUMP+PERM+RT
#line 632 "regression-compile-tmp/gens400.imp"
goto L_0096;
#line 632 "regression-compile-tmp/gens400.imp"
L_0095:;
                                                                //    633              TAG = LAB(B_LAB&LABEL)
#line 633 "regression-compile-tmp/gens400.imp"
TAG = LAB[((B->LAB) & (65535))];
                                                                //    634              %IF B_LAB&(PERM!RT) = 0 %OR B_LAB&COND # 0 %START;! JUMP
#line 634 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (((2097152) | (1048576))))) == (0))) goto L_0097;
#line 634 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (4194304))) == (0))) goto L_0098;
#line 634 "regression-compile-tmp/gens400.imp"
L_0097:;
                                                                //    635                 %IF B_LAB&(PERM!RT) # 0 %START
#line 635 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (((2097152) | (1048576))))) == (0))) goto L_0099;
                                                                //    636                    %IF B_LAB&RT # 0 %START
#line 636 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (1048576))) == (0))) goto L_009a;
                                                                //    637                       LAST = L %IF LAST = 0
#line 637 "regression-compile-tmp/gens400.imp"
if (((LAST) != (0))) goto L_009b;
#line 637 "regression-compile-tmp/gens400.imp"
LAST = L;
#line 637 "regression-compile-tmp/gens400.imp"
L_009b:;
                                                                //    638                       LAST = NOT(LAST&15)!X'8000'
#line 638 "regression-compile-tmp/gens400.imp"
LAST = ((NOT[((LAST) & (15))]) | (32768));
                                                                //    639                       NEXT CODE
#line 639 "regression-compile-tmp/gens400.imp"
NEXTCODE();
                                                                //    640                       %CONTINUE
#line 640 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    641                    %FINISH
#line 641 "regression-compile-tmp/gens400.imp"
L_009a:;
                                                                //    642                    L = LAST;  LAST = 0
#line 642 "regression-compile-tmp/gens400.imp"
L = LAST;
#line 642 "regression-compile-tmp/gens400.imp"
LAST = 0;
                                                                //    643                 %FINISH
#line 643 "regression-compile-tmp/gens400.imp"
L_0099:;
                                                                //    644                 L = L&15
#line 644 "regression-compile-tmp/gens400.imp"
L = ((L) & (15));
                                                                //    645                 %IF B_LAB&(LONG!VERY) = 0 %START;! LEAVE IT SHORT
#line 645 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (((8388608) | (524288))))) != (0))) goto L_009c;
                                                                //    646                    J = (TAG-CA)//2
#line 646 "regression-compile-tmp/gens400.imp"
J = (long)((long)(((((int)(TAG)) - (CA)))) / (long)((int)(2)));
                                                                //    647                    MONITOR(5) %UNLESS -15 <= J <= 15
#line 647 "regression-compile-tmp/gens400.imp"
if (((((-15)) > (J))) || (((J) <= (15)))) goto L_009d;
#line 647 "regression-compile-tmp/gens400.imp"
L_0082:;
#line 647 "regression-compile-tmp/gens400.imp"
MONITOR(5);
#line 647 "regression-compile-tmp/gens400.imp"
L_009d:;
                                                                //    648                    %IF J < 0 %THEN CPUT(SB(L)-J) %C
#line 648 "regression-compile-tmp/gens400.imp"
if (((J) >= (0))) goto L_009e;
#line 648 "regression-compile-tmp/gens400.imp"
CPUT((((int)(SB[L])) - (J)));
#line 648 "regression-compile-tmp/gens400.imp"
goto L_009f;
#line 648 "regression-compile-tmp/gens400.imp"
L_009e:;
#line 648 "regression-compile-tmp/gens400.imp"
CPUT((((int)(SF[L])) + (J)));
#line 648 "regression-compile-tmp/gens400.imp"
L_009f:;
                                                                //    649                              %ELSE CPUT(SF(L)+J)
                                                                //    650                    SJ = SJ+1
#line 650 "regression-compile-tmp/gens400.imp"
SJ = (((int)(SJ)) + (1));
                                                                //    651                 %ELSE;               ! MAKE IT LONG
#line 651 "regression-compile-tmp/gens400.imp"
goto L_00a0;
#line 651 "regression-compile-tmp/gens400.imp"
L_009c:;
                                                                //    652                    L = LJ(L);  PLANT LONG JUMP
#line 652 "regression-compile-tmp/gens400.imp"
L = LJ[L];
#line 652 "regression-compile-tmp/gens400.imp"
PLANTLONGJUMP();
                                                                //    653                 %FINISH
#line 653 "regression-compile-tmp/gens400.imp"
L_00a0:;
                                                                //    654              %ELSE;! PERM OR ROUTINE
#line 654 "regression-compile-tmp/gens400.imp"
goto L_00a1;
#line 654 "regression-compile-tmp/gens400.imp"
L_0098:;
                                                                //    655                 DIAG LINE
#line 655 "regression-compile-tmp/gens400.imp"
DIAGLINE();
                                                                //    656                 IGNORE = 5
#line 656 "regression-compile-tmp/gens400.imp"
IGNORE = 5;
                                                                //    657                 TAG = PADDR(B_LAB&LABEL) %IF B_LAB&PERM # 0
#line 657 "regression-compile-tmp/gens400.imp"
if (((((B->LAB) & (2097152))) == (0))) goto L_00a2;
#line 657 "regression-compile-tmp/gens400.imp"
TAG = PADDR[(((int)(((B->LAB) & (65535)))) - (1))];
#line 657 "regression-compile-tmp/gens400.imp"
L_00a2:;
                                                                //    658                 PLANT LONG JUMP
#line 658 "regression-compile-tmp/gens400.imp"
PLANTLONGJUMP();
                                                                //    659              %FINISH
#line 659 "regression-compile-tmp/gens400.imp"
L_00a1:;
                                                                //    660           %FINISH
#line 660 "regression-compile-tmp/gens400.imp"
L_0096:;
                                                                //    661           NEXT CODE
#line 661 "regression-compile-tmp/gens400.imp"
NEXTCODE();
                                                                //    662        %FINISH %ELSE CPUT(L)
#line 662 "regression-compile-tmp/gens400.imp"
goto L_00a3;
#line 662 "regression-compile-tmp/gens400.imp"
L_0094:;
#line 662 "regression-compile-tmp/gens400.imp"
CPUT(L);
#line 662 "regression-compile-tmp/gens400.imp"
L_00a3:;
                                                                //    663        %CONTINUE
#line 663 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    664  C(11):GET(J)
#line 664 "regression-compile-tmp/gens400.imp"
sw2_C_11:;
#line 664 "regression-compile-tmp/gens400.imp"
GET(&J);
                                                                //    665        %IF J = X'FFFF' %START
#line 665 "regression-compile-tmp/gens400.imp"
if (((J) != (65535))) goto L_00a4;
                                                                //    666           GET(J)
#line 666 "regression-compile-tmp/gens400.imp"
GET(&J);
                                                                //    667           TPUT(X'4000');  TPUT(CA)
#line 667 "regression-compile-tmp/gens400.imp"
TPUT(16384);
#line 667 "regression-compile-tmp/gens400.imp"
TPUT(CA);
                                                                //    668           %CONTINUE
#line 668 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    669        %FINISH
#line 669 "regression-compile-tmp/gens400.imp"
L_00a4:;
                                                                //    670        TPUT(J)
#line 670 "regression-compile-tmp/gens400.imp"
TPUT(J);
                                                                //    671        GET(K)
#line 671 "regression-compile-tmp/gens400.imp"
GET(&K);
                                                                //    672        K = CA %IF J&X'8000' # 0
#line 672 "regression-compile-tmp/gens400.imp"
if (((((J) & (32768))) == (0))) goto L_00a5;
#line 672 "regression-compile-tmp/gens400.imp"
K = CA;
#line 672 "regression-compile-tmp/gens400.imp"
L_00a5:;
                                                                //    673                 TPUT(K)
#line 673 "regression-compile-tmp/gens400.imp"
TPUT(K);
                                                                //    674        GET(K);  TPUT(K)
#line 674 "regression-compile-tmp/gens400.imp"
GET(&K);
#line 674 "regression-compile-tmp/gens400.imp"
TPUT(K);
                                                                //    675        GET(K);  TPUT(K)
#line 675 "regression-compile-tmp/gens400.imp"
GET(&K);
#line 675 "regression-compile-tmp/gens400.imp"
TPUT(K);
                                                                //    676        GET(K);  TPUT(K)
#line 676 "regression-compile-tmp/gens400.imp"
GET(&K);
#line 676 "regression-compile-tmp/gens400.imp"
TPUT(K);
                                                                //    677        GET(K);  TPUT(K)
#line 677 "regression-compile-tmp/gens400.imp"
GET(&K);
#line 677 "regression-compile-tmp/gens400.imp"
TPUT(K);
                                                                //    678        %CONTINUE
#line 678 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    679  C(10): DIAG LINE;  %CONTINUE
#line 679 "regression-compile-tmp/gens400.imp"
sw2_C_10:;
#line 679 "regression-compile-tmp/gens400.imp"
DIAGLINE();
#line 679 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    680  C(4):
#line 680 "regression-compile-tmp/gens400.imp"
sw2_C_4:;
                                                                //    681  C(9):CURRENT LINE = CURRENT LINE+1;  CFLUSH
#line 681 "regression-compile-tmp/gens400.imp"
sw2_C_9:;
#line 681 "regression-compile-tmp/gens400.imp"
CURRENTLINE = (((int)(CURRENTLINE)) + (1));
#line 681 "regression-compile-tmp/gens400.imp"
CFLUSH();
                                                                //    682       %CONTINUE;! LINE FLAG
#line 682 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    683  C(7):IGNORE = 0;  GET(L);  %CONTINUE
#line 683 "regression-compile-tmp/gens400.imp"
sw2_C_7:;
#line 683 "regression-compile-tmp/gens400.imp"
IGNORE = 0;
#line 683 "regression-compile-tmp/gens400.imp"
GET(&L);
#line 683 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    684  C(6):L = NL
#line 684 "regression-compile-tmp/gens400.imp"
sw2_C_6:;
#line 684 "regression-compile-tmp/gens400.imp"
L = 10;
                                                                //    685       J = 0
#line 685 "regression-compile-tmp/gens400.imp"
J = 0;
                                                                //    686       %CYCLE K = 1, 1, 9
#line 686 "regression-compile-tmp/gens400.imp"
K = 0;
if ((((9)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle K = 1, 1, 9");
L_00a6:;
if (K == 9) goto L_00a7;
K += 1;
                                                                //    687          %IF L # 0 %START
#line 687 "regression-compile-tmp/gens400.imp"
if (((L) == (0))) goto L_00a9;
                                                                //    688             READSYMBOL(L)
#line 688 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&L);
                                                                //    689             J = J+1;  LTEMP(J) = L
#line 689 "regression-compile-tmp/gens400.imp"
J = (((int)(J)) + (1));
#line 689 "regression-compile-tmp/gens400.imp"
LTEMP[J] = L;
                                                                //    690          %FINISH
#line 690 "regression-compile-tmp/gens400.imp"
L_00a9:;
                                                                //    691       %REPEAT
#line 691 "regression-compile-tmp/gens400.imp"
goto L_00a6;
#line 691 "regression-compile-tmp/gens400.imp"
L_00a7:;
                                                                //    692       READSYMBOL(L) %WHILE L # 0
#line 692 "regression-compile-tmp/gens400.imp"
L_00aa:;
#line 692 "regression-compile-tmp/gens400.imp"
if (((L) == (0))) goto L_00ab;
#line 692 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&L);
#line 692 "regression-compile-tmp/gens400.imp"
goto L_00aa;
#line 692 "regression-compile-tmp/gens400.imp"
L_00ab:;
                                                                //    693       J = J-1;  LTEMP(0) = J
#line 693 "regression-compile-tmp/gens400.imp"
J = (((int)(J)) - (1));
#line 693 "regression-compile-tmp/gens400.imp"
LTEMP[0] = J;
                                                                //    694       LSYM(LTEMP(J)) %FOR J = 0, 1, 8
#line 694 "regression-compile-tmp/gens400.imp"
J = (-1);
if ((((8)-(0)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle J = 0, 1, 8");
L_00ad:;
if (J == 8) goto L_00ae;
J += 1;
#line 694 "regression-compile-tmp/gens400.imp"
LSYM(LTEMP[J]);
#line 694 "regression-compile-tmp/gens400.imp"
goto L_00ad;
#line 694 "regression-compile-tmp/gens400.imp"
L_00ae:;
                                                                //    695       GET(K);  READSYMBOL(L)
#line 695 "regression-compile-tmp/gens400.imp"
GET(&K);
#line 695 "regression-compile-tmp/gens400.imp"
_imp_READSYMBOL(&L);
                                                                //    696       LSYM(L);  LPUT(K)
#line 696 "regression-compile-tmp/gens400.imp"
LSYM(L);
#line 696 "regression-compile-tmp/gens400.imp"
LPUT(K);
                                                                //    697       %CONTINUE
#line 697 "regression-compile-tmp/gens400.imp"
goto L_0093;
                                                                //    698  C(8):
#line 698 "regression-compile-tmp/gens400.imp"
sw2_C_8:;
                                                                //    699  C(3):! GLA <VAL>  -- SWITCH VECTOR ELEMENT
#line 699 "regression-compile-tmp/gens400.imp"
sw2_C_3:;
                                                                //    700        GET(L)
#line 700 "regression-compile-tmp/gens400.imp"
GET(&L);
                                                                //    701        %IF GA = GADDR %START
#line 701 "regression-compile-tmp/gens400.imp"
if (((GA) != (GADDR))) goto L_00b0;
                                                                //    702           L = GVAL
#line 702 "regression-compile-tmp/gens400.imp"
L = GVAL;
                                                                //    703           NEXT GLA
#line 703 "regression-compile-tmp/gens400.imp"
NEXTGLA();
                                                                //    704        %FINISH
#line 704 "regression-compile-tmp/gens400.imp"
L_00b0:;
                                                                //    705        GPUT(L)
#line 705 "regression-compile-tmp/gens400.imp"
GPUT(L);
                                                                //    706     %REPEAT
#line 706 "regression-compile-tmp/gens400.imp"
L_0093:;
#line 706 "regression-compile-tmp/gens400.imp"
goto L_0091;
                                                                //    707  C(5):! END
#line 707 "regression-compile-tmp/gens400.imp"
sw2_C_5:;
                                                                //    708     %CYCLE J = 1, 1, MAX PERM
#line 708 "regression-compile-tmp/gens400.imp"
J = 0;
if ((((54)-(1)) % (1)) != 0) _imp_signal(5,1,0,"Illegal cycle J = 1, 1, 54");
L_00b1:;
if (J == 54) goto L_00b2;
J += 1;
                                                                //    709        %IF PEP(J) # 0 %START
#line 709 "regression-compile-tmp/gens400.imp"
if (((PEP[(((int)(J)) - (1))]) == (0))) goto L_00b4;
                                                                //    710           K = PERMS(J);  MONITOR(6) %IF K = 0
#line 710 "regression-compile-tmp/gens400.imp"
K = (PERMS-1)[J];
#line 710 "regression-compile-tmp/gens400.imp"
if (((K) != (0))) goto L_00b5;
#line 710 "regression-compile-tmp/gens400.imp"
MONITOR(6);
#line 710 "regression-compile-tmp/gens400.imp"
L_00b5:;
                                                                //    711           L = PADDR(J)
#line 711 "regression-compile-tmp/gens400.imp"
L = PADDR[(((int)(J)) - (1))];
                                                                //    712           MONITOR(7) %IF CA # L
#line 712 "regression-compile-tmp/gens400.imp"
if (((CA) == (L))) goto L_00b6;
#line 712 "regression-compile-tmp/gens400.imp"
MONITOR(7);
#line 712 "regression-compile-tmp/gens400.imp"
L_00b6:;
                                                                //    713           CFLUSH %IF CBP+PERMS(K) > CODE BUFF SIZE
#line 713 "regression-compile-tmp/gens400.imp"
if ((((((int)(CBP)) + ((PERMS-1)[K]))) <= (200))) goto L_00b7;
#line 713 "regression-compile-tmp/gens400.imp"
CFLUSH();
#line 713 "regression-compile-tmp/gens400.imp"
L_00b7:;
                                                                //    714  {         %CYCLE L = K+1, 1, K+PERMS(K)      L is corrupted below!! }
                                                                //    715           l = k;  z = k + perms(k)
#line 715 "regression-compile-tmp/gens400.imp"
L = K;
#line 715 "regression-compile-tmp/gens400.imp"
Z = (((int)(K)) + ((PERMS-1)[K]));
                                                                //    716           %while l # z %cycle
#line 716 "regression-compile-tmp/gens400.imp"
L_00b8:;
#line 716 "regression-compile-tmp/gens400.imp"
if (((L) == (Z))) goto L_00b9;
                                                                //    717              l = l+1
#line 717 "regression-compile-tmp/gens400.imp"
L = (((int)(L)) + (1));
                                                                //    718              TAG = PERMS(L)
#line 718 "regression-compile-tmp/gens400.imp"
TAG = (PERMS-1)[L];
                                                                //    719              %IF TAG = EMARK %START
#line 719 "regression-compile-tmp/gens400.imp"
if (((TAG) != (34952))) goto L_00bb;
                                                                //    720              !  USE PC RELATIVE UNCONDITIONAL BRANCH FOR INTERNAL
                                                                //    721              !  LINKING BETWEEN PERM ROUTINES.
                                                                //    722                 CPUT(X'4300')
#line 722 "regression-compile-tmp/gens400.imp"
CPUT(17152);
                                                                //    723                 L = L+1;  CPUT((PADDR(PERMS(L))-CA-2)!X'8000')
#line 723 "regression-compile-tmp/gens400.imp"
L = (((int)(L)) + (1));
#line 723 "regression-compile-tmp/gens400.imp"
CPUT((((((int)((((int)(PADDR[(((int)((PERMS-1)[L])) - (1))])) - (CA)))) - (2))) | (32768)));
                                                                //    724              %ELSE
#line 724 "regression-compile-tmp/gens400.imp"
goto L_00bc;
#line 724 "regression-compile-tmp/gens400.imp"
L_00bb:;
                                                                //    725                 CPUT(TAG)
#line 725 "regression-compile-tmp/gens400.imp"
CPUT(TAG);
                                                                //    726              %FINISH
#line 726 "regression-compile-tmp/gens400.imp"
L_00bc:;
                                                                //    727           %REPEAT
#line 727 "regression-compile-tmp/gens400.imp"
goto L_00b8;
#line 727 "regression-compile-tmp/gens400.imp"
L_00b9:;
                                                                //    728        %FINISH
#line 728 "regression-compile-tmp/gens400.imp"
L_00b4:;
                                                                //    729     %REPEAT
#line 729 "regression-compile-tmp/gens400.imp"
goto L_00b1;
#line 729 "regression-compile-tmp/gens400.imp"
L_00b2:;
                                                                //    730  !
                                                                //    731     CLOSE OBJECT FILE
#line 731 "regression-compile-tmp/gens400.imp"
CLOSEOBJECTFILE();
                                                                //    732  !
                                                                //    733     MONITOR(9) %UNLESS CADDR = NEVER
#line 733 "regression-compile-tmp/gens400.imp"
if (((CADDR) == (32767))) goto L_00bd;
#line 733 "regression-compile-tmp/gens400.imp"
MONITOR(9);
#line 733 "regression-compile-tmp/gens400.imp"
L_00bd:;
                                                                //    734     MONITOR(10) %UNLESS GADDR = NEVER
#line 734 "regression-compile-tmp/gens400.imp"
if (((GADDR) == (32767))) goto L_00be;
#line 734 "regression-compile-tmp/gens400.imp"
MONITOR(10);
#line 734 "regression-compile-tmp/gens400.imp"
L_00be:;
                                                                //    735     SELECTOUTPUT(REPORT)
#line 735 "regression-compile-tmp/gens400.imp"
_imp_SELECTOUTPUT(0);
                                                                //    736     DA = DA+DIAG SIZE
#line 736 "regression-compile-tmp/gens400.imp"
DA = (((int)(DA)) + (DIAGSIZE));
                                                                //    737     PRINTSTRING("CODE");  WRITE(CODE SIZE-PERM SIZE, 1)
#line 737 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("CODE"));
#line 737 "regression-compile-tmp/gens400.imp"
_imp_WRITE((((int)(CODESIZE)) - (PERMSIZE)), 1);
                                                                //    738     PRINTSTRING(" + GLA");  WRITE(GLA SIZE, 1)
#line 738 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" + GLA"));
#line 738 "regression-compile-tmp/gens400.imp"
_imp_WRITE(GLASIZE, 1);
                                                                //    739     PRINTSTRING(" + PERM");  WRITE(PERM SIZE, 1)
#line 739 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" + PERM"));
#line 739 "regression-compile-tmp/gens400.imp"
_imp_WRITE(PERMSIZE, 1);
                                                                //    740     PRINTSTRING(" + DIAGS");  WRITE(DA, 1)
#line 740 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" + DIAGS"));
#line 740 "regression-compile-tmp/gens400.imp"
_imp_WRITE(DA, 1);
                                                                //    741     PRINTSTRING(" =")
#line 741 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" ="));
                                                                //    742     WRITE(CODE SIZE+GLA SIZE+DA, 1)
#line 742 "regression-compile-tmp/gens400.imp"
_imp_WRITE((((int)((((int)(CODESIZE)) + (GLASIZE)))) + (DA)), 1);
                                                                //    743     PRINTSTRING(" BYTES")
#line 743 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" BYTES"));
                                                                //    744     NEWLINE
#line 744 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    745  
                                                                //    746  
                                                                //    747  !%ENDOFPROGRAM;     !**REMOVE FOR EXTRA MONITORING**
                                                                //    748  
                                                                //    749  ! ------TEMPORARY EXTRA MONITORING-------
                                                                //    750     NEWLINE
#line 750 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    751     PRINT STRING("JUMPS:")
#line 751 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("JUMPS:"));
                                                                //    752     WRITE(SJ,1);  PRINT STRING(" SHORT,")
#line 752 "regression-compile-tmp/gens400.imp"
_imp_WRITE(SJ, 1);
#line 752 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" SHORT,"));
                                                                //    753     WRITE(RX1,1); PRINT STRING(" RX1,")
#line 753 "regression-compile-tmp/gens400.imp"
_imp_WRITE(RX1, 1);
#line 753 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" RX1,"));
                                                                //    754     WRITE(RX2,1); PRINT STRING(" RX2,")
#line 754 "regression-compile-tmp/gens400.imp"
_imp_WRITE(RX2, 1);
#line 754 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" RX2,"));
                                                                //    755     WRITE(RX3,1); PRINT STRING(" RX3")
#line 755 "regression-compile-tmp/gens400.imp"
_imp_WRITE(RX3, 1);
#line 755 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" RX3"));
                                                                //    756     NEWLINE
#line 756 "regression-compile-tmp/gens400.imp"
_imp_NEWLINE();
                                                                //    757     PRINT STRING("...INCLUDING")
#line 757 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal("...INCLUDING"));
                                                                //    758     WRITE(PERMCALLS,1); PRINT STRING(" PERMCALLS AND")
#line 758 "regression-compile-tmp/gens400.imp"
_imp_WRITE(PERMCALLS, 1);
#line 758 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" PERMCALLS AND"));
                                                                //    759     WRITE(RTNCALLS,1); PRINT STRING(" CALLS ON USER-DEFINED ROUTINES")
#line 759 "regression-compile-tmp/gens400.imp"
_imp_WRITE(RTNCALLS, 1);
#line 759 "regression-compile-tmp/gens400.imp"
_imp_PRINTSTRING(_imp_str_literal(" CALLS ON USER-DEFINED ROUTINES"));
                                                                //    760     NEWLINES(2)
#line 760 "regression-compile-tmp/gens400.imp"
_imp_NEWLINES(2);
                                                                //    761  %ENDOFPROGRAM
#line 761 "regression-compile-tmp/gens400.imp"
/* Remove %on %event handler here if present for this block */
return 0;
} // End of block _imp_main at level 1
#line 761 "regression-compile-tmp/gens400.imp"
// End of file
