/* Generated with C2C (Cedar To C)*/
/* Copyright (C) 1994 by Xerox Corporation. All rights reserved. */
/* time: March 9, 1994 11:42:55 am PST */
/* C2C version: January 12, 1994 (sun4) */
/* ref-counting: off */
/* file: ImagerRasterImpl, module: ImagerRasterImpl */
/* 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)))
static char versionStamp[] = "@(#)mob←version [3953602962,387497237] ImagerRasterImpl";
typedef unsigned word, *ptr;
typedef unsigned char byte, *bPt;
typedef unsigned short half, *hPt;
typedef word (*fPt)();
typedef struct {word f0, f1;} W2;
typedef struct {word f0, f1, f2, f3, f4, f5, f6, f7;} W8;
typedef struct {W8 f; W2 r;} W10;
typedef W10 *W10Pt;
typedef struct {word f0, f1, f2;} W3;
typedef struct {word f0, f1, f2, f3;} W4;
typedef struct {W8 f; word r;} W9;
typedef struct {word f0, f1, f2, f3, f4;} W5;
typedef W5 *W5Pt;
typedef W4 *W4Pt;
typedef struct {W8 f; W8 r;} W16;
typedef struct {W16 f; W5 r;} W21;
typedef W21 *W21Pt;
typedef W2 *W2Pt;
typedef struct {W8 f; W3 r;} W11;
typedef struct {W16 f; W8 r;} W24;
typedef struct {word f0, f1, f2, f3, f4, f5;} W6;
typedef struct {word f0, f1, f2, f3, f4, f5, f6;} W7;
typedef struct {W16 f; W16 r;} W32;
typedef struct {W32 f; W32 r;} W64;
typedef struct {W64 f; W6 r;} W70;
typedef W70 *W70Pt;
typedef struct {W8 f; W6 r;} W14;
typedef struct {W8 f; W4 r;} W12;
typedef struct {W8 f; W7 r;} W15;
typedef struct {W8 f; W5 r;} W13;
#define SOURCE(p, l) /* source p, l */
static float fc61 = 1.0;
static float fc62 = 0.0001;
#define BCK(idx, lim) ( ((unsigned) idx) >= ((unsigned) lim) ? (XR←RaiseBoundsFault()) : (idx) )
static float fc66 = 65535.0;
static float fc69 = 1073741823.0;
static float fc70 = 0.0;
#define FABS(f, t) ( ((t=(f)) >= (float) 0.0) ? (t) : (- (t)) )
static float fc96 = 0.5;
#define INEG(x) ( (word) ( - ((int) (word) (x)) ) )
#define MAX(cast, x, y) ( ( cast x) > ( cast y) ? (x) : (y) )
#define MIN(cast, x, y) ( ( cast x) < ( cast y) ? (x) : (y) )
static float fc332 = 0.0254;
#define IABS(i) ( ((int)(word)(i) > 0) ? (i) : (word)(-(int)(word)(i)) )
static void NoName←Q11628();
static void ImagerRasterImpl←P0();
static void NoteStateChanges←P240();
static word GetColorViewToDevice←P300();
static word ScaleSnap←P360();
static void ValidateIfNeeded←P420();
static void Validate←P480();
static word GetDevice←P600();
static void DoWithDevice←P660();
static void proc←P4872();
static word GetInterchangeState←P720();
static word ContextFromInterchangeState←P780();
static void RasterMaskFill←P840();
static word PenFromState←P960();
static void RasterMaskVector←P1020();
static void RasterMaskStroke←P1080();
static void RasterMaskDashedStroke←P1140();
static void RasterMaskBitmap←P1200();
static void GetSampleMapClippedDisplacedBox←P1260();
static void ClippedBounds←P1320();
static void RasterDrawBitmap←P1380();
static void Boxes←P5472();
static void RasterMaskPixel←P1440();
static void GetContainingBox←P1500();
static word GetClipper←P1560();
static void GetDeviceClipBox←P1620();
static void SetDeviceClipBox←P1680();
static void RasterGetBounds←P1740();
static word RasterTestViewRectangle←P1800();
static word IntegerTranslation←P1860();
static void RasterDoWithBuffer←P1920();
static word NoName←Q11688();
static void fillAction←P5820();
static void RasterViewReset←P1980();
static void RasterViewTranslateI←P2040();
static void RasterViewClipRectangleI←P2100();
static void path←P6024();
static word RasterGetTransformation←P2160();
static void RasterViewClip←P2220();
static word IsAllInteger←P2280();
static word Is←P6084();
static void RasterMoveViewRectangle←P2340();
static word RasterGetBufferColorOperator←P2400();
static void RasterAccessBuffer←P2460();
static void outer←P6288();
static void inner←P6348();
static void boxAction←P6408();
static word CreateClass←P2520();
static word Create←P2580();
static void RasterMaskRectangle←P2640();
static void RasterMaskRectangleI←P2700();
static void boxes←P6756();
static void BasicShowChar←P2760();
static void proc←P6864();
static void FlushState←P2820();
static word GetFontAtom←P3000();
static void TryFastState←P3060();
static void RasterShow←P3120();
static void XRelString←P7020();
static void XRelAction←P7200();
static void HardChar←P7080();
static void HardMetrics←P7140();
static void RasterShowBackward←P3180();
static word NoName←Q11748();
static void ModifySetColor←P3240();
static void ModifySetPriority←P3300();
static void ModifySetHalftoneProperties←P3360();
static void ModifyMaskBoxes←P3420();
static void action←P7596();
static void ModifyMaskRegion←P3480();
static void action←P7704();
static void ModifyMaskBitmap←P3540();
static void action←P7812();
static void ModifyMaskPixelArray←P3600();
static void action←P7920();
static void ModifyMaskRawBitmaps←P3660();
static void action←P8028();
static void ModifyDrawBitmap←P3720();
static void action←P8184();
static void ModifyMaskChar←P3780();
static void action←P8292();
static void ModifyMoveBox←P3840();
static void action←P8400();
static void ModifySwitchBuffer←P3900();
static void proc←P8460();
static word ModifyGetBufferColorOperator←P3960();
static void ModifyAccessBuffer←P4020();
static void proc←P8568();
static word InterceptorInEffect←P4080();
static word SetInterceptor←P4140();
static void NoName←Q11808();
static void NoName←Q11868();
static struct {unsigned f; char r[16];} string1 = {851984, "\257\300\205\026\031\133\300\153\303\216\034\100\164\000\000"};
static struct {unsigned f; char r[8];} string2 = {458759, "\006\002\000\001A\024\001"};
static struct {unsigned f; char r[16];} string3 = {851984, "\257\300\231\275\333\246\300\032\361\021\012\100\324\000\000"};
static struct {unsigned f; char r[32];} string4 = {1900573, "\006\011\100\200\001\100\204\001\100\210\001\100\214\001\100\220\001\100\224\001\100\230\001\100\234\001\100\240\001\000\000"};
static struct {unsigned f; char r[16];} string5 = {851984, "\257\300\353\247\061\222\300\027\030\275\025\100\230\000\000"};
static struct {unsigned f; char r[24];} string6 = {1376277, "\006\010\000\001\010\001\014\001\020\001\054\001\100\110\001\100\114\001\100\120\001\000\000"};
static struct {unsigned f; char r[4];} string7 = {131076, "\216\251\000"};
static struct {unsigned f; char r[4];} string8 = {65537, "\001\000\000"};
static struct {unsigned f; char r[16];} string9 = {851984, "\257\300\207\334\320\152\300\253\325\361\210\100\200\000\000"};
static struct {unsigned f; char r[16];} string10 = {917520, "\216\257\300\363\223\326\161\300\017\164\046\072\104\350\000"};
static struct {unsigned f; char r[4];} string11 = {65540, "\256\000\000"};
static struct {unsigned f; char r[16];} string12 = {851984, "\257\300\241\011\366\176\300\127\130\105\301\100\274\000\000"};
static struct {unsigned f; char r[4];} string13 = {131074, "\003\016\000"};
static struct {unsigned f; char r[16];} string14 = {851984, "\257\300\353\247\061\222\300\027\030\275\025\104\210\000\000"};
static struct {unsigned f; char r[4];} string15 = {131074, "\004\006\000"};
static struct {unsigned f; char r[16];} string16 = {851984, "\257\300\241\011\366\176\300\127\130\105\301\101\334\000\000"};
static struct {unsigned f; char r[4];} string17 = {131074, "\003\004\000"};
static struct {unsigned f; char r[16];} string18 = {851984, "\257\300\074\177\166\242\300\203\113\217\044\100\164\000\000"};
static struct {unsigned f; char r[4];} string19 = {131074, "\004\017\000"};
static struct {unsigned f; char r[40];} string20 = {2555944, "Failed to set font before calling Show."};
static struct {unsigned f; char r[16];} string21 = {917520, "RasterTemplate\000"};
static struct {unsigned f; char r[116];} string22 = {7471220, "Sampled blacks may be rescaled by a factor this close to unity, to improve rendered appearance and/or performance.\000"};
static struct {unsigned f; char r[20];} string23 = {1179668, "adjustsampledblack\000"};
static struct {unsigned f; char r[52];} string24 = {3276852, "MaskPixel argument must have one sample per pixel.\000"};
static struct {unsigned f; char r[52];} string25 = {3145780, "MaskPixel argument must have one bit per sample.\000\000\000"};
static struct {unsigned f; char r[48];} string26 = {3080240, "MoveViewRectangle not implemented for this case"};
static struct {unsigned f; char r[16];} string27 = {851984, "\257\300\353\247\061\222\300\027\030\275\025\100\164\000\000"};
static struct {unsigned f; char r[16];} string28 = {851981, "\006\004\020\001\044\001\050\001\100\210\004\100\177\000\000"};
static struct {unsigned f; char r[4];} string29 = {1231905127, "er"};
static struct {unsigned f; char r[16];} string30 = {851984, "\257\300\074\177\166\242\300\203\113\217\044\100\150\000\000"};
static struct {unsigned f; char r[16];} string31 = {851984, "\257\300\241\011\366\176\300\127\130\105\301\100\150\000\000"};
static struct {unsigned f; char r[16];} string32 = {851984, "\257\300\151\316\011\300\300\225\037\327\014\100\150\000\000"};
static struct {unsigned f; char r[16];} string33 = {851984, "\257\300\352\210\333\354\300\066\006\043\223\100\150\000\000"};
static struct {unsigned f; char r[8];} string34 = {1231905127, "erFont"};
static struct {unsigned f; char r[16];} string35 = {851984, "\257\300\046\300\267\143\300\022\215\240\122\100\150\000\000"};
static struct {unsigned f; char r[16];} string36 = {851984, "\257\300\360\006\233\311\300\116\352\007\226\100\150\000\000"};
static struct {unsigned f; char r[16];} string37 = {851984, "\257\300\350\311\135\367\300\362\215\374\250\100\150\000\000"};
static struct {unsigned f; char r[16];} string38 = {851984, "\257\300\130\073\236\351\300\154\373\320\354\100\150\000\000"};
static struct {unsigned f; char r[16];} string39 = {851984, "\257\300\230\052\311\306\300\242\375\035\324\100\150\000\000"};
static struct {unsigned f; char r[16];} string40 = {851984, "\257\300\205\026\031\133\300\153\303\216\034\100\150\000\000"};
static struct {unsigned f; char r[16];} string41 = {851984, "\257\300\213\226\301\143\300\072\355\320\373\100\150\000\000"};
static struct {unsigned f; char r[16];} string42 = {851984, "\257\300\222\214\017\031\300\363\352\337\134\100\150\000\000"};
static struct {unsigned f; char r[8];} string43 = {1231905127, "erState"};
static struct {unsigned f; char r[16];} string44 = {851984, "\257\300\231\275\333\246\300\032\361\021\012\100\164\000\000"};
static struct {unsigned f; char r[16];} string45 = {851984, "\257\300\121\117\377\026\300\315\013\026\004\100\150\000\000"};
static struct {unsigned f; char r[16];} string46 = {851984, "\257\300\301\227\276\106\300\342\254\204\020\100\150\000\000"};
static struct {unsigned f; char r[16];} string47 = {851984, "\257\300\246\205\220\035\300\344\000\142\023\100\150\000\000"};
static struct {unsigned f; char r[16];} string48 = {851984, "\257\300\245\247\302\156\300\052\156\325\023\100\150\000\000"};
static struct {unsigned f; char r[12];} string49 = {720908, "\257\300/\002\345\247\245\243T@h"};
static struct {unsigned f; char r[16];} string50 = {851984, "\257\300\243\162\130\311\300\344\000\142\023\100\150\000\000"};
static struct {unsigned f; char r[16];} string51 = {851984, "\257\300\247\031\224\326\300\123\162\224\023\100\150\000\000"};
static struct {unsigned f; char r[16];} string52 = {851984, "\257\300\346\312\312\137\300\332\074\046\072\100\150\000\000"};
static struct {unsigned f; char r[16];} string53 = {851984, "\257\300\067\246\211\216\300\354\224\134\067\100\150\000\000"};
static struct {unsigned f; char r[24];} string54 = {1376280, "\211\011\010\103\154\141\163\163\122\145\160\300\074\177\166\242\300\203\113\217\044\000\000"};
static struct {unsigned f; char r[24];} string55 = {1376280, "\211\011\010\123\164\141\164\145\122\145\160\300\074\177\166\242\300\203\113\217\044\000\000"};
static struct {unsigned f; char r[28];} string56 = {1572892, "\211\014\013\124\171\160\145\146\141\143\145\122\145\160\300\046\300\267\143\300\022\215\240\122\000\000\000"};
static struct {unsigned f; char r[16];} string57 = {851984, "\257\300\301\227\276\106\300\342\254\204\020\100\164\000\000"};
static struct {unsigned f; char r[4];} string58 = {196611, "\004@\357"};
static struct {unsigned f; char r[28];} string59 = {1703964, "\211\016\015\122\141\163\164\145\162\104\141\164\141\122\145\160\300\231\275\333\246\300\032\361\021\012\000"};
static struct {
word f0[41]; word f41; word f42; word f43;
word f44; word f45; word f46; word f47;
word f48; word f49; word f50; word f51;
word f52; word f53; word f54; word f55;
word f56; word f57; word f58; word f59;
word f60; word f61; word f62; word f63;
word f64; word f65; word f66; word f67;
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[23];
} globalframe = {
{0}, (word) SetInterceptor←P4140, 0, (word) InterceptorInEffect←P4080,
0, (word) ModifyAccessBuffer←P4020, 0, (word) ModifyGetBufferColorOperator←P3960,
0, (word) ModifySwitchBuffer←P3900, 0, (word) ModifyMoveBox←P3840,
0, (word) ModifyMaskChar←P3780, 0, (word) ModifyDrawBitmap←P3720,
0, (word) ModifyMaskRawBitmaps←P3660, 0, (word) ModifyMaskPixelArray←P3600,
0, (word) ModifyMaskBitmap←P3540, 0, (word) ModifyMaskRegion←P3480,
0, (word) ModifyMaskBoxes←P3420, 0, (word) ModifySetHalftoneProperties←P3360,
0, (word) ModifySetPriority←P3300, 0, (word) ModifySetColor←P3240,
0, (word) RasterShowBackward←P3180, 0, (word) RasterShow←P3120,
0, (word) TryFastState←P3060, 0, (word) GetFontAtom←P3000,
0, (word) FlushState←P2820, 0, (word) BasicShowChar←P2760,
0, (word) RasterMaskRectangleI←P2700, 0, (word) RasterMaskRectangle←P2640,
0, (word) Create←P2580, 0, (word) CreateClass←P2520,
0, (word) RasterAccessBuffer←P2460, 0, (word) RasterGetBufferColorOperator←P2400,
0, (word) RasterMoveViewRectangle←P2340, 0, (word) IsAllInteger←P2280,
0, (word) RasterViewClip←P2220, 0, (word) RasterGetTransformation←P2160,
0, (word) RasterViewClipRectangleI←P2100, 0, (word) RasterViewTranslateI←P2040,
0, (word) RasterViewReset←P1980, 0, (word) RasterDoWithBuffer←P1920,
0, (word) IntegerTranslation←P1860, 0, (word) RasterTestViewRectangle←P1800,
0, (word) RasterGetBounds←P1740, 0, (word) SetDeviceClipBox←P1680,
0, (word) GetDeviceClipBox←P1620, 0, (word) GetClipper←P1560,
0, (word) GetContainingBox←P1500, 0, (word) RasterMaskPixel←P1440,
0, (word) RasterDrawBitmap←P1380, 0, (word) ClippedBounds←P1320,
0, (word) GetSampleMapClippedDisplacedBox←P1260, 0, (word) RasterMaskBitmap←P1200,
0, (word) RasterMaskDashedStroke←P1140, 0, (word) RasterMaskStroke←P1080,
0, (word) RasterMaskVector←P1020, 0, (word) PenFromState←P960,
0, (word) RasterMaskFill←P840, 0, (word) ContextFromInterchangeState←P780,
0, (word) GetInterchangeState←P720, 0, (word) DoWithDevice←P660,
0, (word) GetDevice←P600, 0, (word) Validate←P480,
0, (word) ValidateIfNeeded←P420, 0, (word) ScaleSnap←P360,
0, (word) GetColorViewToDevice←P300, 0, (word) NoteStateChanges←P240,
0, (word) ImagerRasterImpl←P0, 0, (word) 2147483647,
(word) 2147483647, (word) 2147483648, (word) 2147483648, (word) 2147483648,
(word) 2147483648, (word) 2147483647, (word) 2147483647, {0}
};
static void NoName←Q11628()
{
register ptr gf←c0786 = (ptr) &globalframe;
word var←c99484;
(* (( (ptr) gf←c0786)+11) ) = (word) XR←GetTypeIndex((word) &string1, 0, (word) &string2);
(* (( (ptr) gf←c0786)+13) ) = (word) XR←GetTypeIndex((word) &string3, 0, (word) &string4);
(* (( (ptr) gf←c0786)+14) ) = (word) XR←GetTypeIndex((word) &string5, 0, (word) &string6);
(* (( (ptr) gf←c0786)+15) ) = (word) XR←GetTypeIndex((word) &string7, 0, (word) &string8);
(* (( (ptr) gf←c0786)+16) ) = (word) XR←GetTypeIndexS((word) (&string9));
(* (( (ptr) gf←c0786)+19) ) = (word) XR←GetTypeIndex((word) &string10, 0, (word) &string8);
(* (( (ptr) gf←c0786)+21) ) = (word) XR←GetTypeIndexS((word) (&string11));
(* (( (ptr) gf←c0786)+23) ) = (word) XR←GetTypeIndex((word) &string12, 0, (word) &string13);
(* (( (ptr) gf←c0786)+27) ) = (word) XR←GetTypeIndex((word) &string14, 0, (word) &string15);
(* (( (ptr) gf←c0786)+28) ) = (word) XR←GetTypeIndex((word) &string16, 0, (word) &string17);
(* (( (ptr) gf←c0786)+29) ) = (word) XR←GetTypeIndex((word) &string18, 0, (word) &string19);
(* (ptr) (( (bPt) gf←c0786)+136) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+19) ), (word) &string20);
(* (ptr) (( (bPt) gf←c0786)+140) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+15) ), (word) &string21);
(* (ptr) (( (bPt) gf←c0786)+144) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+19) ), (word) &string22);
(* (ptr) (( (bPt) gf←c0786)+148) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+15) ), (word) &string23);
(* (ptr) (( (bPt) gf←c0786)+152) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+19) ), (word) &string24);
(* (ptr) (( (bPt) gf←c0786)+156) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+19) ), (word) &string25);
(* (ptr) (( (bPt) gf←c0786)+160) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0786)+19) ), (word) &string26);
(void) XR←DeclareGlobalFrame((word) "ImagerRasterImpl", &globalframe, (word) XR←GetTypeIndex((word) &string27, 0, (word) &string28)
, (word) (( (bPt) gf←c0786)+660)/* var←c92636 */ );
var←c99484 = (word) XR←ImportInterface((word) &string29, (word) XR←GetTypeIndexS((word) (&string30)), 84);
(* (( (ptr) gf←c0786)+179)/* var←c93532 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 793603);
(void) XR←ImportProcS(var←c99484, 530946);
(void) XR←ImportProcS(var←c99484, 529666);
(void) XR←ImportProcS(var←c99484, 272129);
(void) XR←ImportProcS(var←c99484, 796674);
(void) XR←ImportProcS(var←c99484, 791298);
(void) XR←ImportProcS(var←c99484, 266241);
(void) XR←ImportProcS(var←c99484, 526338);
(void) XR←ImportProcS(var←c99484, 1326597);
(void) XR←ImportProcS(var←c99484, 536578);
(void) XR←ImportProcS(var←c99484, 526594);
var←c99484 = (word) XR←ImportInterface((word) "ImagerDevice", (word) XR←GetTypeIndexS((word) (&string31)), 2);
(* (( (ptr) gf←c0786)+191)/* var←c96476 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 68157444);
var←c99484 = (word) XR←ImportInterface((word) "ImagerDeviceInterchange", (word) XR←GetTypeIndexS((word) (&string32)), 2);
(* (( (ptr) gf←c0786)+181)/* var←c93852 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 262401);
(void) XR←ImportProcS(var←c99484, 67108864);
var←c99484 = (word) XR←ImportInterface((word) "ImagerDeviceWorks", (word) XR←GetTypeIndexS((word) (&string33)), 23);
(* (( (ptr) gf←c0786)+189)/* var←c96188 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 1310725);
var←c99484 = (word) XR←ImportInterface((word) &string34, (word) XR←GetTypeIndexS((word) (&string35)), 26);
(* (( (ptr) gf←c0786)+193)/* var←c97020 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67636226);
(void) XR←ImportProcS(var←c99484, 67635970);
(void) XR←ImportProcS(var←c99484, 134744578);
var←c99484 = (word) XR←ImportInterface((word) "ImagerFontWorks", (word) XR←GetTypeIndexS((word) (&string36)), 3);
(* (( (ptr) gf←c0786)+194)/* var←c97052 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 786435);
var←c99484 = (word) XR←ImportInterface((word) "ImagerManhattan", (word) XR←GetTypeIndexS((word) (&string37)), 24);
(* (( (ptr) gf←c0786)+182)/* var←c94236 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67638530);
(void) XR←ImportProcS(var←c99484, 268700673);
(void) XR←ImportProcS(var←c99484, 68425218);
(void) XR←ImportProcS(var←c99484, 67639042);
(void) XR←ImportProcS(var←c99484, 68158209);
(void) XR←ImportProcS(var←c99484, 1577731);
(void) XR←ImportProcS(var←c99484, 67372545);
(void) XR←ImportProcS(var←c99484, 263425);
var←c99484 = (word) XR←ImportInterface((word) "ImagerPenExtras", (word) XR←GetTypeIndexS((word) (&string38)), 1);
(* (( (ptr) gf←c0786)+183)/* var←c94364 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 68681732);
var←c99484 = (word) XR←ImportInterface((word) "ImagerPixelArray", (word) XR←GetTypeIndexS((word) (&string39)), 13);
(* (( (ptr) gf←c0786)+186)/* var←c95004 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67633922);
var←c99484 = (word) XR←ImportInterface((word) "ImagerPrivate", (word) XR←GetTypeIndexS((word) (&string40)), 25);
(* (( (ptr) gf←c0786)+178)/* var←c92988 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 1837063);
(void) XR←ImportProcS(var←c99484, 1836549);
(void) XR←ImportProcS(var←c99484, 530434);
(void) XR←ImportProcS(var←c99484, 530178);
(void) XR←ImportProcS(var←c99484, 1054212);
(void) XR←ImportProcS(var←c99484, 135794693);
(void) XR←ImportProcS(var←c99484, 1313028);
(void) XR←ImportProcS(var←c99484, 1575427);
(void) XR←ImportProcS(var←c99484, 2098950);
(void) XR←ImportProcS(var←c99484, 1310981);
(void) XR←ImportProcS(var←c99484, 786435);
var←c99484 = (word) XR←ImportInterface((word) "ImagerSample", (word) XR←GetTypeIndexS((word) (&string41)), 60);
(* (( (ptr) gf←c0786)+190)/* var←c96380 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 268801);
(void) XR←ImportProcS(var←c99484, 68425474);
var←c99484 = (word) XR←ImportInterface((word) "ImagerScanConverter", (word) XR←GetTypeIndexS((word) (&string42)), 20);
(* (( (ptr) gf←c0786)+187)/* var←c95644 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 262657);
(void) XR←ImportProcS(var←c99484, 68685571);
(void) XR←ImportProcS(var←c99484, 1836036);
(void) XR←ImportProcS(var←c99484, 67109120);
var←c99484 = (word) XR←ImportInterface((word) &string43, (word) XR←GetTypeIndexS((word) (&string44)), 41);
(* (( (ptr) gf←c0786)+177)/* var←c92956 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 1583110);
(void) XR←ImportProcS(var←c99484, 1582851);
(void) XR←ImportProcS(var←c99484, 1058308);
(void) XR←ImportProcS(var←c99484, 1058052);
(void) XR←ImportProcS(var←c99484, 1057796);
(void) XR←ImportProcS(var←c99484, 533250);
(void) XR←ImportProcS(var←c99484, 795139);
(void) XR←ImportProcS(var←c99484, 532738);
(void) XR←ImportProcS(var←c99484, 794626);
(void) XR←ImportProcS(var←c99484, 794370);
(void) XR←ImportProcS(var←c99484, 531970);
(void) XR←ImportProcS(var←c99484, 793858);
(void) XR←ImportProcS(var←c99484, 269313);
(void) XR←ImportProcS(var←c99484, 793347);
(void) XR←ImportProcS(var←c99484, 268801);
(void) XR←ImportProcS(var←c99484, 134748418);
(void) XR←ImportProcS(var←c99484, 792578);
(void) XR←ImportProcS(var←c99484, 792322);
(void) XR←ImportProcS(var←c99484, 529922);
(void) XR←ImportProcS(var←c99484, 791810);
(void) XR←ImportProcS(var←c99484, 529410);
(void) XR←ImportProcS(var←c99484, 791298);
(void) XR←ImportProcS(var←c99484, 528898);
(void) XR←ImportProcS(var←c99484, 67375361);
(void) XR←ImportProcS(var←c99484, 67375105);
(void) XR←ImportProcS(var←c99484, 67374849);
(void) XR←ImportProcS(var←c99484, 67374593);
(void) XR←ImportProcS(var←c99484, 67636482);
(void) XR←ImportProcS(var←c99484, 67636226);
(void) XR←ImportProcS(var←c99484, 527106);
(void) XR←ImportProcS(var←c99484, 526850);
(void) XR←ImportProcS(var←c99484, 526594);
(void) XR←ImportProcS(var←c99484, 526338);
(void) XR←ImportProcS(var←c99484, 788227);
(void) XR←ImportProcS(var←c99484, 787971);
(void) XR←ImportProcS(var←c99484, 525570);
(void) XR←ImportProcS(var←c99484, 67634178);
var←c99484 = (word) XR←ImportInterface((word) "ImagerTransformation", (word) XR←GetTypeIndexS((word) (&string45)), 55);
(* (( (ptr) gf←c0786)+175)/* var←c92796 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67634177);
(void) XR←ImportProcS(var←c99484, 67897347);
(void) XR←ImportProcS(var←c99484, 269756930);
(void) XR←ImportProcS(var←c99484, 270849);
(void) XR←ImportProcS(var←c99484, 529666);
(void) XR←ImportProcS(var←c99484, 270806278);
(void) XR←ImportProcS(var←c99484, 67382273);
(void) XR←ImportProcS(var←c99484, 269757186);
(void) XR←ImportProcS(var←c99484, 1054980);
(void) XR←ImportProcS(var←c99484, 792578);
(void) XR←ImportProcS(var←c99484, 67371521);
(void) XR←ImportProcS(var←c99484, 67635458);
(void) XR←ImportProcS(var←c99484, 262401);
(void) XR←ImportProcS(var←c99484, 529410);
(void) XR←ImportProcS(var←c99484, 794626);
(void) XR←ImportProcS(var←c99484, 67645698);
(void) XR←ImportProcS(var←c99484, 793602);
(void) XR←ImportProcS(var←c99484, 794114);
(void) XR←ImportProcS(var←c99484, 135013122);
(void) XR←ImportProcS(var←c99484, 1319173);
(void) XR←ImportProcS(var←c99484, 67371777);
var←c99484 = (word) XR←ImportInterface((word) "ImagerTypeface", (word) XR←GetTypeIndexS((word) (&string46)), 12);
(* (( (ptr) gf←c0786)+180)/* var←c93628 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67371521);
(void) XR←ImportProcS(var←c99484, 67634178);
var←c99484 = (word) XR←ImportInterface((word) "Real", (word) XR←GetTypeIndexS((word) (&string47)), 11);
(* (( (ptr) gf←c0786)+184)/* var←c94620 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67371521);
var←c99484 = (word) XR←ImportInterface((word) "RealFns", (word) XR←GetTypeIndexS((word) (&string48)), 36);
(* (( (ptr) gf←c0786)+188)/* var←c95740 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67904259);
var←c99484 = (word) XR←ImportInterface((word) "ImagerSwitches", (word) XR←GetTypeIndexS((word) (&string49)), 8);
(* (( (ptr) gf←c0786)+176)/* var←c92892 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 68157444);
var←c99484 = (word) XR←ImportInterface((word) "SF", (word) XR←GetTypeIndexS((word) (&string50)), 19);
(* (( (ptr) gf←c0786)+185)/* var←c94844 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 135267074);
(void) XR←ImportProcS(var←c99484, 135266818);
(void) XR←ImportProcS(var←c99484, 270012418);
(void) XR←ImportProcS(var←c99484, 135267842);
(void) XR←ImportProcS(var←c99484, 135267330);
(void) XR←ImportProcS(var←c99484, 68160001);
(void) XR←ImportProcS(var←c99484, 270535426);
(void) XR←ImportProcS(var←c99484, 69209090);
(void) XR←ImportProcS(var←c99484, 69210370);
(void) XR←ImportProcS(var←c99484, 135270145);
(void) XR←ImportProcS(var←c99484, 68686338);
(void) XR←ImportProcS(var←c99484, 68159745);
var←c99484 = (word) XR←ImportInterface((word) "Vector2", (word) XR←GetTypeIndexS((word) (&string51)), 22);
(* (( (ptr) gf←c0786)+192)/* var←c96796 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 135005698);
(void) XR←ImportProcS(var←c99484, 135006210);
var←c99484 = (word) XR←ImportInterface((word) "Scaled", (word) XR←GetTypeIndexS((word) (&string52)), 19);
(* (( (ptr) gf←c0786)+195)/* var←c97244 */ ) = var←c99484;
(void) XR←ImportProcS(var←c99484, 67371777);
(void) XR←ImportProcS(var←c99484, 67375105);
var←c99484 = (word) XR←ExportInterface((word) "ImagerRaster", (word) XR←GetTypeIndexS((word) (&string53)), 13);
(* (( (ptr) gf←c0786)+196)/* var←c99516 */ ) = var←c99484;
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+364)/* var←c91452 */ , 67371009, (word) "CreateClass");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+356)/* var←c91420 */ , 68419845, (word) "Create");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+612)/* var←c92444 */ , 67371521, (word) "GetDevice");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+604)/* var←c92412 */ , 1573635, (word) "DoWithDevice");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+500)/* var←c91996 */ , 269222914, (word) "GetContainingBox");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+492)/* var←c91964 */ , 67372289, (word) "GetClipper");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+484)/* var←c91932 */ , 268699137, (word) "GetDeviceClipBox");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+476)/* var←c91900 */ , 1312514, (word) "SetDeviceClipBox");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+164)/* var←c90652 */ , 67635202, (word) "SetInterceptor");
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+172)/* var←c90684 */ , 67373313, (word) "InterceptorInEffect")
;
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+596)/* var←c92380 */ , 67373569, (word) "GetInterchangeState")
;
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+588)/* var←c92348 */ , 67635970, (word) "ContextFromInterchangeState")
;
(void) XR←ExportProcS(var←c99484, (word) (( (bPt) gf←c0786)+316)/* var←c91260 */ , 67374081, (word) "GetFontAtom");
var←c99484 = (word) XR←ExportInterface((word) &string29, (word) XR←GetTypeIndexS((word) (&string30)), 84);
(* (( (ptr) gf←c0786)+197)/* var←c99548 */ ) = var←c99484;
(void) XR←ExportType((word) "ClassRep", (word) XR←GetTypeIndexS((word) (&string54)), (word) XR←GetTypeIndex((word) &string1, 0, (word) &string2)
);
(void) XR←ExportType((word) "StateRep", (word) XR←GetTypeIndexS((word) (&string55)), (word) XR←GetTypeIndex((word) &string3, 0, (word) &string4)
);
var←c99484 = (word) XR←ExportInterface((word) &string34, (word) XR←GetTypeIndexS((word) (&string35)), 26);
(* (( (ptr) gf←c0786)+197)/* var←c99548 */ ) = var←c99484;
(void) XR←ExportType((word) "TypefaceRep", (word) XR←GetTypeIndexS((word) (&string56)), (word) XR←GetTypeIndex((word) &string57, 0, (word) &string58)
);
var←c99484 = (word) XR←ExportInterface((word) &string43, (word) XR←GetTypeIndexS((word) (&string44)), 41);
(* (( (ptr) gf←c0786)+197)/* var←c99548 */ ) = var←c99484;
(void) XR←ExportType((word) "RasterDataRep", (word) XR←GetTypeIndexS((word) (&string59)), (word) XR←GetTypeIndex((word) &string5, 0, (word) &string6)
);
}
static void ImagerRasterImpl←P0(formal←c0106, formal←c0101)
word formal←c0106;
word formal←c0101;
{
register ptr gf←c99580 = (ptr) &globalframe;
/* ImagerRasterImpl: */
SOURCE(2979, 48443)
/* 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(5588, 58)
{
word pd60;
pd60 = (* (( (ptr) (* (( (ptr) gf←c99580)+175)/* var←c92796 */ ))+7) );
(* (( (ptr) gf←c99580)+4)/* identity←v5156 */ ) = (word) ( *( (fPt) ((* (ptr) pd60 ))))((* (ptr) (&fc61) ), pd60);
};
SOURCE(7832, 250)
{
word var←c92828;
{
word var←c92860;
var←c92860 = XR←NewObject(4, (* (( (ptr) gf←c99580)+21) ));
(* (ptr) var←c92860 ) = (* (ptr) &fc62 );
var←c92828 = var←c92860;
};
{
word pd63;
word idx64;
pd63 = (* (( (ptr) (* (( (ptr) gf←c99580)+176)/* var←c92892 */ ))+4) );
(* (( (ptr) gf←c99580)+5)/* a←v5436 */ ) = (
idx64 = (word) ( *( (fPt) ((* (ptr) pd63 ))))(0, (* (( (ptr) gf←c99580)+37) ), (* (( (ptr) gf←c99580)+36) ), var←c92828, pd63)
,
BCK(idx64, 1)
);
};
};
SOURCE(23655, 24)
{
word x65;
word x67;
*(float*)(( (ptr) gf←c99580)+6)/* fuzz←v6220 */ = (
x65 = (* (ptr) &fc61 ), *(float*)&x65
) / (
x67 = (* (ptr) &fc66 ), *(float*)&x67
);
};
SOURCE(29773, 26)
{
float tf68;
(* (( (ptr) gf←c99580)+7)/* worryReal←v6472 */ ) = (
tf68 = (float)(unsigned)16382, *(word*)&tf68
);
};
SOURCE(29801, 38)
(* (( (ptr) gf←c99580)+8)/* bigTranslate←v6500 */ ) = (* (ptr) &fc69 );
SOURCE(33700, 2700)
{
word var←c92924;
var←c92924 = XR←NewObject(280, (* (( (ptr) gf←c99580)+11) ));
(* (ptr) var←c92924 ) = (* (( (ptr) gf←c99580)+35) );
(* (( (ptr) var←c92924)+1) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+8) );
(* (( (ptr) var←c92924)+2) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+9) );
(* (( (ptr) var←c92924)+3) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+10) );
(* (( (ptr) var←c92924)+4) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+11) );
(* (( (ptr) var←c92924)+5) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+12) );
(* (( (ptr) var←c92924)+6) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+13) );
(* (( (ptr) var←c92924)+7) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+14) );
(* (( (ptr) var←c92924)+8) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+15) );
(* (( (ptr) var←c92924)+9) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+16) );
(* (( (ptr) var←c92924)+10) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+17) );
(* (( (ptr) var←c92924)+11) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+18) );
(* (( (ptr) var←c92924)+12) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+19) );
(* (( (ptr) var←c92924)+13) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+20) );
(* (( (ptr) var←c92924)+14) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+21) );
(* (( (ptr) var←c92924)+15) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+22) );
(* (( (ptr) var←c92924)+16) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+23) );
(* (( (ptr) var←c92924)+17) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+24) );
(* (( (ptr) var←c92924)+18) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+25) );
(* (( (ptr) var←c92924)+19) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+26) );
(* (( (ptr) var←c92924)+20) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+27) );
(* (( (ptr) var←c92924)+21) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+28) );
(* (( (ptr) var←c92924)+22) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+29) );
(* (( (ptr) var←c92924)+23) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+30) );
(* (( (ptr) var←c92924)+24) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+31) );
(* (( (ptr) var←c92924)+25) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+32) );
(* (( (ptr) var←c92924)+26) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+33) );
(* (( (ptr) var←c92924)+27) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+34) );
(* (( (ptr) var←c92924)+28) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+35) );
(* (( (ptr) var←c92924)+29) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+36) );
(* (( (ptr) var←c92924)+30) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+37) );
(* (( (ptr) var←c92924)+31) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+38) );
(* (( (ptr) var←c92924)+32) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+39) );
(* (( (ptr) var←c92924)+33) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+40) );
(* (( (ptr) var←c92924)+34) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+41) );
(* (( (ptr) var←c92924)+35) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+42) );
(* (( (ptr) var←c92924)+36) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+43) );
(* (( (ptr) var←c92924)+37) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+177)/* var←c92956 */ ))+44) );
(* (( (ptr) var←c92924)+38) ) = (word) (( (bPt) gf←c99580)+300)/* var←c91196 */ ;
(* (( (ptr) var←c92924)+39) ) = (word) (( (bPt) gf←c99580)+292)/* var←c91164 */ ;
(* (( (ptr) var←c92924)+40) ) = (word) (( (bPt) gf←c99580)+580)/* var←c92316 */ ;
(* (( (ptr) var←c92924)+41) ) = (word) (( (bPt) gf←c99580)+348)/* var←c91388 */ ;
(* (( (ptr) var←c92924)+42) ) = (word) (( (bPt) gf←c99580)+556)/* var←c92220 */ ;
(* (( (ptr) var←c92924)+43) ) = (word) (( (bPt) gf←c99580)+508)/* var←c92028 */ ;
(* (( (ptr) var←c92924)+44) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+4) );
(* (( (ptr) var←c92924)+45) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+5) );
(* (( (ptr) var←c92924)+46) ) = (word) (( (bPt) gf←c99580)+340)/* var←c91356 */ ;
(* (( (ptr) var←c92924)+47) ) = (word) (( (bPt) gf←c99580)+564)/* var←c92252 */ ;
(* (( (ptr) var←c92924)+48) ) = (word) (( (bPt) gf←c99580)+548)/* var←c92188 */ ;
(* (( (ptr) var←c92924)+49) ) = (word) (( (bPt) gf←c99580)+540)/* var←c92156 */ ;
(* (( (ptr) var←c92924)+50) ) = (word) (( (bPt) gf←c99580)+516)/* var←c92060 */ ;
(* (( (ptr) var←c92924)+51) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+11) );
(* (( (ptr) var←c92924)+52) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+14) );
(* (( (ptr) var←c92924)+53) ) = (word) (( (bPt) gf←c99580)+444)/* var←c91772 */ ;
(* (( (ptr) var←c92924)+54) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+13) );
(* (( (ptr) var←c92924)+55) ) = (word) (( (bPt) gf←c99580)+468)/* var←c91868 */ ;
(* (( (ptr) var←c92924)+56) ) = (word) (( (bPt) gf←c99580)+436)/* var←c91740 */ ;
(* (( (ptr) var←c92924)+57) ) = (word) (( (bPt) gf←c99580)+428)/* var←c91708 */ ;
(* (( (ptr) var←c92924)+58) ) = (word) (( (bPt) gf←c99580)+404)/* var←c91612 */ ;
(* (( (ptr) var←c92924)+59) ) = (word) (( (bPt) gf←c99580)+420)/* var←c91676 */ ;
(* (( (ptr) var←c92924)+60) ) = (word) (( (bPt) gf←c99580)+412)/* var←c91644 */ ;
(* (( (ptr) var←c92924)+61) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+20) );
(* (( (ptr) var←c92924)+62) ) = (word) (( (bPt) gf←c99580)+388)/* var←c91548 */ ;
(* (( (ptr) var←c92924)+63) ) = (word) (( (bPt) gf←c99580)+460)/* var←c91836 */ ;
(* (( (ptr) var←c92924)+64) ) = (word) (( (bPt) gf←c99580)+380)/* var←c91516 */ ;
(* (( (ptr) var←c92924)+65) ) = (word) (( (bPt) gf←c99580)+372)/* var←c91484 */ ;
(* (( (ptr) var←c92924)+66) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+26) );
(* (( (ptr) var←c92924)+67) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+27) );
(* (( (ptr) var←c92924)+68) ) = (* (( (ptr) (* (( (ptr) gf←c99580)+178)/* var←c92988 */ ))+28) );
(* (( (ptr) gf←c99580)+9)/* rasterClassTemplate←v6640 */ ) = var←c92924;
};
SOURCE(51431, 549)
{
word var←c93020;
var←c93020 = XR←NewObject(60, (* (( (ptr) gf←c99580)+23) ));
(* (ptr) var←c93020 ) = (word) (( (bPt) gf←c99580)+284)/* var←c91132 */ ;
(* (( (ptr) var←c93020)+1) ) = (word) (( (bPt) gf←c99580)+276)/* var←c91100 */ ;
(* (( (ptr) var←c93020)+2) ) = (word) (( (bPt) gf←c99580)+268)/* var←c91068 */ ;
(* (( (ptr) var←c93020)+3) ) = (word) (( (bPt) gf←c99580)+260)/* var←c91036 */ ;
(* (( (ptr) var←c93020)+4) ) = (word) (( (bPt) gf←c99580)+252)/* var←c91004 */ ;
(* (( (ptr) var←c93020)+5) ) = (word) (( (bPt) gf←c99580)+244)/* var←c90972 */ ;
(* (( (ptr) var←c93020)+6) ) = (word) (( (bPt) gf←c99580)+236)/* var←c90940 */ ;
(* (( (ptr) var←c93020)+7) ) = (word) (( (bPt) gf←c99580)+228)/* var←c90908 */ ;
(* (( (ptr) var←c93020)+8) ) = (word) (( (bPt) gf←c99580)+220)/* var←c90876 */ ;
(* (( (ptr) var←c93020)+9) ) = (word) (( (bPt) gf←c99580)+212)/* var←c90844 */ ;
(* (( (ptr) var←c93020)+10) ) = (word) (( (bPt) gf←c99580)+204)/* var←c90812 */ ;
(* (( (ptr) var←c93020)+11) ) = (word) (( (bPt) gf←c99580)+196)/* var←c90780 */ ;
(* (( (ptr) var←c93020)+12) ) = (word) (( (bPt) gf←c99580)+188)/* var←c90748 */ ;
(* (( (ptr) var←c93020)+13) ) = (word) (( (bPt) gf←c99580)+180)/* var←c90716 */ ;
(* (( (ptr) gf←c99580)+10)/* modifiedDeviceClass←v7508 */ ) = var←c93020;
};
}
static void NoteStateChanges←P240(state←v8716)
word state←v8716;
{
word rasterData←v17460;
word changed←v17488;
/* NoteStateChanges: */
SOURCE(7291, 514)
SOURCE(7333, 41)
rasterData←v17460 = (* (( (ptr) state←v8716)+40) );
SOURCE(7376, 48)
changed←v17488 = (* (( (ptr) state←v8716)+1) );
SOURCE(7426, 38)
(* (( (ptr) state←v8716)+1) ) = 0;
SOURCE(7466, 89)
if ((int)changed←v17488<0) {
SOURCE(7486, 33)
(* (( (ptr) rasterData←v17460) + 1) ) &= 3221225471;
SOURCE(7521, 34)
(* (( (ptr) rasterData←v17460)+18) ) = 0;
};
SOURCE(7558, 58)
if ((((unsigned)changed←v17488 << 3) >> 31)) {
SOURCE(7580, 36)
(* (( (ptr) rasterData←v17460) + 1) ) &= 3758096383;
};
SOURCE(7618, 64)
if ((((unsigned)changed←v17488 << 4) >> 31)) {
SOURCE(7643, 39)
(* (( (ptr) rasterData←v17460) + 1) ) &= 4026531839;
};
SOURCE(7684, 65)
if ((((unsigned)changed←v17488 << 1) >> 31)) {
SOURCE(7708, 41)
(* (( (ptr) rasterData←v17460) + 1) ) &= 2147483647;
};
SOURCE(7751, 54)
if ((((unsigned)changed←v17488 << 2) >> 31)) {
SOURCE(7772, 33)
(* (( (ptr) rasterData←v17460) + 1) ) &= 3221225471;
};
}
static word GetColorViewToDevice←P300(state←v8796)
word state←v8796;
{
register ptr gf←c99612 = (ptr) &globalframe;
word var←c8840;
/* GetColorViewToDevice: */
SOURCE(8085, 1061)
SOURCE(8156, 948)
{
word var←c93052;
var←c93052 = (* (( (ptr) state←v8796)+36) );
if ((var←c93052 == 0)) {
goto lab←L100000;
};
if (((* (ptr) var←c93052 ) == 2)) {
{
word color←v17532;
color←v17532 = var←c93052;
SOURCE(8220, 887)
{
word r←v17576;
SOURCE(8222, 57)
{
word var←c93084;
var←c93084 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←c99612)+176)/* var←c92892 */ ))+10) ) );
if ((var←c93084 == 0)) {
goto lab←L100001;
};
if (((* (( (ptr) gf←c99612)+21) ) == XR←GetReferentType(var←c93084))) {
{
word rr←v17620;
rr←v17620 = var←c93084;
r←v17576 = (* (ptr) rr←v17620 );
};
}
else {
lab←L100001: ;
r←v17576 = (* (ptr) &fc70 );
};
};
SOURCE(8315, 789)
{
word x71;
word x72;
word x73;
word x74;
if ( ( ((
x71 = r←v17576, *(float*)&x71
) > (
x72 = (* (ptr) &fc70 ), *(float*)&x72
)) ? ((
x73 = r←v17576, *(float*)&x73
) <= (
x74 = (* (ptr) &fc61 ), *(float*)&x74
)) : 0 ) ) {
SOURCE(8339, 765)
{
word rasterData←v17676;
word m←v17704;
word xScale←v17732;
word yScale←v17760;
W2 origin←v17788;
SOURCE(8341, 41)
rasterData←v17676 = (* (( (ptr) state←v8796)+40) );
SOURCE(8384, 55)
m←v17704 = (* (( (ptr) rasterData←v17676)+20) );
SOURCE(8441, 26)
xScale←v17732 = (* (ptr) &fc61 );
yScale←v17760 = (* (ptr) &fc61 );
SOURCE(8490, 87)
if ((m←v17704 == 0)) {
SOURCE(8506, 71)
{
/*1*/ word var←c93116;
/*1*/ {
/*1*/ word pd75;
/*1*/ pd75 = (* (( (ptr) (* (( (ptr) gf←c99612)+175)/* var←c92796 */ ))+7) );
/*1*/ var←c93116 = (word) ( *( (fPt) ((* (ptr) pd75 ))))((* (ptr) (&fc61) ), pd75);
/*1*/ };
/*1*/ (* (( (ptr) rasterData←v17676)+20) ) = var←c93116;
/*1*/ m←v17704 = var←c93116;
/*1*/ };
};
SOURCE(8579, 74)
{
word pd76;
pd76 = (* (( (ptr) (* (( (ptr) gf←c99612)+175)/* var←c92796 */ ))+37) );
(void) ( *( (fPt) ((* (ptr) pd76 ))))(m←v17704, (* (( (ptr) (* (( (ptr) color←v17532)+1) ))+4) ), (* (( (ptr) color←v17532)+2)
/*1*/ ), (* (( (ptr) state←v8796)+34) ), 0, pd76);
};
SOURCE(8655, 50)
{
W2 var←c0124;
{
/*1*/ W2 var←c93148;
/*1*/ var←c93148.f0 = (* (ptr) &fc70 );
/*1*/ var←c93148.f1 = (* (ptr) &fc70 );
/*1*/ {
/*1*/ word pd77;
/*1*/ pd77 = (* (( (ptr) (* (( (ptr) gf←c99612)+175)/* var←c92796 */ ))+39) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd77 ))))((word) &var←c0124, m←v17704, var←c93148, pd77);
/*1*/ };
/*1*/ };
origin←v17788 = var←c0124;
};
SOURCE(8707, 151)
{
word var←c93180;
var←c93180 = (* (( (ptr) m←v17704)+9) );
if ((var←c93180 == 1)) {
SOURCE(8733, 17)
/*1*/ {
/*1*/ float tf78;
/*1*/ word x79;
/*1*/ float tf80;
/*1*/ xScale←v17732 = (
/*1*/ tf80 = FABS((
/*1*/ x79 = (* (ptr) m←v17704 ), *(float*)&x79
/*1*/ ), tf78), *(word*)&tf80
/*1*/ );
/*1*/ };
SOURCE(8752, 18)
/*1*/ {
/*1*/ float tf81;
/*1*/ word x82;
/*1*/ float tf83;
/*1*/ yScale←v17760 = (
/*1*/ tf83 = FABS((
/*1*/ x82 = (* (( (ptr) m←v17704)+4) ), *(float*)&x82
/*1*/ ), tf81), *(word*)&tf83
/*1*/ );
/*1*/ };
/*1*/ }
else {
/*1*/ if ((var←c93180 == 2)) {
SOURCE(8780, 17)
/*1*/ {
/*1*/ float tf84;
/*1*/ word x85;
/*1*/ float tf86;
/*1*/ xScale←v17732 = (
/*1*/ tf86 = FABS((
/*1*/ x85 = (* (( (ptr) m←v17704)+1) ), *(float*)&x85
/*1*/ ), tf84), *(word*)&tf86
/*1*/ );
/*1*/ };
SOURCE(8799, 18)
/*1*/ {
/*1*/ float tf87;
/*1*/ word x88;
/*1*/ float tf89;
/*1*/ yScale←v17760 = (
/*1*/ tf89 = FABS((
/*1*/ x88 = (* (( (ptr) m←v17704)+3) ), *(float*)&x88
/*1*/ ), tf87), *(word*)&tf89
/*1*/ );
/*1*/ };
/*1*/ }
/*1*/ else {
SOURCE(8831, 27)
/*1*/ return((* (( (ptr) state←v8796)+34) ));
/*1*/ };
/*1*/ };
};
SOURCE(8860, 24)
(* (W10Pt) m←v17704 ) = (* (W10Pt) (* (( (ptr) state←v8796)+34) ) );
SOURCE(8886, 66)
{
W2 var←c93212;
{
/*1*/ word x90;
/*1*/ *(float*)&var←c93212.f0 = - (
/*1*/ x90 = origin←v17788.f0, *(float*)&x90
/*1*/ );
/*1*/ };
{
/*1*/ word x91;
/*1*/ *(float*)&var←c93212.f1 = - (
/*1*/ x91 = origin←v17788.f1, *(float*)&x91
/*1*/ );
/*1*/ };
{
/*1*/ word pd92;
/*1*/ pd92 = (* (( (ptr) (* (( (ptr) gf←c99612)+175)/* var←c92796 */ ))+34) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd92 ))))(m←v17704, var←c93212, pd92);
/*1*/ };
};
SOURCE(8954, 85)
{
word var←c93244;
word var←c93276;
var←c93244 = (word) ScaleSnap←P360(xScale←v17732, r←v17576);
var←c93276 = (word) ScaleSnap←P360(yScale←v17760, r←v17576);
{
/*1*/ W2 var←c93308;
/*1*/ var←c93308.f0 = var←c93244;
/*1*/ var←c93308.f1 = var←c93276;
/*1*/ {
/*1*/ word pd93;
/*1*/ pd93 = (* (( (ptr) (* (( (ptr) gf←c99612)+175)/* var←c92796 */ ))+32) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd93 ))))(m←v17704, var←c93308, pd93);
/*1*/ };
/*1*/ };
};
SOURCE(9041, 50)
{
word pd94;
pd94 = (* (( (ptr) (* (( (ptr) gf←c99612)+175)/* var←c92796 */ ))+34) );
(void) ( *( (fPt) ((* (ptr) pd94 ))))(m←v17704, origin←v17788, pd94);
};
SOURCE(9093, 11)
return(m←v17704);
};
};
};
};
};
}
else {
lab←L100000: ;
};
};
SOURCE(9119, 27)
return((* (( (ptr) state←v8796)+34) ));
}
static word ScaleSnap←P360(s←v8900, r←v8928)
word s←v8900;
word r←v8928;
{
word v←v8972;
/* ScaleSnap: */
SOURCE(9152, 238)
SOURCE(9209, 154)
{
word x95;
word x97;
if (((
x95 = s←v8900, *(float*)&x95
) > (
x97 = (* (ptr) &fc96 ), *(float*)&x97
))) {
SOURCE(9225, 149)
{
word min←v17832;
word max←v17860;
word f←v17888;
word kf←v17916;
SOURCE(9227, 17)
{
word x98;
word x99;
*(float*)&min←v17832 = (
x98 = (* (ptr) &fc61 ), *(float*)&x98
) - (
x99 = r←v8928, *(float*)&x99
);
};
SOURCE(9246, 17)
{
word x100;
word x101;
*(float*)&max←v17860 = (
x100 = (* (ptr) &fc61 ), *(float*)&x100
) + (
x101 = r←v8928, *(float*)&x101
);
};
SOURCE(9265, 15)
{
word x102;
word x103;
*(float*)&f←v17888 = (
x102 = (* (ptr) &fc61 ), *(float*)&x102
) / (
x103 = s←v8900, *(float*)&x103
);
};
SOURCE(9282, 12)
kf←v17916 = f←v17888;
SOURCE(9296, 67)
{
register word noName←c93340 = 1;
if ((noName←c93340 > 4)) {
goto lab←L100002;
};
lab←L100005: ;
SOURCE(9314, 36)
{
word x104;
word x105;
word x106;
word x107;
if ( ( ((
x104 = kf←v17916, *(float*)&x104
) >= (
x105 = min←v17832, *(float*)&x105
)) ? ((
x106 = kf←v17916, *(float*)&x106
) <= (
x107 = max←v17860, *(float*)&x107
)) : 0 ) ) {
SOURCE(9339, 11)
return(kf←v17916);
};
};
SOURCE(9352, 11)
{
word x108;
word x109;
*(float*)&kf←v17916 = (
x108 = kf←v17916, *(float*)&x108
) + (
x109 = f←v17888, *(float*)&x109
);
};
if ((noName←c93340 >= 4)) {
goto lab←L100002;
};
noName←c93340 = (noName←c93340 + 1);
goto lab←L100005;
lab←L100002: ;
};
};
};
};
SOURCE(9377, 13)
return((* (ptr) &fc61 ));
}
static void ValidateIfNeeded←P420(state←v9032, needs←v9060)
word state←v9032;
word needs←v9060;
{
register ptr gf←c99644 = (ptr) &globalframe;
word rasterData←v17960;
word fix←v18100;
word var←c93660;
word f1←v88164;
/* ValidateIfNeeded: */
SOURCE(9394, 1693)
SOURCE(9450, 41)
rasterData←v17960 = (* (( (ptr) state←v9032)+40) );
SOURCE(10798, 56)
{
word f1←v88212;
word f2←v88240;
f1←v88212 = needs←v9060;
{
word f←v88288;
f←v88288 = (* (( (ptr) rasterData←v17960)+1) );
SOURCE(7241, 44)
f2←v88240 = (word) XRM←BITNOT(f←v88288);
};
SOURCE(7123, 59)
fix←v18100 = (word) XRM←BITAND(f1←v88212, f2←v88240);
};
SOURCE(10856, 39)
if ((((unsigned)fix←v18100 << 2) >> 31)) {
SOURCE(10880, 15)
SOURCE(10208, 93)
{
word var←c93500;
var←c93500 = (word) GetColorViewToDevice←P300(state←v9032);
{
word pd110;
pd110 = (* (ptr) (* (( (ptr) (* (ptr) rasterData←v17960 ))+4) ) );
(void) ( *( (fPt) ((* (ptr) pd110 ))))((* (ptr) rasterData←v17960 ), (* (( (ptr) state←v9032)+36) ), var←c93500, pd110)
;
};
};
SOURCE(10303, 35)
(* (( (ptr) rasterData←v17960) + 1) ) |= 536870912;
};
SOURCE(10897, 45)
if ((((unsigned)fix←v18100 << 3) >> 31)) {
SOURCE(10924, 18)
SOURCE(10377, 137)
if ((* (( (bPt) (* (( (ptr) (* (ptr) rasterData←v17960 ))+5) ))+3) ) & 020) {
SOURCE(10430, 84)
{
word pd111;
pd111 = (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v17960 ))+4) ))+1) );
(void) ( *( (fPt) ((* (ptr) pd111 ))))((* (ptr) rasterData←v17960 ), (unsigned) ( (int)(* (( (ptr) state←v9032)+12) ) != (int)0), pd111)
;
};
};
SOURCE(10516, 38)
(* (( (ptr) rasterData←v17960) + 1) ) |= 268435456;
};
SOURCE(10944, 52)
if ((int)fix←v18100<0) {
SOURCE(10973, 23)
SOURCE(10598, 153)
{
word device←v89804;
word viewClipper←v89832;
word clipperToDevice←v89860;
word clientClipper←v89888;
device←v89804 = (* (ptr) rasterData←v17960 );
viewClipper←v89832 = (* (( (ptr) rasterData←v17960)+3) );
clipperToDevice←v89860 = (* (( (ptr) state←v9032)+34) );
clientClipper←v89888 = (* (( (ptr) state←v9032)+37) );
{
word pd112;
pd112 = (* (ptr) (* (ptr) device←v89804 ) );
(void) ( *( (fPt) ((* (ptr) pd112 ))))(device←v89804, viewClipper←v89832, clipperToDevice←v89860, clientClipper←v89888, pd112)
;
};
};
SOURCE(10753, 40)
(* (( (ptr) rasterData←v17960) + 1) ) |= 2147483648;
};
SOURCE(10998, 39)
if ((((unsigned)fix←v18100 << 1) >> 31)) {
SOURCE(11019, 18)
{
word font←v18208;
font←v18208 = (* (( (ptr) state←v9032)+35) );
SOURCE(9552, 617)
if ((font←v18208 == 0)) {
SOURCE(9571, 97)
{
W3 var←c0152;
var←c0152.f0 = 71;
var←c0152.f1 = (* (( (ptr) gf←c99644)+34) );
var←c0152.f2 = 0;
(void) XR←RaiseError((* (ptr) (* (( (ptr) (* (( (ptr) gf←c99644)+179)/* var←c93532 */ ))+6) ) ), (word) &var←c0152);
};
}
else {
{
word typeface←v18236;
word charToDevice←v18264;
typeface←v18236 = (* (( (ptr) font←v18208)+1) );
charToDevice←v18264 = (* (( (ptr) rasterData←v17960)+19) );
SOURCE(9762, 299)
{
word pd114;
if (((* (( (ptr) rasterData←v17960)+18) ) == 0)) { goto then0113;};
pd114 = (* (( (ptr) (* (( (ptr) gf←c99644)+175)/* var←c92796 */ ))+53) );
if ((0 == (word) ( *( (fPt) ((* (ptr) pd114 ))))((* (( (ptr) rasterData←v17960)+18) ), (* (ptr) font←v18208 ), pd114))) {
then0113: ;
SOURCE(9888, 37)
(* (W10Pt) charToDevice←v18264 ) = (* (W10Pt) (* (( (ptr) state←v9032)+33) ) );
SOURCE(9927, 37)
{
W2 var←c93596;
var←c93596.f0 = (* (ptr) &fc70 );
var←c93596.f1 = (* (ptr) &fc70 );
{
word pd115;
pd115 = (* (( (ptr) (* (( (ptr) gf←c99644)+175)/* var←c92796 */ ))+36) );
(void) ( *( (fPt) ((* (ptr) pd115 ))))(charToDevice←v18264, var←c93596, pd115);
};
};
SOURCE(9966, 46)
{
word pd116;
pd116 = (* (( (ptr) (* (( (ptr) gf←c99644)+175)/* var←c92796 */ ))+24) );
(void) ( *( (fPt) ((* (ptr) pd116 ))))(charToDevice←v18264, (* (ptr) font←v18208 ), pd116);
};
SOURCE(10014, 47)
(* (( (ptr) rasterData←v17960)+18) ) = (* (ptr) font←v18208 );
};
};
SOURCE(10066, 69)
{
word pd117;
pd117 = (* (( (ptr) (* (( (ptr) gf←c99644)+180)/* var←c93628 */ ))+8) );
(* (( (ptr) rasterData←v17960)+4) ) = (word) ( *( (fPt) ((* (ptr) pd117 ))))(typeface←v18236, charToDevice←v18264, pd117)
;
};
SOURCE(10137, 32)
(* (( (ptr) rasterData←v17960) + 1) ) |= 1073741824;
};
};
};
};
SOURCE(11039, 48)
f1←v88164 = (* (( (ptr) rasterData←v17960)+1) );
SOURCE(7123, 59)
var←c93660 = (word) XRM←BITAND(f1←v88164, needs←v9060);
if ((var←c93660 != needs←v9060)) {
SOURCE(11087, 5)
(void) XR←RaiseUnnamedError();
};
}
static void Validate←P480(state←v9120, needs←v9148)
word state←v9120;
word needs←v9148;
{
word rasterData←v18292;
word var←c93724;
word f1←v88116;
/* Validate: */
SOURCE(11098, 239)
SOURCE(11146, 41)
rasterData←v18292 = (* (( (ptr) state←v9120)+40) );
SOURCE(11189, 68)
if (((* (( (ptr) state←v9120)+1) ) != 0)) {
SOURCE(11234, 23)
(void) NoteStateChanges←P240(state←v9120);
};
SOURCE(11259, 78)
f1←v88116 = (* (( (ptr) rasterData←v18292)+1) );
SOURCE(7123, 59)
var←c93724 = (word) XRM←BITAND(f1←v88116, needs←v9148);
if ((var←c93724 != needs←v9148)) {
SOURCE(11307, 30)
(void) ValidateIfNeeded←P420(state←v9120, needs←v9148);
};
}
static word GetDevice←P600(context←v9296)
word context←v9296;
{
register ptr gf←c99676 = (ptr) &globalframe;
word var←c9340;
word state←v18336;
/* GetDevice: */
SOURCE(11465, 355)
SOURCE(11465, 355)
var←c9340 = 0;
SOURCE(11534, 28)
state←v18336 = (* (( (ptr) context←v9296)+1) );
SOURCE(11564, 256)
if ((state←v18336 != 0)) {
SOURCE(11584, 239)
{
word rasterData←v18380;
SOURCE(11586, 41)
rasterData←v18380 = (* (( (ptr) state←v18336)+40) );
SOURCE(11629, 191)
if ((rasterData←v18380 != 0)) {
SOURCE(11656, 132)
if (((* (( (ptr) (* (ptr) rasterData←v18380 ))+4) ) == (* (( (ptr) gf←c99676)+10)/* modifiedDeviceClass←v7508 */ ))) {
SOURCE(11710, 80)
{
word iData←v18424;
SOURCE(11712, 53)
iData←v18424 = XR←Narrow((* (( (ptr) (* (ptr) rasterData←v18380 ))+7) ), (* (( (ptr) gf←c99676)+27) ));
SOURCE(11767, 21)
return((* (( (ptr) iData←v18424)+2) ));
};
};
SOURCE(11793, 27)
return((* (ptr) rasterData←v18380 ));
};
};
};
SOURCE(11465, 355)
return(var←c9340);
}
static void DoWithDevice←P660(context←v9400, bounds←v9428, formal←c0918)
word context←v9400;
W4 bounds←v9428;
word formal←c0918;
{
W9 var←c99708;
/* declaration of action←v9456 skipped */
register ptr gf←c99740 = (ptr) &globalframe;
/* declaration of var←c93788 skipped */
word state←v18468;
/* declaration of rasterData←v18496 skipped */
(* (( (ptr) &var←c99708)+4)/* action←v9456 */ ) = formal←c0918;
/* DoWithDevice: */
SOURCE(11830, 766)
{
word tmpAddr118;
tmpAddr118 = (word) (( (ptr) &var←c99708)+5)/* var←c93788 */ ;
(* (ptr) tmpAddr118 ) = ( ((word) (fPt) proc←P4872) );
(* (( (ptr) tmpAddr118) + 1) ) = 1;
};
SOURCE(11950, 28)
state←v18468 = (* (( (ptr) context←v9400)+1) );
SOURCE(11980, 41)
(* (( (ptr) &var←c99708)+7)/* rasterData←v18496 */ ) = (* (( (ptr) state←v18468)+40) );
SOURCE(12023, 26)
(void) Validate←P480(state←v18468, 2952790016);
SOURCE(12051, 545)
if (((* (( (ptr) (* (ptr) (* (( (ptr) &var←c99708)+7)/* rasterData←v18496 */ ) ))+4) ) == (* (( (ptr) gf←c99740)+10)/* modifiedDeviceClass←v7508 */ ))) {
SOURCE(12105, 401)
{
/* declaration of iData←v18540 skipped */
word interceptor←v18596;
SOURCE(12107, 53)
(* (( (ptr) &var←c99708)+8)/* iData←v18540 */ ) = XR←Narrow((* (( (ptr) (* (ptr) (* (( (ptr) &var←c99708)+7)/* rasterData←v18496 */ ) ))+7)
), (* (( (ptr) gf←c99740)+27) ));
SOURCE(12403, 44)
interceptor←v18596 = (* (( (ptr) (* (( (ptr) &var←c99708)+8)/* iData←v18540 */ ))+1) );
SOURCE(12449, 55)
{
word pd119;
pd119 = (* (ptr) interceptor←v18596 );
(void) ( *( (fPt) ((* (ptr) pd119 ))))(interceptor←v18596, bounds←v9428, (word) (( (bPt) &var←c99708)+20)/* var←c93788 */ , 0, pd119)
;
};
};
}
else {
SOURCE(12515, 81)
{
word pd120;
pd120 = (* (( (ptr) &var←c99708)+4)/* action←v9456 */ );
(void) ( *( (fPt) ((* (ptr) pd120 ))))((* (ptr) (* (( (ptr) &var←c99708)+7)/* rasterData←v18496 */ ) ), (* (( (ptr) (* (ptr) (* (
( (ptr) &var←c99708)+7)/* rasterData←v18496 */ ) ))+1) ), pd120);
};
};
}
static void proc←P4872(formal←c99772)
word formal←c99772;
{
formal←c99772 = (formal←c99772 - 20);
/* proc: */
SOURCE(12162, 13)
SOURCE(12177, 72)
(* (W5Pt) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c99772)+8) ))+2) ))+1) ) ) = (* (W5Pt) (* (( (ptr) (* (ptr) (* (( (ptr) formal←c99772)+7)
) ))+1) ) );
SOURCE(12251, 70)
{
word pd121;
pd121 = (* (( (ptr) formal←c99772)+4) );
(void) ( *( (fPt) ((* (ptr) pd121 ))))((* (( (ptr) (* (( (ptr) formal←c99772)+8) ))+2) ), (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c99772)+8)
))+2) ))+1) ), pd121);
};
SOURCE(12323, 75)
{
word var←c93820;
var←c93820 = (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c99772)+8) ))+2) ))+1) );
XR←FillWords(&(* (W5Pt) (var←c93820)), 5, 0);
};
}
static word GetInterchangeState←P720(context←v9604)
word context←v9604;
{
register ptr gf←c99804 = (ptr) &globalframe;
word iState←v9648;
word state←v18656;
/* GetInterchangeState: */
SOURCE(12669, 683)
SOURCE(12669, 683)
iState←v9648 = 0;
SOURCE(12773, 28)
state←v18656 = (* (( (ptr) context←v9604)+1) );
SOURCE(12803, 549)
if ((state←v18656 != 0)) {
SOURCE(12823, 534)
{
word rasterData←v18700;
SOURCE(12825, 41)
rasterData←v18700 = (* (( (ptr) state←v18656)+40) );
SOURCE(12868, 484)
if ((rasterData←v18700 != 0)) {
SOURCE(12895, 60)
(void) Validate←P480(state←v18656, 2684354560);
SOURCE(12957, 57)
{
word pd122;
pd122 = (* (( (ptr) (* (( (ptr) gf←c99804)+181)/* var←c93852 */ ))+4) );
iState←v9648 = (word) ( *( (fPt) ((* (ptr) pd122 ))))(pd122);
};
SOURCE(13016, 33)
(* (ptr) iState←v9648 ) = (* (ptr) rasterData←v18700 );
SOURCE(13051, 87)
(* (( (ptr) iState←v9648)+1) ) = (word) RasterGetTransformation←P2160(context←v9604, 0, 1);
SOURCE(13140, 89)
(* (( (ptr) iState←v9648)+2) ) = (word) RasterGetTransformation←P2160(context←v9604, 1, 2);
SOURCE(13231, 93)
(* (( (ptr) iState←v9648)+3) ) = (word) RasterGetTransformation←P2160(context←v9604, 2, 3);
SOURCE(13326, 26)
(* (( (ptr) iState←v9648)+4) ) = (* (( (ptr) state←v18656)+36) );
};
};
};
SOURCE(12669, 683)
return(iState←v9648);
}
static word ContextFromInterchangeState←P780(iState←v9708, scratch←v9736)
word iState←v9708;
word scratch←v9736;
{
register ptr gf←c99836 = (ptr) &globalframe;
word var←c9780;
word context←v18744;
word state←v18772;
word rasterData←v18800;
word charToDevice←v18828;
word cp←v18856;
word surfaceToDevice←v18940;
word viewToDevice←v18968;
word clientToDevice←v18996;
word viewClipper←v19024;
/* ContextFromInterchangeState: */
SOURCE(13364, 2077)
SOURCE(13492, 76)
context←v18744 = ( (scratch←v9736 == 0) ? XR←NewObject(16, (* (( (ptr) gf←c99836)+29) )) : scratch←v9736 ) ;
SOURCE(13570, 75)
if (((* (( (ptr) context←v18744)+1) ) == 0)) {
{
word var←c93916;
var←c93916 = XR←NewObject(164, (* (( (ptr) gf←c99836)+13) ));
(* (( (ptr) var←c93916)+2) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+3) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+5) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+6) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+7) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+8) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+9) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+10) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+13) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+14) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+15) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+16) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+17) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+18) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+20) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+23) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+24) ) = (* (ptr) &fc61 );
(* (( (ptr) var←c93916)+26) ) = (* (ptr) &fc96 );
(* (( (ptr) var←c93916)+27) ) = 2139095039;
(* (( (ptr) var←c93916)+28) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+29) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c93916)+30) ) = (* (ptr) &fc70 );
state←v18772 = var←c93916;
};
}
else {
state←v18772 = (* (( (ptr) context←v18744)+1) );
};
SOURCE(13647, 96)
if (((* (( (ptr) state←v18772)+40) ) == 0)) {
{
word var←c93948;
var←c93948 = XR←NewObject(84, (* (( (ptr) gf←c99836)+14) ));
(* (( (ptr) var←c93948)+6) ) = 2;
rasterData←v18800 = var←c93948;
};
}
else {
rasterData←v18800 = (* (( (ptr) state←v18772)+40) );
};
SOURCE(13745, 127)
{
word tc123;
word pd124;
if (((* (( (ptr) rasterData←v18800)+19) ) == 0)) {
pd124 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+7) );
tc123 = (word) ( *( (fPt) ((* (ptr) pd124 ))))((* (ptr) (&fc61) ), pd124);
}
else {
tc123 = (word) (* (( (ptr) rasterData←v18800)+19) );
};
charToDevice←v18828 = tc123;
};
SOURCE(13874, 98)
cp←v18856 = ( ((* (( (ptr) state←v18772)+32) ) == 0) ? XR←NewObject(20, (* (( (ptr) gf←c99836)+16) )) : (* (( (ptr) state←v18772)+32)
) ) ;
SOURCE(14175, 96)
{
word a←v88520;
word recycle←v88548;
a←v88520 = (* (( (ptr) iState←v9708)+3) );
recycle←v88548 = (* (( (ptr) rasterData←v18800)+2) );
SOURCE(14067, 59)
if ((recycle←v88548 != 0)) {
SOURCE(14089, 37)
{
word pd125;
pd125 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd125 ))))(recycle←v88548, pd125);
};
};
SOURCE(14128, 42)
{
word pd126;
pd126 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+13) );
surfaceToDevice←v18940 = (word) ( *( (fPt) ((* (ptr) pd126 ))))(a←v88520, 0, pd126);
};
};
SOURCE(14273, 95)
{
word a←v88444;
word recycle←v88472;
a←v88444 = (* (( (ptr) iState←v9708)+2) );
recycle←v88472 = (* (( (ptr) state←v18772)+34) );
SOURCE(14067, 59)
if ((recycle←v88472 != 0)) {
SOURCE(14089, 37)
{
word pd127;
pd127 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd127 ))))(recycle←v88472, pd127);
};
};
SOURCE(14128, 42)
{
word pd128;
pd128 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+13) );
viewToDevice←v18968 = (word) ( *( (fPt) ((* (ptr) pd128 ))))(a←v88444, surfaceToDevice←v18940, pd128);
};
};
SOURCE(14370, 95)
{
word a←v88368;
word recycle←v88396;
a←v88368 = (* (( (ptr) iState←v9708)+1) );
recycle←v88396 = (* (( (ptr) state←v18772)+33) );
SOURCE(14067, 59)
if ((recycle←v88396 != 0)) {
SOURCE(14089, 37)
{
word pd129;
pd129 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd129 ))))(recycle←v88396, pd129);
};
};
SOURCE(14128, 42)
{
word pd130;
pd130 = (* (( (ptr) (* (( (ptr) gf←c99836)+175)/* var←c92796 */ ))+13) );
clientToDevice←v18996 = (word) ( *( (fPt) ((* (ptr) pd130 ))))(a←v88368, viewToDevice←v18968, pd130);
};
};
SOURCE(14467, 51)
viewClipper←v19024 = (* (( (ptr) rasterData←v18800)+3) );
SOURCE(14520, 125)
if ((viewClipper←v19024 == 0)) {
SOURCE(14546, 54)
viewClipper←v19024 = XR←NewObject(20, (* (( (ptr) gf←c99836)+28) ));
}
else {
SOURCE(14600, 45)
{
word pd131;
pd131 = (* (( (ptr) (* (( (ptr) gf←c99836)+182)/* var←c94236 */ ))+9) );
(void) ( *( (fPt) ((* (ptr) pd131 ))))((* ((( (ptr) viewClipper←v19024)+4)) ), pd131);
};
};
SOURCE(14647, 86)
{
word pd132;
pd132 = (* (( (ptr) (* (( (ptr) gf←c99836)+182)/* var←c94236 */ ))+10) );
(* (( (ptr) viewClipper←v19024)+4) ) = (word) ( *( (fPt) ((* (ptr) pd132 ))))((* ((( (ptr) (* (( (ptr) (* (ptr) iState←v9708 ))+1)
))+4)) ), pd132);
};
SOURCE(14735, 62)
(* (W4Pt) viewClipper←v19024 ) = (* (W4Pt) (* (( (ptr) (* (ptr) iState←v9708 ))+1) ) );
SOURCE(14799, 16)
XR←FillWords(&(* (W21Pt) (rasterData←v18800)), 21, 0);
(* (( (ptr) rasterData←v18800)+6) ) = 2;
SOURCE(14864, 33)
(* (ptr) rasterData←v18800 ) = (* (ptr) iState←v9708 );
SOURCE(14899, 21)
(* (( (ptr) rasterData←v18800)+1) ) = 0;
SOURCE(14922, 44)
(* (( (ptr) rasterData←v18800)+2) ) = surfaceToDevice←v18940;
SOURCE(14968, 36)
(* (( (ptr) rasterData←v18800)+3) ) = viewClipper←v19024;
SOURCE(15006, 38)
(* (( (ptr) rasterData←v18800)+19) ) = charToDevice←v18828;
SOURCE(15049, 19)
(* (ptr) iState←v9708 ) = 0;
SOURCE(15070, 11)
(* (ptr) state←v18772 ) = 0;
(* (( (ptr) state←v18772)+1) ) = 0;
(* (( (ptr) state←v18772)+2) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+3) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+4) ) = 0;
(* (( (ptr) state←v18772)+5) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+6) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+7) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+8) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+9) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+10) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+11) ) = 0;
(* (( (ptr) state←v18772)+12) ) = 0;
(* (( (ptr) state←v18772)+13) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+14) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+15) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+16) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+17) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+18) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+19) ) = 0;
(* (( (ptr) state←v18772)+20) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+21) ) = 0;
(* (( (ptr) state←v18772)+22) ) = 0;
(* (( (ptr) state←v18772)+23) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+24) ) = (* (ptr) &fc61 );
(* (( (ptr) state←v18772)+25) ) = 0;
(* (( (ptr) state←v18772)+26) ) = (* (ptr) &fc96 );
(* (( (ptr) state←v18772)+27) ) = 2139095039;
(* (( (ptr) state←v18772)+28) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+29) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+30) ) = (* (ptr) &fc70 );
(* (( (ptr) state←v18772)+31) ) = 0;
(* (( (ptr) state←v18772)+32) ) = 0;
(* (( (ptr) state←v18772)+33) ) = 0;
(* (( (ptr) state←v18772)+34) ) = 0;
(* (( (ptr) state←v18772)+35) ) = 0;
(* (( (ptr) state←v18772)+36) ) = 0;
(* (( (ptr) state←v18772)+37) ) = 0;
(* (( (ptr) state←v18772)+38) ) = 0;
(* (( (ptr) state←v18772)+39) ) = 0;
(* (( (ptr) state←v18772)+40) ) = 0;
SOURCE(15085, 26)
(* (( (ptr) state←v18772)+36) ) = (* (( (ptr) iState←v9708)+4) );
SOURCE(15113, 37)
(* (( (ptr) state←v18772)+33) ) = clientToDevice←v18996;
SOURCE(15152, 33)
(* (( (ptr) state←v18772)+34) ) = viewToDevice←v18968;
SOURCE(15187, 13)
(* (( (ptr) state←v18772)+32) ) = cp←v18856;
SOURCE(15202, 29)
(* (( (ptr) state←v18772)+40) ) = rasterData←v18800;
SOURCE(15236, 18)
(* (( (ptr) iState←v9708)+4) ) = 0;
SOURCE(15256, 66)
(* (ptr) context←v18744 ) = (* (( (ptr) gf←c99836)+9)/* rasterClassTemplate←v6640 */ );
(* (( (ptr) context←v18744)+1) ) = state←v18772;
(* (( (ptr) context←v18744)+2) ) = 0;
(* (( (ptr) context←v18744)+3) ) = 0;
SOURCE(15324, 55)
{
word pd133;
pd133 = (* (( (ptr) (* (( (ptr) gf←c99836)+181)/* var←c93852 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd133 ))))(iState←v9708, pd133);
};
SOURCE(15381, 43)
{
W2 var←c94268;
var←c94268.f0 = (* (ptr) &fc70 );
var←c94268.f1 = (* (ptr) &fc70 );
{
word pd134;
pd134 = (* (( (ptr) (* (( (ptr) gf←c99836)+177)/* var←c92956 */ ))+27) );
(void) ( *( (fPt) ((* (ptr) pd134 ))))(context←v18744, var←c94268, pd134);
};
};
SOURCE(15426, 15)
return(context←v18744);
}
static void RasterMaskFill←P840(context←v9840, path←v9868, oddWrap←v9896)
word context←v9840;
word path←v9868;
word oddWrap←v9896;
{
word state←v19228;
/* RasterMaskFill: */
SOURCE(15446, 349)
SOURCE(15521, 28)
state←v19228 = (* (( (ptr) context←v9840)+1) );
SOURCE(15551, 244)
if (( (int)(* (( (ptr) state←v19228)+19) ) == (int)0)) {
SOURCE(15578, 219)
{
word rasterData←v19272;
word device←v19300;
SOURCE(15580, 41)
rasterData←v19272 = (* (( (ptr) state←v19228)+40) );
SOURCE(15623, 34)
device←v19300 = (* (ptr) rasterData←v19272 );
SOURCE(15659, 26)
(void) Validate←P480(state←v19228, 2952790016);
SOURCE(15687, 108)
{
word pathToDevice←v89756;
pathToDevice←v89756 = (* (( (ptr) state←v19228)+33) );
{
word pd135;
pd135 = (* (( (ptr) (* (ptr) device←v19300 ))+1) );
(void) ( *( (fPt) ((* (ptr) pd135 ))))(device←v19300, path←v9868, oddWrap←v9896, pathToDevice←v89756, pd135);
};
};
};
};
}
static word PenFromState←P960(state←v10060)
word state←v10060;
{
register ptr gf←c99868 = (ptr) &globalframe;
word var←c10104;
word rasterData←v19372;
word pen←v19400;
/* PenFromState: */
SOURCE(16090, 464)
SOURCE(16152, 41)
rasterData←v19372 = (* (( (ptr) state←v10060)+40) );
SOURCE(16195, 344)
{
W2 var←c94300;
W2 var←c94332;
var←c94300.f0 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v19372 ))+5) ))+8) ))+9) );
var←c94300.f1 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v19372 ))+5) ))+8) ))+10) );
var←c94332.f0 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v19372 ))+5) ))+8) ))+11) );
var←c94332.f1 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v19372 ))+5) ))+8) ))+12) );
{
word pd136;
pd136 = (* (( (ptr) (* (( (ptr) gf←c99868)+183)/* var←c94364 */ ))+4) );
pen←v19400 = (word) ( *( (fPt) ((* (ptr) pd136 ))))((* (( (ptr) state←v10060)+20) ), (* (( (ptr) state←v10060)+33) ), var←c94300, var←c94332, pd136)
;
};
};
SOURCE(16541, 13)
return(pen←v19400);
}
static void RasterMaskVector←P1020(context←v10164, p1←v10192, p2←v10220)
word context←v10164;
W2 p1←v10192;
W2 p2←v10220;
{
word state←v19444;
/* RasterMaskVector: */
SOURCE(16558, 371)
SOURCE(16617, 28)
state←v19444 = (* (( (ptr) context←v10164)+1) );
SOURCE(16647, 282)
if (( (int)(* (( (ptr) state←v19444)+19) ) == (int)0)) {
SOURCE(16674, 257)
{
word rasterData←v19488;
word device←v19516;
SOURCE(16676, 41)
rasterData←v19488 = (* (( (ptr) state←v19444)+40) );
SOURCE(16719, 34)
device←v19516 = (* (ptr) rasterData←v19488 );
SOURCE(16755, 26)
(void) Validate←P480(state←v19444, 2952790016);
SOURCE(16783, 146)
{
W2 p1←v89596;
W2 p2←v89624;
word pointsToDevice←v89652;
word end←v89680;
word pen←v89708;
p1←v89596 = p1←v10192;
p2←v89624 = p2←v10220;
pointsToDevice←v89652 = (* (( (ptr) state←v19444)+33) );
{
word end←v19344;
end←v19344 = (* (( (ptr) state←v19444)+21) );
SOURCE(15904, 167)
{
word var←c94428;
var←c94428 = end←v19344;
if (( (int)var←c94428 == (int)1) || ( (int)var←c94428 == (int)2)) {
}
else {
SOURCE(15982, 89)
if (( (int)(* (( (ptr) state←v19444)+31) ) != (int)0)) {
end←v19344 = (word) -1;
}
else {
end←v19344 = 0;
};
};
};
SOURCE(16073, 13)
end←v89680 = end←v19344;
};
pen←v89708 = (word) PenFromState←P960(state←v19444);
{
word pd137;
pd137 = (* (( (ptr) (* (ptr) device←v19516 ))+4) );
(void) ( *( (fPt) ((* (ptr) pd137 ))))(device←v19516, p1←v89596, p2←v89624, pointsToDevice←v89652, end←v89680, pen←v89708, pd137)
;
};
};
};
};
}
static void RasterMaskStroke←P1080(context←v10280, path←v10308, closed←v10336)
word context←v10280;
word path←v10308;
word closed←v10336;
{
word state←v19560;
/* RasterMaskStroke: */
SOURCE(16938, 460)
SOURCE(17014, 28)
state←v19560 = (* (( (ptr) context←v10280)+1) );
SOURCE(17044, 354)
if (( (int)(* (( (ptr) state←v19560)+19) ) == (int)0)) {
SOURCE(17071, 329)
{
word rasterData←v19604;
word device←v19632;
SOURCE(17073, 41)
rasterData←v19604 = (* (( (ptr) state←v19560)+40) );
SOURCE(17116, 34)
device←v19632 = (* (ptr) rasterData←v19604 );
SOURCE(17152, 26)
(void) Validate←P480(state←v19560, 2952790016);
SOURCE(17180, 218)
{
word path←v89380;
word closed←v89408;
word pathToDevice←v89436;
word end←v89464;
word joint←v89492;
word miterLimit←v89520;
word pen←v89548;
path←v89380 = path←v10308;
closed←v89408 = closed←v10336;
pathToDevice←v89436 = (* (( (ptr) state←v19560)+33) );
{
word end←v88640;
end←v88640 = (* (( (ptr) state←v19560)+21) );
SOURCE(15904, 167)
{
word var←c94492;
var←c94492 = end←v88640;
if (( (int)var←c94492 == (int)1) || ( (int)var←c94492 == (int)2)) {
}
else {
SOURCE(15982, 89)
if (( (int)(* (( (ptr) state←v19560)+31) ) != (int)0)) {
end←v88640 = (word) -1;
}
else {
end←v88640 = 0;
};
};
};
SOURCE(16073, 13)
end←v89464 = end←v88640;
};
joint←v89492 = (* (( (ptr) state←v19560)+22) );
miterLimit←v89520 = (* (( (ptr) state←v19560)+30) );
pen←v89548 = (word) PenFromState←P960(state←v19560);
{
word pd138;
pd138 = (* (( (ptr) (* (ptr) device←v19632 ))+3) );
(void) ( *( (fPt) ((* (ptr) pd138 ))))(device←v19632, path←v89380, closed←v89408, pathToDevice←v89436, end←v89464, joint←v89492
, miterLimit←v89520, pen←v89548, pd138);
};
};
};
};
}
static void RasterMaskDashedStroke←P1140(context←v10396, path←v10424, patternLen←v10452, pattern←v10480, offset←v10508, length←v10536)
word context←v10396;
word path←v10424;
word patternLen←v10452;
word pattern←v10480;
word offset←v10508;
word length←v10536;
{
word state←v19676;
/* RasterMaskDashedStroke: */
SOURCE(17407, 613)
SOURCE(17557, 28)
state←v19676 = (* (( (ptr) context←v10396)+1) );
SOURCE(17587, 433)
if (( (int)(* (( (ptr) state←v19676)+19) ) == (int)0)) {
SOURCE(17614, 408)
{
word rasterData←v19720;
word device←v19748;
SOURCE(17616, 41)
rasterData←v19720 = (* (( (ptr) state←v19676)+40) );
SOURCE(17659, 34)
device←v19748 = (* (ptr) rasterData←v19720 );
SOURCE(17695, 26)
(void) Validate←P480(state←v19676, 2952790016);
SOURCE(17723, 297)
{
word path←v89080;
word patternLen←v89108;
word pattern←v89136;
word offset←v89164;
word length←v89192;
word pathToDevice←v89220;
word end←v89248;
word joint←v89276;
word miterLimit←v89304;
word pen←v89332;
path←v89080 = path←v10424;
patternLen←v89108 = patternLen←v10452;
pattern←v89136 = pattern←v10480;
offset←v89164 = offset←v10508;
length←v89192 = length←v10536;
pathToDevice←v89220 = (* (( (ptr) state←v19676)+33) );
{
word end←v88596;
end←v88596 = (* (( (ptr) state←v19676)+21) );
SOURCE(15904, 167)
{
word var←c94556;
var←c94556 = end←v88596;
if (( (int)var←c94556 == (int)1) || ( (int)var←c94556 == (int)2)) {
}
else {
SOURCE(15982, 89)
if (( (int)(* (( (ptr) state←v19676)+31) ) != (int)0)) {
end←v88596 = (word) -1;
}
else {
end←v88596 = 0;
};
};
};
SOURCE(16073, 13)
end←v89248 = end←v88596;
};
joint←v89276 = (* (( (ptr) state←v19676)+22) );
miterLimit←v89304 = (* (( (ptr) state←v19676)+30) );
pen←v89332 = (word) PenFromState←P960(state←v19676);
{
word pd139;
pd139 = (* (( (ptr) (* (ptr) device←v19748 ))+5) );
(void) ( *( (fPt) ((* (ptr) pd139 ))))(device←v19748, path←v89080, patternLen←v89108, pattern←v89136, offset←v89164, length←v89192
, 0, pathToDevice←v89220, end←v89248, joint←v89276, miterLimit←v89304, pen←v89332, pd139);
};
};
};
};
}
static void RasterMaskBitmap←P1200(context←v10700, bitmap←v10728, referencePoint←v10756, scanMode←v10784, position←v10812)
word context←v10700;
word bitmap←v10728;
W2 referencePoint←v10756;
word scanMode←v10784;
W2 position←v10812;
{
register ptr gf←c99900 = (ptr) &globalframe;
word state←v19792;
/* RasterMaskBitmap: */
SOURCE(18029, 660)
SOURCE(18153, 28)
state←v19792 = (* (( (ptr) context←v10700)+1) );
SOURCE(18183, 26)
(void) Validate←P480(state←v19792, 2952790016);
SOURCE(18211, 478)
if (( (int)(* (( (ptr) state←v19792)+19) ) == (int)0)) {
SOURCE(18238, 453)
{
word rasterData←v19836;
word device←v19864;
word m←v19892;
SOURCE(18240, 41)
rasterData←v19836 = (* (( (ptr) state←v19792)+40) );
SOURCE(18283, 34)
device←v19864 = (* (ptr) rasterData←v19836 );
SOURCE(18319, 67)
{
word pd140;
pd140 = (* (( (ptr) (* (( (ptr) gf←c99900)+175)/* var←c92796 */ ))+6) );
m←v19892 = (word) ( *( (fPt) ((* (ptr) pd140 ))))((* ((( (ptr) state←v19792)+33)) ), pd140);
};
SOURCE(18388, 51)
{
word pd141;
pd141 = (* (( (ptr) (* (( (ptr) gf←c99900)+175)/* var←c92796 */ ))+28) );
(void) ( *( (fPt) ((* (ptr) pd141 ))))(m←v19892, position←v10812, pd141);
};
SOURCE(18441, 51)
{
word pd142;
pd142 = (* (( (ptr) (* (( (ptr) gf←c99900)+175)/* var←c92796 */ ))+29) );
(void) ( *( (fPt) ((* (ptr) pd142 ))))(m←v19892, scanMode←v10784, 0, 0, pd142);
};
SOURCE(18494, 81)
{
W2 var←c94588;
{
float tf143;
var←c94588.f0 = (
tf143 = (float)(int)INEG(referencePoint←v10756.f0), *(word*)&tf143
);
};
{
float tf144;
var←c94588.f1 = (
tf144 = (float)(int)INEG(referencePoint←v10756.f1), *(word*)&tf144
);
};
{
word pd145;
pd145 = (* (( (ptr) (* (( (ptr) gf←c99900)+175)/* var←c92796 */ ))+28) );
(void) ( *( (fPt) ((* (ptr) pd145 ))))(m←v19892, var←c94588, pd145);
};
};
SOURCE(18577, 79)
{
word pd146;
pd146 = (* (( (ptr) (* (ptr) device←v19864 ))+6) );
(void) ( *( (fPt) ((* (ptr) pd146 ))))(device←v19864, bitmap←v10728, m←v19892, pd146);
};
SOURCE(18658, 31)
{
word pd147;
pd147 = (* (( (ptr) (* (( (ptr) gf←c99900)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd147 ))))(m←v19892, pd147);
};
};
};
}
static void GetSampleMapClippedDisplacedBox←P1260(formal←c0285, map←v10872, clip←v10900, m←v10928)
word formal←c0285;
word map←v10872;
W4 clip←v10900;
word m←v10928;
{
register ptr gf←c99932 = (ptr) &globalframe;
W4 var←c10972;
W4 box←v19936;
word ts←v19964;
word tf←v19992;
W4 clipped←v20020;
/* GetSampleMapClippedDisplacedBox: */
SOURCE(18698, 369)
SOURCE(18807, 38)
box←v19936 = (* (W4Pt) map←v10872 );
SOURCE(18847, 25)
{
word pd148;
pd148 = (* (( (ptr) (* (( (ptr) gf←c99932)+184)/* var←c94620 */ ))+6) );
ts←v19964 = (word) ( *( (fPt) ((* (ptr) pd148 ))))((* ((( (ptr) m←v10928)+2)) ), pd148);
};
SOURCE(18874, 25)
{
word pd149;
pd149 = (* (( (ptr) (* (( (ptr) gf←c99932)+184)/* var←c94620 */ ))+6) );
tf←v19992 = (word) ( *( (fPt) ((* (ptr) pd149 ))))((* ((( (ptr) m←v10928)+5)) ), pd149);
};
SOURCE(18901, 122)
{
W4 var←c0284;
{
W2 var←c94652;
W2 var←c94684;
var←c94652.f0 = (box←v19936.f0 + ts←v19964);
var←c94652.f1 = (box←v19936.f1 + tf←v19992);
var←c94684.f0 = (box←v19936.f2 + ts←v19964);
var←c94684.f1 = (box←v19936.f3 + tf←v19992);
(void) ClippedBounds←P1320((word) &var←c0284, clip←v10900, var←c94652, var←c94684);
};
clipped←v20020 = var←c0284;
};
SOURCE(19025, 19)
if (((* (( (ptr) m←v10928)+9) ) != 3)) {
SOURCE(19044, 5)
(void) XR←RaiseUnnamedError();
};
SOURCE(19051, 16)
var←c10972 = clipped←v20020;
/* removed tail goto */
(* (W4Pt) formal←c0285 ) = var←c10972;
return;
}
static void ClippedBounds←P1320(formal←c0292, clipBox←v11032, p0←v11060, p1←v11088)
word formal←c0292;
W4 clipBox←v11032;
W2 p0←v11060;
W2 p1←v11088;
{
W4 var←c11132;
/* ClippedBounds: */
SOURCE(19071, 495)
SOURCE(19146, 57)
if (( (int)p0←v11060.f0 > (int)p1←v11088.f0)) {
SOURCE(19166, 37)
{
word t←v20064;
SOURCE(19167, 13)
t←v20064 = p0←v11060.f0;
SOURCE(19182, 11)
p0←v11060.f0 = p1←v11088.f0;
SOURCE(19195, 8)
p1←v11088.f0 = t←v20064;
};
};
SOURCE(19206, 57)
if (( (int)p0←v11060.f1 > (int)p1←v11088.f1)) {
SOURCE(19226, 37)
{
word t←v20108;
SOURCE(19227, 13)
t←v20108 = p0←v11060.f1;
SOURCE(19242, 11)
p0←v11060.f1 = p1←v11088.f1;
SOURCE(19255, 8)
p1←v11088.f1 = t←v20108;
};
};
SOURCE(19266, 31)
{
word x150;
word x151;
p0←v11060.f0 = (x150 = p0←v11060.f0,
x151 = clipBox←v11032.f0,
MAX((int)(word), x150, x151));
};
SOURCE(19299, 31)
{
word x152;
word x153;
p0←v11060.f1 = (x152 = p0←v11060.f1,
x153 = clipBox←v11032.f1,
MAX((int)(word), x152, x153));
};
SOURCE(19332, 31)
{
word x154;
word x155;
p1←v11088.f0 = (x154 = p1←v11088.f0,
x155 = clipBox←v11032.f2,
MIN((int)(word), x154, x155));
};
SOURCE(19365, 31)
{
word x156;
word x157;
p1←v11088.f1 = (x156 = p1←v11088.f1,
x157 = clipBox←v11032.f3,
MIN((int)(word), x156, x157));
};
SOURCE(19398, 168)
if ( ( ( (int)p0←v11060.f0 < (int)p1←v11088.f0) ? ( (int)p0←v11060.f1 < (int)p1←v11088.f1) : 0 ) ) {
SOURCE(19434, 88)
var←c11132.f0 = p0←v11060.f0;
var←c11132.f1 = p0←v11060.f1;
var←c11132.f2 = p1←v11088.f0;
var←c11132.f3 = p1←v11088.f1;
/* removed tail goto */
}
else {
SOURCE(19522, 44)
(* (W2Pt) &var←c11132 ) = (* (W2Pt) &clipBox←v11032 );
(* (W2Pt) (( (ptr) &var←c11132)+2) ) = (* (W2Pt) &clipBox←v11032 );
/* removed tail goto */
};
(* (W4Pt) formal←c0292 ) = var←c11132;
return;
}
static void RasterDrawBitmap←P1380(context←v11192, bitmap←v11220, referencePoint←v11248, scanMode←v11276, position←v11304)
word context←v11192;
word bitmap←v11220;
W2 referencePoint←v11248;
word scanMode←v11276;
W2 position←v11304;
{
W11 var←c99964;
register ptr gf←c99996 = (ptr) &globalframe;
/* declaration of var←c94780 skipped */
word state←v20152;
/* RasterDrawBitmap: */
SOURCE(19572, 1195)
{
word tmpAddr158;
tmpAddr158 = (word) (( (ptr) &var←c99964)+4)/* var←c94780 */ ;
(* (ptr) tmpAddr158 ) = ( ((word) (fPt) Boxes←P5472) );
(* (( (ptr) tmpAddr158) + 1) ) = 1;
};
SOURCE(19696, 28)
state←v20152 = (* (( (ptr) context←v11192)+1) );
SOURCE(19726, 26)
(void) Validate←P480(state←v20152, 2952790016);
SOURCE(19754, 1013)
if (( (int)(* (( (ptr) state←v20152)+19) ) == (int)0)) {
SOURCE(19781, 988)
{
/* declaration of rasterData←v20196 skipped */
word m←v20224;
SOURCE(19783, 41)
(* (( (ptr) &var←c99964)+6)/* rasterData←v20196 */ ) = (* (( (ptr) state←v20152)+40) );
SOURCE(19826, 67)
{
word pd159;
pd159 = (* (( (ptr) (* (( (ptr) gf←c99996)+175)/* var←c92796 */ ))+6) );
m←v20224 = (word) ( *( (fPt) ((* (ptr) pd159 ))))((* ((( (ptr) state←v20152)+33)) ), pd159);
};
SOURCE(19895, 51)
{
word pd160;
pd160 = (* (( (ptr) (* (( (ptr) gf←c99996)+175)/* var←c92796 */ ))+28) );
(void) ( *( (fPt) ((* (ptr) pd160 ))))(m←v20224, position←v11304, pd160);
};
SOURCE(19948, 51)
{
word pd161;
pd161 = (* (( (ptr) (* (( (ptr) gf←c99996)+175)/* var←c92796 */ ))+29) );
(void) ( *( (fPt) ((* (ptr) pd161 ))))(m←v20224, scanMode←v11276, 0, 0, pd161);
};
SOURCE(20001, 81)
{
W2 var←c94812;
{
float tf162;
var←c94812.f0 = (
tf162 = (float)(int)INEG(referencePoint←v11248.f0), *(word*)&tf162
);
};
{
float tf163;
var←c94812.f1 = (
tf163 = (float)(int)INEG(referencePoint←v11248.f1), *(word*)&tf163
);
};
{
word pd164;
pd164 = (* (( (ptr) (* (( (ptr) gf←c99996)+175)/* var←c92796 */ ))+28) );
(void) ( *( (fPt) ((* (ptr) pd164 ))))(m←v20224, var←c94812, pd164);
};
};
SOURCE(20084, 650)
{
word tc165;
word tc166;
float tf167;
word x168;
word x169;
float tf170;
word x171;
word x172;
if ( ( ((* (( (bPt) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c99964)+6)/* rasterData←v20196 */ ) ))+5) ))+3) ) & 010) ? ((* (
( (ptr) m←v20224)+9) ) == 3) : 0 ) ) {
tc166 = (word) (FABS((
x168 = (* (( (ptr) m←v20224)+2) ), *(float*)&x168
), tf167) < (
x169 = (* (( (ptr) gf←c99996)+8)/* bigTranslate←v6500 */ ), *(float*)&x169
));
}
else {
tc166 = (word) 0;
};
if (tc166) {
tc165 = (word) (FABS((
x171 = (* (( (ptr) m←v20224)+5) ), *(float*)&x171
), tf170) < (
x172 = (* (( (ptr) gf←c99996)+8)/* bigTranslate←v6500 */ ), *(float*)&x172
));
}
else {
tc165 = (word) 0;
};
if (tc165) {
SOURCE(20205, 438)
{
/* declaration of box←v20268 skipped */
SOURCE(20207, 102)
(void) GetSampleMapClippedDisplacedBox←P1260((word) (( (bPt) &var←c99964)+28)/* box←v20268 */ , bitmap←v11220, (* (W4Pt) (* (
( (ptr) (* (ptr) (* (( (ptr) &var←c99964)+6)/* rasterData←v20196 */ ) ))+1) ) ), m←v20224);
SOURCE(20463, 178)
{
word pd173;
pd173 = (* (( (ptr) (* (( (ptr) gf←c99996)+185)/* var←c94844 */ ))+13) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd173 ))))((* (W4Pt) ((( (ptr) &var←c99964)+7)/* box←v20268 */ ) ), pd173))) {
SOURCE(20488, 153)
{
word var←c94876;
word var←c94908;
{
/*1*/ word pd174;
/*1*/ pd174 = (* (( (ptr) (* (( (ptr) gf←c99996)+184)/* var←c94620 */ ))+6) );
/*1*/ var←c94876 = (word) ( *( (fPt) ((* (ptr) pd174 ))))((* ((( (ptr) m←v20224)+2)) ), pd174);
/*1*/ };
{
/*1*/ word pd175;
/*1*/ pd175 = (* (( (ptr) (* (( (ptr) gf←c99996)+184)/* var←c94620 */ ))+6) );
/*1*/ var←c94908 = (word) ( *( (fPt) ((* (ptr) pd175 ))))((* ((( (ptr) m←v20224)+5)) ), pd175);
/*1*/ };
{
/*1*/ W2 var←c94940;
/*1*/ var←c94940.f0 = var←c94876;
/*1*/ var←c94940.f1 = var←c94908;
/*1*/ {
/*1*/ word pd176;
/*1*/ pd176 = (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c99964)+6)/* rasterData←v20196 */ ) ))+4) ))+8) );
/*1*/ (void) ( *( (fPt) ((* (ptr) pd176 ))))((* (ptr) (* (( (ptr) &var←c99964)+6)/* rasterData←v20196 */ ) ), bitmap←v11220, var←c94940, (* (W4Pt) (
/*1*/ ( (ptr) &var←c99964)+7)/* box←v20268 */ ), (word) (( (bPt) &var←c99964)+16)/* var←c94780 */ , pd176);
/*1*/ };
/*1*/ };
};
};
};
};
}
else {
SOURCE(20650, 84)
{
word pd177;
pd177 = (* (( (ptr) (* (( (ptr) gf←c99996)+178)/* var←c92988 */ ))+10) );
(void) ( *( (fPt) ((* (ptr) pd177 ))))(context←v11192, bitmap←v11220, referencePoint←v11248, scanMode←v11276, position←v11304, pd177)
;
};
};
};
SOURCE(20736, 31)
{
word pd178;
pd178 = (* (( (ptr) (* (( (ptr) gf←c99996)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd178 ))))(m←v20224, pd178);
};
};
};
}
static void Boxes←P5472(action←v20372, formal←c100060)
word action←v20372;
word formal←c100060;
{
register ptr gf←c100028 = (ptr) &globalframe;
formal←c100060 = (formal←c100060 - 16);
/* Boxes: */
SOURCE(20311, 13)
SOURCE(20351, 109)
{
word pd179;
pd179 = (* (( (ptr) (* (( (ptr) gf←c100028)+182)/* var←c94236 */ ))+23) );
(void) ( *( (fPt) ((* (ptr) pd179 ))))((* (W4Pt) (( (ptr) formal←c100060)+7) ), (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) formal←c100060)+6)
) ))+1) ))+4) ), action←v20372, pd179);
};
}
static void RasterMaskPixel←P1440(context←v11364, pa←v11392)
word context←v11364;
word pa←v11392;
{
register ptr gf←c100092 = (ptr) &globalframe;
word state←v20460;
/* RasterMaskPixel: */
SOURCE(20776, 639)
SOURCE(20837, 28)
state←v20460 = (* (( (ptr) context←v11364)+1) );
SOURCE(20867, 141)
if (((* (( (ptr) pa←v11392)+1) ) != 1)) {
SOURCE(20896, 112)
{
W3 var←c0313;
var←c0313.f0 = 74;
var←c0313.f1 = (* (( (ptr) gf←c100092)+38) );
var←c0313.f2 = 0;
(void) XR←RaiseError((* (ptr) (* (( (ptr) (* (( (ptr) gf←c100092)+179)/* var←c93532 */ ))+6) ) ), (word) &var←c0313);
};
};
SOURCE(21010, 159)
{
word pd180;
pd180 = (* (( (ptr) (* (( (ptr) gf←c100092)+186)/* var←c95004 */ ))+7) );
if (((word) ( *( (fPt) ((* (ptr) pd180 ))))(pa←v11392, 0, pd180) != 1)) {
SOURCE(21059, 110)
{
W3 var←c0315;
var←c0315.f0 = 74;
var←c0315.f1 = (* (( (ptr) gf←c100092)+39) );
var←c0315.f2 = 0;
(void) XR←RaiseError((* (ptr) (* (( (ptr) (* (( (ptr) gf←c100092)+179)/* var←c93532 */ ))+6) ) ), (word) &var←c0315);
};
};
};
SOURCE(21171, 26)
(void) Validate←P480(state←v20460, 2952790016);
SOURCE(21199, 216)
if ( ( ( ( (int)(* (( (ptr) state←v20460)+19) ) == (int)0) ? ( (int)(* (( (ptr) pa←v11392)+2) ) > (int)0) : 0 ) ? ( (int)(* (
( (ptr) pa←v11392)+3) ) > (int)0) : 0 ) ) {
SOURCE(21268, 149)
{
word rasterData←v20504;
word device←v20532;
SOURCE(21270, 41)
rasterData←v20504 = (* (( (ptr) state←v20460)+40) );
SOURCE(21313, 34)
device←v20532 = (* (ptr) rasterData←v20504 );
SOURCE(21349, 66)
{
word clientToDevice←v89032;
clientToDevice←v89032 = (* (( (ptr) state←v20460)+33) );
{
word pd181;
pd181 = (* (( (ptr) (* (ptr) device←v20532 ))+7) );
(void) ( *( (fPt) ((* (ptr) pd181 ))))(device←v20532, pa←v11392, clientToDevice←v89032, pd181);
};
};
};
};
}
static void GetContainingBox←P1500(formal←c0327, context←v11452, p←v11480)
word formal←c0327;
word context←v11452;
W2 p←v11480;
{
register ptr gf←c100124 = (ptr) &globalframe;
W4 var←c11524;
word state←v20576;
word rasterData←v20604;
/* GetContainingBox: */
SOURCE(21424, 443)
SOURCE(21505, 28)
state←v20576 = (* (( (ptr) context←v11452)+1) );
SOURCE(21535, 41)
rasterData←v20604 = (* (( (ptr) state←v20576)+40) );
SOURCE(21578, 41)
(void) Validate←P480(state←v20576, 2147483648);
SOURCE(21621, 190)
{
register word each←v20648;
each←v20648 = (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v20604 ))+1) ))+4) );
lab←L100022: ;
if ((each←v20648 != 0)) {
}
else {
goto lab←L100019;
};
{
W4 box←v20776;
SOURCE(21725, 24)
box←v20776 = (* (W4Pt) each←v20648 );
SOURCE(21751, 34)
{
word pd182;
pd182 = (* (( (ptr) (* (( (ptr) gf←c100124)+185)/* var←c94844 */ ))+22) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd182 ))))(p←v11480, box←v20776, pd182))) {
SOURCE(21773, 12)
var←c11524 = box←v20776;
goto lab←L100018;
};
};
SOURCE(21787, 24)
if (( (int)box←v20776.f0 > (int)p←v11480.f0)) {
SOURCE(21811, 4)
goto lab←L100020;
};
};
each←v20648 = (* (( (ptr) each←v20648)+4) );
goto lab←L100022;
lab←L100019: ;
lab←L100020: ;
};
SOURCE(21826, 41)
var←c11524 = (* (W4Pt) (( (ptr) gf←c100124)+167)/* var←c92700 */ );
/* removed tail goto */
lab←L100018: ;
(* (W4Pt) formal←c0327 ) = var←c11524;
return;
}
static word GetClipper←P1560(context←v11584)
word context←v11584;
{
word var←c11628;
word state←v20820;
word rasterData←v20848;
/* GetClipper: */
SOURCE(21873, 233)
SOURCE(21944, 28)
state←v20820 = (* (( (ptr) context←v11584)+1) );
SOURCE(21974, 41)
rasterData←v20848 = (* (( (ptr) state←v20820)+40) );
SOURCE(22017, 41)
(void) Validate←P480(state←v20820, 2147483648);
SOURCE(22060, 46)
return((* (( (ptr) (* (ptr) rasterData←v20848 ))+1) ));
}
static void GetDeviceClipBox←P1620(formal←c0337, context←v11688)
word formal←c0337;
word context←v11688;
{
W4 var←c11732;
word state←v20892;
word rasterData←v20920;
/* GetDeviceClipBox: */
SOURCE(22110, 183)
SOURCE(22180, 28)
state←v20892 = (* (( (ptr) context←v11688)+1) );
SOURCE(22210, 41)
rasterData←v20920 = (* (( (ptr) state←v20892)+40) );
SOURCE(22253, 40)
var←c11732 = (* (W4Pt) (( (ptr) (* (( (ptr) (* (ptr) rasterData←v20920 ))+6) ))+1) );
/* removed tail goto */
(* (W4Pt) formal←c0337 ) = var←c11732;
return;
}
static void SetDeviceClipBox←P1680(context←v11792, clipBox←v11820)
word context←v11792;
W4 clipBox←v11820;
{
word state←v20964;
word rasterData←v20992;
/* SetDeviceClipBox: */
SOURCE(22297, 226)
SOURCE(22367, 28)
state←v20964 = (* (( (ptr) context←v11792)+1) );
SOURCE(22397, 41)
rasterData←v20992 = (* (( (ptr) state←v20964)+40) );
SOURCE(22440, 40)
(* (W4Pt) (( (ptr) (* (( (ptr) (* (ptr) rasterData←v20992 ))+6) ))+1) ) = clipBox←v11820;
SOURCE(22482, 41)
(* (( (ptr) rasterData←v20992) + 1) ) &= 2147483647;
}
static void RasterGetBounds←P1740(formal←c0353, context←v11880)
word formal←c0353;
word context←v11880;
{
register ptr gf←c100156 = (ptr) &globalframe;
W4 var←c11924;
word state←v21036;
word rasterData←v21064;
/* RasterGetBounds: */
SOURCE(22529, 419)
SOURCE(22594, 28)
state←v21036 = (* (( (ptr) context←v11880)+1) );
SOURCE(22624, 41)
rasterData←v21064 = (* (( (ptr) state←v21036)+40) );
SOURCE(22667, 41)
(void) Validate←P480(state←v21036, 2147483648);
SOURCE(22710, 240)
{
W4 box←v21108;
W2 size←v21136;
word m←v21164;
W4 r←v21192;
SOURCE(22712, 58)
box←v21108 = (* (W4Pt) (* (( (ptr) (* (ptr) rasterData←v21064 ))+1) ) );
SOURCE(22772, 27)
{
word pd183;
pd183 = (* (( (ptr) (* (( (ptr) gf←c100156)+185)/* var←c94844 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd183 ))))((word) &size←v21136, box←v21108, pd183);
};
SOURCE(22801, 40)
m←v21164 = (* (( (ptr) state←v21036)+33) );
SOURCE(22843, 94)
{
W4 var←c0352;
{
W4 var←c95132;
{
float tf184;
var←c95132.f0 = (
tf184 = (float)(int)box←v21108.f0, *(word*)&tf184
);
};
{
float tf185;
var←c95132.f1 = (
tf185 = (float)(int)box←v21108.f1, *(word*)&tf185
);
};
{
float tf186;
var←c95132.f2 = (
tf186 = (float)(int)size←v21136.f0, *(word*)&tf186
);
};
{
float tf187;
var←c95132.f3 = (
tf187 = (float)(int)size←v21136.f1, *(word*)&tf187
);
};
{
word pd188;
pd188 = (* (( (ptr) (* (( (ptr) gf←c100156)+175)/* var←c92796 */ ))+47) );
(void) ( *( (fPt) ((* (ptr) pd188 ))))((word) &var←c0352, m←v21164, var←c95132, pd188);
};
};
r←v21192 = var←c0352;
};
SOURCE(22939, 9)
var←c11924 = r←v21192;
/* removed tail goto */
};
(* (W4Pt) formal←c0353 ) = var←c11924;
return;
}
static word RasterTestViewRectangle←P1800(context←v11984, x←v12012, y←v12040, w←v12068, h←v12096)
word context←v11984;
word x←v12012;
word y←v12040;
word w←v12068;
word h←v12096;
{
register ptr gf←c100188 = (ptr) &globalframe;
word var←c12140;
word state←v21236;
word rasterData←v21264;
word viewToDevice←v21292;
word viewClip←v21320;
/* RasterTestViewRectangle: */
SOURCE(22957, 693)
SOURCE(23059, 28)
state←v21236 = (* (( (ptr) context←v11984)+1) );
SOURCE(23089, 41)
rasterData←v21264 = (* (( (ptr) state←v21236)+40) );
SOURCE(23132, 49)
viewToDevice←v21292 = (* (( (ptr) state←v21236)+34) );
SOURCE(23183, 60)
viewClip←v21320 = (* (( (ptr) (* (( (ptr) rasterData←v21264)+3) ))+4) );
SOURCE(23245, 36)
if ((viewClip←v21320 == 0)) {
SOURCE(23268, 13)
return(0);
};
SOURCE(23283, 349)
{
word pd189;
pd189 = (* (( (ptr) (* (( (ptr) gf←c100188)+175)/* var←c92796 */ ))+48) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd189 ))))(viewToDevice←v21292, pd189))) {
SOURCE(23345, 289)
{
W4 box←v21364;
SOURCE(23347, 109)
{
word pd190;
pd190 = (* (( (ptr) (* (( (ptr) gf←c100188)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd190 ))))((word) &box←v21364, viewToDevice←v21292, x←v12012, y←v12040, w←v12068, h←v12096
, (* (W4Pt) (( (ptr) gf←c100188)+171)/* var←c92764 */ ), pd190);
};
SOURCE(23458, 102)
{
word tc191;
word pd192;
word pd193;
pd192 = (* (( (ptr) (* (( (ptr) gf←c100188)+185)/* var←c94844 */ ))+21) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd192 ))))(box←v21364, (* (W4Pt) viewClip←v21320 ), pd192))) {
pd193 = (* (( (ptr) (* (( (ptr) gf←c100188)+185)/* var←c94844 */ ))+21) );
tc191 = (word) (0 != (word) ( *( (fPt) ((* (ptr) pd193 ))))(box←v21364, (* (W4Pt) (( (ptr) (* (( (ptr) (* (ptr) rasterData←v21264 ))+6)
))+1) ), pd193));
}
else {
tc191 = (word) 0;
};
if (tc191) {
SOURCE(23548, 12)
return(2);
};
};
SOURCE(23562, 70)
{
word pd194;
pd194 = (* (( (ptr) (* (( (ptr) gf←c100188)+185)/* var←c94844 */ ))+16) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd194 ))))(box←v21364, (* (W4Pt) (* (( (ptr) rasterData←v21264)+3) ) ), pd194))) {
SOURCE(23619, 13)
return(0);
};
};
};
};
};
SOURCE(23637, 13)
return(1);
}
static word IntegerTranslation←P1860(m←v12200)
word m←v12200;
{
register ptr gf←c100220 = (ptr) &globalframe;
word var←c12244;
/* IntegerTranslation: */
SOURCE(23681, 119)
SOURCE(23745, 55)
{
word tc195;
float tf196;
word x197;
word x198;
float tf199;
word x200;
word x201;
if ((FABS(((
x197 = (* (( (ptr) m←v12200)+2) ), *(float*)&x197
) - (float)(int)(* (( (ptr) m←v12200)+6) )), tf196) < (
x198 = (* (( (ptr) gf←c100220)+6)/* fuzz←v6220 */ ), *(float*)&x198
))) {
tc195 = (word) (unsigned) (FABS(((
x200 = (* (( (ptr) m←v12200)+5) ), *(float*)&x200
) - (float)(int)(* (( (ptr) m←v12200)+7) )), tf199) < (
x201 = (* (( (ptr) gf←c100220)+6)/* fuzz←v6220 */ ), *(float*)&x201
));
}
else {
tc195 = (word) (unsigned) 0;
};
return(tc195);
};
}
static void RasterDoWithBuffer←P1920(formal←c0919, formal←c0920, formal←c0921, formal←c0922, formal←c0923, formal←c0924, formal←c0925)
word formal←c0919;
word formal←c0920;
word formal←c0921;
word formal←c0922;
word formal←c0923;
word formal←c0924;
word formal←c0925;
{
W24 var←c100252;
/* declaration of context←v12304 skipped */
/* declaration of action←v12332 skipped */
/* declaration of x←v12360 skipped */
/* declaration of y←v12388 skipped */
/* declaration of w←v12416 skipped */
/* declaration of h←v12444 skipped */
/* declaration of backgroundColor←v12472 skipped */
register ptr gf←c100284 = (ptr) &globalframe;
/* declaration of var←c95164 skipped */
/* declaration of state←v21408 skipped */
/* declaration of rasterData←v21436 skipped */
(* (( (ptr) &var←c100252)+4)/* context←v12304 */ ) = formal←c0919;
(* (( (ptr) &var←c100252)+5)/* action←v12332 */ ) = formal←c0920;
(* (( (ptr) &var←c100252)+6)/* x←v12360 */ ) = formal←c0921;
(* (( (ptr) &var←c100252)+7)/* y←v12388 */ ) = formal←c0922;
(* (( (ptr) &var←c100252)+8)/* w←v12416 */ ) = formal←c0923;
(* (( (ptr) &var←c100252)+9)/* h←v12444 */ ) = formal←c0924;
(* (( (ptr) &var←c100252)+10)/* backgroundColor←v12472 */ ) = formal←c0925;
/* RasterDoWithBuffer: */
SOURCE(23804, 1785)
{
word tmpAddr202;
tmpAddr202 = (word) (( (ptr) &var←c100252)+11)/* var←c95164 */ ;
(* (ptr) tmpAddr202 ) = ( ((word) (fPt) fillAction←P5820) );
(* (( (ptr) tmpAddr202) + 1) ) = 1;
};
SOURCE(23911, 28)
(* (( (ptr) &var←c100252)+13)/* state←v21408 */ ) = (* (( (ptr) (* (( (ptr) &var←c100252)+4)/* context←v12304 */ ))+1) );
SOURCE(23941, 41)
(* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) = (* (( (ptr) (* (( (ptr) &var←c100252)+13)/* state←v21408 */ ))+40)
);
SOURCE(23984, 1472)
if ((* (( (bPt) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+5) ))+3) ) & 02) {
SOURCE(24040, 1416)
{
word tc203;
word pd204;
pd204 = (* (( (ptr) (* (( (ptr) gf←c100284)+175)/* var←c92796 */ ))+48) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd204 ))))((* ((( (ptr) (* (( (ptr) &var←c100252)+13)/* state←v21408 */ ))+33)) ), pd204)
)) {
tc203 = (word) (0 != (word) IntegerTranslation←P1860((* ((( (ptr) (* (( (ptr) &var←c100252)+13)/* state←v21408 */ ))+33)
) )));
}
else {
tc203 = (word) 0;
};
if (tc203) {
SOURCE(24155, 1303)
{
/* declaration of oldDeviceClipBox←v21480 skipped */
/* declaration of box←v21508 skipped */
SOURCE(24157, 57)
(* (W4Pt) (( (ptr) &var←c100252)+15)/* oldDeviceClipBox←v21480 */ ) = (* (W4Pt) (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)
/* rasterData←v21436 */ ) ))+6) ))+1) );
SOURCE(24216, 170)
{
W4 var←c95196;
{
word pd205;
pd205 = (* (( (ptr) (* (( (ptr) gf←c100284)+185)/* var←c94844 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd205 ))))((word) &var←c95196, (* (W4Pt) (* (( (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ))+3)
) ), (* (W4Pt) (( (ptr) &var←c100252)+15)/* oldDeviceClipBox←v21480 */ ), pd205);
};
{
W4 var←c0382;
{
word pd206;
pd206 = (* (( (ptr) (* (( (ptr) gf←c100284)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd206 ))))((word) &var←c0382, (* (( (ptr) (* (( (ptr) &var←c100252)+13)/* state←v21408 */ ))+33)
), (* (( (ptr) &var←c100252)+6)/* x←v12360 */ ), (* (( (ptr) &var←c100252)+7)/* y←v12388 */ ), (* (( (ptr) &var←c100252)+8)
/* w←v12416 */ ), (* (( (ptr) &var←c100252)+9)/* h←v12444 */ )
, var←c95196, pd206);
};
(* (W4Pt) (( (ptr) &var←c100252)+19)/* box←v21508 */ ) = var←c0382;
};
};
SOURCE(24580, 28)
{
word pd207;
pd207 = (* (( (ptr) (* (( (ptr) gf←c100284)+185)/* var←c94844 */ ))+14) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd207 ))))((* (W4Pt) ((( (ptr) &var←c100252)+19)/* box←v21508 */ ) ), pd207))) {
SOURCE(24602, 6)
return;
};
};
SOURCE(24610, 36)
(* (W4Pt) (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+6) ))+1) ) = (* (W4Pt) (
( (ptr) &var←c100252)+19)/* box←v21508 */ );
SOURCE(24648, 41)
(* (( (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ )) + 1) ) &= 2147483647;
SOURCE(24691, 41)
(void) Validate←P480((* (( (ptr) &var←c100252)+13)/* state←v21408 */ ), 2147483648);
SOURCE(24734, 617)
if (((* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+1) ))+4) ) != 0)) {
SOURCE(24796, 213)
{
word var←c95228;
{
word pd208;
if (((* (( (ptr) &var←c100252)+10)/* backgroundColor←v12472 */ ) == 0) || ( (int)(* (( (ptr) (* (( (ptr) &var←c100252)+13)
/* state←v21408 */ ))+19) ) != (int)0)) {
var←c95228 = (unsigned) 1;
}
else {
pd208 = (* (( (ptr) (* (( (ptr) gf←c100284)+185)/* var←c94844 */ ))+21) );
var←c95228 = (unsigned) (0 == (word) ( *( (fPt) ((* (ptr) pd208 ))))((* (W4Pt) (( (ptr) &var←c100252)+19)/* box←v21508 */ ), (* (W4Pt) (* (
/*1*/ ( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+1) ))+4) ) ), pd208));
};
};
{
word pd209;
pd209 = (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+4) ))+11) );
(void) ( *( (fPt) ((* (ptr) pd209 ))))((* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ), (* (W4Pt) (
/*1*/ ( (ptr) &var←c100252)+19)/* box←v21508 */ ), var←c95228, 1, pd209);
};
};
SOURCE(25011, 236)
{
/* declaration of var←c01 skipped */
(* (( (ptr) &var←c100252)+23)/* var←c01 */ ) = (* (( (ptr) (* (( (ptr) gf←c100284)+179)/* var←c93532 */ ))+13) );
{
word var←c0870;
var←c0870 = (word) &var←c100252;
(void) (word) XR←Enable(( ((word) (fPt) NoName←Q11688) ), ( ((word) (fPt) NoName←Q11868) ), var←c0870);
};
};
SOURCE(25251, 100)
{
word pd210;
pd210 = (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+4) ))+11) );
(void) ( *( (fPt) ((* (ptr) pd210 ))))((* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ), (* (W4Pt) (
( (ptr) &var←c100252)+19)/* box←v21508 */ ), 1, 0, pd210);
};
};
SOURCE(25356, 49)
(* (W4Pt) (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ ) ))+6) ))+1) ) = (* (W4Pt) (
( (ptr) &var←c100252)+15)/* oldDeviceClipBox←v21480 */ );
SOURCE(25407, 41)
(* (( (ptr) (* (( (ptr) &var←c100252)+14)/* rasterData←v21436 */ )) + 1) ) &= 2147483647;
SOURCE(25450, 6)
return;
};
};
};
};
SOURCE(25464, 125)
{
word pd211;
pd211 = (* (( (ptr) (* (( (ptr) gf←c100284)+178)/* var←c92988 */ ))+12) );
(void) ( *( (fPt) ((* (ptr) pd211 ))))((* (( (ptr) &var←c100252)+4)/* context←v12304 */ ), (* (( (ptr) &var←c100252)+5)
/* action←v12332 */ ), (* (( (ptr) &var←c100252)+6)/* x←v12360 */ ), (* (( (ptr) &var←c100252)+7)/* y←v12388 */ ), (* (
( (ptr) &var←c100252)+8)/* w←v12416 */ ), (* (( (ptr) &var←c100252)+9)/* h←v12444 */ )
, (* (( (ptr) &var←c100252)+10)/* backgroundColor←v12472 */ ), pd211);
};
}
static word NoName←Q11688(formal←c0807)
word formal←c0807;
{
SOURCE(25011, 236)
{
word pd212;
pd212 = (* (( (ptr) formal←c0807)+23) );
(void) ( *( (fPt) ((* (ptr) pd212 ))))((* (( (ptr) formal←c0807)+4) ), ( ((* (( (ptr) formal←c0807)+10) ) == 0) ? (* (( (ptr) formal←c0807)+5)
) : (word) (( (bPt) formal←c0807)+44) ) , pd212);
};
return(0);
}
static void fillAction←P5820(formal←c100348)
word formal←c100348;
{
register ptr gf←c100316 = (ptr) &globalframe;
word savedColor←v21596;
formal←c100348 = (formal←c100348 - 44);
/* fillAction: */
SOURCE(24388, 19)
SOURCE(24409, 31)
savedColor←v21596 = (* (( (ptr) (* (( (ptr) formal←c100348)+13) ))+36) );
SOURCE(24442, 41)
{
word pd213;
pd213 = (* (( (ptr) (* (( (ptr) gf←c100316)+179)/* var←c93532 */ ))+52) );
(void) ( *( (fPt) ((* (ptr) pd213 ))))((* (( (ptr) formal←c100348)+4) ), (* (( (ptr) formal←c100348)+10) ), pd213);
};
SOURCE(24485, 42)
{
word pd214;
pd214 = (* (( (ptr) (* (( (ptr) gf←c100316)+179)/* var←c93532 */ ))+66) );
(void) ( *( (fPt) ((* (ptr) pd214 ))))((* (( (ptr) formal←c100348)+4) ), (* (( (ptr) formal←c100348)+6) ), (* (( (ptr) formal←c100348)+7)
), (* (( (ptr) formal←c100348)+8) ), (* (( (ptr) formal←c100348)+9) ), pd214);
};
SOURCE(24529, 36)
{
word pd215;
pd215 = (* (( (ptr) (* (( (ptr) gf←c100316)+179)/* var←c93532 */ ))+52) );
(void) ( *( (fPt) ((* (ptr) pd215 ))))((* (( (ptr) formal←c100348)+4) ), savedColor←v21596, pd215);
};
SOURCE(24567, 8)
{
word pd216;
pd216 = (* (( (ptr) formal←c100348)+5) );
(void) ( *( (fPt) ((* (ptr) pd216 ))))(pd216);
};
}
static void RasterViewReset←P1980(context←v12548)
word context←v12548;
{
register ptr gf←c100380 = (ptr) &globalframe;
word state←v21640;
word rasterData←v21668;
word T←v21696;
/* RasterViewReset: */
SOURCE(25595, 869)
SOURCE(25640, 28)
state←v21640 = (* (( (ptr) context←v12548)+1) );
SOURCE(25670, 41)
rasterData←v21668 = (* (( (ptr) state←v21640)+40) );
SOURCE(25713, 50)
{
word pd217;
pd217 = (* (( (ptr) (* (( (ptr) gf←c100380)+177)/* var←c92956 */ ))+18) );
T←v21696 = (word) ( *( (fPt) ((* (ptr) pd217 ))))(context←v12548, pd217);
};
SOURCE(25765, 49)
(* (W10Pt) (* (( (ptr) state←v21640)+34) ) ) = (* (W10Pt) (* (( (ptr) rasterData←v21668)+2) ) );
SOURCE(25816, 161)
if (((* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v21668 ))+5) ))+6) ) != 1)) {
SOURCE(25872, 105)
{
word pd218;
float tf219;
pd218 = (* (( (ptr) (* (( (ptr) gf←c100380)+175)/* var←c92796 */ ))+25) );
(void) ( *( (fPt) ((* (ptr) pd218 ))))((* (( (ptr) state←v21640)+34) ), (
tf219 = (float)(unsigned)(* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v21668 ))+5) ))+6) ), *(word*)&tf219
), pd218);
};
};
SOURCE(25979, 101)
{
word var←c95260;
word var←c95292;
word var←c95324;
var←c95260 = (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v21668 ))+5) ))+1) );
var←c95292 = (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v21668 ))+5) ))+2) );
var←c95324 = (* (( (ptr) rasterData←v21668)+3) );
(* (ptr) var←c95324 ) = 0;
(* (( (ptr) var←c95324)+1) ) = 0;
(* (( (ptr) var←c95324)+2) ) = var←c95260;
(* (( (ptr) var←c95324)+3) ) = var←c95292;
};
SOURCE(26082, 56)
{
word pd220;
pd220 = (* (( (ptr) (* (( (ptr) gf←c100380)+182)/* var←c94236 */ ))+9) );
(void) ( *( (fPt) ((* (ptr) pd220 ))))((* ((( (ptr) (* (( (ptr) rasterData←v21668)+3) ))+4)) ), pd220);
};
SOURCE(26140, 95)
{
word pd221;
pd221 = (* (( (ptr) (* (( (ptr) gf←c100380)+182)/* var←c94236 */ ))+7) );
(* (( (ptr) (* (( (ptr) rasterData←v21668)+3) ))+4) ) = (word) ( *( (fPt) ((* (ptr) pd221 ))))((* (W4Pt) ((* (( (ptr) rasterData←v21668)+3)
)) ), pd221);
};
SOURCE(26237, 41)
(* (( (ptr) rasterData←v21668) + 1) ) &= 2147483647;
SOURCE(26280, 33)
(* (( (ptr) rasterData←v21668) + 1) ) &= 3221225471;
SOURCE(26315, 36)
(* (( (ptr) rasterData←v21668) + 1) ) &= 3758096383;
SOURCE(26353, 33)
{
word pd222;
pd222 = (* (( (ptr) (* (( (ptr) gf←c100380)+177)/* var←c92956 */ ))+12) );
(void) ( *( (fPt) ((* (ptr) pd222 ))))(context←v12548, T←v21696, pd222);
};
SOURCE(26388, 31)
{
word pd223;
pd223 = (* (( (ptr) (* (( (ptr) gf←c100380)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd223 ))))(T←v21696, pd223);
};
SOURCE(26421, 43)
{
W2 var←c95356;
var←c95356.f0 = (* (ptr) &fc70 );
var←c95356.f1 = (* (ptr) &fc70 );
{
word pd224;
pd224 = (* (( (ptr) (* (( (ptr) gf←c100380)+177)/* var←c92956 */ ))+27) );
(void) ( *( (fPt) ((* (ptr) pd224 ))))(context←v12548, var←c95356, pd224);
};
};
}
static void RasterViewTranslateI←P2040(context←v12608, x←v12636, y←v12664)
word context←v12608;
word x←v12636;
word y←v12664;
{
register ptr gf←c100412 = (ptr) &globalframe;
word state←v21740;
word rasterData←v21768;
word T←v21796;
/* RasterViewTranslateI: */
SOURCE(26470, 405)
SOURCE(26535, 28)
state←v21740 = (* (( (ptr) context←v12608)+1) );
SOURCE(26565, 41)
rasterData←v21768 = (* (( (ptr) state←v21740)+40) );
SOURCE(26608, 50)
{
word pd225;
pd225 = (* (( (ptr) (* (( (ptr) gf←c100412)+177)/* var←c92956 */ ))+18) );
T←v21796 = (word) ( *( (fPt) ((* (ptr) pd225 ))))(context←v12608, pd225);
};
SOURCE(26660, 66)
{
W2 var←c95388;
{
float tf226;
var←c95388.f0 = (
tf226 = (float)(int)x←v12636, *(word*)&tf226
);
};
{
float tf227;
var←c95388.f1 = (
tf227 = (float)(int)y←v12664, *(word*)&tf227
);
};
{
word pd228;
pd228 = (* (( (ptr) (* (( (ptr) gf←c100412)+175)/* var←c92796 */ ))+28) );
(void) ( *( (fPt) ((* (ptr) pd228 ))))((* (( (ptr) state←v21740)+34) ), var←c95388, pd228);
};
};
SOURCE(26728, 33)
{
word pd229;
pd229 = (* (( (ptr) (* (( (ptr) gf←c100412)+177)/* var←c92956 */ ))+12) );
(void) ( *( (fPt) ((* (ptr) pd229 ))))(context←v12608, T←v21796, pd229);
};
SOURCE(26763, 31)
{
word pd230;
pd230 = (* (( (ptr) (* (( (ptr) gf←c100412)+175)/* var←c92796 */ ))+5) );
(void) ( *( (fPt) ((* (ptr) pd230 ))))(T←v21796, pd230);
};
SOURCE(26796, 41)
(* (( (ptr) rasterData←v21768) + 1) ) &= 2147483647;
SOURCE(26839, 36)
(* (( (ptr) rasterData←v21768) + 1) ) &= 3758096383;
}
static void RasterViewClipRectangleI←P2100(context←v12724, formal←c0926, formal←c0927, formal←c0928, formal←c0929, exclude←v12864)
word context←v12724;
word formal←c0926;
word formal←c0927;
word formal←c0928;
word formal←c0929;
word exclude←v12864;
{
W10 var←c100444;
/* declaration of x←v12752 skipped */
/* declaration of y←v12780 skipped */
/* declaration of w←v12808 skipped */
/* declaration of h←v12836 skipped */
register ptr gf←c100476 = (ptr) &globalframe;
/* declaration of var←c95420 skipped */
word state←v21840;
word rasterData←v21868;
word viewToDevice←v21896;
(* (( (ptr) &var←c100444)+4)/* x←v12752 */ ) = formal←c0926;
(* (( (ptr) &var←c100444)+5)/* y←v12780 */ ) = formal←c0927;
(* (( (ptr) &var←c100444)+6)/* w←v12808 */ ) = formal←c0928;
(* (( (ptr) &var←c100444)+7)/* h←v12836 */ ) = formal←c0929;
/* RasterViewClipRectangleI: */
SOURCE(26881, 1045)
{
word tmpAddr231;
tmpAddr231 = (word) (( (ptr) &var←c100444)+8)/* var←c95420 */ ;
(* (ptr) tmpAddr231 ) = ( ((word) (fPt) path←P6024) );
(* (( (ptr) tmpAddr231) + 1) ) = 1;
};
SOURCE(26971, 28)
state←v21840 = (* (( (ptr) context←v12724)+1) );
SOURCE(27001, 41)
rasterData←v21868 = (* (( (ptr) state←v21840)+40) );
SOURCE(27044, 49)
viewToDevice←v21896 = (* (( (ptr) state←v21840)+34) );
SOURCE(27095, 831)
{
word pd232;
pd232 = (* (( (ptr) (* (( (ptr) gf←c100476)+175)/* var←c92796 */ ))+48) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd232 ))))(viewToDevice←v21896, pd232))) {
SOURCE(27157, 595)
{
word old←v21940;
W4 box←v21968;
word v←v21996;
SOURCE(27159, 55)
old←v21940 = (* (( (ptr) (* (( (ptr) rasterData←v21868)+3) ))+4) );
SOURCE(27216, 130)
{
word pd233;
pd233 = (* (( (ptr) (* (( (ptr) gf←c100476)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd233 ))))((word) &box←v21968, viewToDevice←v21896, (* (( (ptr) &var←c100444)+4)/* x←v12752 */ ), (* (
( (ptr) &var←c100444)+5)/* y←v12780 */ ), (* (( (ptr) &var←c100444)+6)/* w←v12808 */ ), (* (( (ptr) &var←c100444)+7)/* h←v12836 */ )
, (* (W4Pt) (* (( (ptr) rasterData←v21868)+3) ) ), pd233);
};
SOURCE(27348, 53)
v←v21996 = (* (( (ptr) (* (( (ptr) rasterData←v21868)+3) ))+4) );
SOURCE(27403, 202)
if ((0 != exclude←v12864)) {
SOURCE(27419, 136)
{
word t←v22040;
SOURCE(27421, 56)
{
word pd234;
pd234 = (* (( (ptr) (* (( (ptr) gf←c100476)+182)/* var←c94236 */ ))+7) );
t←v22040 = (word) ( *( (fPt) ((* (ptr) pd234 ))))(box←v21968, pd234);
};
SOURCE(27479, 47)
{
word pd235;
pd235 = (* (( (ptr) (* (( (ptr) gf←c100476)+182)/* var←c94236 */ ))+27) );
v←v21996 = (word) ( *( (fPt) ((* (ptr) pd235 ))))(v←v21996, t←v22040, pd235);
};
SOURCE(27528, 27)
{
word pd236;
pd236 = (* (( (ptr) (* (( (ptr) gf←c100476)+182)/* var←c94236 */ ))+9) );
(void) ( *( (fPt) ((* (ptr) pd236 ))))(t←v22040, pd236);
};
};
}
else {
SOURCE(27562, 43)
{
word pd237;
pd237 = (* (( (ptr) (* (( (ptr) gf←c100476)+182)/* var←c94236 */ ))+26) );
v←v21996 = (word) ( *( (fPt) ((* (ptr) pd237 ))))(v←v21996, box←v21968, pd237);
};
};
SOURCE(27607, 35)
(* (( (ptr) (* (( (ptr) rasterData←v21868)+3) ))+4) ) = v←v21996;
SOURCE(27644, 63)
{
word pd238;
pd238 = (* (( (ptr) (* (( (ptr) gf←c100476)+182)/* var←c94236 */ ))+16) );
(void) ( *( (fPt) ((* (ptr) pd238 ))))((* (( (ptr) rasterData←v21868)+3) ), v←v21996, pd238);
};
SOURCE(27709, 41)
(* (( (ptr) rasterData←v21868) + 1) ) &= 2147483647;
};
}
else {
SOURCE(27759, 169)
SOURCE(27848, 78)
(void) RasterViewClip←P2220(context←v12724, (word) (( (bPt) &var←c100444)+32)/* var←c95420 */ , 0, exclude←v12864);
};
};
}
static void path←P6024(moveTo←v84392, lineTo←v84420, curveTo←v84448, conicTo←v84476, arcTo←v84504, formal←c100508)
word moveTo←v84392;
word lineTo←v84420;
word curveTo←v84448;
word conicTo←v84476;
word arcTo←v84504;
word formal←c100508;
{
formal←c100508 = (formal←c100508 - 32);
/* path: */
SOURCE(27761, 17)
SOURCE(27779, 13)
{
W2 var←c95452;
{
float tf239;
var←c95452.f0 = (
tf239 = (float)(int)(* (( (ptr) formal←c100508)+4) ), *(word*)&tf239
);
};
{
float tf240;
var←c95452.f1 = (
tf240 = (float)(int)(* (( (ptr) formal←c100508)+5) ), *(word*)&tf240
);
};
(void) ( *( (fPt) ((* (ptr) moveTo←v84392 ))))(var←c95452, moveTo←v84392);
};
SOURCE(27794, 15)
{
W2 var←c95484;
{
float tf241;
var←c95484.f0 = (
tf241 = (float)(int)((* (( (ptr) formal←c100508)+4) ) + (* (( (ptr) formal←c100508)+6) )), *(word*)&tf241
);
};
{
float tf242;
var←c95484.f1 = (
tf242 = (float)(int)(* (( (ptr) formal←c100508)+5) ), *(word*)&tf242
);
};
(void) ( *( (fPt) ((* (ptr) lineTo←v84420 ))))(var←c95484, lineTo←v84420);
};
SOURCE(27811, 17)
{
W2 var←c95516;
{
float tf243;
var←c95516.f0 = (
tf243 = (float)(int)((* (( (ptr) formal←c100508)+4) ) + (* (( (ptr) formal←c100508)+6) )), *(word*)&tf243
);
};
{
float tf244;
var←c95516.f1 = (
tf244 = (float)(int)((* (( (ptr) formal←c100508)+5) ) + (* (( (ptr) formal←c100508)+7) )), *(word*)&tf244
);
};
(void) ( *( (fPt) ((* (ptr) lineTo←v84420 ))))(var←c95516, lineTo←v84420);
};
SOURCE(27830, 15)
{
W2 var←c95548;
{
float tf245;
var←c95548.f0 = (
tf245 = (float)(int)(* (( (ptr) formal←c100508)+4) ), *(word*)&tf245
);
};
{
float tf246;
var←c95548.f1 = (
tf246 = (float)(int)((* (( (ptr) formal←c100508)+5) ) + (* (( (ptr) formal←c100508)+7) )), *(word*)&tf246
);
};
(void) ( *( (fPt) ((* (ptr) lineTo←v84420 ))))(var←c95548, lineTo←v84420);
};
}
static word RasterGetTransformation←P2160(context←v12924, from←v12952, to←v12980)
word context←v12924;
word from←v12952;
word to←v12980;
{
register ptr gf←c100540 = (ptr) &globalframe;
word var←c13024;
word state←v22128;
word rasterData←v22156;
word m←v22184 = 0;
/* RasterGetTransformation: */
SOURCE(27935, 786)
SOURCE(28033, 28)
state←v22128 = (* (( (ptr) context←v12924)+1) );
SOURCE(28063, 41)
rasterData←v22156 = (* (( (ptr) state←v22128)+40) );
SOURCE(28131, 252)
{
word var←c95580;
var←c95580 = to←v12980;
switch (var←c95580) {
case 0:
SOURCE(28156, 51)
{
word pd247;
pd247 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+6) );
m←v22184 = (word) ( *( (fPt) ((* (ptr) pd247 ))))((* ((( (ptr) state←v22128)+33)) ), pd247);
};
break;
case 1:
SOURCE(28217, 49)
{
word pd248;
pd248 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+6) );
m←v22184 = (word) ( *( (fPt) ((* (ptr) pd248 ))))((* ((( (ptr) state←v22128)+34)) ), pd248);
};
break;
case 2:
SOURCE(28279, 57)
{
word pd249;
pd249 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+6) );
m←v22184 = (word) ( *( (fPt) ((* (ptr) pd249 ))))((* ((( (ptr) rasterData←v22156)+2)) ), pd249);
};
break;
case 3:
SOURCE(28348, 35)
{
word pd250;
pd250 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+7) );
m←v22184 = (word) ( *( (fPt) ((* (ptr) pd250 ))))((* (ptr) (&fc61) ), pd250);
};
break;
default:
SOURCE(28396, 5)
(void) XR←RaiseUnnamedError();
break;
};
};
SOURCE(28403, 35)
{
word pd251;
pd251 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+38) );
(void) ( *( (fPt) ((* (ptr) pd251 ))))(m←v22184, pd251);
};
SOURCE(28440, 234)
{
word var←c95612;
var←c95612 = from←v12952;
switch (var←c95612) {
case 0:
SOURCE(28467, 60)
{
word pd252;
pd252 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+24) );
(void) ( *( (fPt) ((* (ptr) pd252 ))))(m←v22184, (* (( (ptr) state←v22128)+33) ), pd252);
};
break;
case 1:
SOURCE(28537, 58)
{
word pd253;
pd253 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+24) );
(void) ( *( (fPt) ((* (ptr) pd253 ))))(m←v22184, (* (( (ptr) state←v22128)+34) ), pd253);
};
break;
case 2:
SOURCE(28608, 66)
{
word pd254;
pd254 = (* (( (ptr) (* (( (ptr) gf←c100540)+175)/* var←c92796 */ ))+24) );
(void) ( *( (fPt) ((* (ptr) pd254 ))))(m←v22184, (* (( (ptr) rasterData←v22156)+2) ), pd254);
};
break;
case 3:
break;
default:
SOURCE(28703, 5)
(void) XR←RaiseUnnamedError();
break;
};
};
SOURCE(28710, 11)
return(m←v22184);
}
static void RasterViewClip←P2220(context←v13084, path←v13112, oddWrap←v13140, exclude←v13168)
word context←v13084;
word path←v13112;
word oddWrap←v13140;
word exclude←v13168;
{
register ptr gf←c100572 = (ptr) &globalframe;
word state←v22228;
word rasterData←v22256;
word this←v22284 = 0;
word Combine←v22312;
word devicePath←v22340;
/* RasterViewClip: */
SOURCE(28725, 1005)
SOURCE(28815, 28)
state←v22228 = (* (( (ptr) context←v13084)+1) );
SOURCE(28845, 41)
rasterData←v22256 = (* (( (ptr) state←v22228)+40) );
SOURCE(28912, 15)
Combine←v22312 = ( (0 != exclude←v13168) ? (* (( (ptr) (* (( (ptr) gf←c100572)+182)/* var←c94236 */ ))+27) ) : (* (( (ptr) (* (
( (ptr) gf←c100572)+182)/* var←c94236 */ ))+25) ) ) ;
SOURCE(29084, 73)
{
word pd255;
pd255 = (* (( (ptr) (* (( (ptr) gf←c100572)+187)/* var←c95644 */ ))+5) );
devicePath←v22340 = (word) ( *( (fPt) ((* (ptr) pd255 ))))(pd255);
};
SOURCE(29159, 141)
{
word pd256;
pd256 = (* (( (ptr) (* (( (ptr) gf←c100572)+187)/* var←c95644 */ ))+8) );
(void) ( *( (fPt) ((* (ptr) pd256 ))))(devicePath←v22340, path←v13112, (* (( (ptr) state←v22228)+34) ), (* (W4Pt) (* (( (ptr) rasterData←v22256)+3)
) ), pd256);
};
SOURCE(29302, 136)
{
word pd257;
pd257 = (* (( (ptr) (* (( (ptr) gf←c100572)+187)/* var←c95644 */ ))+19) );
this←v22284 = (word) ( *( (fPt) ((* (ptr) pd257 ))))(devicePath←v22340, oddWrap←v13140, (* (W4Pt) (* (( (ptr) rasterData←v22256)+3)
) ), pd257);
};
SOURCE(29440, 80)
(* (( (ptr) (* (( (ptr) rasterData←v22256)+3) ))+4) ) = (word) ( *( (fPt) ((* (ptr) Combine←v22312 ))))((* (( (ptr) (* (
( (ptr) rasterData←v22256)+3) ))+4) ), this←v22284, Combine←v22312);
SOURCE(29522, 29)
{
word pd258;
pd258 = (* (( (ptr) (* (( (ptr) gf←c100572)+182)/* var←c94236 */ ))+9) );
(void) ( *( (fPt) ((* (ptr) pd258 ))))(this←v22284, pd258);
};
SOURCE(29553, 39)
{
word pd259;
pd259 = (* (( (ptr) (* (( (ptr) gf←c100572)+187)/* var←c95644 */ ))+6) );
(void) ( *( (fPt) ((* (ptr) pd259 ))))(devicePath←v22340, pd259);
};
SOURCE(29594, 93)
{
word pd260;
pd260 = (* (( (ptr) (* (( (ptr) gf←c100572)+182)/* var←c94236 */ ))+16) );
(void) ( *( (fPt) ((* (ptr) pd260 ))))((* (( (ptr) rasterData←v22256)+3) ), (* (( (ptr) (* (( (ptr) rasterData←v22256)+3)
))+4) ), pd260);
};
SOURCE(29689, 41)
(* (( (ptr) rasterData←v22256) + 1) ) &= 2147483647;
}
static word IsAllInteger←P2280(m←v13228)
word m←v13228;
{
W6 var←c100604;
register ptr gf←c100636 = (ptr) &globalframe;
word var←c13272;
/* declaration of var←c95676 skipped */
/* IsAllInteger: */
SOURCE(29841, 373)
{
word tmpAddr261;
tmpAddr261 = (word) (( (ptr) &var←c100604)+4)/* var←c95676 */ ;
(* (ptr) tmpAddr261 ) = ( ((word) (fPt) Is←P6084) );
(* (( (ptr) tmpAddr261) + 1) ) = 1;
};
SOURCE(30105, 109)
{
word tc262;
word tc263;
word tc264;
word tc265;
float tf266;
word x267;
word x268;
float tf269;
word x270;
word x271;
if ( ( (0 != (word) Is←P6084((* (ptr) m←v13228 ), (word) (( (bPt) &var←c100604)+16)/* var←c95676 */ )) ? (0 != (word) Is←P6084(
(* (( (ptr) m←v13228)+1) ), (word) (( (bPt) &var←c100604)+16)/* var←c95676 */ )) : 0 ) ) {
tc265 = (word) (FABS((
x267 = (* (( (ptr) m←v13228)+2) ), *(float*)&x267
), tf266) <= (
x268 = (* (( (ptr) gf←c100636)+8)/* bigTranslate←v6500 */ ), *(float*)&x268
));
}
else {
tc265 = (word) 0;
};
if (tc265) {
tc264 = (word) (0 != (word) Is←P6084((* (( (ptr) m←v13228)+3) ), (word) (( (bPt) &var←c100604)+16)/* var←c95676 */ ));
}
else {
tc264 = (word) 0;
};
if (tc264) {
tc263 = (word) (0 != (word) Is←P6084((* (( (ptr) m←v13228)+4) ), (word) (( (bPt) &var←c100604)+16)/* var←c95676 */ ));
}
else {
tc263 = (word) 0;
};
if (tc263) {
tc262 = (word) (unsigned) (FABS((
x270 = (* (( (ptr) m←v13228)+5) ), *(float*)&x270
), tf269) <= (
x271 = (* (( (ptr) gf←c100636)+8)/* bigTranslate←v6500 */ ), *(float*)&x271
));
}
else {
tc262 = (word) (unsigned) 0;
};
return(tc262);
};
}
static word Is←P6084(r←v22592, formal←c100700)
word r←v22592;
word formal←c100700;
{
register ptr gf←c100668 = (ptr) &globalframe;
word var←c22636;
formal←c100700 = (formal←c100700 - 16);
/* Is: */
SOURCE(29899, 201)
SOURCE(29937, 145)
{
word x272;
word x273;
word x274;
word x275;
if ( ( ((
x272 = r←v22592, *(float*)&x272
) >= - (
x273 = (* (( (ptr) gf←c100668)+7)/* worryReal←v6472 */ ), *(float*)&x273
)) ? ((
x274 = r←v22592, *(float*)&x274
) <= (
x275 = (* (( (ptr) gf←c100668)+7)/* worryReal←v6472 */ ), *(float*)&x275
)) : 0 ) ) {
SOURCE(29974, 110)
{
word ir←v22664;
SOURCE(29976, 23)
{
word pd276;
pd276 = (* (( (ptr) (* (( (ptr) gf←c100668)+184)/* var←c94620 */ ))+6) );
ir←v22664 = (word) ( *( (fPt) ((* (ptr) pd276 ))))(r←v22592, pd276);
};
SOURCE(30001, 27)
{
word x277;
if (((
x277 = r←v22592, *(float*)&x277
) == (float)(int)ir←v22664)) {
SOURCE(30016, 12)
return(1);
};
};
SOURCE(30030, 52)
{
word pd278;
float tf279;
pd278 = (* (( (ptr) (* (( (ptr) gf←c100668)+188)/* var←c95740 */ ))+39) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd278 ))))(r←v22592, (
tf279 = (float)(int)ir←v22664, *(word*)&tf279
), 108, pd278))) {
SOURCE(30070, 12)
return(1);
};
};
};
};
};
SOURCE(30087, 13)
return(0);
}
static void RasterMoveViewRectangle←P2340(context←v13332, width←v13360, height←v13388, fromX←v13416, fromY←v13444, toX←v13472, toY←v13500)
word context←v13332;
word width←v13360;
word height←v13388;
word fromX←v13416;
word fromY←v13444;
word toX←v13472;
word toY←v13500;
{
register ptr gf←c100732 = (ptr) &globalframe;
word state←v22708;
word rasterData←v22736;
word viewToDevice←v22764;
/* RasterMoveViewRectangle: */
SOURCE(30220, 2016)
SOURCE(30321, 28)
state←v22708 = (* (( (ptr) context←v13332)+1) );
SOURCE(30351, 41)
rasterData←v22736 = (* (( (ptr) state←v22708)+40) );
SOURCE(30394, 49)
viewToDevice←v22764 = (* (( (ptr) state←v22708)+34) );
SOURCE(30445, 35)
if (( (int)(* (( (ptr) state←v22708)+19) ) != (int)0)) {
SOURCE(30474, 6)
return;
};
SOURCE(30482, 642)
{
word tc280;
word pd281;
pd281 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+48) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd281 ))))(viewToDevice←v22764, pd281))) {
tc280 = (word) (((unsigned)(* (( (bPt) (* (( (ptr) (* (ptr) rasterData←v22736 ))+5) ))+3) ) << 29) >> 31);
}
else {
tc280 = (word) 0;
};
if (tc280) {
SOURCE(30589, 540)
{
W4 clipBox←v22808;
W4 srcBox←v22836;
W4 dstBox←v22864;
W2 size←v22892;
W2 var←c0468;
SOURCE(30591, 94)
{
word pd282;
pd282 = (* (( (ptr) (* (( (ptr) gf←c100732)+185)/* var←c94844 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd282 ))))((word) &clipBox←v22808, (* (W4Pt) (* (( (ptr) rasterData←v22736)+3) ) ), (* (W4Pt) (
( (ptr) (* (( (ptr) (* (ptr) rasterData←v22736 ))+6) ))+1) ), pd282);
};
SOURCE(30687, 127)
{
word pd283;
pd283 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd283 ))))((word) &srcBox←v22836, viewToDevice←v22764, fromX←v13416, fromY←v13444, width←v13360, height←v13388
, clipBox←v22808, pd283);
};
SOURCE(30816, 123)
{
word pd284;
pd284 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd284 ))))((word) &dstBox←v22864, viewToDevice←v22764, toX←v13472, toY←v13500, width←v13360, height←v13388
, clipBox←v22808, pd284);
};
SOURCE(30941, 30)
{
word pd285;
pd285 = (* (( (ptr) (* (( (ptr) gf←c100732)+185)/* var←c94844 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd285 ))))((word) &size←v22892, srcBox←v22836, pd285);
};
SOURCE(30973, 151)
{
word pd286;
pd286 = (* (( (ptr) (* (( (ptr) gf←c100732)+185)/* var←c94844 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd286 ))))((word) &var←c0468, dstBox←v22864, pd286);
};
if (XR←EqualWords(&var←c0468, &size←v22892, 2)) {
SOURCE(31006, 110)
{
word pd287;
pd287 = (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v22736 ))+4) ))+10) );
(void) ( *( (fPt) ((* (ptr) pd287 ))))((* (ptr) rasterData←v22736 ), (* (W2Pt) &dstBox←v22864 ), (* (W2Pt) &srcBox←v22836 ), size←v22892, pd287)
;
};
SOURCE(31118, 6)
return;
};
};
};
};
SOURCE(31132, 1009)
if ( ( ( ((* (( (ptr) viewToDevice←v22764)+9) ) != 0) ? (0 != (word) IsAllInteger←P2280(viewToDevice←v22764)) : 0 ) ? (((unsigned)(* (
( (bPt) (* (( (ptr) (* (ptr) rasterData←v22736 ))+5) ))+3) ) << 29) >> 31) : 0 ) ) {
SOURCE(31238, 908)
{
W4 srcRect←v22936;
W4 dstRect←v22964;
W4 clipBox←v22992;
W4 srcBox←v23020;
W4 dstBox←v23048;
W2 size←v23076;
W2 var←c0491;
SOURCE(31240, 123)
{
W4 var←c0471;
{
W4 var←c95772;
{
float tf288;
var←c95772.f0 = (
tf288 = (float)(int)fromX←v13416, *(word*)&tf288
);
};
{
float tf289;
var←c95772.f1 = (
tf289 = (float)(int)fromY←v13444, *(word*)&tf289
);
};
{
float tf290;
var←c95772.f2 = (
tf290 = (float)(int)width←v13360, *(word*)&tf290
);
};
{
float tf291;
var←c95772.f3 = (
tf291 = (float)(int)height←v13388, *(word*)&tf291
);
};
{
word pd292;
pd292 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+46) );
(void) ( *( (fPt) ((* (ptr) pd292 ))))((word) &var←c0471, viewToDevice←v22764, var←c95772, pd292);
};
};
srcRect←v22936 = var←c0471;
};
SOURCE(31365, 119)
{
W4 var←c0474;
{
W4 var←c95804;
{
float tf293;
var←c95804.f0 = (
tf293 = (float)(int)toX←v13472, *(word*)&tf293
);
};
{
float tf294;
var←c95804.f1 = (
tf294 = (float)(int)toY←v13500, *(word*)&tf294
);
};
{
float tf295;
var←c95804.f2 = (
tf295 = (float)(int)width←v13360, *(word*)&tf295
);
};
{
float tf296;
var←c95804.f3 = (
tf296 = (float)(int)height←v13388, *(word*)&tf296
);
};
{
word pd297;
pd297 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+46) );
(void) ( *( (fPt) ((* (ptr) pd297 ))))((word) &var←c0474, viewToDevice←v22764, var←c95804, pd297);
};
};
dstRect←v22964 = var←c0474;
};
SOURCE(31486, 94)
{
word pd298;
pd298 = (* (( (ptr) (* (( (ptr) gf←c100732)+185)/* var←c94844 */ ))+15) );
(void) ( *( (fPt) ((* (ptr) pd298 ))))((word) &clipBox←v22992, (* (W4Pt) (* (( (ptr) rasterData←v22736)+3) ) ), (* (W4Pt) (
( (ptr) (* (( (ptr) (* (ptr) rasterData←v22736 ))+6) ))+1) ), pd298);
};
SOURCE(31582, 186)
{
word var←c95836;
word var←c95868;
word var←c95900;
word var←c95932;
{
word pd299;
pd299 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c95836 = (word) ( *( (fPt) ((* (ptr) pd299 ))))(srcRect←v22936.f0, pd299);
};
{
word pd300;
pd300 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c95868 = (word) ( *( (fPt) ((* (ptr) pd300 ))))(srcRect←v22936.f1, pd300);
};
{
word pd301;
pd301 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c95900 = (word) ( *( (fPt) ((* (ptr) pd301 ))))(srcRect←v22936.f2, pd301);
};
{
word pd302;
pd302 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c95932 = (word) ( *( (fPt) ((* (ptr) pd302 ))))(srcRect←v22936.f3, pd302);
};
{
W4 var←c0482;
{
word pd303;
pd303 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd303 ))))((word) &var←c0482, (* (( (ptr) gf←c100732)+4)/* identity←v5156 */ ), var←c95836, var←c95868, var←c95900, var←c95932
, clipBox←v22992, pd303);
};
srcBox←v23020 = var←c0482;
};
};
SOURCE(31770, 186)
{
word var←c95964;
word var←c95996;
word var←c96028;
word var←c96060;
{
word pd304;
pd304 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c95964 = (word) ( *( (fPt) ((* (ptr) pd304 ))))(dstRect←v22964.f0, pd304);
};
{
word pd305;
pd305 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c95996 = (word) ( *( (fPt) ((* (ptr) pd305 ))))(dstRect←v22964.f1, pd305);
};
{
word pd306;
pd306 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c96028 = (word) ( *( (fPt) ((* (ptr) pd306 ))))(dstRect←v22964.f2, pd306);
};
{
word pd307;
pd307 = (* (( (ptr) (* (( (ptr) gf←c100732)+184)/* var←c94620 */ ))+6) );
var←c96060 = (word) ( *( (fPt) ((* (ptr) pd307 ))))(dstRect←v22964.f3, pd307);
};
{
W4 var←c0488;
{
word pd308;
pd308 = (* (( (ptr) (* (( (ptr) gf←c100732)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd308 ))))((word) &var←c0488, (* (( (ptr) gf←c100732)+4)/* identity←v5156 */ ), var←c95964, var←c95996, var←c96028, var←c96060
, clipBox←v22992, pd308);
};
dstBox←v23048 = var←c0488;
};
};
SOURCE(31958, 30)
{
word pd309;
pd309 = (* (( (ptr) (* (( (ptr) gf←c100732)+185)/* var←c94844 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd309 ))))((word) &size←v23076, srcBox←v23020, pd309);
};
SOURCE(31990, 151)
{
word pd310;
pd310 = (* (( (ptr) (* (( (ptr) gf←c100732)+185)/* var←c94844 */ ))+19) );
(void) ( *( (fPt) ((* (ptr) pd310 ))))((word) &var←c0491, dstBox←v23048, pd310);
};
if (XR←EqualWords(&var←c0491, &size←v23076, 2)) {
SOURCE(32023, 110)
{
word pd311;
pd311 = (* (( (ptr) (* (( (ptr) (* (ptr) rasterData←v22736 ))+4) ))+10) );
(void) ( *( (fPt) ((* (ptr) pd311 ))))((* (ptr) rasterData←v22736 ), (* (W2Pt) &dstBox←v23048 ), (* (W2Pt) &srcBox←v23020 ), size←v23076, pd311)
;
};
SOURCE(32135, 6)
return;
};
};
};
SOURCE(32149, 87)
{
W3 var←c0493;
var←c0493.f0 = 103;
var←c0493.f1 = (* (( (ptr) gf←c100732)+40) );
var←c0493.f2 = 0;
(void) XR←RaiseError((* (ptr) (* (( (ptr) (* (( (ptr) gf←c100732)+179)/* var←c93532 */ ))+6) ) ), (word) &var←c0493);
};
}
static word RasterGetBufferColorOperator←P2400(context←v13560)
word context←v13560;
{
word var←c13604;
word state←v23120;
word rasterData←v23148;
word device←v23176;
/* RasterGetBufferColorOperator: */
SOURCE(32242, 300)
SOURCE(32242, 300)
var←c13604 = 0;
SOURCE(32330, 28)
state←v23120 = (* (( (ptr) context←v13560)+1) );
SOURCE(32360, 41)
rasterData←v23148 = (* (( (ptr) state←v23120)+40) );
SOURCE(32403, 34)
device←v23176 = (* (ptr) rasterData←v23148 );
SOURCE(32439, 103)
if (((* (( (ptr) (* (( (ptr) device←v23176)+4) ))+12) ) != 0)) {
SOURCE(32489, 53)
{
word pd312;
pd312 = (* (( (ptr) (* (( (ptr) device←v23176)+4) ))+12) );
return((word) ( *( (fPt) ((* (ptr) pd312 ))))(device←v23176, pd312));
};
};
SOURCE(32242, 300)
return(var←c13604);
}
static void RasterAccessBuffer←P2460(context←v13664, formal←c0930, path←v13720, oddWrap←v13748)
word context←v13664;
word formal←c0930;
word path←v13720;
word oddWrap←v13748;
{
W8 var←c100764;
/* declaration of action←v13692 skipped */
register ptr gf←c100796 = (ptr) &globalframe;
/* declaration of var←c96156 skipped */
word state←v23220;
/* declaration of rasterData←v23248 skipped */
var←c100764.f4/* action←v13692 */ = formal←c0930;
/* RasterAccessBuffer: */
SOURCE(32549, 1146)
{
word tmpAddr313;
tmpAddr313 = (word) (( (ptr) &var←c100764)+5)/* var←c96156 */ ;
(* (ptr) tmpAddr313 ) = ( ((word) (fPt) outer←P6288) );
(* (( (ptr) tmpAddr313) + 1) ) = 1;
};
SOURCE(32663, 28)
state←v23220 = (* (( (ptr) context←v13664)+1) );
SOURCE(32693, 41)
var←c100764.f7/* rasterData←v23248 */ = (* (( (ptr) state←v23220)+40) );
SOURCE(33413, 88)
if (( (int)(* (( (ptr) state←v23220)+19) ) != (int)0) || ! ((* (( (bPt) (* (( (ptr) (* (ptr) var←c100764.f7/* rasterData←v23248 */ ))+5)
))+3) ) & 1)) {
SOURCE(33495, 6)
return;
};
SOURCE(33503, 26)
(void) Validate←P480(state←v23220, 2952790016);
SOURCE(33531, 164)
{
word pd314;
pd314 = (* (( (ptr) (* (( (ptr) gf←c100796)+189)/* var←c96188 */ ))+4) );
(void) ( *( (fPt) ((* (ptr) pd314 ))))((word) (( (bPt) &var←c100764)+20)/* var←c96156 */ , path←v13720, oddWrap←v13748, (* (
( (ptr) state←v23220)+33) ), (* (( (ptr) (* (ptr) var←c100764.f7/* rasterData←v23248 */ ))+1) ), pd314);
};
}
static void outer←P6288(bounds←v23352, formal←c0931, formal←c100860)
W4 bounds←v23352;
word formal←c0931;
word formal←c100860;
{
W7 var←c100828;
/* declaration of boxGenerator←v23380 skipped */
/* declaration of var←c96220 skipped */
formal←c100860 = (formal←c100860 - 20);
var←c100828.f4/* boxGenerator←v23380 */ = formal←c0931;
var←c100828.f0 = formal←c100860;
/* outer: */
SOURCE(32736, 672)
{
word tmpAddr315;
tmpAddr315 = (word) (( (ptr) &var←c100828)+5)/* var←c96220 */ ;
(* (ptr) tmpAddr315 ) = ( ((word) (fPt) inner←P6348) );
(* (( (ptr) tmpAddr315) + 1) ) = 1;
};
SOURCE(33338, 70)
{
word pd316;
pd316 = (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) formal←c100860)+7) ) ))+4) ))+13) );
(void) ( *( (fPt) ((* (ptr) pd316 ))))((* (ptr) (* (( (ptr) formal←c100860)+7) ) ), bounds←v23352, (word) (( (bPt) &var←c100828)+20)
/* var←c96220 */ , pd316);
};
}
static void inner←P6348(formal←c0932, formal←c100924)
word formal←c0932;
word formal←c100924;
{
W11 var←c100892;
/* declaration of pixelMap←v23484 skipped */
/* declaration of var←c96252 skipped */
/* declaration of pixelMapBox←v23512 skipped */
formal←c100924 = (formal←c100924 - 20);
(* (( (ptr) &var←c100892)+4)/* pixelMap←v23484 */ ) = formal←c0932;
(* (ptr) &var←c100892 ) = formal←c100924;
/* inner: */
SOURCE(32800, 533)
{
word tmpAddr317;
tmpAddr317 = (word) (( (ptr) &var←c100892)+5)/* var←c96252 */ ;
(* (ptr) tmpAddr317 ) = ( ((word) (fPt) boxAction←P6408) );
(* (( (ptr) tmpAddr317) + 1) ) = 1;
};
SOURCE(32837, 34)
(* (W4Pt) (( (ptr) &var←c100892)+7)/* pixelMapBox←v23512 */ ) = (* (W4Pt) (( (ptr) (* (( (ptr) &var←c100892)+4)/* pixelMap←v23484 */ ))+1)
);
SOURCE(33310, 23)
{
word pd318;
pd318 = (* (( (ptr) formal←c100924)+4) );
(void) ( *( (fPt) ((* (ptr) pd318 ))))((word) ((( (bPt) &var←c100892)+20)/* var←c96252 */ ), pd318);
};
}
static void boxAction←P6408(box←v23616, formal←c100988)
W4 box←v23616;
word formal←c100988;
{
register ptr gf←c100956 = (ptr) &globalframe;
formal←c100988 = (formal←c100988 - 20);
/* boxAction: */
SOURCE(32873, 429)
SOURCE(32907, 395)
if (XR←EqualWords(&box←v23616, (( (ptr) formal←c100988)+7), 4)) {
SOURCE(32933, 22)
{
word pd319;
pd319 = (* (( (ptr) (* (ptr) (* (ptr) formal←c100988 ) ))+4) );
(void) ( *( (fPt) ((* (ptr) pd319 ))))((* ((( (ptr) formal←c100988)+4)) ), pd319);
};
}
else {
SOURCE(32955, 349)
{
W5 a←v23644;
SOURCE(32957, 28)
XR←FillWords(&a←v23644, 5, 0);
SOURCE(32987, 18)
(* (W4Pt) (( (ptr) (* (( (ptr) formal←c100988)+4) ))+1) ) = box←v23616;
SOURCE(33007, 109)
{
register word i←v23724 = 0;
register word noName←c96316;
noName←c96316 = (* (( (ptr) (* (( (ptr) formal←c100988)+4) ))+5) );
if ((i←v23724 >= noName←c96316)) {
goto lab←L100027;
};
lab←L100030: ;
SOURCE(33054, 18)
{
word limit320;
(* (( (ptr) &a←v23644)+BCK(i←v23724, 5)) ) = (* ((( (ptr) (* (( (ptr) formal←c100988)+4) ))+6)+(
limit320 = (* (( (ptr) (* (( (ptr) formal←c100988)+4) ))+5) ),
BCK(i←v23724, limit320)
)) );
};
SOURCE(33074, 42)
{
word var←c96348;
{
word pd321;
pd321 = (* (( (ptr) (* (( (ptr) gf←c100956)+190)/* var←c96380 */ ))+27) );
var←c96348 = (word) ( *( (fPt) ((* (ptr) pd321 ))))((* (( (ptr) &a←v23644)+BCK(i←v23724, 5)) ), box←v23616, pd321);
};
{
word limit322;
(* ((( (ptr) (* (( (ptr) formal←c100988)+4) ))+6)+(
limit322 = (* (( (ptr) (* (( (ptr) formal←c100988)+4) ))+5) ),
BCK(i←v23724, limit322)
)) ) = var←c96348;
};
};
i←v23724 = (i←v23724 + 1);
if ((i←v23724 < noName←c96316)) {
goto lab←L100030;
};
lab←L100027: ;
};
SOURCE(33127, 16)
{
word pd323;
pd323 = (* (( (ptr) (* (ptr) (* (ptr) formal←c100988 ) ))+4) );
(void) ( *( (fPt) ((* (ptr) pd323 ))))((* ((( (ptr) formal←c100988)+4)) ), pd323);
};
SOURCE(33145, 120)
{
register word i←v23768 = 0;
register word noName←c96412;
noName←c96412 = (* (( (ptr) (* (( (ptr) formal←c100988)+4) ))+5) );
if ((i←v23768 >= noName←c96412)) {
goto lab←L100031;
};
lab←L100034: ;
SOURCE(33200, 44)
SOURCE(33201, 43)
{
word pd324;
word limit325;
pd324 = (* (( (ptr) (* (( (ptr) gf←c100956)+190)/* var←c96380 */ ))+30) );
(void) ( *( (fPt) ((* (ptr) pd324 ))))((* (((( (ptr) (* (( (ptr) formal←c100988)+4) ))+6)+(
limit325 = (* (( (ptr) (* (( (ptr) formal←c100988)+4) ))+5) ),
BCK(i←v23768, limit325)
))) ), pd324);
};
SOURCE(33247, 18)
{
word limit326;
(* ((( (ptr) (* (( (ptr) formal←c100988)+4) ))+6)+(
limit326 = (* (( (ptr) (* (( (ptr) formal←c100988)+4) ))+5) ),
BCK(i←v23768, limit326)
)) ) = (* (( (ptr) &a←v23644)+BCK(i←v23768, 5)) );
};
i←v23768 = (i←v23768 + 1);
if ((i←v23768 < noName←c96412)) {
goto lab←L100034;
};
lab←L100031: ;
};
SOURCE(33276, 26)
(* (W4Pt) (( (ptr) (* (( (ptr) formal←c100988)+4) ))+1) ) = (* (W4Pt) (( (ptr) formal←c100988)+7) );
};
};
}
static word CreateClass←P2520(type←v13868)
word type←v13868;
{
register ptr gf←c101020 = (ptr) &globalframe;
word var←c13912;
word class←v23812;
/* CreateClass: */
SOURCE(36402, 144)
SOURCE(36460, 52)
class←v23812 = XR←NewObject(280, (* (( (ptr) gf←c101020)+11) ));
(* (W70Pt) class←v23812 ) = (* (W70Pt) (* (( (ptr) gf←c101020)+9)/* rasterClassTemplate←v6640 */ ) );
SOURCE(36514, 17)
(* (ptr) class←v23812 ) = type←v13868;
SOURCE(36533, 13)
return(class←v23812);
}
static word Create←P2580(class←v13972, deviceClass←v14000, deviceParm←v14028, data←v14056, pixelUnits←v14084)
word class←v13972;
word deviceClass←v14000;
word deviceParm←v14028;
word data←v14056;
word pixelUnits←v14084;
{
register ptr gf←c101052 = (ptr) &globalframe;
word var←c14144;
word device←v23856;
word rasterData←v23884;
word state←v23912;
word context←v23940;
/* Create: */
SOURCE(36552, 1028)
SOURCE(36714, 103)
{
word pd327;
pd327 = (* (( (ptr) (* (( (ptr) gf←c101052)+191)/* var←c96476 */ ))+4) );
device←v23856 = (word) ( *( (fPt) ((* (ptr) pd327 ))))(deviceClass←v14000, deviceParm←v14028, 0, data←v14056, pd327);
};
SOURCE(36819, 276)
{
word var←c96508;
word var←c96540;
word var←c96604;
word var←c96636;
{
word pd328;
pd328 = (* (( (ptr) (* (( (ptr) gf←c101052)+175)/* var←c92796 */ ))+12) );
var←c96508 = (word) ( *( (fPt) ((* (ptr) pd328 ))))( (unsigned) ((* (( (bPt) (* (( (ptr) device←v23856)+5) ))+15) ) & 017), (* (
( (ptr) (* (( (ptr) device←v23856)+5) ))+1) ), (* (( (ptr) (* (( (ptr) device←v23856)+5) ))+2) ), pd328);
};
var←c96540 = XR←NewObject(20, (* (( (ptr) gf←c101052)+28) ));
{
word pd329;
pd329 = (* (( (ptr) (* (( (ptr) gf←c101052)+175)/* var←c92796 */ ))+7) );
var←c96604 = (word) ( *( (fPt) ((* (ptr) pd329 ))))((* (ptr) (&fc61) ), pd329);
};
var←c96636 = XR←NewObject(84, (* (( (ptr) gf←c101052)+14) ));
(* (ptr) var←c96636 ) = device←v23856;
(* (( (ptr) var←c96636)+2) ) = var←c96508;
(* (( (ptr) var←c96636)+3) ) = var←c96540;
(* (( (ptr) var←c96636)+6) ) = 2;
(* (( (ptr) var←c96636)+19) ) = var←c96604;
rasterData←v23884 = var←c96636;
};
SOURCE(37097, 354)
{
word var←c96668;
word var←c96732;
word var←c96828;
word var←c96860;
var←c96668 = XR←NewObject(20, (* (( (ptr) gf←c101052)+16) ));
{
word pd330;
if ((0 != pixelUnits←v14084)) {
pd330 = (* (( (ptr) (* (( (ptr) gf←c101052)+175)/* var←c92796 */ ))+7) );
var←c96732 = (word) ( *( (fPt) ((* (ptr) pd330 ))))((* (ptr) (&fc61) ), pd330);
}
else {
{
W2 var←c96764;
{
word pd331;
pd331 = (* (( (ptr) (* (( (ptr) gf←c101052)+192)/* var←c96796 */ ))+12) );
(void) ( *( (fPt) ((* (ptr) pd331 ))))((word) &var←c96764, (* (W2Pt) (( (ptr) deviceParm←v14028)+4) ), (* (ptr) &fc332 ), pd331)
;
};
{
word pd333;
pd333 = (* (( (ptr) (* (( (ptr) gf←c101052)+175)/* var←c92796 */ ))+8) );
var←c96732 = (word) ( *( (fPt) ((* (ptr) pd333 ))))(var←c96764, pd333);
};
};
};
};
{
word pd334;
pd334 = (* (( (ptr) (* (( (ptr) gf←c101052)+175)/* var←c92796 */ ))+7) );
var←c96828 = (word) ( *( (fPt) ((* (ptr) pd334 ))))((* (ptr) (&fc61) ), pd334);
};
var←c96860 = XR←NewObject(164, (* (( (ptr) gf←c101052)+13) ));
(* (( (ptr) var←c96860)+2) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+3) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+5) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+6) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+7) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+8) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+9) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+10) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+13) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+14) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+15) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+16) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+17) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+18) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+20) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+23) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+24) ) = (* (ptr) &fc61 );
(* (( (ptr) var←c96860)+26) ) = (* (ptr) &fc96 );
(* (( (ptr) var←c96860)+27) ) = 2139095039;
(* (( (ptr) var←c96860)+28) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+29) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+30) ) = (* (ptr) &fc70 );
(* (( (ptr) var←c96860)+32) ) = var←c96668;
(* (( (ptr) var←c96860)+33) ) = var←c96732;
(* (( (ptr) var←c96860)+34) ) = var←c96828;
(* (( (ptr) var←c96860)+36) ) = (* (ptr) (* (( (ptr) (* (( (ptr) gf←c101052)+179)/* var←c93532 */ ))+54) ) );
(* (( (ptr) var←c96860)+40) ) = rasterData←v23884;
state←v23912 = var←c96860;
};
SOURCE(37453, 84)
context←v23940 = XR←NewObject(16, (* (( (ptr) gf←c101052)+29) ));
(* (ptr) context←v23940 ) = class←v13972;
(* (( (ptr) context←v23940)+1) ) = state←v23912;
SOURCE(37539, 24)
(void) RasterViewReset←P1980(context←v23940);
SOURCE(37565, 15)
return(context←v23940);
}
static void RasterMaskRectangle←P2640(context←v14204, r←v14232)
word context←v14204;
W4 r←v14232;
{
word state←v23984;
/* RasterMaskRectangle: */
SOURCE(37586, 333)
SOURCE(37649, 28)
state←v23984 = (* (( (ptr) context←v14204)+1) );
SOURCE(37679, 26)
(void) Validate←P480(state←v23984, 2952790016);
SOURCE(37707, 212)
if (( (int)(* (( (ptr) state←v23984)+19) ) == (int)0)) {
SOURCE(37734, 187)
{
word rasterData←v24028;
word device←v24056;
SOURCE(37736, 41)
rasterData←v24028 = (* (( (ptr) state←v23984)+40) );
SOURCE(37779, 34)
device←v24056 = (* (ptr) rasterData←v24028 );
SOURCE(37815, 104)
{
word rectangleToDevice←v88984;
rectangleToDevice←v88984 = (* (( (ptr) state←v23984)+33) );
{
word pd335;
pd335 = (* (( (ptr) (* (ptr) device←v24056 ))+2) );
(void) ( *( (fPt) ((* (ptr) pd335 ))))(device←v24056, r←v14232, rectangleToDevice←v88984, pd335);
};
};
};
};
}
static void RasterMaskRectangleI←P2700(context←v14292, x←v14320, y←v14348, w←v14376, h←v14404)
word context←v14292;
word x←v14320;
word y←v14348;
word w←v14376;
word h←v14404;
{
W11 var←c101084;
register ptr gf←c101116 = (ptr) &globalframe;
/* declaration of var←c96924 skipped */
word state←v24100;
/* RasterMaskRectangleI: */
SOURCE(37928, 876)
{
word tmpAddr336;
tmpAddr336 = (word) (( (ptr) &var←c101084)+4)/* var←c96924 */ ;
(* (ptr) tmpAddr336 ) = ( ((word) (fPt) boxes←P6756) );
(* (( (ptr) tmpAddr336) + 1) ) = 1;
};
SOURCE(37999, 28)
state←v24100 = (* (( (ptr) context←v14292)+1) );
SOURCE(38029, 26)
(void) Validate←P480(state←v24100, 2952790016);
SOURCE(38057, 747)
if (( (int)(* (( (ptr) state←v24100)+19) ) == (int)0)) {
SOURCE(38084, 725)
{
/* declaration of rasterData←v24144 skipped */
word clientToDevice←v24172;
SOURCE(38086, 41)
(* (( (ptr) &var←c101084)+6)/* rasterData←v24144 */ ) = (* (( (ptr) state←v24100)+40) );
SOURCE(38129, 53)
clientToDevice←v24172 = (* (( (ptr) state←v24100)+33) );
SOURCE(38184, 620)
{
word pd337;
pd337 = (* (( (ptr) (* (( (ptr) gf←c101116)+175)/* var←c92796 */ ))+48) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd337 ))))(clientToDevice←v24172, pd337))) {
SOURCE(38248, 395)
{
/* declaration of box←v24216 skipped */
SOURCE(38250, 125)
{
word pd338;
pd338 = (* (( (ptr) (* (( (ptr) gf←c101116)+175)/* var←c92796 */ ))+49) );
(void) ( *( (fPt) ((* (ptr) pd338 ))))((word) (( (bPt) &var←c101084)+28)/* box←v24216 */ , clientToDevice←v24172, x←v14320, y←v14348, w←v14376, h←v14404
, (* (W4Pt) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c101084)+6)/* rasterData←v24144 */ ) ))+1) ) ), pd338);
};
SOURCE(38529, 112)
{
word pd339;
pd339 = (* (( (ptr) (* (( (ptr) gf←c101116)+185)/* var←c94844 */ ))+13) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd339 ))))((* (W4Pt) ((( (ptr) &var←c101084)+7)/* box←v24216 */ ) ), pd339))) {
SOURCE(38554, 87)
{
word pd340;
pd340 = (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) &var←c101084)+6)/* rasterData←v24144 */ ) ))+4) ))+3) );
(void) ( *( (fPt) ((* (ptr) pd340 ))))((* (ptr) (* (( (ptr) &var←c101084)+6)/* rasterData←v24144 */ ) ), (* (W4Pt) (( (ptr) &var←c101084)+7)
/*1*/ /* box←v24216 */ ), (word) (( (bPt) &var←c101084)+16)/* var←c96924 */ , pd340);
};
};
};
};
}
else {
SOURCE(38650, 156)
{
word device←v24408;
SOURCE(38652, 34)
device←v24408 = (* (ptr) (* (( (ptr) &var←c101084)+6)/* rasterData←v24144 */ ) );
SOURCE(38688, 116)
{
W4 var←c96956;
{
float tf341;
var←c96956.f0 = (
tf341 = (float)(int)x←v14320, *(word*)&tf341
);
};
{
float tf342;
var←c96956.f1 = (
tf342 = (float)(int)y←v14348, *(word*)&tf342
);
};
{
float tf343;
var←c96956.f2 = (
tf343 = (float)(int)w←v14376, *(word*)&tf343
);
};
{
float tf344;
var←c96956.f3 = (
tf344 = (float)(int)h←v14404, *(word*)&tf344
);
};
{
word pd345;
pd345 = (* (( (ptr) (* (ptr) device←v24408 ))+2) );
(void) ( *( (fPt) ((* (ptr) pd345 ))))(device←v24408, var←c96956, clientToDevice←v24172, pd345);
};
};
};
};
};
};
};
}
static void boxes←P6756(action←v24320, formal←c101180)
word action←v24320;
word formal←c101180;
{
register ptr gf←c101148 = (ptr) &globalframe;
formal←c101180 = (formal←c101180 - 16);
/* boxes: */
SOURCE(38377, 13)
SOURCE(38416, 108)
{
word pd346;
pd346 = (* (( (ptr) (* (( (ptr) gf←c101148)+182)/* var←c94236 */ ))+23) );
(void) ( *( (fPt) ((* (ptr) pd346 ))))((* (W4Pt) (( (ptr) formal←c101180)+7) ), (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) formal←c101180)+6)
) ))+1) ))+4) ), action←v24320, pd346);
};
}
static void BasicShowChar←P2760(formal←c0933, formal←c0934)
word formal←c0933;
word formal←c0934;
{
W10 var←c101212;
/* declaration of context←v14464 skipped */
/* declaration of char←v14492 skipped */
register ptr gf←c101244 = (ptr) &globalframe;
/* declaration of var←c96988 skipped */
/* declaration of state←v24452 skipped */
/* declaration of amplifySpace←v24480 skipped */
(* (( (ptr) &var←c101212)+4)/* context←v14464 */ ) = formal←c0933;
(* (( (ptr) &var←c101212)+5)/* char←v14492 */ ) = formal←c0934;
/* BasicShowChar: */
SOURCE(38816, 666)
{
word tmpAddr347;
tmpAddr347 = (word) (( (ptr) &var←c101212)+6)/* var←c96988 */ ;
(* (ptr) tmpAddr347 ) = ( ((word) (fPt) proc←P6864) );
(* (( (ptr) tmpAddr347) + 1) ) = 1;
};
SOURCE(38879, 28)
(* (( (ptr) &var←c101212)+8)/* state←v24452 */ ) = (* (( (ptr) (* (( (ptr) &var←c101212)+4)/* context←v14464 */ ))+1) );
SOURCE(38909, 42)
(* (( (ptr) &var←c101212)+9)/* amplifySpace←v24480 */ ) = (* (( (ptr) (* (( (ptr) &var←c101212)+8)/* state←v24452 */ ))+24)
);
SOURCE(39454, 28)
{
word pd348;
pd348 = (* (( (ptr) (* (( (ptr) gf←c101244)+179)/* var←c93532 */ ))+12) );
(void) ( *( (fPt) ((* (ptr) pd348 ))))((* (( (ptr) &var←c101212)+4)/* context←v14464 */ ), (word) (( (bPt) &var←c101212)+24)
/* var←c96988 */ , pd348);
};
}
static void proc←P6864(formal←c101308)
word formal←c101308;
{
register ptr gf←c101276 = (ptr) &globalframe;
word font←v24568;
W2 escapement←v24596;
formal←c101308 = (formal←c101308 - 24);
/* proc: */
SOURCE(38953, 478)
SOURCE(38968, 23)
font←v24568 = (* (( (ptr) (* (( (ptr) formal←c101308)+8) ))+35) );
SOURCE(38993, 51)
{
word pd349;
pd349 = (* (( (ptr) (* (( (ptr) gf←c101276)+193)/* var←c97020 */ ))+14) );
(void) ( *( (fPt) ((* (ptr) pd349 ))))((word) &escapement←v24596, font←v24568, (* (( (ptr) formal←c101308)+5) ), pd349);
};
SOURCE(39046, 93)
{
word pd350;
pd350 = (* (( (ptr) (* (( (ptr) gf←c101276)+193)/* var←c97020 */ ))+15) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd350 ))))(font←v24568, (* (( (ptr) formal←c101308)+5) ), pd350))) {
SOURCE(39089, 50)
{
word pd351;
pd351 = (* (( (ptr) (* (( (ptr) gf←c101276)+192)/* var←c96796 */ ))+10) );
(void) ( *( (fPt) ((* (ptr) pd351 ))))((word) &escapement←v24596, escapement←v24596, (* (( (ptr) formal←c101308)+9) ), pd351)
;
};
};
};
SOURCE(39144, 21)
{
word pd352;
pd352 = (* (( (ptr) (* (( (ptr) gf←c101276)+179)/* var←c93532 */ ))+20) );
(void) ( *( (fPt) ((* (ptr) pd352 ))))((* ((( (ptr) formal←c101308)+4)) ), pd352);
};
SOURCE(39167, 77)
if (( (int)(* (( (ptr) (* (( (ptr) formal←c101308)+8) ))+19) ) == (int)0)) {
SOURCE(39198, 46)
{
word pd353;
pd353 = (* (( (ptr) (* (( (ptr) gf←c101276)+194)/* var←c97052 */ ))+4) );
(void) ( *( (fPt) ((* (ptr) pd353 ))))(font←v24568, (* (( (ptr) formal←c101308)+5) ), (* (( (ptr) formal←c101308)+4) ), pd353)
;
};
};
SOURCE(39247, 36)
{
word pd354;
pd354 = (* (( (ptr) (* (( (ptr) gf←c101276)+179)/* var←c93532 */ ))+23) );
(void) ( *( (fPt) ((* (ptr) pd354 ))))((* (( (ptr) formal←c101308)+4) ), escapement←v24596, pd354);
};
SOURCE(39285, 146)
{
word var←c97084;
{
word pd355;
pd355 = (* (( (ptr) (* (( (ptr) gf←c101276)+193)/* var←c97020 */ ))+16) );
var←c97084 = (word) ( *( (fPt) ((* (ptr) pd355 ))))(font←v24568, (* (( (ptr) formal←c101308)+5) ), pd355);
};
switch (var←c97084) {
case 2:
break;
case 1:
SOURCE(39354, 40)
{
word pd356;
pd356 = (* (( (ptr) (* (( (ptr) gf←c101276)+179)/* var←c93532 */ ))+44) );
(void) ( *( (fPt) ((* (ptr) pd356 ))))((* (( (ptr) formal←c101308)+4) ), escapement←v24596, pd356);
};
break;
case 0:
SOURCE(39404, 27)
{
word pd357;
pd357 = (* (( (ptr) (* (( (ptr) gf←c101276)+179)/* var←c93532 */ ))+43) );
(void) ( *( (fPt) ((* (ptr) pd357 ))))((* ((( (ptr) formal←c101308)+4)) ), pd357);
};
break;
default:
SOURCE(39444, 5)
(void) XR←RaiseUnnamedError();
break;
};
};
}
static void FlushState←P2820(state←v14552)
word state←v14552;
{
register ptr gf←c101340 = (ptr) &globalframe;
word rasterData←v24640;
/* FlushState: */
SOURCE(39488, 255)
SOURCE(39531, 41)
rasterData←v24640 = (* (( (ptr) state←v14552)+40) );
SOURCE(39574, 169)
if ((0 != (* (( (ptr) rasterData←v24640)+5) ))) {
SOURCE(39605, 91)
{
word var←c97116;
var←c97116 = (* (( (ptr) state←v14552)+25) );
if (( (int)var←c97116 == (int)1)) {
SOURCE(39643, 53)
{
W2 var←c97148;
{
W2 var←c97180;
W2 sv←v88748;
sv←v88748 = (* (W2Pt) (( (ptr) rasterData←v24640)+7) );
SOURCE(39809, 68)
{
W2 var←c97212;
{
word pd358;
pd358 = (* (( (ptr) (* (( (ptr) gf←c101340)+195)/* var←c97244 */ ))+20) );
var←c97212.f0 = (word) ( *( (fPt) ((* (ptr) pd358 ))))(sv←v88748.f0, pd358);
};
{
word pd359;
pd359 = (* (( (ptr) (* (( (ptr) gf←c101340)+195)/* var←c97244 */ ))+20) );
var←c97212.f1 = (word) ( *( (fPt) ((* (ptr) pd359 ))))(sv←v88748.f1, pd359);
};
var←c97180 = var←c97212;
};
var←c97148 = var←c97180;
};
(* (W2Pt) (( (ptr) state←v14552)+5) ) = var←c97148;
};
}
else {
};
};
SOURCE(39715, 28)
(* (( (ptr) rasterData←v24640)+5) ) = 0;
};
}
static word GetFontAtom←P3000(context←v14820)
word context←v14820;
{
word var←c14864;
word state←v24684;
word rasterData←v24712;
/* GetFontAtom: */
SOURCE(40013, 218)
SOURCE(40094, 28)
state←v24684 = (* (( (ptr) context←v14820)+1) );
SOURCE(40124, 41)
rasterData←v24712 = (* (( (ptr) state←v24684)+40) );
SOURCE(40167, 33)
(void) Validate←P480(state←v24684, 1073741824);
SOURCE(40202, 29)
return((* (( (ptr) rasterData←v24712)+4) ));
}
static void TryFastState←P3060(state←v14924)
word state←v14924;
{
register ptr gf←c101372 = (ptr) &globalframe;
word rasterData←v24756;
word cp←v24784;
/* TryFastState: */
SOURCE(40235, 1147)
SOURCE(40273, 41)
rasterData←v24756 = (* (( (ptr) state←v14924)+40) );
SOURCE(40316, 38)
cp←v24784 = (* (( (ptr) state←v14924)+32) );
SOURCE(40356, 78)
{
word x360;
word x361;
if (((
x360 = (* (( (ptr) state←v14924)+24) ), *(float*)&x360
) == (
x361 = (* (ptr) &fc61 ), *(float*)&x361
))) {
(* (( (ptr) rasterData←v24756)+6) ) = 0;
}
else {
(* (( (ptr) rasterData←v24756)+6) ) = 1;
};
};
SOURCE(40436, 28)
(* (( (ptr) rasterData←v24756)+11) ) = 0;
SOURCE(40466, 188)
if ((0 == (* (ptr) cp←v24784 ))) {
SOURCE(40490, 164)
{
word tc362;
float tf363;
word x364;
word x365;
float tf366;
word x367;
word x368;
if ((FABS((
x364 = (* (( (ptr) cp←v24784)+3) ), *(float*)&x364
), tf363) < (
x365 = (* (( (ptr) gf←c101372)+7)/* worryReal←v6472 */ ), *(float*)&x365
))) {
tc362 = (word) (FABS((
x367 = (* (( (ptr) cp←v24784)+4) ), *(float*)&x367
), tf366) < (
x368 = (* (( (ptr) gf←c101372)+7)/* worryReal←v6472 */ ), *(float*)&x368
));
}
else {
tc362 = (word) 0;
};
if (tc362) {
SOURCE(40554, 16)
(* (ptr) cp←v24784 ) = 1;
SOURCE(40572, 40)
{
word var←c97276;
{
word var←c97308;
word real←v90508;
real←v90508 = (* (( (ptr) cp←v24784)+3) );
{
word pd369;
pd369 = (* (( (ptr) (* (( (ptr) gf←c101372)+195)/* var←c97244 */ ))+7) );
var←c97308 = (word) ( *( (fPt) ((* (ptr) pd369 ))))(real←v90508, pd369);
};
var←c97276 = var←c97308;
};
(* (( (ptr) cp←v24784)+1) ) = var←c97276;
};
SOURCE(40614, 40)
{
word var←c97372;
{
word var←c97404;
word real←v90460;
real←v90460 = (* (( (ptr) cp←v24784)+4) );
{
word pd370;
pd370 = (* (( (ptr) (* (( (ptr) gf←c101372)+195)/* var←c97244 */ ))+7) );
var←c97404 = (word) ( *( (fPt) ((* (ptr) pd370 ))))(real←v90460, pd370);
};
var←c97372 = var←c97404;
};
(* (( (ptr) cp←v24784)+2) ) = var←c97372;
};
};
};
};
SOURCE(40662, 38)
(* (( (ptr) rasterData←v24756)+5) ) = (* (ptr) (* (( (ptr) state←v14924)+32) ) );
SOURCE(40702, 257)
if ( ( (0 != (* (( (ptr) rasterData←v24756)+5) )) ? ( (int)(* (( (ptr) state←v14924)+25) ) == (int)1) : 0 ) ) {
SOURCE(40760, 201)
{
W2 s←v24828;
SOURCE(40762, 27)
s←v24828 = (* (W2Pt) (( (ptr) state←v14924)+5) );
SOURCE(40791, 29)
(* (( (ptr) rasterData←v24756)+6) ) = 2;
SOURCE(40822, 70)
{
float tf371;
word x372;
word x373;
float tf374;
word x375;
word x376;
if ((FABS((
x372 = s←v24828.f0, *(float*)&x372
), tf371) < (
x373 = (* (( (ptr) gf←c101372)+7)/* worryReal←v6472 */ ), *(float*)&x373
))) {
(* (( (ptr) rasterData←v24756)+5) ) = (unsigned) (FABS((
x375 = s←v24828.f1, *(float*)&x375
), tf374) < (
x376 = (* (( (ptr) gf←c101372)+7)/* worryReal←v6472 */ ), *(float*)&x376
));
}
else {
(* (( (ptr) rasterData←v24756)+5) ) = (unsigned) 0;
};
};
SOURCE(40894, 65)
if ((0 != (* (( (ptr) rasterData←v24756)+5) ))) {
SOURCE(40923, 36)
{
word var←c97468;
word var←c97500;
{
word pd377;
pd377 = (* (( (ptr) (* (( (ptr) gf←c101372)+195)/* var←c97244 */ ))+7) );
var←c97468 = (word) ( *( (fPt) ((* (ptr) pd377 ))))(s←v24828.f0, pd377);
};
{
word pd378;
pd378 = (* (( (ptr) (* (( (ptr) gf←c101372)+195)/* var←c97244 */ ))+7) );
var←c97500 = (word) ( *( (fPt) ((* (ptr) pd378 ))))(s←v24828.f1, pd378);
};
(* (( (ptr) rasterData←v24756)+7) ) = var←c97468;
(* (( (ptr) rasterData←v24756)+8) ) = var←c97500;
};
};
};
};
SOURCE(40964, 418)
if ( ( (0 != (* (( (ptr) rasterData←v24756)+5) )) ? ( (int)(* (( (ptr) state←v14924)+25) ) == (int)2) : 0 ) ) {
SOURCE(41022, 365)
{
W2 s←v24872;
SOURCE(41024, 28)
s←v24872 = (* (W2Pt) (( (ptr) state←v14924)+7) );
SOURCE(41054, 70)
{
float tf379;
word x380;
word x381;
float tf382;
word x383;
word x384;
if ((FABS((
x380 = s←v24872.f0, *(float*)&x380
), tf379) < (
x381 = (* (( (ptr) gf←c101372)+7)/* worryReal←v6472 */ ), *(float*)&x381
))) {
(* (( (ptr) rasterData←v24756)+5) ) = (unsigned) (FABS((
x383 = s←v24872.f1, *(float*)&x383
), tf382) < (
x384 = (* (( (ptr) gf←c101372)+7)/* worryReal←v6472 */ ), *(float*)&x384
));
}
else {
(* (( (ptr) rasterData←v24756)+5) ) = (unsigned) 0;
};
};
SOURCE(41126, 256)
if ((0 != (* (( (ptr) rasterData←v24756)+5) ))) {
{
W2 var←c97724;
SOURCE(41157, 37)
{
word var←c97596;
word var←c97628;
{
word pd385;
pd385 = (* (( (ptr) (* (( (ptr) gf←c101372)+195)/* var←c97244 */ ))+7) );
var←c97596 = (word) ( *( (fPt) ((* (ptr) pd385 ))))(s←v24872.f0, pd385);
};
{
word pd386;
pd386 = (* (( (ptr) (* (( (ptr) gf←c101372)+195)/* var←c97244 */ ))+7) );
var←c97628 = (word) ( *( (fPt) ((* (ptr) pd386 ))))(s←v24872.f1, pd386);
};
(* (( (ptr) rasterData←v24756)+9) ) = var←c97596;
(* (( (ptr) rasterData←v24756)+10) ) = var←c97628;
};
SOURCE(41196, 47)
(* (( (ptr) rasterData←v24756)+14) ) = 0;
(* (( (ptr) rasterData←v24756)+15) ) = 0;
SOURCE(41245, 45)
(* (( (ptr) rasterData←v24756)+16) ) = 0;
(* (( (ptr) rasterData←v24756)+17) ) = 0;
SOURCE(41292, 90)
var←c97724.f0 = 0;
var←c97724.f1 = 0;
if (XR←EqualWords((( (ptr) rasterData←v24756)+9), &var←c97724, 2)) {
(* (( (ptr) rasterData←v24756)+6) ) = 1;
}
else {
(* (( (ptr) rasterData←v24756)+6) ) = 2;
};
};
};
};
};
}
static void RasterShow←P3120(formal←c0935, formal←c0936, xrel←v15040)
word formal←c0935;
word formal←c0936;
word xrel←v15040;
{
W14 var←c101404;
/* declaration of context←v14984 skipped */
/* declaration of string←v15012 skipped */
/* declaration of var←c97756 skipped */
/* declaration of var←c97788 skipped */
/* declaration of var←c97820 skipped */
/* declaration of state←v24916 skipped */
/* declaration of rasterData←v24944 skipped */
word device←v24972;
(* (( (ptr) &var←c101404)+4)/* context←v14984 */ ) = formal←c0935;
(* (( (ptr) &var←c101404)+5)/* string←v15012 */ ) = formal←c0936;
/* RasterShow: */
SOURCE(41394, 2919)
{
word tmpAddr387;
tmpAddr387 = (word) (( (ptr) &var←c101404)+6)/* var←c97756 */ ;
(* (ptr) tmpAddr387 ) = ( ((word) (fPt) HardMetrics←P7140) );
(* (( (ptr) tmpAddr387) + 1) ) = 1;
};
{
word tmpAddr388;
tmpAddr388 = (word) (( (ptr) &var←c101404)+8)/* var←c97788 */ ;
(* (ptr) tmpAddr388 ) = ( ((word) (fPt) HardChar←P7080) );
(* (( (ptr) tmpAddr388) + 1) ) = 1;
};
{
word tmpAddr389;
tmpAddr389 = (word) (( (ptr) &var←c101404)+10)/* var←c97820 */ ;
(* (ptr) tmpAddr389 ) = ( ((word) (fPt) XRelString←P7020) );
(* (( (ptr) tmpAddr389) + 1) ) = 1;
};
SOURCE(41474, 28)
(* (( (ptr) &var←c101404)+12)/* state←v24916 */ ) = (* (( (ptr) (* (( (ptr) &var←c101404)+4)/* context←v14984 */ ))+1) );
SOURCE(41504, 41)
(* (( (ptr) &var←c101404)+13)/* rasterData←v24944 */ ) = (* (( (ptr) (* (( (ptr) &var←c101404)+12)/* state←v24916 */ ))+40)
);
SOURCE(41547, 34)
device←v24972 = (* (ptr) (* (( (ptr) &var←c101404)+13)/* rasterData←v24944 */ ) );
SOURCE(44003, 26)
(void) Validate←P480((* (( (ptr) &var←c101404)+12)/* state←v24916 */ ), 4026531840);
SOURCE(44031, 19)
(void) TryFastState←P3060((* ((( (ptr) &var←c101404)+12)/* state←v24916 */ ) ));
SOURCE(44052, 242)
{
word fontAtom←v88796;
word string←v88824;
word cp←v88852;
word easyMetrics←v88908;
word noImage←v88936;
fontAtom←v88796 = (* (( (ptr) (* (( (ptr) &var←c101404)+13)/* rasterData←v24944 */ ))+4) );
string←v88824 = ( (0 != xrel←v15040) ? (word) (( (bPt) &var←c101404)+40)/* var←c97820 */ : (* (( (ptr) &var←c101404)+5)
/* string←v15012 */ ) ) ;
cp←v88852 = (* (( (ptr) (* (( (ptr) &var←c101404)+12)/* state←v24916 */ ))+32) );
easyMetrics←v88908 = (* (( (ptr) (* (( (ptr) &var←c101404)+13)/* rasterData←v24944 */ ))+6) );
noImage←v88936 = (unsigned) ( (int)(* (( (ptr) (* (( (ptr) &var←c101404)+12)/* state←v24916 */ ))+19) ) != (int)0);
{
word pd390;
pd390 = (* (( (ptr) (* (ptr) device←v24972 ))+10) );
(void) ( *( (fPt) ((* (ptr) pd390 ))))(device←v24972, fontAtom←v88796, string←v88824, cp←v88852, (word) (( (bPt) &var←c101404)+32)
/* var←c97788 */ , (word) (( (bPt) &var←c101404)+24)/* var←c97756 */
, easyMetrics←v88908, noImage←v88936, pd390);
};
};
SOURCE(44296, 17)
(void) FlushState←P2820((* ((( (ptr) &var←c101404)+12)/* state←v24916 */ ) ));
}
static void XRelString←P7020(formal←c0937, formal←c101468)
word formal←c0937;
word formal←c101468;
{
W8 var←c101436;
/* declaration of charAction←v86748 skipped */
/* declaration of var←c97852 skipped */
/* declaration of oddCharIndex←v25160 skipped */
formal←c101468 = (formal←c101468 - 40);
var←c101436.f4/* charAction←v86748 */ = formal←c0937;
var←c101436.f0 = formal←c101468;
/* XRelString: */
SOURCE(41583, 284)
{
word tmpAddr391;
tmpAddr391 = (word) (( (ptr) &var←c101436)+5)/* var←c97852 */ ;
(* (ptr) tmpAddr391 ) = ( ((word) (fPt) XRelAction←P7200) );
(* (( (ptr) tmpAddr391) + 1) ) = 1;
};
SOURCE(41611, 26)
var←c101436.f7/* oddCharIndex←v25160 */ = 0;
SOURCE(41849, 18)
{
word pd392;
pd392 = (* (( (ptr) formal←c101468)+5) );
(void) ( *( (fPt) ((* (ptr) pd392 ))))((word) ((( (bPt) &var←c101436)+20)/* var←c97852 */ ), pd392);
};
}
static void XRelAction←P7200(char←v25264, formal←c101532)
word char←v25264;
word formal←c101532;
{
register ptr gf←c101500 = (ptr) &globalframe;
formal←c101532 = (formal←c101532 - 20);
/* XRelAction: */
SOURCE(41639, 205)
SOURCE(41674, 137)
if ((0 != (* (( (ptr) formal←c101532)+7) ))) {
SOURCE(41697, 17)
(void) FlushState←P2820((* ((( (ptr) (* (ptr) formal←c101532 ))+12)) ));
SOURCE(41716, 49)
{
word pd393;
float tf394;
pd393 = (* (( (ptr) (* (( (ptr) gf←c101500)+179)/* var←c93532 */ ))+25) );
(void) ( *( (fPt) ((* (ptr) pd393 ))))((* (( (ptr) (* (ptr) formal←c101532 ))+4) ), (
tf394 = (float)(int)((char←v25264 & 0377) - 128), *(word*)&tf394
), pd393);
};
SOURCE(41767, 19)
(void) TryFastState←P3060((* ((( (ptr) (* (ptr) formal←c101532 ))+12)) ));
}
else {
SOURCE(41795, 16)
{
word pd395;
pd395 = (* (( (ptr) formal←c101532)+4) );
(void) ( *( (fPt) ((* (ptr) pd395 ))))(char←v25264, pd395);
};
};
SOURCE(41813, 31)
(* (( (ptr) formal←c101532)+7) ) = (unsigned) (0 == (* (( (ptr) formal←c101532)+7) ));
}
static void HardChar←P7080(char←v86808, formal←c101564)
word char←v86808;
word formal←c101564;
{
formal←c101564 = (formal←c101564 - 32);
/* HardChar: */
SOURCE(41872, 103)
SOURCE(41907, 17)
(void) FlushState←P2820((* ((( (ptr) formal←c101564)+12)) ));
SOURCE(41926, 28)
(void) BasicShowChar←P2760((* (( (ptr) formal←c101564)+4) ), char←v86808);
SOURCE(41956, 19)
(void) TryFastState←P3060((* ((( (ptr) formal←c101564)+12)) ));
}
static void HardMetrics←P7140(m←v25132, formal←c101628)
word m←v25132;
word formal←c101628;
{
register ptr gf←c101596 = (ptr) &globalframe;
formal←c101628 = (formal←c101628 - 24);
/* HardMetrics: */
SOURCE(41980, 2020)
SOURCE(42014, 1986)
SOURCE(42016, 29)
{
W2 esc←v25292;
word var←c98844;
word a←v90604;
word var←c98876;
word a←v90556;
SOURCE(42016, 29)
esc←v25292 = (* (W2Pt) (( (ptr) m←v25132)+2) );
SOURCE(42047, 33)
if ((0 == (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+5) ))) {
SOURCE(42080, 13)
goto lab←L100038;
};
SOURCE(42095, 558)
if ((* (( (bPt) m←v25132)+35) ) & 010) {
SOURCE(42123, 501)
if ((m←v25132 != (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+11) ))) {
SOURCE(42158, 468)
{
word amp←v25336;
SOURCE(42160, 33)
amp←v25336 = (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+24) );
SOURCE(42195, 398)
{
word x396;
word x397;
if (((
x396 = amp←v25336, *(float*)&x396
) == (
x397 = (* (ptr) &fc61 ), *(float*)&x397
))) {
SOURCE(42215, 25)
(* (W2Pt) (( (ptr) (* (( (ptr) formal←c101628)+13) ))+12) ) = esc←v25292;
}
else {
SOURCE(42249, 142)
if ((esc←v25292.f0 != 0)) {
SOURCE(42283, 123)
{
word r←v25380;
SOURCE(42285, 39)
{
/*1*/ word pd398;
/*1*/ word x399;
/*1*/ word x400;
/*1*/ pd398 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+20) );
/*1*/ *(float*)&r←v25380 = (
/*1*/ x399 = (word) ( *( (fPt) ((* (ptr) pd398 ))))(esc←v25292.f0, pd398), *(float*)&x399
/*1*/ ) * (
/*1*/ x400 = amp←v25336, *(float*)&x400
/*1*/ );
/*1*/ };
SOURCE(42326, 65)
{
/*1*/ float tf401;
/*1*/ word x402;
/*1*/ word x403;
/*1*/ if ((FABS((
/*1*/ x402 = r←v25380, *(float*)&x402
/*1*/ ), tf401) < (
/*1*/ x403 = (* (( (ptr) gf←c101596)+7)/* worryReal←v6472 */ ), *(float*)&x403
/*1*/ ))) {
SOURCE(42353, 38)
/*1*/ {
/*1*/ word pd404;
/*1*/ pd404 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+7) );
/*1*/ esc←v25292.f0 = (word) ( *( (fPt) ((* (ptr) pd404 ))))(r←v25380, pd404);
/*1*/ };
/*1*/ }
/*1*/ else {
SOURCE(42391, 13)
/*1*/ goto lab←L100038;
/*1*/ };
/*1*/ };
};
};
SOURCE(42409, 142)
if ((esc←v25292.f1 != 0)) {
SOURCE(42443, 123)
{
word r←v25424;
SOURCE(42445, 39)
{
/*1*/ word pd405;
/*1*/ word x406;
/*1*/ word x407;
/*1*/ pd405 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+20) );
/*1*/ *(float*)&r←v25424 = (
/*1*/ x406 = (word) ( *( (fPt) ((* (ptr) pd405 ))))(esc←v25292.f1, pd405), *(float*)&x406
/*1*/ ) * (
/*1*/ x407 = amp←v25336, *(float*)&x407
/*1*/ );
/*1*/ };
SOURCE(42486, 65)
{
/*1*/ float tf408;
/*1*/ word x409;
/*1*/ word x410;
/*1*/ if ((FABS((
/*1*/ x409 = r←v25424, *(float*)&x409
/*1*/ ), tf408) < (
/*1*/ x410 = (* (( (ptr) gf←c101596)+7)/* worryReal←v6472 */ ), *(float*)&x410
/*1*/ ))) {
SOURCE(42513, 38)
/*1*/ {
/*1*/ word pd411;
/*1*/ pd411 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+7) );
/*1*/ esc←v25292.f1 = (word) ( *( (fPt) ((* (ptr) pd411 ))))(r←v25424, pd411);
/*1*/ };
/*1*/ }
/*1*/ else {
SOURCE(42551, 13)
/*1*/ goto lab←L100038;
/*1*/ };
/*1*/ };
};
};
SOURCE(42569, 24)
(* (W2Pt) (( (ptr) (* (( (ptr) formal←c101628)+13) ))+12) ) = esc←v25292;
};
};
SOURCE(42598, 26)
(* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+11) ) = m←v25132;
};
};
SOURCE(42629, 24)
esc←v25292 = (* (W2Pt) (( (ptr) (* (( (ptr) formal←c101628)+13) ))+12) );
};
SOURCE(42658, 884)
{
word var←c97948;
var←c97948 = (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+25) );
if (( (int)var←c97948 == (int)1)) {
SOURCE(42698, 257)
{
word var←c97980;
var←c97980 = (unsigned) (((unsigned)(* (( (bPt) m←v25132)+35) ) << 29) >> 30);
if ((var←c97980 == 0)) {
SOURCE(42737, 53)
(* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+4) ) = ((* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+4) ) + 1);
}
else {
if ((var←c97980 == 1)) {
SOURCE(42803, 75)
{
word var←c98012;
word a←v90396;
a←v90396 = (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+7) );
{
word i←v51772;
i←v51772 = (a←v90396 + esc←v25292.f0);
var←c98012 = i←v51772;
};
(* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+7) ) = var←c98012;
};
SOURCE(42880, 75)
{
word var←c98108;
word a←v90304;
a←v90304 = (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+8) );
{
word i←v90352;
i←v90352 = (a←v90304 + esc←v25292.f1);
var←c98108 = i←v90352;
};
(* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+8) ) = var←c98108;
};
}
else {
};
};
};
}
else {
if (( (int)var←c97948 == (int)2)) {
SOURCE(42987, 555)
{
word var←c98204;
var←c98204 = (unsigned) (((unsigned)(* (( (bPt) m←v25132)+35) ) << 29) >> 30);
if ((var←c98204 == 0)) {
SOURCE(43028, 210)
if (( (int)(* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+4) ) != (int)0)) {
SOURCE(43065, 58)
{
word var←c98236;
word b←v90212;
b←v90212 = (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+9) );
{
/*1*/ word i←v90260;
/*1*/ i←v90260 = (esc←v25292.f0 + b←v90212);
/*1*/ var←c98236 = i←v90260;
/*1*/ };
esc←v25292.f0 = var←c98236;
};
SOURCE(43125, 58)
{
word var←c98332;
word b←v90120;
b←v90120 = (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+10) );
{
/*1*/ word i←v90168;
/*1*/ i←v90168 = (esc←v25292.f1 + b←v90120);
/*1*/ var←c98332 = i←v90168;
/*1*/ };
esc←v25292.f1 = var←c98332;
};
SOURCE(43185, 53)
(* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+4) ) = ((* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+4) ) - 1);
};
}
else {
if ((var←c98204 == 1)) {
SOURCE(43257, 244)
if ( ! XR←EqualWords(&esc←v25292, (( (ptr) (* (( (ptr) formal←c101628)+13) ))+14), 2)) {
SOURCE(43303, 200)
{
/*1*/ W2 cs←v25468;
/*1*/ W2 e1←v25496;
/*1*/ W2 e3←v25524;
SOURCE(43305, 30)
/*1*/ cs←v25468 = (* (W2Pt) (( (ptr) (* (( (ptr) formal←c101628)+12) ))+9) );
SOURCE(43337, 24)
/*1*/ {
/*1*/ W2 sv←v88700;
/*1*/ sv←v88700 = esc←v25292;
SOURCE(39809, 68)
/*1*/ {
/*1*/ W2 var←c98460;
/*1*/ {
/*1*/ word pd412;
/*1*/ pd412 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+20) );
/*1*/ var←c98460.f0 = (word) ( *( (fPt) ((* (ptr) pd412 ))))(sv←v88700.f0, pd412);
/*1*/ };
/*1*/ {
/*1*/ word pd413;
/*1*/ pd413 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+20) );
/*1*/ var←c98460.f1 = (word) ( *( (fPt) ((* (ptr) pd413 ))))(sv←v88700.f1, pd413);
/*1*/ };
/*1*/ e1←v25496 = var←c98460;
/*1*/ };
/*1*/ };
SOURCE(43363, 52)
/*1*/ {
/*1*/ word x414;
/*1*/ word x415;
/*1*/ word x416;
/*1*/ *(float*)&e3←v25524.f0 = ((
/*1*/ x414 = cs←v25468.f0, *(float*)&x414
/*1*/ ) * (
/*1*/ x415 = e1←v25496.f0, *(float*)&x415
/*1*/ )) + (
/*1*/ x416 = e1←v25496.f0, *(float*)&x416
/*1*/ );
/*1*/ };
/*1*/ {
/*1*/ word x417;
/*1*/ word x418;
/*1*/ word x419;
/*1*/ *(float*)&e3←v25524.f1 = ((
/*1*/ x417 = cs←v25468.f1, *(float*)&x417
/*1*/ ) * (
/*1*/ x418 = e1←v25496.f1, *(float*)&x418
/*1*/ )) + (
/*1*/ x419 = e1←v25496.f1, *(float*)&x419
/*1*/ );
/*1*/ };
SOURCE(43417, 45)
/*1*/ {
/*1*/ word var←c98524;
/*1*/ word var←c98556;
/*1*/ {
/*1*/ word pd420;
/*1*/ pd420 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+7) );
/*1*/ var←c98524 = (word) ( *( (fPt) ((* (ptr) pd420 ))))(e3←v25524.f0, pd420);
/*1*/ };
/*1*/ {
/*1*/ word pd421;
/*1*/ pd421 = (* (( (ptr) (* (( (ptr) gf←c101596)+195)/* var←c97244 */ ))+7) );
/*1*/ var←c98556 = (word) ( *( (fPt) ((* (ptr) pd421 ))))(e3←v25524.f1, pd421);
/*1*/ };
/*1*/ {
/*1*/ word var←c98588;
/*1*/ word var←c98620;
/*1*/ var←c98588 = var←c98524;
/*1*/ var←c98620 = var←c98556;
/*1*/ (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+16) ) = var←c98588;
/*1*/ (* (( (ptr) (* (( (ptr) formal←c101628)+13) ))+17) ) = var←c98620;
/*1*/ };
/*1*/ };
SOURCE(43464, 37)
/*1*/ (* (W2Pt) (( (ptr) (* (( (ptr) formal←c101628)+13) ))+14) ) = esc←v25292;
/*1*/ };
};
SOURCE(43506, 36)
esc←v25292 = (* (W2Pt) (( (ptr) (* (( (ptr) formal←c101628)+13) ))+16) );
}
else {
};
};
};
}
else {
};
};
};
SOURCE(43582, 55)
{
word var←c98652;
word a←v90028;
a←v90028 = (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+32) ))+1) );
{
word i←v90076;
i←v90076 = (a←v90028 + esc←v25292.f0);
var←c98652 = i←v90076;
};
(* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+32) ))+1) ) = var←c98652;
};
SOURCE(43639, 55)
{
word var←c98748;
word a←v89936;
a←v89936 = (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+32) ))+2) );
{
word i←v89984;
i←v89984 = (a←v89936 + esc←v25292.f1);
var←c98748 = i←v89984;
};
(* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+32) ))+2) ) = var←c98748;
};
SOURCE(43696, 130)
a←v90604 = (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+32) ))+1) );
var←c98844 = (word)( (int)a←v90604 >> 16);
if ((IABS(var←c98844) >= 16382)) { goto then0422;};
a←v90556 = (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+32) ))+2) );
var←c98876 = (word)( (int)a←v90556 >> 16);
if ((IABS(var←c98876) >= 16382)) {
then0422: ;
SOURCE(43809, 17)
(void) FlushState←P2820((* ((( (ptr) formal←c101628)+12)) ));
};
};
goto lab←L100054;
lab←L100038: ;
SOURCE(43846, 151)
{
word save←v25568;
SOURCE(43848, 28)
save←v25568 = (* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+19) );
SOURCE(43878, 20)
(* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+19) ) = 1;
SOURCE(43900, 17)
(void) FlushState←P2820((* ((( (ptr) formal←c101628)+12)) ));
SOURCE(43919, 30)
(void) BasicShowChar←P2760((* (( (ptr) formal←c101628)+4) ), (* (( (ptr) m←v25132)+1) ));
SOURCE(43951, 19)
(void) TryFastState←P3060((* ((( (ptr) formal←c101628)+12)) ));
SOURCE(43972, 23)
(* (( (ptr) (* (( (ptr) formal←c101628)+12) ))+19) ) = save←v25568;
};
lab←L100054: ;
}
static void RasterShowBackward←P3180(formal←c0938, formal←c0939)
word formal←c0938;
word formal←c0939;
{
W8 var←c101660;
/* declaration of context←v15100 skipped */
/* declaration of string←v15128 skipped */
register ptr gf←c101692 = (ptr) &globalframe;
word state←v25612;
/* declaration of font←v25640 skipped */
word typeface←v25668;
word new←v25696;
var←c101660.f4/* context←v15100 */ = formal←c0938;
var←c101660.f5/* string←v15128 */ = formal←c0939;
/* RasterShowBackward: */
SOURCE(44319, 397)
SOURCE(44395, 28)
state←v25612 = (* (( (ptr) var←c101660.f4/* context←v15100 */ )+1) );
SOURCE(44425, 23)
var←c101660.f6/* font←v25640 */ = (* (( (ptr) state←v25612)+35) );
SOURCE(44450, 34)
typeface←v25668 = (* (( (ptr) var←c101660.f6/* font←v25640 */ )+1) );
SOURCE(44486, 95)
{
word var←c98908;
{
word pd423;
pd423 = (* (( (ptr) (* (( (ptr) gf←c101692)+180)/* var←c93628 */ ))+6) );
var←c98908 = (word) ( *( (fPt) ((* (ptr) pd423 ))))(typeface←v25668, pd423);
};
{
word pd424;
pd424 = (* (( (ptr) (* (( (ptr) gf←c101692)+180)/* var←c93628 */ ))+8) );
new←v25696 = (word) ( *( (fPt) ((* (ptr) pd424 ))))(var←c98908, (* (ptr) var←c101660.f6/* font←v25640 */ ), pd424);
};
};
SOURCE(44583, 28)
{
word pd425;
pd425 = (* (( (ptr) (* (( (ptr) gf←c101692)+179)/* var←c93532 */ ))+30) );
(void) ( *( (fPt) ((* (ptr) pd425 ))))(var←c101660.f4/* context←v15100 */ , new←v25696, pd425);
};
SOURCE(44613, 70)
{
/* declaration of var←c02 skipped */
var←c101660.f7/* var←c02 */ = (* (( (ptr) (* (( (ptr) gf←c101692)+179)/* var←c93532 */ ))+32) );
{
word var←c0871;
var←c0871 = (word) &var←c101660;
(void) (word) XR←Enable(( ((word) (fPt) NoName←Q11748) ), ( ((word) (fPt) NoName←Q11808) ), var←c0871);
};
};
SOURCE(44687, 29)
{
word pd426;
pd426 = (* (( (ptr) (* (( (ptr) gf←c101692)+179)/* var←c93532 */ ))+30) );
(void) ( *( (fPt) ((* (ptr) pd426 ))))(var←c101660.f4/* context←v15100 */ , var←c101660.f6/* font←v25640 */ , pd426);
};
}
static word NoName←Q11748(formal←c0842)
word formal←c0842;
{
SOURCE(44613, 70)
{
word pd427;
pd427 = (* (( (ptr) formal←c0842)+7) );
(void) ( *( (fPt) ((* (ptr) pd427 ))))((* (( (ptr) formal←c0842)+4) ), (* (( (ptr) formal←c0842)+5) ), 0, pd427);
};
return(0);
}
static void ModifySetColor←P3240(device←v15300, color←v15328, viewToDevice←v15356)
word device←v15300;
word color←v15328;
word viewToDevice←v15356;
{
register ptr gf←c101724 = (ptr) &globalframe;
word iData←v25740;
/* ModifySetColor: */
SOURCE(44861, 192)
SOURCE(44947, 42)
iData←v25740 = XR←Narrow((* (( (ptr) device←v15300)+7) ), (* (( (ptr) gf←c101724)+27) ));
SOURCE(44991, 62)
{
word pd428;
pd428 = (* (ptr) (* (( (ptr) (* (( (ptr) iData←v25740)+2) ))+4) ) );
(void) ( *( (fPt) ((* (ptr) pd428 ))))((* (( (ptr) iData←v25740)+2) ), color←v15328, viewToDevice←v15356, pd428);
};
}
static void ModifySetPriority←P3300(device←v15416, priorityImportant←v15444)
word device←v15416;
word priorityImportant←v15444;
{
register ptr gf←c101756 = (ptr) &globalframe;
word iData←v25784;
/* ModifySetPriority: */
SOURCE(45059, 230)
SOURCE(45129, 42)
iData←v25784 = XR←Narrow((* (( (ptr) device←v15416)+7) ), (* (( (ptr) gf←c101756)+27) ));
SOURCE(45173, 51)
if (((* (( (ptr) (* (( (ptr) (* (( (ptr) iData←v25784)+2) ))+4) ))+1) ) == 0)) {
SOURCE(45218, 6)
return;
};
SOURCE(45226, 63)
{
word pd429;
pd429 = (* (( (ptr) (* (( (ptr) (* (( (ptr) iData←v25784)+2) ))+4) ))+1) );
(void) ( *( (fPt) ((* (ptr) pd429 ))))((* (( (ptr) iData←v25784)+2) ), priorityImportant←v15444, pd429);
};
}
static void ModifySetHalftoneProperties←P3360(device←v15504, halftoneProperties←v15532)
word device←v15504;
word halftoneProperties←v15532;
{
register ptr gf←c101788 = (ptr) &globalframe;
word iData←v25828;
/* ModifySetHalftoneProperties: */
SOURCE(45295, 288)
SOURCE(45402, 42)
iData←v25828 = XR←Narrow((* (( (ptr) device←v15504)+7) ), (* (( (ptr) gf←c101788)+27) ));
SOURCE(45446, 61)
if (((* (( (ptr) (* (( (ptr) (* (( (ptr) iData←v25828)+2) ))+4) ))+2) ) == 0)) {
SOURCE(45501, 6)
return;
};
SOURCE(45509, 74)
{
word pd430;
pd430 = (* (( (ptr) (* (( (ptr) (* (( (ptr) iData←v25828)+2) ))+4) ))+2) );
(void) ( *( (fPt) ((* (ptr) pd430 ))))((* (( (ptr) iData←v25828)+2) ), halftoneProperties←v15532, pd430);
};
}
static void ModifyMaskBoxes←P3420(device←v15592, formal←c0940, formal←c0941)
word device←v15592;
W4 formal←c0940;
word formal←c0941;
{
W12 var←c101820;
/* declaration of bounds←v15620 skipped */
/* declaration of boxes←v15648 skipped */
register ptr gf←c101852 = (ptr) &globalframe;
/* declaration of var←c98940 skipped */
/* declaration of iData←v25872 skipped */
(* (W4Pt) (( (ptr) &var←c101820)+4)/* bounds←v15620 */ ) = formal←c0940;
(* (( (ptr) &var←c101820)+8)/* boxes←v15648 */ ) = formal←c0941;
/* ModifyMaskBoxes: */
SOURCE(45589, 398)
{
word tmpAddr431;
tmpAddr431 = (word) (( (ptr) &var←c101820)+9)/* var←c98940 */ ;
(* (ptr) tmpAddr431 ) = ( ((word) (fPt) action←P7596) );
(* (( (ptr) tmpAddr431) + 1) ) = 1;
};
SOURCE(45672, 42)
(* (( (ptr) &var←c101820)+11)/* iData←v25872 */ ) = XR←Narrow((* (( (ptr) device←v15592)+7) ), (* (( (ptr) gf←c101852)+27)
));
SOURCE(45716, 271)
if ((0 != (* (ptr) (* (( (ptr) &var←c101820)+11)/* iData←v25872 */ ) ))) {
SOURCE(45741, 58)
{
word pd432;
pd432 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c101820)+11)/* iData←v25872 */ ))+2) ))+4) ))+3) );
(void) ( *( (fPt) ((* (ptr) pd432 ))))((* (( (ptr) (* (( (ptr) &var←c101820)+11)/* iData←v25872 */ ))+2) ), (* (W4Pt) (
( (ptr) &var←c101820)+4)/* bounds←v15620 */ ), (* (( (ptr) &var←c101820)+8)/* boxes←v15648 */ ), pd432);
};
}
else {
SOURCE(45806, 183)
{
word interceptor←v25916;
SOURCE(45808, 44)
interceptor←v25916 = (* (( (ptr) (* (( (ptr) &var←c101820)+11)/* iData←v25872 */ ))+1) );
SOURCE(45930, 57)
{
word pd433;
pd433 = (* (ptr) interceptor←v25916 );
(void) ( *( (fPt) ((* (ptr) pd433 ))))(interceptor←v25916, (* (W4Pt) (( (ptr) &var←c101820)+4)/* bounds←v15620 */ ), (word) (
( (bPt) &var←c101820)+36)/* var←c98940 */ , 0, pd433);
};
};
};
}
static void action←P7596(formal←c101884)
word formal←c101884;
{
formal←c101884 = (formal←c101884 - 36);
/* action: */
SOURCE(45854, 15)
SOURCE(45870, 57)
{
word pd434;
pd434 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101884)+11) ))+2) ))+4) ))+3) );
(void) ( *( (fPt) ((* (ptr) pd434 ))))((* (( (ptr) (* (( (ptr) formal←c101884)+11) ))+2) ), (* (W4Pt) (( (ptr) formal←c101884)+4)
), (* (( (ptr) formal←c101884)+8) ), pd434);
};
}
static void ModifyMaskRegion←P3480(device←v15708, formal←c0942, formal←c0943)
word device←v15708;
W4 formal←c0942;
word formal←c0943;
{
W12 var←c101916;
/* declaration of bounds←v15736 skipped */
/* declaration of edgeGenerator←v15764 skipped */
register ptr gf←c101948 = (ptr) &globalframe;
/* declaration of var←c98972 skipped */
/* declaration of iData←v26004 skipped */
(* (W4Pt) (( (ptr) &var←c101916)+4)/* bounds←v15736 */ ) = formal←c0942;
(* (( (ptr) &var←c101916)+8)/* edgeGenerator←v15764 */ ) = formal←c0943;
/* ModifyMaskRegion: */
SOURCE(45996, 440)
{
word tmpAddr435;
tmpAddr435 = (word) (( (ptr) &var←c101916)+9)/* var←c98972 */ ;
(* (ptr) tmpAddr435 ) = ( ((word) (fPt) action←P7704) );
(* (( (ptr) tmpAddr435) + 1) ) = 1;
};
SOURCE(46103, 42)
(* (( (ptr) &var←c101916)+11)/* iData←v26004 */ ) = XR←Narrow((* (( (ptr) device←v15708)+7) ), (* (( (ptr) gf←c101948)+27)
));
SOURCE(46147, 289)
if ((0 != (* (ptr) (* (( (ptr) &var←c101916)+11)/* iData←v26004 */ ) ))) {
SOURCE(46172, 67)
{
word pd436;
pd436 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c101916)+11)/* iData←v26004 */ ))+2) ))+4) ))+4) );
(void) ( *( (fPt) ((* (ptr) pd436 ))))((* (( (ptr) (* (( (ptr) &var←c101916)+11)/* iData←v26004 */ ))+2) ), (* (W4Pt) (
( (ptr) &var←c101916)+4)/* bounds←v15736 */ ), (* (( (ptr) &var←c101916)+8)/* edgeGenerator←v15764 */ ), pd436);
};
}
else {
SOURCE(46246, 192)
{
word interceptor←v26048;
SOURCE(46248, 44)
interceptor←v26048 = (* (( (ptr) (* (( (ptr) &var←c101916)+11)/* iData←v26004 */ ))+1) );
SOURCE(46379, 57)
{
word pd437;
pd437 = (* (ptr) interceptor←v26048 );
(void) ( *( (fPt) ((* (ptr) pd437 ))))(interceptor←v26048, (* (W4Pt) (( (ptr) &var←c101916)+4)/* bounds←v15736 */ ), (word) (
( (bPt) &var←c101916)+36)/* var←c98972 */ , 0, pd437);
};
};
};
}
static void action←P7704(formal←c101980)
word formal←c101980;
{
formal←c101980 = (formal←c101980 - 36);
/* action: */
SOURCE(46294, 15)
SOURCE(46310, 66)
{
word pd438;
pd438 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c101980)+11) ))+2) ))+4) ))+4) );
(void) ( *( (fPt) ((* (ptr) pd438 ))))((* (( (ptr) (* (( (ptr) formal←c101980)+11) ))+2) ), (* (W4Pt) (( (ptr) formal←c101980)+4)
), (* (( (ptr) formal←c101980)+8) ), pd438);
};
}
static void ModifyMaskBitmap←P3540(device←v15884, formal←c0944, formal←c0945, formal←c0946, formal←c0947)
word device←v15884;
word formal←c0944;
W2 formal←c0945;
W4 formal←c0946;
word formal←c0947;
{
W15 var←c102012;
/* declaration of bitmap←v15912 skipped */
/* declaration of delta←v15940 skipped */
/* declaration of bounds←v15968 skipped */
/* declaration of boxes←v15996 skipped */
register ptr gf←c102044 = (ptr) &globalframe;
/* declaration of var←c99004 skipped */
/* declaration of iData←v26136 skipped */
(* (( (ptr) &var←c102012)+4)/* bitmap←v15912 */ ) = formal←c0944;
(* (W2Pt) (( (ptr) &var←c102012)+5)/* delta←v15940 */ ) = formal←c0945;
(* (W4Pt) (( (ptr) &var←c102012)+7)/* bounds←v15968 */ ) = formal←c0946;
(* (( (ptr) &var←c102012)+11)/* boxes←v15996 */ ) = formal←c0947;
/* ModifyMaskBitmap: */
SOURCE(46445, 465)
{
word tmpAddr439;
tmpAddr439 = (word) (( (ptr) &var←c102012)+12)/* var←c99004 */ ;
(* (ptr) tmpAddr439 ) = ( ((word) (fPt) action←P7812) );
(* (( (ptr) tmpAddr439) + 1) ) = 1;
};
SOURCE(46563, 42)
(* (( (ptr) &var←c102012)+14)/* iData←v26136 */ ) = XR←Narrow((* (( (ptr) device←v15884)+7) ), (* (( (ptr) gf←c102044)+27)
));
SOURCE(46607, 303)
if ((0 != (* (ptr) (* (( (ptr) &var←c102012)+14)/* iData←v26136 */ ) ))) {
SOURCE(46632, 74)
{
word pd440;
pd440 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c102012)+14)/* iData←v26136 */ ))+2) ))+4) ))+5) );
(void) ( *( (fPt) ((* (ptr) pd440 ))))((* (( (ptr) (* (( (ptr) &var←c102012)+14)/* iData←v26136 */ ))+2) ), (* (( (ptr) &var←c102012)+4)
/* bitmap←v15912 */ ), (* (W2Pt) (( (ptr) &var←c102012)+5)/* delta←v15940 */ ), (* (W4Pt) (( (ptr) &var←c102012)+7)/* bounds←v15968 */ ), (* (
( (ptr) &var←c102012)+11)/* boxes←v15996 */ ), pd440);
};
}
else {
SOURCE(46713, 199)
{
word interceptor←v26180;
SOURCE(46715, 44)
interceptor←v26180 = (* (( (ptr) (* (( (ptr) &var←c102012)+14)/* iData←v26136 */ ))+1) );
SOURCE(46853, 57)
{
word pd441;
pd441 = (* (ptr) interceptor←v26180 );
(void) ( *( (fPt) ((* (ptr) pd441 ))))(interceptor←v26180, (* (W4Pt) (( (ptr) &var←c102012)+7)/* bounds←v15968 */ ), (word) (
( (bPt) &var←c102012)+48)/* var←c99004 */ , 0, pd441);
};
};
};
}
static void action←P7812(formal←c102076)
word formal←c102076;
{
formal←c102076 = (formal←c102076 - 48);
/* action: */
SOURCE(46761, 15)
SOURCE(46777, 73)
{
word pd442;
pd442 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102076)+14) ))+2) ))+4) ))+5) );
(void) ( *( (fPt) ((* (ptr) pd442 ))))((* (( (ptr) (* (( (ptr) formal←c102076)+14) ))+2) ), (* (( (ptr) formal←c102076)+4)
), (* (W2Pt) (( (ptr) formal←c102076)+5) ), (* (W4Pt) (( (ptr) formal←c102076)+7) ), (* (( (ptr) formal←c102076)+11) ), pd442)
;
};
}
static void ModifyMaskPixelArray←P3600(device←v16056, formal←c0948, formal←c0949, formal←c0950, formal←c0951)
word device←v16056;
word formal←c0948;
word formal←c0949;
W4 formal←c0950;
word formal←c0951;
{
W14 var←c102108;
/* declaration of bitmap←v16084 skipped */
/* declaration of clientToDevice←v16112 skipped */
/* declaration of bounds←v16140 skipped */
/* declaration of boxes←v16168 skipped */
register ptr gf←c102140 = (ptr) &globalframe;
/* declaration of var←c99036 skipped */
/* declaration of iData←v26268 skipped */
(* (( (ptr) &var←c102108)+4)/* bitmap←v16084 */ ) = formal←c0948;
(* (( (ptr) &var←c102108)+5)/* clientToDevice←v16112 */ ) = formal←c0949;
(* (W4Pt) (( (ptr) &var←c102108)+6)/* bounds←v16140 */ ) = formal←c0950;
(* (( (ptr) &var←c102108)+10)/* boxes←v16168 */ ) = formal←c0951;
/* ModifyMaskPixelArray: */
SOURCE(46919, 513)
{
word tmpAddr443;
tmpAddr443 = (word) (( (ptr) &var←c102108)+11)/* var←c99036 */ ;
(* (ptr) tmpAddr443 ) = ( ((word) (fPt) action←P7920) );
(* (( (ptr) tmpAddr443) + 1) ) = 1;
};
SOURCE(47059, 42)
(* (( (ptr) &var←c102108)+13)/* iData←v26268 */ ) = XR←Narrow((* (( (ptr) device←v16056)+7) ), (* (( (ptr) gf←c102140)+27)
));
SOURCE(47103, 329)
if ((0 != (* (ptr) (* (( (ptr) &var←c102108)+13)/* iData←v26268 */ ) ))) {
SOURCE(47128, 87)
{
word pd444;
pd444 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c102108)+13)/* iData←v26268 */ ))+2) ))+4) ))+6) );
(void) ( *( (fPt) ((* (ptr) pd444 ))))((* (( (ptr) (* (( (ptr) &var←c102108)+13)/* iData←v26268 */ ))+2) ), (* (( (ptr) &var←c102108)+4)
/* bitmap←v16084 */ ), (* (( (ptr) &var←c102108)+5)/* clientToDevice←v16112 */ ), (* (W4Pt) (( (ptr) &var←c102108)+6)/* bounds←v16140 */ ), (* (
( (ptr) &var←c102108)+10)/* boxes←v16168 */ ), pd444);
};
}
else {
SOURCE(47222, 212)
{
word interceptor←v26312;
SOURCE(47224, 44)
interceptor←v26312 = (* (( (ptr) (* (( (ptr) &var←c102108)+13)/* iData←v26268 */ ))+1) );
SOURCE(47375, 57)
{
word pd445;
pd445 = (* (ptr) interceptor←v26312 );
(void) ( *( (fPt) ((* (ptr) pd445 ))))(interceptor←v26312, (* (W4Pt) (( (ptr) &var←c102108)+6)/* bounds←v16140 */ ), (word) (
( (bPt) &var←c102108)+44)/* var←c99036 */ , 0, pd445);
};
};
};
}
static void action←P7920(formal←c102172)
word formal←c102172;
{
formal←c102172 = (formal←c102172 - 44);
/* action: */
SOURCE(47270, 15)
SOURCE(47286, 86)
{
word pd446;
pd446 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102172)+13) ))+2) ))+4) ))+6) );
(void) ( *( (fPt) ((* (ptr) pd446 ))))((* (( (ptr) (* (( (ptr) formal←c102172)+13) ))+2) ), (* (( (ptr) formal←c102172)+4)
), (* (( (ptr) formal←c102172)+5) ), (* (W4Pt) (( (ptr) formal←c102172)+6) ), (* (( (ptr) formal←c102172)+10) ), pd446)
;
};
}
static void ModifyMaskRawBitmaps←P3660(device←v16228, formal←c0952)
word device←v16228;
word formal←c0952;
{
W8 var←c102204;
/* declaration of list←v16256 skipped */
register ptr gf←c102236 = (ptr) &globalframe;
/* declaration of var←c99068 skipped */
/* declaration of iData←v26400 skipped */
var←c102204.f4/* list←v16256 */ = formal←c0952;
/* ModifyMaskRawBitmaps: */
SOURCE(47441, 676)
{
word tmpAddr447;
tmpAddr447 = (word) (( (ptr) &var←c102204)+5)/* var←c99068 */ ;
(* (ptr) tmpAddr447 ) = ( ((word) (fPt) action←P8028) );
(* (( (ptr) tmpAddr447) + 1) ) = 1;
};
SOURCE(47531, 42)
var←c102204.f7/* iData←v26400 */ = XR←Narrow((* (( (ptr) device←v16228)+7) ), (* (( (ptr) gf←c102236)+27) ));
SOURCE(47575, 542)
if ((0 != (* (ptr) var←c102204.f7/* iData←v26400 */ ))) {
SOURCE(47600, 54)
{
word pd448;
pd448 = (* (( (ptr) (* (( (ptr) (* (( (ptr) var←c102204.f7/* iData←v26400 */ )+2) ))+4) ))+7) );
(void) ( *( (fPt) ((* (ptr) pd448 ))))((* (( (ptr) var←c102204.f7/* iData←v26400 */ )+2) ), var←c102204.f4/* list←v16256 */ , pd448)
;
};
}
else {
SOURCE(47661, 458)
{
word interceptor←v26444;
W4 bounds←v26500;
SOURCE(47663, 44)
interceptor←v26444 = (* (( (ptr) var←c102204.f7/* iData←v26400 */ )+1) );
SOURCE(47783, 49)
bounds←v26500.f0 = 2147483647;
bounds←v26500.f1 = 2147483647;
bounds←v26500.f2 = 2147483648;
bounds←v26500.f3 = 2147483648;
SOURCE(47834, 187)
{
register word tail←v26560;
tail←v26560 = var←c102204.f4/* list←v16256 */ ;
lab←L100060: ;
if ((tail←v26560 != 0)) {
}
else {
goto lab←L100057;
};
SOURCE(47917, 51)
{
word pd449;
pd449 = (* (( (ptr) (* (( (ptr) gf←c102236)+185)/* var←c94844 */ ))+8) );
(void) ( *( (fPt) ((* (ptr) pd449 ))))((word) &bounds←v26500, (* (W2Pt) &bounds←v26500 ), (* (W2Pt) tail←v26560 ), pd449)
;
};
SOURCE(47970, 51)
{
word pd450;
pd450 = (* (( (ptr) (* (( (ptr) gf←c102236)+185)/* var←c94844 */ ))+10) );
(void) ( *( (fPt) ((* (ptr) pd450 ))))((word) (( (bPt) &bounds←v26500)+8), (* (W2Pt) (( (ptr) &bounds←v26500)+2) ), (* (W2Pt) (
( (ptr) tail←v26560)+2) ), pd450);
};
tail←v26560 = (* (( (ptr) tail←v26560)+7) );
goto lab←L100060;
lab←L100057: ;
};
SOURCE(48032, 85)
{
word pd451;
pd451 = (* (( (ptr) (* (( (ptr) gf←c102236)+185)/* var←c94844 */ ))+13) );
if ((0 != (word) ( *( (fPt) ((* (ptr) pd451 ))))(bounds←v26500, pd451))) {
SOURCE(48060, 57)
{
word pd452;
pd452 = (* (ptr) interceptor←v26444 );
(void) ( *( (fPt) ((* (ptr) pd452 ))))(interceptor←v26444, bounds←v26500, (word) (( (bPt) &var←c102204)+20)/* var←c99068 */ , 0, pd452)
;
};
};
};
};
};
}
static void action←P8028(formal←c102268)
word formal←c102268;
{
formal←c102268 = (formal←c102268 - 20);
/* action: */
SOURCE(47709, 15)
SOURCE(47726, 54)
{
word pd453;
pd453 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102268)+7) ))+2) ))+4) ))+7) );
(void) ( *( (fPt) ((* (ptr) pd453 ))))((* (( (ptr) (* (( (ptr) formal←c102268)+7) ))+2) ), (* (( (ptr) formal←c102268)+4)
), pd453);
};
}
static void ModifyDrawBitmap←P3720(device←v16400, formal←c0953, formal←c0954, formal←c0955, formal←c0956)
word device←v16400;
word formal←c0953;
W2 formal←c0954;
W4 formal←c0955;
word formal←c0956;
{
W15 var←c102300;
/* declaration of bitmap←v16428 skipped */
/* declaration of delta←v16456 skipped */
/* declaration of bounds←v16484 skipped */
/* declaration of boxes←v16512 skipped */
register ptr gf←c102332 = (ptr) &globalframe;
/* declaration of var←c99132 skipped */
/* declaration of iData←v26688 skipped */
(* (( (ptr) &var←c102300)+4)/* bitmap←v16428 */ ) = formal←c0953;
(* (W2Pt) (( (ptr) &var←c102300)+5)/* delta←v16456 */ ) = formal←c0954;
(* (W4Pt) (( (ptr) &var←c102300)+7)/* bounds←v16484 */ ) = formal←c0955;
(* (( (ptr) &var←c102300)+11)/* boxes←v16512 */ ) = formal←c0956;
/* ModifyDrawBitmap: */
SOURCE(48126, 465)
{
word tmpAddr454;
tmpAddr454 = (word) (( (ptr) &var←c102300)+12)/* var←c99132 */ ;
(* (ptr) tmpAddr454 ) = ( ((word) (fPt) action←P8184) );
(* (( (ptr) tmpAddr454) + 1) ) = 1;
};
SOURCE(48244, 42)
(* (( (ptr) &var←c102300)+14)/* iData←v26688 */ ) = XR←Narrow((* (( (ptr) device←v16400)+7) ), (* (( (ptr) gf←c102332)+27)
));
SOURCE(48288, 303)
if ((0 != (* (ptr) (* (( (ptr) &var←c102300)+14)/* iData←v26688 */ ) ))) {
SOURCE(48313, 74)
{
word pd455;
pd455 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c102300)+14)/* iData←v26688 */ ))+2) ))+4) ))+8) );
(void) ( *( (fPt) ((* (ptr) pd455 ))))((* (( (ptr) (* (( (ptr) &var←c102300)+14)/* iData←v26688 */ ))+2) ), (* (( (ptr) &var←c102300)+4)
/* bitmap←v16428 */ ), (* (W2Pt) (( (ptr) &var←c102300)+5)/* delta←v16456 */ ), (* (W4Pt) (( (ptr) &var←c102300)+7)/* bounds←v16484 */ ), (* (
( (ptr) &var←c102300)+11)/* boxes←v16512 */ ), pd455);
};
}
else {
SOURCE(48394, 199)
{
word interceptor←v26732;
SOURCE(48396, 44)
interceptor←v26732 = (* (( (ptr) (* (( (ptr) &var←c102300)+14)/* iData←v26688 */ ))+1) );
SOURCE(48534, 57)
{
word pd456;
pd456 = (* (ptr) interceptor←v26732 );
(void) ( *( (fPt) ((* (ptr) pd456 ))))(interceptor←v26732, (* (W4Pt) (( (ptr) &var←c102300)+7)/* bounds←v16484 */ ), (word) (
( (bPt) &var←c102300)+48)/* var←c99132 */ , 0, pd456);
};
};
};
}
static void action←P8184(formal←c102364)
word formal←c102364;
{
formal←c102364 = (formal←c102364 - 48);
/* action: */
SOURCE(48442, 15)
SOURCE(48458, 73)
{
word pd457;
pd457 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102364)+14) ))+2) ))+4) ))+8) );
(void) ( *( (fPt) ((* (ptr) pd457 ))))((* (( (ptr) (* (( (ptr) formal←c102364)+14) ))+2) ), (* (( (ptr) formal←c102364)+4)
), (* (W2Pt) (( (ptr) formal←c102364)+5) ), (* (W4Pt) (( (ptr) formal←c102364)+7) ), (* (( (ptr) formal←c102364)+11) ), pd457)
;
};
}
static void ModifyMaskChar←P3780(device←v16572, formal←c0957, formal←c0958)
word device←v16572;
W2 formal←c0957;
word formal←c0958;
{
W10 var←c102396;
/* declaration of delta←v16600 skipped */
/* declaration of mask←v16628 skipped */
register ptr gf←c102428 = (ptr) &globalframe;
/* declaration of var←c99164 skipped */
/* declaration of iData←v26820 skipped */
(* (W2Pt) (( (ptr) &var←c102396)+4)/* delta←v16600 */ ) = formal←c0957;
(* (( (ptr) &var←c102396)+6)/* mask←v16628 */ ) = formal←c0958;
/* ModifyMaskChar: */
SOURCE(48600, 404)
{
word tmpAddr458;
tmpAddr458 = (word) (( (ptr) &var←c102396)+7)/* var←c99164 */ ;
(* (ptr) tmpAddr458 ) = ( ((word) (fPt) action←P8292) );
(* (( (ptr) tmpAddr458) + 1) ) = 1;
};
SOURCE(48673, 42)
(* (( (ptr) &var←c102396)+9)/* iData←v26820 */ ) = XR←Narrow((* (( (ptr) device←v16572)+7) ), (* (( (ptr) gf←c102428)+27)
));
SOURCE(48717, 287)
if ((0 != (* (ptr) (* (( (ptr) &var←c102396)+9)/* iData←v26820 */ ) ))) {
SOURCE(48742, 55)
{
word pd459;
pd459 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c102396)+9)/* iData←v26820 */ ))+2) ))+4) ))+9) );
(void) ( *( (fPt) ((* (ptr) pd459 ))))((* (( (ptr) (* (( (ptr) &var←c102396)+9)/* iData←v26820 */ ))+2) ), (* (W2Pt) (
( (ptr) &var←c102396)+4)/* delta←v16600 */ ), (* (( (ptr) &var←c102396)+6)/* mask←v16628 */ ), pd459);
};
}
else {
SOURCE(48804, 202)
{
word interceptor←v26864;
SOURCE(48806, 44)
interceptor←v26864 = (* (( (ptr) (* (( (ptr) &var←c102396)+9)/* iData←v26820 */ ))+1) );
SOURCE(48925, 79)
{
W4 var←c99196;
{
word pd460;
pd460 = (* (( (ptr) (* (( (ptr) gf←c102428)+185)/* var←c94844 */ ))+20) );
(void) ( *( (fPt) ((* (ptr) pd460 ))))((word) &var←c99196, (* (W4Pt) (( (ptr) (* (( (ptr) &var←c102396)+6)/* mask←v16628 */ ))+4)
), (* (W2Pt) (( (ptr) &var←c102396)+4)/* delta←v16600 */ ), pd460);
};
{
word pd461;
pd461 = (* (ptr) interceptor←v26864 );
(void) ( *( (fPt) ((* (ptr) pd461 ))))(interceptor←v26864, var←c99196, (word) (( (bPt) &var←c102396)+28)/* var←c99164 */ , 0, pd461)
;
};
};
};
};
}
static void action←P8292(formal←c102460)
word formal←c102460;
{
formal←c102460 = (formal←c102460 - 28);
/* action: */
SOURCE(48852, 15)
SOURCE(48868, 54)
{
word pd462;
pd462 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102460)+9) ))+2) ))+4) ))+9) );
(void) ( *( (fPt) ((* (ptr) pd462 ))))((* (( (ptr) (* (( (ptr) formal←c102460)+9) ))+2) ), (* (W2Pt) (( (ptr) formal←c102460)+4)
), (* (( (ptr) formal←c102460)+6) ), pd462);
};
}
static void ModifyMoveBox←P3840(device←v16688, formal←c0959, formal←c0960, formal←c0961)
word device←v16688;
W2 formal←c0959;
W2 formal←c0960;
W2 formal←c0961;
{
W13 var←c102492;
/* declaration of dstMin←v16716 skipped */
/* declaration of srcMin←v16744 skipped */
/* declaration of size←v16772 skipped */
register ptr gf←c102524 = (ptr) &globalframe;
/* declaration of var←c99228 skipped */
/* declaration of iData←v26952 skipped */
(* (W2Pt) (( (ptr) &var←c102492)+4)/* dstMin←v16716 */ ) = formal←c0959;
(* (W2Pt) (( (ptr) &var←c102492)+6)/* srcMin←v16744 */ ) = formal←c0960;
(* (W2Pt) (( (ptr) &var←c102492)+8)/* size←v16772 */ ) = formal←c0961;
/* ModifyMoveBox: */
SOURCE(49013, 505)
{
word tmpAddr463;
tmpAddr463 = (word) (( (ptr) &var←c102492)+10)/* var←c99228 */ ;
(* (ptr) tmpAddr463 ) = ( ((word) (fPt) action←P8400) );
(* (( (ptr) tmpAddr463) + 1) ) = 1;
};
SOURCE(49084, 42)
(* (( (ptr) &var←c102492)+12)/* iData←v26952 */ ) = XR←Narrow((* (( (ptr) device←v16688)+7) ), (* (( (ptr) gf←c102524)+27)
));
SOURCE(49128, 390)
if ((0 != (* (ptr) (* (( (ptr) &var←c102492)+12)/* iData←v26952 */ ) ))) {
SOURCE(49153, 63)
{
word pd464;
pd464 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c102492)+12)/* iData←v26952 */ ))+2) ))+4) ))+10) );
(void) ( *( (fPt) ((* (ptr) pd464 ))))((* (( (ptr) (* (( (ptr) &var←c102492)+12)/* iData←v26952 */ ))+2) ), (* (W2Pt) (
( (ptr) &var←c102492)+4)/* dstMin←v16716 */ ), (* (W2Pt) (( (ptr) &var←c102492)+6)/* srcMin←v16744 */ ), (* (W2Pt) (( (ptr) &var←c102492)+8)
/* size←v16772 */ ), pd464);
};
}
else {
SOURCE(49223, 297)
{
word interceptor←v26996;
W2 min←v27052;
W2 max←v27080;
SOURCE(49225, 44)
interceptor←v26996 = (* (( (ptr) (* (( (ptr) &var←c102492)+12)/* iData←v26952 */ ))+1) );
SOURCE(49352, 36)
{
word pd465;
pd465 = (* (( (ptr) (* (( (ptr) gf←c102524)+185)/* var←c94844 */ ))+8) );
(void) ( *( (fPt) ((* (ptr) pd465 ))))((word) &min←v27052, (* (W2Pt) (( (ptr) &var←c102492)+4)/* dstMin←v16716 */ ), (* (W2Pt) (
( (ptr) &var←c102492)+6)/* srcMin←v16744 */ ), pd465);
};
SOURCE(49390, 55)
{
W2 var←c99260;
{
W2 var←c99292;
{
word pd466;
pd466 = (* (( (ptr) (* (( (ptr) gf←c102524)+185)/* var←c94844 */ ))+6) );
(void) ( *( (fPt) ((* (ptr) pd466 ))))((word) &var←c99292, (* (W2Pt) (( (ptr) &var←c102492)+4)/* dstMin←v16716 */ ), (* (W2Pt) (
( (ptr) &var←c102492)+6)/* srcMin←v16744 */ ), pd466);
};
{
W2 var←c0745;
{
word pd467;
pd467 = (* (( (ptr) (* (( (ptr) gf←c102524)+185)/* var←c94844 */ ))+7) );
(void) ( *( (fPt) ((* (ptr) pd467 ))))((word) &var←c0745, var←c99292, min←v27052, pd467);
};
var←c99260 = var←c0745;
};
};
{
W2 var←c0746;
{
word pd468;
pd468 = (* (( (ptr) (* (( (ptr) gf←c102524)+185)/* var←c94844 */ ))+6) );
(void) ( *( (fPt) ((* (ptr) pd468 ))))((word) &var←c0746, var←c99260, (* (W2Pt) (( (ptr) &var←c102492)+8)/* size←v16772 */ ), pd468)
;
};
max←v27080 = var←c0746;
};
};
SOURCE(49447, 71)
{
W4 var←c99324;
(* (W2Pt) &var←c99324 ) = min←v27052;
(* (W2Pt) (( (ptr) &var←c99324)+2) ) = max←v27080;
{
word pd469;
pd469 = (* (ptr) interceptor←v26996 );
(void) ( *( (fPt) ((* (ptr) pd469 ))))(interceptor←v26996, var←c99324, (word) (( (bPt) &var←c102492)+40)/* var←c99228 */ , 0, pd469)
;
};
};
};
};
}
static void action←P8400(formal←c102556)
word formal←c102556;
{
formal←c102556 = (formal←c102556 - 40);
/* action: */
SOURCE(49271, 15)
SOURCE(49287, 62)
{
word pd470;
pd470 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102556)+12) ))+2) ))+4) ))+10) );
(void) ( *( (fPt) ((* (ptr) pd470 ))))((* (( (ptr) (* (( (ptr) formal←c102556)+12) ))+2) ), (* (W2Pt) (( (ptr) formal←c102556)+4)
), (* (W2Pt) (( (ptr) formal←c102556)+6) ), (* (W2Pt) (( (ptr) formal←c102556)+8) ), pd470);
};
}
static void ModifySwitchBuffer←P3900(device←v16832, formal←c0962, formal←c0963, formal←c0964)
word device←v16832;
W4 formal←c0962;
word formal←c0963;
word formal←c0964;
{
W13 var←c102588;
/* declaration of bounds←v16860 skipped */
/* declaration of copy←v16888 skipped */
/* declaration of alt←v16916 skipped */
register ptr gf←c102620 = (ptr) &globalframe;
/* declaration of var←c99356 skipped */
/* declaration of iData←v27140 skipped */
word interceptor←v27168;
(* (W4Pt) (( (ptr) &var←c102588)+4)/* bounds←v16860 */ ) = formal←c0962;
(* (( (ptr) &var←c102588)+8)/* copy←v16888 */ ) = formal←c0963;
(* (( (ptr) &var←c102588)+9)/* alt←v16916 */ ) = formal←c0964;
/* ModifySwitchBuffer: */
SOURCE(49527, 358)
{
word tmpAddr471;
tmpAddr471 = (word) (( (ptr) &var←c102588)+10)/* var←c99356 */ ;
(* (ptr) tmpAddr471 ) = ( ((word) (fPt) proc←P8460) );
(* (( (ptr) tmpAddr471) + 1) ) = 1;
};
SOURCE(49612, 42)
(* (( (ptr) &var←c102588)+12)/* iData←v27140 */ ) = XR←Narrow((* (( (ptr) device←v16832)+7) ), (* (( (ptr) gf←c102620)+27)
));
SOURCE(49656, 44)
interceptor←v27168 = (* (( (ptr) (* (( (ptr) &var←c102588)+12)/* iData←v27140 */ ))+1) );
SOURCE(49785, 78)
if ((0 != (* (( (ptr) &var←c102588)+8)/* copy←v16888 */ ))) {
SOURCE(49798, 59)
{
word pd472;
pd472 = (* (ptr) interceptor←v27168 );
(void) ( *( (fPt) ((* (ptr) pd472 ))))(interceptor←v27168, (* (W4Pt) (( (ptr) &var←c102588)+4)/* bounds←v16860 */ ), (word) (
( (bPt) &var←c102588)+40)/* var←c99356 */ , (* (( (ptr) &var←c102588)+9)/* alt←v16916 */ ), pd472);
};
}
else {
SOURCE(49857, 6)
(void) proc←P8460((word) ((( (bPt) &var←c102588)+40)/* var←c99356 */ ));
};
SOURCE(49865, 20)
(* (ptr) (* (( (ptr) &var←c102588)+12)/* iData←v27140 */ ) ) = (* (( (ptr) &var←c102588)+9)/* alt←v16916 */ );
}
static void proc←P8460(formal←c102652)
word formal←c102652;
{
formal←c102652 = (formal←c102652 - 40);
/* proc: */
SOURCE(49702, 80)
SOURCE(49717, 65)
{
word pd473;
pd473 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102652)+12) ))+2) ))+4) ))+11) );
(void) ( *( (fPt) ((* (ptr) pd473 ))))((* (( (ptr) (* (( (ptr) formal←c102652)+12) ))+2) ), (* (W4Pt) (( (ptr) formal←c102652)+4)
), (* (( (ptr) formal←c102652)+8) ), (* (( (ptr) formal←c102652)+9) ), pd473);
};
}
static word ModifyGetBufferColorOperator←P3960(device←v16976)
word device←v16976;
{
register ptr gf←c102684 = (ptr) &globalframe;
word var←c17020;
word iData←v27256;
word dev←v27284;
/* ModifyGetBufferColorOperator: */
SOURCE(49891, 260)
SOURCE(49971, 42)
iData←v27256 = XR←Narrow((* (( (ptr) device←v16976)+7) ), (* (( (ptr) gf←c102684)+27) ));
SOURCE(50015, 26)
dev←v27284 = (* (( (ptr) iData←v27256)+2) );
SOURCE(50043, 59)
if (((* (( (ptr) (* (( (ptr) dev←v27284)+4) ))+12) ) == 0)) {
SOURCE(50090, 12)
return(0);
};
SOURCE(50104, 47)
{
word pd474;
pd474 = (* (( (ptr) (* (( (ptr) dev←v27284)+4) ))+12) );
return((word) ( *( (fPt) ((* (ptr) pd474 ))))(dev←v27284, pd474));
};
}
static void ModifyAccessBuffer←P4020(device←v17080, formal←c0965, formal←c0966)
word device←v17080;
W4 formal←c0965;
word formal←c0966;
{
W12 var←c102716;
/* declaration of box←v17108 skipped */
/* declaration of action←v17136 skipped */
register ptr gf←c102748 = (ptr) &globalframe;
/* declaration of var←c99420 skipped */
/* declaration of iData←v27328 skipped */
(* (W4Pt) (( (ptr) &var←c102716)+4)/* box←v17108 */ ) = formal←c0965;
(* (( (ptr) &var←c102716)+8)/* action←v17136 */ ) = formal←c0966;
/* ModifyAccessBuffer: */
SOURCE(50155, 404)
{
word tmpAddr475;
tmpAddr475 = (word) (( (ptr) &var←c102716)+9)/* var←c99420 */ ;
(* (ptr) tmpAddr475 ) = ( ((word) (fPt) proc←P8568) );
(* (( (ptr) tmpAddr475) + 1) ) = 1;
};
SOURCE(50249, 42)
(* (( (ptr) &var←c102716)+11)/* iData←v27328 */ ) = XR←Narrow((* (( (ptr) device←v17080)+7) ), (* (( (ptr) gf←c102748)+27)
));
SOURCE(50293, 266)
if ((0 != (* (ptr) (* (( (ptr) &var←c102716)+11)/* iData←v27328 */ ) ))) {
SOURCE(50318, 59)
{
word pd476;
pd476 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) &var←c102716)+11)/* iData←v27328 */ ))+2) ))+4) ))+13) );
(void) ( *( (fPt) ((* (ptr) pd476 ))))((* (( (ptr) (* (( (ptr) &var←c102716)+11)/* iData←v27328 */ ))+2) ), (* (W4Pt) (
( (ptr) &var←c102716)+4)/* box←v17108 */ ), (* (( (ptr) &var←c102716)+8)/* action←v17136 */ ), pd476);
};
}
else {
SOURCE(50384, 177)
{
word interceptor←v27372;
SOURCE(50386, 44)
interceptor←v27372 = (* (( (ptr) (* (( (ptr) &var←c102716)+11)/* iData←v27328 */ ))+1) );
SOURCE(50507, 52)
{
word pd477;
pd477 = (* (ptr) interceptor←v27372 );
(void) ( *( (fPt) ((* (ptr) pd477 ))))(interceptor←v27372, (* (W4Pt) (( (ptr) &var←c102716)+4)/* box←v17108 */ ), (word) (
( (bPt) &var←c102716)+36)/* var←c99420 */ , 0, pd477);
};
};
};
}
static void proc←P8568(formal←c102780)
word formal←c102780;
{
formal←c102780 = (formal←c102780 - 36);
/* proc: */
SOURCE(50432, 13)
SOURCE(50446, 58)
{
word pd478;
pd478 = (* (( (ptr) (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c102780)+11) ))+2) ))+4) ))+13) );
(void) ( *( (fPt) ((* (ptr) pd478 ))))((* (( (ptr) (* (( (ptr) formal←c102780)+11) ))+2) ), (* (W4Pt) (( (ptr) formal←c102780)+4)
), (* (( (ptr) formal←c102780)+8) ), pd478);
};
}
static word InterceptorInEffect←P4080(context←v17256)
word context←v17256;
{
register ptr gf←c102812 = (ptr) &globalframe;
word var←c17300;
word state←v27460;
word rasterData←v27488;
/* InterceptorInEffect: */
SOURCE(50568, 199)
SOURCE(50639, 28)
state←v27460 = (* (( (ptr) context←v17256)+1) );
SOURCE(50669, 41)
rasterData←v27488 = (* (( (ptr) state←v27460)+40) );
SOURCE(50712, 55)
return( (unsigned) ((* (( (ptr) (* (ptr) rasterData←v27488 ))+4) ) == (* (( (ptr) gf←c102812)+10)/* modifiedDeviceClass←v7508 */ )));
}
static word SetInterceptor←P4140(context←v17360, interceptor←v17388)
word context←v17360;
word interceptor←v17388;
{
register ptr gf←c102844 = (ptr) &globalframe;
word old←v17432;
word state←v27532;
word rasterData←v27560;
/* SetInterceptor: */
SOURCE(50771, 651)
SOURCE(50771, 651)
old←v17432 = 0;
SOURCE(50881, 28)
state←v27532 = (* (( (ptr) context←v17360)+1) );
SOURCE(50911, 41)
rasterData←v27560 = (* (( (ptr) state←v27532)+40) );
SOURCE(50954, 168)
if (((* (( (ptr) (* (ptr) rasterData←v27560 ))+4) ) == (* (( (ptr) gf←c102844)+10)/* modifiedDeviceClass←v7508 */ ))) {
SOURCE(51008, 116)
{
word iData←v27604;
SOURCE(51010, 53)
iData←v27604 = XR←Narrow((* (( (ptr) (* (ptr) rasterData←v27560 ))+7) ), (* (( (ptr) gf←c102844)+27) ));
SOURCE(51065, 23)
old←v17432 = (* (( (ptr) iData←v27604)+1) );
SOURCE(51090, 32)
(* (ptr) rasterData←v27560 ) = (* (( (ptr) iData←v27604)+2) );
};
};
SOURCE(51127, 295)
if ((interceptor←v17388 != 0)) {
SOURCE(51153, 271)
{
word iData←v27648;
SOURCE(51155, 117)
iData←v27648 = XR←NewObject(12, (* (( (ptr) gf←c102844)+27) ));
(* (( (ptr) iData←v27648)+1) ) = interceptor←v17388;
(* (( (ptr) iData←v27648)+2) ) = (* (ptr) rasterData←v27560 );
SOURCE(51274, 148)
{
word pd479;
pd479 = (* (( (ptr) (* (( (ptr) gf←c102844)+191)/* var←c96476 */ ))+4) );
(* (ptr) rasterData←v27560 ) = (word) ( *( (fPt) ((* (ptr) pd479 ))))((* (( (ptr) gf←c102844)+10)/* modifiedDeviceClass←v7508 */ ), (* (
( (ptr) (* (ptr) rasterData←v27560 ))+5) ), (* (( (ptr) (* (ptr) rasterData←v27560 ))+6) ), iData←v27648, pd479);
};
};
};
SOURCE(50771, 651)
return(old←v17432);
}
static void NoName←Q11808(formal←c0780, formal←c200004, formal←c200005, formal←c200006, formal←c200007)
word formal←c0780;
word formal←c200004;
word formal←c200005;
word formal←c200006;
word formal←c200007;
{
register ptr gf←c0869 = (ptr) &globalframe;
if ((formal←c200005 == XR←Unwind)) {
SOURCE(44654, 29)
{
word pd480;
pd480 = (* (( (ptr) (* (( (ptr) gf←c0869)+179)/* var←c93532 */ ))+30) );
(void) ( *( (fPt) ((* (ptr) pd480 ))))((* (( (ptr) formal←c200004)+4) ), (* (( (ptr) formal←c200004)+6) ), pd480);
};
};
(* (ptr) formal←c0780 ) = 0;
(* (( (ptr) formal←c0780)+1) ) = 0;
return;
}
static void NoName←Q11868(formal←c0785, formal←c200000, formal←c200001, formal←c200002, formal←c200003)
word formal←c0785;
word formal←c200000;
word formal←c200001;
word formal←c200002;
word formal←c200003;
{
if ((formal←c200001 == XR←Unwind)) {
SOURCE(25102, 43)
(void) SetDeviceClipBox←P1680((* (( (ptr) formal←c200000)+4) ), (* (W4Pt) (( (ptr) formal←c200000)+15) ));
SOURCE(25147, 100)
{
word pd481;
pd481 = (* (( (ptr) (* (( (ptr) (* (ptr) (* (( (ptr) formal←c200000)+14) ) ))+4) ))+11) );
(void) ( *( (fPt) ((* (ptr) pd481 ))))((* (ptr) (* (( (ptr) formal←c200000)+14) ) ), (* (W4Pt) (( (ptr) formal←c200000)+19)
), 1, 0, pd481);
};
};
(* (ptr) formal←c0785 ) = 0;
(* (( (ptr) formal←c0785)+1) ) = 0;
return;
}
/* file: ImagerRasterImpl, module: ImagerRasterImpl, compiled at: March 9, 1994 11:42:53 am PST */
extern void XR←install←ImagerRasterImpl() {
NoName←Q11628();
}
extern void XR←run←ImagerRasterImpl() { XR←Start(&globalframe); }