/* Generated with C2C (Cedar To C)*/
/* Copyright (C) 1992 by Xerox Corporation. All rights reserved. */
/* time: February 21, 1992 11:34:29 pm PST */
/* C2C version: October 16, 1990 (native) */
/* ref-counting: off */
/* file: UnsafeTileImpl, module: UnsafeTileImpl */
/* switches: cfhklnouw */
#include <cedar/InstallationSupport.h>
#include <cedar/CedarExtra.h>
#define XRM←BITAND(x, y) (((word)(x)) & ((word)(y)))
#define XRM←BITXOR(x, y) (((word)(x)) ↑ ((word)(y)))
#define XRM←BITLSHIFT(x, y) ((word)(x) << (word)(y))
#define XRM←BITRSHIFT(x, y) ((word)(x) >> (word)(y))
#define XRM←BITNOT(x) (~((word)(x)))
#define XRM←BITOR(x, y) (((word)(x)) | ((word)(y)))
static char versionStamp[] = "@(#)mob←version [1309050070,1920915394] UnsafeTileImpl";
typedef unsigned word, *ptr;
typedef unsigned char byte, *bPt;
typedef unsigned short half, *hPt;
typedef struct {word f0, f1, f2, f3, f4, f5, f6, f7;} W8;
typedef struct {W8 f; W8 r;} W16;
typedef struct {word f0, f1;} W2;
typedef word (*fPt)();
#define SOURCE(p, l) /* source p, l */
#define IOP2(op, x, y) ( (word) ((x) op (y)) )
static void NoName←Q4620();
static void UnsafeTileImpl←P0();
static void Op←P60();
static void Fast1←P120();
static void Fast2←P180();
static void Fast3←P240();
static void DoLine←P300();
static void WithFunction←P1968();
static void DumbOp←P480();
static word FunnyOp←P540();
static void BadAssertion←P660();
static void InitReplicatorArray←P720();
static struct {unsigned f; char r[16];} string1 = {851984, "\257\300\116\006\204\326\300\162\176\327\302\100\164\000\000"};
static struct {unsigned f; char r[16];} string2 = {851984, "\257\300\047\273\127\037\300\356\271\016\020\100\150\000\000"};
static struct {
word f0[71]; word f71; word f72; word f73;
word f74; word f75; word f76; word f77;
word f78; word f79; word f80; word f81;
word f82; word f83; word f84; word f85;
word f86; word f87; word f88; word f89;
word f90[2];
} globalframe = {
{0}, (word) InitReplicatorArray←P720, 0, (word) BadAssertion←P660,
0, (word) FunnyOp←P540, 0, (word) DumbOp←P480,
0, (word) DoLine←P300, 0, (word) Fast3←P240,
0, (word) Fast2←P180, 0, (word) Fast1←P120,
0, (word) Op←P60, 0, (word) UnsafeTileImpl←P0,
{0}
};
static void NoName←Q4620()
{
register ptr gf←c0309 = (ptr) &globalframe;
word var←c17152;
(void) XR←DeclareGlobalFrame((word) "UnsafeTileImpl", &globalframe, (word) XR←GetTypeIndexS((word) (&string1)), (word) (( (bPt) gf←c0309)+356)
/* var←c14624 */ );
var←c17152 = (word) XR←ExportInterface((word) "UnsafeTile", (word) XR←GetTypeIndexS((word) (&string2)), 5);
(* (( (ptr) gf←c0309)+91)/* var←c17120 */ ) = var←c17152;
(void) XR←ExportProcS(var←c17152, (word) (( (bPt) gf←c0309)+348)/* var←c14592 */ , 262145);
(void) XR←ExportProcS(var←c17152, (word) (( (bPt) gf←c0309)+340)/* var←c14560 */ , 262401);
(void) XR←ExportProcS(var←c17152, (word) (( (bPt) gf←c0309)+332)/* var←c14528 */ , 262657);
(void) XR←ExportProcS(var←c17152, (word) (( (bPt) gf←c0309)+324)/* var←c14496 */ , 262913);
(void) XR←ExportProcS(var←c17152, (word) (( (bPt) gf←c0309)+308)/* var←c14432 */ , 263169);
}
static void UnsafeTileImpl←P0(formal←c017, formal←c016)
word formal←c017;
word formal←c016;
{
/* UnsafeTileImpl: */
SOURCE(31, 14375)
SOURCE(14385, 21)
(void) InitReplicatorArray←P720();
}
static void Op←P60(arg←v3528)
word arg←v3528;
{
word fSizeTile←v4792;
/* Op: */
SOURCE(513, 420)
SOURCE(561, 30)
fSizeTile←v4792 = (* (( (ptr) arg←v3528)+8) );
SOURCE(612, 48)
if (((* (( (ptr) arg←v3528)+10) ) >= fSizeTile←v4792)) {
SOURCE(646, 14)
(void) BadAssertion←P660();
};
SOURCE(662, 45)
if (((* (( (ptr) arg←v3528)+12) ) >= fSizeTile←v4792)) {
SOURCE(693, 14)
(void) BadAssertion←P660();
};
SOURCE(709, 53)
if (((* (( (ptr) arg←v3528)+11) ) >= (* (( (ptr) arg←v3528)+9) ))) {
SOURCE(748, 14)
(void) BadAssertion←P660();
};
SOURCE(767, 45)
if (((* (( (ptr) arg←v3528)+3) ) == 0) || ((* (( (ptr) arg←v3528)+4) ) == 0)) {
SOURCE(806, 6)
return;
};
SOURCE(814, 104)
if ((fSizeTile←v4792 <= 32)) {
SOURCE(841, 69)
if (((word) XRM←BITAND(fSizeTile←v4792, (fSizeTile←v4792 - 1)) == 0)) {
SOURCE(884, 16)
(void) Fast1←P120(arg←v3528);
}
else {
SOURCE(900, 10)
(void) Fast2←P180(arg←v3528);
};
SOURCE(912, 6)
return;
};
SOURCE(923, 10)
(void) Fast3←P240(arg←v3528);
}
static void Fast1←P120(arg←v3588)
word arg←v3588;
{
word tileLine←v4836;
word firstBit←v4864;
word srcBpl←v4892;
word srcBit←v4920;
word src←v4948;
word dst←v4976;
word dstBit←v5004;
word fSize←v5032;
word fSizeTile←v5060;
word sSizeTile←v5088;
word sSize←v5116;
word sw←v5144;
word invert←v5172;
/* Fast1: */
SOURCE(939, 3381)
SOURCE(990, 29)
tileLine←v4836 = (* (( (ptr) arg←v3588)+11) );
SOURCE(1021, 34)
firstBit←v4864 = (* (( (ptr) arg←v3588)+10) );
SOURCE(1057, 24)
srcBpl←v4892 = (* (( (ptr) arg←v3588)+7) );
SOURCE(1083, 30)
srcBit←v4920 = (* (( (ptr) arg←v3588)+6) );
SOURCE(1115, 26)
src←v4948 = (* (( (ptr) arg←v3588)+5) );
SOURCE(1143, 26)
dst←v4976 = (* (ptr) arg←v3588 );
SOURCE(1171, 30)
dstBit←v5004 = (* (( (ptr) arg←v3588)+1) );
SOURCE(1203, 22)
fSize←v5032 = (* (( (ptr) arg←v3588)+3) );
SOURCE(1227, 35)
fSizeTile←v5060 = (* (( (ptr) arg←v3588)+8) );
SOURCE(1264, 30)
sSizeTile←v5088 = (* (( (ptr) arg←v3588)+9) );
SOURCE(1296, 22)
sSize←v5116 = (* (( (ptr) arg←v3588)+4) );
SOURCE(1330, 28)
invert←v5172 = (* (( (ptr) arg←v3588)+13) );
SOURCE(3977, 70)
if (((word) XRM←BITAND(fSizeTile←v5060, (fSizeTile←v5060 - 1)) != 0)) {
SOURCE(4033, 14)
(void) BadAssertion←P660();
};
SOURCE(4049, 271)
if ((sSize←v5116 != 0)) {
SOURCE(4069, 116)
if ((tileLine←v4836 != 0)) {
SOURCE(4090, 97)
{
word next←v5524;
SOURCE(4092, 36)
next←v5524 = (srcBit←v4920 + (tileLine←v4836 * srcBpl←v4892));
SOURCE(4130, 21)
srcBit←v4920 = (next←v5524 & 037);
SOURCE(4153, 32)
src←v4948 = (src←v4948 + ((next←v5524 - srcBit←v4920) >> 3));
};
};
SOURCE(4190, 130)
{
word var←c14656;
var←c14656 = (* (( (ptr) arg←v3588)+14) );
switch (var←c14656) {
case 0:
SOURCE(4222, 18)
SOURCE(3865, 98)
lab←L100002: ;
SOURCE(3868, 13)
{
word k←v5568;
k←v5568 = fSizeTile←v5060;
SOURCE(1414, 25)
sw←v5144 = (word) XRM←BITXOR((* (ptr) src←v4948 ), invert←v5172);
SOURCE(1441, 131)
if ((srcBit←v4920 != 0)) {
SOURCE(1462, 26)
sw←v5144 = (word) XRM←BITLSHIFT(sw←v5144, srcBit←v4920);
SOURCE(1490, 82)
if (((srcBit←v4920 + k←v5568) > 32)) {
SOURCE(1513, 59)
{
word var←c14688;
word var←c0314;
var←c14688 = (word) XRM←BITXOR((* (ptr) (src←v4948 + 4) ), invert←v5172);
var←c0314 = (word) XRM←BITRSHIFT(var←c14688, (32 - srcBit←v4920));
sw←v5144 = (sw←v5144 + var←c0314);
};
};
};
SOURCE(1577, 122)
if ((k←v5568 < 32)) {
SOURCE(1595, 44)
{
word var←c14720;
var←c14720 = (word) XRM←BITLSHIFT( (word) -1, (32 - k←v5568));
sw←v5144 = (word) XRM←BITAND(sw←v5144, var←c14720);
};
SOURCE(1641, 58)
lab←L100005: ;
SOURCE(1644, 26)
sw←v5144 = (sw←v5144 + (word) XRM←BITRSHIFT(sw←v5144, k←v5568));
SOURCE(1672, 9)
k←v5568 = (k←v5568 + k←v5568);
SOURCE(1683, 16)
if ((k←v5568 == 32)) {
SOURCE(1699, 4)
goto lab←L100004;
};
goto lab←L100005;
lab←L100004: ;
};
SOURCE(1717, 79)
if ((firstBit←v4864 != 0)) {
SOURCE(1738, 58)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, firstBit←v4864) + (word) XRM←BITRSHIFT(sw←v5144, (32 - firstBit←v4864)));
};
};
SOURCE(3883, 15)
SOURCE(1842, 1563)
{
word rem←v5596;
word dwp←v5624;
rem←v5596 = fSize←v5032;
dwp←v5624 = dst←v4976;
SOURCE(1882, 596)
if ((dstBit←v5004 != 0)) {
{
word dw←v5652;
word mask←v5680;
word rw←v5708;
dw←v5652 = (* (ptr) dwp←v5624 );
mask←v5680 = (word) XRM←BITRSHIFT( (word) -1, dstBit←v5004);
rw←v5708 = (word) XRM←BITRSHIFT(sw←v5144, dstBit←v5004);
SOURCE(1997, 18)
rem←v5596 = (rem←v5596 + dstBit←v5004);
SOURCE(2017, 64)
if ((rem←v5596 < 32)) {
SOURCE(2035, 46)
{
/*1*/ word var←c14752;
/*1*/ var←c14752 = (word) XRM←BITRSHIFT( (word) -1, rem←v5596);
/*1*/ mask←v5680 = (word) XRM←BITXOR(mask←v5680, var←c14752);
/*1*/ };
};
SOURCE(2083, 284)
SOURCE(2106, 50)
{
word var←c14784;
{
/*1*/ word var←c14816;
/*1*/ word var←c0315;
/*1*/ var←c14816 = (word) XRM←BITNOT(mask←v5680);
/*1*/ var←c0315 = (word) XRM←BITAND(dw←v5652, var←c14816);
/*1*/ var←c14784 = (var←c0315 + (word) XRM←BITAND(rw←v5708, mask←v5680));
/*1*/ };
(* (ptr) dwp←v5624 ) = var←c14784;
};
SOURCE(2378, 19)
if ((rem←v5596 <= 32)) {
SOURCE(2397, 10)
goto lab←L100006;
};
SOURCE(2409, 35)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, (32 - dstBit←v5004)) + rw←v5708);
SOURCE(2446, 15)
rem←v5596 = (rem←v5596 - 32);
SOURCE(2463, 15)
dwp←v5624 = (dwp←v5624 + 4);
};
};
SOURCE(2483, 330)
lab←L100009: ;
if ((rem←v5596 >= 64)) {
}
else {
goto lab←L100007;
};
SOURCE(2505, 260)
SOURCE(2529, 9)
(* (ptr) dwp←v5624 ) = sw←v5144;
SOURCE(2540, 15)
(* (ptr) (dwp←v5624 + 4) ) = sw←v5144;
SOURCE(2777, 17)
rem←v5596 = (rem←v5596 - 64);
SOURCE(2796, 17)
dwp←v5624 = (dwp←v5624 + 8);
goto lab←L100009;
lab←L100007: ;
SOURCE(2824, 185)
if ((rem←v5596 >= 32)) {
SOURCE(2845, 130)
SOURCE(2868, 9)
(* (ptr) dwp←v5624 ) = sw←v5144;
SOURCE(2977, 15)
rem←v5596 = (rem←v5596 - 32);
SOURCE(2994, 15)
dwp←v5624 = (dwp←v5624 + 4);
};
SOURCE(3014, 359)
if ((rem←v5596 != 0)) {
{
word mask←v5736;
word dw←v5764;
mask←v5736 = (word) XRM←BITRSHIFT( (word) -1, rem←v5596);
dw←v5764 = (* (ptr) dwp←v5624 );
SOURCE(3089, 284)
SOURCE(3112, 50)
{
word var←c14848;
{
/*1*/ word var←c14880;
/*1*/ word var←c0316;
/*1*/ var←c14880 = (word) XRM←BITNOT(mask←v5736);
/*1*/ var←c0316 = (word) XRM←BITAND(sw←v5144, var←c14880);
/*1*/ var←c14848 = ((word) XRM←BITAND(dw←v5764, mask←v5736) + var←c0316);
/*1*/ };
(* (ptr) dwp←v5624 ) = var←c14848;
};
};
};
};
goto lab←L100010;
lab←L100006: ;
lab←L100010: ;
SOURCE(3900, 18)
if ((sSize←v5116 == 1)) {
SOURCE(3918, 4)
goto lab←L100001;
};
SOURCE(3924, 17)
sSize←v5116 = (sSize←v5116 - 1);
SOURCE(3943, 9)
{
word next←v5792;
next←v5792 = (dstBit←v5004 + (* (( (ptr) arg←v3588)+2) ));
SOURCE(3466, 21)
dstBit←v5004 = (next←v5792 & 037);
SOURCE(3489, 34)
dst←v4976 = (dst←v4976 + ((next←v5792 - dstBit←v5004) >> 3));
};
SOURCE(3954, 9)
{
word next←v5820;
next←v5820 = (srcBit←v4920 + srcBpl←v4892);
SOURCE(3582, 21)
srcBit←v4920 = (next←v5820 & 037);
SOURCE(3605, 34)
src←v4948 = (src←v4948 + ((next←v5820 - srcBit←v4920) >> 3));
SOURCE(3641, 21)
tileLine←v4836 = (tileLine←v4836 + 1);
SOURCE(3664, 149)
if ((tileLine←v4836 == sSizeTile←v5088)) {
SOURCE(3695, 64)
firstBit←v4864 = (word) XRM←BITAND((firstBit←v4864 + (fSizeTile←v5060 - (* (( (ptr) arg←v3588)+12) ))), (fSizeTile←v5060 - 1))
;
SOURCE(3761, 12)
tileLine←v4836 = 0;
SOURCE(3775, 19)
srcBit←v4920 = (* (( (ptr) arg←v3588)+6) );
SOURCE(3796, 17)
src←v4948 = (* (( (ptr) arg←v3588)+5) );
};
};
goto lab←L100002;
lab←L100001: ;
break;
case 1:
SOURCE(4249, 17)
SOURCE(3865, 98)
lab←L100013: ;
SOURCE(3868, 13)
{
word k←v11780;
k←v11780 = fSizeTile←v5060;
SOURCE(1414, 25)
sw←v5144 = (word) XRM←BITXOR((* (ptr) src←v4948 ), invert←v5172);
SOURCE(1441, 131)
if ((srcBit←v4920 != 0)) {
SOURCE(1462, 26)
sw←v5144 = (word) XRM←BITLSHIFT(sw←v5144, srcBit←v4920);
SOURCE(1490, 82)
if (((srcBit←v4920 + k←v11780) > 32)) {
SOURCE(1513, 59)
{
word var←c14912;
word var←c0317;
var←c14912 = (word) XRM←BITXOR((* (ptr) (src←v4948 + 4) ), invert←v5172);
var←c0317 = (word) XRM←BITRSHIFT(var←c14912, (32 - srcBit←v4920));
sw←v5144 = (sw←v5144 + var←c0317);
};
};
};
SOURCE(1577, 122)
if ((k←v11780 < 32)) {
SOURCE(1595, 44)
{
word var←c14944;
var←c14944 = (word) XRM←BITLSHIFT( (word) -1, (32 - k←v11780));
sw←v5144 = (word) XRM←BITAND(sw←v5144, var←c14944);
};
SOURCE(1641, 58)
lab←L100016: ;
SOURCE(1644, 26)
sw←v5144 = (sw←v5144 + (word) XRM←BITRSHIFT(sw←v5144, k←v11780));
SOURCE(1672, 9)
k←v11780 = (k←v11780 + k←v11780);
SOURCE(1683, 16)
if ((k←v11780 == 32)) {
SOURCE(1699, 4)
goto lab←L100015;
};
goto lab←L100016;
lab←L100015: ;
};
SOURCE(1717, 79)
if ((firstBit←v4864 != 0)) {
SOURCE(1738, 58)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, firstBit←v4864) + (word) XRM←BITRSHIFT(sw←v5144, (32 - firstBit←v4864)));
};
};
SOURCE(3883, 15)
SOURCE(1842, 1563)
{
word rem←v11868;
word dwp←v11896;
rem←v11868 = fSize←v5032;
dwp←v11896 = dst←v4976;
SOURCE(1882, 596)
if ((dstBit←v5004 != 0)) {
{
word dw←v11940;
word mask←v11968;
word rw←v11996;
dw←v11940 = (* (ptr) dwp←v11896 );
mask←v11968 = (word) XRM←BITRSHIFT( (word) -1, dstBit←v5004);
rw←v11996 = (word) XRM←BITRSHIFT(sw←v5144, dstBit←v5004);
SOURCE(1997, 18)
rem←v11868 = (rem←v11868 + dstBit←v5004);
SOURCE(2017, 64)
if ((rem←v11868 < 32)) {
SOURCE(2035, 46)
{
/*1*/ word var←c14976;
/*1*/ var←c14976 = (word) XRM←BITRSHIFT( (word) -1, rem←v11868);
/*1*/ mask←v11968 = (word) XRM←BITXOR(mask←v11968, var←c14976);
/*1*/ };
};
SOURCE(2083, 284)
SOURCE(2165, 62)
{
word var←c15008;
{
/*1*/ word var←c15040;
/*1*/ word var←c0318;
/*1*/ word var←c15072;
/*1*/ var←c15040 = (word) XRM←BITNOT(mask←v11968);
/*1*/ var←c0318 = (word) XRM←BITAND(dw←v11940, var←c15040);
/*1*/ var←c15072 = (word) XRM←BITAND(dw←v11940, rw←v11996);
/*1*/ var←c15008 = (var←c0318 + (word) XRM←BITAND(var←c15072, mask←v11968));
/*1*/ };
(* (ptr) dwp←v11896 ) = var←c15008;
};
SOURCE(2378, 19)
if ((rem←v11868 <= 32)) {
SOURCE(2397, 10)
goto lab←L100017;
};
SOURCE(2409, 35)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, (32 - dstBit←v5004)) + rw←v11996);
SOURCE(2446, 15)
rem←v11868 = (rem←v11868 - 32);
SOURCE(2463, 15)
dwp←v11896 = (dwp←v11896 + 4);
};
};
SOURCE(2483, 330)
lab←L100020: ;
if ((rem←v11868 >= 64)) {
}
else {
goto lab←L100018;
};
SOURCE(2505, 260)
SOURCE(2566, 23)
(* (ptr) dwp←v11896 ) = (word) XRM←BITAND((* (ptr) dwp←v11896 ), sw←v5144);
SOURCE(2591, 35)
{
word var←c15104;
var←c15104 = (word) XRM←BITAND((* (ptr) (dwp←v11896 + 4) ), sw←v5144);
(* (ptr) (dwp←v11896 + 4) ) = var←c15104;
};
SOURCE(2777, 17)
rem←v11868 = (rem←v11868 - 64);
SOURCE(2796, 17)
dwp←v11896 = (dwp←v11896 + 8);
goto lab←L100020;
lab←L100018: ;
SOURCE(2824, 185)
if ((rem←v11868 >= 32)) {
SOURCE(2845, 130)
SOURCE(2886, 23)
(* (ptr) dwp←v11896 ) = (word) XRM←BITAND((* (ptr) dwp←v11896 ), sw←v5144);
SOURCE(2977, 15)
rem←v11868 = (rem←v11868 - 32);
SOURCE(2994, 15)
dwp←v11896 = (dwp←v11896 + 4);
};
SOURCE(3014, 359)
if ((rem←v11868 != 0)) {
{
word mask←v12040;
word dw←v12068;
mask←v12040 = (word) XRM←BITRSHIFT( (word) -1, rem←v11868);
dw←v12068 = (* (ptr) dwp←v11896 );
SOURCE(3089, 284)
SOURCE(3171, 62)
{
word var←c15136;
{
/*1*/ word var←c15168;
/*1*/ word var←c15200;
/*1*/ word var←c0319;
/*1*/ var←c15168 = (word) XRM←BITAND(dw←v12068, sw←v5144);
/*1*/ var←c15200 = (word) XRM←BITNOT(mask←v12040);
/*1*/ var←c0319 = (word) XRM←BITAND(var←c15168, var←c15200);
/*1*/ var←c15136 = ((word) XRM←BITAND(dw←v12068, mask←v12040) + var←c0319);
/*1*/ };
(* (ptr) dwp←v11896 ) = var←c15136;
};
};
};
};
goto lab←L100021;
lab←L100017: ;
lab←L100021: ;
SOURCE(3900, 18)
if ((sSize←v5116 == 1)) {
SOURCE(3918, 4)
goto lab←L100012;
};
SOURCE(3924, 17)
sSize←v5116 = (sSize←v5116 - 1);
SOURCE(3943, 9)
{
word next←v12112;
next←v12112 = (dstBit←v5004 + (* (( (ptr) arg←v3588)+2) ));
SOURCE(3466, 21)
dstBit←v5004 = (next←v12112 & 037);
SOURCE(3489, 34)
dst←v4976 = (dst←v4976 + ((next←v12112 - dstBit←v5004) >> 3));
};
SOURCE(3954, 9)
{
word next←v12156;
next←v12156 = (srcBit←v4920 + srcBpl←v4892);
SOURCE(3582, 21)
srcBit←v4920 = (next←v12156 & 037);
SOURCE(3605, 34)
src←v4948 = (src←v4948 + ((next←v12156 - srcBit←v4920) >> 3));
SOURCE(3641, 21)
tileLine←v4836 = (tileLine←v4836 + 1);
SOURCE(3664, 149)
if ((tileLine←v4836 == sSizeTile←v5088)) {
SOURCE(3695, 64)
firstBit←v4864 = (word) XRM←BITAND((firstBit←v4864 + (fSizeTile←v5060 - (* (( (ptr) arg←v3588)+12) ))), (fSizeTile←v5060 - 1))
;
SOURCE(3761, 12)
tileLine←v4836 = 0;
SOURCE(3775, 19)
srcBit←v4920 = (* (( (ptr) arg←v3588)+6) );
SOURCE(3796, 17)
src←v4948 = (* (( (ptr) arg←v3588)+5) );
};
};
goto lab←L100013;
lab←L100012: ;
break;
case 2:
SOURCE(4274, 16)
SOURCE(3865, 98)
lab←L100024: ;
SOURCE(3868, 13)
{
word k←v11360;
k←v11360 = fSizeTile←v5060;
SOURCE(1414, 25)
sw←v5144 = (word) XRM←BITXOR((* (ptr) src←v4948 ), invert←v5172);
SOURCE(1441, 131)
if ((srcBit←v4920 != 0)) {
SOURCE(1462, 26)
sw←v5144 = (word) XRM←BITLSHIFT(sw←v5144, srcBit←v4920);
SOURCE(1490, 82)
if (((srcBit←v4920 + k←v11360) > 32)) {
SOURCE(1513, 59)
{
word var←c15232;
word var←c0320;
var←c15232 = (word) XRM←BITXOR((* (ptr) (src←v4948 + 4) ), invert←v5172);
var←c0320 = (word) XRM←BITRSHIFT(var←c15232, (32 - srcBit←v4920));
sw←v5144 = (sw←v5144 + var←c0320);
};
};
};
SOURCE(1577, 122)
if ((k←v11360 < 32)) {
SOURCE(1595, 44)
{
word var←c15264;
var←c15264 = (word) XRM←BITLSHIFT( (word) -1, (32 - k←v11360));
sw←v5144 = (word) XRM←BITAND(sw←v5144, var←c15264);
};
SOURCE(1641, 58)
lab←L100027: ;
SOURCE(1644, 26)
sw←v5144 = (sw←v5144 + (word) XRM←BITRSHIFT(sw←v5144, k←v11360));
SOURCE(1672, 9)
k←v11360 = (k←v11360 + k←v11360);
SOURCE(1683, 16)
if ((k←v11360 == 32)) {
SOURCE(1699, 4)
goto lab←L100026;
};
goto lab←L100027;
lab←L100026: ;
};
SOURCE(1717, 79)
if ((firstBit←v4864 != 0)) {
SOURCE(1738, 58)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, firstBit←v4864) + (word) XRM←BITRSHIFT(sw←v5144, (32 - firstBit←v4864)));
};
};
SOURCE(3883, 15)
SOURCE(1842, 1563)
{
word rem←v11448;
word dwp←v11476;
rem←v11448 = fSize←v5032;
dwp←v11476 = dst←v4976;
SOURCE(1882, 596)
if ((dstBit←v5004 != 0)) {
{
word dw←v11520;
word mask←v11548;
word rw←v11576;
dw←v11520 = (* (ptr) dwp←v11476 );
mask←v11548 = (word) XRM←BITRSHIFT( (word) -1, dstBit←v5004);
rw←v11576 = (word) XRM←BITRSHIFT(sw←v5144, dstBit←v5004);
SOURCE(1997, 18)
rem←v11448 = (rem←v11448 + dstBit←v5004);
SOURCE(2017, 64)
if ((rem←v11448 < 32)) {
SOURCE(2035, 46)
{
/*1*/ word var←c15296;
/*1*/ var←c15296 = (word) XRM←BITRSHIFT( (word) -1, rem←v11448);
/*1*/ mask←v11548 = (word) XRM←BITXOR(mask←v11548, var←c15296);
/*1*/ };
};
SOURCE(2083, 284)
SOURCE(2235, 61)
{
word var←c15328;
{
/*1*/ word var←c15360;
/*1*/ word var←c0321;
/*1*/ word var←c15392;
/*1*/ var←c15360 = (word) XRM←BITNOT(mask←v11548);
/*1*/ var←c0321 = (word) XRM←BITAND(dw←v11520, var←c15360);
/*1*/ var←c15392 = (word) XRM←BITOR(dw←v11520, rw←v11576);
/*1*/ var←c15328 = (var←c0321 + (word) XRM←BITAND(var←c15392, mask←v11548));
/*1*/ };
(* (ptr) dwp←v11476 ) = var←c15328;
};
SOURCE(2378, 19)
if ((rem←v11448 <= 32)) {
SOURCE(2397, 10)
goto lab←L100028;
};
SOURCE(2409, 35)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, (32 - dstBit←v5004)) + rw←v11576);
SOURCE(2446, 15)
rem←v11448 = (rem←v11448 - 32);
SOURCE(2463, 15)
dwp←v11476 = (dwp←v11476 + 4);
};
};
SOURCE(2483, 330)
lab←L100031: ;
if ((rem←v11448 >= 64)) {
}
else {
goto lab←L100029;
};
SOURCE(2505, 260)
SOURCE(2636, 22)
(* (ptr) dwp←v11476 ) = (word) XRM←BITOR((* (ptr) dwp←v11476 ), sw←v5144);
SOURCE(2660, 34)
{
word var←c15424;
var←c15424 = (word) XRM←BITOR((* (ptr) (dwp←v11476 + 4) ), sw←v5144);
(* (ptr) (dwp←v11476 + 4) ) = var←c15424;
};
SOURCE(2777, 17)
rem←v11448 = (rem←v11448 - 64);
SOURCE(2796, 17)
dwp←v11476 = (dwp←v11476 + 8);
goto lab←L100031;
lab←L100029: ;
SOURCE(2824, 185)
if ((rem←v11448 >= 32)) {
SOURCE(2845, 130)
SOURCE(2917, 22)
(* (ptr) dwp←v11476 ) = (word) XRM←BITOR((* (ptr) dwp←v11476 ), sw←v5144);
SOURCE(2977, 15)
rem←v11448 = (rem←v11448 - 32);
SOURCE(2994, 15)
dwp←v11476 = (dwp←v11476 + 4);
};
SOURCE(3014, 359)
if ((rem←v11448 != 0)) {
{
word mask←v11620;
word dw←v11648;
mask←v11620 = (word) XRM←BITRSHIFT( (word) -1, rem←v11448);
dw←v11648 = (* (ptr) dwp←v11476 );
SOURCE(3089, 284)
SOURCE(3241, 61)
{
word var←c15456;
{
/*1*/ word var←c15488;
/*1*/ word var←c15520;
/*1*/ word var←c0322;
/*1*/ var←c15488 = (word) XRM←BITOR(dw←v11648, sw←v5144);
/*1*/ var←c15520 = (word) XRM←BITNOT(mask←v11620);
/*1*/ var←c0322 = (word) XRM←BITAND(var←c15488, var←c15520);
/*1*/ var←c15456 = ((word) XRM←BITAND(dw←v11648, mask←v11620) + var←c0322);
/*1*/ };
(* (ptr) dwp←v11476 ) = var←c15456;
};
};
};
};
goto lab←L100032;
lab←L100028: ;
lab←L100032: ;
SOURCE(3900, 18)
if ((sSize←v5116 == 1)) {
SOURCE(3918, 4)
goto lab←L100023;
};
SOURCE(3924, 17)
sSize←v5116 = (sSize←v5116 - 1);
SOURCE(3943, 9)
{
word next←v11692;
next←v11692 = (dstBit←v5004 + (* (( (ptr) arg←v3588)+2) ));
SOURCE(3466, 21)
dstBit←v5004 = (next←v11692 & 037);
SOURCE(3489, 34)
dst←v4976 = (dst←v4976 + ((next←v11692 - dstBit←v5004) >> 3));
};
SOURCE(3954, 9)
{
word next←v11736;
next←v11736 = (srcBit←v4920 + srcBpl←v4892);
SOURCE(3582, 21)
srcBit←v4920 = (next←v11736 & 037);
SOURCE(3605, 34)
src←v4948 = (src←v4948 + ((next←v11736 - srcBit←v4920) >> 3));
SOURCE(3641, 21)
tileLine←v4836 = (tileLine←v4836 + 1);
SOURCE(3664, 149)
if ((tileLine←v4836 == sSizeTile←v5088)) {
SOURCE(3695, 64)
firstBit←v4864 = (word) XRM←BITAND((firstBit←v4864 + (fSizeTile←v5060 - (* (( (ptr) arg←v3588)+12) ))), (fSizeTile←v5060 - 1))
;
SOURCE(3761, 12)
tileLine←v4836 = 0;
SOURCE(3775, 19)
srcBit←v4920 = (* (( (ptr) arg←v3588)+6) );
SOURCE(3796, 17)
src←v4948 = (* (( (ptr) arg←v3588)+5) );
};
};
goto lab←L100024;
lab←L100023: ;
break;
default:
SOURCE(4303, 17)
SOURCE(3865, 98)
lab←L100035: ;
SOURCE(3868, 13)
{
word k←v10940;
k←v10940 = fSizeTile←v5060;
SOURCE(1414, 25)
sw←v5144 = (word) XRM←BITXOR((* (ptr) src←v4948 ), invert←v5172);
SOURCE(1441, 131)
if ((srcBit←v4920 != 0)) {
SOURCE(1462, 26)
sw←v5144 = (word) XRM←BITLSHIFT(sw←v5144, srcBit←v4920);
SOURCE(1490, 82)
if (((srcBit←v4920 + k←v10940) > 32)) {
SOURCE(1513, 59)
{
word var←c15552;
word var←c0323;
var←c15552 = (word) XRM←BITXOR((* (ptr) (src←v4948 + 4) ), invert←v5172);
var←c0323 = (word) XRM←BITRSHIFT(var←c15552, (32 - srcBit←v4920));
sw←v5144 = (sw←v5144 + var←c0323);
};
};
};
SOURCE(1577, 122)
if ((k←v10940 < 32)) {
SOURCE(1595, 44)
{
word var←c15584;
var←c15584 = (word) XRM←BITLSHIFT( (word) -1, (32 - k←v10940));
sw←v5144 = (word) XRM←BITAND(sw←v5144, var←c15584);
};
SOURCE(1641, 58)
lab←L100038: ;
SOURCE(1644, 26)
sw←v5144 = (sw←v5144 + (word) XRM←BITRSHIFT(sw←v5144, k←v10940));
SOURCE(1672, 9)
k←v10940 = (k←v10940 + k←v10940);
SOURCE(1683, 16)
if ((k←v10940 == 32)) {
SOURCE(1699, 4)
goto lab←L100037;
};
goto lab←L100038;
lab←L100037: ;
};
SOURCE(1717, 79)
if ((firstBit←v4864 != 0)) {
SOURCE(1738, 58)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, firstBit←v4864) + (word) XRM←BITRSHIFT(sw←v5144, (32 - firstBit←v4864)));
};
};
SOURCE(3883, 15)
SOURCE(1842, 1563)
{
word rem←v11028;
word dwp←v11056;
rem←v11028 = fSize←v5032;
dwp←v11056 = dst←v4976;
SOURCE(1882, 596)
if ((dstBit←v5004 != 0)) {
{
word dw←v11100;
word mask←v11128;
word rw←v11156;
dw←v11100 = (* (ptr) dwp←v11056 );
mask←v11128 = (word) XRM←BITRSHIFT( (word) -1, dstBit←v5004);
rw←v11156 = (word) XRM←BITRSHIFT(sw←v5144, dstBit←v5004);
SOURCE(1997, 18)
rem←v11028 = (rem←v11028 + dstBit←v5004);
SOURCE(2017, 64)
if ((rem←v11028 < 32)) {
SOURCE(2035, 46)
{
/*1*/ word var←c15616;
/*1*/ var←c15616 = (word) XRM←BITRSHIFT( (word) -1, rem←v11028);
/*1*/ mask←v11128 = (word) XRM←BITXOR(mask←v11128, var←c15616);
/*1*/ };
};
SOURCE(2083, 284)
SOURCE(2305, 62)
{
word var←c15648;
{
/*1*/ word var←c15680;
/*1*/ word var←c0324;
/*1*/ word var←c15712;
/*1*/ var←c15680 = (word) XRM←BITNOT(mask←v11128);
/*1*/ var←c0324 = (word) XRM←BITAND(dw←v11100, var←c15680);
/*1*/ var←c15712 = (word) XRM←BITXOR(dw←v11100, rw←v11156);
/*1*/ var←c15648 = (var←c0324 + (word) XRM←BITAND(var←c15712, mask←v11128));
/*1*/ };
(* (ptr) dwp←v11056 ) = var←c15648;
};
SOURCE(2378, 19)
if ((rem←v11028 <= 32)) {
SOURCE(2397, 10)
goto lab←L100039;
};
SOURCE(2409, 35)
sw←v5144 = ((word) XRM←BITLSHIFT(sw←v5144, (32 - dstBit←v5004)) + rw←v11156);
SOURCE(2446, 15)
rem←v11028 = (rem←v11028 - 32);
SOURCE(2463, 15)
dwp←v11056 = (dwp←v11056 + 4);
};
};
SOURCE(2483, 330)
lab←L100042: ;
if ((rem←v11028 >= 64)) {
}
else {
goto lab←L100040;
};
SOURCE(2505, 260)
SOURCE(2705, 23)
(* (ptr) dwp←v11056 ) = (word) XRM←BITXOR((* (ptr) dwp←v11056 ), sw←v5144);
SOURCE(2730, 35)
{
word var←c15744;
var←c15744 = (word) XRM←BITXOR((* (ptr) (dwp←v11056 + 4) ), sw←v5144);
(* (ptr) (dwp←v11056 + 4) ) = var←c15744;
};
SOURCE(2777, 17)
rem←v11028 = (rem←v11028 - 64);
SOURCE(2796, 17)
dwp←v11056 = (dwp←v11056 + 8);
goto lab←L100042;
lab←L100040: ;
SOURCE(2824, 185)
if ((rem←v11028 >= 32)) {
SOURCE(2845, 130)
SOURCE(2952, 23)
(* (ptr) dwp←v11056 ) = (word) XRM←BITXOR((* (ptr) dwp←v11056 ), sw←v5144);
SOURCE(2977, 15)
rem←v11028 = (rem←v11028 - 32);
SOURCE(2994, 15)
dwp←v11056 = (dwp←v11056 + 4);
};
SOURCE(3014, 359)
if ((rem←v11028 != 0)) {
{
word mask←v11200;
word dw←v11228;
mask←v11200 = (word) XRM←BITRSHIFT( (word) -1, rem←v11028);
dw←v11228 = (* (ptr) dwp←v11056 );
SOURCE(3089, 284)
SOURCE(3311, 62)
{
word var←c15776;
{
/*1*/ word var←c15808;
/*1*/ word var←c15840;
/*1*/ word var←c0325;
/*1*/ var←c15808 = (word) XRM←BITXOR(dw←v11228, sw←v5144);
/*1*/ var←c15840 = (word) XRM←BITNOT(mask←v11200);
/*1*/ var←c0325 = (word) XRM←BITAND(var←c15808, var←c15840);
/*1*/ var←c15776 = ((word) XRM←BITAND(dw←v11228, mask←v11200) + var←c0325);
/*1*/ };
(* (ptr) dwp←v11056 ) = var←c15776;
};
};
};
};
goto lab←L100043;
lab←L100039: ;
lab←L100043: ;
SOURCE(3900, 18)
if ((sSize←v5116 == 1)) {
SOURCE(3918, 4)
goto lab←L100034;
};
SOURCE(3924, 17)
sSize←v5116 = (sSize←v5116 - 1);
SOURCE(3943, 9)
{
word next←v11272;
next←v11272 = (dstBit←v5004 + (* (( (ptr) arg←v3588)+2) ));
SOURCE(3466, 21)
dstBit←v5004 = (next←v11272 & 037);
SOURCE(3489, 34)
dst←v4976 = (dst←v4976 + ((next←v11272 - dstBit←v5004) >> 3));
};
SOURCE(3954, 9)
{
word next←v11316;
next←v11316 = (srcBit←v4920 + srcBpl←v4892);
SOURCE(3582, 21)
srcBit←v4920 = (next←v11316 & 037);
SOURCE(3605, 34)
src←v4948 = (src←v4948 + ((next←v11316 - srcBit←v4920) >> 3));
SOURCE(3641, 21)
tileLine←v4836 = (tileLine←v4836 + 1);
SOURCE(3664, 149)
if ((tileLine←v4836 == sSizeTile←v5088)) {
SOURCE(3695, 64)
firstBit←v4864 = (word) XRM←BITAND((firstBit←v4864 + (fSizeTile←v5060 - (* (( (ptr) arg←v3588)+12) ))), (fSizeTile←v5060 - 1))
;
SOURCE(3761, 12)
tileLine←v4836 = 0;
SOURCE(3775, 19)
srcBit←v4920 = (* (( (ptr) arg←v3588)+6) );
SOURCE(3796, 17)
src←v4948 = (* (( (ptr) arg←v3588)+5) );
};
};
goto lab←L100035;
lab←L100034: ;
break;
};
};
};
}
static void Fast2←P180(arg←v3648)
word arg←v3648;
{
register ptr gf←c17184 = (ptr) &globalframe;
word tileLine←v5932;
word firstBit←v5960;
word srcBit←v5988;
word src←v6016;
word dst←v6044;
word dstBit←v6072;
word fSizeTile←v6100;
word tBits←v6128;
word sSize←v6156;
word invert←v6184;
word df←v6212;
word sw←v6240 = 0;
/* Fast2: */
SOURCE(4329, 2386)
SOURCE(5240, 29)
tileLine←v5932 = (* (( (ptr) arg←v3648)+11) );
SOURCE(5271, 34)
firstBit←v5960 = (* (( (ptr) arg←v3648)+10) );
SOURCE(5307, 30)
srcBit←v5988 = (* (( (ptr) arg←v3648)+6) );
SOURCE(5339, 26)
src←v6016 = (* (( (ptr) arg←v3648)+5) );
SOURCE(5367, 26)
dst←v6044 = (* (ptr) arg←v3648 );
SOURCE(5395, 30)
dstBit←v6072 = (* (( (ptr) arg←v3648)+1) );
SOURCE(5427, 30)
fSizeTile←v6100 = (* (( (ptr) arg←v3648)+8) );
SOURCE(5459, 43)
tBits←v6128 = (* ((( (ptr) gf←c17184)+37)/* replicatorBitsArray←v3168 */ +fSizeTile←v6100) );
SOURCE(5504, 22)
sSize←v6156 = (* (( (ptr) arg←v3648)+4) );
SOURCE(5528, 28)
invert←v6184 = (* (( (ptr) arg←v3648)+13) );
SOURCE(5558, 25)
df←v6212 = (* (( (ptr) arg←v3648)+14) );
SOURCE(5638, 51)
if ((fSizeTile←v6100 > 32)) {
SOURCE(5675, 14)
(void) BadAssertion←P660();
};
SOURCE(5691, 1024)
if ( ( (sSize←v6156 != 0) ? ((* (( (ptr) arg←v3648)+3) ) != 0) : 0 ) ) {
SOURCE(5729, 120)
if ((tileLine←v5932 != 0)) {
SOURCE(5750, 101)
{
word next←v6332;
SOURCE(5752, 40)
next←v6332 = (srcBit←v5988 + (tileLine←v5932 * (* (( (ptr) arg←v3648)+7) )));
SOURCE(5794, 21)
srcBit←v5988 = (next←v6332 & 037);
SOURCE(5817, 32)
src←v6016 = (src←v6016 + ((next←v6332 - srcBit←v5988) >> 3));
};
};
SOURCE(5854, 861)
lab←L100046: ;
SOURCE(5854, 861)
{
word rem←v6376;
word xBits←v6404;
word dwp←v6432;
word shift←v6460;
word dShift←v6488;
SOURCE(5857, 20)
rem←v6376 = (* (( (ptr) arg←v3648)+3) );
SOURCE(5909, 23)
xBits←v6404 = (32 - dstBit←v6072);
SOURCE(5950, 18)
dwp←v6432 = dst←v6044;
SOURCE(5998, 21)
shift←v6460 = firstBit←v5960;
SOURCE(6021, 20)
dShift←v6488 = dstBit←v6072;
SOURCE(6523, 8)
{
word comp←v6760;
comp←v6760 = (32 - fSizeTile←v6100);
SOURCE(4915, 25)
sw←v6240 = (word) XRM←BITXOR((* (ptr) src←v6016 ), invert←v6184);
SOURCE(4942, 155)
if ((srcBit←v5988 != 0)) {
{
word lim←v6788;
lim←v6788 = (srcBit←v5988 + fSizeTile←v6100);
SOURCE(4992, 26)
sw←v6240 = (word) XRM←BITLSHIFT(sw←v6240, srcBit←v5988);
SOURCE(5020, 77)
if ((lim←v6788 > 32)) {
SOURCE(5038, 59)
{
word var←c15872;
word var←c0326;
var←c15872 = (word) XRM←BITXOR((* (ptr) (src←v6016 + 4) ), invert←v6184);
var←c0326 = (word) XRM←BITRSHIFT(var←c15872, (32 - srcBit←v5988));
sw←v6240 = (sw←v6240 + var←c0326);
};
};
};
};
SOURCE(5102, 133)
if ((fSizeTile←v6100 <= 16)) {
SOURCE(5129, 63)
sw←v6240 = ((word) XRM←BITRSHIFT(sw←v6240, comp←v6760) * (* ((( (ptr) gf←c17184)+4)/* replicatorMultArray←v3140 */ +fSizeTile←v6100)
));
}
else {
SOURCE(5192, 43)
{
word var←c15904;
var←c15904 = (word) XRM←BITLSHIFT( (word) -1, comp←v6760);
sw←v6240 = (word) XRM←BITAND(sw←v6240, var←c15904);
};
};
};
SOURCE(6533, 117)
{
word var←c15936;
var←c15936 = df←v6212;
switch (var←c15936) {
case 0:
SOURCE(6556, 17)
SOURCE(6086, 423)
lab←L100049: ;
{
word tw←v6620;
word valid←v6648;
tw←v6620 = (word) XRM←BITLSHIFT(sw←v6240, shift←v6460);
valid←v6648 = (tBits←v6128 - shift←v6460);
SOURCE(6150, 31)
if ((rem←v6376 < xBits←v6404)) {
SOURCE(6170, 11)
xBits←v6404 = rem←v6376;
};
SOURCE(6183, 76)
lab←L100052: ;
if ((valid←v6648 < xBits←v6404)) {
}
else {
goto lab←L100050;
};
SOURCE(6206, 30)
tw←v6620 = ((word) XRM←BITRSHIFT(sw←v6240, valid←v6648) + tw←v6620);
SOURCE(6238, 21)
valid←v6648 = (valid←v6648 + tBits←v6128);
goto lab←L100052;
lab←L100050: ;
SOURCE(6270, 42)
{
word dst←v13060;
word dstMod←v13088;
word w←v13116;
word bits←v13144;
dst←v13060 = dwp←v6432;
dstMod←v13088 = dShift←v6488;
w←v13116 = tw←v6620;
bits←v13144 = xBits←v6404;
if ((dstMod←v13088 != 0)) {
{
/*1*/ word dstLim←v13192;
/*1*/ word mask←v13220;
/*1*/ word dstW←v13248;
/*1*/ word tw←v13276;
/*1*/ dstLim←v13192 = (dstMod←v13088 + bits←v13144);
/*1*/ mask←v13220 = (word) XRM←BITRSHIFT( (word) -1, dstMod←v13088);
/*1*/ dstW←v13248 = (* (ptr) dst←v13060 );
/*1*/ tw←v13276 = (word) XRM←BITRSHIFT(w←v13116, dstMod←v13088);
SOURCE(10307, 56)
/*1*/ if ((dstLim←v13192 < 32)) {
SOURCE(10328, 35)
/*1*/ mask←v13220 = (mask←v13220 - (word) XRM←BITRSHIFT(mask←v13220, bits←v13144));
/*1*/ };
SOURCE(10484, 52)
/*1*/ {
/*1*/ word var←c15968;
/*1*/ word var←c0327;
/*1*/ var←c15968 = (word) XRM←BITNOT(mask←v13220);
/*1*/ var←c0327 = (word) XRM←BITAND(dstW←v13248, var←c15968);
/*1*/ (* (ptr) dst←v13060 ) = (var←c0327 + (word) XRM←BITAND(tw←v13276, mask←v13220));
/*1*/ };
SOURCE(10538, 295)
/*1*/ if ((dstLim←v13192 > 32)) {
SOURCE(10561, 43)
/*1*/ mask←v13220 = (word) XRM←BITRSHIFT( (word) -1, (dstLim←v13192 & 037));
SOURCE(10606, 17)
/*1*/ dstW←v13248 = (* (ptr) (dst←v13060 + 4) );
SOURCE(10625, 29)
/*1*/ tw←v13276 = (word) XRM←BITLSHIFT(w←v13116, (32 - dstMod←v13088));
SOURCE(10775, 58)
/*1*/ {
/*1*/ word var←c16000;
/*1*/ word var←c0328;
/*1*/ var←c16000 = (word) XRM←BITNOT(mask←v13220);
/*1*/ var←c0328 = (word) XRM←BITAND(tw←v13276, var←c16000);
/*1*/ (* (ptr) (dst←v13060 + 4) ) = (var←c0328 + (word) XRM←BITAND(dstW←v13248, mask←v13220));
/*1*/ };
/*1*/ };
/*1*/ };
}
else {
if ((bits←v13144 != 32)) {
/*1*/ {
/*1*/ word mask←v13320;
/*1*/ word dstW←v13348;
/*1*/ word tw←v13376;
/*1*/ mask←v13320 = (word) XRM←BITRSHIFT( (word) -1, bits←v13144);
/*1*/ dstW←v13348 = (* (ptr) dst←v13060 );
/*1*/ tw←v13376 = w←v13116;
SOURCE(11050, 52)
/*1*/ {
/*1*/ word var←c16032;
/*1*/ word var←c0329;
/*1*/ var←c16032 = (word) XRM←BITNOT(mask←v13320);
/*1*/ var←c0329 = (word) XRM←BITAND(tw←v13376, var←c16032);
/*1*/ (* (ptr) dst←v13060 ) = ((word) XRM←BITAND(dstW←v13348, mask←v13320) + var←c0329);
/*1*/ };
/*1*/ };
/*1*/ }
else {
SOURCE(11118, 126)
SOURCE(11141, 8)
/*1*/ (* (ptr) dst←v13060 ) = w←v13116;
/*1*/ };
};
};
SOURCE(6314, 20)
if ((rem←v6376 == xBits←v6404)) {
SOURCE(6334, 4)
goto lab←L100048;
};
SOURCE(6340, 21)
shift←v6460 = (shift←v6460 + xBits←v6404);
SOURCE(6363, 45)
lab←L100055: ;
if ((shift←v6460 >= tBits←v6128)) {
}
else {
goto lab←L100053;
};
SOURCE(6387, 21)
shift←v6460 = (shift←v6460 - tBits←v6128);
goto lab←L100055;
lab←L100053: ;
SOURCE(6419, 15)
dwp←v6432 = (dwp←v6432 + 4);
SOURCE(6436, 10)
dShift←v6488 = 0;
SOURCE(6448, 17)
rem←v6376 = (rem←v6376 - xBits←v6404);
SOURCE(6467, 11)
xBits←v6404 = 32;
SOURCE(6480, 29)
if ((rem←v6376 < 32)) {
SOURCE(6498, 11)
xBits←v6404 = rem←v6376;
};
};
goto lab←L100049;
lab←L100048: ;
break;
case 1:
SOURCE(6582, 16)
SOURCE(6086, 423)
lab←L100058: ;
{
word tw←v12536;
word valid←v12564;
tw←v12536 = (word) XRM←BITLSHIFT(sw←v6240, shift←v6460);
valid←v12564 = (tBits←v6128 - shift←v6460);
SOURCE(6150, 31)
if ((rem←v6376 < xBits←v6404)) {
SOURCE(6170, 11)
xBits←v6404 = rem←v6376;
};
SOURCE(6183, 76)
lab←L100061: ;
if ((valid←v12564 < xBits←v6404)) {
}
else {
goto lab←L100059;
};
SOURCE(6206, 30)
tw←v12536 = ((word) XRM←BITRSHIFT(sw←v6240, valid←v12564) + tw←v12536);
SOURCE(6238, 21)
valid←v12564 = (valid←v12564 + tBits←v6128);
goto lab←L100061;
lab←L100059: ;
SOURCE(6270, 42)
{
word dst←v14140;
word dstMod←v14168;
word w←v14196;
word bits←v14224;
dst←v14140 = dwp←v6432;
dstMod←v14168 = dShift←v6488;
w←v14196 = tw←v12536;
bits←v14224 = xBits←v6404;
if ((dstMod←v14168 != 0)) {
{
/*1*/ word dstLim←v7644;
/*1*/ word mask←v7672;
/*1*/ word dstW←v7700;
/*1*/ word tw←v7728;
/*1*/ dstLim←v7644 = (dstMod←v14168 + bits←v14224);
/*1*/ mask←v7672 = (word) XRM←BITRSHIFT( (word) -1, dstMod←v14168);
/*1*/ dstW←v7700 = (* (ptr) dst←v14140 );
/*1*/ tw←v7728 = (word) XRM←BITRSHIFT(w←v14196, dstMod←v14168);
SOURCE(10307, 56)
/*1*/ if ((dstLim←v7644 < 32)) {
SOURCE(10328, 35)
/*1*/ mask←v7672 = (mask←v7672 - (word) XRM←BITRSHIFT(mask←v7672, bits←v14224));
/*1*/ };
SOURCE(10365, 117)
SOURCE(10399, 21)
/*1*/ tw←v7728 = (word) XRM←BITAND(dstW←v7700, tw←v7728);
SOURCE(10484, 52)
/*1*/ {
/*1*/ word var←c16064;
/*1*/ word var←c0330;
/*1*/ var←c16064 = (word) XRM←BITNOT(mask←v7672);
/*1*/ var←c0330 = (word) XRM←BITAND(dstW←v7700, var←c16064);
/*1*/ (* (ptr) dst←v14140 ) = (var←c0330 + (word) XRM←BITAND(tw←v7728, mask←v7672));
/*1*/ };
SOURCE(10538, 295)
/*1*/ if ((dstLim←v7644 > 32)) {
SOURCE(10561, 43)
/*1*/ mask←v7672 = (word) XRM←BITRSHIFT( (word) -1, (dstLim←v7644 & 037));
SOURCE(10606, 17)
/*1*/ dstW←v7700 = (* (ptr) (dst←v14140 + 4) );
SOURCE(10625, 29)
/*1*/ tw←v7728 = (word) XRM←BITLSHIFT(w←v14196, (32 - dstMod←v14168));
SOURCE(10656, 117)
SOURCE(10690, 21)
/*1*/ tw←v7728 = (word) XRM←BITAND(dstW←v7700, tw←v7728);
SOURCE(10775, 58)
/*1*/ {
/*1*/ word var←c16096;
/*1*/ word var←c0331;
/*1*/ var←c16096 = (word) XRM←BITNOT(mask←v7672);
/*1*/ var←c0331 = (word) XRM←BITAND(tw←v7728, var←c16096);
/*1*/ (* (ptr) (dst←v14140 + 4) ) = (var←c0331 + (word) XRM←BITAND(dstW←v7700, mask←v7672));
/*1*/ };
/*1*/ };
/*1*/ };
}
else {
if ((bits←v14224 != 32)) {
/*1*/ {
/*1*/ word mask←v7756;
/*1*/ word dstW←v7784;
/*1*/ word tw←v7812;
/*1*/ mask←v7756 = (word) XRM←BITRSHIFT( (word) -1, bits←v14224);
/*1*/ dstW←v7784 = (* (ptr) dst←v14140 );
/*1*/ tw←v7812 = w←v14196;
SOURCE(10931, 117)
SOURCE(10965, 21)
/*1*/ tw←v7812 = (word) XRM←BITAND(dstW←v7784, tw←v7812);
SOURCE(11050, 52)
/*1*/ {
/*1*/ word var←c16128;
/*1*/ word var←c0332;
/*1*/ var←c16128 = (word) XRM←BITNOT(mask←v7756);
/*1*/ var←c0332 = (word) XRM←BITAND(tw←v7812, var←c16128);
/*1*/ (* (ptr) dst←v14140 ) = ((word) XRM←BITAND(dstW←v7784, mask←v7756) + var←c0332);
/*1*/ };
/*1*/ };
/*1*/ }
else {
SOURCE(11118, 126)
SOURCE(11158, 22)
/*1*/ (* (ptr) dst←v14140 ) = (word) XRM←BITAND((* (ptr) dst←v14140 ), w←v14196);
/*1*/ };
};
};
SOURCE(6314, 20)
if ((rem←v6376 == xBits←v6404)) {
SOURCE(6334, 4)
goto lab←L100057;
};
SOURCE(6340, 21)
shift←v6460 = (shift←v6460 + xBits←v6404);
SOURCE(6363, 45)
lab←L100064: ;
if ((shift←v6460 >= tBits←v6128)) {
}
else {
goto lab←L100062;
};
SOURCE(6387, 21)
shift←v6460 = (shift←v6460 - tBits←v6128);
goto lab←L100064;
lab←L100062: ;
SOURCE(6419, 15)
dwp←v6432 = (dwp←v6432 + 4);
SOURCE(6436, 10)
dShift←v6488 = 0;
SOURCE(6448, 17)
rem←v6376 = (rem←v6376 - xBits←v6404);
SOURCE(6467, 11)
xBits←v6404 = 32;
SOURCE(6480, 29)
if ((rem←v6376 < 32)) {
SOURCE(6498, 11)
xBits←v6404 = rem←v6376;
};
};
goto lab←L100058;
lab←L100057: ;
break;
case 2:
SOURCE(6606, 15)
SOURCE(6086, 423)
lab←L100067: ;
{
word tw←v12464;
word valid←v12492;
tw←v12464 = (word) XRM←BITLSHIFT(sw←v6240, shift←v6460);
valid←v12492 = (tBits←v6128 - shift←v6460);
SOURCE(6150, 31)
if ((rem←v6376 < xBits←v6404)) {
SOURCE(6170, 11)
xBits←v6404 = rem←v6376;
};
SOURCE(6183, 76)
lab←L100070: ;
if ((valid←v12492 < xBits←v6404)) {
}
else {
goto lab←L100068;
};
SOURCE(6206, 30)
tw←v12464 = ((word) XRM←BITRSHIFT(sw←v6240, valid←v12492) + tw←v12464);
SOURCE(6238, 21)
valid←v12492 = (valid←v12492 + tBits←v6128);
goto lab←L100070;
lab←L100068: ;
SOURCE(6270, 42)
{
word dst←v13780;
word dstMod←v13808;
word w←v13836;
word bits←v13864;
dst←v13780 = dwp←v6432;
dstMod←v13808 = dShift←v6488;
w←v13836 = tw←v12464;
bits←v13864 = xBits←v6404;
if ((dstMod←v13808 != 0)) {
{
/*1*/ word dstLim←v13912;
/*1*/ word mask←v13940;
/*1*/ word dstW←v13968;
/*1*/ word tw←v13996;
/*1*/ dstLim←v13912 = (dstMod←v13808 + bits←v13864);
/*1*/ mask←v13940 = (word) XRM←BITRSHIFT( (word) -1, dstMod←v13808);
/*1*/ dstW←v13968 = (* (ptr) dst←v13780 );
/*1*/ tw←v13996 = (word) XRM←BITRSHIFT(w←v13836, dstMod←v13808);
SOURCE(10307, 56)
/*1*/ if ((dstLim←v13912 < 32)) {
SOURCE(10328, 35)
/*1*/ mask←v13940 = (mask←v13940 - (word) XRM←BITRSHIFT(mask←v13940, bits←v13864));
/*1*/ };
SOURCE(10365, 117)
SOURCE(10428, 20)
/*1*/ tw←v13996 = (word) XRM←BITOR(dstW←v13968, tw←v13996);
SOURCE(10484, 52)
/*1*/ {
/*1*/ word var←c16160;
/*1*/ word var←c0333;
/*1*/ var←c16160 = (word) XRM←BITNOT(mask←v13940);
/*1*/ var←c0333 = (word) XRM←BITAND(dstW←v13968, var←c16160);
/*1*/ (* (ptr) dst←v13780 ) = (var←c0333 + (word) XRM←BITAND(tw←v13996, mask←v13940));
/*1*/ };
SOURCE(10538, 295)
/*1*/ if ((dstLim←v13912 > 32)) {
SOURCE(10561, 43)
/*1*/ mask←v13940 = (word) XRM←BITRSHIFT( (word) -1, (dstLim←v13912 & 037));
SOURCE(10606, 17)
/*1*/ dstW←v13968 = (* (ptr) (dst←v13780 + 4) );
SOURCE(10625, 29)
/*1*/ tw←v13996 = (word) XRM←BITLSHIFT(w←v13836, (32 - dstMod←v13808));
SOURCE(10656, 117)
SOURCE(10719, 20)
/*1*/ tw←v13996 = (word) XRM←BITOR(dstW←v13968, tw←v13996);
SOURCE(10775, 58)
/*1*/ {
/*1*/ word var←c16192;
/*1*/ word var←c0334;
/*1*/ var←c16192 = (word) XRM←BITNOT(mask←v13940);
/*1*/ var←c0334 = (word) XRM←BITAND(tw←v13996, var←c16192);
/*1*/ (* (ptr) (dst←v13780 + 4) ) = (var←c0334 + (word) XRM←BITAND(dstW←v13968, mask←v13940));
/*1*/ };
/*1*/ };
/*1*/ };
}
else {
if ((bits←v13864 != 32)) {
/*1*/ {
/*1*/ word mask←v14040;
/*1*/ word dstW←v14068;
/*1*/ word tw←v14096;
/*1*/ mask←v14040 = (word) XRM←BITRSHIFT( (word) -1, bits←v13864);
/*1*/ dstW←v14068 = (* (ptr) dst←v13780 );
/*1*/ tw←v14096 = w←v13836;
SOURCE(10931, 117)
SOURCE(10994, 20)
/*1*/ tw←v14096 = (word) XRM←BITOR(dstW←v14068, tw←v14096);
SOURCE(11050, 52)
/*1*/ {
/*1*/ word var←c16224;
/*1*/ word var←c0335;
/*1*/ var←c16224 = (word) XRM←BITNOT(mask←v14040);
/*1*/ var←c0335 = (word) XRM←BITAND(tw←v14096, var←c16224);
/*1*/ (* (ptr) dst←v13780 ) = ((word) XRM←BITAND(dstW←v14068, mask←v14040) + var←c0335);
/*1*/ };
/*1*/ };
/*1*/ }
else {
SOURCE(11118, 126)
SOURCE(11188, 21)
/*1*/ (* (ptr) dst←v13780 ) = (word) XRM←BITOR((* (ptr) dst←v13780 ), w←v13836);
/*1*/ };
};
};
SOURCE(6314, 20)
if ((rem←v6376 == xBits←v6404)) {
SOURCE(6334, 4)
goto lab←L100066;
};
SOURCE(6340, 21)
shift←v6460 = (shift←v6460 + xBits←v6404);
SOURCE(6363, 45)
lab←L100073: ;
if ((shift←v6460 >= tBits←v6128)) {
}
else {
goto lab←L100071;
};
SOURCE(6387, 21)
shift←v6460 = (shift←v6460 - tBits←v6128);
goto lab←L100073;
lab←L100071: ;
SOURCE(6419, 15)
dwp←v6432 = (dwp←v6432 + 4);
SOURCE(6436, 10)
dShift←v6488 = 0;
SOURCE(6448, 17)
rem←v6376 = (rem←v6376 - xBits←v6404);
SOURCE(6467, 11)
xBits←v6404 = 32;
SOURCE(6480, 29)
if ((rem←v6376 < 32)) {
SOURCE(6498, 11)
xBits←v6404 = rem←v6376;
};
};
goto lab←L100067;
lab←L100066: ;
break;
default:
SOURCE(6634, 16)
SOURCE(6086, 423)
lab←L100076: ;
{
word tw←v12392;
word valid←v12420;
tw←v12392 = (word) XRM←BITLSHIFT(sw←v6240, shift←v6460);
valid←v12420 = (tBits←v6128 - shift←v6460);
SOURCE(6150, 31)
if ((rem←v6376 < xBits←v6404)) {
SOURCE(6170, 11)
xBits←v6404 = rem←v6376;
};
SOURCE(6183, 76)
lab←L100079: ;
if ((valid←v12420 < xBits←v6404)) {
}
else {
goto lab←L100077;
};
SOURCE(6206, 30)
tw←v12392 = ((word) XRM←BITRSHIFT(sw←v6240, valid←v12420) + tw←v12392);
SOURCE(6238, 21)
valid←v12420 = (valid←v12420 + tBits←v6128);
goto lab←L100079;
lab←L100077: ;
SOURCE(6270, 42)
{
word dst←v13420;
word dstMod←v13448;
word w←v13476;
word bits←v13504;
dst←v13420 = dwp←v6432;
dstMod←v13448 = dShift←v6488;
w←v13476 = tw←v12392;
bits←v13504 = xBits←v6404;
if ((dstMod←v13448 != 0)) {
{
/*1*/ word dstLim←v13552;
/*1*/ word mask←v13580;
/*1*/ word dstW←v13608;
/*1*/ word tw←v13636;
/*1*/ dstLim←v13552 = (dstMod←v13448 + bits←v13504);
/*1*/ mask←v13580 = (word) XRM←BITRSHIFT( (word) -1, dstMod←v13448);
/*1*/ dstW←v13608 = (* (ptr) dst←v13420 );
/*1*/ tw←v13636 = (word) XRM←BITRSHIFT(w←v13476, dstMod←v13448);
SOURCE(10307, 56)
/*1*/ if ((dstLim←v13552 < 32)) {
SOURCE(10328, 35)
/*1*/ mask←v13580 = (mask←v13580 - (word) XRM←BITRSHIFT(mask←v13580, bits←v13504));
/*1*/ };
SOURCE(10365, 117)
SOURCE(10461, 21)
/*1*/ tw←v13636 = (word) XRM←BITXOR(dstW←v13608, tw←v13636);
SOURCE(10484, 52)
/*1*/ {
/*1*/ word var←c16256;
/*1*/ word var←c0336;
/*1*/ var←c16256 = (word) XRM←BITNOT(mask←v13580);
/*1*/ var←c0336 = (word) XRM←BITAND(dstW←v13608, var←c16256);
/*1*/ (* (ptr) dst←v13420 ) = (var←c0336 + (word) XRM←BITAND(tw←v13636, mask←v13580));
/*1*/ };
SOURCE(10538, 295)
/*1*/ if ((dstLim←v13552 > 32)) {
SOURCE(10561, 43)
/*1*/ mask←v13580 = (word) XRM←BITRSHIFT( (word) -1, (dstLim←v13552 & 037));
SOURCE(10606, 17)
/*1*/ dstW←v13608 = (* (ptr) (dst←v13420 + 4) );
SOURCE(10625, 29)
/*1*/ tw←v13636 = (word) XRM←BITLSHIFT(w←v13476, (32 - dstMod←v13448));
SOURCE(10656, 117)
SOURCE(10752, 21)
/*1*/ tw←v13636 = (word) XRM←BITXOR(dstW←v13608, tw←v13636);
SOURCE(10775, 58)
/*1*/ {
/*1*/ word var←c16288;
/*1*/ word var←c0337;
/*1*/ var←c16288 = (word) XRM←BITNOT(mask←v13580);
/*1*/ var←c0337 = (word) XRM←BITAND(tw←v13636, var←c16288);
/*1*/ (* (ptr) (dst←v13420 + 4) ) = (var←c0337 + (word) XRM←BITAND(dstW←v13608, mask←v13580));
/*1*/ };
/*1*/ };
/*1*/ };
}
else {
if ((bits←v13504 != 32)) {
/*1*/ {
/*1*/ word mask←v13680;
/*1*/ word dstW←v13708;
/*1*/ word tw←v13736;
/*1*/ mask←v13680 = (word) XRM←BITRSHIFT( (word) -1, bits←v13504);
/*1*/ dstW←v13708 = (* (ptr) dst←v13420 );
/*1*/ tw←v13736 = w←v13476;
SOURCE(10931, 117)
SOURCE(11027, 21)
/*1*/ tw←v13736 = (word) XRM←BITXOR(dstW←v13708, tw←v13736);
SOURCE(11050, 52)
/*1*/ {
/*1*/ word var←c16320;
/*1*/ word var←c0338;
/*1*/ var←c16320 = (word) XRM←BITNOT(mask←v13680);
/*1*/ var←c0338 = (word) XRM←BITAND(tw←v13736, var←c16320);
/*1*/ (* (ptr) dst←v13420 ) = ((word) XRM←BITAND(dstW←v13708, mask←v13680) + var←c0338);
/*1*/ };
/*1*/ };
/*1*/ }
else {
SOURCE(11118, 126)
SOURCE(11222, 22)
/*1*/ (* (ptr) dst←v13420 ) = (word) XRM←BITXOR((* (ptr) dst←v13420 ), w←v13476);
/*1*/ };
};
};
SOURCE(6314, 20)
if ((rem←v6376 == xBits←v6404)) {
SOURCE(6334, 4)
goto lab←L100075;
};
SOURCE(6340, 21)
shift←v6460 = (shift←v6460 + xBits←v6404);
SOURCE(6363, 45)
lab←L100082: ;
if ((shift←v6460 >= tBits←v6128)) {
}
else {
goto lab←L100080;
};
SOURCE(6387, 21)
shift←v6460 = (shift←v6460 - tBits←v6128);
goto lab←L100082;
lab←L100080: ;
SOURCE(6419, 15)
dwp←v6432 = (dwp←v6432 + 4);
SOURCE(6436, 10)
dShift←v6488 = 0;
SOURCE(6448, 17)
rem←v6376 = (rem←v6376 - xBits←v6404);
SOURCE(6467, 11)
xBits←v6404 = 32;
SOURCE(6480, 29)
if ((rem←v6376 < 32)) {
SOURCE(6498, 11)
xBits←v6404 = rem←v6376;
};
};
goto lab←L100076;
lab←L100075: ;
break;
};
};
SOURCE(6652, 18)
if ((sSize←v6156 == 1)) {
SOURCE(6670, 4)
goto lab←L100045;
};
SOURCE(6676, 17)
sSize←v6156 = (sSize←v6156 - 1);
SOURCE(6695, 9)
{
word next←v6704;
next←v6704 = (srcBit←v5988 + (* (( (ptr) arg←v3648)+7) ));
SOURCE(4558, 21)
srcBit←v5988 = (next←v6704 & 037);
SOURCE(4581, 34)
src←v6016 = (src←v6016 + ((next←v6704 - srcBit←v5988) >> 3));
SOURCE(4617, 21)
tileLine←v5932 = (tileLine←v5932 + 1);
SOURCE(4640, 210)
if ((tileLine←v5932 == (* (( (ptr) arg←v3648)+9) ))) {
{
word phase←v6732;
phase←v6732 = (* (( (ptr) arg←v3648)+12) );
SOURCE(4699, 97)
if ((firstBit←v5960 < phase←v6732)) {
SOURCE(4724, 45)
firstBit←v5960 = (firstBit←v5960 + (fSizeTile←v6100 - phase←v6732));
}
else {
SOURCE(4769, 27)
firstBit←v5960 = (firstBit←v5960 - phase←v6732);
};
SOURCE(4798, 12)
tileLine←v5932 = 0;
SOURCE(4812, 19)
srcBit←v5988 = (* (( (ptr) arg←v3648)+6) );
SOURCE(4833, 17)
src←v6016 = (* (( (ptr) arg←v3648)+5) );
};
};
};
SOURCE(6706, 9)
{
word next←v6676;
next←v6676 = (dstBit←v6072 + (* (( (ptr) arg←v3648)+2) ));
SOURCE(4438, 21)
dstBit←v6072 = (next←v6676 & 037);
SOURCE(4461, 34)
dst←v6044 = (dst←v6044 + ((next←v6676 - dstBit←v6072) >> 3));
};
};
goto lab←L100046;
lab←L100045: ;
};
}
static void Fast3←P240(arg←v3708)
word arg←v3708;
{
word tileLine←v6872;
word firstBit←v6900;
word srcBit←v6928;
word src←v6956;
word dst←v6984;
word dstBit←v7012;
word fSizeTile←v7040;
word sSize←v7068;
/* Fast3: */
SOURCE(6733, 1027)
SOURCE(7245, 29)
tileLine←v6872 = (* (( (ptr) arg←v3708)+11) );
SOURCE(7276, 28)
firstBit←v6900 = (* (( (ptr) arg←v3708)+10) );
SOURCE(7306, 30)
srcBit←v6928 = (* (( (ptr) arg←v3708)+6) );
SOURCE(7338, 26)
src←v6956 = (* (( (ptr) arg←v3708)+5) );
SOURCE(7366, 26)
dst←v6984 = (* (ptr) arg←v3708 );
SOURCE(7394, 30)
dstBit←v7012 = (* (( (ptr) arg←v3708)+1) );
SOURCE(7426, 30)
fSizeTile←v7040 = (* (( (ptr) arg←v3708)+8) );
SOURCE(7458, 22)
sSize←v7068 = (* (( (ptr) arg←v3708)+4) );
SOURCE(7482, 278)
if ( ( (sSize←v7068 != 0) ? ((* (( (ptr) arg←v3708)+3) ) != 0) : 0 ) ) {
SOURCE(7520, 120)
if ((tileLine←v6872 != 0)) {
SOURCE(7541, 101)
{
word next←v7144;
SOURCE(7543, 40)
next←v7144 = (srcBit←v6928 + (tileLine←v6872 * (* (( (ptr) arg←v3708)+7) )));
SOURCE(7585, 21)
srcBit←v6928 = (next←v7144 & 037);
SOURCE(7608, 32)
src←v6956 = (src←v6956 + ((next←v7144 - srcBit←v6928) >> 3));
};
};
SOURCE(7645, 115)
lab←L100085: ;
SOURCE(7648, 47)
(void) DoLine←P300(arg←v3708, dst←v6984, dstBit←v7012, src←v6956, srcBit←v6928, firstBit←v6900);
SOURCE(7697, 18)
if ((sSize←v7068 == 1)) {
SOURCE(7715, 4)
goto lab←L100084;
};
SOURCE(7721, 17)
sSize←v7068 = (sSize←v7068 - 1);
SOURCE(7740, 9)
{
word next←v7216;
next←v7216 = (srcBit←v6928 + (* (( (ptr) arg←v3708)+7) ));
SOURCE(6945, 21)
srcBit←v6928 = (next←v7216 & 037);
SOURCE(6968, 34)
src←v6956 = (src←v6956 + ((next←v7216 - srcBit←v6928) >> 3));
SOURCE(7004, 21)
tileLine←v6872 = (tileLine←v6872 + 1);
SOURCE(7027, 210)
if ((tileLine←v6872 == (* (( (ptr) arg←v3708)+9) ))) {
{
word phase←v7244;
phase←v7244 = (* (( (ptr) arg←v3708)+12) );
SOURCE(7086, 97)
if ((firstBit←v6900 < phase←v7244)) {
SOURCE(7111, 45)
firstBit←v6900 = (firstBit←v6900 + (fSizeTile←v7040 - phase←v7244));
}
else {
SOURCE(7156, 27)
firstBit←v6900 = (firstBit←v6900 - phase←v7244);
};
SOURCE(7185, 12)
tileLine←v6872 = 0;
SOURCE(7199, 19)
srcBit←v6928 = (* (( (ptr) arg←v3708)+6) );
SOURCE(7220, 17)
src←v6956 = (* (( (ptr) arg←v3708)+5) );
};
};
};
SOURCE(7751, 9)
{
word next←v7188;
next←v7188 = (dstBit←v7012 + (* (( (ptr) arg←v3708)+2) ));
SOURCE(6825, 21)
dstBit←v7012 = (next←v7188 & 037);
SOURCE(6848, 34)
dst←v6984 = (dst←v6984 + ((next←v7188 - dstBit←v7012) >> 3));
};
goto lab←L100085;
lab←L100084: ;
};
}
static void DoLine←P300(arg←v3768, formal←c0347, formal←c0348, formal←c0349, formal←c0350, firstBit←v3908)
word arg←v3768;
word formal←c0347;
word formal←c0348;
word formal←c0349;
word formal←c0350;
word firstBit←v3908;
{
W16 var←c17216;
/* declaration of dwp←v3796 skipped */
/* declaration of dstPos←v3824 skipped */
/* declaration of src←v3852 skipped */
/* declaration of srcBit←v3880 skipped */
/* declaration of var←c16352 skipped */
/* declaration of invert←v7272 skipped */
/* declaration of dstRem←v7300 skipped */
/* declaration of fSizeTile←v7328 skipped */
/* declaration of srcRem←v7356 skipped */
/* declaration of srcPos←v7384 skipped */
/* declaration of swp←v7412 skipped */
(* (( (ptr) &var←c17216)+4)/* dwp←v3796 */ ) = formal←c0347;
(* (( (ptr) &var←c17216)+5)/* dstPos←v3824 */ ) = formal←c0348;
(* (( (ptr) &var←c17216)+6)/* src←v3852 */ ) = formal←c0349;
(* (( (ptr) &var←c17216)+7)/* srcBit←v3880 */ ) = formal←c0350;
/* DoLine: */
SOURCE(7778, 2057)
{
word tmpAddr3;
tmpAddr3 = (word) (( (ptr) &var←c17216)+8)/* var←c16352 */ ;
(* (ptr) tmpAddr3 ) = ( ((word) (fPt) WithFunction←P1968) );
(* (( (ptr) tmpAddr3) + 1) ) = 1;
};
SOURCE(7887, 28)
(* (( (ptr) &var←c17216)+10)/* invert←v7272 */ ) = (* (( (ptr) arg←v3768)+13) );
SOURCE(7917, 23)
(* (( (ptr) &var←c17216)+11)/* dstRem←v7300 */ ) = (* (( (ptr) arg←v3768)+3) );
SOURCE(7942, 30)
(* (( (ptr) &var←c17216)+12)/* fSizeTile←v7328 */ ) = (* (( (ptr) arg←v3768)+8) );
SOURCE(7974, 32)
(* (( (ptr) &var←c17216)+13)/* srcRem←v7356 */ ) = ((* (( (ptr) &var←c17216)+12)/* fSizeTile←v7328 */ ) - firstBit←v3908);
SOURCE(8008, 45)
(* (( (ptr) &var←c17216)+14)/* srcPos←v7384 */ ) = ((firstBit←v3908 + (* (( (ptr) &var←c17216)+7)/* srcBit←v3880 */ )) & 037);
SOURCE(8055, 58)
(* (( (ptr) &var←c17216)+15)/* swp←v7412 */ ) = ((* (( (ptr) &var←c17216)+6)/* src←v3852 */ ) + (((firstBit←v3908 + (* (
( (ptr) &var←c17216)+7)/* srcBit←v3880 */ )) - (* (( (ptr) &var←c17216)+14)/* srcPos←v7384 */ )) >> 3));
SOURCE(9705, 130)
{
word var←c16384;
var←c16384 = (* (( (ptr) arg←v3768)+14) );
switch (var←c16384) {
case 0:
SOURCE(9737, 18)
(void) WithFunction←P1968(0, (word) (( (bPt) &var←c17216)+32)/* var←c16352 */ );
break;
case 1:
SOURCE(9764, 17)
(void) WithFunction←P1968(1, (word) (( (bPt) &var←c17216)+32)/* var←c16352 */ );
break;
case 2:
SOURCE(9789, 16)
(void) WithFunction←P1968(2, (word) (( (bPt) &var←c17216)+32)/* var←c16352 */ );
break;
default:
SOURCE(9818, 17)
(void) WithFunction←P1968(3, (word) (( (bPt) &var←c17216)+32)/* var←c16352 */ );
break;
};
};
}
static void WithFunction←P1968(df←v7516, formal←c17248)
word df←v7516;
word formal←c17248;
{
formal←c17248 = (formal←c17248 - 32);
/* WithFunction: */
SOURCE(8115, 1576)
SOURCE(8163, 1528)
lab←L100088: ;
SOURCE(8163, 1528)
{
word next←v7544;
word sw←v7572;
word xBits←v7600;
SOURCE(8177, 31)
sw←v7572 = (word) XRM←BITXOR((* (ptr) (* (( (ptr) formal←c17248)+15) ) ), (* (( (ptr) formal←c17248)+10) ));
SOURCE(8210, 28)
xBits←v7600 = (32 - (* (( (ptr) formal←c17248)+5) ));
SOURCE(8240, 37)
if (((* (( (ptr) formal←c17248)+11) ) < xBits←v7600)) {
SOURCE(8263, 14)
xBits←v7600 = (* (( (ptr) formal←c17248)+11) );
};
SOURCE(8280, 541)
if (((* (( (ptr) formal←c17248)+13) ) < xBits←v7600)) {
SOURCE(8305, 136)
if (((* (( (ptr) formal←c17248)+14) ) != 0)) {
SOURCE(8326, 26)
sw←v7572 = (word) XRM←BITLSHIFT(sw←v7572, (* (( (ptr) formal←c17248)+14) ));
SOURCE(8354, 87)
if ((((* (( (ptr) formal←c17248)+14) ) + (* (( (ptr) formal←c17248)+13) )) > 32)) {
SOURCE(8382, 59)
{
word var←c16416;
word var←c0339;
var←c16416 = (word) XRM←BITXOR((* (ptr) ((* (( (ptr) formal←c17248)+15) ) + 4) ), (* (( (ptr) formal←c17248)+10) ));
var←c0339 = (word) XRM←BITRSHIFT(var←c16416, (32 - (* (( (ptr) formal←c17248)+14) )));
sw←v7572 = (sw←v7572 + var←c0339);
};
};
};
SOURCE(8446, 110)
{
word var←c16448;
word var←c0340;
word var←c16480;
var←c16448 = (word) XRM←BITLSHIFT( (word) -1, (32 - (* (( (ptr) formal←c17248)+13) )));
var←c0340 = (word) XRM←BITAND(sw←v7572, var←c16448);
{
word var←c16512;
var←c16512 = (word) XRM←BITXOR((* (ptr) (* (( (ptr) formal←c17248)+6) ) ), (* (( (ptr) formal←c17248)+10) ));
var←c16480 = (word) XRM←BITLSHIFT(var←c16512, (* (( (ptr) formal←c17248)+7) ));
};
sw←v7572 = (var←c0340 + (word) XRM←BITRSHIFT(var←c16480, (* (( (ptr) formal←c17248)+13) )));
};
SOURCE(8558, 17)
next←v7544 = (32 - (* (( (ptr) formal←c17248)+7) ));
SOURCE(8577, 41)
if (((* (( (ptr) formal←c17248)+12) ) < next←v7544)) {
SOURCE(8602, 16)
next←v7544 = (* (( (ptr) formal←c17248)+12) );
};
SOURCE(8620, 20)
next←v7544 = ((* (( (ptr) formal←c17248)+13) ) + next←v7544);
SOURCE(8642, 33)
if ((next←v7544 < xBits←v7600)) {
SOURCE(8663, 12)
xBits←v7600 = next←v7544;
};
}
else {
SOURCE(8686, 135)
if (((* (( (ptr) formal←c17248)+14) ) != 0)) {
SOURCE(8707, 26)
sw←v7572 = (word) XRM←BITLSHIFT(sw←v7572, (* (( (ptr) formal←c17248)+14) ));
SOURCE(8735, 86)
if ((((* (( (ptr) formal←c17248)+14) ) + xBits←v7600) > 32)) {
SOURCE(8762, 59)
{
word var←c16544;
word var←c0341;
var←c16544 = (word) XRM←BITXOR((* (ptr) ((* (( (ptr) formal←c17248)+15) ) + 4) ), (* (( (ptr) formal←c17248)+10) ));
var←c0341 = (word) XRM←BITRSHIFT(var←c16544, (32 - (* (( (ptr) formal←c17248)+14) )));
sw←v7572 = (sw←v7572 + var←c0341);
};
};
};
};
SOURCE(8830, 620)
if ((xBits←v7600 == 32)) {
SOURCE(8852, 130)
{
word var←c16576;
var←c16576 = df←v7516;
switch (var←c16576) {
case 0:
SOURCE(8875, 9)
(* (ptr) (* (( (ptr) formal←c17248)+4) ) ) = sw←v7572;
break;
case 1:
SOURCE(8893, 23)
{
word var←c16608;
var←c16608 = (word) XRM←BITAND((* (ptr) (* (( (ptr) formal←c17248)+4) ) ), sw←v7572);
(* (ptr) (* (( (ptr) formal←c17248)+4) ) ) = var←c16608;
};
break;
case 2:
SOURCE(8924, 22)
{
word var←c16640;
var←c16640 = (word) XRM←BITOR((* (ptr) (* (( (ptr) formal←c17248)+4) ) ), sw←v7572);
(* (ptr) (* (( (ptr) formal←c17248)+4) ) ) = var←c16640;
};
break;
default:
SOURCE(8959, 23)
{
word var←c16672;
var←c16672 = (word) XRM←BITXOR((* (ptr) (* (( (ptr) formal←c17248)+4) ) ), sw←v7572);
(* (ptr) (* (( (ptr) formal←c17248)+4) ) ) = var←c16672;
};
break;
};
};
SOURCE(8984, 23)
if ((xBits←v7600 == (* (( (ptr) formal←c17248)+11) ))) {
SOURCE(9007, 4)
goto lab←L100087;
};
SOURCE(9013, 15)
(* (( (ptr) formal←c17248)+4) ) = ((* (( (ptr) formal←c17248)+4) ) + 4);
SOURCE(9030, 23)
(* (( (ptr) formal←c17248)+11) ) = ((* (( (ptr) formal←c17248)+11) ) - xBits←v7600);
SOURCE(9055, 65)
if (((* (( (ptr) formal←c17248)+13) ) > xBits←v7600)) {
SOURCE(9080, 15)
(* (( (ptr) formal←c17248)+15) ) = ((* (( (ptr) formal←c17248)+15) ) + 4);
SOURCE(9097, 23)
(* (( (ptr) formal←c17248)+13) ) = ((* (( (ptr) formal←c17248)+13) ) - xBits←v7600);
SOURCE(9122, 4)
goto lab←L100088;
};
}
else {
SOURCE(9140, 42)
{
word dst←v12672;
word dstMod←v12700;
word w←v12728;
word bits←v12756;
word df←v12784;
dst←v12672 = (* (( (ptr) formal←c17248)+4) );
dstMod←v12700 = (* (( (ptr) formal←c17248)+5) );
w←v12728 = sw←v7572;
bits←v12756 = xBits←v7600;
df←v12784 = df←v7516;
if ((dstMod←v12700 != 0)) {
{
word dstLim←v12832;
word mask←v12860;
word dstW←v12888;
word tw←v12916;
dstLim←v12832 = (dstMod←v12700 + bits←v12756);
mask←v12860 = (word) XRM←BITRSHIFT( (word) -1, dstMod←v12700);
dstW←v12888 = (* (ptr) dst←v12672 );
tw←v12916 = (word) XRM←BITRSHIFT(w←v12728, dstMod←v12700);
SOURCE(10307, 56)
if ((dstLim←v12832 < 32)) {
SOURCE(10328, 35)
mask←v12860 = (mask←v12860 - (word) XRM←BITRSHIFT(mask←v12860, bits←v12756));
};
SOURCE(10365, 117)
{
word var←c16704;
var←c16704 = df←v12784;
switch (var←c16704) {
case 0:
break;
case 1:
SOURCE(10399, 21)
tw←v12916 = (word) XRM←BITAND(dstW←v12888, tw←v12916);
break;
case 2:
SOURCE(10428, 20)
tw←v12916 = (word) XRM←BITOR(dstW←v12888, tw←v12916);
break;
default:
SOURCE(10461, 21)
tw←v12916 = (word) XRM←BITXOR(dstW←v12888, tw←v12916);
break;
};
};
SOURCE(10484, 52)
{
word var←c16736;
word var←c0342;
var←c16736 = (word) XRM←BITNOT(mask←v12860);
var←c0342 = (word) XRM←BITAND(dstW←v12888, var←c16736);
(* (ptr) dst←v12672 ) = (var←c0342 + (word) XRM←BITAND(tw←v12916, mask←v12860));
};
SOURCE(10538, 295)
if ((dstLim←v12832 > 32)) {
SOURCE(10561, 43)
mask←v12860 = (word) XRM←BITRSHIFT( (word) -1, (dstLim←v12832 & 037));
SOURCE(10606, 17)
dstW←v12888 = (* (ptr) (dst←v12672 + 4) );
SOURCE(10625, 29)
tw←v12916 = (word) XRM←BITLSHIFT(w←v12728, (32 - dstMod←v12700));
SOURCE(10656, 117)
{
word var←c16768;
var←c16768 = df←v12784;
switch (var←c16768) {
case 0:
/*1*/ break;
case 1:
SOURCE(10690, 21)
/*1*/ tw←v12916 = (word) XRM←BITAND(dstW←v12888, tw←v12916);
/*1*/ break;
case 2:
SOURCE(10719, 20)
/*1*/ tw←v12916 = (word) XRM←BITOR(dstW←v12888, tw←v12916);
/*1*/ break;
default:
SOURCE(10752, 21)
/*1*/ tw←v12916 = (word) XRM←BITXOR(dstW←v12888, tw←v12916);
/*1*/ break;
};
};
SOURCE(10775, 58)
{
word var←c16800;
word var←c0343;
var←c16800 = (word) XRM←BITNOT(mask←v12860);
var←c0343 = (word) XRM←BITAND(tw←v12916, var←c16800);
(* (ptr) (dst←v12672 + 4) ) = (var←c0343 + (word) XRM←BITAND(dstW←v12888, mask←v12860));
};
};
};
}
else {
if ((bits←v12756 != 32)) {
{
word mask←v12960;
word dstW←v12988;
word tw←v13016;
mask←v12960 = (word) XRM←BITRSHIFT( (word) -1, bits←v12756);
dstW←v12988 = (* (ptr) dst←v12672 );
tw←v13016 = w←v12728;
SOURCE(10931, 117)
{
word var←c16832;
var←c16832 = df←v12784;
switch (var←c16832) {
case 0:
/*1*/ break;
case 1:
SOURCE(10965, 21)
/*1*/ tw←v13016 = (word) XRM←BITAND(dstW←v12988, tw←v13016);
/*1*/ break;
case 2:
SOURCE(10994, 20)
/*1*/ tw←v13016 = (word) XRM←BITOR(dstW←v12988, tw←v13016);
/*1*/ break;
default:
SOURCE(11027, 21)
/*1*/ tw←v13016 = (word) XRM←BITXOR(dstW←v12988, tw←v13016);
/*1*/ break;
};
};
SOURCE(11050, 52)
{
word var←c16864;
word var←c0344;
var←c16864 = (word) XRM←BITNOT(mask←v12960);
var←c0344 = (word) XRM←BITAND(tw←v13016, var←c16864);
(* (ptr) dst←v12672 ) = ((word) XRM←BITAND(dstW←v12988, mask←v12960) + var←c0344);
};
};
}
else {
SOURCE(11118, 126)
{
word var←c16896;
var←c16896 = df←v12784;
switch (var←c16896) {
case 0:
SOURCE(11141, 8)
(* (ptr) dst←v12672 ) = w←v12728;
break;
case 1:
SOURCE(11158, 22)
(* (ptr) dst←v12672 ) = (word) XRM←BITAND((* (ptr) dst←v12672 ), w←v12728);
break;
case 2:
SOURCE(11188, 21)
(* (ptr) dst←v12672 ) = (word) XRM←BITOR((* (ptr) dst←v12672 ), w←v12728);
break;
default:
SOURCE(11222, 22)
(* (ptr) dst←v12672 ) = (word) XRM←BITXOR((* (ptr) dst←v12672 ), w←v12728);
break;
};
};
};
};
};
SOURCE(9184, 23)
if ((xBits←v7600 == (* (( (ptr) formal←c17248)+11) ))) {
SOURCE(9207, 4)
goto lab←L100087;
};
SOURCE(9213, 19)
next←v7544 = ((* (( (ptr) formal←c17248)+5) ) + xBits←v7600);
SOURCE(9234, 21)
(* (( (ptr) formal←c17248)+5) ) = (next←v7544 & 037);
SOURCE(9257, 36)
(* (( (ptr) formal←c17248)+4) ) = ((* (( (ptr) formal←c17248)+4) ) + ((next←v7544 - (* (( (ptr) formal←c17248)+5) )) >> 3));
SOURCE(9295, 23)
(* (( (ptr) formal←c17248)+11) ) = ((* (( (ptr) formal←c17248)+11) ) - xBits←v7600);
SOURCE(9320, 130)
if (((* (( (ptr) formal←c17248)+13) ) > xBits←v7600)) {
SOURCE(9345, 19)
next←v7544 = ((* (( (ptr) formal←c17248)+14) ) + xBits←v7600);
SOURCE(9366, 21)
(* (( (ptr) formal←c17248)+14) ) = (next←v7544 & 037);
SOURCE(9389, 36)
(* (( (ptr) formal←c17248)+15) ) = ((* (( (ptr) formal←c17248)+15) ) + ((next←v7544 - (* (( (ptr) formal←c17248)+14) )) >> 3));
SOURCE(9427, 23)
(* (( (ptr) formal←c17248)+13) ) = ((* (( (ptr) formal←c17248)+13) ) - xBits←v7600);
SOURCE(9452, 4)
goto lab←L100088;
};
};
SOURCE(9464, 172)
if (((* (( (ptr) formal←c17248)+13) ) < xBits←v7600)) {
SOURCE(9489, 21)
next←v7544 = (xBits←v7600 - (* (( (ptr) formal←c17248)+13) ));
SOURCE(9512, 25)
(* (( (ptr) formal←c17248)+13) ) = ((* (( (ptr) formal←c17248)+12) ) - next←v7544);
SOURCE(9539, 20)
next←v7544 = ((* (( (ptr) formal←c17248)+7) ) + next←v7544);
SOURCE(9561, 21)
(* (( (ptr) formal←c17248)+14) ) = (next←v7544 & 037);
SOURCE(9584, 31)
(* (( (ptr) formal←c17248)+15) ) = ((* (( (ptr) formal←c17248)+6) ) + IOP2( / , (int)(next←v7544 - (* (( (ptr) formal←c17248)+14)
)), (int)8));
SOURCE(9617, 19)
if (((* (( (ptr) formal←c17248)+13) ) != 0)) {
SOURCE(9636, 4)
goto lab←L100088;
};
};
SOURCE(9645, 9)
(* (( (ptr) formal←c17248)+15) ) = (* (( (ptr) formal←c17248)+6) );
SOURCE(9656, 15)
(* (( (ptr) formal←c17248)+14) ) = (* (( (ptr) formal←c17248)+7) );
SOURCE(9673, 18)
(* (( (ptr) formal←c17248)+13) ) = (* (( (ptr) formal←c17248)+12) );
};
goto lab←L100088;
lab←L100087: ;
}
static void DumbOp←P480(arg←v4256)
word arg←v4256;
{
word tileLine←v7840;
word adjustedFirstBit←v7868;
word src←v7896;
word dst←v7924;
word dstBpl←v7952;
word dstBit←v7980;
word srcBpl←v8008;
word phase←v8036;
word fSize←v8064;
word fSizeTile←v8092;
word sSizeTile←v8120;
word sSize←v8148;
word srcBit←v8176;
word invert←v8204;
word df←v8232;
/* DumbOp: */
SOURCE(11250, 1597)
SOURCE(11302, 29)
tileLine←v7840 = (* (( (ptr) arg←v4256)+11) );
SOURCE(11333, 36)
adjustedFirstBit←v7868 = (* (( (ptr) arg←v4256)+10) );
SOURCE(11371, 36)
src←v7896 = (* (( (ptr) arg←v4256)+5) );
SOURCE(11409, 36)
dst←v7924 = (* (ptr) arg←v4256 );
SOURCE(11447, 24)
dstBpl←v7952 = (* (( (ptr) arg←v4256)+2) );
SOURCE(11473, 24)
dstBit←v7980 = (* (( (ptr) arg←v4256)+1) );
SOURCE(11499, 24)
srcBpl←v8008 = (* (( (ptr) arg←v4256)+7) );
SOURCE(11525, 22)
phase←v8036 = (* (( (ptr) arg←v4256)+12) );
SOURCE(11549, 22)
fSize←v8064 = (* (( (ptr) arg←v4256)+3) );
SOURCE(11573, 30)
fSizeTile←v8092 = (* (( (ptr) arg←v4256)+8) );
SOURCE(11605, 30)
sSizeTile←v8120 = (* (( (ptr) arg←v4256)+9) );
SOURCE(11637, 22)
sSize←v8148 = (* (( (ptr) arg←v4256)+4) );
SOURCE(11661, 40)
srcBit←v8176 = ((* (( (ptr) arg←v4256)+6) ) + (srcBpl←v8008 * tileLine←v7840));
SOURCE(11703, 28)
invert←v8204 = (* (( (ptr) arg←v4256)+13) );
SOURCE(11733, 25)
df←v8232 = (* (( (ptr) arg←v4256)+14) );
SOURCE(11779, 48)
if (((* (( (ptr) arg←v4256)+10) ) >= fSizeTile←v8092)) {
SOURCE(11813, 14)
(void) BadAssertion←P660();
};
SOURCE(11829, 45)
if (((* (( (ptr) arg←v4256)+12) ) >= fSizeTile←v8092)) {
SOURCE(11860, 14)
(void) BadAssertion←P660();
};
SOURCE(11876, 53)
if (((* (( (ptr) arg←v4256)+11) ) >= (* (( (ptr) arg←v4256)+9) ))) {
SOURCE(11915, 14)
(void) BadAssertion←P660();
};
SOURCE(11934, 45)
if (((* (( (ptr) arg←v4256)+3) ) == 0) || ((* (( (ptr) arg←v4256)+4) ) == 0)) {
SOURCE(11973, 6)
return;
};
SOURCE(11981, 866)
{
register word s←v8276 = 0;
register word noName←c16928;
noName←c16928 = (* (( (ptr) arg←v4256)+4) );
if ((s←v8276 >= noName←c16928)) {
goto lab←L100089;
};
lab←L100092: ;
{
word dstLim←v8320;
word tileBit←v8348;
word dBit←v8376;
SOURCE(12013, 26)
dstLim←v8320 = (dstBit←v7980 + fSize←v8064);
SOURCE(12041, 31)
tileBit←v8348 = adjustedFirstBit←v7868;
SOURCE(12074, 18)
dBit←v8376 = dstBit←v7980;
SOURCE(12094, 464)
lab←L100095: ;
SOURCE(12094, 464)
{
word sBit←v8420;
word mod←v8448;
word sw←v8476;
word sb←v8504;
SOURCE(12097, 26)
sBit←v8420 = (srcBit←v8176 + tileBit←v8348);
SOURCE(12125, 29)
mod←v8448 = (sBit←v8420 & 037);
SOURCE(12156, 52)
sw←v8476 = (word) XRM←BITXOR((* (ptr) (src←v7896 + IOP2( / , (int)(sBit←v8420 - mod←v8448), (int)8)) ), invert←v8204);
SOURCE(12210, 48)
{
word var←c16960;
var←c16960 = (word) XRM←BITLSHIFT(sw←v8476, mod←v8448);
sb←v8504 = (word) XRM←BITRSHIFT(var←c16960, 31);
};
SOURCE(12260, 188)
{
word var←c16992;
var←c16992 = df←v8232;
switch (var←c16992) {
case 0:
SOURCE(12283, 14)
{
word x4;
word x5;
x4 = (word) (( (ptr) dst←v7924) + (dBit←v8376 >> 5));
x5 = 32 - ((dBit←v8376 & 037)+1);
(* (ptr) x4 ) = ((* (ptr) x4 ) & ( ~ (1 << x5))) | (((sb←v8504 & 1)) << x5);
};
break;
case 1:
SOURCE(12306, 33)
{
word var←c17024;
var←c17024 = (word) XRM←BITAND((((* (ptr) (( (ptr) dst←v7924) + (dBit←v8376 >> 5)) ) >> (31 - ((dBit←v8376 & 037)))) & 1), sb←v8504)
;
{
word x6;
word x7;
x6 = (word) (( (ptr) dst←v7924) + (dBit←v8376 >> 5));
x7 = 32 - ((dBit←v8376 & 037)+1);
(* (ptr) x6 ) = ((* (ptr) x6 ) & ( ~ (1 << x7))) | (((var←c17024 & 1)) << x7);
};
};
break;
case 2:
SOURCE(12347, 32)
{
word var←c17056;
var←c17056 = (word) XRM←BITOR((((* (ptr) (( (ptr) dst←v7924) + (dBit←v8376 >> 5)) ) >> (31 - ((dBit←v8376 & 037)))) & 1), sb←v8504)
;
{
word x8;
word x9;
x8 = (word) (( (ptr) dst←v7924) + (dBit←v8376 >> 5));
x9 = 32 - ((dBit←v8376 & 037)+1);
(* (ptr) x8 ) = ((* (ptr) x8 ) & ( ~ (1 << x9))) | (((var←c17056 & 1)) << x9);
};
};
break;
case 3:
SOURCE(12388, 33)
{
word var←c17088;
var←c17088 = (word) XRM←BITXOR((((* (ptr) (( (ptr) dst←v7924) + (dBit←v8376 >> 5)) ) >> (31 - ((dBit←v8376 & 037)))) & 1), sb←v8504)
;
{
word x10;
word x11;
x10 = (word) (( (ptr) dst←v7924) + (dBit←v8376 >> 5));
x11 = 32 - ((dBit←v8376 & 037)+1);
(* (ptr) x10 ) = ((* (ptr) x10 ) & ( ~ (1 << x11))) | (((var←c17088 & 1)) << x11);
};
};
break;
default:
SOURCE(12434, 14)
(void) BadAssertion←P660();
break;
};
};
SOURCE(12450, 15)
dBit←v8376 = (dBit←v8376 + 1);
SOURCE(12467, 22)
if ((dBit←v8376 == dstLim←v8320)) {
SOURCE(12489, 4)
goto lab←L100094;
};
SOURCE(12495, 21)
tileBit←v8348 = (tileBit←v8348 + 1);
SOURCE(12518, 40)
if ((tileBit←v8348 >= fSizeTile←v8092)) {
SOURCE(12547, 11)
tileBit←v8348 = 0;
};
};
goto lab←L100095;
lab←L100094: ;
SOURCE(12569, 24)
dstBit←v7980 = (dstBit←v7980 + dstBpl←v7952);
SOURCE(12595, 24)
srcBit←v8176 = (srcBit←v8176 + srcBpl←v8008);
SOURCE(12621, 21)
tileLine←v7840 = (tileLine←v7840 + 1);
SOURCE(12644, 203)
if ((tileLine←v7840 == sSizeTile←v8120)) {
SOURCE(12675, 137)
if ((adjustedFirstBit←v7868 < phase←v8036)) {
SOURCE(12708, 61)
adjustedFirstBit←v7868 = (adjustedFirstBit←v7868 + (fSizeTile←v8092 - phase←v8036));
}
else {
SOURCE(12769, 43)
adjustedFirstBit←v7868 = (adjustedFirstBit←v7868 - phase←v8036);
};
SOURCE(12814, 12)
tileLine←v7840 = 0;
SOURCE(12828, 19)
srcBit←v8176 = (* (( (ptr) arg←v4256)+6) );
};
};
s←v8276 = (s←v8276 + 1);
if ((s←v8276 < noName←c16928)) {
goto lab←L100092;
};
lab←L100089: ;
};
}
static word FunnyOp←P540(dw←v4316, sw←v4344, op←v4372)
word dw←v4316;
word sw←v4344;
word op←v4372;
{
word var←c4416;
word m1←v8548;
word m2←v8576;
word m3←v8604;
word w1←v8632;
word w2←v8660;
word w3←v8688;
word w4←v8716;
word w5←v8744;
word w6←v8772;
/* FunnyOp: */
SOURCE(12865, 404)
SOURCE(12934, 55)
m1←v8548 = ( ((op←v4372 == 1) || (op←v4372 == 2)) ? (word) -1 : 0 ) ;
SOURCE(12991, 44)
m2←v8576 = ( (op←v4372 != 1) ? (word) -1 : 0 ) ;
SOURCE(13037, 55)
m3←v8604 = ( ((op←v4372 == 2) || (op←v4372 == 3)) ? (word) -1 : 0 ) ;
SOURCE(13096, 25)
w1←v8632 = (word) XRM←BITAND(sw←v4344, m1←v8548);
SOURCE(13123, 25)
w2←v8660 = (word) XRM←BITAND(sw←v4344, m2←v8576);
SOURCE(13150, 25)
w3←v8688 = (word) XRM←BITAND(dw←v4316, m3←v8604);
SOURCE(13177, 25)
w4←v8716 = (word) XRM←BITXOR(w2←v8660, w3←v8688);
SOURCE(13204, 25)
w5←v8744 = (word) XRM←BITAND(dw←v4316, w1←v8632);
SOURCE(13231, 24)
w6←v8772 = (word) XRM←BITOR(w4←v8716, w5←v8744);
SOURCE(13258, 11)
return(w6←v8772);
}
static void BadAssertion←P660()
{
register ptr gf←c17280 = (ptr) &globalframe;
/* BadAssertion: */
SOURCE(13847, 44)
SOURCE(13870, 21)
(void) XR←RaiseError((word) (( (bPt) gf←c17280)+280)/* var←c14304 */ , 0);
}
static void InitReplicatorArray←P720()
{
register ptr gf←c17312 = (ptr) &globalframe;
/* InitReplicatorArray: */
SOURCE(13928, 442)
SOURCE(13958, 26)
(* (( (ptr) gf←c17312)+4) ) = 0;
SOURCE(13986, 26)
(* (( (ptr) gf←c17312)+37) ) = 0;
SOURCE(14014, 34)
(* (( (ptr) gf←c17312)+5) ) = (word) -1;
SOURCE(14050, 28)
(* (( (ptr) gf←c17312)+38) ) = 32;
SOURCE(14080, 28)
(* (( (ptr) gf←c17312)+36) ) = 1;
SOURCE(14110, 28)
(* (( (ptr) gf←c17312)+69) ) = 1;
SOURCE(14140, 230)
{
register word i←v8816 = 2;
lab←L100099: ;
{
word t←v8860;
word tt←v8888 = 0;
SOURCE(14166, 59)
t←v8860 = ((word) XRM←BITRSHIFT( (word) -1, (i←v8816 - 1)) - (word) XRM←BITRSHIFT( (word) -1, i←v8816));
SOURCE(14241, 47)
lab←L100102: ;
if ((t←v8860 != 0)) {
}
else {
goto lab←L100100;
};
SOURCE(14256, 11)
tt←v8888 = (tt←v8888 + t←v8860);
SOURCE(14269, 19)
t←v8860 = (word) XRM←BITRSHIFT(t←v8860, i←v8816);
goto lab←L100102;
lab←L100100: ;
SOURCE(14299, 27)
(* ((( (ptr) gf←c17312)+4)/* replicatorMultArray←v3140 */ +i←v8816) ) = tt←v8888;
SOURCE(14328, 42)
(* ((( (ptr) gf←c17312)+37)/* replicatorBitsArray←v3168 */ +i←v8816) ) = (32 - (32 % i←v8816));
};
if ((i←v8816 >= 31)) {
goto lab←L100096;
};
i←v8816 = (i←v8816 + 1);
goto lab←L100099;
lab←L100096: ;
};
}
/* file: UnsafeTileImpl, module: UnsafeTileImpl, compiled at: February 21, 1992 11:34:28 pm PST */
extern void XR←install←UnsafeTileImpl() {
NoName←Q4620();
}
extern void XR←run←UnsafeTileImpl() { XR←Start(&globalframe); }