/* Generated with C2C (Cedar To C)*/
/* Copyright (C) 1994 by Xerox Corporation. All rights reserved. */
/* time: March 9, 1994 11:51:54 am PST */
/* C2C version: January 12, 1994 (sun4) */
/* ref-counting: off */
/* file: ImagerSampleImpl, module: ImagerSampleImpl */
/* switches: bcfhklnouw */
#include <cedar/InstallationSupport.h>
#include <cedar/CedarExtra.h>
#define XRM←BITNOT(x) (~((word)(x)))
#define XRM←BITAND(x, y) (((word)(x)) & ((word)(y)))
#define XRM←BITOR(x, y) (((word)(x)) | ((word)(y)))
#define XRM←BITXOR(x, y) (((word)(x)) ↑ ((word)(y)))
#define XRM←BITRSHIFT(x, y) ((word)(x) >> (word)(y))
#define XRM←BITLSHIFT(x, y) ((word)(x) << (word)(y))
static char versionStamp[] = "@(#)mob←version [3449137387,837082302] ImagerSampleImpl";
typedef unsigned word, *ptr;
typedef unsigned char byte, *bPt;
typedef unsigned short half, *hPt;
typedef word (*fPt)();
typedef struct {word f0, f1, f2, f3, f4, f5;} W6;
typedef struct {word f0, f1, f2, f3;} W4;
typedef struct {word f0, f1;} W2;
typedef W2 *W2Pt;
typedef W4 *W4Pt;
typedef struct {word f0, f1, f2, f3, f4, f5, f6, f7;} W8;
typedef struct {word f0, f1, f2;} W3;
typedef struct {W8 f; W3 r;} W11;
typedef W11 *W11Pt;
typedef struct {W8 f; W6 r;} W14;
typedef struct {W8 f; W8 r;} W16;
typedef struct {word f0, f1, f2, f3, f4, f5, f6;} W7;
typedef struct {W8 f; W7 r;} W15;
typedef struct {W16 f; W15 r;} W31;
typedef struct {W16 f; W2 r;} W18;
typedef W8 *W8Pt;
typedef struct {W8 f; W2 r;} W10;
typedef struct {word f0, f1, f2, f3, f4;} W5;
typedef struct {W8 f; W5 r;} W13;
typedef struct {W16 f; W16 r;} W32;
typedef struct {W32 f; W32 r;} W64;
typedef struct {W8 f; word r;} W9;
typedef struct {W8 f; W4 r;} W12;
#define SOURCE(p, l) /* source p, l */
#define BCK(idx, lim) ( ((unsigned) idx) >= ((unsigned) lim) ? (XR←RaiseBoundsFault()) : (idx) )
#define SGNCK(i) ((int) (word) (i) < 0 ? XR←RaiseArithmeticFault(): i )
#define MIN(cast, x, y) ( ( cast x) < ( cast y) ? (x) : (y) )
#define IOP2(op, x, y) ( (word) ((x) op (y)) )
#define INEG(x) ( (word) ( - ((int) (word) (x)) ) )
#define MAX(cast, x, y) ( ( cast x) > ( cast y) ? (x) : (y) )
static void NoName←Q20736();
static void ImagerSampleImpl←P0();
static word Lg←P240();
static word NewSamples←P720();
static word ObtainScratchSamples←P780();
static void ReleaseScratchSamples←P840();
static void DoWithScratchSamples←P900();
static word NoName←Q20796();
static word PointerToSamples←P1020();
static void FlipSamples←P1080();
static void FillSamples←P1140();
static void CopySamples←P1200();
static void ClearSamples←P1260();
static word UnsafeNewSampleMap←P1320();
static word BitsForSamples←P1380();
static word WordsForLines←P1440();
static word WordsForMap←P1500();
static word NewSampleMap←P1620();
static word NewObjectSampleMap←P1680();
static word Copy←P1740();
static word NewDescriptor←P1800();
static void ReleaseDescriptor←P1860();
static word ObtainScratchMap←P1920();
static word TryObtainScratch←P5496();
static void ReleaseScratchMap←P1980();
static void ClearScratchMaps←P2040();
static void DoWithScratchMap←P2100();
static word NoName←Q20856();
static void InPlaceClip←P2160();
static void InPlaceShift←P2340();
static word ObtainUnsafeDescriptor←P2400();
static void CheckBuffer←P2460();
static void ReIndexGetSamples←P2520();
static void ReIndexPutSamples←P2580();
static word ReIndex←P2640();
static word Clip←P2700();
static word Shift←P2760();
static word ZeroOrigin←P2820();
static void GetUnsafeBlock←P2880();
static word ApplyFunction←P2940();
static void ApplyToSamples←P3000();
static word Get←P3120();
static void Put←P3180();
static void GetSamples←P3240();
static void PutSamples←P3300();
static void Clear←P3360();
static void BufferTransfer←P3420();
static void transferAction←P8340();
static void BasicTransfer←P3480();
static void RawListTransfer←P3540();
static void Transfer←P3600();
static void TransferBoxes←P3660();
static void FastTransfer←P8976();
static void SlowTransfer←P9132();
static void Move←P3720();
static void BufferFill←P3780();
static void Fill←P3840();
static void FillBoxes←P3900();
static void FastFill←P10008();
static void SlowFill←P10164();
static void RegionFill←P3960();
static void edgeAction←P10224();
static word TileFromStipple←P4020();
static void DivMod←P4080();
static word Mod←P4140();
static void GeneralTile←P4260();
static void boxes←P10872();
static void GetTileSamples←P4320();
static void GeneralTileBoxes←P4380();
static void GeneralTile←P10932();
static void Tile←P4440();
static void boxes←P11088();
static void TileBoxes←P4500();
static void FastTile←P11292();
static void BoxesFromBitmap←P4560();
static void Halftone←P4620();
static word Zeros←P4680();
static word Equal←P4740();
static void BandAction←P12048();
static word IsAll←P4800();
static void BandAction←P12252();
static void Trim←P4860();
static void BandAction←P12360();
static void NoName←Q20916();
static void NoName←Q20976();
static struct {unsigned f; char r[4];} string1 = {131076, "\216\251\000"};
static struct {unsigned f; char r[4];} string2 = {65537, "\001\000\000"};
static struct {unsigned f; char r[16];} string3 = {851984, "\257\300\315\225\250\353\300\061\344\334\276\103\324\000\000"};
static struct {unsigned f; char r[4];} string4 = {131074, "\003\002\000"};
static struct {unsigned f; char r[16];} string5 = {917520, "\216\257\300\363\223\326\161\300\017\164\046\072\104\350\000"};
static struct {unsigned f; char r[16];} string6 = {851984, "\257\300\315\225\250\353\300\061\344\334\276\102\234\000\000"};
static struct {unsigned f; char r[16];} string7 = {851984, "\257\300\023\276\127\215\300\151\061\365\150\100\164\000\000"};
static struct {unsigned f; char r[16];} string8 = {851984, "\257\300\213\226\301\143\300\072\355\320\373\100\164\000\000"};
static struct {unsigned f; char r[16];} string9 = {851984, "\257\300\213\226\301\143\300\072\355\320\373\101\034\000\000"};
static struct {unsigned f; char r[12];} string10 = {655370, "\007\100\300\040\002\003\012\004\101\200\000"};
static struct {unsigned f; char r[8];} string11 = {262152, "true\000\000\000"};
static struct {unsigned f; char r[28];} string12 = {1703964, "Use CharBlt for characters\000"};
static struct {unsigned f; char r[8];} string13 = {458760, "charblt"};
static struct {unsigned f; char r[16];} string14 = {851984, "\257\300\315\225\250\353\300\061\344\334\276\100\164\000\000"};
static struct {unsigned f; char r[24];} string15 = {1376277, "\006\004\044\004\117\377\100\130\004\200\177\377\100\224\004\103\377\101\000\004\007\000\000"};
static struct {unsigned f; char r[12];} string16 = {720908, "\257\300/\002\345\247\245\243T@h"};
static struct {unsigned f; char r[16];} string17 = {851984, "\257\300\207\330\332\257\300\255\011\025\200\100\150\000\000"};
static struct {unsigned f; char r[16];} string18 = {851984, "\257\300\275\320\070\317\300\004\110\363\366\100\150\000\000"};
static struct {unsigned f; char r[16];} string19 = {851984, "\257\300\277\374\326\303\300\302\136\022\175\100\150\000\000"};
static struct {unsigned f; char r[16];} string20 = {851984, "\257\300\243\162\130\311\300\344\000\142\023\100\150\000\000"};
static struct {unsigned f; char r[16];} string21 = {851984, "\257\300\213\226\301\143\300\072\355\320\373\100\150\000\000"};
static struct {unsigned f; char r[32];} string22 = {1966112, "\211\022\021\123\141\155\160\154\145\115\141\160\103\154\141\163\163\122\145\160\300\213\226\301\143\300\072\355\320\373\000"};
static struct {
word f0[68]; word f68; word f69; word f70;
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;
word f91; word f92; word f93; word f94;
word f95; word f96; word f97; word f98;
word f99; word f100; word f101; word f102;
word f103; word f104; word f105; word f106;
word f107; word f108; word f109; word f110;
word f111; word f112; word f113; word f114;
word f115; word f116; word f117; word f118;
word f119; word f120; word f121; word f122;
word f123; word f124; word f125; word f126;
word f127; word f128; word f129; word f130;
word f131; word f132; word f133; word f134;
word f135; word f136; word f137; word f138;
word f139; word f140; word f141; word f142;
word f143; word f144; word f145; word f146;
word f147; word f148; word f149; word f150;
word f151; word f152; word f153; word f154;
word f155; word f156; word f157; word f158;
word f159; word f160; word f161; word f162;
word f163; word f164; word f165; word f166;
word f167; word f168; word f169; word f170;
word f171; word f172; word f173; word f174;
word f175; word f176; word f177; word f178;
word f179; word f180; word f181; word f182;
word f183; word f184; word f185; word f186;
word f187; word f188; word f189; word f190;
word f191; word f192; word f193; word f194;
word f195; word f196; word f197; word f198;
word f199[2]; word f201; word f202; word f203;
word f204; word f205; word f206; word f207;
word f208; word f209; word f210; word f211;
word f212; word f213; word f214; word f215;
word f216; word f217; word f218; word f219[2];
word f221; word f222; word f223[6];
} globalframe = {
{0}, (word) Trim←P4860, 0, (word) IsAll←P4800,
0, (word) Equal←P4740, 0, (word) Zeros←P4680,
0, (word) Halftone←P4620, 0, (word) BoxesFromBitmap←P4560,
0, (word) TileBoxes←P4500, 0, (word) Tile←P4440,
0, (word) GeneralTileBoxes←P4380, 0, (word) GetTileSamples←P4320,
0, (word) GeneralTile←P4260, 0, (word) Mod←P4140,
0, (word) DivMod←P4080, 0, (word) TileFromStipple←P4020,
0, (word) RegionFill←P3960, 0, (word) FillBoxes←P3900,
0, (word) Fill←P3840, 0, (word) BufferFill←P3780,
0, (word) Move←P3720, 0, (word) TransferBoxes←P3660,
0, (word) Transfer←P3600, 0, (word) RawListTransfer←P3540,
0, (word) BasicTransfer←P3480, 0, (word) BufferTransfer←P3420,
0, (word) Clear←P3360, 0, (word) PutSamples←P3300,
0, (word) GetSamples←P3240, 0, (word) Put←P3180,
0, (word) Get←P3120, 0, (word) ApplyToSamples←P3000,
0, (word) ApplyFunction←P2940, 0, (word) GetUnsafeBlock←P2880,
0, (word) ZeroOrigin←P2820, 0, (word) Shift←P2760,
0, (word) Clip←P2700, 0, (word) ReIndex←P2640,
0, (word) ReIndexPutSamples←P2580, 0, (word) ReIndexGetSamples←P2520,
0, (word) CheckBuffer←P2460, 0, (word) ObtainUnsafeDescriptor←P2400,
0, (word) InPlaceShift←P2340, 0, (word) InPlaceClip←P2160,
0, (word) DoWithScratchMap←P2100, 0, (word) ClearScratchMaps←P2040,
0, (word) ReleaseScratchMap←P1980, 0, (word) ObtainScratchMap←P1920,
0, (word) ReleaseDescriptor←P1860, 0, (word) NewDescriptor←P1800,
0, (word) Copy←P1740, 0, (word) NewObjectSampleMap←P1680,
0, (word) NewSampleMap←P1620, 0, (word) WordsForMap←P1500,
0, (word) WordsForLines←P1440, 0, (word) BitsForSamples←P1380,
0, (word) UnsafeNewSampleMap←P1320, 0, (word) ClearSamples←P1260,
0, (word) CopySamples←P1200, 0, (word) FillSamples←P1140,
0, (word) FlipSamples←P1080, 0, (word) PointerToSamples←P1020,
0, (word) DoWithScratchSamples←P900, 0, (word) ReleaseScratchSamples←P840,
0, (word) ObtainScratchSamples←P780, 0, (word) NewSamples←P720,
0, (word) Lg←P240, 0, (word) ImagerSampleImpl←P0,
{0}, (word) 33751811, (word) 50594820, (word) 67372036,
(word) 67437829, (word) 84215045, (word) 84215045, (word) 84215045,
0, (word) 2147483648, (word) 2147483648, (word) 2147483647,
(word) 2147483647, (word) 4294967295, (word) 1431655765, (word) 286331153,
(word) 16843009, (word) 65537, (word) 1, {0},
(word) 4, (word) 4, {0}
};
static void NoName←Q20736()
{
register ptr gf←c01259 = (ptr) &globalframe;
word var←c80540;
(* (( (ptr) gf←c01259)+49) ) = (word) XR←GetTypeIndex((word) &string1, 0, (word) &string2);
(* (( (ptr) gf←c01259)+50) ) = (word) XR←GetTypeIndex((word) &string3, 0, (word) &string4);
(* (( (ptr) gf←c01259)+53) ) = (word) XR←GetTypeIndex((word) &string5, 0, (word) &string2);
(* (( (ptr) gf←c01259)+55) ) = (word) XR←GetTypeIndexS((word) (&string6));
(* (( (ptr) gf←c01259)+56) ) = (word) XR←GetTypeIndexS((word) (&string7));
(* (( (ptr) gf←c01259)+61) ) = (word) XR←GetTypeIndexS((word) (&string8));
(* (( (ptr) gf←c01259)+62) ) = (word) XR←GetTypeIndex((word) &string9, 0, (word) &string10);
(* (ptr) (( (bPt) gf←c01259)+256) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c01259)+49) ), (word) &string11);
(* (ptr) (( (bPt) gf←c01259)+260) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c01259)+53) ), (word) &string12);
(* (ptr) (( (bPt) gf←c01259)+264) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c01259)+49) ), (word) &string13);
(void) XR←DeclareGlobalFrame((word) "ImagerSampleImpl", &globalframe, (word) XR←GetTypeIndex((word) &string14, 0, (word) &string15)
, (word) (( (bPt) gf←c01259)+792)/* var←c66268 */ );
var←c80540 = (word) XR←ImportInterface((word) "ImagerSwitches", (word) XR←GetTypeIndexS((word) (&string16)), 8);
(* (( (ptr) gf←c01259)+223)/* var←c66556 */ ) = var←c80540;
(void) XR←ImportProcS(var←c80540, 68157444);
var←c80540 = (word) XR←ImportInterface((word) "RasterOp", (word) XR←GetTypeIndexS((word) (&string17)), 8);
(* (( (ptr) gf←c01259)+226)/* var←c70076 */ ) = var←c80540;
(void) XR←ImportProcS(var←c80540, 1574662);
(void) XR←ImportProcS(var←c80540, 1574406);
(void) XR←ImportProcS(var←c80540, 1310724);
(void) XR←ImportProcS(var←c80540, 1310980);
var←c80540 = (word) XR←ImportInterface((word) "RuntimeError", (word) XR←GetTypeIndexS((word) (&string18)), 27);
(* (( (ptr) gf←c01259)+227)/* var←c70300 */ ) = var←c80540;
var←c80540 = (word) XR←ImportInterface((word) "SafeStorage", (word) XR←GetTypeIndexS((word) (&string19)), 27);
(* (( (ptr) gf←c01259)+224)/* var←c66588 */ ) = var←c80540;
(void) XR←ImportProcS(var←c80540, 67109376);
var←c80540 = (word) XR←ImportInterface((word) "SF", (word) XR←GetTypeIndexS((word) (&string20)), 19);
(* (( (ptr) gf←c01259)+225)/* var←c67164 */ ) = var←c80540;
(void) XR←ImportProcS(var←c80540, 270535426);
(void) XR←ImportProcS(var←c80540, 135270145);
var←c80540 = (word) XR←ExportInterface((word) "ImagerSample", (word) XR←GetTypeIndexS((word) (&string21)), 60);
(* (( (ptr) gf←c01259)+228)/* var←c80572 */ ) = var←c80540;
(void) XR←ExportVar(var←c80540, 0, (word) (( (bPt) gf←c01259)+268)/* var←c64156 */ );
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+776)/* var←c66204 */ , 67633410, (word) "NewSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+768)/* var←c66172 */ , 67371521, (word) "ObtainScratchSamples")
;
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+760)/* var←c66140 */ , 262913, (word) "ReleaseScratchSamples")
;
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+752)/* var←c66108 */ , 525314, (word) "DoWithScratchSamples")
;
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+744)/* var←c66076 */ , 67896579, (word) "PointerToSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+736)/* var←c66044 */ , 787971, (word) "FlipSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+728)/* var←c66012 */ , 1050372, (word) "FillSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+720)/* var←c65980 */ , 1312773, (word) "CopySamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+712)/* var←c65948 */ , 788739, (word) "ClearSamples");
(void) XR←ExportType((word) "SampleMapClassRep", (word) XR←GetTypeIndexS((word) (&string22)), (word) XR←GetTypeIndexS((word) (&string7))
);
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+704)/* var←c65916 */ , 69995271, (word) "UnsafeNewSampleMap")
;
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+696)/* var←c65884 */ , 67636226, (word) "BitsForSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+688)/* var←c65852 */ , 67636482, (word) "WordsForLines");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+680)/* var←c65820 */ , 68161027, (word) "WordsForMap");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+672)/* var←c65788 */ , 68685571, (word) "NewSampleMap");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+664)/* var←c65756 */ , 69210117, (word) "NewObjectSampleMap")
;
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+656)/* var←c65724 */ , 68948227, (word) "Copy");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+632)/* var←c65628 */ , 68686339, (word) "ObtainScratchMap");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+624)/* var←c65596 */ , 267009, (word) "ReleaseScratchMap");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+608)/* var←c65532 */ , 1577987, (word) "DoWithScratchMap");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+584)/* var←c65436 */ , 70259976, (word) "ObtainUnsafeDescriptor")
;
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+552)/* var←c65308 */ , 68949507, (word) "ReIndex");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+544)/* var←c65276 */ , 68425474, (word) "Clip");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+536)/* var←c65244 */ , 67901442, (word) "Shift");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+528)/* var←c65212 */ , 67377409, (word) "ZeroOrigin");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+640)/* var←c65660 */ , 268801, (word) "ReleaseDescriptor");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+520)/* var←c65180 */ , 201597441, (word) "GetUnsafeBlock");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+512)/* var←c65148 */ , 67904771, (word) "ApplyFunction");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+496)/* var←c65084 */ , 67905026, (word) "Get");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+488)/* var←c65052 */ , 1320708, (word) "Put");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+480)/* var←c65020 */ , 2107398, (word) "GetSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+344)/* var←c64476 */ , 1321220, (word) "GetTileSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+304)/* var←c64316 */ , 1583621, (word) "Halftone");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+472)/* var←c64988 */ , 2370311, (word) "PutSamples");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+464)/* var←c64956 */ , 273409, (word) "Clear");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+448)/* var←c64892 */ , 2370822, (word) "BasicTransfer");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+432)/* var←c64828 */ , 1322500, (word) "Transfer");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+416)/* var←c64764 */ , 2109189, (word) "Move");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+400)/* var←c64700 */ , 1847300, (word) "Fill");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+440)/* var←c64860 */ , 798979, (word) "RawListTransfer");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+376)/* var←c64604 */ , 68432389, (word) "TileFromStipple");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+328)/* var←c64412 */ , 2110213, (word) "Tile");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+320)/* var←c64380 */ , 1324037, (word) "TileBoxes");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+424)/* var←c64796 */ , 1586437, (word) "TransferBoxes");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+392)/* var←c64668 */ , 1062404, (word) "FillBoxes");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+384)/* var←c64636 */ , 1062660, (word) "RegionFill");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+312)/* var←c64348 */ , 538626, (word) "BoxesFromBitmap");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+272)/* var←c64188 */ , 270022915, (word) "Trim");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+280)/* var←c64220 */ , 68696579, (word) "IsAll");
(void) XR←ExportProcS(var←c80540, (word) (( (bPt) gf←c01259)+288)/* var←c64252 */ , 67648258, (word) "Equal");
}
static void ImagerSampleImpl←P0(formal←c090, formal←c089)
word formal←c090;
word formal←c089;
{
register ptr gf←c80604 = (ptr) &globalframe;
/* ImagerSampleImpl: */
SOURCE(900, 56336)
(* (( (hPt) gf←c80604)+401) ) = 258;
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
(* (( (bPt) gf←c80604)+832) ) = 5;
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
/* moved to installation proc */
SOURCE(1076, 99)
{
word pd23;
pd23 = (* (( (ptr) (* (( (ptr) gf←c80604)+223)/* var←c66556 */ ))+4) );
(* (( (ptr) gf←c80604)+8)/* useCharBlt←v2916 */ ) = (word) ( *( (fPt) ((* (ptr) pd23 ))))(2, (* (( (ptr) gf←c80604)+66)
), (* (( (ptr) gf←c80604)+65) ), (* (( (ptr) gf←c80604)+64) ), pd23);
};
SOURCE(42447, 29)
(* (( (ptr) gf←c80604)+47)/* tileFromStippleRepl←v5464 */ ) = 32;
SOURCE(46481, 21)
(* (( (ptr) gf←c80604)+48)/* smallWidth←v5744 */ ) = 256;
}
static word Lg←P240(a←v6404)
word a←v6404;
{
register ptr gf←c80636 = (ptr) &globalframe;
word lg←v6448;
/* Lg: */
SOURCE(2037, 119)
SOURCE(2037, 119)
lg←v6448 = 0;
SOURCE(2081, 44)
lab←L100002: ;
if ((a←v6404 > 32)) {
}
else {
goto lab←L100000;
};
SOURCE(2097, 15)
a←v6404 = ((word) (a←v6404 + 31) >> 5);
SOURCE(2114, 11)
lg←v6448 = (lg←v6448 + 5);
goto lab←L100002;
lab←L100000: ;
SOURCE(2136, 20)
{
word idx24;
lg←v6448 = (
idx24 = (word) (lg←v6448 + (unsigned) (word) (* ((( (bPt) gf←c80636)+800)/* var←c66332 */ +BCK(a←v6404, 33)) )),
SGNCK(idx24)
);
};
SOURCE(2037, 119)
return(lg←v6448);
}
static word NewSamples←P720(length←v7408, scratch←v7436)
word length←v7408;
word scratch←v7436;
{
register ptr gf←c80668 = (ptr) &globalframe;
word var←c7480;
word new←v18376;
/* NewSamples: */
SOURCE(3388, 275)
SOURCE(3482, 27)
new←v18376 = scratch←v7436;
SOURCE(3511, 116)
if ((new←v18376 == 0) || ((* (( (ptr) new←v18376)+1) ) < length←v7408)) {
SOURCE(3559, 68)
SOURCE(3561, 64)
{
word var←c66620;
word var←c66652;
word var←c66716;
var←c66620 = BCK(length←v7408, 67108863);
var←c66652 = ((word) var←c66620 << 2);
{
word var←c66684;
{
word pd25;
pd25 = (* (( (ptr) (* (( (ptr) gf←c80668)+224)/* var←c66588 */ ))+6) );
var←c66684 = (word) ( *( (fPt) ((* (ptr) pd25 ))))(pd25);
};
{
word pd26;
pd26 = (* (ptr) var←c66684 );
var←c66716 = (word) ( *( (fPt) ((* (ptr) pd26 ))))(var←c66684, (8 + var←c66652), (* (( (ptr) gf←c80668)+61) ), pd26);
};
};
(* (( (ptr) var←c66716)+1) ) = var←c66620;
new←v18376 = var←c66716;
};
};
SOURCE(3630, 19)
(* (ptr) new←v18376 ) = length←v7408;
SOURCE(3651, 12)
return(new←v18376);
}
static word ObtainScratchSamples←P780(length←v7576)
word length←v7576;
{
register ptr gf←c80700 = (ptr) &globalframe;
word var←c7620;
word buf←v18420 = 0;
/* ObtainScratchSamples: */
SOURCE(3786, 419)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c80700)+16)/* LOCK←v2888 */ ));
SOURCE(3892, 187)
{
register word i←v18464 = 0;
lab←L100006: ;
SOURCE(3936, 29)
buf←v18420 = (* ((( (ptr) gf←c80700)+9)/* scratchSampleBuffers←v3700 */ +BCK(i←v18464, 12)) );
SOURCE(3967, 112)
if ( ( (buf←v18420 != 0) ? ((* (( (ptr) buf←v18420)+1) ) >= length←v7576) : 0 ) ) {
SOURCE(4015, 29)
(* ((( (ptr) gf←c80700)+9)/* scratchSampleBuffers←v3700 */ +BCK(i←v18464, 12)) ) = 0;
SOURCE(4046, 19)
(* (ptr) buf←v18420 ) = length←v7576;
SOURCE(4067, 12)
(void) (XR←MonitorExit((word) (( (bPt) gf←c80700)+16)/* LOCK←v2888 */ ));
return(buf←v18420);
};
if ((i←v18464 >= 11)) {
goto lab←L100003;
};
i←v18464 = (i←v18464 + 1);
goto lab←L100006;
lab←L100003: ;
};
SOURCE(4101, 67)
SOURCE(4103, 65)
{
word var←c66748;
word var←c66780;
word var←c66844;
var←c66748 = BCK(length←v7576, 67108863);
var←c66780 = ((word) var←c66748 << 2);
{
word var←c66812;
{
word pd27;
pd27 = (* (( (ptr) (* (( (ptr) gf←c80700)+224)/* var←c66588 */ ))+6) );
var←c66812 = (word) ( *( (fPt) ((* (ptr) pd27 ))))(pd27);
};
{
word pd28;
pd28 = (* (ptr) var←c66812 );
var←c66844 = (word) ( *( (fPt) ((* (ptr) pd28 ))))(var←c66812, (8 + var←c66780), (* (( (ptr) gf←c80700)+61) ), pd28);
};
};
(* (( (ptr) var←c66844)+1) ) = var←c66748;
buf←v18420 = var←c66844;
};
SOURCE(4171, 19)
(* (ptr) buf←v18420 ) = length←v7576;
SOURCE(4192, 13)
(void) (XR←MonitorExit((word) (( (bPt) gf←c80700)+16)/* LOCK←v2888 */ ));
return(buf←v18420);
}
static void ReleaseScratchSamples←P840(buffer←v7680)
word buffer←v7680;
{
register ptr gf←c80732 = (ptr) &globalframe;
word var←c66876;
word slot←v18508 = 0;
/* ReleaseScratchSamples: */
SOURCE(4209, 326)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c80732)+16)/* LOCK←v2888 */ ));
SOURCE(4292, 17)
(* (ptr) buffer←v7680 ) = 0;
SOURCE(4311, 178)
{
register word i←v18552 = 0;
lab←L100010: ;
{
word t←v18596;
SOURCE(4355, 41)
t←v18596 = (* ((( (ptr) gf←c80732)+9)/* scratchSampleBuffers←v3700 */ +BCK(i←v18552, 12)) );
SOURCE(4398, 91)
if ((t←v18596 == 0)) {
SOURCE(4414, 14)
slot←v18508 = i←v18552;
}
else {
SOURCE(4428, 61)
if ((buffer←v7680 == t←v18596)) {
SOURCE(4447, 42)
var←c66876 = (word) (( (bPt) gf←c80732)+268)/* var←c64156 */ ;
(void) (XR←MonitorExit((word) (( (bPt) gf←c80732)+16)/* LOCK←v2888 */ ));
goto lab←L100011;
};
};
};
if ((i←v18552 >= 11)) {
goto lab←L100007;
};
i←v18552 = (i←v18552 + 1);
goto lab←L100010;
lab←L100007: ;
};
SOURCE(4500, 35)
(* ((( (ptr) gf←c80732)+9)/* scratchSampleBuffers←v3700 */ +BCK(slot←v18508, 12)) ) = buffer←v7680;
SOURCE(4209, 326)
(void) (XR←MonitorExit((word) (( (bPt) gf←c80732)+16)/* LOCK←v2888 */ ));
return;
/* c2c skipped dead code */
lab←L100011: ;
SOURCE(4447, 42)
(void) XR←RaiseError(var←c66876, 0);
}
static void DoWithScratchSamples←P900(length←v7740, formal←c01359)
word length←v7740;
word formal←c01359;
{
W6 var←c80764;
/* declaration of action←v7768 skipped */
/* declaration of scratch←v18640 skipped */
var←c80764.f4/* action←v7768 */ = formal←c01359;
/* DoWithScratchSamples: */
SOURCE(4541, 225)
SOURCE(4622, 52)
var←c80764.f5/* scratch←v18640 */ = (word) ObtainScratchSamples←P780(length←v7740);
SOURCE(4676, 58)
{
word var←c01315;
var←c01315 = (word) &var←c80764;
(void) (word) XR←Enable(( ((word) (fPt) NoName←Q20796) ), ( ((word) (fPt) NoName←Q20976) ), var←c01315);
};
SOURCE(4736, 30)
(void) ReleaseScratchSamples←P840(var←c80764.f5/* scratch←v18640 */ );
}
static word NoName←Q20796(formal←c01265)
word formal←c01265;
{
SOURCE(4676, 58)
{
word pd29;
pd29 = (* (( (ptr) formal←c01265)+4) );
(void) ( *( (fPt) ((* (ptr) pd29 ))))((* ((( (ptr) formal←c01265)+5)) ), pd29);
};
return(0);
}
static word PointerToSamples←P1020(buffer←v8048, start←v8076, count←v8104)
word buffer←v8048;
word start←v8076;
word count←v8104;
{
word var←c8148;
/* PointerToSamples: */
SOURCE(5013, 160)
SOURCE(5119, 54)
{
word var←c66940;
word check←v18684;
check←v18684 = (((* (( (ptr) buffer←v8048)+1) ) - start←v8076) - count←v8104);
SOURCE(4940, 67)
var←c66940 = (buffer←v8048 + ((word) ((word) (((word) BCK(start←v8076, 67108861) << 5) + 95) >> 5) << 2));
return(var←c66940);
};
}
static void FlipSamples←P1080(buffer←v8208, start←v8236, count←v8264)
word buffer←v8208;
word start←v8236;
word count←v8264;
{
word size←v18724;
/* FlipSamples: */
SOURCE(5177, 342)
SOURCE(5248, 43)
{
word x30;
size←v18724 = (x30 = ((* (ptr) buffer←v8208 ) - start←v8236),
MIN((int)(word), x30, count←v8264));
};
SOURCE(5293, 226)
if ((size←v18724 > 0)) {
SOURCE(5318, 212)
{
word pointer←v18768;
word last←v18796;
SOURCE(5320, 68)
{
word check←v59924;
check←v59924 = (((* (( (ptr) buffer←v8208)+1) ) - start←v8236) - size←v18724);
SOURCE(4940, 67)
pointer←v18768 = (buffer←v8208 + ((word) ((word) (((word) BCK(start←v8236, 67108861) << 5) + 95) >> 5) << 2));
};
SOURCE(5390, 18)
last←v18796 = SGNCK((size←v18724 - 1));
SOURCE(5410, 109)
{
register word j←v18840 = 0;
register word noName←c67004;
noName←c67004 = ((word) size←v18724 >> 1);
if ((j←v18840 >= noName←c67004)) {
goto lab←L100017;
};
lab←L100020: ;
{
word k←v18884;
word t←v18912;
SOURCE(5439, 15)
k←v18884 = (last←v18796 - j←v18840);
SOURCE(5456, 22)
t←v18912 = (* (( (ptr) pointer←v18768)+j←v18840) );
SOURCE(5480, 23)
(* (( (ptr) pointer←v18768)+j←v18840) ) = (* (( (ptr) pointer←v18768)+k←v18884) );
SOURCE(5505, 14)
(* (( (ptr) pointer←v18768)+k←v18884) ) = t←v18912;
};
j←v18840 = (j←v18840 + 1);
if ((j←v18840 < noName←c67004)) {
goto lab←L100020;
};
lab←L100017: ;
};
};
};
}
static void FillSamples←P1140(buffer←v8324, value←v8352, start←v8380, count←v8408)
word buffer←v8324;
word value←v8352;
word start←v8380;
word count←v8408;
{
word size←v18956;
/* FillSamples: */
SOURCE(5537, 285)
SOURCE(5623, 43)
{
word x31;
size←v18956 = (x31 = ((* (ptr) buffer←v8324 ) - start←v8380),
MIN((int)(word), x31, count←v8408));
};
SOURCE(5668, 154)
if ((size←v18956 > 0)) {
SOURCE(5693, 131)
{
word pointer←v19000;
SOURCE(5695, 68)
{
word check←v59880;
check←v59880 = (((* (( (ptr) buffer←v8324)+1) ) - start←v8380) - size←v18956);
SOURCE(4940, 67)
pointer←v19000 = (buffer←v8324 + ((word) ((word) (((word) BCK(start←v8380, 67108861) << 5) + 95) >> 5) << 2));
};
SOURCE(5765, 57)
(void) Basics←FillWords(pointer←v19000, size←v18956, value←v8352);
};
};
}
static void CopySamples←P1200(dst←v8468, src←v8496, dstStart←v8524, srcStart←v8552, count←v8580)
word dst←v8468;
word src←v8496;
word dstStart←v8524;
word srcStart←v8552;
word count←v8580;
{
word size←v19044;
/* CopySamples: */
SOURCE(5831, 745)
SOURCE(5917, 74)
{
word x32;
word x33;
word x34;
size←v19044 = (x32 = ((* (ptr) dst←v8468 ) - dstStart←v8524),
x33 = ((* (ptr) src←v8496 ) - srcStart←v8552),
x34 = MIN((int)(word), x32, x33),
MIN((int)(word), x34, count←v8580));
};
SOURCE(5993, 583)
if ((size←v19044 > 0)) {
SOURCE(6018, 566)
{
word dstPointer←v19088;
word srcPointer←v19116;
word rem←v19144;
SOURCE(6020, 71)
{
word check←v59836;
check←v59836 = (((* (( (ptr) dst←v8468)+1) ) - dstStart←v8524) - size←v19044);
SOURCE(4940, 67)
dstPointer←v19088 = (dst←v8468 + ((word) ((word) (((word) BCK(dstStart←v8524, 67108861) << 5) + 95) >> 5) << 2));
};
SOURCE(6093, 71)
{
word check←v59792;
check←v59792 = (((* (( (ptr) src←v8496)+1) ) - srcStart←v8552) - size←v19044);
SOURCE(4940, 67)
srcPointer←v19116 = (src←v8496 + ((word) ((word) (((word) BCK(srcStart←v8552, 67108861) << 5) + 95) >> 5) << 2));
};
SOURCE(6166, 19)
rem←v19144 = size←v19044;
SOURCE(6187, 235)
lab←L100026: ;
if (( (int)rem←v19144 >= (int)4)) {
}
else {
goto lab←L100024;
};
SOURCE(6205, 29)
(* (ptr) dstPointer←v19088 ) = (* (ptr) srcPointer←v19116 );
SOURCE(6236, 29)
(* (( (ptr) dstPointer←v19088)+1) ) = (* (( (ptr) srcPointer←v19116)+1) );
SOURCE(6267, 29)
(* (( (ptr) dstPointer←v19088)+2) ) = (* (( (ptr) srcPointer←v19116)+2) );
SOURCE(6298, 29)
(* (( (ptr) dstPointer←v19088)+3) ) = (* (( (ptr) srcPointer←v19116)+3) );
SOURCE(6329, 38)
dstPointer←v19088 = (dstPointer←v19088 + 16);
SOURCE(6369, 38)
srcPointer←v19116 = (srcPointer←v19116 + 16);
SOURCE(6409, 13)
rem←v19144 = (rem←v19144 - 4);
goto lab←L100026;
lab←L100024: ;
SOURCE(6433, 143)
if (( (int)rem←v19144 > (int)0)) {
SOURCE(6451, 29)
(* (ptr) dstPointer←v19088 ) = (* (ptr) srcPointer←v19116 );
SOURCE(6482, 94)
if (( (int)rem←v19144 > (int)1)) {
SOURCE(6500, 29)
(* (( (ptr) dstPointer←v19088)+1) ) = (* (( (ptr) srcPointer←v19116)+1) );
SOURCE(6531, 45)
if (( (int)rem←v19144 > (int)2)) {
SOURCE(6547, 29)
(* (( (ptr) dstPointer←v19088)+2) ) = (* (( (ptr) srcPointer←v19116)+2) );
};
};
};
};
};
}
static void ClearSamples←P1260(buffer←v8640, start←v8668, count←v8696)
word buffer←v8640;
word start←v8668;
word count←v8696;
{
word size←v19188;
/* ClearSamples: */
SOURCE(6591, 267)
SOURCE(6663, 43)
{
word x35;
size←v19188 = (x35 = ((* (ptr) buffer←v8640 ) - start←v8668),
MIN((int)(word), x35, count←v8696));
};
SOURCE(6708, 150)
if ((size←v19188 > 0)) {
SOURCE(6733, 127)
{
word pointer←v19232;
SOURCE(6735, 68)
{
word check←v59748;
check←v59748 = (((* (( (ptr) buffer←v8640)+1) ) - start←v8668) - size←v19188);
SOURCE(4940, 67)
pointer←v19232 = (buffer←v8640 + ((word) ((word) (((word) BCK(start←v8668, 67108861) << 5) + 95) >> 5) << 2));
};
SOURCE(6805, 53)
(void) Basics←FillWords(pointer←v19232, size←v19188, 0);
};
};
}
static word UnsafeNewSampleMap←P1320(box←v8756, bitsPerSample←v8784, bitsPerLine←v8812, base←v8840, ref←v8868, words←v8896, scratchDescriptor←v8924)
W4 box←v8756;
word bitsPerSample←v8784;
word bitsPerLine←v8812;
W2 base←v8840;
word ref←v8868;
word words←v8896;
word scratchDescriptor←v8924;
{
register ptr gf←c80796 = (ptr) &globalframe;
word var←c8984;
W2 size←v19276;
word bpl←v19304;
word dataBitsPerLine←v19332;
word fillBits←v19360;
word totalBits←v19388;
word totalWords←v19416;
word spareWords←v19444;
word s←v19472 = 0;
/* UnsafeNewSampleMap: */
SOURCE(6867, 851)
SOURCE(7071, 24)
{
word pd36;
pd36 = (* (( (ptr) (* (( (ptr) gf←c80796)+225)/* var←c67164 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd36 ))))((word) &size←v19276, box←v8756, pd36);
};
SOURCE(7097, 23)
bpl←v19304 = SGNCK(bitsPerLine←v8812);
SOURCE(7122, 55)
{
word idx37;
dataBitsPerLine←v19332 = ((
idx37 = (word) size←v19276.f1,
SGNCK(idx37)
) * bitsPerSample←v8784);
};
SOURCE(7179, 54)
fillBits←v19360 = (bitsPerLine←v8812 - SGNCK(dataBitsPerLine←v19332));
SOURCE(7267, 53)
{
word idx38;
totalBits←v19388 = ((((
idx38 = (word) size←v19276.f0,
SGNCK(idx38)
) * bpl←v19304) + base←v8840.f1) - fillBits←v19360);
};
SOURCE(7322, 42)
totalWords←v19416 = ((word) (totalBits←v19388 + 31) >> 5);
SOURCE(7366, 59)
{
word value←v64108;
value←v64108 = (words←v8896 - SGNCK(totalWords←v19416));
spareWords←v19444 = SGNCK(value←v64108);
};
SOURCE(7479, 102)
{
word var←c67228;
var←c67228 = scratchDescriptor←v8924;
if ((var←c67228 == 0)) {
goto lab←L100029;
};
if (((* (( (ptr) var←c67228)+6) ) == 0)) {
{
word r←v19516;
r←v19516 = var←c67228;
SOURCE(7536, 17)
s←v19472 = r←v19516;
};
}
else {
lab←L100029: ;
SOURCE(7553, 28)
s←v19472 = XR←NewObject(44, (* (( (ptr) gf←c80796)+62) ));
};
};
SOURCE(7583, 124)
{
W4 var←c67292;
{
W4 box←v56564;
box←v56564 = box←v8756;
SOURCE(1846, 74)
if (( (int)box←v56564.f0 >= (int)box←v56564.f2) || ( (int)box←v56564.f1 >= (int)box←v56564.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56564)+2) ) = (* (W2Pt) &box←v56564 );
};
SOURCE(1922, 12)
var←c67292 = box←v56564;
};
(* (W4Pt) s←v19472 ) = var←c67292;
(* (( (ptr) s←v19472)+4) ) = 0;
(* (( (ptr) s←v19472)+5) ) = bitsPerSample←v8784;
(* (( (ptr) s←v19472)+6) ) = 0;
(* (( (ptr) s←v19472)+7) ) = bpl←v19304;
(* (W2Pt) (( (ptr) s←v19472)+8) ) = base←v8840;
(* (( (ptr) s←v19472)+10) ) = ref←v8868;
};
SOURCE(7709, 9)
return(s←v19472);
}
static word BitsForSamples←P1380(fSize←v9044, bitsPerSample←v9072)
word fSize←v9044;
word bitsPerSample←v9072;
{
word var←c9116;
word num←v19560;
/* BitsForSamples: */
SOURCE(7724, 161)
SOURCE(7803, 69)
num←v19560 = ((word) ((word) ((fSize←v9044 * bitsPerSample←v9072) + 31) >> 5) << 5);
SOURCE(7874, 11)
return(SGNCK(num←v19560));
}
static word WordsForLines←P1440(sSize←v9176, bitsPerLine←v9204)
word sSize←v9176;
word bitsPerLine←v9204;
{
word var←c9248;
/* WordsForLines: */
SOURCE(7891, 121)
SOURCE(7967, 45)
{
word var←c01316;
{
word var←c67388;
word bitCount←v56708;
bitCount←v56708 = (sSize←v9176 * SGNCK(bitsPerLine←v9204));
SOURCE(2535, 32)
var←c67388 = ((word) (bitCount←v56708 + 31) >> 5);
var←c01316 = SGNCK(var←c67388);
};
return(var←c01316);
};
}
static word WordsForMap←P1500(size←v9308, bitsPerSample←v9336, bitsPerLine←v9364)
W2 size←v9308;
word bitsPerSample←v9336;
word bitsPerLine←v9364;
{
word var←c9408;
/* WordsForMap: */
SOURCE(8018, 225)
SOURCE(8126, 73)
if (( (int)bitsPerLine←v9364 == (int)0)) {
SOURCE(8148, 51)
{
word idx39;
bitsPerLine←v9364 = (word) BitsForSamples←P1380((
idx39 = (word) size←v9308.f1,
SGNCK(idx39)
), bitsPerSample←v9336);
};
};
SOURCE(8201, 42)
{
word idx40;
return((word) WordsForLines←P1440((
idx40 = (word) size←v9308.f0,
SGNCK(idx40)
), bitsPerLine←v9364));
};
}
static word NewSampleMap←P1620(box←v9688, bitsPerSample←v9716, bitsPerLine←v9744)
W4 box←v9688;
word bitsPerSample←v9716;
word bitsPerLine←v9744;
{
register ptr gf←c80828 = (ptr) &globalframe;
word var←c9788;
W2 size←v19616;
word actualBitsPerLine←v19644;
word words←v19672;
word wordSeq←v19700;
word map←v19728;
/* NewSampleMap: */
SOURCE(8470, 618)
SOURCE(8597, 24)
{
word pd41;
pd41 = (* (( (ptr) (* (( (ptr) gf←c80828)+225)/* var←c67164 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd41 ))))((word) &size←v19616, box←v9688, pd41);
};
SOURCE(8623, 115)
{
word var←c67452;
var←c67452 = bitsPerLine←v9744;
{
word idx42;
if (( (int)var←c67452 == (int)0)) {
actualBitsPerLine←v19644 = (word) BitsForSamples←P1380((
idx42 = (word) size←v19616.f1,
SGNCK(idx42)
), bitsPerSample←v9716);
}
else {
actualBitsPerLine←v19644 = bitsPerLine←v9744;
};
};
};
SOURCE(8740, 53)
{
word idx43;
words←v19672 = (word) WordsForLines←P1440((
idx43 = (word) size←v19616.f0,
SGNCK(idx43)
), actualBitsPerLine←v19644);
};
SOURCE(8795, 78)
{
word var←c67484;
word var←c67516;
word var←c67580;
var←c67484 = BCK(words←v19672, 67108863);
var←c67516 = ((word) var←c67484 << 2);
{
word var←c67548;
{
word pd44;
pd44 = (* (( (ptr) (* (( (ptr) gf←c80828)+224)/* var←c66588 */ ))+6) );
var←c67548 = (word) ( *( (fPt) ((* (ptr) pd44 ))))(pd44);
};
{
word pd45;
pd45 = (* (ptr) var←c67548 );
var←c67580 = (word) ( *( (fPt) ((* (ptr) pd45 ))))(var←c67548, (4 + var←c67516), (* (( (ptr) gf←c80828)+55) ), pd45);
};
};
(* (ptr) var←c67580 ) = var←c67484;
wordSeq←v19700 = var←c67580;
};
SOURCE(8875, 199)
{
word var←c67612;
{
word wordSeq←v60032;
wordSeq←v60032 = wordSeq←v19700;
SOURCE(8405, 61)
var←c67612 = (wordSeq←v60032 + 4);
};
{
W2 var←c67676;
var←c67676.f0 = var←c67612;
var←c67676.f1 = 0;
map←v19728 = (word) UnsafeNewSampleMap←P1320(box←v9688, bitsPerSample←v9716, actualBitsPerLine←v19644, var←c67676, wordSeq←v19700, (* (ptr) wordSeq←v19700 )
, 0);
};
};
SOURCE(9076, 12)
return(map←v19728);
}
static word NewObjectSampleMap←P1680(box←v9848, bitsPerSample←v9876, getSamples←v9904, putSamples←v9932, data←v9960)
W4 box←v9848;
word bitsPerSample←v9876;
word getSamples←v9904;
word putSamples←v9932;
word data←v9960;
{
register ptr gf←c80860 = (ptr) &globalframe;
word var←c10016;
word new←v19784;
/* NewObjectSampleMap: */
SOURCE(9092, 415)
SOURCE(9260, 232)
{
W4 var←c67708;
word var←c67772;
word var←c67836;
{
W4 box←v56516;
box←v56516 = box←v9848;
SOURCE(1846, 74)
if (( (int)box←v56516.f0 >= (int)box←v56516.f2) || ( (int)box←v56516.f1 >= (int)box←v56516.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56516)+2) ) = (* (W2Pt) &box←v56516 );
};
SOURCE(1922, 12)
var←c67708 = box←v56516;
};
{
word var←c67804;
var←c67804 = XR←NewObject(8, (* (( (ptr) gf←c80860)+56) ));
(* (ptr) var←c67804 ) = XR←CheckProc(getSamples←v9904);
(* (( (ptr) var←c67804)+1) ) = XR←CheckProc(putSamples←v9932);
var←c67772 = var←c67804;
};
var←c67836 = XR←NewObject(36, (* (( (ptr) gf←c80860)+62) ));
(* (W4Pt) var←c67836 ) = var←c67708;
(* (( (ptr) var←c67836)+4) ) = (unsigned) (putSamples←v9932 == 0);
(* (( (ptr) var←c67836)+5) ) = bitsPerSample←v9876;
(* (( (ptr) var←c67836)+6) ) = 1;
(* (( (ptr) var←c67836)+7) ) = var←c67772;
(* (( (ptr) var←c67836)+8) ) = data←v9960;
new←v19784 = var←c67836;
};
SOURCE(9494, 13)
return(new←v19784);
}
static word Copy←P1740(map←v10076, delta←v10104, box←v10132)
word map←v10076;
W2 delta←v10104;
W4 box←v10132;
{
word var←c10176;
word temp←v19828;
word new←v19856;
/* Copy: */
SOURCE(9511, 284)
SOURCE(9598, 42)
temp←v19828 = (word) ReIndex←P2640(map←v10076, delta←v10104, box←v10132);
SOURCE(9642, 84)
new←v19856 = (word) NewSampleMap←P1620((* (W4Pt) temp←v19828 ), (* (( (ptr) map←v10076)+5) ), 0);
SOURCE(9728, 29)
{
W2 var←c67868;
var←c67868.f0 = 0;
var←c67868.f1 = 0;
(void) Transfer←P3600(new←v19856, temp←v19828, var←c67868, 0);
};
SOURCE(9759, 23)
(void) ReleaseDescriptor←P1860(temp←v19828);
SOURCE(9784, 11)
return(new←v19856);
}
static word NewDescriptor←P1800(map←v10292)
word map←v10292;
{
register ptr gf←c80892 = (ptr) &globalframe;
word new←v10336;
/* NewDescriptor: */
SOURCE(9938, 307)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c80892)+16)/* LOCK←v2888 */ ));
SOURCE(9938, 307)
new←v10336 = 0;
SOURCE(10034, 177)
if (((* (( (ptr) gf←c80892)+21)/* scratchDescsTop←v4260 */ ) == 0)) {
SOURCE(10062, 36)
new←v10336 = XR←NewObject(44, (* (( (ptr) gf←c80892)+62) ));
}
else {
SOURCE(10100, 37)
{
word idx46;
(* (( (ptr) gf←c80892)+21)/* scratchDescsTop←v4260 */ ) = (
idx46 = (word) ((* (( (ptr) gf←c80892)+21)/* scratchDescsTop←v4260 */ ) - 1),
BCK(idx46, 16)
);
};
SOURCE(10139, 35)
{
word idx47;
new←v10336 = (* ((( (ptr) gf←c80892)+22)/* scratchDescs←v4288 */ +(
idx47 = (* (( (ptr) gf←c80892)+21)/* scratchDescsTop←v4260 */ ),
BCK(idx47, 15)
)) );
};
SOURCE(10176, 35)
{
word idx48;
(* ((( (ptr) gf←c80892)+22)/* scratchDescs←v4288 */ +(
idx48 = (* (( (ptr) gf←c80892)+21)/* scratchDescsTop←v4260 */ ),
BCK(idx48, 15)
)) ) = 0;
};
};
SOURCE(10216, 29)
if ((map←v10292 != 0)) {
SOURCE(10234, 11)
(* (W11Pt) new←v10336 ) = (* (W11Pt) map←v10292 );
};
SOURCE(9938, 307)
(void) (XR←MonitorExit((word) (( (bPt) gf←c80892)+16)/* LOCK←v2888 */ ));
return(new←v10336);
}
static void ReleaseDescriptor←P1860(map←v10396)
word map←v10396;
{
register ptr gf←c80924 = (ptr) &globalframe;
word var←c67996;
/* ReleaseDescriptor: */
SOURCE(10251, 403)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c80924)+16)/* LOCK←v2888 */ ));
SOURCE(10309, 345)
{
word var←c67932;
var←c67932 = map←v10396;
if ((var←c67932 == 0)) {
goto lab←L100034;
};
if (((* (( (ptr) var←c67932)+6) ) == 0)) {
{
word map←v19900;
map←v19900 = var←c67932;
SOURCE(10356, 110)
{
register word i←v19944 = 0;
register word noName←c67964;
noName←c67964 = (* (( (ptr) gf←c80924)+21)/* scratchDescsTop←v4260 */ );
if ((i←v19944 >= noName←c67964)) {
goto lab←L100035;
};
lab←L100038: ;
SOURCE(10394, 72)
if ((map←v19900 == (* ((( (ptr) gf←c80924)+22)/* scratchDescs←v4288 */ +BCK(i←v19944, 15)) ))) {
SOURCE(10424, 42)
var←c67996 = (word) (( (bPt) gf←c80924)+268)/* var←c64156 */ ;
(void) (XR←MonitorExit((word) (( (bPt) gf←c80924)+16)/* LOCK←v2888 */ ));
goto lab←L100039;
};
i←v19944 = (i←v19944 + 1);
if ((i←v19944 < noName←c67964)) {
goto lab←L100038;
};
lab←L100035: ;
};
SOURCE(10477, 177)
if (((* (( (ptr) gf←c80924)+21)/* scratchDescsTop←v4260 */ ) < 15)) {
SOURCE(10519, 23)
(* (ptr) map←v19900 ) = 0;
(* (( (ptr) map←v19900)+1) ) = 0;
(* (( (ptr) map←v19900)+2) ) = 0;
(* (( (ptr) map←v19900)+3) ) = 0;
SOURCE(10544, 19)
(* (( (ptr) map←v19900)+8) ) = 0;
SOURCE(10565, 13)
(* (( (ptr) map←v19900)+10) ) = 0;
SOURCE(10580, 35)
{
word idx49;
(* ((( (ptr) gf←c80924)+22)/* scratchDescs←v4288 */ +(
idx49 = (* (( (ptr) gf←c80924)+21)/* scratchDescsTop←v4260 */ ),
BCK(idx49, 15)
)) ) = map←v19900;
};
SOURCE(10617, 37)
{
word idx50;
(* (( (ptr) gf←c80924)+21)/* scratchDescsTop←v4260 */ ) = (
idx50 = (word) ((* (( (ptr) gf←c80924)+21)/* scratchDescsTop←v4260 */ ) + 1),
BCK(idx50, 16)
);
};
};
};
}
else {
lab←L100034: ;
};
};
SOURCE(10251, 403)
(void) (XR←MonitorExit((word) (( (bPt) gf←c80924)+16)/* LOCK←v2888 */ ));
return;
/* c2c skipped dead code */
lab←L100039: ;
SOURCE(10424, 42)
(void) XR←RaiseError(var←c67996, 0);
}
static word ObtainScratchMap←P1920(box←v10492, bitsPerSample←v10520, bitsPerLine←v10548)
W4 box←v10492;
word bitsPerSample←v10520;
word bitsPerLine←v10548;
{
W6 var←c80956;
register ptr gf←c80988 = (ptr) &globalframe;
word var←c10592;
/* declaration of var←c68028 skipped */
W2 size←v19988;
word actualBitsPerLine←v20016;
word nWords←v20044;
word s←v20100;
/* ObtainScratchMap: */
SOURCE(10776, 1291)
{
word tmpAddr51;
tmpAddr51 = (word) (( (ptr) &var←c80956)+4)/* var←c68028 */ ;
(* (ptr) tmpAddr51 ) = ( ((word) (fPt) TryObtainScratch←P5496) );
(* (( (ptr) tmpAddr51) + 1) ) = 1;
};
SOURCE(10900, 24)
{
word pd52;
pd52 = (* (( (ptr) (* (( (ptr) gf←c80988)+225)/* var←c67164 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd52 ))))((word) &size←v19988, box←v10492, pd52);
};
SOURCE(10926, 115)
{
word var←c68060;
var←c68060 = bitsPerLine←v10548;
{
word idx53;
if (( (int)var←c68060 == (int)0)) {
actualBitsPerLine←v20016 = (word) BitsForSamples←P1380((
idx53 = (word) size←v19988.f1,
SGNCK(idx53)
), bitsPerSample←v10520);
}
else {
actualBitsPerLine←v20016 = bitsPerLine←v10548;
};
};
};
SOURCE(11043, 74)
{
word idx54;
nWords←v20044 = (word) WordsForLines←P1440((
idx54 = (word) size←v19988.f0,
SGNCK(idx54)
), actualBitsPerLine←v20016);
};
SOURCE(11809, 45)
s←v20100 = (word) TryObtainScratch←P5496(nWords←v20044, (word) (( (bPt) &var←c80956)+16)/* var←c68028 */ );
SOURCE(11856, 195)
if ((s←v20100 == 0)) {
SOURCE(11872, 88)
s←v20100 = (word) NewSampleMap←P1620(box←v10492, bitsPerSample←v10520, bitsPerLine←v10548);
}
else {
SOURCE(11962, 21)
{
W4 box←v56468;
box←v56468 = box←v10492;
SOURCE(1846, 74)
if (( (int)box←v56468.f0 >= (int)box←v56468.f2) || ( (int)box←v56468.f1 >= (int)box←v56468.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56468)+2) ) = (* (W2Pt) &box←v56468 );
};
SOURCE(1922, 12)
(* (W4Pt) s←v20100 ) = box←v56468;
};
SOURCE(11985, 31)
(* (( (ptr) s←v20100)+5) ) = bitsPerSample←v10520;
SOURCE(12018, 33)
(* (( (ptr) s←v20100)+7) ) = SGNCK(actualBitsPerLine←v20016);
};
SOURCE(12056, 11)
return(s←v20100);
}
static word TryObtainScratch←P5496(nw←v20176, formal←c81052)
word nw←v20176;
word formal←c81052;
{
register ptr gf←c81020 = (ptr) &globalframe;
word var←c20220;
word besti←v20248 = (word) -1;
word smallestWaste←v20276 = 2147483647;
formal←c81052 = (formal←c81052 - 16);
/* TryObtainScratch: */
SOURCE(11119, 687)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c81020)+16)/* LOCK←v2888 */ ));
SOURCE(11244, 271)
{
register word i←v20320 = 0;
lab←L100045: ;
{
word s←v20364;
SOURCE(11279, 35)
s←v20364 = (* ((( (ptr) gf←c81020)+37)/* scratchMaps←v4400 */ +BCK(i←v20320, 10)) );
SOURCE(11316, 199)
if ((s←v20364 != 0)) {
SOURCE(11334, 181)
{
word var←c68124;
var←c68124 = (* (( (ptr) s←v20364)+10) );
if ((var←c68124 == 0)) {
goto lab←L100046;
};
if (((* (( (ptr) gf←c81020)+55) ) == XR←GetReferentType(var←c68124))) {
{
word wordSeq←v20408;
wordSeq←v20408 = var←c68124;
SOURCE(11386, 129)
if (( (int)nw←v20176 <= (int)(* (ptr) wordSeq←v20408 ))) {
SOURCE(11415, 105)
{
word waste←v20464;
SOURCE(11417, 32)
waste←v20464 = ((* (ptr) wordSeq←v20408 ) - nw←v20176);
SOURCE(11451, 64)
if (( (int)waste←v20464 < (int)smallestWaste←v20276)) {
SOURCE(11483, 9)
/*1*/ besti←v20248 = i←v20320;
SOURCE(11494, 21)
/*1*/ smallestWaste←v20276 = waste←v20464;
/*1*/ };
};
};
};
}
else {
lab←L100046: ;
};
};
};
};
if ((i←v20320 >= 9)) {
goto lab←L100042;
};
i←v20320 = (i←v20320 + 1);
goto lab←L100045;
lab←L100042: ;
};
SOURCE(11547, 241)
if (( (int)besti←v20248 >= (int)0)) {
SOURCE(11566, 224)
{
word s←v20508;
SOURCE(11568, 39)
s←v20508 = (* ((( (ptr) gf←c81020)+37)/* scratchMaps←v4400 */ +BCK(besti←v20248, 10)) );
SOURCE(11609, 24)
(* ((( (ptr) gf←c81020)+37)/* scratchMaps←v4400 */ +BCK(besti←v20248, 10)) ) = 0;
SOURCE(11635, 120)
{
word var←c68156;
var←c68156 = (* (( (ptr) s←v20508)+10) );
if ((var←c68156 == 0)) {
goto lab←L100047;
};
if (((* (( (ptr) gf←c81020)+55) ) == XR←GetReferentType(var←c68156))) {
{
word wordSeq←v20552;
wordSeq←v20552 = var←c68156;
SOURCE(11685, 72)
{
word ptr←v20608;
SOURCE(11687, 38)
{
word wordSeq←v59984;
wordSeq←v59984 = wordSeq←v20552;
SOURCE(8405, 61)
ptr←v20608 = (wordSeq←v59984 + 4);
};
SOURCE(11727, 28)
(* (( (ptr) s←v20508)+8) ) = ptr←v20608;
(* (( (ptr) s←v20508)+9) ) = 0;
};
};
}
else {
lab←L100047: ;
SOURCE(11771, 5)
(void) XR←RaiseUnnamedError();
};
};
SOURCE(11778, 10)
(void) (XR←MonitorExit((word) (( (bPt) gf←c81020)+16)/* LOCK←v2888 */ ));
return(s←v20508);
};
};
SOURCE(11793, 13)
(void) (XR←MonitorExit((word) (( (bPt) gf←c81020)+16)/* LOCK←v2888 */ ));
return(0);
}
static void ReleaseScratchMap←P1980(map←v10652)
word map←v10652;
{
register ptr gf←c81084 = (ptr) &globalframe;
word var←c68284;
/* ReleaseScratchMap: */
SOURCE(12071, 557)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c81084)+16)/* LOCK←v2888 */ ));
SOURCE(12129, 28)
if ((0 != (* (( (ptr) map←v10652)+4) ))) {
SOURCE(12151, 6)
(void) (XR←MonitorExit((word) (( (bPt) gf←c81084)+16)/* LOCK←v2888 */ ));
return;
};
SOURCE(12159, 469)
{
word var←c68220;
var←c68220 = map←v10652;
if ((var←c68220 == 0)) {
goto lab←L100049;
};
if (((* (( (ptr) var←c68220)+6) ) == 0)) {
{
word map←v20664;
map←v20664 = var←c68220;
SOURCE(12204, 438)
{
word slot←v20708 = (word) -1;
SOURCE(12222, 73)
{
word var←c68252;
var←c68252 = (* (( (ptr) map←v20664)+10) );
if ((var←c68252 == 0)) {
goto lab←L100050;
};
if (((* (( (ptr) gf←c81084)+55) ) == XR←GetReferentType(var←c68252))) {
{
word wordSeq←v20752;
wordSeq←v20752 = var←c68252;
};
}
else {
lab←L100050: ;
SOURCE(12289, 6)
(void) (XR←MonitorExit((word) (( (bPt) gf←c81084)+16)/* LOCK←v2888 */ ));
return;
};
};
SOURCE(12297, 182)
{
register word i←v20808 = 0;
lab←L100054: ;
{
word t←v20852;
SOURCE(12332, 35)
t←v20852 = (* ((( (ptr) gf←c81084)+37)/* scratchMaps←v4400 */ +BCK(i←v20808, 10)) );
if ((t←v20852 == 0)) {
SOURCE(12397, 8)
slot←v20708 = i←v20808;
}
else {
if ((map←v20664 == t←v20852) || ((* (( (ptr) map←v20664)+10) ) == (* (( (ptr) t←v20852)+10) ))) {
SOURCE(12437, 42)
var←c68284 = (word) (( (bPt) gf←c81084)+268)/* var←c64156 */ ;
(void) (XR←MonitorExit((word) (( (bPt) gf←c81084)+16)/* LOCK←v2888 */ ));
goto lab←L100055;
};
};
};
if ((i←v20808 >= 9)) {
goto lab←L100051;
};
i←v20808 = (i←v20808 + 1);
goto lab←L100054;
lab←L100051: ;
};
SOURCE(12499, 129)
if (( (int)slot←v20708 >= (int)0)) {
SOURCE(12519, 23)
(* ((( (ptr) gf←c81084)+37)/* scratchMaps←v4400 */ +BCK(slot←v20708, 10)) ) = map←v20664;
}
else {
SOURCE(12551, 20)
(* (( (ptr) gf←c81084)+37) ) = map←v20664;
SOURCE(12573, 55)
{
register word i←v20896 = 1;
lab←L100059: ;
SOURCE(12608, 20)
(* ((( (ptr) gf←c81084)+37)/* scratchMaps←v4400 */ +BCK(i←v20896, 10)) ) = 0;
if ((i←v20896 >= 9)) {
goto lab←L100056;
};
i←v20896 = (i←v20896 + 1);
goto lab←L100059;
lab←L100056: ;
};
};
};
};
}
else {
lab←L100049: ;
};
};
SOURCE(12071, 557)
(void) (XR←MonitorExit((word) (( (bPt) gf←c81084)+16)/* LOCK←v2888 */ ));
return;
/* c2c skipped dead code */
lab←L100055: ;
SOURCE(12437, 42)
(void) XR←RaiseError(var←c68284, 0);
}
static void ClearScratchMaps←P2040()
{
register ptr gf←c81116 = (ptr) &globalframe;
/* ClearScratchMaps: */
SOURCE(12658, 88)
(void) (XR←MonitorEntry((word) (( (bPt) gf←c81116)+16)/* LOCK←v2888 */ ));
SOURCE(12691, 55)
{
register word i←v20940 = 1;
lab←L100064: ;
SOURCE(12726, 20)
(* ((( (ptr) gf←c81116)+37)/* scratchMaps←v4400 */ +BCK(i←v20940, 10)) ) = 0;
if ((i←v20940 >= 9)) {
goto lab←L100061;
};
i←v20940 = (i←v20940 + 1);
goto lab←L100064;
lab←L100061: ;
};
SOURCE(12658, 88)
(void) (XR←MonitorExit((word) (( (bPt) gf←c81116)+16)/* LOCK←v2888 */ ));
return;
}
static void DoWithScratchMap←P2100(box←v10728, bitsPerSample←v10756, formal←c01360)
W4 box←v10728;
word bitsPerSample←v10756;
word formal←c01360;
{
W6 var←c81148;
/* declaration of action←v10784 skipped */
/* declaration of scratch←v20984 skipped */
var←c81148.f4/* action←v10784 */ = formal←c01360;
/* DoWithScratchMap: */
SOURCE(12761, 274)
SOURCE(12868, 83)
var←c81148.f5/* scratch←v20984 */ = (word) ObtainScratchMap←P1920(box←v10728, bitsPerSample←v10756, 0);
SOURCE(12953, 54)
{
word var←c01317;
var←c01317 = (word) &var←c81148;
(void) (word) XR←Enable(( ((word) (fPt) NoName←Q20856) ), ( ((word) (fPt) NoName←Q20916) ), var←c01317);
};
SOURCE(13009, 26)
(void) ReleaseScratchMap←P1980(var←c81148.f5/* scratch←v20984 */ );
}
static word NoName←Q20856(formal←c01276)
word formal←c01276;
{
SOURCE(12953, 54)
{
word pd55;
pd55 = (* (( (ptr) formal←c01276)+4) );
(void) ( *( (fPt) ((* (ptr) pd55 ))))((* ((( (ptr) formal←c01276)+5)) ), pd55);
};
return(0);
}
static void InPlaceClip←P2160(map←v10904, box←v10932)
word map←v10904;
W4 box←v10932;
{
W4 newBox←v21028;
word skipBits←v21056;
/* InPlaceClip: */
SOURCE(13040, 307)
SOURCE(13102, 46)
{
W4 box1←v63096;
box1←v63096 = (* (W4Pt) map←v10904 );
{
W2 v1←v48904;
W2 v2←v48936;
v1←v48904 = (* (W2Pt) &box←v10932 );
v2←v48936 = (* (W2Pt) &box1←v63096 );
if (( (int)v2←v48936.f0 >= (int)v1←v48904.f0)) {
newBox←v21028.f0 = v2←v48936.f0;
}
else {
newBox←v21028.f0 = v1←v48904.f0;
};
if (( (int)v2←v48936.f1 >= (int)v1←v48904.f1)) {
newBox←v21028.f1 = v2←v48936.f1;
}
else {
newBox←v21028.f1 = v1←v48904.f1;
};
};
{
W2 v1←v49280;
W2 v2←v49312;
v1←v49280 = (* (W2Pt) (( (ptr) &box1←v63096)+2) );
v2←v49312 = (* (W2Pt) (( (ptr) &box←v10932)+2) );
if (( (int)v1←v49280.f0 <= (int)v2←v49312.f0)) {
newBox←v21028.f2 = v1←v49280.f0;
}
else {
newBox←v21028.f2 = v2←v49312.f0;
};
if (( (int)v1←v49280.f1 <= (int)v2←v49312.f1)) {
newBox←v21028.f3 = v1←v49280.f1;
}
else {
newBox←v21028.f3 = v2←v49312.f1;
};
};
};
SOURCE(13150, 128)
{
word idx56;
word idx57;
skipBits←v21056 = (((
idx56 = (word) (newBox←v21028.f0 - (* (ptr) map←v10904 )),
SGNCK(idx56)
) * (* (( (ptr) map←v10904)+7) )) + ((
idx57 = (word) (newBox←v21028.f1 - (* (( (ptr) map←v10904)+1) )),
SGNCK(idx57)
) * (* (( (ptr) map←v10904)+5) )));
};
SOURCE(13280, 26)
{
W4 box←v56420;
box←v56420 = newBox←v21028;
SOURCE(1846, 74)
if (( (int)box←v56420.f0 >= (int)box←v56420.f2) || ( (int)box←v56420.f1 >= (int)box←v56420.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56420)+2) ) = (* (W2Pt) &box←v56420 );
};
SOURCE(1922, 12)
(* (W4Pt) map←v10904 ) = box←v56420;
};
SOURCE(13308, 39)
{
W2 var←c68540;
W2 addr←v58088;
addr←v58088 = (* (W2Pt) (( (ptr) map←v10904)+8) );
{
word bitOffset←v18252;
word mod←v18280;
bitOffset←v18252 = (skipBits←v21056 + addr←v58088.f1);
mod←v18280 = (bitOffset←v18252 & 037);
SOURCE(2833, 63)
var←c68540.f0 = (addr←v58088.f0 + IOP2( / , (int)(bitOffset←v18252 - mod←v18280), (int)8));
var←c68540.f1 = mod←v18280;
};
(* (W2Pt) (( (ptr) map←v10904)+8) ) = var←c68540;
};
}
static void InPlaceShift←P2340(map←v11256, delta←v11284)
word map←v11256;
W2 delta←v11284;
{
W2 newmin←v21100;
W2 newmax←v21128;
W4 chk←v21156;
/* InPlaceShift: */
SOURCE(13678, 354)
SOURCE(13753, 50)
{
W2 a←v60424;
a←v60424 = (* (W2Pt) map←v11256 );
SOURCE(13614, 60)
{
word a←v60156;
word b←v60184;
a←v60156 = a←v60424.f0;
b←v60184 = delta←v11284.f0;
SOURCE(13415, 136)
if (( (int)a←v60156 > (int)0)) {
SOURCE(13429, 63)
if (( (int)b←v60184 < (int)(2147483647 - a←v60156))) {
newmin←v21100.f0 = (a←v60156 + b←v60184);
}
else {
newmin←v21100.f0 = 2147483647;
};
}
else {
SOURCE(13492, 59)
if (( (int)b←v60184 > (int)(2147483648 - a←v60156))) {
newmin←v21100.f0 = (a←v60156 + b←v60184);
}
else {
newmin←v21100.f0 = 2147483648;
};
};
};
{
word a←v60080;
word b←v60108;
a←v60080 = a←v60424.f1;
b←v60108 = delta←v11284.f1;
SOURCE(13415, 136)
if (( (int)a←v60080 > (int)0)) {
SOURCE(13429, 63)
if (( (int)b←v60108 < (int)(2147483647 - a←v60080))) {
newmin←v21100.f1 = (a←v60080 + b←v60108);
}
else {
newmin←v21100.f1 = 2147483647;
};
}
else {
SOURCE(13492, 59)
if (( (int)b←v60108 > (int)(2147483648 - a←v60080))) {
newmin←v21100.f1 = (a←v60080 + b←v60108);
}
else {
newmin←v21100.f1 = 2147483648;
};
};
};
};
SOURCE(13805, 50)
{
W2 a←v60232;
a←v60232 = (* (W2Pt) (( (ptr) map←v11256)+2) );
SOURCE(13614, 60)
{
word a←v60280;
word b←v60308;
a←v60280 = a←v60232.f0;
b←v60308 = delta←v11284.f0;
SOURCE(13415, 136)
if (( (int)a←v60280 > (int)0)) {
SOURCE(13429, 63)
if (( (int)b←v60308 < (int)(2147483647 - a←v60280))) {
newmax←v21128.f0 = (a←v60280 + b←v60308);
}
else {
newmax←v21128.f0 = 2147483647;
};
}
else {
SOURCE(13492, 59)
if (( (int)b←v60308 > (int)(2147483648 - a←v60280))) {
newmax←v21128.f0 = (a←v60280 + b←v60308);
}
else {
newmax←v21128.f0 = 2147483648;
};
};
};
{
word a←v60352;
word b←v60380;
a←v60352 = a←v60232.f1;
b←v60380 = delta←v11284.f1;
SOURCE(13415, 136)
if (( (int)a←v60352 > (int)0)) {
SOURCE(13429, 63)
if (( (int)b←v60380 < (int)(2147483647 - a←v60352))) {
newmax←v21128.f1 = (a←v60352 + b←v60380);
}
else {
newmax←v21128.f1 = 2147483647;
};
}
else {
SOURCE(13492, 59)
if (( (int)b←v60380 > (int)(2147483648 - a←v60352))) {
newmax←v21128.f1 = (a←v60352 + b←v60380);
}
else {
newmax←v21128.f1 = 2147483648;
};
};
};
};
SOURCE(13857, 82)
chk←v21156.f0 = (newmin←v21100.f0 - delta←v11284.f0);
chk←v21156.f1 = (newmin←v21100.f1 - delta←v11284.f1);
chk←v21156.f2 = (newmax←v21128.f0 - delta←v11284.f0);
chk←v21156.f3 = (newmax←v21128.f1 - delta←v11284.f1);
SOURCE(13941, 43)
if ( ! XR←EqualWords(&chk←v21156, map←v11256, 4)) {
SOURCE(13963, 21)
(void) InPlaceClip←P2160(map←v11256, chk←v21156);
};
SOURCE(13986, 46)
{
W4 box←v56372;
(* (W2Pt) &box←v56372 ) = newmin←v21100;
(* (W2Pt) (( (ptr) &box←v56372)+2) ) = newmax←v21128;
SOURCE(1846, 74)
if (( (int)box←v56372.f0 >= (int)box←v56372.f2) || ( (int)box←v56372.f1 >= (int)box←v56372.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56372)+2) ) = (* (W2Pt) &box←v56372 );
};
SOURCE(1922, 12)
(* (W4Pt) map←v11256 ) = box←v56372;
};
}
static word ObtainUnsafeDescriptor←P2400(size←v11344, bitsPerSample←v11372, bitsPerLine←v11400, base←v11428, ref←v11456, words←v11484, rawMin←v11512, delta←v11540)
W2 size←v11344;
word bitsPerSample←v11372;
word bitsPerLine←v11400;
W2 base←v11428;
word ref←v11456;
word words←v11484;
W2 rawMin←v11512;
W2 delta←v11540;
{
word var←c11596;
word new←v21200;
/* ObtainUnsafeDescriptor: */
SOURCE(14038, 541)
SOURCE(14252, 212)
{
word var←c68956;
var←c68956 = (word) NewDescriptor←P1800(0);
{
W4 var←c68988;
var←c68988.f0 = 0;
var←c68988.f1 = 0;
var←c68988.f2 = (rawMin←v11512.f0 + size←v11344.f0);
var←c68988.f3 = (rawMin←v11512.f1 + size←v11344.f1);
new←v21200 = (word) UnsafeNewSampleMap←P1320(var←c68988, bitsPerSample←v11372, bitsPerLine←v11400, base←v11428, ref←v11456, words←v11484
, var←c68956);
};
};
SOURCE(14466, 39)
{
W2 var←c69020;
var←c69020.f0 = INEG(rawMin←v11512.f0);
var←c69020.f1 = INEG(rawMin←v11512.f1);
(void) InPlaceShift←P2340(new←v21200, var←c69020);
};
SOURCE(14507, 32)
{
W4 var←c69052;
var←c69052.f0 = 0;
var←c69052.f1 = 0;
(* (W2Pt) (( (ptr) &var←c69052)+2) ) = size←v11344;
(void) InPlaceClip←P2160(new←v21200, var←c69052);
};
SOURCE(14541, 24)
(void) InPlaceShift←P2340(new←v21200, delta←v11540);
SOURCE(14567, 12)
return(new←v21200);
}
static void CheckBuffer←P2460(map←v11656, sInitIndex←v11684, fInitIndex←v11712, sDelta←v11740, fDelta←v11768, count←v11796)
word map←v11656;
word sInitIndex←v11684;
word fInitIndex←v11712;
word sDelta←v11740;
word fDelta←v11768;
word count←v11796;
{
/* CheckBuffer: */
SOURCE(14585, 619)
SOURCE(14712, 492)
if ((count←v11796 != 0)) {
SOURCE(14730, 476)
{
word countMinus1←v21244;
word s0←v21272;
word s1←v21300;
word f0←v21328;
word f1←v21356;
SOURCE(14732, 30)
countMinus1←v21244 = (count←v11796 - 1);
SOURCE(14764, 24)
s0←v21272 = sInitIndex←v11684;
SOURCE(14790, 73)
s1←v21300 = (sInitIndex←v11684 + ( ( (int)sDelta←v11740 == (int)0) ? 0 : IOP2( * , (int)sDelta←v11740, (int)countMinus1←v21244)
) );
SOURCE(14865, 24)
f0←v21328 = fInitIndex←v11712;
SOURCE(14891, 83)
f1←v21356 = (fInitIndex←v11712 + ( ( (int)fDelta←v11768 == (int)1) ? countMinus1←v21244 : IOP2( * , (int)fDelta←v11768, (int)countMinus1←v21244)
) );
SOURCE(14976, 51)
if (( (int)s0←v21272 > (int)s1←v21300)) {
SOURCE(14992, 35)
{
word t←v21400;
SOURCE(14994, 15)
t←v21400 = s0←v21272;
SOURCE(15011, 7)
s0←v21272 = s1←v21300;
SOURCE(15020, 7)
s1←v21300 = t←v21400;
};
};
SOURCE(15030, 51)
if (( (int)f0←v21328 > (int)f1←v21356)) {
SOURCE(15046, 35)
{
word t←v21444;
SOURCE(15048, 15)
t←v21444 = f0←v21328;
SOURCE(15065, 7)
f0←v21328 = f1←v21356;
SOURCE(15074, 7)
f1←v21356 = t←v21444;
};
};
SOURCE(15084, 120)
if (((( (int)s0←v21272 < (int)(* (ptr) map←v11656 )) || ( (int)f0←v21328 < (int)(* (( (ptr) map←v11656)+1) ))) || ( (int)s1←v21300 >= (int)(* (
( (ptr) map←v11656)+2) ))) || ( (int)f1←v21356 >= (int)(* (( (ptr) map←v11656)+3) ))) {
SOURCE(15179, 25)
(void) XR←RaiseBoundsFault();
};
};
};
}
static void ReIndexGetSamples←P2520(self←v11928, initIndex←v11956, buffer←v11984, start←v12012, count←v12040)
word self←v11928;
W2 initIndex←v11956;
word buffer←v11984;
word start←v12012;
word count←v12040;
{
register ptr gf←c81180 = (ptr) &globalframe;
word data←v21488;
/* ReIndexGetSamples: */
SOURCE(15278, 337)
SOURCE(15390, 44)
data←v21488 = XR←Narrow((* (( (ptr) self←v11928)+8) ), (* (( (ptr) gf←c81180)+50) ));
SOURCE(15436, 39)
{
word x58;
count←v12040 = (x58 = ((* (ptr) buffer←v11984 ) - start←v12012),
MIN((int)(word), x58, count←v12040));
};
SOURCE(15477, 138)
if ((count←v12040 > 0)) {
SOURCE(15497, 118)
{
W2 var←c69084;
{
W2 var←c69116;
W2 v2←v61676;
v2←v61676 = (* (W2Pt) data←v21488 );
var←c69116.f0 = (initIndex←v11956.f0 - v2←v61676.f0);
var←c69116.f1 = (initIndex←v11956.f1 - v2←v61676.f1);
var←c69084 = var←c69116;
};
{
W2 var←c69180;
var←c69180.f0 = 0;
var←c69180.f1 = 1;
(void) GetSamples←P3240((* (( (ptr) data←v21488)+2) ), var←c69084, var←c69180, buffer←v11984, start←v12012, count←v12040)
;
};
};
};
}
static void ReIndexPutSamples←P2580(self←v12100, initIndex←v12128, buffer←v12156, start←v12184, count←v12212, function←v12240)
word self←v12100;
W2 initIndex←v12128;
word buffer←v12156;
word start←v12184;
word count←v12212;
word function←v12240;
{
register ptr gf←c81212 = (ptr) &globalframe;
word data←v21544;
/* ReIndexPutSamples: */
SOURCE(15624, 377)
SOURCE(15756, 44)
data←v21544 = XR←Narrow((* (( (ptr) self←v12100)+8) ), (* (( (ptr) gf←c81212)+50) ));
SOURCE(15802, 39)
{
word x59;
count←v12212 = (x59 = ((* (ptr) buffer←v12156 ) - start←v12184),
MIN((int)(word), x59, count←v12212));
};
SOURCE(15843, 158)
if ((count←v12212 > 0)) {
SOURCE(15863, 138)
{
W2 var←c69212;
{
W2 var←c69244;
W2 v2←v61628;
v2←v61628 = (* (W2Pt) data←v21544 );
var←c69244.f0 = (initIndex←v12128.f0 - v2←v61628.f0);
var←c69244.f1 = (initIndex←v12128.f1 - v2←v61628.f1);
var←c69212 = var←c69244;
};
{
W2 var←c69308;
var←c69308.f0 = 0;
var←c69308.f1 = 1;
(void) PutSamples←P3300((* (( (ptr) data←v21544)+2) ), var←c69212, var←c69308, buffer←v12156, start←v12184, count←v12212
, function←v12240);
};
};
};
}
static word ReIndex←P2640(map←v12300, delta←v12328, box←v12356)
word map←v12300;
W2 delta←v12328;
W4 box←v12356;
{
register ptr gf←c81244 = (ptr) &globalframe;
word var←c12400;
/* ReIndex: */
SOURCE(16010, 654)
SOURCE(16102, 562)
{
word var←c69340;
var←c69340 = map←v12300;
if ((var←c69340 == 0)) {
goto lab←L100081;
};
{
word var←c69500;
var←c69500 = (* (( (ptr) var←c69340)+6) );
if ((var←c69500 == 0)) {
{
word map←v21600;
map←v21600 = var←c69340;
SOURCE(16147, 107)
{
word new←v21644;
SOURCE(16149, 41)
new←v21644 = (word) NewDescriptor←P1800(map←v21600);
SOURCE(16192, 24)
(void) InPlaceShift←P2340(new←v21644, delta←v12328);
SOURCE(16218, 21)
(void) InPlaceClip←P2160(new←v21644, box←v12356);
SOURCE(16241, 13)
return(new←v21644);
};
};
}
else {
if ((var←c69500 == 1)) {
{
word map←v21688;
map←v21688 = var←c69340;
SOURCE(16281, 357)
{
word data←v21732;
W4 newBox←v21760;
word new←v21788;
SOURCE(16283, 74)
data←v21732 = XR←NewObject(12, (* (( (ptr) gf←c81244)+50) ));
(* (W2Pt) data←v21732 ) = delta←v12328;
(* (( (ptr) data←v21732)+2) ) = map←v21688;
SOURCE(16359, 69)
{
W4 var←c69404;
{
W4 var←c69436;
W4 box←v63464;
box←v63464 = (* (W4Pt) map←v21688 );
var←c69436.f0 = (box←v63464.f0 + delta←v12328.f0);
var←c69436.f1 = (box←v63464.f1 + delta←v12328.f1);
var←c69436.f2 = (box←v63464.f2 + delta←v12328.f0);
var←c69436.f3 = (box←v63464.f3 + delta←v12328.f1);
var←c69404 = var←c69436;
};
{
W4 var←c0371;
{
/*1*/ word pd60;
/*1*/ pd60 = (* (( (ptr) (* (( (ptr) gf←c81244)+225)/* var←c67164 */ ))+15) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd60 ))))((word) &var←c0371, box←v12356, var←c69404, pd60);
/*1*/ };
newBox←v21760 = var←c0371;
};
};
SOURCE(16430, 193)
new←v21788 = (word) NewObjectSampleMap←P1680(newBox←v21760, (* (( (ptr) map←v21688)+5) ), (word) (( (bPt) gf←c81244)+568)
/* var←c65372 */ , ( (0 != (* (( (ptr) map←v21688)+4) )) ? 0 : (word) (( (bPt) gf←c81244)+560)/* var←c65340 */ ) , data←v21732)
;
SOURCE(16625, 13)
return(new←v21788);
};
};
}
else {
lab←L100081: ;
SOURCE(16652, 12)
return(0);
};
};
};
};
}
static word Clip←P2700(map←v12460, box←v12488)
word map←v12460;
W4 box←v12488;
{
word var←c12532;
/* Clip: */
SOURCE(16670, 120)
SOURCE(16739, 51)
{
word var←c01318;
{
W2 var←c69564;
var←c69564.f0 = 0;
var←c69564.f1 = 0;
var←c01318 = (word) ReIndex←P2640(map←v12460, var←c69564, box←v12488);
};
return(var←c01318);
};
}
static word Shift←P2760(map←v12592, delta←v12620)
word map←v12592;
W2 delta←v12620;
{
register ptr gf←c81276 = (ptr) &globalframe;
word var←c12664;
/* Shift: */
SOURCE(16796, 124)
SOURCE(16868, 52)
return((word) ReIndex←P2640(map←v12592, delta←v12620, (* (W4Pt) (( (ptr) gf←c81276)+209)/* var←c66396 */ )));
}
static word ZeroOrigin←P2820(map←v12724)
word map←v12724;
{
register ptr gf←c81308 = (ptr) &globalframe;
word var←c12768;
/* ZeroOrigin: */
SOURCE(16926, 137)
SOURCE(16991, 72)
{
W2 var←c69692;
W2 v←v62300;
W2 var←c69660;
v←v62300 = (* (W2Pt) map←v12724 );
var←c69692.f0 = INEG(v←v62300.f0);
var←c69692.f1 = INEG(v←v62300.f1);
var←c69660 = (var←c69692
);
return((word) ReIndex←P2640(map←v12724, var←c69660, (* (W4Pt) (( (ptr) gf←c81308)+209)/* var←c66396 */ )));
};
}
static void GetUnsafeBlock←P2880(formal←c0397, map←v12828)
word formal←c0397;
word map←v12828;
{
word var←c01387;
word var←c01388;
word var←c01389;
W2 size←v21844;
word bitsPerLine←v21872;
word dataBitsPerLine←v21900;
word fillBitsPerLine←v21928;
word padStart←v21956;
word nBytes←v21984;
/* GetUnsafeBlock: */
SOURCE(17069, 440)
/* Return var split */
SOURCE(17153, 27)
{
word map←v56228;
map←v56228 = map←v12828;
SOURCE(1717, 74)
size←v21844.f0 = ((* (( (ptr) map←v56228)+2) ) - (* (ptr) map←v56228 ));
size←v21844.f1 = ((* (( (ptr) map←v56228)+3) ) - (* (( (ptr) map←v56228)+1) ));
};
SOURCE(17182, 35)
bitsPerLine←v21872 = (* (( (ptr) map←v12828)+7) );
SOURCE(17219, 60)
{
word idx61;
dataBitsPerLine←v21900 = ((* (( (ptr) map←v12828)+5) ) * (
idx61 = (word) size←v21844.f1,
SGNCK(idx61)
));
};
SOURCE(17281, 55)
fillBitsPerLine←v21928 = BCK((bitsPerLine←v21872 - dataBitsPerLine←v21900), 1);
SOURCE(17338, 37)
{
word idx62;
padStart←v21956 = (
idx62 = ((* (( (ptr) map←v12828)+9) ) & 7),
BCK(idx62, 1)
);
};
SOURCE(17377, 46)
{
word idx63;
nBytes←v21984 = ((word) (((
idx63 = (word) size←v21844.f0,
SGNCK(idx63)
) * bitsPerLine←v21872) + 7) >> 3);
};
SOURCE(17425, 84)
var←c01387 = (* (( (ptr) map←v12828)+8) );
var←c01388 = ((* (( (ptr) map←v12828)+9) ) >> 3);
var←c01389 = nBytes←v21984;
/* removed tail goto */
(* (( (ptr) formal←c0397)+2) ) = var←c01389;
(* (( (ptr) formal←c0397)+1) ) = var←c01388;
(* (ptr) formal←c0397 ) = var←c01387;
return;
}
static word ApplyFunction←P2940(function←v12932, dstVal←v12960, srcVal←v12988)
word function←v12932;
word dstVal←v12960;
word srcVal←v12988;
{
word var←c13032;
/* ApplyFunction: */
SOURCE(17513, 354)
SOURCE(17606, 68)
if (( (unsigned) (function←v12932 & 1) == 1)) {
SOURCE(17644, 30)
srcVal←v12988 = (word) XRM←BITNOT(srcVal←v12988);
};
SOURCE(17676, 191)
{
word var←c69884;
var←c69884 = (unsigned) (((unsigned)function←v12932 << 29) >> 30);
switch (var←c69884) {
case 0:
SOURCE(17713, 15)
return(srcVal←v12988);
case 1:
SOURCE(17737, 38)
return((word) XRM←BITAND(dstVal←v12960, srcVal←v12988));
case 2:
SOURCE(17783, 37)
return((word) XRM←BITOR(dstVal←v12960, srcVal←v12988));
case 3:
SOURCE(17829, 38)
return((word) XRM←BITXOR(dstVal←v12960, srcVal←v12988));
default:
SOURCE(17880, 5)
(void) XR←RaiseUnnamedError();
break;
};
};
}
static void ApplyToSamples←P3000(function←v13092, dst←v13120, src←v13148, start←v13176, count←v13204)
word function←v13092;
word dst←v13120;
word src←v13148;
word start←v13176;
word count←v13204;
{
register ptr gf←c81340 = (ptr) &globalframe;
word clippedCount←v22068;
word d←v22096;
word s←v22124;
/* ApplyToSamples: */
SOURCE(17891, 557)
SOURCE(17987, 77)
{
word x64;
word x65;
word x66;
word idx67;
clippedCount←v22068 = (
idx67 = (word) (x64 = ((* (ptr) dst←v13120 ) - start←v13176),
x65 = MIN((int)(word), count←v13204, x64),
x66 = ((* (ptr) src←v13148 ) - start←v13176),
MIN((int)(word), x65, x66)),
SGNCK(idx67)
);
};
SOURCE(18066, 61)
d←v22096 = (word) PointerToSamples←P1020(dst←v13120, start←v13176, SGNCK(clippedCount←v22068));
SOURCE(18129, 61)
s←v22124 = (word) PointerToSamples←P1020(src←v13148, start←v13176, SGNCK(clippedCount←v22068));
SOURCE(18192, 256)
if ((clippedCount←v22068 != 0)) {
SOURCE(18225, 225)
{
word bits←v22168;
SOURCE(18227, 44)
bits←v22168 = ((word) clippedCount←v22068 << 5);
SOURCE(18273, 175)
{
W2 var←c70012;
W2 var←c70044;
var←c70012.f0 = d←v22096;
var←c70012.f1 = 0;
var←c70044.f0 = s←v22124;
var←c70044.f1 = 0;
{
word pd68;
pd68 = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81340)+226)/* var←c70076 */ ))+8) ))+(((unsigned)function←v13092 << 29) >> 30))
)+(function←v13092 & 1)) );
(void) ( *( (fPt) ((* (ptr) pd68 ))))(var←c70012, var←c70044, bits←v22168, bits←v22168, 1, bits←v22168, pd68);
};
};
};
};
}
static word Get←P3120(map←v13388, index←v13416)
word map←v13388;
W2 index←v13416;
{
register ptr gf←c81372 = (ptr) &globalframe;
word var←c13460;
/* Get: */
SOURCE(18553, 1083)
SOURCE(18628, 1008)
{
word var←c70108;
var←c70108 = map←v13388;
if ((var←c70108 == 0)) {
goto lab←L100086;
};
{
word var←c70684;
var←c70684 = (* (( (ptr) var←c70108)+6) );
if ((var←c70684 == 0)) {
{
word map←v22212;
map←v22212 = var←c70108;
SOURCE(18673, 627)
{
W2 size←v22256;
W2 v←v22284;
word bitsPerSample←v22312;
word bitIndex←v22340;
word pointer←v22368;
word shiftAmt←v22396;
word mask←v22424;
word shiftedBits←v22452;
SOURCE(18675, 27)
{
word map←v56180;
map←v56180 = map←v22212;
SOURCE(1717, 74)
size←v22256.f0 = ((* (( (ptr) map←v56180)+2) ) - (* (ptr) map←v56180 ));
size←v22256.f1 = ((* (( (ptr) map←v56180)+3) ) - (* (( (ptr) map←v56180)+1) ));
};
SOURCE(18704, 41)
{
W2 v2←v61580;
v2←v61580 = (* (W2Pt) map←v22212 );
v←v22284.f0 = (index←v13416.f0 - v2←v61580.f0);
v←v22284.f1 = (index←v13416.f1 - v2←v61580.f1);
};
SOURCE(18747, 38)
bitsPerSample←v22312 = (* (( (ptr) map←v22212)+5) );
SOURCE(18787, 123)
{
word var←c70268;
word limit←v58692;
word var←c01319;
word var←c70332;
word limit←v58644;
word var←c01320;
{
word idx69;
limit←v58692 = (
idx69 = (word) size←v22256.f0,
SGNCK(idx69)
);
};
SOURCE(3132, 92)
if ((v←v22284.f0 >= limit←v58692)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81372)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
word idx70;
var←c70268 = (
/*1*/ idx70 = (word) v←v22284.f0,
/*1*/ SGNCK(idx70)
/*1*/ );
};
};
var←c01319 = (var←c70268 * (* (( (ptr) map←v22212)+7) ));
{
word idx71;
limit←v58644 = (
idx71 = (word) size←v22256.f1,
SGNCK(idx71)
);
};
SOURCE(3132, 92)
if ((v←v22284.f1 >= limit←v58644)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81372)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
word idx72;
var←c70332 = (
/*1*/ idx72 = (word) v←v22284.f1,
/*1*/ SGNCK(idx72)
/*1*/ );
};
};
var←c01320 = (var←c01319 + (var←c70332 * bitsPerSample←v22312));
bitIndex←v22340 = (var←c01320 + (* (( (ptr) map←v22212)+9) ));
};
SOURCE(18912, 59)
{
word word←v58212;
word←v58212 = (* (( (ptr) map←v22212)+8) );
{
word mod←v18328;
mod←v18328 = (bitIndex←v22340 & 037);
SOURCE(3022, 40)
pointer←v22368 = (word←v58212 + IOP2( / , (int)(bitIndex←v22340 - mod←v18328), (int)8));
};
};
SOURCE(18973, 55)
{
word var←c70396;
word i←v60840;
i←v60840 = SGNCK(bitIndex←v22340);
SOURCE(18510, 39)
var←c70396 = (i←v60840 & 037);
shiftAmt←v22396 = ((var←c70396 + bitsPerSample←v22312) - 32);
};
SOURCE(19030, 39)
{
word var←c70428;
{
word i←v60888;
i←v60888 = (32 - bitsPerSample←v22312);
SOURCE(18510, 39)
var←c70428 = (i←v60888 & 037);
};
mask←v22424 = (word) XRM←BITRSHIFT( (word) -1, var←c70428);
};
SOURCE(19071, 185)
if (( (int)shiftAmt←v22396 <= (int)0)) {
{
word var←c70492;
{
word i←v60792;
i←v60792 = INEG(shiftAmt←v22396);
SOURCE(18510, 39)
var←c70492 = (i←v60792 & 037);
};
shiftedBits←v22452 = (word) XRM←BITRSHIFT((* (ptr) pointer←v22368 ), var←c70492);
};
}
else {
{
word var←c70556;
word var←c01321;
{
word i←v60744;
i←v60744 = (32 - shiftAmt←v22396);
SOURCE(18510, 39)
var←c70556 = (i←v60744 & 037);
};
var←c01321 = (word) XRM←BITRSHIFT((* (( (ptr) pointer←v22368)+1) ), var←c70556);
shiftedBits←v22452 = ((word) XRM←BITLSHIFT((* (ptr) pointer←v22368 ), (shiftAmt←v22396 & 037)) + var←c01321);
};
};
SOURCE(19258, 40)
return((word) XRM←BITAND(shiftedBits←v22452, mask←v22424));
};
};
}
else {
if ((var←c70684 == 1)) {
{
word map←v22496;
map←v22496 = var←c70108;
SOURCE(19327, 309)
{
word buffer←v22540;
word sample←v22568 = 0;
word true←v22596;
word class←v22624;
SOURCE(19329, 46)
buffer←v22540 = (word) ObtainScratchSamples←P780(1);
SOURCE(19397, 52)
{
word var←c70652;
W4 box←v63224;
box←v63224 = (* (W4Pt) map←v22496 );
if ( ( ( (int)index←v13416.f0 >= (int)box←v63224.f0) ? ( (int)index←v13416.f0 < (int)box←v63224.f2) : 0 ) ) {
if (( (int)index←v13416.f1 >= (int)box←v63224.f1)) {
/*1*/ var←c70652 = (unsigned) ( (int)index←v13416.f1 < (int)box←v63224.f3);
/*1*/ }
else {
/*1*/ var←c70652 = (unsigned) 0;
/*1*/ };
}
else {
var←c70652 = (unsigned) 0;
};
true←v22596 = BCK((var←c70652 - 1), 1);
};
SOURCE(19451, 33)
class←v22624 = (* (( (ptr) map←v22496)+7) );
SOURCE(19486, 81)
{
word pd73;
pd73 = (* (ptr) class←v22624 );
(void) ( *( (fPt) ((* (ptr) pd73 ))))(map←v22496, index←v13416, buffer←v22540, 0, 1, pd73);
};
SOURCE(19569, 18)
{
word limit74;
sample←v22568 = (* ((( (ptr) buffer←v22540)+2)+(
/*1*/ limit74 = (* (( (ptr) buffer←v22540)+1) ),
/*1*/ BCK(0, limit74)
/*1*/ )) );
};
SOURCE(19589, 29)
(void) ReleaseScratchSamples←P840(buffer←v22540);
SOURCE(19620, 16)
return(sample←v22568);
};
};
}
else {
lab←L100086: ;
SOURCE(19650, 5)
(void) XR←RaiseUnnamedError();
};
};
};
};
}
static void Put←P3180(map←v13520, index←v13548, value←v13576, function←v13604)
word map←v13520;
W2 index←v13548;
word value←v13576;
word function←v13604;
{
register ptr gf←c81404 = (ptr) &globalframe;
word false←v22688;
/* Put: */
SOURCE(19661, 910)
SOURCE(19761, 41)
{
word idx75;
false←v22688 = (
idx75 = (* (( (ptr) map←v13520)+4) ),
BCK(idx75, 1)
);
};
SOURCE(19804, 767)
{
word var←c70716;
var←c70716 = map←v13520;
if ((var←c70716 == 0)) {
goto lab←L100097;
};
{
word var←c71036;
var←c71036 = (* (( (ptr) var←c70716)+6) );
if ((var←c71036 == 0)) {
{
word map←v22752;
map←v22752 = var←c70716;
SOURCE(19857, 397)
{
W2 size←v22796;
W2 v←v22824;
word bitsPerSample←v22852;
word bitIndex←v22880;
SOURCE(19859, 27)
{
word map←v56132;
map←v56132 = map←v22752;
SOURCE(1717, 74)
size←v22796.f0 = ((* (( (ptr) map←v56132)+2) ) - (* (ptr) map←v56132 ));
size←v22796.f1 = ((* (( (ptr) map←v56132)+3) ) - (* (( (ptr) map←v56132)+1) ));
};
SOURCE(19888, 41)
{
W2 v2←v61532;
v2←v61532 = (* (W2Pt) map←v22752 );
v←v22824.f0 = (index←v13548.f0 - v2←v61532.f0);
v←v22824.f1 = (index←v13548.f1 - v2←v61532.f1);
};
SOURCE(19931, 38)
bitsPerSample←v22852 = (* (( (ptr) map←v22752)+5) );
SOURCE(19971, 123)
{
word var←c70876;
word limit←v58596;
word var←c01322;
word var←c70908;
word limit←v58548;
word var←c01323;
{
word idx76;
limit←v58596 = (
idx76 = (word) size←v22796.f0,
SGNCK(idx76)
);
};
SOURCE(3132, 92)
if ((v←v22824.f0 >= limit←v58596)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81404)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
word idx77;
var←c70876 = (
/*1*/ idx77 = (word) v←v22824.f0,
/*1*/ SGNCK(idx77)
/*1*/ );
};
};
var←c01322 = (var←c70876 * (* (( (ptr) map←v22752)+7) ));
{
word idx78;
limit←v58548 = (
idx78 = (word) size←v22796.f1,
SGNCK(idx78)
);
};
SOURCE(3132, 92)
if ((v←v22824.f1 >= limit←v58548)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81404)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
word idx79;
var←c70908 = (
/*1*/ idx79 = (word) v←v22824.f1,
/*1*/ SGNCK(idx79)
/*1*/ );
};
};
var←c01323 = (var←c01322 + (var←c70908 * bitsPerSample←v22852));
bitIndex←v22880 = (var←c01323 + (* (( (ptr) map←v22752)+9) ));
};
SOURCE(20096, 156)
{
word var←c70940;
{
word i←v60696;
i←v60696 = (32 - bitsPerSample←v22852);
SOURCE(18510, 39)
var←c70940 = (i←v60696 & 037);
};
(void) Basics←CopyBits((* (( (ptr) map←v22752)+8) ), bitIndex←v22880, (word) &value←v13576, var←c70940, bitsPerSample←v22852)
;
};
};
};
}
else {
if ((var←c71036 == 1)) {
{
word map←v22924;
map←v22924 = var←c70716;
SOURCE(20281, 292)
{
word buffer←v22968;
word true←v22996;
word class←v23024;
SOURCE(20283, 46)
buffer←v22968 = (word) ObtainScratchSamples←P780(1);
SOURCE(20331, 52)
{
word var←c71004;
W4 box←v63176;
box←v63176 = (* (W4Pt) map←v22924 );
if ( ( ( (int)index←v13548.f0 >= (int)box←v63176.f0) ? ( (int)index←v13548.f0 < (int)box←v63176.f2) : 0 ) ) {
if (( (int)index←v13548.f1 >= (int)box←v63176.f1)) {
/*1*/ var←c71004 = (unsigned) ( (int)index←v13548.f1 < (int)box←v63176.f3);
/*1*/ }
else {
/*1*/ var←c71004 = (unsigned) 0;
/*1*/ };
}
else {
var←c71004 = (unsigned) 0;
};
true←v22996 = BCK((var←c71004 - 1), 1);
};
SOURCE(20385, 33)
class←v23024 = (* (( (ptr) map←v22924)+7) );
SOURCE(20420, 17)
{
word limit80;
(* ((( (ptr) buffer←v22968)+2)+(
/*1*/ limit80 = (* (( (ptr) buffer←v22968)+1) ),
/*1*/ BCK(0, limit80)
/*1*/ )) ) = value←v13576;
};
SOURCE(20439, 101)
{
word pd81;
pd81 = (* (( (ptr) class←v23024)+1) );
(void) ( *( (fPt) ((* (ptr) pd81 ))))(map←v22924, index←v13548, buffer←v22968, 0, 1, function←v13604, pd81);
};
SOURCE(20542, 29)
(void) ReleaseScratchSamples←P840(buffer←v22968);
};
};
}
else {
lab←L100097: ;
};
};
};
};
}
static void GetSamples←P3240(map←v13664, initIndex←v13692, delta←v13720, buffer←v13748, start←v13776, count←v13804)
word map←v13664;
W2 initIndex←v13692;
W2 delta←v13720;
word buffer←v13748;
word start←v13776;
word count←v13804;
{
register ptr gf←c81436 = (ptr) &globalframe;
W2 size←v23088;
/* GetSamples: */
SOURCE(20597, 2791)
SOURCE(20756, 27)
size←v23088.f0 = ((* (( (ptr) map←v13664)+2) ) - (* (ptr) map←v13664 ));
size←v23088.f1 = ((* (( (ptr) map←v13664)+3) ) - (* (( (ptr) map←v13664)+1) ));
SOURCE(20785, 39)
{
word x82;
count←v13804 = (x82 = ((* (ptr) buffer←v13748 ) - start←v13776),
MIN((int)(word), x82, count←v13804));
};
SOURCE(20826, 119)
(void) CheckBuffer←P2460(map←v13664, initIndex←v13692.f0, initIndex←v13692.f1, delta←v13720.f0, delta←v13720.f1, count←v13804)
;
SOURCE(20947, 2441)
if ( ( ( ( (int)delta←v13720.f0 == (int)0) ? ( (int)delta←v13720.f1 == (int)1) : 0 ) ? (count←v13804 != 0) : 0 ) ) {
SOURCE(20999, 540)
{
word var←c71100;
var←c71100 = map←v13664;
if ((var←c71100 == 0)) {
goto lab←L100104;
};
{
word var←c71420;
var←c71420 = (* (( (ptr) var←c71100)+6) );
if ((var←c71420 == 0)) {
{
word map←v23132;
map←v23132 = var←c71100;
SOURCE(21052, 330)
{
W2 v0←v23176;
word srcBitIndex←v23204;
SOURCE(21054, 46)
{
W2 v2←v61484;
v2←v61484 = (* (W2Pt) map←v23132 );
v0←v23176.f0 = (initIndex←v13692.f0 - v2←v61484.f0);
v0←v23176.f1 = (initIndex←v13692.f1 - v2←v61484.f1);
};
SOURCE(21102, 121)
{
word var←c71196;
word limit←v58500;
word var←c01324;
word var←c71228;
word limit←v58452;
{
word idx83;
limit←v58500 = (
/*1*/ idx83 = (word) size←v23088.f0,
/*1*/ SGNCK(idx83)
/*1*/ );
};
SOURCE(3132, 92)
if ((v0←v23176.f0 >= limit←v58500)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81436)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
/*1*/ word idx84;
/*1*/ var←c71196 = (
/*1*/ idx84 = (word) v0←v23176.f0,
/*1*/ SGNCK(idx84)
/*1*/ );
/*1*/ };
};
var←c01324 = (var←c71196 * (* (( (ptr) map←v23132)+7) ));
{
word idx85;
limit←v58452 = (
/*1*/ idx85 = (word) size←v23088.f1,
/*1*/ SGNCK(idx85)
/*1*/ );
};
SOURCE(3132, 92)
if ((v0←v23176.f1 >= limit←v58452)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81436)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
/*1*/ word idx86;
/*1*/ var←c71228 = (
/*1*/ idx86 = (word) v0←v23176.f1,
/*1*/ SGNCK(idx86)
/*1*/ );
/*1*/ };
};
srcBitIndex←v23204 = (var←c01324 + (var←c71228 * (* (( (ptr) map←v23132)+5) )));
};
SOURCE(21225, 155)
{
word var←c71260;
W2 var←c71324;
{
word var←c71292;
word check←v59704;
check←v59704 = (((* (( (ptr) buffer←v13748)+1) ) - start←v13776) - count←v13804);
SOURCE(4940, 67)
var←c71292 = (buffer←v13748 + ((word) ((word) (((word) BCK(start←v13776, 67108861) << 5) + 95) >> 5) << 2));
var←c71260 = var←c71292;
};
{
W2 var←c71356;
W2 addr←v57984;
addr←v57984 = (* (W2Pt) (( (ptr) map←v23132)+8) );
{
/*1*/ word bitOffset←v58016;
/*1*/ word mod←v58044;
/*1*/ bitOffset←v58016 = (srcBitIndex←v23204 + addr←v57984.f1);
/*1*/ mod←v58044 = (bitOffset←v58016 & 037);
SOURCE(2833, 63)
/*1*/ var←c71356.f0 = (addr←v57984.f0 + IOP2( / , (int)(bitOffset←v58016 - mod←v58044), (int)8));
/*1*/ var←c71356.f1 = mod←v58044;
/*1*/ };
var←c71324 = var←c71356;
};
{
word pd87;
pd87 = (* (( (ptr) (* (( (ptr) gf←c81436)+226)/* var←c70076 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd87 ))))(var←c71260, var←c71324, (* (( (ptr) map←v23132)+5) ), count←v13804, pd87);
};
};
};
};
}
else {
if ((var←c71420 == 1)) {
{
word map←v23248;
map←v23248 = var←c71100;
SOURCE(21409, 132)
{
word class←v23292;
SOURCE(21411, 33)
class←v23292 = (* (( (ptr) map←v23248)+7) );
SOURCE(21446, 93)
{
word pd88;
pd88 = (* (ptr) class←v23292 );
(void) ( *( (fPt) ((* (ptr) pd88 ))))(map←v23248, initIndex←v13692, buffer←v13748, start←v13776, count←v13804, pd88);
};
};
};
}
else {
lab←L100104: ;
SOURCE(21555, 5)
(void) XR←RaiseUnnamedError();
};
};
};
};
}
else {
SOURCE(21571, 1817)
{
word var←c71452;
var←c71452 = map←v13664;
if ((var←c71452 == 0)) {
goto lab←L100110;
};
{
word var←c72060;
var←c72060 = (* (( (ptr) var←c71452)+6) );
if ((var←c72060 == 0)) {
{
word map←v23336;
map←v23336 = var←c71452;
SOURCE(21624, 1521)
{
W2 v←v23380;
word bitsPerSample←v23408;
word bitIndex←v23436;
word bitIndexDelta←v23464;
SOURCE(21626, 45)
{
W2 v2←v61436;
v2←v61436 = (* (W2Pt) map←v23336 );
v←v23380.f0 = (initIndex←v13692.f0 - v2←v61436.f0);
v←v23380.f1 = (initIndex←v13692.f1 - v2←v61436.f1);
};
SOURCE(21673, 38)
bitsPerSample←v23408 = (* (( (ptr) map←v23336)+5) );
SOURCE(21713, 125)
{
word var←c71548;
word limit←v58404;
word var←c01325;
word var←c71580;
word limit←v58356;
word var←c01326;
{
word idx89;
limit←v58404 = (
/*1*/ idx89 = (word) size←v23088.f0,
/*1*/ SGNCK(idx89)
/*1*/ );
};
SOURCE(3132, 92)
if ((v←v23380.f0 >= limit←v58404)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81436)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
/*1*/ word idx90;
/*1*/ var←c71548 = (
/*1*/ idx90 = (word) v←v23380.f0,
/*1*/ SGNCK(idx90)
/*1*/ );
/*1*/ };
};
var←c01325 = (var←c71548 * (* (( (ptr) map←v23336)+7) ));
{
word idx91;
limit←v58356 = (
/*1*/ idx91 = (word) size←v23088.f1,
/*1*/ SGNCK(idx91)
/*1*/ );
};
SOURCE(3132, 92)
if ((v←v23380.f1 >= limit←v58356)) {
SOURCE(3175, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81436)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3211, 13)
{
/*1*/ word idx92;
/*1*/ var←c71580 = (
/*1*/ idx92 = (word) v←v23380.f1,
/*1*/ SGNCK(idx92)
/*1*/ );
/*1*/ };
};
var←c01326 = (var←c01325 + (var←c71580 * bitsPerSample←v23408));
bitIndex←v23436 = (var←c01326 + (* (( (ptr) map←v23336)+9) ));
};
SOURCE(21840, 82)
{
word idx93;
bitIndexDelta←v23464 = (IOP2( * , (int)(
/*1*/ idx93 = (* (( (ptr) map←v23336)+7) ),
/*1*/ SGNCK(idx93)
/*1*/ ), (int)delta←v13720.f0) + IOP2( * , (int)(* (( (ptr) map←v23336)+5) ), (int)delta←v13720.f1));
};
if ( ( ( (bitsPerSample←v23408 == 8) ? ((bitIndex←v23436 & 7) == 0) : 0 ) ? ((bitIndexDelta←v23464 & 7) == 0) : 0 ) ) {
SOURCE(22060, 590)
{
word step←v23508;
word bx←v23536;
word src←v23564;
word dst←v23592;
word lim←v23620;
word lim4←v23648;
SOURCE(22062, 38)
step←v23508 = IOP2( / , (int)bitIndexDelta←v23464, (int)8);
SOURCE(22102, 36)
bx←v23536 = ((word) bitIndex←v23436 >> 3);
SOURCE(22140, 55)
src←v23564 = (* (( (ptr) map←v23336)+8) );
SOURCE(22197, 75)
{
/*1*/ word check←v59660;
/*1*/ check←v59660 = (((* (( (ptr) buffer←v13748)+1) ) - start←v13776) - count←v13804);
SOURCE(4940, 67)
/*1*/ dst←v23592 = (buffer←v13748 + ((word) ((word) (((word) BCK(start←v13776, 67108861) << 5) + 95) >> 5) << 2));
/*1*/ };
SOURCE(22274, 43)
lim←v23620 = (dst←v23592 + ((word) count←v13804 << 2));
SOURCE(22319, 52)
lim4←v23648 = (lim←v23620 - ((word) (count←v13804 & 3) << 2));
SOURCE(22373, 180)
lab←L100117: ;
if ((dst←v23592 != lim4←v23648)) {
/*1*/ }
else {
/*1*/ goto lab←L100115;
/*1*/ };
SOURCE(22393, 16)
(* (ptr) dst←v23592 ) = (unsigned) (word) (* (( (bPt) src←v23564)+bx←v23536) );
SOURCE(22411, 14)
bx←v23536 = (bx←v23536 + step←v23508);
SOURCE(22427, 16)
(* (( (ptr) dst←v23592)+1) ) = (unsigned) (word) (* (( (bPt) src←v23564)+bx←v23536) );
SOURCE(22445, 14)
bx←v23536 = (bx←v23536 + step←v23508);
SOURCE(22461, 16)
(* (( (ptr) dst←v23592)+2) ) = (unsigned) (word) (* (( (bPt) src←v23564)+bx←v23536) );
SOURCE(22479, 14)
bx←v23536 = (bx←v23536 + step←v23508);
SOURCE(22495, 16)
(* (( (ptr) dst←v23592)+3) ) = (unsigned) (word) (* (( (bPt) src←v23564)+bx←v23536) );
SOURCE(22513, 14)
bx←v23536 = (bx←v23536 + step←v23508);
SOURCE(22529, 24)
dst←v23592 = (dst←v23592 + 16);
goto lab←L100117;
lab←L100115: ;
SOURCE(22564, 75)
lab←L100120: ;
if ((dst←v23592 != lim←v23620)) {
/*1*/ }
else {
/*1*/ goto lab←L100118;
/*1*/ };
SOURCE(22583, 16)
(* (ptr) dst←v23592 ) = (unsigned) (word) (* (( (bPt) src←v23564)+bx←v23536) );
SOURCE(22601, 22)
dst←v23592 = (dst←v23592 + 4);
SOURCE(22625, 14)
bx←v23536 = (bx←v23536 + step←v23508);
goto lab←L100120;
lab←L100118: ;
};
}
else {
SOURCE(22664, 478)
{
word mask←v23692;
SOURCE(22666, 39)
{
/*1*/ word var←c71644;
/*1*/ {
/*1*/ word i←v61032;
/*1*/ i←v61032 = (32 - bitsPerSample←v23408);
SOURCE(18510, 39)
/*1*/ var←c71644 = (i←v61032 & 037);
/*1*/ };
/*1*/ mask←v23692 = (word) XRM←BITRSHIFT( (word) -1, var←c71644);
/*1*/ };
SOURCE(22707, 424)
{
/*1*/ register word i←v23736;
/*1*/ register word noName←c71708;
/*1*/ i←v23736 = start←v13776;
/*1*/ noName←c71708 = (start←v13776 + count←v13804);
/*1*/ if ((i←v23736 >= noName←c71708)) {
/*1*/ goto lab←L100122;
/*1*/ };
/*1*/ lab←L100125: ;
/*1*/ {
/*1*/ word pointer←v23780;
/*1*/ word shiftAmt←v23808;
/*1*/ word shiftedBits←v23836;
SOURCE(22745, 59)
/*1*/ {
/*1*/ word word←v58136;
/*1*/ word←v58136 = (* (( (ptr) map←v23336)+8) );
/*1*/ {
/*1*/ word mod←v58168;
/*1*/ mod←v58168 = (bitIndex←v23436 & 037);
SOURCE(3022, 40)
/*1*/ pointer←v23780 = (word←v58136 + IOP2( / , (int)(bitIndex←v23436 - mod←v58168), (int)8));
/*1*/ };
/*1*/ };
SOURCE(22806, 55)
/*1*/ {
/*1*/ word var←c71772;
/*1*/ word i←v60648;
/*1*/ i←v60648 = SGNCK(bitIndex←v23436);
SOURCE(18510, 39)
/*1*/ var←c71772 = (i←v60648 & 037);
/*1*/ shiftAmt←v23808 = ((var←c71772 + bitsPerSample←v23408) - 32);
/*1*/ };
SOURCE(22863, 185)
/*1*/ if (( (int)shiftAmt←v23808 <= (int)0)) {
/*1*/ {
/*1*/ word var←c71804;
/*1*/ {
/*1*/ word i←v60600;
/*1*/ i←v60600 = INEG(shiftAmt←v23808);
SOURCE(18510, 39)
/*1*/ var←c71804 = (i←v60600 & 037);
/*1*/ };
/*1*/ shiftedBits←v23836 = (word) XRM←BITRSHIFT((* (ptr) pointer←v23780 ), var←c71804);
/*1*/ };
/*1*/ }
/*1*/ else {
/*1*/ {
/*1*/ word var←c71868;
/*1*/ word var←c01327;
/*1*/ {
/*1*/ word i←v60552;
/*1*/ i←v60552 = (32 - shiftAmt←v23808);
SOURCE(18510, 39)
/*1*/ var←c71868 = (i←v60552 & 037);
/*1*/ };
/*1*/ var←c01327 = (word) XRM←BITRSHIFT((* (( (ptr) pointer←v23780)+1) ), var←c71868);
/*1*/ shiftedBits←v23836 = ((word) XRM←BITLSHIFT((* (ptr) pointer←v23780 ), (shiftAmt←v23808 & 037)) + var←c01327);
/*1*/ };
/*1*/ };
SOURCE(23050, 44)
/*1*/ {
/*1*/ word var←c71932;
/*1*/ var←c71932 = (word) XRM←BITAND(shiftedBits←v23836, mask←v23692);
/*1*/ {
/*1*/ word limit94;
/*1*/ (* ((( (ptr) buffer←v13748)+2)+(
/*1*/ limit94 = (* (( (ptr) buffer←v13748)+1) ),
/*1*/ BCK(i←v23736, limit94)
/*1*/ )) ) = var←c71932;
/*1*/ };
/*1*/ };
SOURCE(23096, 35)
/*1*/ bitIndex←v23436 = (bitIndex←v23436 + bitIndexDelta←v23464);
/*1*/ };
/*1*/ i←v23736 = (i←v23736 + 1);
/*1*/ if ((i←v23736 < noName←c71708)) {
/*1*/ goto lab←L100125;
/*1*/ };
/*1*/ lab←L100122: ;
/*1*/ };
};
};
};
};
}
else {
if ((var←c72060 == 1)) {
{
word map←v23880;
map←v23880 = var←c71452;
SOURCE(23172, 227)
{
W2 index←v23924;
word class←v23952;
SOURCE(23174, 22)
index←v23924 = initIndex←v13692;
SOURCE(23198, 33)
class←v23952 = (* (( (ptr) map←v23880)+7) );
SOURCE(23233, 155)
{
register word i←v23996;
register word noName←c71964;
i←v23996 = start←v13776;
noName←c71964 = (start←v13776 + count←v13804);
if ((i←v23996 >= noName←c71964)) {
/*1*/ goto lab←L100130;
/*1*/ };
lab←L100133: ;
SOURCE(23271, 81)
{
/*1*/ word pd95;
/*1*/ pd95 = (* (ptr) class←v23952 );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd95 ))))(map←v23880, index←v23924, buffer←v13748, i←v23996, 1, pd95);
/*1*/ };
SOURCE(23354, 34)
{
/*1*/ word var←c71996;
/*1*/ word var←c72028;
/*1*/ var←c71996 = (index←v23924.f0 + delta←v13720.f0);
/*1*/ var←c72028 = (index←v23924.f1 + delta←v13720.f1);
/*1*/ index←v23924.f0 = var←c71996;
/*1*/ index←v23924.f1 = var←c72028;
/*1*/ };
i←v23996 = (i←v23996 + 1);
if ((i←v23996 < noName←c71964)) {
/*1*/ goto lab←L100133;
/*1*/ };
lab←L100130: ;
};
};
};
}
else {
lab←L100110: ;
SOURCE(23413, 5)
(void) XR←RaiseUnnamedError();
};
};
};
};
};
}
static void PutSamples←P3300(map←v13864, initIndex←v13892, delta←v13920, buffer←v13948, start←v13976, count←v14004, function←v14032)
word map←v13864;
W2 initIndex←v13892;
W2 delta←v13920;
word buffer←v13948;
word start←v13976;
word count←v14004;
word function←v14032;
{
register ptr gf←c81468 = (ptr) &globalframe;
word false←v24040;
W2 size←v24068;
word sDelta←v24096;
word fDelta←v24124;
/* PutSamples: */
SOURCE(23427, 2339)
SOURCE(23621, 41)
{
word idx96;
false←v24040 = (
idx96 = (* (( (ptr) map←v13864)+4) ),
BCK(idx96, 1)
);
};
SOURCE(23664, 27)
size←v24068.f0 = ((* (( (ptr) map←v13864)+2) ) - (* (ptr) map←v13864 ));
size←v24068.f1 = ((* (( (ptr) map←v13864)+3) ) - (* (( (ptr) map←v13864)+1) ));
SOURCE(23693, 25)
sDelta←v24096 = delta←v13920.f0;
SOURCE(23720, 25)
fDelta←v24124 = delta←v13920.f1;
SOURCE(23747, 39)
{
word x97;
count←v14004 = (x97 = ((* (ptr) buffer←v13948 ) - start←v13976),
MIN((int)(word), x97, count←v14004));
};
SOURCE(23788, 117)
(void) CheckBuffer←P2460(map←v13864, initIndex←v13892.f0, initIndex←v13892.f1, sDelta←v24096, fDelta←v24124, count←v14004)
;
SOURCE(23907, 24)
if ((count←v14004 == 0)) {
SOURCE(23925, 6)
return;
};
SOURCE(23933, 1047)
if ( ( ( (int)sDelta←v24096 == (int)0) ? ( (int)fDelta←v24124 == (int)1) : 0 ) ) {
SOURCE(23969, 1013)
{
word srcBuffer←v24188;
SOURCE(23971, 32)
srcBuffer←v24188 = buffer←v13948;
SOURCE(24005, 308)
if ((function←v14032 != 0)) {
SOURCE(24037, 278)
{
word tmpBuffer←v24232;
SOURCE(24039, 67)
tmpBuffer←v24232 = (word) ObtainScratchSamples←P780(SGNCK((start←v13976 + count←v14004)));
SOURCE(24108, 89)
{
W2 var←c72124;
var←c72124.f0 = 0;
var←c72124.f1 = 1;
(void) GetSamples←P3240(map←v13864, initIndex←v13892, var←c72124, tmpBuffer←v24232, start←v13976, count←v14004);
};
SOURCE(24199, 91)
(void) ApplyToSamples←P3000(function←v14032, tmpBuffer←v24232, buffer←v13948, start←v13976, count←v14004);
SOURCE(24292, 21)
srcBuffer←v24188 = tmpBuffer←v24232;
};
};
SOURCE(24318, 564)
{
word var←c72156;
var←c72156 = map←v13864;
if ((var←c72156 == 0)) {
goto lab←L100134;
};
{
word var←c72476;
var←c72476 = (* (( (ptr) var←c72156)+6) );
if ((var←c72476 == 0)) {
{
word map←v24276;
map←v24276 = var←c72156;
SOURCE(24371, 331)
{
W2 v0←v24320;
word dstBitIndex←v24348;
SOURCE(24373, 46)
{
W2 v2←v61388;
v2←v61388 = (* (W2Pt) map←v24276 );
v0←v24320.f0 = (initIndex←v13892.f0 - v2←v61388.f0);
v0←v24320.f1 = (initIndex←v13892.f1 - v2←v61388.f1);
};
SOURCE(24421, 121)
{
word var←c72252;
word limit←v58308;
word var←c01328;
word var←c72284;
word limit←v58260;
{
/*1*/ word idx98;
/*1*/ limit←v58308 = (
/*1*/ idx98 = (word) size←v24068.f0,
/*1*/ SGNCK(idx98)
/*1*/ );
/*1*/ };
SOURCE(3132, 92)
if ((v0←v24320.f0 >= limit←v58308)) {
SOURCE(3175, 36)
/*1*/ (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81468)+227)/* var←c70300 */ ))+8) ), 0);
/*1*/ }
else {
SOURCE(3211, 13)
/*1*/ {
/*1*/ word idx99;
/*1*/ var←c72252 = (
/*1*/ idx99 = (word) v0←v24320.f0,
/*1*/ SGNCK(idx99)
/*1*/ );
/*1*/ };
/*1*/ };
var←c01328 = (var←c72252 * (* (( (ptr) map←v24276)+7) ));
{
/*1*/ word idx100;
/*1*/ limit←v58260 = (
/*1*/ idx100 = (word) size←v24068.f1,
/*1*/ SGNCK(idx100)
/*1*/ );
/*1*/ };
SOURCE(3132, 92)
if ((v0←v24320.f1 >= limit←v58260)) {
SOURCE(3175, 36)
/*1*/ (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81468)+227)/* var←c70300 */ ))+8) ), 0);
/*1*/ }
else {
SOURCE(3211, 13)
/*1*/ {
/*1*/ word idx101;
/*1*/ var←c72284 = (
/*1*/ idx101 = (word) v0←v24320.f1,
/*1*/ SGNCK(idx101)
/*1*/ );
/*1*/ };
/*1*/ };
dstBitIndex←v24348 = (var←c01328 + (var←c72284 * (* (( (ptr) map←v24276)+5) )));
};
SOURCE(24544, 156)
{
W2 var←c72316;
word var←c72412;
{
/*1*/ W2 var←c72348;
/*1*/ W2 addr←v57880;
/*1*/ addr←v57880 = (* (W2Pt) (( (ptr) map←v24276)+8) );
/*1*/ {
/*1*/ word bitOffset←v57912;
/*1*/ word mod←v57940;
/*1*/ bitOffset←v57912 = (dstBitIndex←v24348 + addr←v57880.f1);
/*1*/ mod←v57940 = (bitOffset←v57912 & 037);
SOURCE(2833, 63)
/*1*/ var←c72348.f0 = (addr←v57880.f0 + IOP2( / , (int)(bitOffset←v57912 - mod←v57940), (int)8));
/*1*/ var←c72348.f1 = mod←v57940;
/*1*/ };
/*1*/ var←c72316 = var←c72348;
/*1*/ };
{
/*1*/ word var←c72444;
/*1*/ word check←v59616;
/*1*/ check←v59616 = (((* (( (ptr) srcBuffer←v24188)+1) ) - start←v13976) - count←v14004);
SOURCE(4940, 67)
/*1*/ var←c72444 = (srcBuffer←v24188 + ((word) ((word) (((word) BCK(start←v13976, 67108861) << 5) + 95) >> 5) << 2));
/*1*/ var←c72412 = var←c72444;
/*1*/ };
{
/*1*/ word pd102;
/*1*/ pd102 = (* (( (ptr) (* (( (ptr) gf←c81468)+226)/* var←c70076 */ ))+4) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd102 ))))(var←c72316, var←c72412, (* (( (ptr) map←v24276)+5) ), count←v14004, pd102);
/*1*/ };
};
};
};
}
else {
if ((var←c72476 == 1)) {
{
word map←v24392;
map←v24392 = var←c72156;
SOURCE(24729, 155)
{
word class←v24436;
SOURCE(24731, 33)
class←v24436 = (* (( (ptr) map←v24392)+7) );
SOURCE(24766, 116)
{
/*1*/ word pd103;
/*1*/ pd103 = (* (( (ptr) class←v24436)+1) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd103 ))))(map←v24392, initIndex←v13892, srcBuffer←v24188, start←v13976, count←v14004, function←v14032, pd103)
/*1*/ ;
/*1*/ };
};
};
}
else {
lab←L100134: ;
SOURCE(24898, 5)
(void) XR←RaiseUnnamedError();
};
};
};
};
SOURCE(24905, 67)
if ((srcBuffer←v24188 != buffer←v13948)) {
SOURCE(24932, 40)
(void) ReleaseScratchSamples←P840(srcBuffer←v24188);
};
SOURCE(24974, 6)
return;
};
};
SOURCE(24985, 567)
if ( ( ((* (( (ptr) map←v13864)+5) ) == 8) ? (function←v14032 == 0) : 0 ) ) {
SOURCE(25041, 511)
{
word var←c72508;
var←c72508 = map←v13864;
if ((var←c72508 == 0)) {
goto lab←L100140;
};
if (((* (( (ptr) var←c72508)+6) ) == 0)) {
{
word map←v24480;
map←v24480 = var←c72508;
SOURCE(25094, 458)
SOURCE(25096, 451)
if ( ( (((* (( (ptr) map←v24480)+7) ) & 7) == 0) ? (((* (( (ptr) map←v24480)+9) ) & 7) == 0) : 0 ) ) {
SOURCE(25157, 392)
{
word dst←v24524;
word byteIndex←v24552;
word byteDelta←v24580;
word src←v24608;
SOURCE(25159, 57)
dst←v24524 = (* (( (ptr) map←v24480)+8) );
SOURCE(25218, 83)
byteIndex←v24552 = ((((* (( (ptr) map←v24480)+9) ) >> 3) + IOP2( * , (int)initIndex←v13892.f0, (int)((* (( (ptr) map←v24480)+7)
) >> 3))) + initIndex←v13892.f1);
SOURCE(25303, 54)
byteDelta←v24580 = (IOP2( * , (int)sDelta←v24096, (int)((* (( (ptr) map←v24480)+7) ) >> 3)) + fDelta←v24124);
SOURCE(25359, 78)
{
word check←v59572;
check←v59572 = (((* (( (ptr) buffer←v13948)+1) ) - start←v13976) - count←v14004);
SOURCE(4940, 67)
src←v24608 = (buffer←v13948 + ((word) ((word) (((word) BCK(start←v13976, 67108861) << 5) + 95) >> 5) << 2));
};
SOURCE(25439, 91)
{
register word i←v24676 = 0;
register word noName←c72572;
noName←c72572 = count←v14004;
if ((i←v24676 >= noName←c72572)) {
goto lab←L100142;
};
lab←L100145: ;
SOURCE(25472, 23)
{
word idx104;
(* (( (bPt) dst←v24524)+byteIndex←v24552) ) = (
/*1*/ idx104 = (* (( (ptr) src←v24608)+i←v24676) ),
/*1*/ BCK(idx104, 256)
/*1*/ );
};
SOURCE(25497, 33)
byteIndex←v24552 = (byteIndex←v24552 + byteDelta←v24580);
i←v24676 = (i←v24676 + 1);
if ((i←v24676 < noName←c72572)) {
goto lab←L100145;
};
lab←L100142: ;
};
SOURCE(25541, 6)
return;
};
};
};
}
else {
lab←L100140: ;
};
};
};
SOURCE(25572, 205)
{
W2 index←v24720;
SOURCE(25574, 22)
index←v24720 = initIndex←v13892;
SOURCE(25598, 168)
{
register word i←v24764;
register word noName←c72604;
i←v24764 = start←v13976;
noName←c72604 = (start←v13976 + count←v14004);
if ((i←v24764 >= noName←c72604)) {
goto lab←L100146;
};
lab←L100149: ;
SOURCE(25636, 94)
{
W2 var←c72636;
var←c72636.f0 = 0;
var←c72636.f1 = 1;
(void) PutSamples←P3300(map←v13864, index←v24720, var←c72636, buffer←v13948, i←v24764, 1
, function←v14032);
};
SOURCE(25732, 34)
{
word var←c72668;
word var←c72700;
var←c72668 = (index←v24720.f0 + delta←v13920.f0);
var←c72700 = (index←v24720.f1 + delta←v13920.f1);
index←v24720.f0 = var←c72668;
index←v24720.f1 = var←c72700;
};
i←v24764 = (i←v24764 + 1);
if ((i←v24764 < noName←c72604)) {
goto lab←L100149;
};
lab←L100146: ;
};
};
}
static void Clear←P3360(map←v14092)
word map←v14092;
{
word false←v24808;
/* Clear: */
SOURCE(25784, 909)
SOURCE(25824, 41)
{
word idx105;
false←v24808 = (
idx105 = (* (( (ptr) map←v14092)+4) ),
BCK(idx105, 1)
);
};
SOURCE(25867, 826)
{
word var←c72732;
var←c72732 = map←v14092;
if ((var←c72732 == 0)) {
goto lab←L100150;
};
{
word var←c72892;
var←c72892 = (* (( (ptr) var←c72732)+6) );
if ((var←c72892 == 0)) {
{
word map←v24872;
map←v24872 = var←c72732;
SOURCE(25920, 725)
{
word sSize←v24916;
word fSize←v24944;
word bitsPerLine←v24972;
word dataBitsPerLine←v25000;
word pointer←v25028;
word bit←v25056;
SOURCE(25922, 67)
sSize←v24916 = ((* (( (ptr) map←v24872)+2) ) - (* (ptr) map←v24872 ));
SOURCE(25991, 67)
fSize←v24944 = ((* (( (ptr) map←v24872)+3) ) - (* (( (ptr) map←v24872)+1) ));
SOURCE(26060, 35)
bitsPerLine←v24972 = (* (( (ptr) map←v24872)+7) );
SOURCE(26097, 59)
dataBitsPerLine←v25000 = ((* (( (ptr) map←v24872)+5) ) * fSize←v24944);
SOURCE(26158, 37)
pointer←v25028 = (* (( (ptr) map←v24872)+8) );
SOURCE(26197, 24)
bit←v25056 = (* (( (ptr) map←v24872)+9) );
SOURCE(26223, 24)
if ((sSize←v24916 == 0)) {
SOURCE(26241, 6)
return;
};
SOURCE(26249, 382)
if (((dataBitsPerLine←v25000 + 32) > bitsPerLine←v24972)) {
SOURCE(26293, 120)
{
word var←c72764;
{
word bitCount←v56660;
bitCount←v56660 = ((bit←v25056 + (bitsPerLine←v24972 * sSize←v24916)) - (bitsPerLine←v24972 - dataBitsPerLine←v25000));
SOURCE(2535, 32)
var←c72764 = ((word) (bitCount←v56660 + 31) >> 5);
};
(void) Basics←FillWords(pointer←v25028, var←c72764, 0);
};
}
else {
SOURCE(26424, 207)
{
register word i←v25112 = 0;
if ((i←v25112 >= sSize←v24916)) {
goto lab←L100152;
};
lab←L100155: ;
SOURCE(26457, 82)
{
word var←c72828;
{
/*1*/ word bitCount←v56612;
/*1*/ bitCount←v56612 = (bit←v25056 + dataBitsPerLine←v25000);
SOURCE(2535, 32)
/*1*/ var←c72828 = ((word) (bitCount←v56612 + 31) >> 5);
/*1*/ };
(void) Basics←FillWords(pointer←v25028, var←c72828, 0);
};
SOURCE(26541, 23)
bit←v25056 = (bit←v25056 + bitsPerLine←v24972);
SOURCE(26566, 46)
pointer←v25028 = (pointer←v25028 + ((word) ((word) bit←v25056 >> 5) << 2));
SOURCE(26614, 17)
bit←v25056 = (bit←v25056 & 037);
i←v25112 = (i←v25112 + 1);
if ((i←v25112 < sSize←v24916)) {
goto lab←L100155;
};
lab←L100152: ;
};
};
};
};
}
else {
if ((var←c72892 == 1)) {
{
word map←v25156;
map←v25156 = var←c72732;
SOURCE(26672, 21)
(void) Fill←P3840(map←v25156, (* (W4Pt) map←v25156 ), 0, 0);
};
}
else {
lab←L100150: ;
};
};
};
};
}
static void BufferTransfer←P3420(formal←c01361, formal←c01362, formal←c01363, formal←c01364, size←v14264, formal←c01365)
word formal←c01361;
word formal←c01362;
W2 formal←c01363;
W2 formal←c01364;
W2 size←v14264;
word formal←c01365;
{
W14 var←c81500;
/* declaration of dst←v14152 skipped */
/* declaration of src←v14180 skipped */
/* declaration of dstMin←v14208 skipped */
/* declaration of srcMin←v14236 skipped */
/* declaration of function←v14292 skipped */
register ptr gf←c81532 = (ptr) &globalframe;
/* declaration of var←c72924 skipped */
W2 dstSize←v25200;
W2 srcSize←v25228;
word sDst0←v25256;
word fDst0←v25284;
word sSrc0←v25312;
word fSrc0←v25340;
/* declaration of sSize←v25368 skipped */
word fSize←v25396;
(* (( (ptr) &var←c81500)+4)/* dst←v14152 */ ) = formal←c01361;
(* (( (ptr) &var←c81500)+5)/* src←v14180 */ ) = formal←c01362;
(* (W2Pt) (( (ptr) &var←c81500)+6)/* dstMin←v14208 */ ) = formal←c01363;
(* (W2Pt) (( (ptr) &var←c81500)+8)/* srcMin←v14236 */ ) = formal←c01364;
(* (( (ptr) &var←c81500)+10)/* function←v14292 */ ) = formal←c01365;
/* BufferTransfer: */
SOURCE(26715, 844)
{
word tmpAddr106;
tmpAddr106 = (word) (( (ptr) &var←c81500)+11)/* var←c72924 */ ;
(* (ptr) tmpAddr106 ) = ( ((word) (fPt) transferAction←P8340) );
(* (( (ptr) tmpAddr106) + 1) ) = 1;
};
SOURCE(26875, 30)
dstSize←v25200.f0 = ((* (( (ptr) (* (( (ptr) &var←c81500)+4)/* dst←v14152 */ ))+2) ) - (* (ptr) (* (( (ptr) &var←c81500)+4)
/* dst←v14152 */ ) ));
dstSize←v25200.f1 = ((* (( (ptr) (* (( (ptr) &var←c81500)+4)/* dst←v14152 */ ))+3) ) - (* (( (ptr) (* (( (ptr) &var←c81500)+4)
/* dst←v14152 */ ))+1) ));
SOURCE(26907, 30)
srcSize←v25228.f0 = ((* (( (ptr) (* (( (ptr) &var←c81500)+5)/* src←v14180 */ ))+2) ) - (* (ptr) (* (( (ptr) &var←c81500)+5)
/* src←v14180 */ ) ));
srcSize←v25228.f1 = ((* (( (ptr) (* (( (ptr) &var←c81500)+5)/* src←v14180 */ ))+3) ) - (* (( (ptr) (* (( (ptr) &var←c81500)+5)
/* src←v14180 */ ))+1) ));
SOURCE(26939, 37)
{
word idx107;
sDst0←v25256 = (
idx107 = (word) ((* (( (ptr) &var←c81500)+6) ) - (* (ptr) (* (( (ptr) &var←c81500)+4)/* dst←v14152 */ ) )),
SGNCK(idx107)
);
};
SOURCE(26978, 37)
{
word idx108;
fDst0←v25284 = (
idx108 = (word) ((* (( (ptr) &var←c81500)+7) ) - (* (( (ptr) (* (( (ptr) &var←c81500)+4)/* dst←v14152 */ ))+1) )),
SGNCK(idx108)
);
};
SOURCE(27017, 37)
{
word idx109;
sSrc0←v25312 = (
idx109 = (word) ((* (( (ptr) &var←c81500)+8) ) - (* (ptr) (* (( (ptr) &var←c81500)+5)/* src←v14180 */ ) )),
SGNCK(idx109)
);
};
SOURCE(27056, 37)
{
word idx110;
fSrc0←v25340 = (
idx110 = (word) ((* (( (ptr) &var←c81500)+9) ) - (* (( (ptr) (* (( (ptr) &var←c81500)+5)/* src←v14180 */ ))+1) )),
SGNCK(idx110)
);
};
SOURCE(27095, 67)
{
word value←v59360;
word bound←v59388;
{
word bound←v59436;
bound←v59436 = (dstSize←v25200.f0 - sDst0←v25256);
SOURCE(3290, 95)
if ((size←v14264.f0 > bound←v59436)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81532)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
{
word idx111;
value←v59360 = (
idx111 = (word) size←v14264.f0,
SGNCK(idx111)
);
};
};
};
bound←v59388 = (srcSize←v25228.f0 - sSrc0←v25312);
SOURCE(3290, 95)
if ((value←v59360 > bound←v59388)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81532)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
(* (( (ptr) &var←c81500)+13)/* sSize←v25368 */ ) = SGNCK(value←v59360);
};
};
SOURCE(27164, 67)
{
word value←v59236;
word bound←v59264;
{
word bound←v59312;
bound←v59312 = (dstSize←v25200.f1 - fDst0←v25284);
SOURCE(3290, 95)
if ((size←v14264.f1 > bound←v59312)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81532)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
{
word idx112;
value←v59236 = (
idx112 = (word) size←v14264.f1,
SGNCK(idx112)
);
};
};
};
bound←v59264 = (srcSize←v25228.f1 - fSrc0←v25340);
SOURCE(3290, 95)
if ((value←v59236 > bound←v59264)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81532)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
fSize←v25396 = SGNCK(value←v59236);
};
};
SOURCE(27500, 59)
(void) DoWithScratchSamples←P900(fSize←v25396, (word) (( (bPt) &var←c81500)+44)/* var←c72924 */ );
}
static void transferAction←P8340(buffer←v25500, formal←c81564)
word buffer←v25500;
word formal←c81564;
{
formal←c81564 = (formal←c81564 - 44);
/* transferAction: */
SOURCE(27233, 253)
SOURCE(27281, 205)
{
register word s←v25528 = 0;
if ((s←v25528 >= (* (( (ptr) formal←c81564)+13) ))) {
goto lab←L100161;
};
lab←L100164: ;
SOURCE(27309, 77)
{
W2 var←c73148;
W2 var←c73180;
var←c73148.f0 = ((* (( (ptr) formal←c81564)+8) ) + s←v25528);
var←c73148.f1 = (* (( (ptr) formal←c81564)+9) );
var←c73180.f0 = 0;
var←c73180.f1 = 1;
(void) GetSamples←P3240((* (( (ptr) formal←c81564)+5) ), var←c73148, var←c73180, buffer←v25500, 0, 2147483647);
};
SOURCE(27388, 98)
{
W2 var←c73212;
W2 var←c73244;
var←c73212.f0 = ((* (( (ptr) formal←c81564)+6) ) + s←v25528);
var←c73212.f1 = (* (( (ptr) formal←c81564)+7) );
var←c73244.f0 = 0;
var←c73244.f1 = 1;
(void) PutSamples←P3300((* (( (ptr) formal←c81564)+4) ), var←c73212, var←c73244, buffer←v25500, 0, 2147483647
, (* (( (ptr) formal←c81564)+10) ));
};
s←v25528 = (s←v25528 + 1);
if ((s←v25528 < (* (( (ptr) formal←c81564)+13) ))) {
goto lab←L100164;
};
lab←L100161: ;
};
}
static void BasicTransfer←P3480(dst←v14352, src←v14380, dstMin←v14408, srcMin←v14436, size←v14464, function←v14492)
word dst←v14352;
word src←v14380;
W2 dstMin←v14408;
W2 srcMin←v14436;
W2 size←v14464;
word function←v14492;
{
register ptr gf←c81596 = (ptr) &globalframe;
word false←v25572;
word bitsPerSample←v25600;
/* BasicTransfer: */
SOURCE(27565, 1169)
SOURCE(27721, 41)
{
word idx113;
false←v25572 = (
idx113 = (* (( (ptr) dst←v14352)+4) ),
BCK(idx113, 1)
);
};
SOURCE(27764, 38)
bitsPerSample←v25600 = (* (( (ptr) dst←v14352)+5) );
SOURCE(27804, 853)
{
word var←c73276;
var←c73276 = dst←v14352;
if ((var←c73276 == 0)) {
goto lab←L100165;
};
if (((* (( (ptr) var←c73276)+6) ) == 0)) {
{
word dst←v25664;
dst←v25664 = var←c73276;
SOURCE(27849, 808)
{
word var←c73308;
var←c73308 = src←v14380;
if ((var←c73308 == 0)) {
goto lab←L100166;
};
if (((* (( (ptr) var←c73308)+6) ) == 0)) {
{
word src←v25708;
src←v25708 = var←c73308;
SOURCE(27894, 763)
if (((* (( (ptr) src←v25708)+5) ) == bitsPerSample←v25600)) {
SOURCE(27942, 717)
{
W2 dstSize←v25752;
W2 srcSize←v25780;
word sDst0←v25808;
word fDst0←v25836;
word sSrc0←v25864;
word fSrc0←v25892;
word sSize←v25920;
word fSize←v25948;
SOURCE(27944, 30)
{
/*1*/ word map←v56084;
/*1*/ map←v56084 = dst←v25664;
SOURCE(1717, 74)
/*1*/ dstSize←v25752.f0 = ((* (( (ptr) map←v56084)+2) ) - (* (ptr) map←v56084 ));
/*1*/ dstSize←v25752.f1 = ((* (( (ptr) map←v56084)+3) ) - (* (( (ptr) map←v56084)+1) ));
/*1*/ };
SOURCE(27976, 30)
{
/*1*/ word map←v56036;
/*1*/ map←v56036 = src←v25708;
SOURCE(1717, 74)
/*1*/ srcSize←v25780.f0 = ((* (( (ptr) map←v56036)+2) ) - (* (ptr) map←v56036 ));
/*1*/ srcSize←v25780.f1 = ((* (( (ptr) map←v56036)+3) ) - (* (( (ptr) map←v56036)+1) ));
/*1*/ };
SOURCE(28008, 37)
{
/*1*/ word idx114;
/*1*/ sDst0←v25808 = (
/*1*/ idx114 = (word) (dstMin←v14408.f0 - (* (ptr) dst←v25664 )),
/*1*/ SGNCK(idx114)
/*1*/ );
/*1*/ };
SOURCE(28047, 37)
{
/*1*/ word idx115;
/*1*/ fDst0←v25836 = (
/*1*/ idx115 = (word) (dstMin←v14408.f1 - (* (( (ptr) dst←v25664)+1) )),
/*1*/ SGNCK(idx115)
/*1*/ );
/*1*/ };
SOURCE(28086, 37)
{
/*1*/ word idx116;
/*1*/ sSrc0←v25864 = (
/*1*/ idx116 = (word) (srcMin←v14436.f0 - (* (ptr) src←v25708 )),
/*1*/ SGNCK(idx116)
/*1*/ );
/*1*/ };
SOURCE(28125, 37)
{
/*1*/ word idx117;
/*1*/ fSrc0←v25892 = (
/*1*/ idx117 = (word) (srcMin←v14436.f1 - (* (( (ptr) src←v25708)+1) )),
/*1*/ SGNCK(idx117)
/*1*/ );
/*1*/ };
SOURCE(28164, 67)
{
/*1*/ word value←v59112;
/*1*/ word bound←v59140;
/*1*/ {
/*1*/ word bound←v59188;
/*1*/ bound←v59188 = (dstSize←v25752.f0 - sDst0←v25808);
SOURCE(3290, 95)
/*1*/ if ((size←v14464.f0 > bound←v59188)) {
SOURCE(3334, 36)
/*1*/ (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81596)+227)/* var←c70300 */ ))+8) ), 0);
/*1*/ }
/*1*/ else {
SOURCE(3370, 15)
/*1*/ {
/*1*/ word idx118;
/*1*/ value←v59112 = (
/*1*/ idx118 = (word) size←v14464.f0,
/*1*/ SGNCK(idx118)
/*1*/ );
/*1*/ };
/*1*/ };
/*1*/ };
/*1*/ bound←v59140 = (srcSize←v25780.f0 - sSrc0←v25864);
SOURCE(3290, 95)
/*1*/ if ((value←v59112 > bound←v59140)) {
SOURCE(3334, 36)
/*1*/ (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81596)+227)/* var←c70300 */ ))+8) ), 0);
/*1*/ }
/*1*/ else {
SOURCE(3370, 15)
/*1*/ sSize←v25920 = SGNCK(value←v59112);
/*1*/ };
/*1*/ };
SOURCE(28233, 67)
{
/*1*/ word value←v58988;
/*1*/ word bound←v59016;
/*1*/ {
/*1*/ word bound←v59064;
/*1*/ bound←v59064 = (dstSize←v25752.f1 - fDst0←v25836);
SOURCE(3290, 95)
/*1*/ if ((size←v14464.f1 > bound←v59064)) {
SOURCE(3334, 36)
/*1*/ (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81596)+227)/* var←c70300 */ ))+8) ), 0);
/*1*/ }
/*1*/ else {
SOURCE(3370, 15)
/*1*/ {
/*1*/ word idx119;
/*1*/ value←v58988 = (
/*1*/ idx119 = (word) size←v14464.f1,
/*1*/ SGNCK(idx119)
/*1*/ );
/*1*/ };
/*1*/ };
/*1*/ };
/*1*/ bound←v59016 = (srcSize←v25780.f1 - fSrc0←v25892);
SOURCE(3290, 95)
/*1*/ if ((value←v58988 > bound←v59016)) {
SOURCE(3334, 36)
/*1*/ (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81596)+227)/* var←c70300 */ ))+8) ), 0);
/*1*/ }
/*1*/ else {
SOURCE(3370, 15)
/*1*/ fSize←v25948 = SGNCK(value←v58988);
/*1*/ };
/*1*/ };
SOURCE(28302, 347)
if ( ( (sSize←v25920 != 0) ? (fSize←v25948 != 0) : 0 ) ) {
SOURCE(28330, 319)
/*1*/ {
/*1*/ W2 var←c73596;
/*1*/ W2 var←c73692;
/*1*/ {
/*1*/ W2 var←c73628;
/*1*/ W2 addr←v57748;
/*1*/ word offset←v57776;
/*1*/ addr←v57748 = (* (W2Pt) (( (ptr) dst←v25664)+8) );
/*1*/ offset←v57776 = ((sDst0←v25808 * (* (( (ptr) dst←v25664)+7) )) + (fDst0←v25836 * bitsPerSample←v25600));
/*1*/ {
/*1*/ word bitOffset←v57808;
/*1*/ word mod←v57836;
/*1*/ bitOffset←v57808 = (offset←v57776 + addr←v57748.f1);
/*1*/ mod←v57836 = (bitOffset←v57808 & 037);
SOURCE(2833, 63)
/*1*/ var←c73628.f0 = (addr←v57748.f0 + IOP2( / , (int)(bitOffset←v57808 - mod←v57836), (int)8));
/*1*/ var←c73628.f1 = mod←v57836;
/*1*/ };
/*1*/ var←c73596 = var←c73628;
/*1*/ };
/*1*/ {
/*1*/ W2 var←c73724;
/*1*/ W2 addr←v57616;
/*1*/ word offset←v57644;
/*1*/ addr←v57616 = (* (W2Pt) (( (ptr) src←v25708)+8) );
/*1*/ offset←v57644 = ((sSrc0←v25864 * (* (( (ptr) src←v25708)+7) )) + (fSrc0←v25892 * bitsPerSample←v25600));
/*1*/ {
/*1*/ word bitOffset←v57676;
/*1*/ word mod←v57704;
/*1*/ bitOffset←v57676 = (offset←v57644 + addr←v57616.f1);
/*1*/ mod←v57704 = (bitOffset←v57676 & 037);
SOURCE(2833, 63)
/*1*/ var←c73724.f0 = (addr←v57616.f0 + IOP2( / , (int)(bitOffset←v57676 - mod←v57704), (int)8));
/*1*/ var←c73724.f1 = mod←v57704;
/*1*/ };
/*1*/ var←c73692 = var←c73724;
/*1*/ };
/*1*/ {
/*1*/ word pd120;
/*1*/ pd120 = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81596)+226)/* var←c70076 */ ))+8) ))+(((unsigned)function←v14492 << 29) >> 30))
/*1*/ )+(function←v14492 & 1)) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd120 ))))(var←c73596, var←c73692, (* (( (ptr) dst←v25664)+7) ), (* (( (ptr) src←v25708)+7) ), sSize←v25920, (fSize←v25948 * bitsPerSample←v25600), pd120)
/*1*/ ;
/*1*/ };
/*1*/ };
/*1*/ };
SOURCE(28651, 6)
return;
};
};
};
}
else {
lab←L100166: ;
};
};
};
}
else {
lab←L100165: ;
};
};
SOURCE(28678, 56)
(void) BufferTransfer←P3420(dst←v14352, src←v14380, dstMin←v14408, srcMin←v14436, size←v14464, function←v14492);
}
static void RawListTransfer←P3540(dst←v14552, src←v14580, function←v14608)
word dst←v14552;
word src←v14580;
word function←v14608;
{
register ptr gf←c81628 = (ptr) &globalframe;
word false←v25992;
word bitsPerSample←v26020;
word dstPtr←v26048;
word dstOff←v26076;
word var←c73788;
word switch←v64060;
/* RawListTransfer: */
SOURCE(28740, 2198)
SOURCE(28867, 41)
{
word idx121;
false←v25992 = (
idx121 = (* (( (ptr) dst←v14552)+4) ),
BCK(idx121, 1)
);
};
SOURCE(28910, 41)
{
word idx122;
bitsPerSample←v26020 = (
idx122 = (word) ((* (( (ptr) dst←v14552)+5) ) - 1),
BCK(idx122, 1)
);
};
SOURCE(28953, 50)
dstPtr←v26048 = (* (( (ptr) dst←v14552)+8) );
SOURCE(29005, 26)
dstOff←v26076 = (* (( (ptr) dst←v14552)+9) );
SOURCE(29033, 1905)
{
word tc123;
word tc124;
switch←v64060 = (* (( (ptr) gf←c81628)+8)/* useCharBlt←v2916 */ );
var←c73788 = (unsigned) ((* (( (ptr) (* (( (ptr) (* (( (ptr) gf←c81628)+223)/* var←c66556 */ ))+10) ))+switch←v64060) ) != 0);
if ((0 != var←c73788)) {
if ((function←v14608 == 4)) {
tc124 = (word) 1;
}
else {
tc124 = (word) (function←v14608 == 3);
};
}
else {
tc124 = (word) 0;
};
if (tc124) {
tc123 = (word) (((* (( (ptr) dst←v14552)+7) ) & 037) == 0);
}
else {
tc123 = (word) 0;
};
if (tc123) {
SOURCE(29187, 959)
{
word dstUnitsPerLine←v26188;
word op←v26216;
SOURCE(29220, 52)
dstUnitsPerLine←v26188 = ((* (( (ptr) dst←v14552)+7) ) >> 3);
SOURCE(29274, 17)
op←v26216 = ( (function←v14608 == 4) ? (* (( (ptr) (* (( (ptr) gf←c81628)+226)/* var←c70076 */ ))+10) ) : (* (( (ptr) (* (
( (ptr) gf←c81628)+226)/* var←c70076 */ ))+11) ) ) ;
SOURCE(29466, 669)
lab←L100178: ;
if ((src←v14580 != 0)) {
}
else {
goto lab←L100176;
};
{
word sCheck←v26460;
word fCheck←v26488;
word sSize←v26516;
word fSize←v26544;
SOURCE(29485, 47)
{
word idx125;
sCheck←v26460 = (
idx125 = (word) ((* (( (ptr) dst←v14552)+2) ) - (* (( (ptr) src←v14580)+2) )),
SGNCK(idx125)
);
};
SOURCE(29534, 47)
{
word idx126;
fCheck←v26488 = (
idx126 = (word) ((* (( (ptr) dst←v14552)+3) ) - (* (( (ptr) src←v14580)+3) )),
SGNCK(idx126)
);
};
SOURCE(29583, 56)
sSize←v26516 = ((* (( (ptr) src←v14580)+2) ) - (* (ptr) src←v14580 ));
SOURCE(29641, 56)
fSize←v26544 = ((* (( (ptr) src←v14580)+3) ) - (* (( (ptr) src←v14580)+1) ));
SOURCE(29699, 417)
if ( ( ( (int)sSize←v26516 > (int)0) ? ( (int)fSize←v26544 > (int)0) : 0 ) ) {
SOURCE(29731, 387)
{
word dstBitIndex←v26588;
word mod←v26616;
SOURCE(29733, 126)
dstBitIndex←v26588 = ((dstOff←v26076 + (((* (ptr) src←v14580 ) - (* (ptr) dst←v14552 )) * (* (( (ptr) dst←v14552)+7) ))) +
((* (( (ptr) src←v14580)+1) ) - (* (( (ptr) dst←v14552)+1) )));
SOURCE(29889, 58)
mod←v26616 = (dstBitIndex←v26588 & 037);
SOURCE(29949, 167)
(void) ( *( (fPt) ((* (ptr) op←v26216 ))))((* (( (ptr) src←v14580)+5) ), (dstPtr←v26048 + IOP2( / , (int)(dstBitIndex←v26588 - mod←v26616), (int)8)
), mod←v26616, SGNCK(fSize←v26544), dstUnitsPerLine←v26188, sSize←v26516, op←v26216);
};
};
SOURCE(30121, 14)
src←v14580 = (* (( (ptr) src←v14580)+7) );
};
goto lab←L100178;
lab←L100176: ;
};
}
else {
SOURCE(30153, 796)
{
word op←v26660;
SOURCE(30155, 17)
op←v26660 = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81628)+226)/* var←c70076 */ ))+8) ))+(((unsigned)function←v14608 << 29) >> 30))
)+(function←v14608 & 1)) );
SOURCE(30304, 634)
lab←L100181: ;
if ((src←v14580 != 0)) {
}
else {
goto lab←L100179;
};
{
W4 box←v26904;
word sCheck←v26932;
word fCheck←v26960;
word dstBitIndex←v26988;
word sSize←v27016;
word fSize←v27044;
W2 dstBA←v27072;
SOURCE(30323, 62)
(* (W2Pt) &box←v26904 ) = (* (W2Pt) src←v14580 );
(* (W2Pt) (( (ptr) &box←v26904)+2) ) = (* (W2Pt) (( (ptr) src←v14580)+2) );
SOURCE(30387, 37)
{
word idx127;
sCheck←v26932 = (
idx127 = (word) ((* (( (ptr) dst←v14552)+2) ) - box←v26904.f2),
SGNCK(idx127)
);
};
SOURCE(30426, 37)
{
word idx128;
fCheck←v26960 = (
idx128 = (word) ((* (( (ptr) dst←v14552)+3) ) - box←v26904.f3),
SGNCK(idx128)
);
};
SOURCE(30465, 101)
{
word idx129;
word idx130;
dstBitIndex←v26988 = (((
idx129 = (word) (box←v26904.f0 - (* (ptr) dst←v14552 )),
SGNCK(idx129)
) * (* (( (ptr) dst←v14552)+7) )) + (
idx130 = (word) (box←v26904.f1 - (* (( (ptr) dst←v14552)+1) )),
SGNCK(idx130)
));
};
SOURCE(30596, 32)
{
word idx131;
sSize←v27016 = (
idx131 = (word) ( ( (int)box←v26904.f0 < (int)box←v26904.f2) ? (box←v26904.f2 - box←v26904.f0) : 0 ) ,
SGNCK(idx131)
);
};
SOURCE(30630, 32)
{
word idx132;
fSize←v27044 = (
idx132 = (word) ( ( (int)box←v26904.f1 < (int)box←v26904.f3) ? (box←v26904.f3 - box←v26904.f1) : 0 ) ,
SGNCK(idx132)
);
};
SOURCE(30692, 51)
{
W2 addr←v57512;
addr←v57512 = (* (W2Pt) (( (ptr) dst←v14552)+8) );
{
word bitOffset←v57544;
word mod←v57572;
bitOffset←v57544 = (dstBitIndex←v26988 + addr←v57512.f1);
mod←v57572 = (bitOffset←v57544 & 037);
SOURCE(2833, 63)
dstBA←v27072.f0 = (addr←v57512.f0 + IOP2( / , (int)(bitOffset←v57544 - mod←v57572), (int)8));
dstBA←v27072.f1 = mod←v57572;
};
};
SOURCE(30745, 177)
if ( ( (sSize←v27016 > 0) ? (fSize←v27044 > 0) : 0 ) ) {
SOURCE(30777, 145)
{
W2 var←c73916;
var←c73916.f0 = (* (( (ptr) src←v14580)+5) );
var←c73916.f1 = 0;
(void) ( *( (fPt) ((* (ptr) op←v26660 ))))(dstBA←v27072, var←c73916, (* (( (ptr) dst←v14552)+7) ), (* (( (ptr) src←v14580)+4)
), sSize←v27016, fSize←v27044, op←v26660);
};
};
SOURCE(30924, 14)
src←v14580 = (* (( (ptr) src←v14580)+7) );
};
goto lab←L100181;
lab←L100179: ;
};
};
};
}
static void Transfer←P3600(dst←v14752, src←v14780, delta←v14808, function←v14836)
word dst←v14752;
word src←v14780;
W2 delta←v14808;
word function←v14836;
{
W4 box←v27116;
/* Transfer: */
SOURCE(30956, 356)
SOURCE(31072, 73)
{
W4 box1←v62876;
W4 box2←v62904;
box1←v62876 = (* (W4Pt) dst←v14752 );
{
W4 box←v63416;
box←v63416 = (* (W4Pt) src←v14780 );
box2←v62904.f0 = (box←v63416.f0 + delta←v14808.f0);
box2←v62904.f1 = (box←v63416.f1 + delta←v14808.f1);
box2←v62904.f2 = (box←v63416.f2 + delta←v14808.f0);
box2←v62904.f3 = (box←v63416.f3 + delta←v14808.f1);
};
{
W2 v1←v62952;
W2 v2←v62980;
v1←v62952 = (* (W2Pt) &box2←v62904 );
v2←v62980 = (* (W2Pt) &box1←v62876 );
if (( (int)v2←v62980.f0 >= (int)v1←v62952.f0)) {
box←v27116.f0 = v2←v62980.f0;
}
else {
box←v27116.f0 = v1←v62952.f0;
};
if (( (int)v2←v62980.f1 >= (int)v1←v62952.f1)) {
box←v27116.f1 = v2←v62980.f1;
}
else {
box←v27116.f1 = v1←v62952.f1;
};
};
{
W2 v1←v63024;
W2 v2←v63052;
v1←v63024 = (* (W2Pt) (( (ptr) &box1←v62876)+2) );
v2←v63052 = (* (W2Pt) (( (ptr) &box2←v62904)+2) );
if (( (int)v1←v63024.f0 <= (int)v2←v63052.f0)) {
box←v27116.f2 = v1←v63024.f0;
}
else {
box←v27116.f2 = v2←v63052.f0;
};
if (( (int)v1←v63024.f1 <= (int)v2←v63052.f1)) {
box←v27116.f3 = v1←v63024.f1;
}
else {
box←v27116.f3 = v2←v63052.f1;
};
};
};
SOURCE(31147, 165)
if ( ( ( (int)box←v27116.f0 < (int)box←v27116.f2) ? ( (int)box←v27116.f1 < (int)box←v27116.f3) : 0 ) ) {
SOURCE(31178, 134)
{
W2 var←c74204;
W2 var←c74236;
var←c74204.f0 = (box←v27116.f0 - delta←v14808.f0);
var←c74204.f1 = (box←v27116.f1 - delta←v14808.f1);
{
word x133;
var←c74236.f0 = (x133 = (box←v27116.f2 - box←v27116.f0),
MAX((int)(word), x133, 0));
};
{
word x134;
var←c74236.f1 = (x134 = (box←v27116.f3 - box←v27116.f1),
MAX((int)(word), x134, 0));
};
(void) BasicTransfer←P3480(dst←v14752, src←v14780, (* (W2Pt) &box←v27116 ), var←c74204, var←c74236, function←v14836);
};
};
}
static void TransferBoxes←P3660(formal←c01366, formal←c01367, formal←c01368, boxes←v14980, formal←c01369)
word formal←c01366;
word formal←c01367;
W2 formal←c01368;
word boxes←v14980;
word formal←c01369;
{
W31 var←c81660;
/* declaration of dst←v14896 skipped */
/* declaration of src←v14924 skipped */
/* declaration of delta←v14952 skipped */
/* declaration of function←v15008 skipped */
register ptr gf←c81692 = (ptr) &globalframe;
/* declaration of var←c74268 skipped */
/* declaration of var←c74300 skipped */
/* declaration of bitsPerSample←v27160 skipped */
word false←v27188;
(* (( (ptr) &var←c81660)+4)/* dst←v14896 */ ) = formal←c01366;
(* (( (ptr) &var←c81660)+5)/* src←v14924 */ ) = formal←c01367;
(* (W2Pt) (( (ptr) &var←c81660)+6)/* delta←v14952 */ ) = formal←c01368;
(* (( (ptr) &var←c81660)+8)/* function←v15008 */ ) = formal←c01369;
/* TransferBoxes: */
SOURCE(31318, 1748)
{
word tmpAddr135;
tmpAddr135 = (word) (( (ptr) &var←c81660)+9)/* var←c74268 */ ;
(* (ptr) tmpAddr135 ) = ( ((word) (fPt) SlowTransfer←P9132) );
(* (( (ptr) tmpAddr135) + 1) ) = 1;
};
{
word tmpAddr136;
tmpAddr136 = (word) (( (ptr) &var←c81660)+11)/* var←c74300 */ ;
(* (ptr) tmpAddr136 ) = ( ((word) (fPt) FastTransfer←P8976) );
(* (( (ptr) tmpAddr136) + 1) ) = 1;
};
SOURCE(31461, 38)
(* (( (ptr) &var←c81660)+13)/* bitsPerSample←v27160 */ ) = (* (( (ptr) (* (( (ptr) &var←c81660)+4)/* dst←v14896 */ ))+5)
);
SOURCE(31501, 41)
{
word idx137;
false←v27188 = (
idx137 = (* (( (ptr) (* (( (ptr) &var←c81660)+4)/* dst←v14896 */ ))+4) ),
BCK(idx137, 1)
);
};
SOURCE(31544, 1282)
{
word var←c74332;
var←c74332 = (* (( (ptr) &var←c81660)+4)/* dst←v14896 */ );
if ((var←c74332 == 0)) {
goto lab←L100187;
};
if (((* (( (ptr) var←c74332)+6) ) == 0)) {
{
/* declaration of dst←v27252 skipped */
(* (( (ptr) &var←c81660)+14)/* dst←v27252 */ ) = var←c74332;
SOURCE(31589, 1237)
{
word var←c74364;
var←c74364 = (* (( (ptr) &var←c81660)+5)/* src←v14924 */ );
if ((var←c74364 == 0)) {
goto lab←L100188;
};
if (((* (( (ptr) var←c74364)+6) ) == 0)) {
{
/* declaration of src←v27296 skipped */
(* (( (ptr) &var←c81660)+15)/* src←v27296 */ ) = var←c74364;
SOURCE(31634, 1192)
if (((* (( (ptr) (* (( (ptr) &var←c81660)+15)/* src←v27296 */ ))+5) ) == (* (( (ptr) &var←c81660)+13)/* bitsPerSample←v27160 */ ))) {
SOURCE(31682, 1146)
{
/* declaration of dstBox←v27340 skipped */
/* declaration of srcBox←v27368 skipped */
/* declaration of bounds←v27396 skipped */
/* declaration of dstBPL←v27424 skipped */
/* declaration of srcBPL←v27452 skipped */
/* declaration of op←v27480 skipped */
SOURCE(31684, 21)
(* (W4Pt) (( (ptr) &var←c81660)+16)/* dstBox←v27340 */ ) = (* (W4Pt) (* (( (ptr) &var←c81660)+14)/* dst←v27252 */ ) );
SOURCE(31707, 47)
{
/*1*/ W4 box←v63368;
/*1*/ box←v63368 = (* (W4Pt) (* (( (ptr) &var←c81660)+15)/* src←v27296 */ ) );
/*1*/ (* (( (ptr) &var←c81660)+20) ) = (box←v63368.f0 + (* (( (ptr) &var←c81660)+6) ));
/*1*/ (* (( (ptr) &var←c81660)+21) ) = (box←v63368.f1 + (* (( (ptr) &var←c81660)+7) ));
/*1*/ (* (( (ptr) &var←c81660)+22) ) = (box←v63368.f2 + (* (( (ptr) &var←c81660)+6) ));
/*1*/ (* (( (ptr) &var←c81660)+23) ) = (box←v63368.f3 + (* (( (ptr) &var←c81660)+7) ));
/*1*/ };
SOURCE(31756, 48)
{
/*1*/ W2 v1←v62732;
/*1*/ W2 v2←v62760;
/*1*/ v1←v62732 = (* (W2Pt) (( (ptr) &var←c81660)+20) );
/*1*/ v2←v62760 = (* (W2Pt) (( (ptr) &var←c81660)+16) );
/*1*/ if (( (int)v2←v62760.f0 >= (int)v1←v62732.f0)) {
/*1*/ (* (( (ptr) &var←c81660)+24) ) = v2←v62760.f0;
/*1*/ }
/*1*/ else {
/*1*/ (* (( (ptr) &var←c81660)+24) ) = v1←v62732.f0;
/*1*/ };
/*1*/ if (( (int)v2←v62760.f1 >= (int)v1←v62732.f1)) {
/*1*/ (* (( (ptr) &var←c81660)+25) ) = v2←v62760.f1;
/*1*/ }
/*1*/ else {
/*1*/ (* (( (ptr) &var←c81660)+25) ) = v1←v62732.f1;
/*1*/ };
/*1*/ };
{
/*1*/ W2 v1←v62804;
/*1*/ W2 v2←v62832;
/*1*/ v1←v62804 = (* (W2Pt) (( (ptr) &var←c81660)+18) );
/*1*/ v2←v62832 = (* (W2Pt) (( (ptr) &var←c81660)+22) );
/*1*/ if (( (int)v1←v62804.f0 <= (int)v2←v62832.f0)) {
/*1*/ (* (( (ptr) &var←c81660)+26) ) = v1←v62804.f0;
/*1*/ }
/*1*/ else {
/*1*/ (* (( (ptr) &var←c81660)+26) ) = v2←v62832.f0;
/*1*/ };
/*1*/ if (( (int)v1←v62804.f1 <= (int)v2←v62832.f1)) {
/*1*/ (* (( (ptr) &var←c81660)+27) ) = v1←v62804.f1;
/*1*/ }
/*1*/ else {
/*1*/ (* (( (ptr) &var←c81660)+27) ) = v2←v62832.f1;
/*1*/ };
/*1*/ };
SOURCE(31806, 29)
{
/*1*/ word idx138;
/*1*/ (* (( (ptr) &var←c81660)+28)/* dstBPL←v27424 */ ) = (
/*1*/ idx138 = (* (( (ptr) (* (( (ptr) &var←c81660)+14)/* dst←v27252 */ ))+7) ),
/*1*/ SGNCK(idx138)
/*1*/ );
/*1*/ };
SOURCE(31837, 29)
{
/*1*/ word idx139;
/*1*/ (* (( (ptr) &var←c81660)+29)/* srcBPL←v27452 */ ) = (
/*1*/ idx139 = (* (( (ptr) (* (( (ptr) &var←c81660)+15)/* src←v27296 */ ))+7) ),
/*1*/ SGNCK(idx139)
/*1*/ );
/*1*/ };
SOURCE(31868, 17)
(* (( (ptr) &var←c81660)+30)/* op←v27480 */ ) = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81692)+226)/* var←c70076 */ ))+8)
/*1*/ ))+(((unsigned)(* (( (bPt) &var←c81660)+35) ) << 29) >> 30)))+((* (( (bPt) &var←c81660)+35) ) & 1)) );
SOURCE(32799, 19)
(void) ( *( (fPt) ((* (ptr) boxes←v14980 ))))((word) ((( (bPt) &var←c81660)+44)/* var←c74300 */ ), boxes←v14980);
SOURCE(32820, 6)
return;
};
};
};
}
else {
lab←L100188: ;
};
};
};
}
else {
lab←L100187: ;
};
};
SOURCE(32863, 205)
SOURCE(33047, 19)
(void) ( *( (fPt) ((* (ptr) boxes←v14980 ))))((word) ((( (bPt) &var←c81660)+36)/* var←c74268 */ ), boxes←v14980);
}
static void FastTransfer←P8976(box←v55364, formal←c81724)
W4 box←v55364;
word formal←c81724;
{
word sSize←v27752;
word fSize←v27780;
formal←c81724 = (formal←c81724 - 44);
/* FastTransfer: */
SOURCE(32017, 34)
SOURCE(32053, 36)
sSize←v27752 = (box←v55364.f2 - box←v55364.f0);
SOURCE(32091, 36)
fSize←v27780 = (box←v55364.f3 - box←v55364.f1);
SOURCE(32129, 662)
if ( ( ( (int)sSize←v27752 > (int)0) ? ( (int)fSize←v27780 > (int)0) : 0 ) ) {
SOURCE(32161, 632)
{
word sSpaceLo←v27824;
word fSpaceLo←v27852;
word sSpaceHi←v27880;
word fSpaceHi←v27908;
word dstBitIndex←v27936;
word srcBitIndex←v27964;
W2 dstBA←v27992;
W2 srcBA←v28020;
SOURCE(32163, 38)
{
word idx140;
sSpaceLo←v27824 = (
idx140 = (word) (box←v55364.f0 - (* (( (ptr) formal←c81724)+24) )),
SGNCK(idx140)
);
};
SOURCE(32223, 38)
{
word idx141;
fSpaceLo←v27852 = (
idx141 = (word) (box←v55364.f1 - (* (( (ptr) formal←c81724)+25) )),
SGNCK(idx141)
);
};
SOURCE(32263, 38)
{
word idx142;
sSpaceHi←v27880 = (
idx142 = (word) ((* (( (ptr) formal←c81724)+26) ) - box←v55364.f2),
SGNCK(idx142)
);
};
SOURCE(32303, 38)
{
word idx143;
fSpaceHi←v27908 = (
idx143 = (word) ((* (( (ptr) formal←c81724)+27) ) - box←v55364.f3),
SGNCK(idx143)
);
};
SOURCE(32343, 112)
{
word idx144;
word idx145;
dstBitIndex←v27936 = (((
idx144 = (word) (box←v55364.f0 - (* (( (ptr) formal←c81724)+16) )),
SGNCK(idx144)
) * (* (( (ptr) formal←c81724)+28) )) + ((
idx145 = (word) (box←v55364.f1 - (* (( (ptr) formal←c81724)+17) )),
SGNCK(idx145)
) * (* (( (ptr) formal←c81724)+13) )));
};
SOURCE(32457, 112)
{
word idx146;
word idx147;
srcBitIndex←v27964 = (((
idx146 = (word) (box←v55364.f0 - (* (( (ptr) formal←c81724)+20) )),
SGNCK(idx146)
) * (* (( (ptr) formal←c81724)+29) )) + ((
idx147 = (word) (box←v55364.f1 - (* (( (ptr) formal←c81724)+21) )),
SGNCK(idx147)
) * (* (( (ptr) formal←c81724)+13) )));
};
SOURCE(32571, 51)
{
W2 addr←v57408;
addr←v57408 = (* (W2Pt) (( (ptr) (* (( (ptr) formal←c81724)+14) ))+8) );
{
word bitOffset←v57440;
word mod←v57468;
bitOffset←v57440 = (dstBitIndex←v27936 + addr←v57408.f1);
mod←v57468 = (bitOffset←v57440 & 037);
SOURCE(2833, 63)
dstBA←v27992.f0 = (addr←v57408.f0 + IOP2( / , (int)(bitOffset←v57440 - mod←v57468), (int)8));
dstBA←v27992.f1 = mod←v57468;
};
};
SOURCE(32624, 51)
{
W2 addr←v57304;
addr←v57304 = (* (W2Pt) (( (ptr) (* (( (ptr) formal←c81724)+15) ))+8) );
{
word bitOffset←v57336;
word mod←v57364;
bitOffset←v57336 = (srcBitIndex←v27964 + addr←v57304.f1);
mod←v57364 = (bitOffset←v57336 & 037);
SOURCE(2833, 63)
srcBA←v28020.f0 = (addr←v57304.f0 + IOP2( / , (int)(bitOffset←v57336 - mod←v57364), (int)8));
srcBA←v28020.f1 = mod←v57364;
};
};
SOURCE(32677, 114)
{
word pd148;
pd148 = (* (( (ptr) formal←c81724)+30) );
(void) ( *( (fPt) ((* (ptr) pd148 ))))(dstBA←v27992, srcBA←v28020, (* (( (ptr) formal←c81724)+28) ), (* (( (ptr) formal←c81724)+29)
), SGNCK(sSize←v27752), (SGNCK(fSize←v27780) * (* (( (ptr) formal←c81724)+13) )), pd148);
};
};
};
}
static void SlowTransfer←P9132(box←v55424, formal←c81756)
W4 box←v55424;
word formal←c81756;
{
W2 dstMin←v28108;
W2 srcMin←v28136;
formal←c81756 = (formal←c81756 - 36);
/* SlowTransfer: */
SOURCE(32865, 26)
SOURCE(32893, 21)
dstMin←v28108 = (* (W2Pt) &box←v55424 );
SOURCE(32916, 42)
srcMin←v28136.f0 = (box←v55424.f0 - (* (( (ptr) formal←c81756)+6) ));
srcMin←v28136.f1 = (box←v55424.f1 - (* (( (ptr) formal←c81756)+7) ));
SOURCE(32960, 82)
{
W2 var←c74780;
var←c74780.f0 = (box←v55424.f2 - box←v55424.f0);
var←c74780.f1 = (box←v55424.f3 - box←v55424.f1);
(void) BufferTransfer←P3420((* (( (ptr) formal←c81756)+4) ), (* (( (ptr) formal←c81756)+5) ), dstMin←v28108, srcMin←v28136, var←c74780, (* (
( (ptr) formal←c81756)+8) ));
};
}
static void Move←P3720(map←v15068, dstMin←v15096, srcMin←v15124, size←v15152, function←v15180)
word map←v15068;
W2 dstMin←v15096;
W2 srcMin←v15124;
W2 size←v15152;
word function←v15180;
{
register ptr gf←c81788 = (ptr) &globalframe;
word false←v28180;
W2 selfSize←v28208;
word sDst0←v28236;
word fDst0←v28264;
word sSrc0←v28292;
word fSrc0←v28320;
word sSize←v28348;
word fSize←v28376;
/* Move: */
SOURCE(33075, 2544)
SOURCE(33169, 41)
{
word idx149;
false←v28180 = (
idx149 = (* (( (ptr) map←v15068)+4) ),
BCK(idx149, 1)
);
};
SOURCE(33212, 31)
selfSize←v28208.f0 = ((* (( (ptr) map←v15068)+2) ) - (* (ptr) map←v15068 ));
selfSize←v28208.f1 = ((* (( (ptr) map←v15068)+3) ) - (* (( (ptr) map←v15068)+1) ));
SOURCE(33245, 37)
{
word idx150;
sDst0←v28236 = (
idx150 = (word) (dstMin←v15096.f0 - (* (ptr) map←v15068 )),
SGNCK(idx150)
);
};
SOURCE(33284, 37)
{
word idx151;
fDst0←v28264 = (
idx151 = (word) (dstMin←v15096.f1 - (* (( (ptr) map←v15068)+1) )),
SGNCK(idx151)
);
};
SOURCE(33323, 37)
{
word idx152;
sSrc0←v28292 = (
idx152 = (word) (srcMin←v15124.f0 - (* (ptr) map←v15068 )),
SGNCK(idx152)
);
};
SOURCE(33362, 37)
{
word idx153;
fSrc0←v28320 = (
idx153 = (word) (srcMin←v15124.f1 - (* (( (ptr) map←v15068)+1) )),
SGNCK(idx153)
);
};
SOURCE(33401, 69)
{
word value←v58864;
word bound←v58892;
{
word bound←v58940;
bound←v58940 = (selfSize←v28208.f0 - sDst0←v28236);
SOURCE(3290, 95)
if ((size←v15152.f0 > bound←v58940)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81788)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
{
word idx154;
value←v58864 = (
idx154 = (word) size←v15152.f0,
SGNCK(idx154)
);
};
};
};
bound←v58892 = (selfSize←v28208.f0 - sSrc0←v28292);
SOURCE(3290, 95)
if ((value←v58864 > bound←v58892)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81788)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
sSize←v28348 = SGNCK(value←v58864);
};
};
SOURCE(33472, 69)
{
word value←v58740;
word bound←v58768;
{
word bound←v58816;
bound←v58816 = (selfSize←v28208.f1 - fDst0←v28264);
SOURCE(3290, 95)
if ((size←v15152.f1 > bound←v58816)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81788)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
{
word idx155;
value←v58740 = (
idx155 = (word) size←v15152.f1,
SGNCK(idx155)
);
};
};
};
bound←v58768 = (selfSize←v28208.f1 - fSrc0←v28320);
SOURCE(3290, 95)
if ((value←v58740 > bound←v58768)) {
SOURCE(3334, 36)
(void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c81788)+227)/* var←c70300 */ ))+8) ), 0);
}
else {
SOURCE(3370, 15)
fSize←v28376 = SGNCK(value←v58740);
};
};
SOURCE(33543, 35)
if ((sSize←v28348 == 0) || (fSize←v28376 == 0)) {
SOURCE(33572, 6)
return;
};
SOURCE(33580, 2039)
{
word var←c74972;
var←c74972 = map←v15068;
if ((var←c74972 == 0)) {
goto lab←L100198;
};
{
word var←c75516;
var←c75516 = (* (( (ptr) var←c74972)+6) );
if ((var←c75516 == 0)) {
{
word map←v28440;
map←v28440 = var←c74972;
SOURCE(33625, 1263)
{
word bitsPerSample←v28484;
word bitsPerLine←v28512;
word dstBitIndex←v28540;
word srcBitIndex←v28568;
SOURCE(33627, 38)
bitsPerSample←v28484 = (* (( (ptr) map←v28440)+5) );
SOURCE(33667, 34)
{
word idx156;
bitsPerLine←v28512 = (
idx156 = (* (( (ptr) map←v28440)+7) ),
SGNCK(idx156)
);
};
SOURCE(33703, 71)
dstBitIndex←v28540 = ((sDst0←v28236 * bitsPerLine←v28512) + (fDst0←v28264 * bitsPerSample←v28484));
SOURCE(33776, 71)
srcBitIndex←v28568 = ((sSrc0←v28292 * bitsPerLine←v28512) + (fSrc0←v28320 * bitsPerSample←v28484));
SOURCE(33849, 1034)
if ( ( ( ( ( ((fSrc0←v28320 + fSize←v28376) > fDst0←v28264) ? ((fDst0←v28264 + fSize←v28376) > fSrc0←v28320) : 0 ) ? ((sSrc0←v28292 +
sSize←v28348) > sDst0←v28236) : 0 ) ? ((sDst0←v28236 + sSize←v28348) > sSrc0←v28292) : 0 ) ? ( (sDst0←v28236 > sSrc0←v28292) ? 1 : ( (sDst0←v28236 == sSrc0←v28292) ? (fDst0←v28264 > fSrc0←v28320) : 0 ) ) : 0 ) ) {
SOURCE(34016, 630)
if (( (int)srcMin←v15124.f0 < (int)dstMin←v15096.f0)) {
SOURCE(34044, 310)
{
word bandSize←v28612;
SOURCE(34046, 35)
{
/*1*/ word idx157;
/*1*/ bandSize←v28612 = (
/*1*/ idx157 = (word) (dstMin←v15096.f0 - srcMin←v15124.f0),
/*1*/ SGNCK(idx157)
/*1*/ );
/*1*/ };
SOURCE(34083, 260)
{
/*1*/ register word sEnd←v28656;
/*1*/ sEnd←v28656 = size←v15152.f0;
/*1*/ lab←L100202: ;
/*1*/ if (( (int)sEnd←v28656 > (int)0)) {
/*1*/ }
/*1*/ else {
/*1*/ goto lab←L100199;
/*1*/ };
/*1*/ {
/*1*/ word sBegin←v28700;
SOURCE(34144, 39)
/*1*/ sBegin←v28700 = (MAX((int)(word), (sEnd←v28656 - bandSize←v28612), 0));
SOURCE(34185, 158)
/*1*/ {
/*1*/ W2 var←c75004;
/*1*/ W2 var←c75036;
/*1*/ W2 var←c75068;
/*1*/ var←c75004.f0 = (dstMin←v15096.f0 + sBegin←v28700);
/*1*/ var←c75004.f1 = dstMin←v15096.f1;
/*1*/ var←c75036.f0 = (srcMin←v15124.f0 + sBegin←v28700);
/*1*/ var←c75036.f1 = srcMin←v15124.f1;
/*1*/ var←c75068.f0 = (sEnd←v28656 - sBegin←v28700);
/*1*/ var←c75068.f1 = size←v15152.f1;
/*1*/ (void) BasicTransfer←P3480(map←v28440, map←v28440, var←c75004, var←c75036, var←c75068, function←v15180);
/*1*/ };
/*1*/ };
/*1*/ sEnd←v28656 = (sEnd←v28656 - bandSize←v28612);
/*1*/ goto lab←L100202;
/*1*/ lab←L100199: ;
/*1*/ };
};
}
else {
SOURCE(34361, 287)
{
word temp←v28744;
SOURCE(34363, 86)
{
/*1*/ W4 var←c75100;
/*1*/ var←c75100.f0 = 0;
/*1*/ var←c75100.f1 = 0;
/*1*/ (* (W2Pt) (( (ptr) &var←c75100)+2) ) = size←v15152;
/*1*/ temp←v28744 = (word) ObtainScratchMap←P1920(var←c75100, (* (( (ptr) map←v28440)+5) ), 0);
/*1*/ };
SOURCE(34451, 86)
{
/*1*/ W2 var←c75132;
/*1*/ var←c75132.f0 = 0;
/*1*/ var←c75132.f1 = 0;
/*1*/ (void) BasicTransfer←P3480(temp←v28744, map←v28440, var←c75132, srcMin←v15124, size←v15152, 0);
/*1*/ };
SOURCE(34539, 82)
{
/*1*/ W2 var←c75164;
/*1*/ var←c75164.f0 = 0;
/*1*/ var←c75164.f1 = 0;
/*1*/ (void) BasicTransfer←P3480(map←v28440, temp←v28744, dstMin←v15096, var←c75164, size←v15152, function←v15180);
/*1*/ };
SOURCE(34623, 23)
(void) ReleaseScratchMap←P1980(temp←v28744);
};
};
}
else {
SOURCE(34660, 223)
{
W2 var←c75196;
W2 var←c75292;
{
W2 var←c75228;
W2 addr←v57200;
addr←v57200 = (* (W2Pt) (( (ptr) map←v28440)+8) );
{
/*1*/ word bitOffset←v57232;
/*1*/ word mod←v57260;
/*1*/ bitOffset←v57232 = (dstBitIndex←v28540 + addr←v57200.f1);
/*1*/ mod←v57260 = (bitOffset←v57232 & 037);
SOURCE(2833, 63)
/*1*/ var←c75228.f0 = (addr←v57200.f0 + IOP2( / , (int)(bitOffset←v57232 - mod←v57260), (int)8));
/*1*/ var←c75228.f1 = mod←v57260;
/*1*/ };
var←c75196 = var←c75228;
};
{
W2 var←c75324;
W2 addr←v57096;
addr←v57096 = (* (W2Pt) (( (ptr) map←v28440)+8) );
{
/*1*/ word bitOffset←v57128;
/*1*/ word mod←v57156;
/*1*/ bitOffset←v57128 = (srcBitIndex←v28568 + addr←v57096.f1);
/*1*/ mod←v57156 = (bitOffset←v57128 & 037);
SOURCE(2833, 63)
/*1*/ var←c75324.f0 = (addr←v57096.f0 + IOP2( / , (int)(bitOffset←v57128 - mod←v57156), (int)8));
/*1*/ var←c75324.f1 = mod←v57156;
/*1*/ };
var←c75292 = var←c75324;
};
{
word pd158;
pd158 = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81788)+226)/* var←c70076 */ ))+8) ))+(((unsigned)function←v15180 << 29) >> 30))
/*1*/ )+(function←v15180 & 1)) );
(void) ( *( (fPt) ((* (ptr) pd158 ))))(var←c75196, var←c75292, bitsPerLine←v28512, bitsPerLine←v28512, sSize←v28348, (fSize←v28376 * bitsPerSample←v28484), pd158)
;
};
};
};
};
};
}
else {
if ((var←c75516 == 1)) {
{
word map←v28788;
map←v28788 = var←c74972;
SOURCE(34915, 706)
{
word buffer←v28832;
word class←v28860;
SOURCE(34917, 50)
buffer←v28832 = (word) ObtainScratchSamples←P780(fSize←v28376);
SOURCE(34969, 33)
class←v28860 = (* (( (ptr) map←v28788)+7) );
SOURCE(35004, 572)
if ((sDst0←v28236 <= sSrc0←v28292)) {
SOURCE(35029, 258)
{
register word s←v28904 = 0;
if ((s←v28904 >= sSize←v28348)) {
/*1*/ goto lab←L100205;
/*1*/ };
lab←L100208: ;
SOURCE(35057, 102)
{
/*1*/ W2 var←c75388;
/*1*/ var←c75388.f0 = (s←v28904 + srcMin←v15124.f0);
/*1*/ var←c75388.f1 = srcMin←v15124.f1;
/*1*/ {
/*1*/ word pd159;
/*1*/ pd159 = (* (ptr) class←v28860 );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd159 ))))(map←v28788, var←c75388, buffer←v28832, 0, fSize←v28376, pd159);
/*1*/ };
/*1*/ };
SOURCE(35161, 126)
{
/*1*/ W2 var←c75420;
/*1*/ var←c75420.f0 = (s←v28904 + dstMin←v15096.f0);
/*1*/ var←c75420.f1 = dstMin←v15096.f1;
/*1*/ {
/*1*/ word pd160;
/*1*/ pd160 = (* (( (ptr) class←v28860)+1) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd160 ))))(map←v28788, var←c75420, buffer←v28832, 0, fSize←v28376, 0, pd160);
/*1*/ };
/*1*/ };
s←v28904 = (s←v28904 + 1);
if ((s←v28904 < sSize←v28348)) {
/*1*/ goto lab←L100208;
/*1*/ };
lab←L100205: ;
};
}
else {
SOURCE(35307, 269)
{
register word s←v28948;
s←v28948 = sSize←v28348;
if ((0 >= s←v28948)) {
/*1*/ goto lab←L100209;
/*1*/ };
s←v28948 = (s←v28948 - 1);
lab←L100212: ;
SOURCE(35346, 102)
{
/*1*/ W2 var←c75452;
/*1*/ var←c75452.f0 = (s←v28948 + srcMin←v15124.f0);
/*1*/ var←c75452.f1 = srcMin←v15124.f1;
/*1*/ {
/*1*/ word pd161;
/*1*/ pd161 = (* (ptr) class←v28860 );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd161 ))))(map←v28788, var←c75452, buffer←v28832, 0, fSize←v28376, pd161);
/*1*/ };
/*1*/ };
SOURCE(35450, 126)
{
/*1*/ W2 var←c75484;
/*1*/ var←c75484.f0 = (s←v28948 + dstMin←v15096.f0);
/*1*/ var←c75484.f1 = dstMin←v15096.f1;
/*1*/ {
/*1*/ word pd162;
/*1*/ pd162 = (* (( (ptr) class←v28860)+1) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd162 ))))(map←v28788, var←c75484, buffer←v28832, 0, fSize←v28376, 0, pd162);
/*1*/ };
/*1*/ };
if ((0 >= s←v28948)) {
/*1*/ goto lab←L100209;
/*1*/ };
s←v28948 = (s←v28948 - 1);
goto lab←L100212;
lab←L100209: ;
};
};
SOURCE(35590, 29)
(void) ReleaseScratchSamples←P840(buffer←v28832);
};
};
}
else {
lab←L100198: ;
};
};
};
};
}
static void BufferFill←P3780(map←v15240, box←v15268, value←v15296, function←v15324)
word map←v15240;
W4 box←v15268;
word value←v15296;
word function←v15324;
{
register ptr gf←c81820 = (ptr) &globalframe;
/* BufferFill: */
SOURCE(35645, 466)
SOURCE(35752, 32)
{
word pd163;
pd163 = (* (( (ptr) (* (( (ptr) gf←c81820)+225)/* var←c67164 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd163 ))))((word) &box←v15268, (* (W4Pt) map←v15240 ), box←v15268, pd163);
};
SOURCE(35786, 325)
if ( ( ( (int)box←v15268.f0 < (int)box←v15268.f2) ? ( (int)box←v15268.f1 < (int)box←v15268.f3) : 0 ) ) {
SOURCE(35817, 296)
{
word buffer←v28992;
SOURCE(35819, 64)
{
word idx164;
buffer←v28992 = (word) ObtainScratchSamples←P780((
idx164 = (word) (box←v15268.f3 - box←v15268.f1),
SGNCK(idx164)
));
};
SOURCE(35885, 61)
{
register word i←v29036 = 0;
register word noName←c75548;
noName←c75548 = (* (ptr) buffer←v28992 );
if ((i←v29036 >= noName←c75548)) {
goto lab←L100213;
};
lab←L100216: ;
SOURCE(35921, 25)
{
word limit165;
(* ((( (ptr) buffer←v28992)+2)+(
limit165 = (* (( (ptr) buffer←v28992)+1) ),
BCK(i←v29036, limit165)
)) ) = value←v15296;
};
i←v29036 = (i←v29036 + 1);
if ((i←v29036 < noName←c75548)) {
goto lab←L100216;
};
lab←L100213: ;
};
SOURCE(35948, 123)
{
register word s←v29080;
register word noName←c75580;
{
word idx166;
s←v29080 = (
idx166 = (word) box←v15268.f0,
SGNCK(idx166)
);
};
{
word idx167;
noName←c75580 = (
idx167 = (word) box←v15268.f2,
SGNCK(idx167)
);
};
if ((s←v29080 >= noName←c75580)) {
goto lab←L100217;
};
lab←L100220: ;
SOURCE(35988, 83)
{
W2 var←c75612;
W2 var←c75644;
var←c75612.f0 = s←v29080;
var←c75612.f1 = box←v15268.f1;
var←c75644.f0 = 0;
var←c75644.f1 = 1;
(void) PutSamples←P3300(map←v15240, var←c75612, var←c75644, buffer←v28992, 0, 2147483647
, function←v15324);
};
s←v29080 = (s←v29080 + 1);
if ((s←v29080 < noName←c75580)) {
goto lab←L100220;
};
lab←L100217: ;
};
SOURCE(36082, 29)
(void) ReleaseScratchSamples←P840(buffer←v28992);
};
};
}
static void Fill←P3840(map←v15420, box←v15448, value←v15476, function←v15504)
word map←v15420;
W4 box←v15448;
word value←v15476;
word function←v15504;
{
register ptr gf←c81852 = (ptr) &globalframe;
word false←v29124;
word bitsPerSample←v29152;
/* Fill: */
SOURCE(36233, 1016)
SOURCE(36332, 41)
{
word idx168;
false←v29124 = (
idx168 = (* (( (ptr) map←v15420)+4) ),
BCK(idx168, 1)
);
};
SOURCE(36375, 38)
bitsPerSample←v29152 = (* (( (ptr) map←v15420)+5) );
SOURCE(36415, 756)
{
word var←c75676;
var←c75676 = map←v15420;
if ((var←c75676 == 0)) {
goto lab←L100221;
};
if (((* (( (ptr) var←c75676)+6) ) == 0)) {
{
word map←v29216;
map←v29216 = var←c75676;
SOURCE(36460, 711)
if (((word) XRM←BITAND(bitsPerSample←v29152, SGNCK((bitsPerSample←v29152 - 1))) == 0)) {
SOURCE(36504, 669)
{
word bitsPerLine←v29260;
W4 actualBox←v29288;
word sSize←v29316;
word fSize←v29344;
word dstBitIndex←v29372;
word bitMask←v29400;
word replicatedPixel←v29428;
SOURCE(36506, 34)
{
word idx169;
bitsPerLine←v29260 = (
idx169 = (* (( (ptr) map←v29216)+7) ),
SGNCK(idx169)
);
};
SOURCE(36542, 49)
{
W4 box1←v62540;
box1←v62540 = (* (W4Pt) map←v29216 );
{
W2 v1←v62588;
W2 v2←v62616;
v1←v62588 = (* (W2Pt) &box←v15448 );
v2←v62616 = (* (W2Pt) &box1←v62540 );
if (( (int)v2←v62616.f0 >= (int)v1←v62588.f0)) {
actualBox←v29288.f0 = v2←v62616.f0;
}
else {
actualBox←v29288.f0 = v1←v62588.f0;
};
if (( (int)v2←v62616.f1 >= (int)v1←v62588.f1)) {
actualBox←v29288.f1 = v2←v62616.f1;
}
else {
actualBox←v29288.f1 = v1←v62588.f1;
};
};
{
W2 v1←v62660;
W2 v2←v62688;
v1←v62660 = (* (W2Pt) (( (ptr) &box1←v62540)+2) );
v2←v62688 = (* (W2Pt) (( (ptr) &box←v15448)+2) );
if (( (int)v1←v62660.f0 <= (int)v2←v62688.f0)) {
actualBox←v29288.f2 = v1←v62660.f0;
}
else {
actualBox←v29288.f2 = v2←v62688.f0;
};
if (( (int)v1←v62660.f1 <= (int)v2←v62688.f1)) {
actualBox←v29288.f3 = v1←v62660.f1;
}
else {
actualBox←v29288.f3 = v2←v62688.f1;
};
};
};
SOURCE(36593, 43)
sSize←v29316 = ( ( (int)actualBox←v29288.f0 < (int)actualBox←v29288.f2) ? (actualBox←v29288.f2 - actualBox←v29288.f0) : 0 ) ;
SOURCE(36638, 43)
fSize←v29344 = ( ( (int)actualBox←v29288.f1 < (int)actualBox←v29288.f3) ? (actualBox←v29288.f3 - actualBox←v29288.f1) : 0 ) ;
SOURCE(36683, 131)
{
word idx170;
word idx171;
dstBitIndex←v29372 = (((
idx170 = (word) (actualBox←v29288.f0 - (* (ptr) map←v29216 )),
SGNCK(idx170)
) * bitsPerLine←v29260) + ((
idx171 = (word) (actualBox←v29288.f1 - (* (( (ptr) map←v29216)+1) )),
SGNCK(idx171)
) * bitsPerSample←v29152));
};
SOURCE(36816, 42)
{
word var←c75900;
{
word i←v60984;
i←v60984 = (32 - bitsPerSample←v29152);
SOURCE(18510, 39)
var←c75900 = (i←v60984 & 037);
};
bitMask←v29400 = (word) XRM←BITRSHIFT( (word) -1, var←c75900);
};
SOURCE(36860, 85)
{
word idx172;
replicatedPixel←v29428 = ((word) XRM←BITAND(value←v15476, bitMask←v29400) * (* ((( (ptr) gf←c81852)+213)/* var←c66460 */ +(
idx172 = (word) Lg←P240(bitsPerSample←v29152),
BCK(idx172, 6)
)) ));
};
SOURCE(36947, 216)
{
W2 var←c75964;
{
W2 var←c75996;
W2 addr←v56992;
addr←v56992 = (* (W2Pt) (( (ptr) map←v29216)+8) );
{
word bitOffset←v57024;
word mod←v57052;
bitOffset←v57024 = (dstBitIndex←v29372 + addr←v56992.f1);
mod←v57052 = (bitOffset←v57024 & 037);
SOURCE(2833, 63)
var←c75996.f0 = (addr←v56992.f0 + IOP2( / , (int)(bitOffset←v57024 - mod←v57052), (int)8));
var←c75996.f1 = mod←v57052;
};
var←c75964 = var←c75996;
};
{
word pd173;
pd173 = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81852)+226)/* var←c70076 */ ))+7) ))+(((unsigned)function←v15504 << 29) >> 30))
)+(function←v15504 & 1)) );
(void) ( *( (fPt) ((* (ptr) pd173 ))))(var←c75964, (word) &replicatedPixel←v29428, bitsPerLine←v29260, 0, 1, sSize←v29316
, (fSize←v29344 * bitsPerSample←v29152), pd173);
};
};
SOURCE(37165, 6)
return;
};
};
};
}
else {
lab←L100221: ;
};
};
SOURCE(37185, 64)
(void) BufferFill←P3780(map←v15420, box←v15448, value←v15476, function←v15504);
}
static void FillBoxes←P3900(formal←c01370, boxes←v15592, formal←c01371, formal←c01372)
word formal←c01370;
word boxes←v15592;
word formal←c01371;
word formal←c01372;
{
W15 var←c81884;
/* declaration of map←v15564 skipped */
/* declaration of value←v15620 skipped */
/* declaration of function←v15648 skipped */
register ptr gf←c81916 = (ptr) &globalframe;
/* declaration of var←c76060 skipped */
/* declaration of var←c76092 skipped */
word false←v29472;
word bitsPerSample←v29500;
(* (( (ptr) &var←c81884)+4)/* map←v15564 */ ) = formal←c01370;
(* (( (ptr) &var←c81884)+5)/* value←v15620 */ ) = formal←c01371;
(* (( (ptr) &var←c81884)+6)/* function←v15648 */ ) = formal←c01372;
/* FillBoxes: */
SOURCE(37255, 2113)
{
word tmpAddr174;
tmpAddr174 = (word) (( (ptr) &var←c81884)+7)/* var←c76060 */ ;
(* (ptr) tmpAddr174 ) = ( ((word) (fPt) SlowFill←P10164) );
(* (( (ptr) tmpAddr174) + 1) ) = 1;
};
{
word tmpAddr175;
tmpAddr175 = (word) (( (ptr) &var←c81884)+9)/* var←c76092 */ ;
(* (ptr) tmpAddr175 ) = ( ((word) (fPt) FastFill←P10008) );
(* (( (ptr) tmpAddr175) + 1) ) = 1;
};
SOURCE(37383, 41)
{
word idx176;
false←v29472 = (
idx176 = (* (( (ptr) (* (( (ptr) &var←c81884)+4)/* map←v15564 */ ))+4) ),
BCK(idx176, 1)
);
};
SOURCE(37426, 38)
bitsPerSample←v29500 = (* (( (ptr) (* (( (ptr) &var←c81884)+4)/* map←v15564 */ ))+5) );
SOURCE(37466, 1790)
{
word var←c76124;
var←c76124 = (* (( (ptr) &var←c81884)+4)/* map←v15564 */ );
if ((var←c76124 == 0)) {
goto lab←L100227;
};
if (((* (( (ptr) var←c76124)+6) ) == 0)) {
{
/* declaration of map←v29564 skipped */
(* (( (ptr) &var←c81884)+11)/* map←v29564 */ ) = var←c76124;
SOURCE(37511, 1745)
if (((word) XRM←BITAND(bitsPerSample←v29500, SGNCK((bitsPerSample←v29500 - 1))) == 0)) {
SOURCE(37555, 1703)
{
/* declaration of lgBitsPerSample←v29608 skipped */
word bitMask←v29636;
/* declaration of replicatedPixel←v29664 skipped */
/* declaration of op←v29692 skipped */
SOURCE(37557, 43)
{
word idx177;
(* (( (ptr) &var←c81884)+12)/* lgBitsPerSample←v29608 */ ) = (
idx177 = (word) Lg←P240(bitsPerSample←v29500),
BCK(idx177, 6)
);
};
SOURCE(37602, 52)
bitMask←v29636 = ((word) XRM←BITLSHIFT(1, BCK(bitsPerSample←v29500, 32)) - 1);
SOURCE(37656, 83)
(* (( (ptr) &var←c81884)+13)/* replicatedPixel←v29664 */ ) = ((word) XRM←BITAND((* (( (ptr) &var←c81884)+5)/* value←v15620 */ ), bitMask←v29636)
* (* ((( (ptr) gf←c81916)+213)/* var←c66460 */ +(* (( (ptr) &var←c81884)+12)/* lgBitsPerSample←v29608 */ )) ));
SOURCE(37741, 17)
(* (( (ptr) &var←c81884)+14)/* op←v29692 */ ) = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c81916)+226)/* var←c70076 */ ))+7)
))+(((unsigned)(* (( (bPt) &var←c81884)+27) ) << 29) >> 30)))+((* (( (bPt) &var←c81884)+27) ) & 1)) );
SOURCE(39233, 15)
(void) ( *( (fPt) ((* (ptr) boxes←v15592 ))))((word) ((( (bPt) &var←c81884)+36)/* var←c76092 */ ), boxes←v15592);
SOURCE(39250, 6)
return;
};
};
};
}
else {
lab←L100227: ;
};
};
SOURCE(39286, 84)
SOURCE(39353, 15)
(void) ( *( (fPt) ((* (ptr) boxes←v15592 ))))((word) ((( (bPt) &var←c81884)+28)/* var←c76060 */ ), boxes←v15592);
}
static void FastFill←P10008(box←v55508, formal←c81948)
W4 box←v55508;
word formal←c81948;
{
word sMin←v30012;
word fMin←v30040;
word sMax←v30068;
word fMax←v30096;
formal←c81948 = (formal←c81948 - 36);
/* FastFill: */
SOURCE(37899, 30)
SOURCE(37931, 25)
sMin←v30012 = box←v55508.f0;
SOURCE(37958, 25)
fMin←v30040 = box←v55508.f1;
SOURCE(37985, 25)
sMax←v30068 = box←v55508.f2;
SOURCE(38012, 25)
fMax←v30096 = box←v55508.f3;
SOURCE(38039, 1186)
if ( ( ( (int)sMax←v30068 > (int)sMin←v30012) ? ( (int)fMax←v30096 > (int)fMin←v30040) : 0 ) ) {
SOURCE(38075, 1152)
{
word m←v30140;
word bitsPerLine←v30168;
word sDst←v30196;
word fDst←v30224;
word lgBPS←v30252;
word check←v30280;
word bitDst←v30308;
word fBitCount←v30336;
word mod←v30364;
word wordAddress←v30392;
word sSize←v30420;
SOURCE(38077, 24)
m←v30140 = (* (( (ptr) formal←c81948)+11) );
SOURCE(38103, 37)
bitsPerLine←v30168 = (* (( (ptr) m←v30140)+7) );
SOURCE(38142, 43)
sDst←v30196 = (sMin←v30012 - (* (ptr) m←v30140 ));
SOURCE(38187, 43)
fDst←v30224 = (fMin←v30040 - (* (( (ptr) m←v30140)+1) ));
SOURCE(38232, 31)
lgBPS←v30252 = (* (( (ptr) formal←c81948)+12) );
SOURCE(38265, 141)
{
word var←c76156;
word var←c76188;
var←c76156 = (word) XRM←BITOR(sDst←v30196, fDst←v30224);
var←c76188 = (word) XRM←BITOR(((* (( (ptr) m←v30140)+2) ) - sMax←v30068), ((* (( (ptr) m←v30140)+3) ) - fMax←v30096));
{
word idx178;
check←v30280 = (
idx178 = (word) XRM←BITOR(var←c76156, var←c76188),
SGNCK(idx178)
);
};
};
SOURCE(38428, 76)
bitDst←v30308 = (((sDst←v30196 * bitsPerLine←v30168) + (word) XRM←BITLSHIFT(fDst←v30224, lgBPS←v30252)) + (* (( (ptr) m←v30140)+9)
));
SOURCE(38506, 72)
fBitCount←v30336 = (word) XRM←BITLSHIFT((fMax←v30096 - fMin←v30040), lgBPS←v30252);
SOURCE(38580, 39)
mod←v30364 = (bitDst←v30308 & 037);
SOURCE(38621, 57)
wordAddress←v30392 = ((* (( (ptr) m←v30140)+8) ) + IOP2( / , (int)(bitDst←v30308 - mod←v30364), (int)8));
SOURCE(38680, 47)
sSize←v30420 = (sMax←v30068 - sMin←v30012);
SOURCE(38729, 333)
if (((* (( (ptr) formal←c81948)+6) ) == 0)) {
if ( ( ( (fBitCount←v30336 == bitsPerLine←v30168) ? (mod←v30364 == 0) : 0 ) ? ((fBitCount←v30336 & 037) == 0) : 0 ) ) {
SOURCE(38843, 88)
(void) Basics←FillWords(wordAddress←v30392, (((word) fBitCount←v30336 >> 5) * sSize←v30420), (* (( (ptr) formal←c81948)+13)
));
SOURCE(38933, 6)
return;
}
else {
if ((sSize←v30420 == 1)) {
SOURCE(38960, 94)
(void) Basics←FillBits(wordAddress←v30392, mod←v30364, fBitCount←v30336, (* (( (ptr) formal←c81948)+13) ));
SOURCE(39056, 6)
return;
};
};
};
SOURCE(39076, 149)
{
W2 var←c76220;
var←c76220.f0 = wordAddress←v30392;
var←c76220.f1 = mod←v30364;
{
word pd179;
pd179 = (* (( (ptr) formal←c81948)+14) );
(void) ( *( (fPt) ((* (ptr) pd179 ))))(var←c76220, (word) (( (bPt) formal←c81948)+52), bitsPerLine←v30168, 0, 1, sSize←v30420
, fBitCount←v30336, pd179);
};
};
};
};
}
static void SlowFill←P10164(box←v55580, formal←c81980)
W4 box←v55580;
word formal←c81980;
{
formal←c81980 = (formal←c81980 - 28);
/* SlowFill: */
SOURCE(39288, 22)
SOURCE(39312, 38)
(void) BufferFill←P3780((* (( (ptr) formal←c81980)+4) ), box←v55580, (* (( (ptr) formal←c81980)+5) ), (* (( (ptr) formal←c81980)+6)
));
}
static void RegionFill←P3960(formal←c01373, edgeGenerator←v15736, value←v15764, function←v15792)
word formal←c01373;
word edgeGenerator←v15736;
word value←v15764;
word function←v15792;
{
W18 var←c82012;
/* declaration of dst←v15708 skipped */
register ptr gf←c82044 = (ptr) &globalframe;
/* declaration of var←c76252 skipped */
word false←v30560;
/* declaration of edges←v30616 skipped */
word bitsPerSample←v30644;
word zero←v30672;
/* declaration of lgBitsPerSample←v30700 skipped */
/* declaration of op←v30728 skipped */
word bitMask←v30784;
/* declaration of replicatedPixel←v30812 skipped */
(* (( (ptr) &var←c82012)+4)/* dst←v15708 */ ) = formal←c01373;
/* RegionFill: */
SOURCE(39377, 3064)
{
word tmpAddr180;
tmpAddr180 = (word) (( (ptr) &var←c82012)+5)/* var←c76252 */ ;
(* (ptr) tmpAddr180 ) = ( ((word) (fPt) edgeAction←P10224) );
(* (( (ptr) tmpAddr180) + 1) ) = 1;
};
SOURCE(39505, 41)
{
word idx181;
false←v30560 = (
idx181 = (* (( (ptr) (* (( (ptr) &var←c82012)+4)/* dst←v15708 */ ))+4) ),
BCK(idx181, 1)
);
};
SOURCE(39648, 79)
{
W4 var←c76316;
var←c76316.f0 = 0;
var←c76316.f1 = 0;
var←c76316.f2 = 0;
var←c76316.f3 = 0;
XR←FillLongWords(&(* (W8Pt) ((( (ptr) &var←c82012)+7)/* edges←v30616 */ )), &var←c76316, 4, 2);
};
SOURCE(39729, 38)
bitsPerSample←v30644 = (* (( (ptr) (* (( (ptr) &var←c82012)+4)/* dst←v15708 */ ))+5) );
SOURCE(39769, 36)
{
word idx182;
zero←v30672 = (
idx182 = (word) (32 % bitsPerSample←v30644),
BCK(idx182, 1)
);
};
SOURCE(39848, 43)
{
word idx183;
(* (( (ptr) &var←c82012)+15)/* lgBitsPerSample←v30700 */ ) = (
idx183 = (word) Lg←P240(bitsPerSample←v30644),
BCK(idx183, 6)
);
};
SOURCE(39933, 17)
(* (( (ptr) &var←c82012)+16)/* op←v30728 */ ) = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c82044)+226)/* var←c70076 */ ))+7)
))+(((unsigned)function←v15792 << 29) >> 30)))+(function←v15792 & 1)) );
SOURCE(42287, 42)
{
word var←c76348;
{
word i←v60936;
i←v60936 = (32 - bitsPerSample←v30644);
SOURCE(18510, 39)
var←c76348 = (i←v60936 & 037);
};
bitMask←v30784 = (word) XRM←BITRSHIFT( (word) -1, var←c76348);
};
SOURCE(42331, 83)
(* (( (ptr) &var←c82012)+17)/* replicatedPixel←v30812 */ ) = ((word) XRM←BITAND(value←v15764, bitMask←v30784) * (* ((( (ptr) gf←c82044)+213)
/* var←c66460 */ +(* (( (ptr) &var←c82012)+15)/* lgBitsPerSample←v30700 */ )) ));
SOURCE(42416, 25)
(void) ( *( (fPt) ((* (ptr) edgeGenerator←v15736 ))))((word) ((( (bPt) &var←c82012)+20)/* var←c76252 */ ), edgeGenerator←v15736)
;
}
static void edgeAction←P10224(which←v31340, sMin←v31368, sCount←v31396, f0←v31424, df←v31452, formal←c82076)
word which←v31340;
word sMin←v31368;
word sCount←v31396;
word f0←v31424;
word df←v31452;
word formal←c82076;
{
word lgbps←v31500;
W8 e←v31556;
formal←c82076 = (formal←c82076 - 20);
/* edgeAction: */
SOURCE(40091, 2191)
SOURCE(40197, 31)
lgbps←v31500 = (* (( (ptr) formal←c82076)+15) );
SOURCE(40354, 190)
if ((which←v31340 == 0)) {
e←v31556.f0 = sMin←v31368;
e←v31556.f1 = (sMin←v31368 + sCount←v31396);
e←v31556.f2 = f0←v31424;
e←v31556.f3 = df←v31452;
}
else {
(* (W4Pt) &e←v31556 ) = (* (W4Pt) (( (ptr) formal←c82076)+7) );
};
if ((which←v31340 == 1)) {
e←v31556.f4 = sMin←v31368;
e←v31556.f5 = (sMin←v31368 + sCount←v31396);
e←v31556.f6 = f0←v31424;
e←v31556.f7 = df←v31452;
}
else {
(* (W4Pt) (( (ptr) &e←v31556)+4) ) = (* (W4Pt) (( (ptr) formal←c82076)+11) );
};
SOURCE(40546, 1722)
if ( ( ( ( (int)e←v31556.f0 < (int)e←v31556.f1) ? ( (int)e←v31556.f4 < (int)e←v31556.f5) : 0 ) ? ( (int)e←v31556.f0 < (int)(* (
( (ptr) (* (( (ptr) formal←c82076)+4) ))+2) )) : 0 ) ) {
SOURCE(40638, 1632)
{
word s←v31760;
word zero←v31788;
W4 box←v31816;
word sMax←v31844;
W4 currentBox←v31872;
word bitsPerLine←v31900;
W2 line←v31928;
SOURCE(40640, 22)
s←v31760 = e←v31556.f0;
SOURCE(40664, 28)
{
word idx184;
zero←v31788 = (
idx184 = (word) (s←v31760 - e←v31556.f4),
BCK(idx184, 1)
);
};
SOURCE(40694, 18)
box←v31816 = (* (W4Pt) (* (( (ptr) formal←c82076)+4) ) );
SOURCE(40714, 52)
{
word x185;
word x186;
word x187;
word x188;
sMax←v31844 = (x185 = e←v31556.f1,
x186 = e←v31556.f5,
x187 = MIN((int)(word), x185, x186),
x188 = box←v31816.f2,
MIN((int)(word), x187, x188));
};
SOURCE(40768, 23)
currentBox←v31872.f0 = 0;
currentBox←v31872.f1 = 0;
currentBox←v31872.f2 = 0;
currentBox←v31872.f3 = 0;
SOURCE(40793, 34)
{
word idx189;
bitsPerLine←v31900 = (
idx189 = (* (( (ptr) (* (( (ptr) formal←c82076)+4) ))+7) ),
SGNCK(idx189)
);
};
SOURCE(40829, 73)
{
W2 addr←v56860;
word offset←v56888;
addr←v56860 = (* (W2Pt) (( (ptr) (* (( (ptr) formal←c82076)+4) ))+8) );
{
word idx190;
offset←v56888 = ((
idx190 = (word) (s←v31760 - box←v31816.f0),
SGNCK(idx190)
) * bitsPerLine←v31900);
};
{
word bitOffset←v56920;
word mod←v56948;
bitOffset←v56920 = (offset←v56888 + addr←v56860.f1);
mod←v56948 = (bitOffset←v56920 & 037);
SOURCE(2833, 63)
line←v31928.f0 = (addr←v56860.f0 + IOP2( / , (int)(bitOffset←v56920 - mod←v56948), (int)8));
line←v31928.f1 = mod←v56948;
};
};
SOURCE(40904, 1325)
if ( ( ( (e←v31556.f3 == 0) ? (e←v31556.f7 == 0) : 0 ) ? ( (int)s←v31760 >= (int)box←v31816.f0) : 0 ) ) {
SOURCE(40991, 495)
{
word f0←v31992;
word f1←v32020;
SOURCE(40993, 41)
{
word a←v64012;
a←v64012 = e←v31556.f2;
f0←v31992 = (word)( (int)a←v64012 >> 16);
};
SOURCE(41036, 41)
{
word a←v63964;
a←v63964 = e←v31556.f6;
f1←v32020 = (word)( (int)a←v63964 >> 16);
};
SOURCE(41079, 49)
if (( (int)f0←v31992 > (int)f1←v32020)) {
SOURCE(41095, 33)
{
word t←v32064;
SOURCE(41096, 15)
t←v32064 = f0←v31992;
SOURCE(41113, 7)
f0←v31992 = f1←v32020;
SOURCE(41122, 6)
f1←v32020 = t←v32064;
};
};
SOURCE(41131, 37)
if (( (int)f0←v31992 < (int)box←v31816.f1)) {
SOURCE(41154, 14)
f0←v31992 = box←v31816.f1;
};
SOURCE(41170, 37)
if (( (int)f1←v32020 > (int)box←v31816.f3)) {
SOURCE(41193, 14)
f1←v32020 = box←v31816.f3;
};
SOURCE(41209, 262)
if (( (int)f0←v31992 < (int)f1←v32020)) {
SOURCE(41225, 248)
{
word offset←v32108;
SOURCE(41227, 44)
{
word var←c76732;
word f←v61224;
f←v61224 = (f0←v31992 - box←v31816.f1);
SOURCE(40295, 56)
var←c76732 = (word) XRM←BITLSHIFT(f←v61224, lgbps←v31500);
offset←v32108 = (line←v31928.f1 + var←c76732);
};
SOURCE(41273, 198)
{
word var←c76796;
{
word var←c76828;
word f←v61176;
f←v61176 = (f1←v32020 - f0←v31992);
SOURCE(40295, 56)
var←c76828 = (word) XRM←BITLSHIFT(f←v61176, lgbps←v31500);
var←c76796 = var←c76828;
};
{
W2 var←c76892;
{
/*1*/ word idx191;
/*1*/ var←c76892.f0 = (line←v31928.f0 + ((word) ((word) (((word) (
/*1*/ idx191 = (word) ((word) offset←v32108 >> 5),
/*1*/ BCK(idx191, 67108863)
/*1*/ ) << 5) + 31) >> 5) << 2));
/*1*/ };
var←c76892.f1 = (offset←v32108 & 037);
{
/*1*/ word pd192;
/*1*/ pd192 = (* (( (ptr) formal←c82076)+16) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd192 ))))(var←c76892, (word) (( (bPt) formal←c82076)+68), bitsPerLine←v31900, 0, 1, (sMax←v31844 - s←v31760)
/*1*/ , var←c76796, pd192);
/*1*/ };
};
};
};
};
SOURCE(41476, 8)
s←v31760 = sMax←v31844;
};
}
else {
SOURCE(41495, 734)
lab←L100236: ;
if (( (int)s←v31760 < (int)sMax←v31844)) {
}
else {
goto lab←L100234;
};
{
word f0←v32152;
word f1←v32180;
SOURCE(41513, 41)
{
word a←v63916;
a←v63916 = e←v31556.f2;
f0←v32152 = (word)( (int)a←v63916 >> 16);
};
SOURCE(41556, 41)
{
word a←v63868;
a←v63868 = e←v31556.f6;
f1←v32180 = (word)( (int)a←v63868 >> 16);
};
SOURCE(41599, 49)
if (( (int)f0←v32152 > (int)f1←v32180)) {
SOURCE(41615, 33)
{
word t←v32224;
SOURCE(41616, 15)
t←v32224 = f0←v32152;
SOURCE(41633, 7)
f0←v32152 = f1←v32180;
SOURCE(41642, 6)
f1←v32180 = t←v32224;
};
};
SOURCE(41651, 37)
if (( (int)f0←v32152 < (int)box←v31816.f1)) {
SOURCE(41674, 14)
f0←v32152 = box←v31816.f1;
};
SOURCE(41690, 37)
if (( (int)f1←v32180 > (int)box←v31816.f3)) {
SOURCE(41713, 14)
f1←v32180 = box←v31816.f3;
};
SOURCE(41729, 266)
if ( ( ( (int)s←v31760 >= (int)box←v31816.f0) ? ( (int)f0←v32152 < (int)f1←v32180) : 0 ) ) {
SOURCE(41764, 233)
{
word offset←v32268;
SOURCE(41766, 44)
{
word var←c76988;
word f←v61128;
f←v61128 = (f0←v32152 - box←v31816.f1);
SOURCE(40295, 56)
var←c76988 = (word) XRM←BITLSHIFT(f←v61128, lgbps←v31500);
offset←v32268 = (line←v31928.f1 + var←c76988);
};
SOURCE(41812, 183)
{
word var←c77052;
{
word var←c77084;
word f←v61080;
f←v61080 = (f1←v32180 - f0←v32152);
SOURCE(40295, 56)
var←c77084 = (word) XRM←BITLSHIFT(f←v61080, lgbps←v31500);
var←c77052 = var←c77084;
};
{
W2 var←c77148;
{
/*1*/ word idx193;
/*1*/ var←c77148.f0 = (line←v31928.f0 + ((word) ((word) (((word) (
/*1*/ idx193 = (word) ((word) offset←v32268 >> 5),
/*1*/ BCK(idx193, 67108863)
/*1*/ ) << 5) + 31) >> 5) << 2));
/*1*/ };
var←c77148.f1 = (offset←v32268 & 037);
{
/*1*/ word pd194;
/*1*/ pd194 = (* (( (ptr) formal←c82076)+16) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd194 ))))(var←c77148, (word) (( (bPt) formal←c82076)+68), bitsPerLine←v31900, 0, 1, 1
/*1*/ , var←c77052, pd194);
/*1*/ };
};
};
};
};
SOURCE(42000, 45)
{
word a←v63776;
word b←v63804;
a←v63776 = e←v31556.f2;
b←v63804 = e←v31556.f3;
{
word i←v45352;
i←v45352 = (a←v63776 + b←v63804);
e←v31556.f2 = i←v45352;
};
};
SOURCE(42047, 45)
{
word a←v63656;
word b←v63684;
a←v63656 = e←v31556.f6;
b←v63684 = e←v31556.f7;
{
word i←v63732;
i←v63732 = (a←v63656 + b←v63684);
e←v31556.f6 = i←v63732;
};
};
SOURCE(42094, 123)
{
word offset←v32312;
SOURCE(42095, 39)
offset←v32312 = (line←v31928.f1 + bitsPerLine←v31900);
SOURCE(42136, 52)
{
word idx195;
line←v31928.f0 = (line←v31928.f0 + ((word) ((word) (((word) (
idx195 = (word) ((word) offset←v32312 >> 5),
BCK(idx195, 67108863)
) << 5) + 31) >> 5) << 2));
};
SOURCE(42190, 25)
line←v31928.f1 = (offset←v32312 & 037);
};
SOURCE(42220, 9)
s←v31760 = (s←v31760 + 1);
};
goto lab←L100236;
lab←L100234: ;
};
SOURCE(42243, 25)
e←v31556.f0 = s←v31760;
e←v31556.f4 = s←v31760;
};
};
SOURCE(42273, 9)
(* (W8Pt) (( (ptr) formal←c82076)+7) ) = e←v31556;
}
static word TileFromStipple←P4020(stipple←v15912, bitsPerSample←v15940, value0←v15968, value1←v15996, scratch←v16024)
word stipple←v15912;
word bitsPerSample←v15940;
word value0←v15968;
word value1←v15996;
word scratch←v16024;
{
register ptr gf←c82108 = (ptr) &globalframe;
word var←c16068;
word easy←v32356;
W2 size←v32384;
word temp←v32412;
word tile←v32440;
W4 var←c77468;
/* TileFromStipple: */
SOURCE(42479, 825)
SOURCE(42630, 44)
easy←v32356 = (unsigned) ((32 % ((word) bitsPerSample←v15940 << 2)) == 0);
SOURCE(42676, 91)
if ((0 != easy←v32356)) {
size←v32384.f0 = 4;
size←v32384.f1 = (32 / bitsPerSample←v15940);
}
else {
size←v32384.f0 = 8;
{
word idx196;
size←v32384.f1 = (
idx196 = (word) ((* (( (ptr) gf←c82108)+47)/* tileFromStippleRepl←v5464 */ ) << 2),
SGNCK(idx196)
);
};
};
SOURCE(42769, 67)
temp←v32412 = (word) ObtainScratchMap←P1920((* (W4Pt) (( (ptr) gf←c82108)+219)/* var←c66524 */ ), bitsPerSample←v15940, 0)
;
SOURCE(42838, 25)
tile←v32440 = scratch←v16024;
SOURCE(42865, 168)
{
word tc198;
if ((tile←v32440 == 0)) { goto then0197;};
if (((* (( (ptr) tile←v32440)+5) ) != bitsPerSample←v15940)) {
tc198 = (word) 1;
}
else {
var←c77468.f0 = 0;
var←c77468.f1 = 0;
(* (W2Pt) (( (ptr) &var←c77468)+2) ) = size←v32384;
tc198 = (word) ! XR←EqualWords(tile←v32440, &var←c77468, 4);
};
if (tc198) {
then0197: ;
SOURCE(42961, 72)
{
W4 var←c77500;
var←c77500.f0 = 0;
var←c77500.f1 = 0;
(* (W2Pt) (( (ptr) &var←c77500)+2) ) = size←v32384;
tile←v32440 = (word) NewSampleMap←P1620(var←c77500, bitsPerSample←v15940, 0);
};
};
};
SOURCE(43036, 11)
(void) Clear←P3360(tile←v32440);
SOURCE(43049, 162)
{
register word s←v32484 = 3;
lab←L100248: ;
SOURCE(43084, 127)
{
register word f←v32528 = 3;
lab←L100252: ;
SOURCE(43119, 71)
{
W2 var←c77532;
var←c77532.f0 = s←v32484;
var←c77532.f1 = f←v32528;
(void) Put←P3180(temp←v32412, var←c77532, ( ((stipple←v15912 & 1) == 0) ? value0←v15968 : value1←v15996 ) , 0);
};
SOURCE(43192, 19)
stipple←v15912 = ((word) stipple←v15912 >> 1);
if ((0 >= f←v32528)) {
goto lab←L100249;
};
f←v32528 = (f←v32528 - 1);
goto lab←L100252;
lab←L100249: ;
};
if ((0 >= s←v32484)) {
goto lab←L100245;
};
s←v32484 = (s←v32484 - 1);
goto lab←L100248;
lab←L100245: ;
};
SOURCE(43231, 34)
(void) GeneralTile←P4260(tile←v32440, (* (W4Pt) (( (ptr) gf←c82108)+209)/* var←c66396 */ ), temp←v32412, 0, 0);
SOURCE(43267, 23)
(void) ReleaseScratchMap←P1980(temp←v32412);
SOURCE(43292, 12)
return(tile←v32440);
}
static void DivMod←P4080(formal←c0988, n←v16200, d←v16228)
word formal←c0988;
word n←v16200;
word d←v16228;
{
W2 qr←v16272;
/* DivMod: */
SOURCE(43366, 111)
SOURCE(43417, 24)
qr←v16272.f1 = (word) Mod←P4140(n←v16200, d←v16228);
SOURCE(43443, 34)
qr←v16272.f0 = IOP2( / , (int)(n←v16200 - qr←v16272.f1), (int)d←v16228);
/* removed tail goto */
(* (W2Pt) formal←c0988 ) = qr←v16272;
return;
}
static word Mod←P4140(n←v16332, d←v16360)
word n←v16332;
word d←v16360;
{
word var←c16404;
/* Mod: */
SOURCE(43483, 227)
SOURCE(43528, 182)
if ((d←v16360 != 1)) {
SOURCE(43542, 148)
if (( (int)n←v16332 >= (int)0)) {
SOURCE(43557, 28)
return((SGNCK(n←v16332) % d←v16360));
}
else {
SOURCE(43585, 105)
{
word remainder←v32572;
SOURCE(43587, 24)
remainder←v32572 = IOP2( % , (int)n←v16332, (int)d←v16360);
SOURCE(43613, 56)
lab←L100256: ;
if (( (int)remainder←v32572 < (int)0)) {
}
else {
goto lab←L100254;
};
SOURCE(43636, 33)
remainder←v32572 = (remainder←v32572 + d←v16360);
goto lab←L100256;
lab←L100254: ;
SOURCE(43671, 19)
return(SGNCK(remainder←v32572));
};
};
}
else {
SOURCE(43700, 10)
return(0);
};
}
static void GeneralTile←P4260(formal←c01374, formal←c01375, tile←v16652, phase←v16680, function←v16708)
word formal←c01374;
W4 formal←c01375;
word tile←v16652;
word phase←v16680;
word function←v16708;
{
W11 var←c82140;
/* declaration of map←v16596 skipped */
/* declaration of box←v16624 skipped */
/* declaration of var←c77564 skipped */
(* (( (ptr) &var←c82140)+4)/* map←v16596 */ ) = formal←c01374;
(* (W4Pt) (( (ptr) &var←c82140)+5)/* box←v16624 */ ) = formal←c01375;
/* GeneralTile: */
SOURCE(43800, 242)
{
word tmpAddr199;
tmpAddr199 = (word) (( (ptr) &var←c82140)+9)/* var←c77564 */ ;
(* (ptr) tmpAddr199 ) = ( ((word) (fPt) boxes←P10872) );
(* (( (ptr) tmpAddr199) + 1) ) = 1;
};
SOURCE(43991, 51)
(void) GeneralTileBoxes←P4380((* (( (ptr) &var←c82140)+4)/* map←v16596 */ ), (word) (( (bPt) &var←c82140)+36)/* var←c77564 */ , tile←v16652, phase←v16680, function←v16708)
;
}
static void boxes←P10872(boxAction←v55664, formal←c82204)
word boxAction←v55664;
word formal←c82204;
{
register ptr gf←c82172 = (ptr) &globalframe;
formal←c82204 = (formal←c82204 - 36);
/* boxes: */
SOURCE(43926, 62)
SOURCE(43950, 38)
{
W4 var←c77596;
{
word pd200;
pd200 = (* (( (ptr) (* (( (ptr) gf←c82172)+225)/* var←c67164 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd200 ))))((word) &var←c77596, (* (W4Pt) (* (( (ptr) formal←c82204)+4) ) ), (* (W4Pt) (( (ptr) formal←c82204)+5)
), pd200);
};
(void) ( *( (fPt) ((* (ptr) boxAction←v55664 ))))(var←c77596, boxAction←v55664);
};
}
static void GetTileSamples←P4320(tile←v16768, phase←v16796, initIndex←v16824, buffer←v16852)
word tile←v16768;
word phase←v16796;
W2 initIndex←v16824;
word buffer←v16852;
{
word s0←v32660;
word f0←v32688;
word sOffset←v32716;
W2 tileSize←v32744;
W2 qr←v32772;
word fOffset←v32800;
W2 srcIndexRel←v32828;
W2 srcIndex←v32856;
word count1←v32884;
word count2←v32912;
word count3←v32940;
/* GetTileSamples: */
SOURCE(44048, 959)
SOURCE(44151, 24)
s0←v32660 = (* (ptr) tile←v16768 );
SOURCE(44177, 24)
f0←v32688 = (* (( (ptr) tile←v16768)+1) );
SOURCE(44203, 29)
sOffset←v32716 = (initIndex←v16824.f0 - s0←v32660);
SOURCE(44234, 39)
{
W4 box←v62204;
box←v62204 = (* (W4Pt) tile←v16768 );
{
word x201;
tileSize←v32744.f0 = (x201 = (box←v62204.f2 - box←v62204.f0),
MAX((int)(word), x201, 0));
};
{
word x202;
tileSize←v32744.f1 = (x202 = (box←v62204.f3 - box←v62204.f1),
MAX((int)(word), x202, 0));
};
};
SOURCE(44275, 36)
{
word idx203;
(void) DivMod←P4080((word) &qr←v32772, sOffset←v32716, (
idx203 = (word) tileSize←v32744.f0,
SGNCK(idx203)
));
};
SOURCE(44313, 56)
fOffset←v32800 = (initIndex←v16824.f1 - (f0←v32688 + IOP2( * , (int)qr←v32772.f0, (int)phase←v16796)));
SOURCE(44371, 65)
srcIndexRel←v32828.f0 = qr←v32772.f1;
{
word idx204;
srcIndexRel←v32828.f1 = (word) Mod←P4140(fOffset←v32800, (
idx204 = (word) tileSize←v32744.f1,
SGNCK(idx204)
));
};
SOURCE(44438, 55)
{
W2 v2←v63608;
v2←v63608 = (* (W2Pt) tile←v16768 );
srcIndex←v32856.f0 = (srcIndexRel←v32828.f0 + v2←v63608.f0);
srcIndex←v32856.f1 = (srcIndexRel←v32828.f1 + v2←v63608.f1);
};
SOURCE(44495, 58)
{
word x205;
word x206;
count1←v32884 = (x205 = (* (ptr) buffer←v16852 ),
x206 = (tileSize←v32744.f1 - srcIndexRel←v32828.f1),
MIN((int)(word), x205, x206));
};
SOURCE(44555, 54)
{
word x207;
word x208;
count2←v32912 = (x207 = ((* (ptr) buffer←v16852 ) - count1←v32884),
x208 = srcIndexRel←v32828.f1,
MIN((int)(word), x207, x208));
};
SOURCE(44611, 41)
count3←v32940 = (((* (ptr) buffer←v16852 ) - count1←v32884) - count2←v32912);
SOURCE(44654, 98)
{
W2 var←c77788;
var←c77788.f0 = 0;
var←c77788.f1 = 1;
(void) GetSamples←P3240(tile←v16768, srcIndex←v32856, var←c77788, buffer←v16852, 0, count1←v32884);
};
SOURCE(44754, 142)
if ((count2←v32912 != 0)) {
SOURCE(44773, 123)
{
W2 var←c77820;
W2 var←c77852;
var←c77820.f0 = srcIndex←v32856.f0;
var←c77820.f1 = (* (( (ptr) tile←v16768)+1) );
var←c77852.f0 = 0;
var←c77852.f1 = 1;
(void) GetSamples←P3240(tile←v16768, var←c77820, var←c77852, buffer←v16852, count1←v32884, count2←v32912);
};
};
SOURCE(44898, 109)
if ((count3←v32940 != 0)) {
SOURCE(44917, 90)
(void) CopySamples←P1200(buffer←v16852, buffer←v16852, SGNCK((count1←v32884 + count2←v32912)), 0, count3←v32940);
};
}
static void GeneralTileBoxes←P4380(formal←c01376, boxes←v16940, formal←c01377, formal←c01378, formal←c01379)
word formal←c01376;
word boxes←v16940;
word formal←c01377;
word formal←c01378;
word formal←c01379;
{
W10 var←c82236;
/* declaration of map←v16912 skipped */
/* declaration of tile←v16968 skipped */
/* declaration of phase←v16996 skipped */
/* declaration of function←v17024 skipped */
/* declaration of var←c77884 skipped */
word tileSizeF←v33012;
(* (( (ptr) &var←c82236)+4)/* map←v16912 */ ) = formal←c01376;
(* (( (ptr) &var←c82236)+5)/* tile←v16968 */ ) = formal←c01377;
(* (( (ptr) &var←c82236)+6)/* phase←v16996 */ ) = formal←c01378;
(* (( (ptr) &var←c82236)+7)/* function←v17024 */ ) = formal←c01379;
/* GeneralTileBoxes: */
SOURCE(45013, 1221)
{
word tmpAddr209;
tmpAddr209 = (word) (( (ptr) &var←c82236)+8)/* var←c77884 */ ;
(* (ptr) tmpAddr209 ) = ( ((word) (fPt) GeneralTile←P10932) );
(* (( (ptr) tmpAddr209) + 1) ) = 1;
};
SOURCE(46119, 41)
{
word var←c77916;
W4 box←v62108;
box←v62108 = (* (W4Pt) (* (( (ptr) &var←c82236)+5)/* tile←v16968 */ ) );
if (( (int)box←v62108.f1 < (int)box←v62108.f3)) {
var←c77916 = (box←v62108.f3 - box←v62108.f1);
}
else {
var←c77916 = 0;
};
tileSizeF←v33012 = SGNCK(var←c77916);
};
SOURCE(46162, 52)
if (((* (( (ptr) &var←c82236)+6)/* phase←v16996 */ ) >= tileSizeF←v33012)) {
SOURCE(46187, 27)
(* (( (ptr) &var←c82236)+6)/* phase←v16996 */ ) = ((* (( (ptr) &var←c82236)+6)/* phase←v16996 */ ) % tileSizeF←v33012);
};
SOURCE(46216, 18)
(void) ( *( (fPt) ((* (ptr) boxes←v16940 ))))((word) ((( (bPt) &var←c82236)+32)/* var←c77884 */ ), boxes←v16940);
}
static void GeneralTile←P10932(box←v55724, formal←c82268)
W4 box←v55724;
word formal←c82268;
{
word s0←v33056;
word f0←v33084;
W4 actualBox←v33112;
word sOffset←v33140;
W2 tileSize←v33168;
W2 qr←v33196;
word fOffset←v33224;
W2 dstRow←v33252;
W2 srcRow←v33280;
formal←c82268 = (formal←c82268 - 32);
/* GeneralTile: */
SOURCE(45146, 959)
SOURCE(45173, 24)
s0←v33056 = (* (ptr) (* (( (ptr) formal←c82268)+5) ) );
SOURCE(45199, 24)
f0←v33084 = (* (( (ptr) (* (( (ptr) formal←c82268)+5) ))+1) );
SOURCE(45225, 49)
{
W4 box1←v62348;
box1←v62348 = (* (W4Pt) (* (( (ptr) formal←c82268)+4) ) );
{
W2 v1←v62396;
W2 v2←v62424;
v1←v62396 = (* (W2Pt) &box←v55724 );
v2←v62424 = (* (W2Pt) &box1←v62348 );
if (( (int)v2←v62424.f0 >= (int)v1←v62396.f0)) {
actualBox←v33112.f0 = v2←v62424.f0;
}
else {
actualBox←v33112.f0 = v1←v62396.f0;
};
if (( (int)v2←v62424.f1 >= (int)v1←v62396.f1)) {
actualBox←v33112.f1 = v2←v62424.f1;
}
else {
actualBox←v33112.f1 = v1←v62396.f1;
};
};
{
W2 v1←v62468;
W2 v2←v62496;
v1←v62468 = (* (W2Pt) (( (ptr) &box1←v62348)+2) );
v2←v62496 = (* (W2Pt) (( (ptr) &box←v55724)+2) );
if (( (int)v1←v62468.f0 <= (int)v2←v62496.f0)) {
actualBox←v33112.f2 = v1←v62468.f0;
}
else {
actualBox←v33112.f2 = v2←v62496.f0;
};
if (( (int)v1←v62468.f1 <= (int)v2←v62496.f1)) {
actualBox←v33112.f3 = v1←v62468.f1;
}
else {
actualBox←v33112.f3 = v2←v62496.f1;
};
};
};
SOURCE(45276, 33)
sOffset←v33140 = (actualBox←v33112.f0 - s0←v33056);
SOURCE(45311, 39)
{
W4 box←v62156;
box←v62156 = (* (W4Pt) (* (( (ptr) formal←c82268)+5) ) );
{
word x210;
tileSize←v33168.f0 = (x210 = (box←v62156.f2 - box←v62156.f0),
MAX((int)(word), x210, 0));
};
{
word x211;
tileSize←v33168.f1 = (x211 = (box←v62156.f3 - box←v62156.f1),
MAX((int)(word), x211, 0));
};
};
SOURCE(45352, 36)
{
word idx212;
(void) DivMod←P4080((word) &qr←v33196, sOffset←v33140, (
idx212 = (word) tileSize←v33168.f0,
SGNCK(idx212)
));
};
SOURCE(45390, 60)
fOffset←v33224 = (actualBox←v33112.f1 - (f0←v33084 + IOP2( * , (int)qr←v33196.f0, (int)(* (( (ptr) formal←c82268)+6) ))
));
SOURCE(45452, 27)
dstRow←v33252 = (* (W2Pt) &actualBox←v33112 );
SOURCE(45481, 60)
srcRow←v33280.f0 = qr←v33196.f1;
{
word idx213;
srcRow←v33280.f1 = (word) Mod←P4140(fOffset←v33224, (
idx213 = (word) tileSize←v33168.f1,
SGNCK(idx213)
));
};
SOURCE(45543, 562)
lab←L100266: ;
if (( (int)dstRow←v33252.f0 < (int)actualBox←v33112.f2)) {
}
else {
goto lab←L100264;
};
{
word sSize←v33324;
W2 dstCol←v33352;
W2 srcCol←v33380;
SOURCE(45579, 63)
{
word x214;
word x215;
sSize←v33324 = (x214 = (tileSize←v33168.f0 - srcRow←v33280.f0),
x215 = (actualBox←v33112.f2 - dstRow←v33252.f0),
MIN((int)(word), x214, x215));
};
SOURCE(45644, 20)
dstCol←v33352 = dstRow←v33252;
SOURCE(45666, 20)
srcCol←v33380 = srcRow←v33280;
SOURCE(45688, 284)
lab←L100269: ;
if (( (int)dstCol←v33352.f1 < (int)actualBox←v33112.f3)) {
}
else {
goto lab←L100267;
};
{
word fSize←v33424;
SOURCE(45724, 63)
{
word x216;
word x217;
fSize←v33424 = (x216 = (tileSize←v33168.f1 - srcCol←v33380.f1),
x217 = (actualBox←v33112.f3 - dstCol←v33352.f1),
MIN((int)(word), x216, x217));
};
SOURCE(45789, 142)
{
W2 var←c78236;
{
W2 var←c78268;
W2 v1←v63560;
v1←v63560 = (* (W2Pt) (* (( (ptr) formal←c82268)+5) ) );
var←c78268.f0 = (v1←v63560.f0 + srcCol←v33380.f0);
var←c78268.f1 = (v1←v63560.f1 + srcCol←v33380.f1);
var←c78236 = var←c78268;
};
{
W2 var←c78332;
var←c78332.f0 = sSize←v33324;
var←c78332.f1 = fSize←v33424;
(void) BasicTransfer←P3480((* (( (ptr) formal←c82268)+4) ), (* (( (ptr) formal←c82268)+5) ), dstCol←v33352, var←c78236, var←c78332, (* (
( (ptr) formal←c82268)+7) ));
};
};
SOURCE(45933, 25)
dstCol←v33352.f1 = (dstCol←v33352.f1 + fSize←v33424);
SOURCE(45960, 12)
srcCol←v33380.f1 = 0;
};
goto lab←L100269;
lab←L100267: ;
SOURCE(45983, 25)
dstRow←v33252.f0 = (dstRow←v33252.f0 + sSize←v33324);
SOURCE(46010, 12)
srcRow←v33280.f0 = 0;
SOURCE(46024, 81)
if (( (int)srcRow←v33280.f1 < (int)(* (( (ptr) formal←c82268)+6) ))) {
srcRow←v33280.f1 = (srcRow←v33280.f1 + (tileSize←v33168.f1 - (* (( (ptr) formal←c82268)+6) )));
}
else {
srcRow←v33280.f1 = (srcRow←v33280.f1 - (* (( (ptr) formal←c82268)+6) ));
};
};
goto lab←L100266;
lab←L100264: ;
}
static void Tile←P4440(formal←c01380, formal←c01381, tile←v17140, phase←v17168, function←v17196)
word formal←c01380;
W4 formal←c01381;
word tile←v17140;
word phase←v17168;
word function←v17196;
{
W11 var←c82300;
/* declaration of map←v17084 skipped */
/* declaration of box←v17112 skipped */
/* declaration of var←c78364 skipped */
(* (( (ptr) &var←c82300)+4)/* map←v17084 */ ) = formal←c01380;
(* (W4Pt) (( (ptr) &var←c82300)+5)/* box←v17112 */ ) = formal←c01381;
/* Tile: */
SOURCE(46240, 235)
{
word tmpAddr218;
tmpAddr218 = (word) (( (ptr) &var←c82300)+9)/* var←c78364 */ ;
(* (ptr) tmpAddr218 ) = ( ((word) (fPt) boxes←P11088) );
(* (( (ptr) tmpAddr218) + 1) ) = 1;
};
SOURCE(46431, 44)
(void) TileBoxes←P4500((* (( (ptr) &var←c82300)+4)/* map←v17084 */ ), (word) (( (bPt) &var←c82300)+36)/* var←c78364 */ , tile←v17140, phase←v17168, function←v17196)
;
}
static void boxes←P11088(boxAction←v55784, formal←c82364)
word boxAction←v55784;
word formal←c82364;
{
register ptr gf←c82332 = (ptr) &globalframe;
formal←c82364 = (formal←c82364 - 36);
/* boxes: */
SOURCE(46366, 62)
SOURCE(46390, 38)
{
W4 var←c78396;
{
word pd219;
pd219 = (* (( (ptr) (* (( (ptr) gf←c82332)+225)/* var←c67164 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd219 ))))((word) &var←c78396, (* (W4Pt) (( (ptr) formal←c82364)+5) ), (* (W4Pt) (* (( (ptr) formal←c82364)+4)
) ), pd219);
};
(void) ( *( (fPt) ((* (ptr) boxAction←v55784 ))))(var←c78396, boxAction←v55784);
};
}
static void TileBoxes←P4500(map←v17256, boxes←v17284, tile←v17312, phase←v17340, function←v17368)
word map←v17256;
word boxes←v17284;
word tile←v17312;
word phase←v17340;
word function←v17368;
{
W13 var←c82396;
register ptr gf←c82428 = (ptr) &globalframe;
/* declaration of var←c78428 skipped */
word false←v33512;
word bitsPerSample←v33540;
/* declaration of sSizeTile←v33568 skipped */
word fSizeTile←v33596;
word fSizeSelf←v33624;
/* TileBoxes: */
SOURCE(46505, 2801)
{
word tmpAddr220;
tmpAddr220 = (word) (( (ptr) &var←c82396)+4)/* var←c78428 */ ;
(* (ptr) tmpAddr220 ) = ( ((word) (fPt) FastTile←P11292) );
(* (( (ptr) tmpAddr220) + 1) ) = 1;
};
SOURCE(46638, 41)
{
word idx221;
false←v33512 = (
idx221 = (* (( (ptr) map←v17256)+4) ),
BCK(idx221, 1)
);
};
SOURCE(46681, 38)
bitsPerSample←v33540 = (* (( (ptr) map←v17256)+5) );
SOURCE(46721, 46)
{
word idx222;
(* (( (ptr) &var←c82396)+6)/* sSizeTile←v33568 */ ) = (
idx222 = (word) ((* (( (ptr) tile←v17312)+2) ) - (* (ptr) tile←v17312 )),
SGNCK(idx222)
);
};
SOURCE(46769, 46)
{
word idx223;
fSizeTile←v33596 = (
idx223 = (word) ((* (( (ptr) tile←v17312)+3) ) - (* (( (ptr) tile←v17312)+1) )),
SGNCK(idx223)
);
};
SOURCE(46817, 44)
{
word idx224;
fSizeSelf←v33624 = (
idx224 = (word) ((* (( (ptr) map←v17256)+3) ) - (* (( (ptr) map←v17256)+1) )),
SGNCK(idx224)
);
};
SOURCE(46863, 1940)
{
word var←c78460;
var←c78460 = map←v17256;
if ((var←c78460 == 0)) {
goto lab←L100271;
};
if (((* (( (ptr) var←c78460)+6) ) == 0)) {
{
/* declaration of map←v33688 skipped */
(* (( (ptr) &var←c82396)+7)/* map←v33688 */ ) = var←c78460;
SOURCE(46908, 1895)
{
word var←c78492;
var←c78492 = tile←v17312;
if ((var←c78492 == 0)) {
goto lab←L100272;
};
if (((* (( (ptr) var←c78492)+6) ) == 0)) {
{
/* declaration of tile←v33732 skipped */
(* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ) = var←c78492;
SOURCE(46957, 1582)
{
word idx225;
if ( ( ( ( ( ( ( ( (phase←v17340 == 0) ? ((* (( (ptr) (* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ))+5) ) == bitsPerSample←v33540) : 0 ) ? ((* (
( (ptr) (* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ))+7) ) == 32) : 0 ) ? ((* (( (ptr) (* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ))+9)
) == 0) : 0 ) ? ((* (( (ptr) (* (( (ptr) &var←c82396)+7)/* map←v33688 */ ))+9) ) == 0) : 0 ) ? ((fSizeTile←v33596 * bitsPerSample←v33540) == 32) : 0 ) ? ((word) XRM←BITAND(
(* (( (ptr) &var←c82396)+6)/* sSizeTile←v33568 */ ), (
/*1*/ idx225 = (word) ((* (( (ptr) &var←c82396)+6)/* sSizeTile←v33568 */ ) - 1),
/*1*/ SGNCK(idx225)
/*1*/ )) == 0) : 0 ) ? ((word) XRM←BITAND(bitsPerSample←v33540, SGNCK((bitsPerSample←v33540 - 1))) == 0) : 0 ) ) {
SOURCE(47176, 1365)
{
/*1*/ /* declaration of sTileMask←v33776 skipped */
/*1*/ /* declaration of sOffset←v33804 skipped */
/*1*/ /* declaration of lgBitsPerSample←v33832 skipped */
/*1*/ /* declaration of op←v33860 skipped */
SOURCE(47178, 33)
/*1*/ {
/*1*/ word idx226;
/*1*/ (* (( (ptr) &var←c82396)+9)/* sTileMask←v33776 */ ) = (
/*1*/ idx226 = (word) ((* (( (ptr) &var←c82396)+6)/* sSizeTile←v33568 */ ) - 1),
/*1*/ SGNCK(idx226)
/*1*/ );
/*1*/ };
SOURCE(47242, 81)
/*1*/ (* (( (ptr) &var←c82396)+10)/* sOffset←v33804 */ ) = (word) XRM←BITAND(INEG((* (ptr) (* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ) ))
/*1*/ , (* (( (ptr) &var←c82396)+9)/* sTileMask←v33776 */ ));
SOURCE(47325, 43)
/*1*/ {
/*1*/ word idx227;
/*1*/ (* (( (ptr) &var←c82396)+11)/* lgBitsPerSample←v33832 */ ) = (
/*1*/ idx227 = (word) Lg←P240(bitsPerSample←v33540),
/*1*/ BCK(idx227, 6)
/*1*/ );
/*1*/ };
SOURCE(47370, 17)
/*1*/ (* (( (ptr) &var←c82396)+12)/* op←v33860 */ ) = (* (( (ptr) (( (W2Pt) (* (( (ptr) (* (( (ptr) gf←c82428)+226)/* var←c70076 */ ))+7)
/*1*/ ))+(((unsigned)function←v17368 << 29) >> 30)))+(function←v17368 & 1)) );
SOURCE(48516, 15)
/*1*/ (void) ( *( (fPt) ((* (ptr) boxes←v17284 ))))((word) ((( (bPt) &var←c82396)+16)/* var←c78428 */ ), boxes←v17284);
SOURCE(48533, 6)
/*1*/ return;
/*1*/ };
};
};
SOURCE(48544, 259)
{
word tc228;
word x229;
word x230;
if (((* (( (ptr) (* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ))+5) ) == (* (( (ptr) (* (( (ptr) &var←c82396)+7)/* map←v33688 */ ))+5)
))) {
tc228 = (word) ((fSizeTile←v33596 * bitsPerSample←v33540) >= (x229 = (fSizeSelf←v33624 * bitsPerSample←v33540),
/*1*/ x230 = (* (( (ptr) gf←c82428)+48)/* smallWidth←v5744 */ ),
/*1*/ MIN( (unsigned) , x229, x230)));
}
else {
tc228 = (word) 0;
};
if (tc228) {
SOURCE(48709, 86)
(void) GeneralTileBoxes←P4380((* (( (ptr) &var←c82396)+7)/* map←v33688 */ ), boxes←v17284, (* (( (ptr) &var←c82396)+8)/* tile←v33732 */ ), phase←v17340, function←v17368)
;
SOURCE(48797, 6)
return;
};
};
};
}
else {
lab←L100272: ;
};
};
};
}
else {
lab←L100271: ;
};
};
SOURCE(48846, 462)
{
word nf←v34672;
W2 macroTileSize←v34700;
word macroTile←v34728;
SOURCE(48866, 81)
nf←v34672 = (((((((* (( (ptr) gf←c82428)+48)/* smallWidth←v5744 */ ) + fSizeTile←v33596) - 1) / fSizeTile←v33596) + bitsPerSample←v33540) - 1) / bitsPerSample←v33540);
SOURCE(48949, 55)
macroTileSize←v34700.f0 = (* (( (ptr) &var←c82396)+6)/* sSizeTile←v33568 */ );
{
word idx231;
macroTileSize←v34700.f1 = (
idx231 = (word) (nf←v34672 * fSizeTile←v33596),
SGNCK(idx231)
);
};
SOURCE(49006, 119)
{
W2 var←c78556;
{
W2 var←c78588;
W2 v1←v63512;
v1←v63512 = (* (W2Pt) tile←v17312 );
var←c78588.f0 = (v1←v63512.f0 + macroTileSize←v34700.f0);
var←c78588.f1 = (v1←v63512.f1 + macroTileSize←v34700.f1);
var←c78556 = var←c78588;
};
{
W4 var←c78652;
(* (W2Pt) &var←c78652 ) = (* (W2Pt) tile←v17312 );
(* (W2Pt) (( (ptr) &var←c78652)+2) ) = var←c78556;
macroTile←v34728 = (word) ObtainScratchMap←P1920(var←c78652, BCK(bitsPerSample←v33540, 33), 0);
};
};
SOURCE(49127, 53)
(void) GeneralTile←P4260(macroTile←v34728, (* (W4Pt) (( (ptr) gf←c82428)+209)/* var←c66396 */ ), tile←v17312, phase←v17340, 0)
;
SOURCE(49182, 94)
(void) GeneralTileBoxes←P4380(map←v17256, boxes←v17284, macroTile←v34728, phase←v17340, function←v17368);
SOURCE(49278, 28)
(void) ReleaseScratchMap←P1980(macroTile←v34728);
};
}
static void FastTile←P11292(box←v55844, formal←c82460)
W4 box←v55844;
word formal←c82460;
{
word sMin←v34180;
word fMin←v34208;
word sMax←v34236;
word fMax←v34264;
formal←c82460 = (formal←c82460 - 16);
/* FastTile: */
SOURCE(47528, 30)
SOURCE(47560, 25)
sMin←v34180 = box←v55844.f0;
SOURCE(47587, 25)
fMin←v34208 = box←v55844.f1;
SOURCE(47614, 25)
sMax←v34236 = box←v55844.f2;
SOURCE(47641, 25)
fMax←v34264 = box←v55844.f3;
SOURCE(47668, 840)
if ( ( ( (int)sMax←v34236 > (int)sMin←v34180) ? ( (int)fMax←v34264 > (int)fMin←v34208) : 0 ) ) {
SOURCE(47704, 806)
{
word m←v34308;
word bitsPerLine←v34336;
word sDst←v34364;
word fDst←v34392;
word lgBPS←v34420;
word check←v34448;
word bitDst←v34476;
word fBitCount←v34504;
word mod←v34532;
word yOffset←v34560;
SOURCE(47706, 24)
m←v34308 = (* (( (ptr) formal←c82460)+7) );
SOURCE(47732, 37)
bitsPerLine←v34336 = (* (( (ptr) m←v34308)+7) );
SOURCE(47771, 43)
sDst←v34364 = (sMin←v34180 - (* (ptr) m←v34308 ));
SOURCE(47816, 43)
fDst←v34392 = (fMin←v34208 - (* (( (ptr) m←v34308)+1) ));
SOURCE(47861, 31)
lgBPS←v34420 = (* (( (ptr) formal←c82460)+11) );
SOURCE(47894, 121)
{
word var←c78684;
word var←c78716;
var←c78684 = (word) XRM←BITOR(sDst←v34364, fDst←v34392);
var←c78716 = (word) XRM←BITOR(((* (( (ptr) m←v34308)+2) ) - sMax←v34236), ((* (( (ptr) m←v34308)+3) ) - fMax←v34264));
{
word idx232;
check←v34448 = (
idx232 = (word) XRM←BITOR(var←c78684, var←c78716),
SGNCK(idx232)
);
};
};
SOURCE(48037, 76)
bitDst←v34476 = (((sDst←v34364 * bitsPerLine←v34336) + (word) XRM←BITLSHIFT(fDst←v34392, lgBPS←v34420)) + (* (( (ptr) m←v34308)+9)
));
SOURCE(48115, 62)
fBitCount←v34504 = (word) XRM←BITLSHIFT((fMax←v34264 - fMin←v34208), lgBPS←v34420);
SOURCE(48179, 39)
mod←v34532 = (bitDst←v34476 & 037);
SOURCE(48220, 78)
yOffset←v34560 = (word) XRM←BITAND(((* (( (ptr) formal←c82460)+10) ) + sMin←v34180), (* (( (ptr) formal←c82460)+9) ));
SOURCE(48300, 208)
{
W2 var←c78748;
var←c78748.f0 = ((* (( (ptr) m←v34308)+8) ) + IOP2( / , (int)(bitDst←v34476 - mod←v34532), (int)8));
var←c78748.f1 = mod←v34532;
{
word pd233;
pd233 = (* (( (ptr) formal←c82460)+12) );
(void) ( *( (fPt) ((* (ptr) pd233 ))))(var←c78748, (* (( (ptr) (* (( (ptr) formal←c82460)+8) ))+8) ), bitsPerLine←v34336, yOffset←v34560, (* (
( (ptr) formal←c82460)+6) ), (sMax←v34236 - sMin←v34180)
, fBitCount←v34504, pd233);
};
};
};
};
}
static void BoxesFromBitmap←P4560(map←v17428, boxAction←v17456)
word map←v17428;
word boxAction←v17456;
{
/* BoxesFromBitmap: */
SOURCE(49315, 1864)
SOURCE(49387, 1486)
{
word var←c78780;
var←c78780 = map←v17428;
if ((var←c78780 == 0)) {
goto lab←L100274;
};
if (((* (( (ptr) var←c78780)+6) ) == 0)) {
{
word map←v34772;
map←v34772 = var←c78780;
SOURCE(49434, 1439)
if (((* (( (ptr) map←v34772)+5) ) == 1)) {
SOURCE(49472, 1403)
{
word sMin←v34816;
word fMin←v34844;
word fMax←v34872;
W2 lineStart←v34900;
SOURCE(49474, 29)
sMin←v34816 = (* (ptr) map←v34772 );
SOURCE(49505, 29)
fMin←v34844 = (* (( (ptr) map←v34772)+1) );
SOURCE(49536, 29)
fMax←v34872 = (* (( (ptr) map←v34772)+3) );
SOURCE(49567, 32)
lineStart←v34900 = (* (W2Pt) (( (ptr) map←v34772)+8) );
SOURCE(49601, 43)
if (( (int)(* (( (ptr) map←v34772)+1) ) >= (int)(* (( (ptr) map←v34772)+3) ))) {
SOURCE(49638, 6)
return;
};
SOURCE(49646, 1210)
{
register word sRel←v34944 = 0;
register word noName←c78812;
noName←c78812 = ((* (( (ptr) map←v34772)+2) ) - (* (ptr) map←v34772 ));
if ((sRel←v34944 >= noName←c78812)) {
goto lab←L100275;
};
lab←L100278: ;
{
word f←v34988;
word wordPtr←v35016;
word wordsWorth←v35044;
word remainingBitsInWord←v35072;
SOURCE(49699, 26)
f←v34988 = (* (( (ptr) map←v34772)+1) );
SOURCE(49727, 50)
wordPtr←v35016 = lineStart←v34900.f0;
SOURCE(49779, 64)
wordsWorth←v35044 = (word) XRM←BITLSHIFT((* (ptr) wordPtr←v35016 ), lineStart←v34900.f1);
SOURCE(49845, 48)
remainingBitsInWord←v35072 = (32 - lineStart←v34900.f1);
SOURCE(50615, 182)
lab←L100281: ;
if (( (int)f←v34988 < (int)fMax←v34872)) {
}
else {
goto lab←L100279;
};
{
word fStart←v35236;
SOURCE(50650, 10)
SOURCE(50105, 496)
lab←L100284: ;
if (( (int)f←v34988 < (int)fMax←v34872)) {
/*1*/ }
else {
/*1*/ goto lab←L100282;
/*1*/ };
SOURCE(50143, 383)
if ( ( ( (int)remainingBitsInWord←v35072 == (int)32) ? (wordsWorth←v35044 == 0) : 0 ) ) {
SOURCE(50201, 28)
/*1*/ f←v34988 = (f←v34988 + remainingBitsInWord←v35072);
/*1*/ }
else {
SOURCE(50238, 27)
/*1*/ f←v34988 = (f←v34988 + remainingBitsInWord←v35072);
SOURCE(50267, 156)
/*1*/ lab←L100287: ;
/*1*/ if ( ( ( (int)remainingBitsInWord←v35072 > (int)0) ? ((word) XRM←BITAND(wordsWorth←v35044, 2147483648) != 2147483648) : 0 ) ) {
/*1*/ }
/*1*/ else {
/*1*/ goto lab←L100285;
/*1*/ };
SOURCE(50353, 43)
/*1*/ remainingBitsInWord←v35072 = (remainingBitsInWord←v35072 - 1);
SOURCE(50398, 25)
/*1*/ wordsWorth←v35044 = ((word) wordsWorth←v35044 << 1);
/*1*/ goto lab←L100287;
/*1*/ lab←L100285: ;
SOURCE(50434, 27)
/*1*/ f←v34988 = (f←v34988 - remainingBitsInWord←v35072);
SOURCE(50463, 32)
/*1*/ if (( (int)remainingBitsInWord←v35072 > (int)0)) {
SOURCE(50495, 4)
/*1*/ goto lab←L100283;
/*1*/ };
SOURCE(50501, 25)
/*1*/ remainingBitsInWord←v35072 = 32;
/*1*/ };
SOURCE(50531, 30)
wordPtr←v35016 = (wordPtr←v35016 + 4);
SOURCE(50563, 38)
if (( (int)f←v34988 < (int)fMax←v34872)) {
SOURCE(50580, 21)
/*1*/ wordsWorth←v35044 = (* (ptr) wordPtr←v35016 );
/*1*/ };
goto lab←L100284;
lab←L100282: ;
lab←L100283: ;
SOURCE(50662, 10)
fStart←v35236 = f←v34988;
SOURCE(50674, 10)
SOURCE(50105, 496)
lab←L100290: ;
if (( (int)f←v34988 < (int)fMax←v34872)) {
/*1*/ }
else {
/*1*/ goto lab←L100288;
/*1*/ };
SOURCE(50143, 383)
if ( ( ( (int)remainingBitsInWord←v35072 == (int)32) ? (wordsWorth←v35044 == (word) -1) : 0 ) ) {
SOURCE(50201, 28)
/*1*/ f←v34988 = (f←v34988 + remainingBitsInWord←v35072);
/*1*/ }
else {
SOURCE(50238, 27)
/*1*/ f←v34988 = (f←v34988 + remainingBitsInWord←v35072);
SOURCE(50267, 156)
/*1*/ lab←L100293: ;
/*1*/ if ( ( ( (int)remainingBitsInWord←v35072 > (int)0) ? ((word) XRM←BITAND(wordsWorth←v35044, 2147483648) != 0) : 0 ) ) {
/*1*/ }
/*1*/ else {
/*1*/ goto lab←L100291;
/*1*/ };
SOURCE(50353, 43)
/*1*/ remainingBitsInWord←v35072 = (remainingBitsInWord←v35072 - 1);
SOURCE(50398, 25)
/*1*/ wordsWorth←v35044 = ((word) wordsWorth←v35044 << 1);
/*1*/ goto lab←L100293;
/*1*/ lab←L100291: ;
SOURCE(50434, 27)
/*1*/ f←v34988 = (f←v34988 - remainingBitsInWord←v35072);
SOURCE(50463, 32)
/*1*/ if (( (int)remainingBitsInWord←v35072 > (int)0)) {
SOURCE(50495, 4)
/*1*/ goto lab←L100289;
/*1*/ };
SOURCE(50501, 25)
/*1*/ remainingBitsInWord←v35072 = 32;
/*1*/ };
SOURCE(50531, 30)
wordPtr←v35016 = (wordPtr←v35016 + 4);
SOURCE(50563, 38)
if (( (int)f←v34988 < (int)fMax←v34872)) {
SOURCE(50580, 21)
/*1*/ wordsWorth←v35044 = (* (ptr) wordPtr←v35016 );
/*1*/ };
goto lab←L100290;
lab←L100288: ;
lab←L100289: ;
SOURCE(50686, 16)
f←v34988 = (MIN((int)(word), f←v34988, fMax←v34872));
SOURCE(50704, 93)
if (( (int)f←v34988 > (int)fStart←v35236)) {
SOURCE(50723, 74)
/*1*/ {
/*1*/ W4 var←c78844;
/*1*/ var←c78844.f0 = (sMin←v34816 + sRel←v34944);
/*1*/ var←c78844.f1 = fStart←v35236;
/*1*/ var←c78844.f2 = ((sMin←v34816 + sRel←v34944) + 1);
/*1*/ var←c78844.f3 = f←v34988;
/*1*/ (void) ( *( (fPt) ((* (ptr) boxAction←v17456 ))))(var←c78844, boxAction←v17456);
/*1*/ };
/*1*/ };
};
goto lab←L100281;
lab←L100279: ;
SOURCE(50808, 48)
{
W2 var←c78876;
word offset←v56756;
offset←v56756 = (* (( (ptr) map←v34772)+7) );
{
/*1*/ word bitOffset←v56788;
/*1*/ word mod←v56816;
/*1*/ bitOffset←v56788 = (offset←v56756 + lineStart←v34900.f1);
/*1*/ mod←v56816 = (bitOffset←v56788 & 037);
SOURCE(2833, 63)
/*1*/ var←c78876.f0 = (lineStart←v34900.f0 + IOP2( / , (int)(bitOffset←v56788 - mod←v56816), (int)8));
/*1*/ var←c78876.f1 = mod←v56816;
/*1*/ };
lineStart←v34900 = var←c78876;
};
};
sRel←v34944 = (sRel←v34944 + 1);
if ((sRel←v34944 < noName←c78812)) {
goto lab←L100278;
};
lab←L100275: ;
};
SOURCE(50867, 6)
return;
};
};
};
}
else {
lab←L100274: ;
};
};
SOURCE(50916, 263)
{
register word s←v35364;
register word noName←c78940;
{
word idx234;
s←v35364 = (
idx234 = (* (ptr) map←v17428 ),
SGNCK(idx234)
);
};
{
word idx235;
noName←c78940 = (
idx235 = (* (( (ptr) map←v17428)+2) ),
SGNCK(idx235)
);
};
if ((s←v35364 >= noName←c78940)) {
goto lab←L100295;
};
lab←L100298: ;
{
word buffer←v35408;
SOURCE(50964, 119)
{
W4 var←c78972;
var←c78972.f0 = s←v35364;
var←c78972.f1 = (* (( (ptr) map←v17428)+1) );
var←c78972.f2 = SGNCK((s←v35364 + 1));
var←c78972.f3 = (* (( (ptr) map←v17428)+3) );
buffer←v35408 = (word) ObtainScratchMap←P1920(var←c78972, 1, 0);
};
SOURCE(51085, 31)
{
W2 var←c79004;
var←c79004.f0 = 0;
var←c79004.f1 = 0;
(void) Transfer←P3600(buffer←v35408, map←v17428, var←c79004, 0);
};
SOURCE(51118, 34)
(void) BoxesFromBitmap←P4560(buffer←v35408, boxAction←v17456);
SOURCE(51154, 25)
(void) ReleaseScratchMap←P1980(buffer←v35408);
};
s←v35364 = (s←v35364 + 1);
if ((s←v35364 < noName←c78940)) {
goto lab←L100298;
};
lab←L100295: ;
};
SOURCE(51193, 5)
(void) XR←RaiseUnnamedError();
}
static void Halftone←P4620(map←v17516, min←v17544, sampleBuffer←v17572, thresholdBuffer←v17600, function←v17628)
word map←v17516;
W2 min←v17544;
word sampleBuffer←v17572;
word thresholdBuffer←v17600;
word function←v17628;
{
word false←v35452;
W64 bitBuffer←v35564;
word bitBufferPtr←v35592;
word bitBufferMap←v35620;
word count←v35648;
W2 index←v35676;
word residual←v35704;
word s←v35732;
word b←v35760;
/* Halftone: */
SOURCE(51243, 2022)
SOURCE(51369, 41)
{
word idx236;
false←v35452 = (
idx236 = (* (( (ptr) map←v17516)+4) ),
BCK(idx236, 1)
);
};
SOURCE(51568, 39)
bitBufferPtr←v35592 = (word) &bitBuffer←v35564;
SOURCE(51609, 207)
{
W2 var←c79036;
W2 var←c79068;
W2 var←c79100;
W2 var←c79132;
var←c79036.f0 = 1;
var←c79036.f1 = 2048;
var←c79068.f0 = bitBufferPtr←v35592;
var←c79068.f1 = 0;
var←c79100.f0 = 0;
var←c79100.f1 = 0;
var←c79132.f0 = 0;
var←c79132.f1 = 0;
bitBufferMap←v35620 = (word) ObtainUnsafeDescriptor←P2400(var←c79036, 1, 2048, var←c79068, 0, 64
, var←c79100, var←c79132);
};
SOURCE(51818, 61)
{
word x237;
word x238;
count←v35648 = (x237 = (* (ptr) sampleBuffer←v17572 ),
x238 = (* (ptr) thresholdBuffer←v17600 ),
MIN( (unsigned) , x237, x238));
};
SOURCE(51881, 19)
index←v35676 = min←v17544;
SOURCE(51902, 21)
residual←v35704 = count←v35648;
SOURCE(51925, 121)
{
word check←v59528;
check←v59528 = ((* (( (ptr) sampleBuffer←v17572)+1) ) - count←v35648);
SOURCE(4940, 67)
s←v35732 = (sampleBuffer←v17572 + 8);
};
SOURCE(52048, 124)
{
word check←v59484;
check←v59484 = ((* (( (ptr) thresholdBuffer←v17600)+1) ) - count←v35648);
SOURCE(4940, 67)
b←v35760 = (thresholdBuffer←v17600 + 8);
};
SOURCE(52283, 940)
lab←L100303: ;
if ((residual←v35704 != 0)) {
}
else {
goto lab←L100301;
};
{
word chunkSize←v36120;
word bitBufferIndex←v36148 = 0;
word chunkResidual←v36176;
SOURCE(52305, 45)
chunkSize←v36120 = (MIN( (unsigned) , 2048, residual←v35704));
SOURCE(52377, 30)
chunkResidual←v36176 = chunkSize←v36120;
SOURCE(52409, 387)
lab←L100306: ;
if ((chunkResidual←v36176 >= 16)) {
}
else {
goto lab←L100304;
};
SOURCE(52438, 203)
{
word var←c79228;
{
word idx239;
var←c79228 = (
idx239 = (word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) (((word) XRM←BITRSHIFT(
(((* (ptr) s←v35732 ) - (* (ptr) b←v35760 )) - 1), 31) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+1) ) - (* (
( (ptr) b←v35760)+1) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+2) ) - (* (( (ptr) b←v35760)+2) )) - 1), 31)
) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+3) ) - (* (( (ptr) b←v35760)+3) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT(
(((* (( (ptr) s←v35732)+4) ) - (* (( (ptr) b←v35760)+4) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+5)
) - (* (( (ptr) b←v35760)+5) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+6) ) - (* (( (ptr) b←v35760)+6)
)) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+7) ) - (* (( (ptr) b←v35760)+7) )) - 1), 31)) << 1) +
(word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+8) ) - (* (( (ptr) b←v35760)+8) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (
( (ptr) s←v35732)+9) ) - (* (( (ptr) b←v35760)+9) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+10) ) - (* (
( (ptr) b←v35760)+10) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+11) ) - (* (( (ptr) b←v35760)+11)
)) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+12) ) - (* (( (ptr) b←v35760)+12) )) - 1), 31)) << 1) +
(word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+13) ) - (* (( (ptr) b←v35760)+13) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT(
(((* (( (ptr) s←v35732)+14) ) - (* (( (ptr) b←v35760)+14) )) - 1), 31)) << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+15)
) - (* (( (ptr) b←v35760)+15) )) - 1), 31)),
BCK(idx239, 65536)
);
};
(* (( (hPt) &bitBuffer←v35564)+BCK(bitBufferIndex←v36148, 128)) ) = var←c79228;
};
SOURCE(52643, 35)
bitBufferIndex←v36148 = (bitBufferIndex←v36148 + 1);
SOURCE(52680, 34)
chunkResidual←v36176 = SGNCK((chunkResidual←v36176 - 16));
SOURCE(52716, 39)
s←v35732 = (s←v35732 + 64);
SOURCE(52757, 39)
b←v35760 = (b←v35760 + 64);
goto lab←L100306;
lab←L100304: ;
SOURCE(52807, 242)
if ((chunkResidual←v36176 != 0)) {
SOURCE(52833, 218)
{
word w←v36292 = 0;
SOURCE(52852, 29)
if ((chunkSize←v36120 != residual←v35704)) {
SOURCE(52881, 5)
(void) XR←RaiseUnnamedError();
};
SOURCE(52917, 60)
{
register word i←v36336 = 0;
register word noName←c79260;
noName←c79260 = chunkResidual←v36176;
if ((i←v36336 >= noName←c79260)) {
goto lab←L100307;
};
lab←L100310: ;
SOURCE(52953, 24)
w←v36292 = (((word) w←v36292 << 1) + (word) XRM←BITRSHIFT((((* (( (ptr) s←v35732)+BCK(i←v36336, 16)) ) - (* (( (ptr) b←v35760)+BCK(
i←v36336, 16)) )) - 1), 31));
i←v36336 = (i←v36336 + 1);
if ((i←v36336 < noName←c79260)) {
goto lab←L100310;
};
lab←L100307: ;
};
SOURCE(52979, 70)
{
word var←c79292;
{
word var←c79324;
{
word i←v60504;
i←v60504 = (16 - chunkResidual←v36176);
SOURCE(18510, 39)
var←c79324 = (i←v60504 & 037);
};
{
word idx240;
var←c79292 = (
idx240 = (word) XRM←BITLSHIFT(w←v36292, var←c79324),
BCK(idx240, 65536)
);
};
};
(* (( (hPt) &bitBuffer←v35564)+BCK(bitBufferIndex←v36148, 128)) ) = var←c79292;
};
};
};
SOURCE(53054, 105)
{
W2 var←c79388;
W2 var←c79420;
var←c79388.f0 = 0;
var←c79388.f1 = 0;
var←c79420.f0 = 1;
var←c79420.f1 = chunkSize←v36120;
(void) BasicTransfer←P3480(map←v17516, bitBufferMap←v35620, index←v35676, var←c79388, var←c79420, function←v17628);
};
SOURCE(53161, 29)
index←v35676.f1 = (index←v35676.f1 + chunkSize←v36120);
SOURCE(53192, 31)
residual←v35704 = (residual←v35704 - chunkSize←v36120);
};
goto lab←L100303;
lab←L100301: ;
SOURCE(53234, 31)
(void) ReleaseDescriptor←P1860(bitBufferMap←v35620);
}
static word Zeros←P4680(pointer←v17688, count←v17716)
word pointer←v17688;
word count←v17716;
{
word var←c17772;
word p←v36380;
/* Zeros: */
SOURCE(53271, 506)
SOURCE(53346, 59)
p←v36380 = pointer←v17688;
SOURCE(53407, 246)
lab←L100314: ;
if ((count←v17716 >= 8)) {
}
else {
goto lab←L100312;
};
{
word var←c79452;
SOURCE(53427, 171)
{
word var←c79484;
{
word var←c79516;
{
word var←c79548;
{
word var←c79580;
{
word var←c79612;
var←c79612 = (word) XRM←BITOR((* (ptr) p←v36380 ), (* (( (ptr) p←v36380)+1) ));
var←c79580 = (word) XRM←BITOR(var←c79612, (* (( (ptr) p←v36380)+2) ));
};
var←c79548 = (word) XRM←BITOR(var←c79580, (* (( (ptr) p←v36380)+3) ));
};
var←c79516 = (word) XRM←BITOR(var←c79548, (* (( (ptr) p←v36380)+4) ));
};
var←c79484 = (word) XRM←BITOR(var←c79516, (* (( (ptr) p←v36380)+5) ));
};
var←c79452 = (word) XRM←BITOR(var←c79484, (* (( (ptr) p←v36380)+6) ));
};
if (((word) XRM←BITOR(var←c79452, (* (( (ptr) p←v36380)+7) )) != 0)) {
SOURCE(53584, 14)
return(0);
};
SOURCE(53600, 34)
p←v36380 = (p←v36380 + 32);
SOURCE(53636, 17)
count←v17716 = SGNCK((count←v17716 - 8));
};
goto lab←L100314;
lab←L100312: ;
SOURCE(53664, 89)
lab←L100317: ;
if ((count←v17716 > 0)) {
}
else {
goto lab←L100315;
};
SOURCE(53683, 31)
if (((* (ptr) p←v36380 ) != 0)) {
SOURCE(53700, 14)
return(0);
};
SOURCE(53716, 18)
p←v36380 = (p←v36380 + 4);
SOURCE(53736, 17)
count←v17716 = SGNCK((count←v17716 - 1));
goto lab←L100317;
lab←L100315: ;
SOURCE(53764, 13)
return(1);
}
static word Equal←P4740(formal←c01382, formal←c01383)
word formal←c01382;
word formal←c01383;
{
W9 var←c82492;
/* declaration of s1←v17832 skipped */
/* declaration of s2←v17860 skipped */
/* declaration of equal←v17904 skipped */
/* declaration of var←c79644 skipped */
word var←c79676;
W4 box←v63320;
word var←c79708;
W4 box←v63272;
(* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ) = formal←c01382;
(* (( (ptr) &var←c82492)+5)/* s2←v17860 */ ) = formal←c01383;
/* Equal: */
SOURCE(53783, 926)
{
word tmpAddr241;
tmpAddr241 = (word) (( (ptr) &var←c82492)+7)/* var←c79644 */ ;
(* (ptr) tmpAddr241 ) = ( ((word) (fPt) BandAction←P12048) );
(* (( (ptr) tmpAddr241) + 1) ) = 1;
};
SOURCE(53783, 926)
(* (( (ptr) &var←c82492)+6)/* equal←v17904 */ ) = 1;
SOURCE(54325, 384)
{
word tc242;
box←v63320 = (* (W4Pt) (* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ) );
if (( (int)box←v63320.f0 >= (int)box←v63320.f2)) {
var←c79676 = (unsigned) 1;
}
else {
var←c79676 = (unsigned) ( (int)box←v63320.f1 >= (int)box←v63320.f3);
};
if ((0 != var←c79676)) {
box←v63272 = (* (W4Pt) (* (( (ptr) &var←c82492)+5)/* s2←v17860 */ ) );
if (( (int)box←v63272.f0 >= (int)box←v63272.f2)) {
var←c79708 = (unsigned) 1;
}
else {
var←c79708 = (unsigned) ( (int)box←v63272.f1 >= (int)box←v63272.f3);
};
tc242 = (word) (0 != var←c79708);
}
else {
tc242 = (word) 0;
};
if (tc242) {
}
else {
SOURCE(54393, 316)
if ( ! XR←EqualWords((* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ), (* (( (ptr) &var←c82492)+5)/* s2←v17860 */ ), 4)) {
SOURCE(54417, 19)
(* (( (ptr) &var←c82492)+6)/* equal←v17904 */ ) = 0;
}
else {
SOURCE(54436, 275)
{
word bandBitsPerSample←v36612;
word bandLines←v36640;
W4 bandBox←v36668;
SOURCE(54438, 64)
{
word x243;
word x244;
bandBitsPerSample←v36612 = (x243 = (* (( (ptr) (* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ))+5) ),
x244 = (* (( (ptr) (* (( (ptr) &var←c82492)+5)/* s2←v17860 */ ))+5) ),
MAX( (unsigned) , x243, x244));
};
SOURCE(54504, 81)
{
word var←c79740;
W4 box←v62060;
word var←c01329;
word var←c79772;
W4 box←v61964;
box←v62060 = (* (W4Pt) (* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ) );
if (( (int)box←v62060.f1 < (int)box←v62060.f3)) {
var←c79740 = (box←v62060.f3 - box←v62060.f1);
}
else {
var←c79740 = 0;
};
{
word x245;
var←c01329 = (x245 = (4096 / var←c79740),
MAX( (unsigned) , x245, 1));
};
box←v61964 = (* (W4Pt) (* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ) );
if (( (int)box←v61964.f0 < (int)box←v61964.f2)) {
var←c79772 = (box←v61964.f2 - box←v61964.f0);
}
else {
var←c79772 = 0;
};
bandLines←v36640 = (MIN( (unsigned) , var←c01329, var←c79772));
};
SOURCE(54587, 21)
bandBox←v36668 = (* (W4Pt) (* (( (ptr) &var←c82492)+4)/* s1←v17832 */ ) );
SOURCE(54610, 41)
bandBox←v36668.f2 = (bandBox←v36668.f0 + bandLines←v36640);
SOURCE(54653, 56)
(void) DoWithScratchMap←P2100(bandBox←v36668, BCK(bandBitsPerSample←v36612, 33), (word) (( (bPt) &var←c82492)+28)/* var←c79644 */ )
;
};
};
};
};
SOURCE(53783, 926)
return((* (( (ptr) &var←c82492)+6)/* equal←v17904 */ ));
}
static void BandAction←P12048(band←v36584, formal←c82524)
word band←v36584;
word formal←c82524;
{
word boxSize←v36712;
word bandSize←v36740;
word bandWords←v36768;
formal←c82524 = (formal←c82524 - 28);
/* BandAction: */
SOURCE(53855, 448)
SOURCE(53900, 37)
{
word var←c79804;
W4 box←v61916;
box←v61916 = (* (W4Pt) (* (( (ptr) formal←c82524)+4) ) );
if (( (int)box←v61916.f0 < (int)box←v61916.f2)) {
var←c79804 = (box←v61916.f2 - box←v61916.f0);
}
else {
var←c79804 = 0;
};
boxSize←v36712 = SGNCK(var←c79804);
};
SOURCE(53939, 40)
{
word var←c79836;
W4 box←v61868;
box←v61868 = (* (W4Pt) band←v36584 );
if (( (int)box←v61868.f0 < (int)box←v61868.f2)) {
var←c79836 = (box←v61868.f2 - box←v61868.f0);
}
else {
var←c79836 = 0;
};
bandSize←v36740 = SGNCK(var←c79836);
};
SOURCE(53981, 58)
{
word idx246;
word idx247;
bandWords←v36768 = (
idx247 = (word) WordsForLines←P1440(bandSize←v36740, (
idx246 = (* (( (ptr) band←v36584)+7) ),
SGNCK(idx246)
)),
SGNCK(idx247)
);
};
SOURCE(54041, 11)
(void) Clear←P3360(band←v36584);
SOURCE(54054, 249)
{
register word s←v36812;
s←v36812 = 0;
lab←L100327: ;
if (( (int)s←v36812 < (int)boxSize←v36712)) {
}
else {
goto lab←L100324;
};
SOURCE(54106, 50)
{
W2 var←c79868;
var←c79868.f0 = INEG(s←v36812);
var←c79868.f1 = 0;
(void) Transfer←P3600(band←v36584, (* (( (ptr) formal←c82524)+4) ), var←c79868, 0);
};
SOURCE(54158, 73)
{
W2 var←c79900;
var←c79900.f0 = INEG(s←v36812);
var←c79900.f1 = 0;
(void) Transfer←P3600(band←v36584, (* (( (ptr) formal←c82524)+5) ), var←c79900, 6);
};
SOURCE(54233, 70)
if ((0 == (word) Zeros←P4680((* (( (ptr) band←v36584)+8) ), bandWords←v36768))) {
SOURCE(54290, 13)
(* (( (ptr) formal←c82524)+6) ) = 0;
SOURCE(54305, 5)
goto lab←L100325;
};
s←v36812 = (s←v36812 + bandSize←v36740);
goto lab←L100327;
lab←L100324: ;
lab←L100325: ;
};
}
static word IsAll←P4800(map←v17964, box←v17992, formal←c01384)
word map←v17964;
W4 box←v17992;
word formal←c01384;
{
W9 var←c82556;
/* declaration of value←v18020 skipped */
/* declaration of equal←v18064 skipped */
/* declaration of var←c79932 skipped */
/* declaration of clipped←v36856 skipped */
(* (( (ptr) &var←c82556)+4)/* value←v18020 */ ) = formal←c01384;
/* IsAll: */
SOURCE(54718, 931)
{
word tmpAddr248;
tmpAddr248 = (word) (( (ptr) &var←c82556)+6)/* var←c79932 */ ;
(* (ptr) tmpAddr248 ) = ( ((word) (fPt) BandAction←P12252) );
(* (( (ptr) tmpAddr248) + 1) ) = 1;
};
SOURCE(54718, 931)
(* (( (ptr) &var←c82556)+5)/* equal←v18064 */ ) = 1;
SOURCE(54826, 35)
(* (( (ptr) &var←c82556)+8)/* clipped←v36856 */ ) = (word) Clip←P2700(map←v17964, box←v17992);
{
word var←c79964;
W4 box←v62252;
SOURCE(54863, 755)
box←v62252 = (* (W4Pt) (* (( (ptr) &var←c82556)+8)/* clipped←v36856 */ ) );
if (( (int)box←v62252.f0 < (int)box←v62252.f2)) {
var←c79964 = (unsigned) ( (int)box←v62252.f1 < (int)box←v62252.f3);
}
else {
var←c79964 = (unsigned) 0;
};
if ((0 != var←c79964)) {
SOURCE(54902, 718)
{
word bandLines←v36928;
W4 bandBox←v36956;
SOURCE(55394, 91)
{
word var←c79996;
W4 box←v62012;
word var←c01330;
word var←c80028;
W4 box←v61820;
box←v62012 = (* (W4Pt) (* (( (ptr) &var←c82556)+8)/* clipped←v36856 */ ) );
if (( (int)box←v62012.f1 < (int)box←v62012.f3)) {
var←c79996 = (box←v62012.f3 - box←v62012.f1);
}
else {
var←c79996 = 0;
};
{
word x249;
var←c01330 = (x249 = (4096 / var←c79996),
MAX( (unsigned) , x249, 1));
};
box←v61820 = (* (W4Pt) (* (( (ptr) &var←c82556)+8)/* clipped←v36856 */ ) );
if (( (int)box←v61820.f0 < (int)box←v61820.f2)) {
var←c80028 = (box←v61820.f2 - box←v61820.f0);
}
else {
var←c80028 = 0;
};
bandLines←v36928 = (MIN( (unsigned) , var←c01330, var←c80028));
};
SOURCE(55487, 26)
bandBox←v36956 = (* (W4Pt) (* (( (ptr) &var←c82556)+8)/* clipped←v36856 */ ) );
SOURCE(55515, 41)
bandBox←v36956.f2 = (bandBox←v36956.f0 + bandLines←v36928);
SOURCE(55558, 60)
(void) DoWithScratchMap←P2100(bandBox←v36956, (* (( (ptr) (* (( (ptr) &var←c82556)+8)/* clipped←v36856 */ ))+5) ), (word) (
( (bPt) &var←c82556)+24)/* var←c79932 */ );
};
};
SOURCE(55623, 26)
(void) ReleaseDescriptor←P1860((* ((( (ptr) &var←c82556)+8)/* clipped←v36856 */ ) ));
};
SOURCE(54718, 931)
return((* (( (ptr) &var←c82556)+5)/* equal←v18064 */ ));
}
static void BandAction←P12252(band←v37032, formal←c82620)
word band←v37032;
word formal←c82620;
{
register ptr gf←c82588 = (ptr) &globalframe;
word boxSize←v37060;
word bandSize←v37088;
word bandWords←v37116;
formal←c82620 = (formal←c82620 - 24);
/* BandAction: */
SOURCE(54904, 18)
SOURCE(54949, 42)
{
word var←c80060;
W4 box←v61772;
box←v61772 = (* (W4Pt) (* (( (ptr) formal←c82620)+8) ) );
if (( (int)box←v61772.f0 < (int)box←v61772.f2)) {
var←c80060 = (box←v61772.f2 - box←v61772.f0);
}
else {
var←c80060 = 0;
};
boxSize←v37060 = SGNCK(var←c80060);
};
SOURCE(54993, 40)
{
word var←c80092;
W4 box←v61724;
box←v61724 = (* (W4Pt) band←v37032 );
if (( (int)box←v61724.f0 < (int)box←v61724.f2)) {
var←c80092 = (box←v61724.f2 - box←v61724.f0);
}
else {
var←c80092 = 0;
};
bandSize←v37088 = SGNCK(var←c80092);
};
SOURCE(55035, 58)
{
word idx250;
word idx251;
bandWords←v37116 = (
idx251 = (word) WordsForLines←P1440(bandSize←v37088, (
idx250 = (* (( (ptr) band←v37032)+7) ),
SGNCK(idx250)
)),
SGNCK(idx251)
);
};
SOURCE(55095, 11)
(void) Clear←P3360(band←v37032);
SOURCE(55108, 264)
{
register word s←v37160;
s←v37160 = 0;
lab←L100336: ;
if (( (int)s←v37160 < (int)boxSize←v37060)) {
}
else {
goto lab←L100333;
};
SOURCE(55160, 55)
{
W2 var←c80124;
var←c80124.f0 = INEG(s←v37160);
var←c80124.f1 = 0;
(void) Transfer←P3600(band←v37032, (* (( (ptr) formal←c82620)+8) ), var←c80124, 0);
};
SOURCE(55217, 83)
if (((* (( (ptr) formal←c82620)+4) ) != 0)) {
SOURCE(55235, 65)
(void) Fill←P3840(band←v37032, (* (W4Pt) (( (ptr) gf←c82588)+209)/* var←c66396 */ ), (* (( (ptr) formal←c82620)+4) ), 6)
;
};
SOURCE(55302, 70)
if ((0 == (word) Zeros←P4680((* (( (ptr) band←v37032)+8) ), bandWords←v37116))) {
SOURCE(55359, 13)
(* (( (ptr) formal←c82620)+5) ) = 0;
SOURCE(55374, 5)
goto lab←L100334;
};
s←v37160 = (s←v37160 + bandSize←v37088);
goto lab←L100336;
lab←L100333: ;
lab←L100334: ;
};
}
static void Trim←P4860(formal←c01242, formal←c01385, box←v18152, formal←c01386)
word formal←c01242;
word formal←c01385;
W4 box←v18152;
word formal←c01386;
{
W12 var←c82652;
/* declaration of map←v18124 skipped */
/* declaration of background←v18180 skipped */
register ptr gf←c82684 = (ptr) &globalframe;
W4 var←c18224;
/* declaration of var←c80156 skipped */
W4 actualBox←v37204;
/* declaration of min←v37232 skipped */
/* declaration of max←v37260 skipped */
(* (( (ptr) &var←c82652)+4)/* map←v18124 */ ) = formal←c01385;
(* (( (ptr) &var←c82652)+5)/* background←v18180 */ ) = formal←c01386;
/* Trim: */
SOURCE(55655, 1581)
{
word tmpAddr252;
tmpAddr252 = (word) (( (ptr) &var←c82652)+6)/* var←c80156 */ ;
(* (ptr) tmpAddr252 ) = ( ((word) (fPt) BandAction←P12360) );
(* (( (ptr) tmpAddr252) + 1) ) = 1;
};
SOURCE(55738, 53)
{
W4 box←v56324;
{
word pd253;
pd253 = (* (( (ptr) (* (( (ptr) gf←c82684)+225)/* var←c67164 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd253 ))))((word) &box←v56324, (* (W4Pt) (* (( (ptr) &var←c82652)+4)/* map←v18124 */ ) ), box←v18152, pd253)
;
};
SOURCE(1846, 74)
if (( (int)box←v56324.f0 >= (int)box←v56324.f2) || ( (int)box←v56324.f1 >= (int)box←v56324.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56324)+2) ) = (* (W2Pt) &box←v56324 );
};
SOURCE(1922, 12)
actualBox←v37204 = box←v56324;
};
SOURCE(55793, 24)
(* (W2Pt) (( (ptr) &var←c82652)+8)/* min←v37232 */ ) = (* (W2Pt) &actualBox←v37204 );
SOURCE(55819, 24)
(* (W2Pt) (( (ptr) &var←c82652)+10)/* max←v37260 */ ) = (* (W2Pt) (( (ptr) &actualBox←v37204)+2) );
SOURCE(56596, 124)
{
W4 var←c80220;
var←c80220.f0 = 0;
var←c80220.f1 = 0;
var←c80220.f2 = 1;
{
word idx254;
var←c80220.f3 = (
idx254 = (word) ( ( (int)actualBox←v37204.f1 < (int)actualBox←v37204.f3) ? (actualBox←v37204.f3 - actualBox←v37204.f1) : 0 ) ,
SGNCK(idx254)
);
};
(void) DoWithScratchMap←P2100(var←c80220, (* (( (ptr) (* (( (ptr) &var←c82652)+4)/* map←v18124 */ ))+5) ), (word) (( (bPt) &var←c82652)+24)
/* var←c80156 */ );
};
SOURCE(56722, 448)
if (( (int)(* (( (ptr) &var←c82652)+8) ) == (int)(* (( (ptr) &var←c82652)+10) ))) {
SOURCE(56742, 19)
(* (( (ptr) &var←c82652)+11) ) = (* (( (ptr) &var←c82652)+9) );
}
else {
SOURCE(56763, 407)
{
register word delta←v37392;
delta←v37392 = 16;
lab←L100342: ;
if ((delta←v37392 != 0)) {
}
else {
goto lab←L100339;
};
SOURCE(56809, 173)
lab←L100345: ;
if (( (int)((* (( (ptr) &var←c82652)+9) ) + delta←v37392) <= (int)(* (( (ptr) &var←c82652)+11) ))) {
}
else {
goto lab←L100343;
};
{
W4 margin←v37436;
SOURCE(56859, 57)
margin←v37436.f0 = (* (( (ptr) &var←c82652)+8) );
margin←v37436.f1 = ((* (( (ptr) &var←c82652)+11) ) - delta←v37392);
(* (W2Pt) (( (ptr) &margin←v37436)+2) ) = (* (W2Pt) (( (ptr) &var←c82652)+10)/* max←v37260 */ );
SOURCE(56918, 64)
if ((0 != (word) IsAll←P4800((* (( (ptr) &var←c82652)+4)/* map←v18124 */ ), margin←v37436, (* (( (ptr) &var←c82652)+5)/* background←v18180 */ ))
)) {
SOURCE(56957, 25)
(* (( (ptr) &var←c82652)+11) ) = ((* (( (ptr) &var←c82652)+11) ) - delta←v37392);
}
else {
SOURCE(56982, 4)
goto lab←L100344;
};
};
goto lab←L100345;
lab←L100343: ;
lab←L100344: ;
SOURCE(56997, 173)
lab←L100348: ;
if (( (int)((* (( (ptr) &var←c82652)+9) ) + delta←v37392) <= (int)(* (( (ptr) &var←c82652)+11) ))) {
}
else {
goto lab←L100346;
};
{
W4 margin←v37480;
SOURCE(57047, 57)
(* (W2Pt) &margin←v37480 ) = (* (W2Pt) (( (ptr) &var←c82652)+8)/* min←v37232 */ );
margin←v37480.f2 = (* (( (ptr) &var←c82652)+10) );
margin←v37480.f3 = ((* (( (ptr) &var←c82652)+9) ) + delta←v37392);
SOURCE(57106, 64)
if ((0 != (word) IsAll←P4800((* (( (ptr) &var←c82652)+4)/* map←v18124 */ ), margin←v37480, (* (( (ptr) &var←c82652)+5)/* background←v18180 */ ))
)) {
SOURCE(57145, 25)
(* (( (ptr) &var←c82652)+9) ) = ((* (( (ptr) &var←c82652)+9) ) + delta←v37392);
}
else {
SOURCE(57170, 4)
goto lab←L100347;
};
};
goto lab←L100348;
lab←L100346: ;
lab←L100347: ;
delta←v37392 = ((word) delta←v37392 >> 2);
goto lab←L100342;
lab←L100339: ;
};
};
SOURCE(57197, 39)
{
W4 box←v56276;
(* (W2Pt) &box←v56276 ) = (* (W2Pt) (( (ptr) &var←c82652)+8)/* min←v37232 */ );
(* (W2Pt) (( (ptr) &box←v56276)+2) ) = (* (W2Pt) (( (ptr) &var←c82652)+10)/* max←v37260 */ );
SOURCE(1846, 74)
if (( (int)box←v56276.f0 >= (int)box←v56276.f2) || ( (int)box←v56276.f1 >= (int)box←v56276.f3)) {
SOURCE(1903, 17)
(* (W2Pt) (( (ptr) &box←v56276)+2) ) = (* (W2Pt) &box←v56276 );
};
SOURCE(1922, 12)
var←c18224 = box←v56276;
};
/* removed tail goto */
(* (W4Pt) formal←c01242 ) = var←c18224;
return;
}
static void BandAction←P12360(band←v37364, formal←c82716)
word band←v37364;
word formal←c82716;
{
word bandWords←v37524;
formal←c82716 = (formal←c82716 - 24);
/* BandAction: */
SOURCE(55845, 733)
SOURCE(55890, 64)
{
word idx255;
word idx256;
word idx257;
bandWords←v37524 = (
idx257 = (word) WordsForLines←P1440((
idx255 = (* (( (ptr) band←v37364)+2) ),
SGNCK(idx255)
), (
idx256 = (* (( (ptr) band←v37364)+7) ),
SGNCK(idx256)
)),
SGNCK(idx257)
);
};
SOURCE(55956, 11)
(void) Clear←P3360(band←v37364);
SOURCE(55969, 298)
lab←L100352: ;
if (( (int)(* (( (ptr) formal←c82716)+8) ) < (int)(* (( (ptr) formal←c82716)+10) ))) {
}
else {
goto lab←L100350;
};
SOURCE(56012, 86)
{
W2 var←c80412;
W2 var←c80444;
var←c80412.f0 = 0;
var←c80412.f1 = 0;
var←c80444.f0 = ((* (( (ptr) formal←c82716)+10) ) - 1);
var←c80444.f1 = (* (( (ptr) formal←c82716)+9) );
(void) BasicTransfer←P3480(band←v37364, (* (( (ptr) formal←c82716)+4) ), var←c80412, var←c80444, (* (W2Pt) (( (ptr) band←v37364)+2)
), 0);
};
SOURCE(56100, 93)
if (((* (( (ptr) formal←c82716)+5) ) != 0)) {
SOURCE(56121, 72)
(void) Fill←P3840(band←v37364, (* (W4Pt) band←v37364 ), (* (( (ptr) formal←c82716)+5) ), 6);
};
SOURCE(56195, 72)
if ((0 != (word) Zeros←P4680((* (( (ptr) band←v37364)+8) ), bandWords←v37524))) {
SOURCE(56246, 21)
(* (( (ptr) formal←c82716)+10) ) = ((* (( (ptr) formal←c82716)+10) ) - 1);
}
else {
SOURCE(56267, 4)
goto lab←L100351;
};
goto lab←L100352;
lab←L100350: ;
lab←L100351: ;
SOURCE(56282, 296)
lab←L100355: ;
if (( (int)(* (( (ptr) formal←c82716)+8) ) < (int)(* (( (ptr) formal←c82716)+10) ))) {
}
else {
goto lab←L100353;
};
SOURCE(56325, 84)
{
W2 var←c80476;
W2 var←c80508;
var←c80476.f0 = 0;
var←c80476.f1 = 0;
var←c80508.f0 = (* (( (ptr) formal←c82716)+8) );
var←c80508.f1 = (* (( (ptr) formal←c82716)+9) );
(void) BasicTransfer←P3480(band←v37364, (* (( (ptr) formal←c82716)+4) ), var←c80476, var←c80508, (* (W2Pt) (( (ptr) band←v37364)+2)
), 0);
};
SOURCE(56411, 93)
if (((* (( (ptr) formal←c82716)+5) ) != 0)) {
SOURCE(56432, 72)
(void) Fill←P3840(band←v37364, (* (W4Pt) band←v37364 ), (* (( (ptr) formal←c82716)+5) ), 6);
};
SOURCE(56506, 72)
if ((0 != (word) Zeros←P4680((* (( (ptr) band←v37364)+8) ), bandWords←v37524))) {
SOURCE(56557, 21)
(* (( (ptr) formal←c82716)+8) ) = ((* (( (ptr) formal←c82716)+8) ) + 1);
}
else {
SOURCE(56578, 4)
goto lab←L100354;
};
goto lab←L100355;
lab←L100353: ;
lab←L100354: ;
}
static void NoName←Q20916(formal←c01253, formal←c200004, formal←c200005, formal←c200006, formal←c200007)
word formal←c01253;
word formal←c200004;
word formal←c200005;
word formal←c200006;
word formal←c200007;
{
if ((formal←c200005 == XR←Unwind)) {
SOURCE(12980, 27)
(void) ReleaseScratchMap←P1980((* ((( (ptr) formal←c200004)+5)) ));
};
(* (ptr) formal←c01253 ) = 0;
(* (( (ptr) formal←c01253)+1) ) = 0;
return;
}
static void NoName←Q20976(formal←c01258, formal←c200000, formal←c200001, formal←c200002, formal←c200003)
word formal←c01258;
word formal←c200000;
word formal←c200001;
word formal←c200002;
word formal←c200003;
{
if ((formal←c200001 == XR←Unwind)) {
SOURCE(4703, 31)
(void) ReleaseScratchSamples←P840((* ((( (ptr) formal←c200000)+5)) ));
};
(* (ptr) formal←c01258 ) = 0;
(* (( (ptr) formal←c01258)+1) ) = 0;
return;
}
/* file: ImagerSampleImpl, module: ImagerSampleImpl, compiled at: March 9, 1994 11:51:50 am PST */
extern void XR←install←ImagerSampleImpl() {
NoName←Q20736();
}
extern void XR←run←ImagerSampleImpl() { XR←Start(&globalframe); }