/* Generated from Cedar to C at: May 9, 1988 5:26:49 pm PDT */
/* from module "YggLogBasicImpl" */
#include <cedar/InstallationSupport.h>
#include <cedar/CedarExtra.h>
#include <cedar/Basics.h>
static char versionStamp[] = "@(#)mob←version [2876622077,3964313475] YggLogBasicImpl";
typedef unsigned word, *ptr;
typedef unsigned char byte, *bytePtr;
typedef unsigned short half, *halfPtr;
typedef struct {word f0; word f1; word f2; word f3} BIT128;
typedef struct {BIT128 f; BIT128 r} BIT256;
typedef struct {BIT256 f; BIT256 r} BIT512;
typedef struct {BIT512 f; BIT512 r} BIT1024;
typedef struct {BIT1024 f; BIT1024 r} BIT2048;
typedef struct {BIT2048 f; BIT2048 r} BIT4096;
typedef struct {word f0; word f1} BIT64;
typedef struct {BIT128 f; BIT64 r} BIT192;
typedef struct {BIT256 f; BIT192 r} BIT448;
typedef struct {BIT512 f; BIT448 r} BIT960;
typedef struct {BIT4096 f; BIT960 r} BIT5056;
typedef word (*funcPtr)();
typedef BIT1024 *BIT1024Ptr;
typedef struct {word f0; word f1; word f2} BIT96;
typedef BIT96 *BIT96Ptr;
typedef BIT256 *BIT256Ptr;
typedef BIT64 *BIT64Ptr;
typedef BIT128 *BIT128Ptr;
typedef struct {BIT128 f; word r} BIT160;
typedef BIT160 *BIT160Ptr;
typedef struct {word proc; word link} ProcDescBody;
typedef BIT192 *BIT192Ptr;
#define SOURCE(p, l) /* source p, l */
#define SOURCEPOP(p, l, op, ol) /* source←pop op */
#define SGNCK(i) ((int) (word) (i) >= 0 ? i : XR←RaiseArithmeticFault())
#define IOP2(op, x, y) ( (word) (((int) (word) (x)) op ((int) (word) (y))) )
#define MIN(cast, x, y) ( ( cast x) < ( cast y) ? (x) : (y) )
#define BCK(idx, lim) ( ((unsigned) idx) >= ((unsigned) lim) ? (XR←RaiseBoundsFault()) : (idx) )
#define IOP1(op, x) ( (word) ( op ((int) (word) (x)) ) )
static void YggLogBasicImpl();
static struct {unsigned f; char r[20];} string1 = {1179668, "\205\210\242\000\003\257\300\253\165\304\375\300\354\112\237\203\100\202\000\000"};
static struct {unsigned f; char r[8];} string2 = {393222, "\010\000 \004\003\003\000\000"};
static struct {unsigned f; char r[16];} string3 = {786448, "\257\300\253\165\304\375\300\354\112\237\203\072\000\000\000\000"};
static struct {unsigned f; char r[16];} string4 = {917518, "\006\003\020\001\064\010\000\040\004\003\003\100\350\014\000\000"};
static struct {unsigned f; char r[16];} string5 = {786448, "\257\300\223\372\371\166\300\350\005\245\226\064\000\000\000\000"};
static struct {unsigned f; char r[16];} string6 = {786448, "\257\300\176\376\130\133\300\036\160\324\226\064\000\000\000\000"};
static struct {unsigned f; char r[16];} string7 = {786448, "\257\300\026\033\105\164\300\355\324\177\221\064\000\000\000\000"};
static struct {unsigned f; char r[16];} string8 = {786448, "\257\300\036\115\133\355\300\135\116\033\024\064\000\000\000\000"};
static struct {unsigned f; char r[16];} string9 = {786448, "\257\300\377\035\135\330\300\363\373\363\176\064\000\000\000\000"};
static struct {unsigned f; char r[16];} string10 = {786448, "\257\300\104\264\246\031\300\066\220\147\257\064\000\000\000\000"};
static struct {unsigned f; char r[16];} string11 = {786448, "\257\300\000\277\107\161\300\106\322\316\107\072\000\000\000\000"};
static struct {unsigned f; char r[16];} string12 = {786448, "\257\300\231\020\357\041\300\373\357\163\372\064\000\000\000\000"};
static void L0();
static void EstablishLogFile←150();
static word LogFileSize←180();
static word LogUsage←210();
static void AdvanceChunk←270();
static void ForceChunk←300();
static void ForceTo←330();
static void TailForceRequired←1200();
static void AwaitForce←1230();
static void OpenBasicForPut←360();
static void AssertNormalOperation←390();
static void CloseBasicForPut←420();
static void WordNumberFromRecordID←450();
static ProcDescBody descXenablex100046 = {0, 0};
static void enable←100046();
static void VerifyGet←480();
static void Release←510();
static word OpenPageStream←540();
static void ClosePageStream←570();
static void ReadAhead←600();
static void SavePageStreamPos←630();
static void ForgetSavedPageStreamPos←690();
static word AdvancePageStream←720();
static void SetPageStreamPosFromSavedPos←750();
static void OpenRecordStreamFromWord←780();
static void OpenRecordStreamFromCheckpoint←810();
static ProcDescBody descXenablex100074 = {0, 0};
static void enable←100074();
static word OpenRecordStream←840();
static void CurrentWordNumber←870();
static void CloseRecordStream←900();
static word VerifyCurrentRecordID←930();
static word CheckCurrentRecord←960();
static void GetCurrentRecord←990();
static void GetCurrentPageAndVersion←1020();
static void AdvanceRecordStream←1050();
static void LocateFirstRecord←1080();
static word LocateStartingPage←1110();
static void SkipAhead←1578();
static void Get←1140();
static void GetChunk←1608();
static void Verify←1698();
static word Ln9();
static BIT5056 globalframe;
static void YggLogBasicImpl()
{
register ptr gf←0454 = (ptr) &globalframe;
word var←16496;
word var←16528;
(* (( (ptr) gf←0454)+149) ) = ( ((word) (funcPtr) L0) );
(* (( (ptr) gf←0454)+147) ) = ( ((word) (funcPtr) EstablishLogFile←150) );
(* (( (ptr) gf←0454)+145) ) = ( ((word) (funcPtr) LogFileSize←180) );
(* (( (ptr) gf←0454)+143) ) = ( ((word) (funcPtr) LogUsage←210) );
(* (( (ptr) gf←0454)+141) ) = ( ((word) (funcPtr) AdvanceChunk←270) );
(* (( (ptr) gf←0454)+139) ) = ( ((word) (funcPtr) ForceChunk←300) );
(* (( (ptr) gf←0454)+137) ) = ( ((word) (funcPtr) ForceTo←330) );
(* (( (ptr) gf←0454)+135) ) = ( ((word) (funcPtr) OpenBasicForPut←360) );
(* (( (ptr) gf←0454)+133) ) = ( ((word) (funcPtr) AssertNormalOperation←390) );
(* (( (ptr) gf←0454)+131) ) = ( ((word) (funcPtr) CloseBasicForPut←420) );
(* (( (ptr) gf←0454)+129) ) = ( ((word) (funcPtr) WordNumberFromRecordID←450) );
(* (( (ptr) gf←0454)+127) ) = ( ((word) (funcPtr) VerifyGet←480) );
(* (( (ptr) gf←0454)+125) ) = ( ((word) (funcPtr) Release←510) );
(* (( (ptr) gf←0454)+123) ) = ( ((word) (funcPtr) OpenPageStream←540) );
(* (( (ptr) gf←0454)+121) ) = ( ((word) (funcPtr) ClosePageStream←570) );
(* (( (ptr) gf←0454)+119) ) = ( ((word) (funcPtr) ReadAhead←600) );
(* (( (ptr) gf←0454)+117) ) = ( ((word) (funcPtr) SavePageStreamPos←630) );
(* (( (ptr) gf←0454)+115) ) = ( ((word) (funcPtr) ForgetSavedPageStreamPos←690) );
(* (( (ptr) gf←0454)+113) ) = ( ((word) (funcPtr) AdvancePageStream←720) );
(* (( (ptr) gf←0454)+111) ) = ( ((word) (funcPtr) SetPageStreamPosFromSavedPos←750) );
(* (( (ptr) gf←0454)+109) ) = ( ((word) (funcPtr) OpenRecordStreamFromWord←780) );
(* (( (ptr) gf←0454)+107) ) = ( ((word) (funcPtr) OpenRecordStreamFromCheckpoint←810) );
(* (( (ptr) gf←0454)+105) ) = ( ((word) (funcPtr) OpenRecordStream←840) );
(* (( (ptr) gf←0454)+103) ) = ( ((word) (funcPtr) CurrentWordNumber←870) );
(* (( (ptr) gf←0454)+101) ) = ( ((word) (funcPtr) CloseRecordStream←900) );
(* (( (ptr) gf←0454)+99) ) = ( ((word) (funcPtr) VerifyCurrentRecordID←930) );
(* (( (ptr) gf←0454)+97) ) = ( ((word) (funcPtr) CheckCurrentRecord←960) );
(* (( (ptr) gf←0454)+95) ) = ( ((word) (funcPtr) GetCurrentRecord←990) );
(* (( (ptr) gf←0454)+93) ) = ( ((word) (funcPtr) GetCurrentPageAndVersion←1020) );
(* (( (ptr) gf←0454)+91) ) = ( ((word) (funcPtr) AdvanceRecordStream←1050) );
(* (( (ptr) gf←0454)+89) ) = ( ((word) (funcPtr) LocateFirstRecord←1080) );
(* (( (ptr) gf←0454)+87) ) = ( ((word) (funcPtr) LocateStartingPage←1110) );
(* (( (ptr) gf←0454)+85) ) = ( ((word) (funcPtr) Get←1140) );
(* (( (ptr) gf←0454)+76) ) = (word) XR←GetTypeIndex((word) &string1, 0, (word) &string2);
(void) XR←DeclareGlobalFrame((word) "YggLogBasicImpl\000", &globalframe, (word) XR←GetTypeIndex((word) &string3, 0, (word) &string4), (word) (( (bytePtr) gf←0454)+596)/* var←14128 */ );
var←16496 = (word) XR←ImportInterface((word) "Basics\000", (word) XR←GetTypeIndex((word) &string5, 0, 0), 62);
(* (( (ptr) gf←0454)+156)/* var←15280 */ ) = var←16496;
var←16496 = (word) XR←ImportInterface((word) "YggDummyProcess\000", (word) XR←GetTypeIndex((word) &string6, 0, 0), 19);
(* (( (ptr) gf←0454)+155)/* var←14784 */ ) = var←16496;
(void) XR←ImportProc(var←16496, 5, 0, 8);
var←16496 = (word) XR←ImportInterface((word) "YggFile\000", (word) XR←GetTypeIndex((word) &string7, 0, 0), 8);
(* (( (ptr) gf←0454)+151)/* var←14656 */ ) = var←16496;
(void) XR←ImportProc(var←16496, 7, 12, 4);
var←16496 = (word) XR←ImportInterface((word) "YggFilePageMgr\000", (word) XR←GetTypeIndex((word) &string8, 0, 0), 28);
(* (( (ptr) gf←0454)+152)/* var←14672 */ ) = var←16496;
(void) XR←ImportProc(var←16496, 5, 0, 12);
(void) XR←ImportProc(var←16496, 4, 16, 12);
(void) XR←ImportProc(var←16496, 7, 0, 16);
(void) XR←ImportProc(var←16496, 9, 0, 16);
(void) XR←ImportProc(var←16496, 6, 16, 12);
(void) XR←ImportProc(var←16496, 8, 0, 24);
(void) XR←ImportProc(var←16496, 15, 4, 4);
var←16496 = (word) XR←ImportInterface((word) "YggLog\000", (word) XR←GetTypeIndex((word) &string9, 0, 0), 9);
(* (( (ptr) gf←0454)+153)/* var←14704 */ ) = var←16496;
var←16496 = (word) XR←ImportInterface((word) "ConstArith\000", (word) XR←GetTypeIndex((word) &string10, 0, 0), 15);
(* (( (ptr) gf←0454)+154)/* var←14720 */ ) = var←16496;
(void) XR←ImportProc(var←16496, 9, 12, 24);
(void) XR←ImportProc(var←16496, 4, 4, 12);
(void) XR←ImportProc(var←16496, 10, 24, 24);
(void) XR←ImportProc(var←16496, 8, 12, 24);
(void) XR←ImportProc(var←16496, 5, 4, 12);
(void) XR←ImportProc(var←16496, 7, 12, 24);
(void) XR←ImportProc(var←16496, 14, 4, 24);
(void) XR←ImportProc(var←16496, 2, 12, 4);
(void) XR←ImportProc(var←16496, 6, 12, 24);
(void) XR←ImportProc(var←16496, 3, 12, 4);
(void) XR←ImportProc(var←16496, 11, 12, 24);
var←16528 = (word) XR←ExportInterface((word) "YggLogBasic\000", (word) XR←GetTypeIndex((word) &string11, 0, 0), 22);
(* (( (ptr) gf←0454)+157)/* var←16512 */ ) = var←16528;
(void) XR←ExportProc(var←16528, 0, (word) (( (bytePtr) gf←0454)+588)/* var←14112 */ , 0, 4);
(void) XR←ExportProc(var←16528, 1, (word) (( (bytePtr) gf←0454)+580)/* var←14096 */ , 4, 0);
(void) XR←ExportProc(var←16528, 2, (word) (( (bytePtr) gf←0454)+572)/* var←14080 */ , 4, 0);
(void) XR←ExportProc(var←16528, 3, (word) (( (bytePtr) gf←0454)+356)/* var←13648 */ , 12, 0);
(void) XR←ExportProc(var←16528, 4, (word) (( (bytePtr) gf←0454)+436)/* var←13808 */ , 16, 12);
(void) XR←ExportProc(var←16528, 5, (word) (( (bytePtr) gf←0454)+428)/* var←13792 */ , 16, 36);
(void) XR←ExportVar(var←16528, 6, (word) (( (bytePtr) gf←0454)+336));
(void) XR←ExportProc(var←16528, 7, (word) (( (bytePtr) gf←0454)+388)/* var←13712 */ , 4, 0);
(void) XR←ExportProc(var←16528, 8, (word) (( (bytePtr) gf←0454)+380)/* var←13696 */ , 8, 24);
(void) XR←ExportProc(var←16528, 9, (word) (( (bytePtr) gf←0454)+372)/* var←13680 */ , 8, 0);
(void) XR←ExportProc(var←16528, 10, (word) (( (bytePtr) gf←0454)+364)/* var←13664 */ , 20, 0);
(void) XR←ExportProc(var←16528, 11, (word) (( (bytePtr) gf←0454)+404)/* var←13744 */ , 0, 0);
(void) XR←ExportProc(var←16528, 13, (word) (( (bytePtr) gf←0454)+532)/* var←14000 */ , 0, 0);
(void) XR←ExportProc(var←16528, 15, (word) (( (bytePtr) gf←0454)+516)/* var←13968 */ , 12, 12);
(void) XR←ExportProc(var←16528, 19, (word) (( (bytePtr) gf←0454)+500)/* var←13936 */ , 0, 12);
(void) XR←ExportProc(var←16528, 20, (word) (( (bytePtr) gf←0454)+340)/* var←13616 */ , 8, 24);
var←16528 = (word) XR←ExportInterface((word) "YggLogBasicInternal\000", (word) XR←GetTypeIndex((word) &string12, 0, 0), 4);
(* (( (ptr) gf←0454)+157)/* var←16512 */ ) = var←16528;
(void) XR←ExportProc(var←16528, 0, (word) (( (bytePtr) gf←0454)+564)/* var←14064 */ , 12, 0);
(void) XR←ExportProc(var←16528, 1, (word) (( (bytePtr) gf←0454)+548)/* var←14032 */ , 0, 12);
(void) XR←ExportProc(var←16528, 2, (word) (( (bytePtr) gf←0454)+540)/* var←14016 */ , 8, 20);
(void) XR←ExportProc(var←16528, 3, (word) (( (bytePtr) gf←0454)+524)/* var←13984 */ , 0, 0);
};
static void L0(formal←061, formal←058)
word formal←061;
word formal←058;
{
register word lf←0555;
register ptr gf←0455 = (ptr) &globalframe;
lf←0555 = XR←ExtensionAlloc(36);
XR←PushHandler(lf←0555, 0);
/* YggLogBasicImpl */
SOURCE(170, 22341);
SOURCE(916, 37);
(* (( (ptr) gf←0455)+8)/* logFileHandle←1654 */ ) = 0;
SOURCEPOP(916, 37, 170, 22341);
SOURCE(2450, 50);
{
/* declaration of var←14640 skipped */
{
BIT256 var←0499;
{
BIT256 var←14624;
(* (ptr) &var←14624 ) = 0;
(* (( (ptr) &var←14624)+1) ) = 0;
(* (( (ptr) &var←14624)+2) ) = 0;
(* (( (ptr) &var←14624)+3) ) = 0;
(* (( (ptr) &var←14624)+4) ) = 1;
(* (( (ptr) &var←14624)+5) ) = 0;
(* (( (ptr) &var←14624)+6) ) = 0;
(* (( (ptr) &var←14624)+7) ) = 0;
var←0499 = var←14624;
};
{
BIT1024 allTemplate;
XR←FillLongWords( &allTemplate, &var←0499, 8, 4);
(* (BIT1024Ptr) (( (ptr) lf←0555)+4)/* var←14640 */ ) = allTemplate;
};
};
XR←AssignRefCompositeInit((word) (( (bytePtr) gf←0455)+52)/* chunkTable←1850 */ , (word) (( (bytePtr) lf←0555)+16)/* var←14640 */ , (* (( (ptr) gf←0455)+76) ), 32);
};
SOURCEPOP(2450, 50, 170, 22341);
SOURCE(2525, 21);
(* (( (ptr) gf←0455)+46) ) = 0;
(* (( (ptr) gf←0455)+47) ) = 0;
(* (( (ptr) gf←0455)+48) ) = 0;
(* (( (ptr) gf←0455)+49) ) = 0;
(* (( (ptr) gf←0455)+50) ) = 0;
(* (( (ptr) gf←0455)+51) ) = 0;
SOURCEPOP(2525, 21, 170, 22341);
SOURCE(8375, 28);
(* (( (ptr) gf←0455)+63) ) = 1;
SOURCEPOP(8375, 28, 170, 22341);
XR←PopHandler();
lf←0555 = XR←ExtensionFree(lf←0555);
};
static void EstablishLogFile←150(logFile←2756)
word logFile←2756;
{
register word lf←0556;
register ptr gf←0456 = (ptr) &globalframe;
lf←0556 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0556, 0);
/* EstablishLogFile */
SOURCE(1451, 264);
SOURCE(1516, 58);
{
word var←0500;
{
/* declaration of var←063 skipped */
{
word pd;
pd = (* (( (ptr) (* (( (ptr) gf←0456)+151)/* var←14656 */ ))+11) );
(void) ( *( (funcPtr) ((* (ptr) pd ))))((word) (( (bytePtr) lf←0556)+16)/* var←063 */ , logFile←2756, pd);
};
var←0500 = (* (( (ptr) lf←0556)+4) );
};
XR←AssignRef((word) (( (bytePtr) gf←0456)+32)/* logFileHandle←1654 */ , var←0500);
};
SOURCEPOP(1516, 58, 1451, 264);
SOURCE(1576, 51);
{
word pd13;
pd13 = (* (( (ptr) (* (( (ptr) gf←0456)+152)/* var←14672 */ ))+19) );
(* (( (ptr) gf←0456)+9)/* logFileSize←1668 */ ) = (word) ( *( (funcPtr) ((* (ptr) pd13 ))))((* ((( (ptr) gf←0456)+8)/* logFileHandle←1654 */ ) ), pd13);
};
SOURCEPOP(1576, 51, 1451, 264);
SOURCE(1629, 86);
{
BIT96 var←14688;
word pages←13562;
word deviceCharacteristics←13576;
SOURCE(859, 0);
pages←13562 = (* (( (ptr) gf←0456)+9)/* logFileSize←1668 */ );
SOURCEPOP(859, 0, 1629, 86);
SOURCE(859, 0);
deviceCharacteristics←13576 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0456)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(859, 0, 1629, 86);
{
/* declaration of var←067 skipped */
{
BIT96 var←0501;
BIT96 var←0502;
{
/* declaration of var←068 skipped */
{
word pd14;
pd14 = (* (( (ptr) (* (( (ptr) gf←0456)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd14 ))))((word) (( (bytePtr) lf←0556)+28)/* var←068 */ , pages←13562, pd14);
};
var←0501 = (* (BIT96Ptr) (( (ptr) lf←0556)+7)/* var←068 */ );
};
{
/* declaration of var←069 skipped */
{
word pd15;
word ctmp;
pd15 = (* (( (ptr) (* (( (ptr) gf←0456)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd15 ))))((word) (( (bytePtr) lf←0556)+28)/* var←069 */ , (
ctmp = (unsigned) (* (ptr) deviceCharacteristics←13576 ),
SGNCK(ctmp)
), pd15);
};
var←0502 = (* (BIT96Ptr) (( (ptr) lf←0556)+7)/* var←069 */ );
};
{
word pd16;
pd16 = (* (( (ptr) (* (( (ptr) gf←0456)+154)/* var←14720 */ ))+15) );
(void) ( *( (funcPtr) ((* (ptr) pd16 ))))((word) (( (bytePtr) lf←0556)+16)/* var←067 */ , var←0501, var←0502, pd16);
};
};
var←14688 = (* (BIT96Ptr) (( (ptr) lf←0556)+4)/* var←067 */ );
};
goto lab←100000;
lab←100000: ;
(* (BIT96Ptr) (( (ptr) gf←0456)+10)/* logFileLength←1682 */ ) = var←14688;
};
SOURCEPOP(1629, 86, 1451, 264);
XR←PopHandler();
lf←0556 = XR←ExtensionFree(lf←0556);
};
static word LogFileSize←180()
{
register ptr gf←0457 = (ptr) &globalframe;
/* LogFileSize */
SOURCE(1721, 71);
/* removed dead decl of 2786 */
SOURCE(1773, 19);
return((* (( (ptr) gf←0457)+9)/* logFileSize←1668 */ ));
SOURCEPOP(1773, 19, 1721, 71);
};
static word LogUsage←210()
{
register ptr gf←0458 = (ptr) &globalframe;
word nPages←4290;
/* LogUsage */
SOURCE(1798, 227);
/* removed dead decl of 2816 */
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0458)+16)/* LOCK←1472 */ ));
SOURCE(1853, 11);
SOURCEPOP(1853, 11, 1798, 227);
SOURCE(1866, 159);
{
word var←14752;
word var←0504;
{
word var←0503;
{
word var←14736;
word p←12490;
BIT64 pr←12506;
SOURCE(1172, 138);
SOURCEPOP(1172, 138, 1866, 159);
SOURCE(1172, 138);
pr←12506 = (* (BIT64Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0458)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0458)+45)/* tail←1864 */ )))+1) );
SOURCEPOP(1172, 138, 1866, 159);
SOURCE(1241, 25);
p←12490 = IOP2( + , pr←12506.f0, pr←12506.f1);
SOURCEPOP(1241, 25, 1866, 159);
SOURCE(1268, 42);
if ((p←12490 == (* (( (ptr) gf←0458)+9)/* logFileSize←1668 */ ))) {
var←14736 = 0;
}
else {
var←14736 = p←12490;
};
goto lab←100001;
SOURCEPOP(1268, 42, 1866, 159);
lab←100001: ;
var←0503 = var←14736;
};
var←0504 = (
nPages←4290 = IOP2( - , var←0503, (* (( (ptr) gf←0458)+56)/* oldestFilePage←1920 */ ))
);
};
if (IOP2( >= , var←0504, 0)) {
var←14752 = IOP2( + , nPages←4290, 100);
}
else {
var←14752 = IOP2( + , IOP2( + , nPages←4290, (* (( (ptr) gf←0458)+9)/* logFileSize←1668 */ )), 100);
};
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0458)+16)/* LOCK←1472 */ ));
return(var←14752);
};
SOURCEPOP(1866, 159, 1798, 227);
};
static void AdvanceChunk←270(formal←0115)
word formal←0115;
{
register word lf←0557;
register ptr gf←0459 = (ptr) &globalframe;
word var←14848;
word version←2966;
word pagesInChunk←2980;
word firstPagePtr←2994;
word newTail←4312;
word nextPage←4326;
BIT64 runForNextPage←4340;
word biasedOldestFilePage←4354;
lf←0557 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0557, 0);
/* AdvanceChunk */
SOURCE(2696, 1565);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0459)+16)/* LOCK←1472 */ ));
SOURCE(2825, 24);
SOURCEPOP(2825, 24, 2696, 1565);
SOURCE(2851, 20);
SOURCEPOP(2851, 20, 2696, 1565);
SOURCE(2873, 23);
{
BIT64 var←14768;
var←14768.f1 = 1;
var←14768.f0 = 0;
runForNextPage←4340 = var←14768;
};
SOURCEPOP(2873, 23, 2696, 1565);
SOURCE(2898, 32);
SOURCEPOP(2898, 32, 2696, 1565);
SOURCE(2934, 39);
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )))+7) ) = 1;
SOURCEPOP(2934, 39, 2696, 1565);
SOURCE(2983, 55);
SOURCE(2984, 52);
{
/* declaration of var←087 skipped */
word var←086;
var←086 = XR←ExtensionAlloc(5);
(* (ptr) (word) var←086 ) = (word) ( ((word) (funcPtr) Ln9) );
(* (( (ptr) (word) var←086) + 1) ) = (word) 0;
(* (( (ptr) (word) var←086) + 2) ) = (word) (( (bytePtr) gf←0459)+556)/* var←14048 */ ;
(* (( (ptr) (word) var←086) + 3) ) = (word) 0;
(* (( (ptr) (word) var←086) + 4) ) = (* (( (ptr) gf←0459)+45)/* tail←1864 */ );
(void) XR←Fork((word) (( (bytePtr) lf←0557)+16)/* var←087 */ , var←086);
{
word pd17;
pd17 = (* (( (ptr) (* (( (ptr) gf←0459)+155)/* var←14784 */ ))+9) );
(void) ( *( (funcPtr) ((* (ptr) pd17 ))))((* (BIT64Ptr) ((( (ptr) lf←0557)+4)/* var←087 */ ) ), pd17);
};
};
SOURCEPOP(2984, 52, 2983, 55);
SOURCEPOP(2983, 55, 2696, 1565);
SOURCE(3042, 109);
lab←100002: ;
SOURCE(3045, 35);
if (((* (( (ptr) gf←0459)+45)/* tail←1864 */ ) == 3)) {
newTail←4312 = 0;
}
else {
newTail←4312 = ((* (( (ptr) gf←0459)+45)/* tail←1864 */ ) + 1);
};
SOURCEPOP(3045, 35, 3042, 109);
SOURCE(3082, 48);
if ((0 == (* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+newTail←4312))+7) ))) {
SOURCE(3130, 4);
goto lab←100005;
SOURCEPOP(3130, 4, 3082, 48);
};
SOURCEPOP(3082, 48, 3042, 109);
SOURCE(3136, 15);
(void) (XR←Wait((word) (( (bytePtr) gf←0459)+16)/* LOCK←1472 */ , (word) (( (bytePtr) gf←0459)+184)/* completion←1878 */ ));
SOURCEPOP(3136, 15, 3042, 109);
goto lab←100002;
lab←100005: ;
SOURCEPOP(3042, 109, 2696, 1565);
SOURCE(3163, 56);
{
word var←14800;
word p←12450;
BIT64 pr←12466;
SOURCE(1172, 138);
SOURCEPOP(1172, 138, 3163, 56);
SOURCE(1172, 138);
pr←12466 = (* (BIT64Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )))+1) );
SOURCEPOP(1172, 138, 3163, 56);
SOURCE(1241, 25);
p←12450 = IOP2( + , pr←12466.f0, pr←12466.f1);
SOURCEPOP(1241, 25, 3163, 56);
SOURCE(1268, 42);
if ((p←12450 == (* (( (ptr) gf←0459)+9)/* logFileSize←1668 */ ))) {
var←14800 = 0;
}
else {
var←14800 = p←12450;
};
goto lab←100007;
SOURCEPOP(1268, 42, 3163, 56);
lab←100007: ;
nextPage←4326 = var←14800;
};
SOURCEPOP(3163, 56, 2696, 1565);
SOURCE(3221, 46);
{
BIT64 var←14816;
BIT64 pr←12266;
SOURCE(1028, 140);
SOURCEPOP(1028, 140, 3221, 46);
SOURCE(1028, 140);
pr←12266.f1 = 1;
pr←12266.f0 = 0;
SOURCEPOP(1028, 140, 3221, 46);
SOURCE(1103, 65);
{
BIT64 var←14832;
var←14832.f0 = nextPage←4326;
{
word x;
var←14832.f1 = (x = IOP2( - , (* (( (ptr) gf←0459)+9)/* logFileSize←1668 */ ), nextPage←4326),
MIN((int)(word), x, 4));
};
var←14816 = var←14832;
};
goto lab←100008;
SOURCEPOP(1103, 65, 3221, 46);
lab←100008: ;
runForNextPage←4340 = var←14816;
};
SOURCEPOP(3221, 46, 2696, 1565);
SOURCE(3269, 52);
biasedOldestFilePage←4354 = IOP2( - , (* (( (ptr) gf←0459)+56)/* oldestFilePage←1920 */ ), 100);
SOURCEPOP(3269, 52, 2696, 1565);
SOURCE(3323, 90);
if (IOP2( < , biasedOldestFilePage←4354, 0)) {
SOURCE(3356, 57);
biasedOldestFilePage←4354 = IOP2( + , biasedOldestFilePage←4354, (* (( (ptr) gf←0459)+9)/* logFileSize←1668 */ ));
SOURCEPOP(3356, 57, 3323, 90);
};
SOURCEPOP(3323, 90, 2696, 1565);
SOURCE(3415, 182);
if ( ( (0 != (* (( (ptr) gf←0459)+57)/* enforceBufferPages←1934 */ )) ? ( (IOP2( >= , biasedOldestFilePage←4354, runForNextPage←4340.f0)) ? IOP2( < , biasedOldestFilePage←4354, IOP2( + , runForNextPage←4340.f0, runForNextPage←4340.f1)) : 0 ) : 0 ) || ( (IOP2( >= , (* (( (ptr) gf←0459)+56)/* oldestFilePage←1920 */ ), runForNextPage←4340.f0)) ? IOP2( < , (* (( (ptr) gf←0459)+56)/* oldestFilePage←1920 */ ), IOP2( + , runForNextPage←4340.f0, runForNextPage←4340.f1)) : 0 ) ) {
SOURCE(3560, 37);
var←14848 = (* (( (ptr) (* (( (ptr) gf←0459)+153)/* var←14704 */ ))+10) );
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0459)+16)/* LOCK←1472 */ ));
goto lab←100009;
SOURCEPOP(3560, 37, 3415, 182);
};
SOURCEPOP(3415, 182, 2696, 1565);
SOURCE(3600, 149);
if (((* (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+newTail←4312) ) != 0)) {
SOURCE(3646, 103);
{
word pd18;
pd18 = (* (( (ptr) (* (( (ptr) gf←0459)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd18 ))))((* (BIT128Ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+newTail←4312) ), 4, 1, pd18);
};
SOURCEPOP(3646, 103, 3600, 149);
};
SOURCEPOP(3600, 149, 2696, 1565);
SOURCE(3752, 48);
if ((nextPage←4326 == 0)) {
SOURCE(3773, 27);
{
word idx;
(* (( (ptr) gf←0459)+52)/* curVersion←1892 */ ) = (
idx = (word) IOP2( - , 1, (* (( (ptr) gf←0459)+52)/* curVersion←1892 */ )),
BCK(idx, 2)
);
};
SOURCEPOP(3773, 27, 3752, 48);
};
SOURCEPOP(3752, 48, 2696, 1565);
SOURCE(3802, 14);
(* (( (ptr) gf←0459)+45)/* tail←1864 */ ) = newTail←4312;
SOURCEPOP(3802, 14, 2696, 1565);
SOURCE(3818, 43);
(* (BIT96Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )))+4) ) = (* (BIT96Ptr) (( (ptr) gf←0459)+53)/* nextTailChunkID←1906 */ );
SOURCEPOP(3818, 43, 2696, 1565);
SOURCE(3863, 104);
{
BIT128 var←14864;
{
/* declaration of var←098 skipped */
{
word pd19;
pd19 = (* (( (ptr) (* (( (ptr) gf←0459)+152)/* var←14672 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd19 ))))((word) (( (bytePtr) lf←0557)+16)/* var←098 */ , (* (( (ptr) gf←0459)+8)/* logFileHandle←1654 */ ), runForNextPage←4340, pd19);
};
var←14864 = (* (BIT128Ptr) (( (ptr) lf←0557)+4)/* var←098 */ );
};
(* (BIT96Ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )) ) = (* (BIT96Ptr) &var←14864 );
XR←AssignRef((word) (( (bytePtr) (( (BIT256Ptr) (( (bytePtr) gf←0459)+52)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )))+12), var←14864.f3);
};
SOURCEPOP(3863, 104, 2696, 1565);
SOURCE(3969, 164);
{
BIT96 var←14880;
BIT96 r←13402;
word words←13416;
SOURCE(960, 0);
r←13402 = (* (BIT96Ptr) (( (ptr) gf←0459)+53)/* nextTailChunkID←1906 */ );
SOURCEPOP(960, 0, 3969, 164);
SOURCE(960, 0);
{
word var←14896;
word pages←13222;
word deviceCharacteristics←13236;
SOURCE(628, 0);
pages←13222 = (* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )))+2) );
SOURCEPOP(628, 0, 960, 0);
SOURCE(628, 0);
deviceCharacteristics←13236 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0459)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(628, 0, 960, 0);
{
word var←14912;
word count←8250;
count←8250 = (* (( (ptr) deviceCharacteristics←13236)+2) );
{
word idx20;
if (IOP2( >= , count←8250, 0)) {
var←14912 = (word) XRM←BITLSHIFT(pages←13222, BCK(count←8250, 2147483648));
}
else {
var←14912 = (word) XRM←BITRSHIFT(pages←13222, (
idx20 = (word) IOP1( - , count←8250),
BCK(idx20, 2147483648)
));
};
};
goto lab←100010;
lab←100010: ;
var←14896 = var←14912;
};
goto lab←100011;
lab←100011: ;
words←13416 = var←14896;
};
SOURCEPOP(960, 0, 3969, 164);
{
BIT96 var←14928;
BIT96 r←7682;
word words←7698;
r←7682 = r←13402;
words←7698 = words←13416;
{
/* declaration of var←0110 skipped */
{
BIT96 var←0505;
{
/* declaration of var←0111 skipped */
{
word pd21;
pd21 = (* (( (ptr) (* (( (ptr) gf←0459)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd21 ))))((word) (( (bytePtr) lf←0557)+28)/* var←0111 */ , words←7698, pd21);
};
var←0505 = (* (BIT96Ptr) (( (ptr) lf←0557)+7)/* var←0111 */ );
};
{
word pd22;
pd22 = (* (( (ptr) (* (( (ptr) gf←0459)+154)/* var←14720 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd22 ))))((word) (( (bytePtr) lf←0557)+16)/* var←0110 */ , r←7682, var←0505, pd22);
};
};
var←14928 = (* (BIT96Ptr) (( (ptr) lf←0557)+4)/* var←0110 */ );
};
goto lab←100012;
lab←100012: ;
var←14880 = var←14928;
};
goto lab←100013;
lab←100013: ;
(* (BIT96Ptr) (( (ptr) gf←0459)+53)/* nextTailChunkID←1906 */ ) = var←14880;
};
SOURCEPOP(3969, 164, 2696, 1565);
SOURCE(4136, 125);
{
word var←14944;
word var←14960;
word var←14976;
var←14944 = (* (( (ptr) gf←0459)+52)/* curVersion←1892 */ );
var←14960 = (* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )))+2) );
var←14976 = (* (ptr) (( (BIT256Ptr) (( (ptr) gf←0459)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0459)+45)/* tail←1864 */ )) );
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0459)+16)/* LOCK←1472 */ ));
(* (ptr) (word) formal←0115 ) = (word) var←14944;
(* (( (ptr) (word) formal←0115) + 1) ) = (word) var←14960;
(* (( (ptr) (word) formal←0115) + 2) ) = (word) var←14976;
XR←PopHandler();
goto lab←0209;
};
SOURCEPOP(4136, 125, 2696, 1565);
goto lab←100014;
lab←100009: ;
SOURCE(3560, 37);
(void) XR←RaiseError(var←14848, 0);
lab←100014: ;
XR←PopHandler();
lab←0209: ;
lf←0557 = XR←ExtensionFree(lf←0557);
};
static void ForceChunk←300(index←3030)
word index←3030;
{
register ptr gf←0460 = (ptr) &globalframe;
/* ForceChunk */
SOURCE(4268, 241);
SOURCE(4429, 57);
{
word pd23;
pd23 = (* (( (ptr) (* (( (ptr) gf←0460)+152)/* var←14672 */ ))+13) );
(void) ( *( (funcPtr) ((* (ptr) pd23 ))))((* (BIT128Ptr) ((( (BIT256Ptr) (( (ptr) gf←0460)+13)/* chunkTable←1850 */ )+index←3030)) ), pd23);
};
SOURCEPOP(4429, 57, 4268, 241);
SOURCE(4488, 21);
SOURCE(4488, 21);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0460)+16)/* LOCK←1472 */ ));
SOURCE(4361, 41);
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0460)+13)/* chunkTable←1850 */ )+index←3030))+7) ) = 0;
SOURCEPOP(4361, 41, 4488, 21);
SOURCE(4404, 20);
(void) (XR←Broadcast((word) (( (bytePtr) gf←0460)+184)/* completion←1878 */ ));
SOURCEPOP(4404, 20, 4488, 21);
SOURCE(4314, 110);
goto lab←100015;
SOURCEPOP(4314, 110, 4488, 21);
SOURCEPOP(4488, 21, 4488, 21);
lab←100015: ;
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0460)+16)/* LOCK←1472 */ ));
SOURCEPOP(4488, 21, 4268, 241);
};
static void ForceTo←330(formal←0576)
BIT96 formal←0576;
{
register word lf←0558;
register ptr gf←0461 = (ptr) &globalframe;
/* declaration of var←14992 skipped */
/* declaration of var←15008 skipped */
word doForce←4434;
BIT128 chunk←4448;
lf←0558 = XR←ExtensionAlloc(16);
(* (BIT96Ptr) (( (ptr) lf←0558)+4)/* followingRecord←3060 */ ) = formal←0576;
XR←PushHandler(lf←0558, 0);
/* ForceTo */
SOURCE(4515, 1030);
{
word tmpAddr;
tmpAddr = (word) (( (ptr) lf←0558)+7)/* var←14992 */ ;
(* (ptr) tmpAddr ) = (word) ( ((word) (funcPtr) AwaitForce←1230) );
(* (( (ptr) tmpAddr) + 1) ) = (word) 1;
};
{
word tmpAddr24;
tmpAddr24 = (word) (( (ptr) lf←0558)+9)/* var←15008 */ ;
(* (ptr) tmpAddr24 ) = (word) ( ((word) (funcPtr) TailForceRequired←1200) );
(* (( (ptr) tmpAddr24) + 1) ) = (word) 1;
};
SOURCE(5288, 13);
SOURCEPOP(5288, 13, 4515, 1030);
SOURCE(5304, 31);
{
BIT128 var←15024;
var←15024.f2 = 1;
var←15024.f1 = 0;
var←15024.f3 = 0;
var←15024.f0 = 0;
chunk←4448 = var←15024;
};
SOURCEPOP(5304, 31, 4515, 1030);
SOURCE(5337, 38);
{
BIT160 var←15040;
{
/* declaration of var←0124 skipped */
{
word pd25;
pd25 = ((word) (( (bytePtr) lf←0558)+36)/* var←15008 */ );
(void) ( *( (funcPtr) ((* (ptr) pd25 ))))((word) ((( (bytePtr) lf←0558)+44)/* var←0124 */ ), pd25);
};
var←15040 = (* (BIT160Ptr) (( (ptr) lf←0558)+11)/* var←0124 */ );
};
chunk←4448 = (* (BIT128Ptr) (( (ptr) &var←15040)+1) );
doForce←4434 = (* (ptr) &var←15040 );
};
SOURCEPOP(5337, 38, 4515, 1030);
SOURCE(5377, 153);
if ((0 != doForce←4434)) {
SOURCE(5395, 50);
{
word pd26;
pd26 = (* (( (ptr) (* (( (ptr) gf←0461)+152)/* var←14672 */ ))+13) );
(void) ( *( (funcPtr) ((* (ptr) pd26 ))))(chunk←4448, pd26);
};
SOURCEPOP(5395, 50, 5377, 153);
SOURCE(5447, 83);
{
word pd27;
pd27 = (* (( (ptr) (* (( (ptr) gf←0461)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd27 ))))(chunk←4448, 4, 1, pd27);
};
SOURCEPOP(5447, 83, 5377, 153);
};
SOURCEPOP(5377, 153, 4515, 1030);
SOURCE(5533, 12);
{
word pd28;
pd28 = ((word) (( (bytePtr) lf←0558)+28)/* var←14992 */ );
(void) ( *( (funcPtr) ((* (ptr) pd28 ))))(pd28);
};
SOURCEPOP(5533, 12, 4515, 1030);
XR←PopHandler();
lf←0558 = XR←ExtensionFree(lf←0558);
};
static void TailForceRequired←1200(formal←0131, formal←0463)
word formal←0131;
word formal←0463;
{
register ptr gf←0462 = (ptr) &globalframe;
word var←15056;
word doForce←4486;
BIT128 chunk←4500;
formal←0463 = (formal←0463 - 36);
/* TailForceRequired */
SOURCE(4568, 440);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0462)+16)/* LOCK←1472 */ ));
SOURCE(4568, 440);
chunk←4500.f2 = 1;
chunk←4500.f1 = 0;
chunk←4500.f3 = 0;
chunk←4500.f0 = 0;
SOURCEPOP(4568, 440, 4568, 440);
SOURCE(4670, 111);
{
word pd29;
pd29 = (* (( (ptr) (* (( (ptr) gf←0462)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd29 ))))((* (BIT96Ptr) (( (ptr) formal←0463)+4) ), (* (BIT96Ptr) (( (ptr) gf←0462)+53)/* nextTailChunkID←1906 */ ), pd29) == 2)) {
SOURCE(4741, 40);
var←15056 = (word) (( (bytePtr) gf←0462)+328);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0462)+16)/* LOCK←1472 */ ));
goto lab←100016;
SOURCEPOP(4741, 40, 4670, 111);
};
};
SOURCEPOP(4670, 111, 4568, 440);
SOURCE(4783, 225);
{
word pd30;
pd30 = (* (( (ptr) (* (( (ptr) gf←0462)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd30 ))))((* (BIT96Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0462)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0462)+45)/* tail←1864 */ )))+4) ), (* (BIT96Ptr) (( (ptr) formal←0463)+4) ), pd30) == 0)) {
SOURCE(4863, 53);
{
word pd31;
pd31 = (* (( (ptr) (* (( (ptr) gf←0462)+152)/* var←14672 */ ))+11) );
(void) ( *( (funcPtr) ((* (ptr) pd31 ))))((* (BIT128Ptr) ((( (BIT256Ptr) (( (ptr) gf←0462)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0462)+45)/* tail←1864 */ ))) ), pd31);
};
SOURCEPOP(4863, 53, 4783, 225);
SOURCE(4918, 38);
{
BIT128 var←15072;
var←15072 = (* (BIT128Ptr) (( (BIT256Ptr) (( (ptr) gf←0462)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0462)+45)/* tail←1864 */ )) );
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0462)+16)/* LOCK←1472 */ ));
(* (ptr) (word) formal←0131 ) = (word) 1;
(* (BIT128Ptr) (( (ptr) (word) formal←0131) + 1) ) = var←15072;
return;
};
SOURCEPOP(4918, 38, 4783, 225);
}
else {
SOURCE(4963, 45);
{
BIT128 var←15104;
{
BIT128 var←15088;
var←15088.f0 = 0;
var←15088.f1 = 0;
var←15088.f2 = 0;
var←15088.f3 = 0;
var←15104 = var←15088;
};
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0462)+16)/* LOCK←1472 */ ));
(* (ptr) (word) formal←0131 ) = (word) 0;
(* (BIT128Ptr) (( (ptr) (word) formal←0131) + 1) ) = var←15104;
return;
};
SOURCEPOP(4963, 45, 4783, 225);
};
};
SOURCEPOP(4783, 225, 4568, 440);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0462)+16)/* LOCK←1472 */ ));
goto lab←100017;
lab←100016: ;
SOURCE(4741, 40);
(void) XR←RaiseError(var←15056, 0);
lab←100017: ;
};
static void AwaitForce←1230(formal←0465)
word formal←0465;
{
register ptr gf←0464 = (ptr) &globalframe;
formal←0465 = (formal←0465 - 28);
/* AwaitForce */
SOURCE(5011, 262);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0464)+16)/* LOCK←1472 */ ));
SOURCE(5041, 232);
{
register word currentChunk←4522 = 0;
SOURCE(5041, 0);
SOURCEPOP(5041, 0, 5041, 232);
goto lab←100019;
lab←100018: ;
currentChunk←4522 = IOP2( + , currentChunk←4522, 1);
lab←100019: ;
SOURCE(5105, 168);
SOURCE(5107, 155);
{
word pd32;
pd32 = (* (( (ptr) (* (( (ptr) gf←0464)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd32 ))))((* (BIT96Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0464)+13)/* chunkTable←1850 */ )+currentChunk←4522))+4) ), (* (BIT96Ptr) (( (ptr) formal←0465)+4) ), pd32) == 0)) {
SOURCE(5193, 69);
lab←100023: ;
if ((* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0464)+13)/* chunkTable←1850 */ )+currentChunk←4522))+7) )) {
}
else {
goto lab←100025;
};
SOURCE(5247, 15);
(void) (XR←Wait((word) (( (bytePtr) gf←0464)+16)/* LOCK←1472 */ , (word) (( (bytePtr) gf←0464)+184)/* completion←1878 */ ));
SOURCEPOP(5247, 15, 5193, 69);
goto lab←100023;
lab←100025: ;
SOURCEPOP(5193, 69, 5107, 155);
};
};
SOURCEPOP(5107, 155, 5105, 168);
SOURCEPOP(5105, 168, 5041, 232);
if (IOP2( < , currentChunk←4522, 3)) {
goto lab←100018;
};
};
SOURCEPOP(5041, 232, 5011, 262);
SOURCE(5011, 262);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0464)+16)/* LOCK←1472 */ ));
return;
SOURCEPOP(5011, 262, 5011, 262);
};
static void OpenBasicForPut←360(formal←0158, nextPage←3090, version←3104, nextRecord←3118)
word formal←0158;
word nextPage←3090;
word version←3104;
BIT96 nextRecord←3118;
{
register word lf←0559;
register ptr gf←0466 = (ptr) &globalframe;
word pagesInChunk←3140;
word firstPagePtr←3154;
lf←0559 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0559, 0);
/* OpenBasicForPut */
SOURCE(5551, 696);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0466)+16)/* LOCK←1472 */ ));
SOURCE(5724, 26);
(* (( (ptr) gf←0466)+57)/* enforceBufferPages←1934 */ ) = 0;
SOURCEPOP(5724, 26, 5551, 696);
SOURCE(5752, 20);
(* (( (ptr) gf←0466)+52)/* curVersion←1892 */ ) = version←3104;
SOURCEPOP(5752, 20, 5551, 696);
SOURCE(5774, 29);
(* (( (ptr) gf←0466)+45)/* tail←1864 */ ) = 0;
SOURCEPOP(5774, 29, 5551, 696);
SOURCE(5805, 38);
(* (BIT96Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0466)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )))+4) ) = nextRecord←3118;
SOURCEPOP(5805, 38, 5551, 696);
SOURCE(5845, 119);
{
BIT128 var←15152;
{
/* declaration of var←0139 skipped */
{
BIT64 var←0506;
{
BIT64 var←15120;
BIT64 pr←12242;
SOURCE(1028, 140);
SOURCEPOP(1028, 140, 5845, 119);
SOURCE(1028, 140);
pr←12242.f1 = 1;
pr←12242.f0 = 0;
SOURCEPOP(1028, 140, 5845, 119);
SOURCE(1103, 65);
{
BIT64 var←15136;
var←15136.f0 = nextPage←3090;
{
word x33;
var←15136.f1 = (x33 = IOP2( - , (* (( (ptr) gf←0466)+9)/* logFileSize←1668 */ ), nextPage←3090),
MIN((int)(word), x33, 4));
};
var←15120 = var←15136;
};
goto lab←100028;
SOURCEPOP(1103, 65, 5845, 119);
lab←100028: ;
var←0506 = var←15120;
};
{
word pd34;
pd34 = (* (( (ptr) (* (( (ptr) gf←0466)+152)/* var←14672 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd34 ))))((word) (( (bytePtr) lf←0559)+16)/* var←0139 */ , (* (( (ptr) gf←0466)+8)/* logFileHandle←1654 */ ), var←0506, pd34);
};
};
var←15152 = (* (BIT128Ptr) (( (ptr) lf←0559)+4)/* var←0139 */ );
};
(* (BIT96Ptr) (( (BIT256Ptr) (( (ptr) gf←0466)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )) ) = (* (BIT96Ptr) &var←15152 );
XR←AssignRef((word) (( (bytePtr) (( (BIT256Ptr) (( (bytePtr) gf←0466)+52)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )))+12), var←15152.f3);
};
SOURCEPOP(5845, 119, 5551, 696);
SOURCE(5966, 174);
{
BIT96 var←15168;
BIT96 r←13328;
word words←13342;
SOURCE(960, 0);
r←13328 = (* (BIT96Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0466)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )))+4) );
SOURCEPOP(960, 0, 5966, 174);
SOURCE(960, 0);
{
word var←15184;
word pages←13162;
word deviceCharacteristics←13176;
SOURCE(628, 0);
pages←13162 = (* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0466)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )))+2) );
SOURCEPOP(628, 0, 960, 0);
SOURCE(628, 0);
deviceCharacteristics←13176 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0466)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(628, 0, 960, 0);
{
word var←15200;
word count←13200;
count←13200 = (* (( (ptr) deviceCharacteristics←13176)+2) );
{
word idx35;
if (IOP2( >= , count←13200, 0)) {
var←15200 = (word) XRM←BITLSHIFT(pages←13162, BCK(count←13200, 2147483648));
}
else {
var←15200 = (word) XRM←BITRSHIFT(pages←13162, (
idx35 = (word) IOP1( - , count←13200),
BCK(idx35, 2147483648)
));
};
};
goto lab←100029;
lab←100029: ;
var←15184 = var←15200;
};
goto lab←100030;
lab←100030: ;
words←13342 = var←15184;
};
SOURCEPOP(960, 0, 5966, 174);
{
BIT96 var←15216;
BIT96 r←13366;
word words←13380;
r←13366 = r←13328;
words←13380 = words←13342;
{
/* declaration of var←0154 skipped */
{
BIT96 var←0507;
{
/* declaration of var←0155 skipped */
{
word pd36;
pd36 = (* (( (ptr) (* (( (ptr) gf←0466)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd36 ))))((word) (( (bytePtr) lf←0559)+28)/* var←0155 */ , words←13380, pd36);
};
var←0507 = (* (BIT96Ptr) (( (ptr) lf←0559)+7)/* var←0155 */ );
};
{
word pd37;
pd37 = (* (( (ptr) (* (( (ptr) gf←0466)+154)/* var←14720 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd37 ))))((word) (( (bytePtr) lf←0559)+16)/* var←0154 */ , r←13366, var←0507, pd37);
};
};
var←15216 = (* (BIT96Ptr) (( (ptr) lf←0559)+4)/* var←0154 */ );
};
goto lab←100031;
lab←100031: ;
var←15168 = var←15216;
};
goto lab←100032;
lab←100032: ;
(* (BIT96Ptr) (( (ptr) gf←0466)+53)/* nextTailChunkID←1906 */ ) = var←15168;
};
SOURCEPOP(5966, 174, 5551, 696);
SOURCE(6142, 105);
{
word var←15232;
word var←15248;
var←15232 = (* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0466)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )))+2) );
var←15248 = (* (ptr) (( (BIT256Ptr) (( (ptr) gf←0466)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0466)+45)/* tail←1864 */ )) );
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0466)+16)/* LOCK←1472 */ ));
(* (ptr) (word) formal←0158 ) = (word) var←15232;
(* (( (ptr) (word) formal←0158) + 1) ) = (word) var←15248;
XR←PopHandler();
goto lab←0211;
};
SOURCEPOP(6142, 105, 5551, 696);
XR←PopHandler();
lab←0211: ;
lf←0559 = XR←ExtensionFree(lf←0559);
};
static void AssertNormalOperation←390()
{
register ptr gf←0467 = (ptr) &globalframe;
/* AssertNormalOperation */
SOURCE(6253, 73);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0467)+16)/* LOCK←1472 */ ));
SOURCE(6301, 25);
(* (( (ptr) gf←0467)+57)/* enforceBufferPages←1934 */ ) = 1;
SOURCEPOP(6301, 25, 6253, 73);
SOURCE(6253, 73);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0467)+16)/* LOCK←1472 */ ));
return;
SOURCEPOP(6253, 73, 6253, 73);
};
static void CloseBasicForPut←420()
{
register ptr gf←0468 = (ptr) &globalframe;
/* CloseBasicForPut */
SOURCE(6332, 326);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0468)+16)/* LOCK←1472 */ ));
SOURCE(6375, 283);
{
register word i←4544 = 0;
SOURCE(6375, 0);
SOURCEPOP(6375, 0, 6375, 283);
goto lab←100034;
lab←100033: ;
i←4544 = IOP2( + , i←4544, 1);
lab←100034: ;
SOURCE(6420, 54);
lab←100038: ;
if ((* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+7) )) {
}
else {
goto lab←100040;
};
SOURCE(6459, 15);
(void) (XR←Wait((word) (( (bytePtr) gf←0468)+16)/* LOCK←1472 */ , (word) (( (bytePtr) gf←0468)+184)/* completion←1878 */ ));
SOURCEPOP(6459, 15, 6420, 54);
goto lab←100038;
lab←100040: ;
SOURCEPOP(6420, 54, 6375, 283);
SOURCE(6485, 53);
{
word pd38;
pd38 = (* (( (ptr) (* (( (ptr) gf←0468)+152)/* var←14672 */ ))+13) );
(void) ( *( (funcPtr) ((* (ptr) pd38 ))))((* (BIT128Ptr) ((( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544)) ), pd38);
};
SOURCEPOP(6485, 53, 6375, 283);
SOURCE(6540, 98);
{
word pd39;
pd39 = (* (( (ptr) (* (( (ptr) gf←0468)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd39 ))))((* (BIT128Ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544) ), 4, 0, pd39);
};
SOURCEPOP(6540, 98, 6375, 283);
SOURCE(6640, 18);
(* (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544) ) = 0;
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+1) ) = 0;
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+2) ) = 0;
XR←AssignRef((word) (( (bytePtr) (( (BIT256Ptr) (( (bytePtr) gf←0468)+52)/* chunkTable←1850 */ )+i←4544))+12), 0);
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+4) ) = 1;
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+5) ) = 0;
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+6) ) = 0;
(* (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0468)+13)/* chunkTable←1850 */ )+i←4544))+7) ) = 0;
SOURCEPOP(6640, 18, 6375, 283);
if (IOP2( < , i←4544, 3)) {
goto lab←100033;
};
};
SOURCEPOP(6375, 283, 6332, 326);
SOURCE(6332, 326);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0468)+16)/* LOCK←1472 */ ));
return;
SOURCEPOP(6332, 326, 6332, 326);
};
static void WordNumberFromRecordID←450(formal←0185, thisRecord←3206)
word formal←0185;
BIT96 thisRecord←3206;
{
register word lf←0560;
register ptr gf←0469 = (ptr) &globalframe;
BIT96 result←3228;
lf←0560 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0560, 0);
/* WordNumberFromRecordID */
SOURCE(6673, 875);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0469)+16)/* LOCK←1472 */ ));
SOURCE(6769, 779);
SOURCE(6771, 34);
{
BIT96 offsetFromNextTailChunk←4566;
SOURCE(6771, 34);
SOURCEPOP(6771, 34, 6771, 34);
SOURCE(6815, 82);
SOURCE(6816, 66);
{
word pd40;
pd40 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd40 ))))(thisRecord←3206, (* (BIT96Ptr) (( (ptr) gf←0469)+53)/* nextTailChunkID←1906 */ ), pd40) == 2)) {
SOURCE(6882, 13);
goto lab←100044;
SOURCEPOP(6882, 13, 6816, 66);
};
};
SOURCEPOP(6816, 66, 6815, 82);
SOURCEPOP(6815, 82, 6771, 34);
SOURCE(6900, 127);
{
BIT96 var←15264;
SOURCE(671, 0);
switch (XR←PushHandler(lf←0560, &descXenablex100046)) {
case 0: {
/* declaration of var←0169 skipped */
{
word pd41;
pd41 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+11) );
(void) ( *( (funcPtr) ((* (ptr) pd41 ))))((word) (( (bytePtr) lf←0560)+16)/* var←0169 */ , (* (BIT96Ptr) (( (ptr) gf←0469)+53)/* nextTailChunkID←1906 */ ), thisRecord←3206, pd41);
};
var←15264 = (* (BIT96Ptr) (( (ptr) lf←0560)+4)/* var←0169 */ );
};
XR←PopHandler();
goto lab←100048;
XR←PopHandler(); break;
case 1: XR←PopHandler(); goto L100045;
default: XR←RaiseAbstractionFault();
};
SOURCEPOP(671, 0, 6900, 127);
lab←100048: ;
offsetFromNextTailChunk←4566 = var←15264;
};
SOURCEPOP(6900, 127, 6771, 34);
SOURCE(7043, 75);
{
word pd42;
pd42 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd42 ))))(offsetFromNextTailChunk←4566, (* (BIT96Ptr) (( (ptr) gf←0469)+10)/* logFileLength←1682 */ ), pd42) != 0)) {
SOURCE(7118, 13);
goto L100045;
SOURCEPOP(7118, 13, 7043, 75);
};
};
SOURCEPOP(7043, 75, 6771, 34);
SOURCE(7133, 216);
{
BIT96 var←15296;
BIT96 num←13064;
BIT96 words←13078;
SOURCE(1215, 24);
{
BIT96 var←15312;
word pages←13524;
word deviceCharacteristics←13538;
SOURCE(859, 0);
{
word var←15328;
word p←12410;
BIT64 pr←12426;
SOURCE(1172, 138);
SOURCEPOP(1172, 138, 859, 0);
SOURCE(1172, 138);
pr←12426 = (* (BIT64Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0469)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0469)+45)/* tail←1864 */ )))+1) );
SOURCEPOP(1172, 138, 859, 0);
SOURCE(1241, 25);
p←12410 = IOP2( + , pr←12426.f0, pr←12426.f1);
SOURCEPOP(1241, 25, 859, 0);
SOURCE(1268, 42);
if ((p←12410 == (* (( (ptr) gf←0469)+9)/* logFileSize←1668 */ ))) {
var←15328 = 0;
}
else {
var←15328 = p←12410;
};
goto lab←100049;
SOURCEPOP(1268, 42, 859, 0);
lab←100049: ;
pages←13524 = var←15328;
};
SOURCEPOP(859, 0, 1215, 24);
SOURCE(859, 0);
deviceCharacteristics←13538 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0469)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(859, 0, 1215, 24);
{
/* declaration of var←0178 skipped */
{
BIT96 var←0508;
BIT96 var←0509;
{
/* declaration of var←0179 skipped */
{
word pd43;
pd43 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd43 ))))((word) (( (bytePtr) lf←0560)+28)/* var←0179 */ , pages←13524, pd43);
};
var←0508 = (* (BIT96Ptr) (( (ptr) lf←0560)+7)/* var←0179 */ );
};
{
/* declaration of var←0180 skipped */
{
word pd44;
word ctmp45;
pd44 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd44 ))))((word) (( (bytePtr) lf←0560)+28)/* var←0180 */ , (
/*1*/ ctmp45 = (unsigned) (* (ptr) deviceCharacteristics←13538 ),
/*1*/ SGNCK(ctmp45)
/*1*/ ), pd44);
};
var←0509 = (* (BIT96Ptr) (( (ptr) lf←0560)+7)/* var←0180 */ );
};
{
word pd46;
pd46 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+15) );
(void) ( *( (funcPtr) ((* (ptr) pd46 ))))((word) (( (bytePtr) lf←0560)+16)/* var←0178 */ , var←0508, var←0509, pd46);
};
};
var←15312 = (* (BIT96Ptr) (( (ptr) lf←0560)+4)/* var←0178 */ );
};
goto lab←100050;
lab←100050: ;
num←13064 = var←15312;
};
SOURCEPOP(1215, 24, 7133, 216);
SOURCE(1215, 24);
words←13078 = offsetFromNextTailChunk←4566;
SOURCEPOP(1215, 24, 7133, 216);
{
/* declaration of var←0182 skipped */
{
word pd47;
pd47 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+11) );
(void) ( *( (funcPtr) ((* (ptr) pd47 ))))((word) (( (bytePtr) lf←0560)+16)/* var←0182 */ , num←13064, words←13078, pd47);
};
var←15296 = (* (BIT96Ptr) (( (ptr) lf←0560)+4)/* var←0182 */ );
};
goto lab←100051;
lab←100051: ;
result←3228 = var←15296;
};
SOURCEPOP(7133, 216, 6771, 34);
SOURCE(7351, 105);
{
BIT96 var←15344;
if ((result←3228.f0 == 0)) {
{
/* declaration of var←0184 skipped */
{
word pd48;
pd48 = (* (( (ptr) (* (( (ptr) gf←0469)+154)/* var←14720 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd48 ))))((word) (( (bytePtr) lf←0560)+16)/* var←0184 */ , result←3228, (* (BIT96Ptr) (( (ptr) gf←0469)+10)/* logFileLength←1682 */ ), pd48);
};
var←15344 = (* (BIT96Ptr) (( (ptr) lf←0560)+4)/* var←0184 */ );
};
}
else {
var←15344 = result←3228;
};
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0469)+16)/* LOCK←1472 */ ));
(* (BIT96Ptr) formal←0185 ) = var←15344;
XR←PopHandler();
goto lab←0212;
};
SOURCEPOP(7351, 105, 6771, 34);
};
SOURCEPOP(6771, 34, 6769, 779);
goto lab←100043;
lab←100044: ;
SOURCE(7476, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0469)+328), 0);
SOURCEPOP(7476, 28, 6769, 779);
goto lab←100043;
L100045: ;
SOURCE(7518, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0469)+328), 0);
SOURCEPOP(7518, 28, 6769, 779);
goto lab←100043;
lab←100043: ;
SOURCEPOP(6769, 779, 6673, 875);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0469)+16)/* LOCK←1472 */ ));
XR←PopHandler();
lab←0212: ;
lf←0560 = XR←ExtensionFree(lf←0560);
};
static void enable←100046(formal←0168, formal←200000, formal←200001, formal←200002, formal←200003)
word formal←0168;
word formal←200000;
word formal←200001;
word formal←200002;
word formal←200003;
{
register ptr gf←0470 = (ptr) &globalframe;
if ((formal←200001 == (* (( (ptr) (* (( (ptr) gf←0470)+156)/* var←15280 */ ))+11) ))) {
SOURCE(7027, 14);
(* (ptr) (word) formal←0168 ) = (word) 2;
(* (( (ptr) (word) formal←0168) + 1) ) = (word) 1;
return;
};
(* (ptr) (word) formal←0168 ) = (word) 0;
(* (( (ptr) (word) formal←0168) + 1) ) = (word) 0;
return;
};
static void VerifyGet←480(page←3258, pagePtr←3272)
word page←3258;
word pagePtr←3272;
{
register ptr gf←0471 = (ptr) &globalframe;
word var←15360;
word p←12106;
word var←0510;
/* VerifyGet */
SOURCE(7552, 187);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0471)+16)/* LOCK←1472 */ ));
SOURCE(7627, 39);
SOURCE(7628, 36);
{
word x49;
SOURCE(807, 106);
p←12106 = pagePtr←3272;
SOURCEPOP(807, 106, 7628, 36);
SOURCE(892, 21);
var←15360 = p←12106;
goto lab←100052;
SOURCEPOP(892, 21, 7628, 36);
lab←100052: ;
x49 = (word) ( (unsigned) (* (bytePtr) var←15360 ) >> 7);
if (x49) {
SOURCE(7658, 6);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0471)+16)/* LOCK←1472 */ ));
return;
SOURCEPOP(7658, 6, 7628, 36);
};
};
SOURCEPOP(7628, 36, 7627, 39);
SOURCEPOP(7627, 39, 7552, 187);
SOURCE(7669, 70);
{
word var←15376;
BIT64 pr←12530;
SOURCE(1314, 133);
pr←12530 = (* (BIT64Ptr) (( (ptr) (( (BIT256Ptr) (( (ptr) gf←0471)+13)/* chunkTable←1850 */ )+(* (( (ptr) gf←0471)+45)/* tail←1864 */ )))+1) );
SOURCEPOP(1314, 133, 7669, 70);
SOURCE(1393, 54);
if (IOP2( >= , page←3258, pr←12530.f0)) {
var←15376 = IOP2( < , page←3258, IOP2( + , pr←12530.f0, pr←12530.f1));
}
else {
var←15376 = 0;
};
goto lab←100053;
SOURCEPOP(1393, 54, 7669, 70);
lab←100053: ;
var←0510 = var←15376;
};
if ((0 != var←0510)) {
SOURCE(7733, 6);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0471)+16)/* LOCK←1472 */ ));
return;
SOURCEPOP(7733, 6, 7669, 70);
};
SOURCEPOP(7669, 70, 7552, 187);
SOURCE(7741, 5);
(void) XR←RaiseError(XR←UnnamedError, 0);
SOURCEPOP(7741, 5, 7552, 187);
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0471)+16)/* LOCK←1472 */ ));
};
static void Release←510(beforeRecord←3308)
BIT96 beforeRecord←3308;
{
register word lf←0561;
register ptr gf←0472 = (ptr) &globalframe;
lf←0561 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0561, 0);
/* Release */
SOURCE(7753, 286);
SOURCE(7919, 120);
{
word newOldestFilePage←12554;
SOURCE(7919, 120);
{
word var←15392;
BIT96 words←13026;
word deviceCharacteristics←13040;
SOURCE(1117, 0);
{
/* declaration of var←0196 skipped */
(void) WordNumberFromRecordID←450((word) (( (bytePtr) lf←0561)+16)/* var←0196 */ , beforeRecord←3308);
words←13026 = (* (BIT96Ptr) (( (ptr) lf←0561)+4)/* var←0196 */ );
};
SOURCEPOP(1117, 0, 7919, 120);
SOURCE(1117, 0);
deviceCharacteristics←13040 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0472)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(1117, 0, 7919, 120);
{
/* declaration of var←0198 skipped */
/* declaration of var←0199 skipped */
{
word pd50;
pd50 = (* (( (ptr) (* (( (ptr) gf←0472)+154)/* var←14720 */ ))+12) );
{
word pd51;
pd51 = (* (( (ptr) (* (( (ptr) gf←0472)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd51 ))))((word) (( (bytePtr) lf←0561)+28)/* var←0199 */ , (* (ptr) deviceCharacteristics←13040 ), pd51);
};
(void) ( *( (funcPtr) ((* (ptr) pd50 ))))((word) (( (bytePtr) lf←0561)+16)/* var←0198 */ , words←13026, (* (BIT96Ptr) (( (ptr) lf←0561)+7)/* var←0199 */ ), pd50);
};
{
word pd52;
pd52 = (* (( (ptr) (* (( (ptr) gf←0472)+154)/* var←14720 */ ))+9) );
var←15392 = (word) ( *( (funcPtr) ((* (ptr) pd52 ))))((* (BIT96Ptr) ((( (ptr) lf←0561)+4)/* var←0198 */ ) ), pd52);
};
};
goto lab←100054;
lab←100054: ;
newOldestFilePage←12554 = var←15392;
};
SOURCEPOP(7919, 120, 7919, 120);
SOURCE(7919, 120);
(void) (XR←MonitorEntry((word) (( (bytePtr) gf←0472)+16)/* LOCK←1472 */ ));
SOURCE(7881, 35);
(* (( (ptr) gf←0472)+56)/* oldestFilePage←1920 */ ) = newOldestFilePage←12554;
SOURCEPOP(7881, 35, 7919, 120);
SOURCE(7803, 113);
goto lab←100055;
SOURCEPOP(7803, 113, 7919, 120);
SOURCEPOP(7919, 120, 7919, 120);
lab←100055: ;
(void) (XR←MonitorExit((word) (( (bytePtr) gf←0472)+16)/* LOCK←1472 */ ));
};
SOURCEPOP(7919, 120, 7753, 286);
XR←PopHandler();
lf←0561 = XR←ExtensionFree(lf←0561);
};
static word OpenPageStream←540(p←3478)
word p←3478;
{
word temp;
word temp55;
register word lf←0562;
register ptr gf←0473 = (ptr) &globalframe;
word endOfLog←3500;
lf←0562 = XR←ExtensionAlloc(8);
XR←PushHandler(lf←0562, 0);
/* OpenPageStream */
SOURCE(8406, 557);
SOURCE(8472, 107);
{
BIT128 var←15440;
{
/* declaration of var←0203 skipped */
{
BIT64 var←0511;
{
BIT64 var←15408;
BIT64 pr←12218;
SOURCE(1028, 140);
SOURCEPOP(1028, 140, 8472, 107);
SOURCE(1028, 140);
pr←12218.f1 = 1;
pr←12218.f0 = 0;
SOURCEPOP(1028, 140, 8472, 107);
SOURCE(1103, 65);
{
BIT64 var←15424;
var←15424.f0 = p←3478;
{
word x53;
var←15424.f1 = (x53 = IOP2( - , (* (( (ptr) gf←0473)+9)/* logFileSize←1668 */ ), p←3478),
MIN((int)(word), x53, 4));
};
var←15408 = var←15424;
};
goto lab←100056;
SOURCEPOP(1103, 65, 8472, 107);
lab←100056: ;
var←0511 = var←15408;
};
{
word pd54;
pd54 = (* (( (ptr) (* (( (ptr) gf←0473)+152)/* var←14672 */ ))+8) );
(void) ( *( (funcPtr) ((* (ptr) pd54 ))))((word) (( (bytePtr) lf←0562)+16)/* var←0203 */ , (* (( (ptr) gf←0473)+8)/* logFileHandle←1654 */ ), var←0511, pd54);
};
};
var←15440 = (* (BIT128Ptr) (( (ptr) lf←0562)+4)/* var←0203 */ );
};
(* (BIT96Ptr) (( (ptr) gf←0473)+58) ) = (* (BIT96Ptr) &var←15440 );
XR←AssignRef((word) (( (bytePtr) gf←0473)+244), var←15440.f3);
};
SOURCEPOP(8472, 107, 8406, 557);
SOURCE(8581, 43);
(* (( (ptr) gf←0473)+68) ) = (* (( (ptr) gf←0473)+58) );
SOURCEPOP(8581, 43, 8406, 557);
SOURCE(8626, 28);
(* (( (ptr) gf←0473)+64) ) = 0;
SOURCEPOP(8626, 28, 8406, 557);
SOURCE(8656, 70);
{
word var←15456;
word p←12370;
BIT64 pr←12386;
SOURCE(1172, 138);
SOURCEPOP(1172, 138, 8656, 70);
SOURCE(1172, 138);
pr←12386 = (* (BIT64Ptr) (( (ptr) gf←0473)+59) );
SOURCEPOP(1172, 138, 8656, 70);
SOURCE(1241, 25);
p←12370 = IOP2( + , pr←12386.f0, pr←12386.f1);
SOURCEPOP(1241, 25, 8656, 70);
SOURCE(1268, 42);
if ((p←12370 == (* (( (ptr) gf←0473)+9)/* logFileSize←1668 */ ))) {
var←15456 = 0;
}
else {
var←15456 = p←12370;
};
goto lab←100057;
SOURCEPOP(1268, 42, 8656, 70);
lab←100057: ;
(* (( (ptr) gf←0473)+70) ) = var←15456;
};
SOURCEPOP(8656, 70, 8406, 557);
SOURCE(8728, 52);
{
register word var←15472 = 1;
if (IOP2( > , var←15472, 4)) {
goto lab←100060;
};
goto lab←100059;
lab←100058: ;
var←15472 = IOP2( + , var←15472, 1);
lab←100059: ;
SOURCE(8761, 19);
(void) ReadAhead←600();
SOURCEPOP(8761, 19, 8728, 52);
if (IOP2( < , var←15472, 4)) {
goto lab←100058;
};
lab←100060: ;
};
SOURCEPOP(8728, 52, 8406, 557);
SOURCE(8790, 127);
{
word var←0512;
SOURCE(8792, 58);
{
word var←15488;
word p←12082;
SOURCE(807, 106);
p←12082 = (* (( (ptr) gf←0473)+68) );
SOURCEPOP(807, 106, 8792, 58);
SOURCE(892, 21);
var←15488 = p←12082;
goto lab←100063;
SOURCEPOP(892, 21, 8792, 58);
lab←100063: ;
var←0512 = (var←0512 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15488 ) >> 7)) << 0);
};
if ( ! (var←0512 & 01)) {
SOURCE(8837, 13);
temp = 1;
lf←0562 = XR←ExtensionFree(lf←0562);
XR←PopHandler();
return(temp);
SOURCEPOP(8837, 13, 8792, 58);
};
SOURCEPOP(8792, 58, 8790, 127);
SOURCE(8852, 63);
{
word var←0513;
{
word var←15504;
word p←12058;
SOURCE(807, 106);
p←12058 = (* (( (ptr) gf←0473)+68) );
SOURCEPOP(807, 106, 8852, 63);
SOURCE(892, 21);
var←15504 = p←12058;
goto lab←100064;
SOURCEPOP(892, 21, 8852, 63);
lab←100064: ;
var←0513 = (var←0513 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15504 ) >> 6 & 01)) << 0);
};
(* (( (ptr) gf←0473)+66) ) = (var←0513 & 01);
};
SOURCEPOP(8852, 63, 8790, 127);
};
SOURCEPOP(8790, 127, 8406, 557);
SOURCE(8920, 27);
(* (( (ptr) gf←0473)+69) ) = 0;
SOURCEPOP(8920, 27, 8406, 557);
SOURCE(8949, 14);
temp55 = 0;
lf←0562 = XR←ExtensionFree(lf←0562);
XR←PopHandler();
return(temp55);
SOURCEPOP(8949, 14, 8406, 557);
};
static void ClosePageStream←570()
{
register ptr gf←0474 = (ptr) &globalframe;
/* ClosePageStream */
SOURCE(8969, 173);
SOURCE(8998, 95);
{
word pd56;
pd56 = (* (( (ptr) (* (( (ptr) gf←0474)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd56 ))))((* (BIT128Ptr) (( (ptr) gf←0474)+58) ), 4, 0, pd56);
};
SOURCEPOP(8998, 95, 8969, 173);
SOURCE(9095, 47);
(* (( (ptr) gf←0474)+58) ) = 0;
(* (( (ptr) gf←0474)+59) ) = 0;
(* (( (ptr) gf←0474)+60) ) = 0;
XR←AssignRef((word) (( (bytePtr) gf←0474)+244), 0);
SOURCEPOP(9095, 47, 8969, 173);
};
static void ReadAhead←600()
{
register ptr gf←0475 = (ptr) &globalframe;
/* ReadAhead */
SOURCE(9148, 271);
SOURCE(9171, 99);
{
BIT64 var←0514;
{
BIT64 var←15520;
BIT64 pr←12178;
word p←12194;
SOURCE(1028, 140);
SOURCEPOP(1028, 140, 9171, 99);
SOURCE(1028, 140);
p←12194 = (* (( (ptr) gf←0475)+70) );
SOURCEPOP(1028, 140, 9171, 99);
SOURCE(1028, 140);
pr←12178.f1 = 1;
pr←12178.f0 = 0;
SOURCEPOP(1028, 140, 9171, 99);
SOURCE(1103, 65);
{
BIT64 var←15536;
var←15536.f0 = p←12194;
{
word x57;
var←15536.f1 = (x57 = IOP2( - , (* (( (ptr) gf←0475)+9)/* logFileSize←1668 */ ), p←12194),
MIN((int)(word), x57, 4));
};
var←15520 = var←15536;
};
goto lab←100065;
SOURCEPOP(1103, 65, 9171, 99);
lab←100065: ;
var←0514 = var←15520;
};
{
word pd58;
pd58 = (* (( (ptr) (* (( (ptr) gf←0475)+152)/* var←14672 */ ))+9) );
(void) ( *( (funcPtr) ((* (ptr) pd58 ))))((* (( (ptr) gf←0475)+8)/* logFileHandle←1654 */ ), var←0514, pd58);
};
};
SOURCEPOP(9171, 99, 9148, 271);
SOURCE(9272, 147);
if (IOP2( < , IOP2( + , (* (( (ptr) gf←0475)+70) ), 4), (* (( (ptr) gf←0475)+9)/* logFileSize←1668 */ ))) {
(* (( (ptr) gf←0475)+70) ) = IOP2( + , (* (( (ptr) gf←0475)+70) ), 4);
}
else {
(* (( (ptr) gf←0475)+70) ) = 0;
};
SOURCEPOP(9272, 147, 9148, 271);
};
static void SavePageStreamPos←630()
{
register ptr gf←0476 = (ptr) &globalframe;
/* SavePageStreamPos */
SOURCE(9425, 226);
SOURCE(9456, 49);
(* (BIT64Ptr) (( (ptr) gf←0476)+62) ) = (* (BIT64Ptr) (( (ptr) gf←0476)+59) );
SOURCEPOP(9456, 49, 9425, 226);
SOURCE(9507, 55);
(* (( (ptr) gf←0476)+65) ) = (* (( (ptr) gf←0476)+64) );
SOURCEPOP(9507, 55, 9425, 226);
SOURCE(9564, 59);
(* (( (ptr) gf←0476)+67) ) = (* (( (ptr) gf←0476)+66) );
SOURCEPOP(9564, 59, 9425, 226);
SOURCE(9625, 26);
(* (( (ptr) gf←0476)+69) ) = 1;
SOURCEPOP(9625, 26, 9425, 226);
};
static void ForgetSavedPageStreamPos←690()
{
register ptr gf←0477 = (ptr) &globalframe;
/* ForgetSavedPageStreamPos */
SOURCE(9792, 195);
SOURCE(9830, 38);
if ((0 == (* (( (ptr) gf←0477)+69) ))) {
SOURCE(9862, 6);
return;
SOURCEPOP(9862, 6, 9830, 38);
};
SOURCEPOP(9830, 38, 9792, 195);
SOURCE(9870, 88);
if ( ! XR←EqualWords((( (ptr) gf←0477)+62), (( (ptr) gf←0477)+59), 2)) {
SOURCE(9928, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0477)+332), 0);
SOURCEPOP(9928, 30, 9870, 88);
};
SOURCEPOP(9870, 88, 9792, 195);
SOURCE(9960, 27);
(* (( (ptr) gf←0477)+69) ) = 0;
SOURCEPOP(9960, 27, 9792, 195);
};
static word AdvancePageStream←720()
{
word temp64;
register word lf←0563;
register ptr gf←0478 = (ptr) &globalframe;
word endOfLog←3592;
lf←0563 = XR←ExtensionAlloc(8);
XR←PushHandler(lf←0563, 0);
/* AdvancePageStream */
SOURCE(9993, 851);
SOURCE(10049, 53);
(* (( (ptr) gf←0478)+64) ) = ((* (( (ptr) gf←0478)+64) ) + 1);
SOURCEPOP(10049, 53, 9993, 851);
SOURCE(10104, 610);
{
word ctmp59;
if (((
ctmp59 = (unsigned) (* (( (ptr) gf←0478)+64) ),
SGNCK(ctmp59)
) == (* (( (ptr) gf←0478)+60) ))) {
SOURCE(10170, 476);
{
word p←4640;
SOURCE(10172, 13);
SOURCEPOP(10172, 13, 10170, 476);
SOURCE(10187, 109);
{
word pd60;
pd60 = (* (( (ptr) (* (( (ptr) gf←0478)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd60 ))))((* (BIT128Ptr) (( (ptr) gf←0478)+58) ), 4, (* (( (ptr) gf←0478)+69) ), pd60);
};
SOURCEPOP(10187, 109, 10170, 476);
SOURCE(10298, 43);
{
word var←15552;
word p←12330;
BIT64 pr←12346;
SOURCE(1172, 138);
SOURCEPOP(1172, 138, 10298, 43);
SOURCE(1172, 138);
pr←12346 = (* (BIT64Ptr) (( (ptr) gf←0478)+59) );
SOURCEPOP(1172, 138, 10298, 43);
SOURCE(1241, 25);
p←12330 = IOP2( + , pr←12346.f0, pr←12346.f1);
SOURCEPOP(1241, 25, 10298, 43);
SOURCE(1268, 42);
if ((p←12330 == (* (( (ptr) gf←0478)+9)/* logFileSize←1668 */ ))) {
var←15552 = 0;
}
else {
var←15552 = p←12330;
};
goto lab←100066;
SOURCEPOP(1268, 42, 10298, 43);
lab←100066: ;
p←4640 = var←15552;
};
SOURCEPOP(10298, 43, 10170, 476);
SOURCE(10343, 73);
if ((p←4640 == 0)) {
SOURCE(10357, 59);
{
word idx61;
(* (( (ptr) gf←0478)+66) ) = (
idx61 = (word) IOP2( - , 1, (* (( (ptr) gf←0478)+66) )),
BCK(idx61, 2)
);
};
SOURCEPOP(10357, 59, 10343, 73);
};
SOURCEPOP(10343, 73, 10170, 476);
SOURCE(10418, 106);
{
BIT128 var←15600;
{
/* declaration of var←0225 skipped */
{
BIT64 var←0515;
{
BIT64 var←15568;
BIT64 pr←12154;
SOURCE(1028, 140);
SOURCEPOP(1028, 140, 10418, 106);
SOURCE(1028, 140);
pr←12154.f1 = 1;
pr←12154.f0 = 0;
SOURCEPOP(1028, 140, 10418, 106);
SOURCE(1103, 65);
{
BIT64 var←15584;
var←15584.f0 = p←4640;
{
/*1*/ word x62;
/*1*/ var←15584.f1 = (x62 = IOP2( - , (* (( (ptr) gf←0478)+9)/* logFileSize←1668 */ ), p←4640),
/*1*/ MIN((int)(word), x62, 4));
/*1*/ };
var←15568 = var←15584;
};
goto lab←100067;
SOURCEPOP(1103, 65, 10418, 106);
lab←100067: ;
var←0515 = var←15568;
};
{
word pd63;
pd63 = (* (( (ptr) (* (( (ptr) gf←0478)+152)/* var←14672 */ ))+8) );
(void) ( *( (funcPtr) ((* (ptr) pd63 ))))((word) (( (bytePtr) lf←0563)+16)/* var←0225 */ , (* (( (ptr) gf←0478)+8)/* logFileHandle←1654 */ ), var←0515, pd63);
};
};
var←15600 = (* (BIT128Ptr) (( (ptr) lf←0563)+4)/* var←0225 */ );
};
(* (BIT96Ptr) (( (ptr) gf←0478)+58) ) = (* (BIT96Ptr) &var←15600 );
XR←AssignRef((word) (( (bytePtr) gf←0478)+244), var←15600.f3);
};
SOURCEPOP(10418, 106, 10170, 476);
SOURCE(10526, 43);
(* (( (ptr) gf←0478)+68) ) = (* (( (ptr) gf←0478)+58) );
SOURCEPOP(10526, 43, 10170, 476);
SOURCE(10571, 28);
(* (( (ptr) gf←0478)+64) ) = 0;
SOURCEPOP(10571, 28, 10170, 476);
SOURCE(10601, 43);
if ((0 == (* (( (ptr) gf←0478)+69) ))) {
SOURCE(10633, 11);
(void) ReadAhead←600();
SOURCEPOP(10633, 11, 10601, 43);
};
SOURCEPOP(10601, 43, 10170, 476);
};
SOURCEPOP(10170, 476, 10104, 610);
}
else {
SOURCE(10653, 61);
(* (( (ptr) gf←0478)+68) ) = IOP2( + , (* (( (ptr) gf←0478)+68) ), (* (ptr) (* (( (ptr) (* (( (ptr) gf←0478)+153)/* var←14704 */ ))+5) ) ));
SOURCEPOP(10653, 61, 10104, 610);
};
};
SOURCEPOP(10104, 610, 9993, 851);
SOURCE(10724, 120);
SOURCE(10725, 117);
{
word var←0519;
word var←0520;
{
word var←15632;
word p←12034;
SOURCE(807, 106);
p←12034 = (* (( (ptr) gf←0478)+68) );
SOURCEPOP(807, 106, 10725, 117);
SOURCE(892, 21);
var←15632 = p←12034;
goto lab←100069;
SOURCEPOP(892, 21, 10725, 117);
lab←100069: ;
var←0520 = (var←0520 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15632 ) >> 7)) << 0);
};
if ( ! (var←0520 & 01)) {
var←0519 = 1;
}
else {
{
word var←0518;
{
word var←0517;
{
word var←0516;
{
word var←15616;
word p←12010;
SOURCE(807, 106);
p←12010 = (* (( (ptr) gf←0478)+68) );
SOURCEPOP(807, 106, 10725, 117);
SOURCE(892, 21);
var←15616 = p←12010;
goto lab←100068;
SOURCEPOP(892, 21, 10725, 117);
lab←100068: ;
var←0516 = (var←0516 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15616 ) >> 6 & 01)) << 0);
};
var←0517 = (var←0516 & 01);
};
var←0518 = (var←0518 & 4294967294) | ((01 & ((* (( (ptr) gf←0478)+66) ) != var←0517)) << 0);
};
var←0519 = (var←0518 & 01);
};
};
temp64 = var←0519;
lf←0563 = XR←ExtensionFree(lf←0563);
XR←PopHandler();
return(temp64);
};
SOURCEPOP(10725, 117, 10724, 120);
SOURCEPOP(10724, 120, 9993, 851);
};
static void SetPageStreamPosFromSavedPos←750()
{
register word lf←0564;
register ptr gf←0479 = (ptr) &globalframe;
lf←0564 = XR←ExtensionAlloc(8);
XR←PushHandler(lf←0564, 0);
/* SetPageStreamPosFromSavedPos */
SOURCE(10851, 624);
SOURCE(10893, 62);
if ((0 == (* (( (ptr) gf←0479)+69) ))) {
SOURCE(10925, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0479)+332), 0);
SOURCEPOP(10925, 30, 10893, 62);
};
SOURCEPOP(10893, 62, 10851, 624);
SOURCE(10957, 322);
if ( ! XR←EqualWords((( (ptr) gf←0479)+59), (( (ptr) gf←0479)+62), 2)) {
SOURCE(11017, 93);
{
word pd65;
pd65 = (* (( (ptr) (* (( (ptr) gf←0479)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd65 ))))((* (BIT128Ptr) (( (ptr) gf←0479)+58) ), 4, 1, pd65);
};
SOURCEPOP(11017, 93, 10957, 322);
SOURCE(11112, 106);
{
BIT128 var←15648;
{
/* declaration of var←0234 skipped */
{
word pd66;
pd66 = (* (( (ptr) (* (( (ptr) gf←0479)+152)/* var←14672 */ ))+8) );
(void) ( *( (funcPtr) ((* (ptr) pd66 ))))((word) (( (bytePtr) lf←0564)+16)/* var←0234 */ , (* (( (ptr) gf←0479)+8)/* logFileHandle←1654 */ ), (* (BIT64Ptr) (( (ptr) gf←0479)+62) ), pd66);
};
var←15648 = (* (BIT128Ptr) (( (ptr) lf←0564)+4)/* var←0234 */ );
};
(* (BIT96Ptr) (( (ptr) gf←0479)+58) ) = (* (BIT96Ptr) &var←15648 );
XR←AssignRef((word) (( (bytePtr) gf←0479)+244), var←15648.f3);
};
SOURCEPOP(11112, 106, 10957, 322);
SOURCE(11220, 59);
(* (( (ptr) gf←0479)+66) ) = (* (( (ptr) gf←0479)+67) );
SOURCEPOP(11220, 59, 10957, 322);
};
SOURCEPOP(10957, 322, 10851, 624);
SOURCE(11284, 55);
(* (( (ptr) gf←0479)+64) ) = (* (( (ptr) gf←0479)+65) );
SOURCEPOP(11284, 55, 10851, 624);
SOURCE(11341, 134);
{
word var←0521;
{
word var←15664;
word pages←13102;
word deviceCharacteristics←13116;
SOURCE(628, 0);
pages←13102 = (* (( (ptr) gf←0479)+64) );
SOURCEPOP(628, 0, 11341, 134);
SOURCE(628, 0);
deviceCharacteristics←13116 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0479)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(628, 0, 11341, 134);
{
word var←15680;
word count←13140;
count←13140 = (* (( (ptr) deviceCharacteristics←13116)+2) );
{
word idx67;
if (IOP2( >= , count←13140, 0)) {
var←15680 = (word) XRM←BITLSHIFT(pages←13102, BCK(count←13140, 2147483648));
}
else {
var←15680 = (word) XRM←BITRSHIFT(pages←13102, (
idx67 = (word) IOP1( - , count←13140),
BCK(idx67, 2147483648)
));
};
};
goto lab←100070;
lab←100070: ;
var←15664 = var←15680;
};
goto lab←100071;
lab←100071: ;
var←0521 = var←15664;
};
(* (( (ptr) gf←0479)+68) ) = IOP2( + , (* (( (ptr) gf←0479)+58) ), var←0521);
};
SOURCEPOP(11341, 134, 10851, 624);
XR←PopHandler();
lf←0564 = XR←ExtensionFree(lf←0564);
};
static void OpenRecordStreamFromWord←780(formal←0243, firstWord←3652)
word formal←0243;
BIT96 firstWord←3652;
{
register ptr gf←0480 = (ptr) &globalframe;
word notStartOfRecord←3674;
BIT96 currentRecord←3688;
/* OpenRecordStreamFromWord */
SOURCE(11569, 286);
SOURCE(11693, 118);
notStartOfRecord←3674 = (word) OpenRecordStream←840(firstWord←3652, firstWord←3652);
SOURCEPOP(11693, 118, 11569, 286);
SOURCE(11813, 42);
(* (ptr) (word) formal←0243 ) = (word) notStartOfRecord←3674;
(* (BIT96Ptr) (( (ptr) (word) formal←0243) + 1) ) = (* (BIT96Ptr) (( (ptr) gf←0480)+71)/* recordStream←2256 */ );
return;
SOURCEPOP(11813, 42, 11569, 286);
};
static void OpenRecordStreamFromCheckpoint←810(formal←0260, checkpointWord←3718, checkpointRecord←3732, firstRecord←3746)
word formal←0260;
BIT96 checkpointWord←3718;
BIT96 checkpointRecord←3732;
BIT96 firstRecord←3746;
{
register word lf←0565;
register ptr gf←0481 = (ptr) &globalframe;
word notStartOfRecord←3768;
BIT96 currentRecord←3782;
lf←0565 = XR←ExtensionAlloc(7);
XR←PushHandler(lf←0565, 0);
/* OpenRecordStreamFromCheckpoint */
SOURCE(11861, 929);
SOURCE(12046, 744);
SOURCE(12048, 42);
{
BIT96 offsetFromCheckpoint←4662;
BIT96 firstWord←4676;
SOURCE(12048, 42);
SOURCEPOP(12048, 42, 12048, 42);
SOURCE(12048, 42);
SOURCEPOP(12048, 42, 12048, 42);
SOURCE(12100, 97);
SOURCE(12102, 93);
{
word pd68;
pd68 = (* (( (ptr) (* (( (ptr) gf←0481)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd68 ))))(checkpointRecord←3732, firstRecord←3746, pd68) == 0)) {
SOURCE(12167, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0481)+328), 0);
SOURCEPOP(12167, 28, 12102, 93);
};
};
SOURCEPOP(12102, 93, 12100, 97);
SOURCEPOP(12100, 97, 12048, 42);
SOURCE(12200, 126);
{
BIT96 var←15696;
SOURCE(671, 0);
switch (XR←PushHandler(lf←0565, &descXenablex100074)) {
case 0: {
/* declaration of var←0257 skipped */
{
word pd69;
pd69 = (* (( (ptr) (* (( (ptr) gf←0481)+154)/* var←14720 */ ))+11) );
(void) ( *( (funcPtr) ((* (ptr) pd69 ))))((word) (( (bytePtr) lf←0565)+16)/* var←0257 */ , checkpointRecord←3732, firstRecord←3746, pd69);
};
var←15696 = (* (BIT96Ptr) (( (ptr) lf←0565)+4)/* var←0257 */ );
};
XR←PopHandler();
goto lab←100076;
XR←PopHandler(); break;
case 1: XR←PopHandler(); goto L100073;
default: XR←RaiseAbstractionFault();
};
SOURCEPOP(671, 0, 12200, 126);
lab←100076: ;
offsetFromCheckpoint←4662 = var←15696;
};
SOURCEPOP(12200, 126, 12048, 42);
SOURCE(12342, 72);
{
word pd70;
pd70 = (* (( (ptr) (* (( (ptr) gf←0481)+154)/* var←14720 */ ))+18) );
if (((word) ( *( (funcPtr) ((* (ptr) pd70 ))))(offsetFromCheckpoint←4662, (* (BIT96Ptr) (( (ptr) gf←0481)+10)/* logFileLength←1682 */ ), pd70) != 0)) {
SOURCE(12414, 13);
goto L100073;
SOURCEPOP(12414, 13, 12342, 72);
};
};
SOURCEPOP(12342, 72, 12048, 42);
SOURCE(12429, 81);
{
/* declaration of var←0258 skipped */
{
word pd71;
pd71 = (* (( (ptr) (* (( (ptr) gf←0481)+154)/* var←14720 */ ))+11) );
(void) ( *( (funcPtr) ((* (ptr) pd71 ))))((word) (( (bytePtr) lf←0565)+16)/* var←0258 */ , checkpointWord←3718, offsetFromCheckpoint←4662, pd71);
};
firstWord←4676 = (* (BIT96Ptr) (( (ptr) lf←0565)+4)/* var←0258 */ );
};
SOURCEPOP(12429, 81, 12048, 42);
SOURCE(12512, 103);
if ((firstWord←4676.f0 == 0)) {
SOURCE(12546, 69);
{
/* declaration of var←0259 skipped */
{
word pd72;
pd72 = (* (( (ptr) (* (( (ptr) gf←0481)+154)/* var←14720 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd72 ))))((word) (( (bytePtr) lf←0565)+16)/* var←0259 */ , firstWord←4676, (* (BIT96Ptr) (( (ptr) gf←0481)+10)/* logFileLength←1682 */ ), pd72);
};
firstWord←4676 = (* (BIT96Ptr) (( (ptr) lf←0565)+4)/* var←0259 */ );
};
SOURCEPOP(12546, 69, 12512, 103);
};
SOURCEPOP(12512, 103, 12048, 42);
SOURCE(12617, 83);
notStartOfRecord←3768 = (word) OpenRecordStream←840(firstWord←4676, firstRecord←3746);
SOURCEPOP(12617, 83, 12048, 42);
SOURCE(12702, 38);
(* (ptr) (word) formal←0260 ) = (word) notStartOfRecord←3768;
(* (BIT96Ptr) (( (ptr) (word) formal←0260) + 1) ) = firstRecord←3746;
XR←PopHandler();
goto lab←0215;
SOURCEPOP(12702, 38, 12048, 42);
};
SOURCEPOP(12048, 42, 12046, 744);
goto lab←100072;
L100073: ;
SOURCE(12760, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0481)+328), 0);
SOURCEPOP(12760, 28, 12046, 744);
goto lab←100072;
lab←100072: ;
SOURCEPOP(12046, 744, 11861, 929);
XR←PopHandler();
lab←0215: ;
lf←0565 = XR←ExtensionFree(lf←0565);
};
static void enable←100074(formal←0256, formal←200004, formal←200005, formal←200006, formal←200007)
word formal←0256;
word formal←200004;
word formal←200005;
word formal←200006;
word formal←200007;
{
register ptr gf←0482 = (ptr) &globalframe;
if ((formal←200005 == (* (( (ptr) (* (( (ptr) gf←0482)+156)/* var←15280 */ ))+11) ))) {
SOURCE(12326, 14);
(* (ptr) (word) formal←0256 ) = (word) 2;
(* (( (ptr) (word) formal←0256) + 1) ) = (word) 1;
return;
};
(* (ptr) (word) formal←0256 ) = (word) 0;
(* (( (ptr) (word) formal←0256) + 1) ) = (word) 0;
return;
};
static word OpenRecordStream←840(firstWord←3812, firstRecord←3826)
BIT96 firstWord←3812;
BIT96 firstRecord←3826;
{
word temp80;
register word lf←0566;
register ptr gf←0483 = (ptr) &globalframe;
word notStartOfRecord←3848;
lf←0566 = XR←ExtensionAlloc(13);
XR←PushHandler(lf←0566, 0);
/* OpenRecordStream */
SOURCE(12794, 543);
SOURCE(12899, 438);
SOURCE(12901, 13);
{
word p←4698;
word w←4712;
word var←0523;
SOURCE(12901, 13);
SOURCEPOP(12901, 13, 12901, 13);
SOURCE(12916, 11);
SOURCEPOP(12916, 11, 12901, 13);
SOURCE(12929, 95);
{
BIT64 var←15744;
{
BIT64 var←15712;
BIT96 words←12988;
word deviceCharacteristics←13002;
BIT96 q←10362;
BIT96 r←10378;
SOURCE(1376, 15);
words←12988 = firstWord←3812;
SOURCEPOP(1376, 15, 12929, 95);
SOURCE(1376, 15);
deviceCharacteristics←13002 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0483)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(1376, 15, 12929, 95);
{
BIT192 var←15728;
{
/* declaration of var←0273 skipped */
{
BIT96 var←0522;
{
/* declaration of var←0274 skipped */
{
word pd73;
pd73 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd73 ))))((word) (( (bytePtr) lf←0566)+40)/* var←0274 */ , (* (ptr) deviceCharacteristics←13002 ), pd73);
};
var←0522 = (* (BIT96Ptr) (( (ptr) lf←0566)+10)/* var←0274 */ );
};
{
word pd74;
pd74 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+14) );
(void) ( *( (funcPtr) ((* (ptr) pd74 ))))((word) (( (bytePtr) lf←0566)+16)/* var←0273 */ , words←12988, var←0522, pd74);
};
};
var←15728 = (* (BIT192Ptr) (( (ptr) lf←0566)+4)/* var←0273 */ );
};
r←10378 = (* (BIT96Ptr) (( (ptr) &var←15728)+3) );
q←10362 = (* (BIT96Ptr) &var←15728 );
};
{
word pd75;
word pd76;
pd75 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+9) );
(* (ptr) (word) &var←15712 ) = (word) ( *( (funcPtr) ((* (ptr) pd75 ))))(q←10362, pd75);
pd76 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+9) );
(* (( (ptr) (word) &var←15712) + 1) ) = (word) ( *( (funcPtr) ((* (ptr) pd76 ))))(r←10378, pd76);
};
goto lab←100079;
lab←100079: ;
var←15744 = var←15712;
};
w←4712 = var←15744.f1;
p←4698 = var←15744.f0;
};
SOURCEPOP(12929, 95, 12901, 13);
SOURCE(13026, 110);
{
word var←15760;
BIT96 r←12884;
word wordsPerPage←12898;
SOURCE(1461, 0);
r←12884 = firstRecord←3826;
SOURCEPOP(1461, 0, 13026, 110);
SOURCE(1461, 0);
wordsPerPage←12898 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0483)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(1461, 0, 13026, 110);
{
/* declaration of var←0278 skipped */
{
BIT96 var←0524;
{
/* declaration of var←0279 skipped */
{
word pd77;
pd77 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd77 ))))((word) (( (bytePtr) lf←0566)+28)/* var←0279 */ , wordsPerPage←12898, pd77);
};
var←0524 = (* (BIT96Ptr) (( (ptr) lf←0566)+7)/* var←0279 */ );
};
{
word pd78;
pd78 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+13) );
(void) ( *( (funcPtr) ((* (ptr) pd78 ))))((word) (( (bytePtr) lf←0566)+16)/* var←0278 */ , r←12884, var←0524, pd78);
};
};
{
word pd79;
pd79 = (* (( (ptr) (* (( (ptr) gf←0483)+154)/* var←14720 */ ))+8) );
var←15760 = (word) ( *( (funcPtr) ((* (ptr) pd79 ))))((* (BIT96Ptr) ((( (ptr) lf←0566)+4)/* var←0278 */ ) ), pd79);
};
};
goto lab←100080;
lab←100080: ;
var←0523 = var←15760;
};
if ((var←0523 != w←4712)) {
SOURCE(13108, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0483)+328), 0);
SOURCEPOP(13108, 28, 13026, 110);
};
SOURCEPOP(13026, 110, 12901, 13);
SOURCE(13138, 35);
if ((0 != (word) OpenPageStream←540(p←4698))) {
SOURCE(13173, 16);
goto lab←100078;
SOURCEPOP(13173, 16, 13138, 35);
};
SOURCEPOP(13138, 35, 12901, 13);
SOURCE(13191, 19);
(void) SavePageStreamPos←630();
SOURCEPOP(13191, 19, 12901, 13);
SOURCE(13212, 32);
(* (BIT96Ptr) (( (ptr) gf←0483)+71)/* recordStream←2256 */ ) = firstRecord←3826;
SOURCEPOP(13212, 32, 12901, 13);
SOURCE(13246, 49);
temp80 = (word) VerifyCurrentRecordID←930();
lf←0566 = XR←ExtensionFree(lf←0566);
XR←PopHandler();
return(temp80);
SOURCEPOP(13246, 49, 12901, 13);
};
SOURCEPOP(12901, 13, 12899, 438);
goto lab←100077;
lab←100078: ;
SOURCE(13318, 17);
(void) XR←RaiseError((word) (( (bytePtr) gf←0483)+336), 0);
SOURCEPOP(13318, 17, 12899, 438);
goto lab←100077;
lab←100077: ;
SOURCEPOP(12899, 438, 12794, 543);
};
static void CurrentWordNumber←870(formal←0294)
word formal←0294;
{
register word lf←0567;
register ptr gf←0484 = (ptr) &globalframe;
BIT96 w←3886;
lf←0567 = XR←ExtensionAlloc(16);
XR←PushHandler(lf←0567, 0);
/* CurrentWordNumber */
SOURCE(13376, 258);
SOURCE(13439, 195);
SOURCE(13440, 194);
{
/* declaration of var←0281 skipped */
{
BIT96 var←0527;
BIT96 var←0530;
{
BIT96 var←15776;
word pages←13486;
word deviceCharacteristics←13500;
SOURCE(859, 0);
{
word ctmp81;
pages←13486 = IOP2( + , (* (( (ptr) gf←0484)+59) ), (
ctmp81 = (unsigned) (* (( (ptr) gf←0484)+64) ),
SGNCK(ctmp81)
));
};
SOURCEPOP(859, 0, 13440, 194);
SOURCE(859, 0);
deviceCharacteristics←13500 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0484)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(859, 0, 13440, 194);
{
/* declaration of var←0285 skipped */
{
BIT96 var←0525;
BIT96 var←0526;
{
/* declaration of var←0286 skipped */
{
word pd82;
pd82 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd82 ))))((word) (( (bytePtr) lf←0567)+40)/* var←0286 */ , pages←13486, pd82);
};
var←0525 = (* (BIT96Ptr) (( (ptr) lf←0567)+10)/* var←0286 */ );
};
{
/* declaration of var←0287 skipped */
{
word pd83;
word ctmp84;
pd83 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd83 ))))((word) (( (bytePtr) lf←0567)+40)/* var←0287 */ , (
/*1*/ ctmp84 = (unsigned) (* (ptr) deviceCharacteristics←13500 ),
/*1*/ SGNCK(ctmp84)
/*1*/ ), pd83);
};
var←0526 = (* (BIT96Ptr) (( (ptr) lf←0567)+10)/* var←0287 */ );
};
{
word pd85;
pd85 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+15) );
(void) ( *( (funcPtr) ((* (ptr) pd85 ))))((word) (( (bytePtr) lf←0567)+28)/* var←0285 */ , var←0525, var←0526, pd85);
};
};
var←15776 = (* (BIT96Ptr) (( (ptr) lf←0567)+7)/* var←0285 */ );
};
goto lab←100081;
lab←100081: ;
var←0527 = var←15776;
};
{
/* declaration of var←0288 skipped */
{
word var←0528;
{
word var←15792;
BIT96 r←12846;
word wordsPerPage←12860;
SOURCE(1461, 0);
r←12846 = (* (BIT96Ptr) (( (ptr) gf←0484)+71)/* recordStream←2256 */ );
SOURCEPOP(1461, 0, 13440, 194);
SOURCE(1461, 0);
wordsPerPage←12860 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0484)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(1461, 0, 13440, 194);
{
/* declaration of var←0292 skipped */
{
BIT96 var←0529;
{
/* declaration of var←0293 skipped */
{
/*1*/ word pd86;
/*1*/ pd86 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+6) );
/*1*/ (void) ( *( (funcPtr) ((* (ptr) pd86 ))))((word) (( (bytePtr) lf←0567)+52)/* var←0293 */ , wordsPerPage←12860, pd86);
/*1*/ };
var←0529 = (* (BIT96Ptr) (( (ptr) lf←0567)+13)/* var←0293 */ );
};
{
word pd87;
pd87 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+13) );
(void) ( *( (funcPtr) ((* (ptr) pd87 ))))((word) (( (bytePtr) lf←0567)+40)/* var←0292 */ , r←12846, var←0529, pd87);
};
};
{
word pd88;
pd88 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+8) );
var←15792 = (word) ( *( (funcPtr) ((* (ptr) pd88 ))))((* (BIT96Ptr) ((( (ptr) lf←0567)+10)/* var←0292 */ ) ), pd88);
};
};
goto lab←100082;
lab←100082: ;
var←0528 = var←15792;
};
{
word pd89;
pd89 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd89 ))))((word) (( (bytePtr) lf←0567)+28)/* var←0288 */ , var←0528, pd89);
};
};
var←0530 = (* (BIT96Ptr) (( (ptr) lf←0567)+7)/* var←0288 */ );
};
{
word pd90;
pd90 = (* (( (ptr) (* (( (ptr) gf←0484)+154)/* var←14720 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd90 ))))((word) (( (bytePtr) lf←0567)+16)/* var←0281 */ , var←0527, var←0530, pd90);
};
};
w←3886 = (* (BIT96Ptr) (( (ptr) lf←0567)+4)/* var←0281 */ );
};
SOURCEPOP(13440, 194, 13439, 195);
SOURCEPOP(13439, 195, 13376, 258);
SOURCE(13376, 258);
(* (BIT96Ptr) formal←0294 ) = w←3886;
XR←PopHandler();
goto lab←0216;
SOURCEPOP(13376, 258, 13376, 258);
XR←PopHandler();
lab←0216: ;
lf←0567 = XR←ExtensionFree(lf←0567);
};
static void CloseRecordStream←900()
{
/* CloseRecordStream */
SOURCE(13641, 55);
SOURCE(13679, 17);
(void) ClosePageStream←570();
SOURCEPOP(13679, 17, 13641, 55);
};
static word VerifyCurrentRecordID←930()
{
word temp94;
word temp95;
register word lf←0568;
register ptr gf←0485 = (ptr) &globalframe;
word notStartOfRecord←3924;
word wordInPage←4734;
lf←0568 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0568, 0);
/* VerifyCurrentRecordID */
SOURCE(13702, 385);
SOURCE(13770, 96);
{
word var←15808;
BIT96 r←12808;
word wordsPerPage←12822;
SOURCE(1461, 0);
r←12808 = (* (BIT96Ptr) (( (ptr) gf←0485)+71)/* recordStream←2256 */ );
SOURCEPOP(1461, 0, 13770, 96);
SOURCE(1461, 0);
wordsPerPage←12822 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0485)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(1461, 0, 13770, 96);
{
/* declaration of var←0300 skipped */
/* declaration of var←0301 skipped */
{
word pd91;
pd91 = (* (( (ptr) (* (( (ptr) gf←0485)+154)/* var←14720 */ ))+13) );
{
word pd92;
pd92 = (* (( (ptr) (* (( (ptr) gf←0485)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd92 ))))((word) (( (bytePtr) lf←0568)+28)/* var←0301 */ , wordsPerPage←12822, pd92);
};
(void) ( *( (funcPtr) ((* (ptr) pd91 ))))((word) (( (bytePtr) lf←0568)+16)/* var←0300 */ , r←12808, (* (BIT96Ptr) (( (ptr) lf←0568)+7)/* var←0301 */ ), pd91);
};
{
word pd93;
pd93 = (* (( (ptr) (* (( (ptr) gf←0485)+154)/* var←14720 */ ))+8) );
var←15808 = (word) ( *( (funcPtr) ((* (ptr) pd93 ))))((* (BIT96Ptr) ((( (ptr) lf←0568)+4)/* var←0300 */ ) ), pd93);
};
};
goto lab←100083;
lab←100083: ;
wordInPage←4734 = var←15808;
};
SOURCEPOP(13770, 96, 13702, 385);
SOURCE(13876, 136);
{
word w←4756 = 0;
SOURCE(13878, 15);
SOURCEPOP(13878, 15, 13876, 136);
SOURCE(13895, 68);
lab←100084: ;
if ((w←4756 < wordInPage←4734)) {
}
else {
goto lab←100086;
};
SOURCE(13920, 43);
{
word var←0532;
{
word var←0531;
{
word var←15824;
word p←11986;
SOURCE(807, 106);
p←11986 = IOP2( + , (* (( (ptr) gf←0485)+68) ), w←4756);
SOURCEPOP(807, 106, 13920, 43);
SOURCE(892, 21);
var←15824 = p←11986;
goto lab←100089;
SOURCEPOP(892, 21, 13920, 43);
lab←100089: ;
var←0531 = (* (( (ptr) var←15824)+1) );
};
var←0532 = IOP2( + , (
SGNCK( (unsigned) w←4756)
), var←0531);
};
w←4756 = var←0532;
};
SOURCEPOP(13920, 43, 13895, 68);
goto lab←100084;
lab←100086: ;
SOURCEPOP(13895, 68, 13876, 136);
SOURCE(13974, 36);
if ((w←4756 > wordInPage←4734)) {
SOURCE(13997, 13);
temp94 = 1;
lf←0568 = XR←ExtensionFree(lf←0568);
XR←PopHandler();
return(temp94);
SOURCEPOP(13997, 13, 13974, 36);
};
SOURCEPOP(13974, 36, 13876, 136);
};
SOURCEPOP(13876, 136, 13702, 385);
SOURCE(14023, 64);
SOURCE(14024, 61);
{
word var←0534;
{
word var←0533;
{
word var←15840;
word p←11962;
SOURCE(807, 106);
p←11962 = IOP2( + , (* (( (ptr) gf←0485)+68) ), wordInPage←4734);
SOURCEPOP(807, 106, 14024, 61);
SOURCE(892, 21);
var←15840 = p←11962;
goto lab←100090;
SOURCEPOP(892, 21, 14024, 61);
lab←100090: ;
var←0533 = (var←0533 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15840 ) >> 4 & 01)) << 0);
};
var←0534 = (var←0533 & 01);
};
temp95 = var←0534;
lf←0568 = XR←ExtensionFree(lf←0568);
XR←PopHandler();
return(temp95);
};
SOURCEPOP(14024, 61, 14023, 64);
SOURCEPOP(14023, 64, 13702, 385);
};
static word CheckCurrentRecord←960()
{
word temp105;
word temp106;
register word lf←0569;
register ptr gf←0486 = (ptr) &globalframe;
word truncated←3954;
lf←0569 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0569, 0);
/* CheckCurrentRecord */
SOURCE(14094, 1145);
SOURCE(14165, 1074);
SOURCE(14167, 96);
{
word wordInPage←4778;
word var←15872;
word p←11938;
word var←16000;
SOURCE(14167, 96);
{
word var←15856;
BIT96 r←12770;
word wordsPerPage←12784;
SOURCE(1461, 0);
r←12770 = (* (BIT96Ptr) (( (ptr) gf←0486)+71)/* recordStream←2256 */ );
SOURCEPOP(1461, 0, 14167, 96);
SOURCE(1461, 0);
wordsPerPage←12784 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0486)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(1461, 0, 14167, 96);
{
/* declaration of var←0312 skipped */
/* declaration of var←0313 skipped */
{
word pd96;
pd96 = (* (( (ptr) (* (( (ptr) gf←0486)+154)/* var←14720 */ ))+13) );
{
word pd97;
pd97 = (* (( (ptr) (* (( (ptr) gf←0486)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd97 ))))((word) (( (bytePtr) lf←0569)+28)/* var←0313 */ , wordsPerPage←12784, pd97);
};
(void) ( *( (funcPtr) ((* (ptr) pd96 ))))((word) (( (bytePtr) lf←0569)+16)/* var←0312 */ , r←12770, (* (BIT96Ptr) (( (ptr) lf←0569)+7)/* var←0313 */ ), pd96);
};
{
word pd98;
pd98 = (* (( (ptr) (* (( (ptr) gf←0486)+154)/* var←14720 */ ))+8) );
var←15856 = (word) ( *( (funcPtr) ((* (ptr) pd98 ))))((* (BIT96Ptr) ((( (ptr) lf←0569)+4)/* var←0312 */ ) ), pd98);
};
};
goto lab←100094;
lab←100094: ;
wordInPage←4778 = var←15856;
};
SOURCEPOP(14167, 96, 14167, 96);
SOURCE(14265, 79);
if ((0 != (word) VerifyCurrentRecordID←930())) {
SOURCE(14314, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0486)+332), 0);
SOURCEPOP(14314, 30, 14265, 79);
};
SOURCEPOP(14265, 79, 14167, 96);
SOURCE(14346, 663);
{
word x99;
SOURCE(807, 106);
p←11938 = IOP2( + , (* (( (ptr) gf←0486)+68) ), wordInPage←4778);
SOURCEPOP(807, 106, 14346, 663);
SOURCE(892, 21);
var←15872 = p←11938;
goto lab←100095;
SOURCEPOP(892, 21, 14346, 663);
lab←100095: ;
x99 = (word) ( (unsigned) (* (bytePtr) var←15872 ) >> 5 & 01);
if (x99) {
{
word var←0536;
word var←15968;
SOURCE(14410, 90);
{
word ctmp100;
{
word var←0535;
{
word var←15888;
word p←11914;
SOURCE(807, 106);
p←11914 = IOP2( + , (* (( (ptr) gf←0486)+68) ), wordInPage←4778);
SOURCEPOP(807, 106, 14410, 90);
SOURCE(892, 21);
var←15888 = p←11914;
goto lab←100096;
SOURCEPOP(892, 21, 14410, 90);
lab←100096: ;
var←0535 = (* (( (ptr) var←15888)+1) );
};
var←0536 = IOP2( + , var←0535, (
SGNCK( (unsigned) wordInPage←4778)
));
};
if ((var←0536 != (
ctmp100 = (unsigned) (* (ptr) (* (( (ptr) (* (( (ptr) gf←0486)+153)/* var←14704 */ ))+5) ) ),
SGNCK(ctmp100)
))) {
SOURCE(14500, 16);
goto lab←100092;
SOURCEPOP(14500, 16, 14410, 90);
};
};
SOURCEPOP(14410, 90, 14346, 663);
SOURCE(14518, 263);
lab←100097: ;
{
word var←0537;
word var←0538;
word var←0539;
SOURCE(14521, 37);
if ((0 != (word) AdvancePageStream←720())) {
SOURCE(14558, 20);
goto lab←100093;
SOURCEPOP(14558, 20, 14521, 37);
};
SOURCEPOP(14521, 37, 14518, 263);
SOURCE(14580, 54);
{
word var←15904;
word p←11890;
SOURCE(807, 106);
p←11890 = (* (( (ptr) gf←0486)+68) );
SOURCEPOP(807, 106, 14580, 54);
SOURCE(892, 21);
var←15904 = p←11890;
goto lab←100102;
SOURCEPOP(892, 21, 14580, 54);
lab←100102: ;
var←0537 = (var←0537 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15904 ) >> 4 & 01)) << 0);
};
if ( ! (var←0537 & 01)) {
SOURCE(14634, 20);
goto lab←100093;
SOURCEPOP(14634, 20, 14580, 54);
};
SOURCEPOP(14580, 54, 14518, 263);
SOURCE(14656, 55);
{
word var←15920;
word p←11866;
SOURCE(807, 106);
p←11866 = (* (( (ptr) gf←0486)+68) );
SOURCEPOP(807, 106, 14656, 55);
SOURCE(892, 21);
var←15920 = p←11866;
goto lab←100103;
SOURCEPOP(892, 21, 14656, 55);
lab←100103: ;
var←0538 = (var←0538 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←15920 ) >> 5 & 01)) << 0);
};
if ( ! (var←0538 & 01)) {
SOURCE(14711, 4);
goto lab←100100;
SOURCEPOP(14711, 4, 14656, 55);
};
SOURCEPOP(14656, 55, 14518, 263);
SOURCE(14717, 64);
{
word ctmp101;
{
word var←15936;
word p←11842;
SOURCE(807, 106);
p←11842 = (* (( (ptr) gf←0486)+68) );
SOURCEPOP(807, 106, 14717, 64);
SOURCE(892, 21);
var←15936 = p←11842;
goto lab←100104;
SOURCEPOP(892, 21, 14717, 64);
lab←100104: ;
var←0539 = (* (( (ptr) var←15936)+1) );
};
if ((var←0539 != (
ctmp101 = (unsigned) (* (ptr) (* (( (ptr) (* (( (ptr) gf←0486)+153)/* var←14704 */ ))+5) ) ),
SGNCK(ctmp101)
))) {
SOURCE(14781, 16);
goto lab←100092;
SOURCEPOP(14781, 16, 14717, 64);
};
};
SOURCEPOP(14717, 64, 14518, 263);
};
goto lab←100097;
lab←100100: ;
SOURCEPOP(14518, 263, 14346, 663);
SOURCE(14808, 76);
{
word tc;
word ctmp102;
{
word var←15952;
word p←11818;
SOURCE(807, 106);
p←11818 = (* (( (ptr) gf←0486)+68) );
SOURCEPOP(807, 106, 14808, 76);
SOURCE(892, 21);
var←15952 = p←11818;
goto lab←100105;
SOURCEPOP(892, 21, 14808, 76);
lab←100105: ;
var←15968 = (* (( (ptr) var←15952)+1) );
};
if (IOP2( < , var←15968, 1)) {
tc = (word) 1;
}
else {
tc = (word) IOP2( > , var←15968, (
ctmp102 = (unsigned) (* (ptr) (* (( (ptr) (* (( (ptr) gf←0486)+153)/* var←14704 */ ))+5) ) ),
SGNCK(ctmp102)
));
};
if (tc) {
SOURCE(14884, 16);
goto lab←100092;
SOURCEPOP(14884, 16, 14808, 76);
};
};
SOURCEPOP(14808, 76, 14346, 663);
};
}
else {
SOURCE(14911, 98);
{
word tc103;
word ctmp104;
{
word var←15984;
word p←11794;
SOURCE(807, 106);
p←11794 = IOP2( + , (* (( (ptr) gf←0486)+68) ), wordInPage←4778);
SOURCEPOP(807, 106, 14911, 98);
SOURCE(892, 21);
var←15984 = p←11794;
goto lab←100106;
SOURCEPOP(892, 21, 14911, 98);
lab←100106: ;
var←16000 = (* (( (ptr) var←15984)+1) );
};
if (IOP2( < , var←16000, 1)) {
tc103 = (word) 1;
}
else {
tc103 = (word) IOP2( > , var←16000, (
ctmp104 = (unsigned) ((* (ptr) (* (( (ptr) (* (( (ptr) gf←0486)+153)/* var←14704 */ ))+5) ) ) - wordInPage←4778),
SGNCK(ctmp104)
));
};
if (tc103) {
SOURCE(15009, 16);
goto lab←100092;
SOURCEPOP(15009, 16, 14911, 98);
};
};
SOURCEPOP(14911, 98, 14346, 663);
};
};
SOURCEPOP(14346, 663, 14167, 96);
SOURCE(15030, 30);
(void) SetPageStreamPosFromSavedPos←750();
SOURCEPOP(15030, 30, 14167, 96);
SOURCE(15062, 14);
temp105 = 0;
lf←0569 = XR←ExtensionFree(lf←0569);
XR←PopHandler();
return(temp105);
SOURCEPOP(15062, 14, 14167, 96);
};
SOURCEPOP(14167, 96, 14165, 1074);
goto lab←100091;
lab←100092: ;
SOURCE(15101, 30);
(void) SetPageStreamPosFromSavedPos←750();
SOURCEPOP(15101, 30, 14165, 1074);
SOURCE(15134, 31);
(void) XR←RaiseError((word) (( (bytePtr) gf←0486)+332), 0);
SOURCEPOP(15134, 31, 14165, 1074);
goto lab←100091;
lab←100093: ;
SOURCE(15189, 30);
(void) SetPageStreamPosFromSavedPos←750();
SOURCEPOP(15189, 30, 14165, 1074);
SOURCE(15222, 14);
temp106 = 1;
lf←0569 = XR←ExtensionFree(lf←0569);
XR←PopHandler();
return(temp106);
SOURCEPOP(15222, 14, 14165, 1074);
goto lab←100091;
lab←100091: ;
SOURCEPOP(14165, 1074, 14094, 1145);
};
static void GetCurrentRecord←990(formal←0351, currentRecord←3984, to←3998)
word formal←0351;
BIT96 currentRecord←3984;
BIT96 to←3998;
{
register word lf←0570;
register ptr gf←0487 = (ptr) &globalframe;
word status←4020;
word wordsRead←4034;
lf←0570 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0570, 0);
/* GetCurrentRecord */
SOURCE(15244, 1727);
SOURCE(15381, 1590);
SOURCE(15383, 96);
{
word wordInPage←4800;
word var←0540;
SOURCE(15383, 96);
{
word var←16016;
BIT96 r←12732;
word wordsPerPage←12746;
SOURCE(1461, 0);
r←12732 = (* (BIT96Ptr) (( (ptr) gf←0487)+71)/* recordStream←2256 */ );
SOURCEPOP(1461, 0, 15383, 96);
SOURCE(1461, 0);
wordsPerPage←12746 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0487)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(1461, 0, 15383, 96);
{
/* declaration of var←0338 skipped */
/* declaration of var←0339 skipped */
{
word pd107;
pd107 = (* (( (ptr) (* (( (ptr) gf←0487)+154)/* var←14720 */ ))+13) );
{
word pd108;
pd108 = (* (( (ptr) (* (( (ptr) gf←0487)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd108 ))))((word) (( (bytePtr) lf←0570)+28)/* var←0339 */ , wordsPerPage←12746, pd108);
};
(void) ( *( (funcPtr) ((* (ptr) pd107 ))))((word) (( (bytePtr) lf←0570)+16)/* var←0338 */ , r←12732, (* (BIT96Ptr) (( (ptr) lf←0570)+7)/* var←0339 */ ), pd107);
};
{
word pd109;
pd109 = (* (( (ptr) (* (( (ptr) gf←0487)+154)/* var←14720 */ ))+8) );
var←16016 = (word) ( *( (funcPtr) ((* (ptr) pd109 ))))((* (BIT96Ptr) ((( (ptr) lf←0570)+4)/* var←0338 */ ) ), pd109);
};
};
goto lab←100110;
lab←100110: ;
wordInPage←4800 = var←16016;
};
SOURCEPOP(15383, 96, 15383, 96);
SOURCE(15481, 13);
wordsRead←4034 = 0;
SOURCEPOP(15481, 13, 15383, 96);
SOURCE(15496, 97);
{
word var←16032;
BIT96 b←12670;
SOURCE(327, 0);
b←12670 = (* (BIT96Ptr) (( (ptr) gf←0487)+71)/* recordStream←2256 */ );
SOURCEPOP(327, 0, 15496, 97);
{
word pd110;
pd110 = (* (( (ptr) (* (( (ptr) gf←0487)+154)/* var←14720 */ ))+18) );
var←16032 = (word) ( *( (funcPtr) ((* (ptr) pd110 ))))(currentRecord←3984, b←12670, pd110);
};
goto lab←100111;
lab←100111: ;
var←0540 = var←16032;
};
if ((var←0540 != 1)) {
SOURCE(15565, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0487)+328), 0);
SOURCEPOP(15565, 28, 15496, 97);
};
SOURCEPOP(15496, 97, 15383, 96);
SOURCE(15595, 1146);
lab←100112: ;
SOURCE(15595, 1146);
{
word wordsThisBlock←4822;
word wordsThisCopy←4836;
word hasContinuation←4850;
word isContinuation←4864;
SOURCE(15598, 39);
SOURCEPOP(15598, 39, 15595, 1146);
SOURCE(15598, 39);
SOURCEPOP(15598, 39, 15595, 1146);
SOURCE(15639, 37);
SOURCEPOP(15639, 37, 15595, 1146);
SOURCE(15639, 37);
SOURCEPOP(15639, 37, 15595, 1146);
SOURCE(15686, 135);
SOURCE(15688, 131);
{
BIT64 var←16064;
{
word var←16048;
word p←11770;
SOURCE(807, 106);
p←11770 = IOP2( + , (* (( (ptr) gf←0487)+68) ), wordInPage←4800);
SOURCEPOP(807, 106, 15688, 131);
SOURCE(892, 21);
var←16048 = p←11770;
goto lab←100117;
SOURCEPOP(892, 21, 15688, 131);
lab←100117: ;
var←16064 = (* (BIT64Ptr) var←16048 );
};
wordsThisBlock←4822 = var←16064.f1;
isContinuation←4864 = ( (unsigned) (* (bytePtr) &var←16064 ) >> 4 & 01);
hasContinuation←4850 = ( (unsigned) (* (bytePtr) &var←16064 ) >> 5 & 01);
};
SOURCEPOP(15688, 131, 15686, 135);
SOURCEPOP(15686, 135, 15595, 1146);
SOURCE(15824, 45);
if ( ( (wordsRead←4034 > 0) ? (0 == isContinuation←4864) : 0 ) ) {
SOURCE(15869, 20);
goto lab←100109;
SOURCEPOP(15869, 20, 15824, 45);
};
SOURCEPOP(15824, 45, 15595, 1146);
SOURCE(15891, 54);
wordsThisBlock←4822 = (wordsThisBlock←4822 - 8);
SOURCEPOP(15891, 54, 15595, 1146);
SOURCE(15947, 46);
wordInPage←4800 = (wordInPage←4800 + 8);
SOURCEPOP(15947, 46, 15595, 1146);
SOURCE(15995, 746);
lab←100118: ;
SOURCE(15998, 46);
{
word x111;
wordsThisCopy←4836 = (x111 = to←3998.f1,
MIN( (unsigned) , x111, wordsThisBlock←4822));
};
SOURCEPOP(15998, 46, 15995, 746);
SOURCE(16046, 142);
if ((to←3998.f0 != 0)) {
SOURCE(16070, 85);
{
word from←12632;
word to←12646;
SOURCE(16070, 85);
from←12632 = IOP2( + , (* (( (ptr) gf←0487)+68) ), wordInPage←4800);
SOURCEPOP(16070, 85, 16070, 85);
SOURCE(16070, 85);
to←12646 = to←3998.f0;
SOURCEPOP(16070, 85, 16070, 85);
(void) XR←MoveWords(to←12646, from←12632, BCK(wordsThisCopy←4836, 2147483648));
};
SOURCEPOP(16070, 85, 16046, 142);
SOURCE(16157, 31);
to←3998.f0 = IOP2( + , to←3998.f0, wordsThisCopy←4836);
SOURCEPOP(16157, 31, 16046, 142);
};
SOURCEPOP(16046, 142, 15995, 746);
SOURCE(16193, 35);
wordsRead←4034 = (wordsRead←4034 + wordsThisCopy←4836);
SOURCEPOP(16193, 35, 15995, 746);
SOURCE(16230, 511);
if ((wordsThisCopy←4836 != to←3998.f1)) {
SOURCE(16266, 35);
to←3998.f1 = (to←3998.f1 - wordsThisCopy←4836);
SOURCEPOP(16266, 35, 16230, 511);
SOURCE(16303, 28);
if ((0 == hasContinuation←4850)) {
SOURCE(16331, 20);
goto lab←100108;
SOURCEPOP(16331, 20, 16303, 28);
};
SOURCEPOP(16303, 28, 16230, 511);
SOURCE(16353, 37);
if ((0 != (word) AdvancePageStream←720())) {
SOURCE(16390, 20);
goto lab←100109;
SOURCEPOP(16390, 20, 16353, 37);
};
SOURCEPOP(16353, 37, 16230, 511);
SOURCE(16412, 14);
wordInPage←4800 = 0;
SOURCEPOP(16412, 14, 16230, 511);
SOURCE(16428, 14);
goto lab←100123;
SOURCEPOP(16428, 14, 16230, 511);
}
else {
SOURCE(16451, 290);
if ((to←3998.f2 != 0)) {
SOURCE(16481, 105);
SOURCE(16483, 13);
to←3998 = (* (BIT96Ptr) to←3998.f2 );
SOURCEPOP(16483, 13, 16481, 105);
SOURCE(16498, 45);
wordsThisBlock←4822 = (wordsThisBlock←4822 - wordsThisCopy←4836);
SOURCEPOP(16498, 45, 16481, 105);
SOURCE(16545, 39);
wordInPage←4800 = (wordInPage←4800 + wordsThisCopy←4836);
SOURCEPOP(16545, 39, 16481, 105);
SOURCEPOP(16481, 105, 16451, 290);
}
else {
SOURCE(16595, 30);
(void) SetPageStreamPosFromSavedPos←750();
SOURCEPOP(16595, 30, 16451, 290);
SOURCE(16627, 114);
(* (ptr) (word) formal←0351 ) = (word) ( ( (0 == hasContinuation←4850) ? (wordsThisBlock←4822 == wordsThisCopy←4836) : 0 ) ? 0 : 1 ) ;
(* (( (ptr) (word) formal←0351) + 1) ) = (word) wordsRead←4034;
XR←PopHandler();
goto lab←0217;
SOURCEPOP(16627, 114, 16451, 290);
};
SOURCEPOP(16451, 290, 16230, 511);
};
SOURCEPOP(16230, 511, 15995, 746);
goto lab←100118;
lab←100123: ;
goto lab←100121;
lab←100121: ;
SOURCEPOP(15995, 746, 15595, 1146);
};
SOURCEPOP(15595, 1146, 15595, 1146);
goto lab←100112;
SOURCEPOP(15595, 1146, 15383, 96);
};
SOURCEPOP(15383, 96, 15381, 1590);
goto lab←100107;
lab←100108: ;
SOURCE(16814, 30);
(void) SetPageStreamPosFromSavedPos←750();
SOURCEPOP(16814, 30, 15381, 1590);
SOURCE(16846, 36);
(* (ptr) (word) formal←0351 ) = (word) 2;
(* (( (ptr) (word) formal←0351) + 1) ) = (word) wordsRead←4034;
XR←PopHandler();
goto lab←0217;
SOURCEPOP(16846, 36, 15381, 1590);
goto lab←100107;
lab←100109: ;
SOURCE(16906, 30);
(void) SetPageStreamPosFromSavedPos←750();
SOURCEPOP(16906, 30, 15381, 1590);
SOURCE(16938, 28);
(void) XR←RaiseError((word) (( (bytePtr) gf←0487)+328), 0);
SOURCEPOP(16938, 28, 15381, 1590);
goto lab←100107;
lab←100107: ;
SOURCEPOP(15381, 1590, 15244, 1727);
XR←PopHandler();
lab←0217: ;
lf←0570 = XR←ExtensionFree(lf←0570);
};
static void GetCurrentPageAndVersion←1020(formal←0354)
word formal←0354;
{
register ptr gf←0488 = (ptr) &globalframe;
/* GetCurrentPageAndVersion */
SOURCE(16975, 144);
/* removed dead decl of 4064 */
/* removed dead decl of 4078 */
SOURCE(17064, 55);
{
word ctmp112;
(* (ptr) (word) formal←0354 ) = (word) IOP2( + , (* (( (ptr) gf←0488)+59) ), (
ctmp112 = (unsigned) (* (( (ptr) gf←0488)+64) ),
SGNCK(ctmp112)
));
(* (( (ptr) (word) formal←0354) + 1) ) = (* (( (ptr) gf←0488)+66) );
};
return;
SOURCEPOP(17064, 55, 16975, 144);
};
static void AdvanceRecordStream←1050(formal←0383)
word formal←0383;
{
register word lf←0571;
register ptr gf←0489 = (ptr) &globalframe;
word endOfLog←4108;
word truncatedRecord←4122;
BIT96 currentRecord←4136;
word wordsInRecord←4886 = 0;
lf←0571 = XR←ExtensionAlloc(10);
XR←PushHandler(lf←0571, 0);
/* AdvanceRecordStream */
SOURCE(17125, 1321);
SOURCE(17240, 27);
SOURCEPOP(17240, 27, 17125, 1321);
SOURCE(17269, 34);
endOfLog←4108 = (
truncatedRecord←4122 = 0
);
SOURCEPOP(17269, 34, 17125, 1321);
SOURCE(17305, 1141);
SOURCE(17326, 96);
{
word wordInPage←4908;
word var←0545;
SOURCE(17326, 96);
{
word var←16080;
BIT96 r←12694;
word wordsPerPage←12708;
SOURCE(1461, 0);
r←12694 = (* (BIT96Ptr) (( (ptr) gf←0489)+71)/* recordStream←2256 */ );
SOURCEPOP(1461, 0, 17326, 96);
SOURCE(1461, 0);
wordsPerPage←12708 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0489)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(1461, 0, 17326, 96);
{
/* declaration of var←0363 skipped */
/* declaration of var←0364 skipped */
{
word pd113;
pd113 = (* (( (ptr) (* (( (ptr) gf←0489)+154)/* var←14720 */ ))+13) );
{
word pd114;
pd114 = (* (( (ptr) (* (( (ptr) gf←0489)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd114 ))))((word) (( (bytePtr) lf←0571)+28)/* var←0364 */ , wordsPerPage←12708, pd114);
};
(void) ( *( (funcPtr) ((* (ptr) pd113 ))))((word) (( (bytePtr) lf←0571)+16)/* var←0363 */ , r←12694, (* (BIT96Ptr) (( (ptr) lf←0571)+7)/* var←0364 */ ), pd113);
};
{
word pd115;
pd115 = (* (( (ptr) (* (( (ptr) gf←0489)+154)/* var←14720 */ ))+8) );
var←16080 = (word) ( *( (funcPtr) ((* (ptr) pd115 ))))((* (BIT96Ptr) ((( (ptr) lf←0571)+4)/* var←0363 */ ) ), pd115);
};
};
goto lab←100126;
lab←100126: ;
wordInPage←4908 = var←16080;
};
SOURCEPOP(17326, 96, 17326, 96);
SOURCE(17424, 26);
(void) ForgetSavedPageStreamPos←690();
SOURCEPOP(17424, 26, 17326, 96);
SOURCE(17452, 325);
{
word var←16096;
word p←11746;
lab←100127: ;
{
word x116;
SOURCE(807, 106);
p←11746 = IOP2( + , (* (( (ptr) gf←0489)+68) ), wordInPage←4908);
SOURCEPOP(807, 106, 17452, 325);
SOURCE(892, 21);
var←16096 = p←11746;
goto lab←100132;
SOURCEPOP(892, 21, 17452, 325);
lab←100132: ;
x116 = (word) ( (unsigned) (* (bytePtr) var←16096 ) >> 5 & 01);
if (x116) {
}
else {
goto lab←100129;
};
};
{
word var←0543;
SOURCE(17515, 76);
{
word var←0542;
{
word var←0541;
{
word var←16112;
word p←11722;
SOURCE(807, 106);
p←11722 = IOP2( + , (* (( (ptr) gf←0489)+68) ), wordInPage←4908);
SOURCEPOP(807, 106, 17515, 76);
SOURCE(892, 21);
var←16112 = p←11722;
goto lab←100133;
SOURCEPOP(892, 21, 17515, 76);
lab←100133: ;
var←0541 = (* (( (ptr) var←16112)+1) );
};
var←0542 = IOP2( + , (
SGNCK( (unsigned) wordsInRecord←4886)
), var←0541);
};
wordsInRecord←4886 = var←0542;
};
SOURCEPOP(17515, 76, 17452, 325);
SOURCE(17593, 14);
wordInPage←4908 = 0;
SOURCEPOP(17593, 14, 17452, 325);
SOURCE(17609, 72);
if ((0 != (word) AdvancePageStream←720())) {
SOURCE(17648, 33);
endOfLog←4108 = (
truncatedRecord←4122 = 1
);
SOURCEPOP(17648, 33, 17609, 72);
SOURCE(17684, 12);
goto lab←100125;
SOURCEPOP(17684, 12, 17609, 72);
};
SOURCEPOP(17609, 72, 17452, 325);
SOURCE(17699, 78);
{
word var←16128;
word p←11698;
SOURCE(807, 106);
p←11698 = (* (( (ptr) gf←0489)+68) );
SOURCEPOP(807, 106, 17699, 78);
SOURCE(892, 21);
var←16128 = p←11698;
goto lab←100134;
SOURCEPOP(892, 21, 17699, 78);
lab←100134: ;
var←0543 = (var←0543 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←16128 ) >> 4 & 01)) << 0);
};
if ( ! (var←0543 & 01)) {
SOURCE(17755, 22);
truncatedRecord←4122 = 1;
SOURCEPOP(17755, 22, 17699, 78);
SOURCE(17780, 12);
goto lab←100125;
SOURCEPOP(17780, 12, 17699, 78);
};
SOURCEPOP(17699, 78, 17452, 325);
};
goto lab←100127;
lab←100129: ;
};
SOURCEPOP(17452, 325, 17326, 96);
SOURCE(17804, 170);
{
word wordsInLastBlock←4930;
SOURCE(17806, 73);
{
word var←0544;
{
word var←16144;
word p←11674;
SOURCE(807, 106);
p←11674 = IOP2( + , (* (( (ptr) gf←0489)+68) ), wordInPage←4908);
SOURCEPOP(807, 106, 17806, 73);
SOURCE(892, 21);
var←16144 = p←11674;
goto lab←100135;
SOURCEPOP(892, 21, 17806, 73);
lab←100135: ;
var←0544 = (* (( (ptr) var←16144)+1) );
};
wordsInLastBlock←4930 = var←0544;
};
SOURCEPOP(17806, 73, 17804, 170);
SOURCE(17881, 42);
wordInPage←4908 = (wordInPage←4908 + wordsInLastBlock←4930);
SOURCEPOP(17881, 42, 17804, 170);
SOURCE(17925, 49);
wordsInRecord←4886 = (wordsInRecord←4886 + wordsInLastBlock←4930);
SOURCEPOP(17925, 49, 17804, 170);
};
SOURCEPOP(17804, 170, 17326, 96);
SOURCE(17977, 194);
{
word tc117;
if ((wordInPage←4908 < (* (ptr) (* (( (ptr) (* (( (ptr) gf←0489)+153)/* var←14704 */ ))+5) ) ))) {
{
word var←16160;
word p←11650;
SOURCE(807, 106);
p←11650 = IOP2( + , (* (( (ptr) gf←0489)+68) ), wordInPage←4908);
SOURCEPOP(807, 106, 17977, 194);
SOURCE(892, 21);
var←16160 = p←11650;
goto lab←100136;
SOURCEPOP(892, 21, 17977, 194);
lab←100136: ;
var←0545 = (* (( (ptr) var←16160)+1) );
};
tc117 = (word) (var←0545 == 0);
}
else {
tc117 = (word) 0;
};
if (tc117) {
SOURCE(18073, 64);
wordsInRecord←4886 = (wordsInRecord←4886 + ((* (ptr) (* (( (ptr) (* (( (ptr) gf←0489)+153)/* var←14704 */ ))+5) ) ) - wordInPage←4908));
SOURCEPOP(18073, 64, 17977, 194);
SOURCE(18139, 32);
wordInPage←4908 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0489)+153)/* var←14704 */ ))+5) ) );
SOURCEPOP(18139, 32, 17977, 194);
};
};
SOURCEPOP(17977, 194, 17326, 96);
SOURCE(18176, 91);
if ( ( (wordInPage←4908 == (* (ptr) (* (( (ptr) (* (( (ptr) gf←0489)+153)/* var←14704 */ ))+5) ) )) ? (0 != (word) AdvancePageStream←720()) : 0 ) ) {
SOURCE(18252, 15);
endOfLog←4108 = 1;
SOURCEPOP(18252, 15, 18176, 91);
};
SOURCEPOP(18176, 91, 17326, 96);
SOURCE(18272, 18);
goto lab←100125;
SOURCEPOP(18272, 18, 17326, 96);
};
SOURCEPOP(17326, 96, 17305, 1141);
goto lab←100124;
lab←100125: ;
SOURCE(18302, 19);
(void) SavePageStreamPos←630();
SOURCEPOP(18302, 19, 17305, 1141);
SOURCE(18323, 67);
{
BIT96 var←16176;
BIT96 r←13268;
SOURCE(960, 0);
r←13268 = (* (BIT96Ptr) (( (ptr) gf←0489)+71)/* recordStream←2256 */ );
SOURCEPOP(960, 0, 18323, 67);
{
BIT96 var←16192;
BIT96 r←13292;
word words←13306;
r←13292 = r←13268;
words←13306 = wordsInRecord←4886;
{
/* declaration of var←0381 skipped */
{
BIT96 var←0546;
{
/* declaration of var←0382 skipped */
{
word pd118;
pd118 = (* (( (ptr) (* (( (ptr) gf←0489)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd118 ))))((word) (( (bytePtr) lf←0571)+28)/* var←0382 */ , words←13306, pd118);
};
var←0546 = (* (BIT96Ptr) (( (ptr) lf←0571)+7)/* var←0382 */ );
};
{
word pd119;
pd119 = (* (( (ptr) (* (( (ptr) gf←0489)+154)/* var←14720 */ ))+10) );
(void) ( *( (funcPtr) ((* (ptr) pd119 ))))((word) (( (bytePtr) lf←0571)+16)/* var←0381 */ , r←13292, var←0546, pd119);
};
};
var←16192 = (* (BIT96Ptr) (( (ptr) lf←0571)+4)/* var←0381 */ );
};
goto lab←100137;
lab←100137: ;
var←16176 = var←16192;
};
goto lab←100138;
lab←100138: ;
(* (BIT96Ptr) (( (ptr) gf←0489)+71)/* recordStream←2256 */ ) = var←16176;
};
SOURCEPOP(18323, 67, 17305, 1141);
SOURCE(18392, 51);
(* (ptr) (word) formal←0383 ) = (word) endOfLog←4108;
(* (( (ptr) (word) formal←0383) + 1) ) = (word) truncatedRecord←4122;
(* (BIT96Ptr) (( (ptr) (word) formal←0383) + 2) ) = (* (BIT96Ptr) (( (ptr) gf←0489)+71)/* recordStream←2256 */ );
XR←PopHandler();
goto lab←0218;
SOURCEPOP(18392, 51, 17305, 1141);
goto lab←100124;
lab←100124: ;
SOURCEPOP(17305, 1141, 17125, 1321);
XR←PopHandler();
lab←0218: ;
lf←0571 = XR←ExtensionFree(lf←0571);
};
static void LocateFirstRecord←1080(formal←0398)
word formal←0398;
{
register word lf←0572;
register ptr gf←0490 = (ptr) &globalframe;
BIT96 firstRecord←4166;
word notStartOfRecord←4952;
word endOfLog←4966 = 0;
lf←0572 = XR←ExtensionAlloc(14);
XR←PushHandler(lf←0572, 0);
/* LocateFirstRecord */
SOURCE(18496, 463);
SOURCE(18568, 22);
SOURCEPOP(18568, 22, 18496, 463);
SOURCE(18592, 22);
SOURCEPOP(18592, 22, 18496, 463);
SOURCE(18616, 145);
{
BIT128 var←16224;
{
/* declaration of var←0388 skipped */
{
BIT96 var←0549;
{
BIT96 var←16208;
word pages←13448;
word deviceCharacteristics←13462;
SOURCE(859, 0);
pages←13448 = (word) LocateStartingPage←1110();
SOURCEPOP(859, 0, 18616, 145);
SOURCE(859, 0);
deviceCharacteristics←13462 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0490)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(859, 0, 18616, 145);
{
/* declaration of var←0392 skipped */
{
BIT96 var←0547;
BIT96 var←0548;
{
/* declaration of var←0393 skipped */
{
word pd120;
pd120 = (* (( (ptr) (* (( (ptr) gf←0490)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd120 ))))((word) (( (bytePtr) lf←0572)+44)/* var←0393 */ , pages←13448, pd120);
};
var←0547 = (* (BIT96Ptr) (( (ptr) lf←0572)+11)/* var←0393 */ );
};
{
/* declaration of var←0394 skipped */
{
word pd121;
word ctmp122;
pd121 = (* (( (ptr) (* (( (ptr) gf←0490)+154)/* var←14720 */ ))+7) );
(void) ( *( (funcPtr) ((* (ptr) pd121 ))))((word) (( (bytePtr) lf←0572)+44)/* var←0394 */ , (
/*1*/ ctmp122 = (unsigned) (* (ptr) deviceCharacteristics←13462 ),
/*1*/ SGNCK(ctmp122)
/*1*/ ), pd121);
};
var←0548 = (* (BIT96Ptr) (( (ptr) lf←0572)+11)/* var←0394 */ );
};
{
word pd123;
pd123 = (* (( (ptr) (* (( (ptr) gf←0490)+154)/* var←14720 */ ))+15) );
(void) ( *( (funcPtr) ((* (ptr) pd123 ))))((word) (( (bytePtr) lf←0572)+32)/* var←0392 */ , var←0547, var←0548, pd123);
};
};
var←16208 = (* (BIT96Ptr) (( (ptr) lf←0572)+8)/* var←0392 */ );
};
goto lab←100139;
lab←100139: ;
var←0549 = var←16208;
};
(void) OpenRecordStreamFromWord←780((word) (( (bytePtr) lf←0572)+16)/* var←0388 */ , var←0549);
};
var←16224 = (* (BIT128Ptr) (( (ptr) lf←0572)+4)/* var←0388 */ );
};
notStartOfRecord←4952 = var←16224.f0;
};
SOURCEPOP(18616, 145, 18496, 463);
SOURCE(18763, 69);
if ((0 != notStartOfRecord←4952)) {
SOURCE(18788, 44);
{
BIT160 var←16240;
{
/* declaration of var←0396 skipped */
(void) AdvanceRecordStream←1050((word) ((( (bytePtr) lf←0572)+16)/* var←0396 */ ));
var←16240 = (* (BIT160Ptr) (( (ptr) lf←0572)+4)/* var←0396 */ );
};
endOfLog←4966 = (* (ptr) &var←16240 );
};
SOURCEPOP(18788, 44, 18763, 69);
};
SOURCEPOP(18763, 69, 18496, 463);
SOURCE(18834, 47);
if ((0 != endOfLog←4966)) {
SOURCE(18851, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0490)+332), 0);
SOURCEPOP(18851, 30, 18834, 47);
};
SOURCEPOP(18834, 47, 18496, 463);
SOURCE(18883, 33);
{
/* declaration of var←0397 skipped */
(void) CurrentWordNumber←870((word) ((( (bytePtr) lf←0572)+16)/* var←0397 */ ));
firstRecord←4166 = (* (BIT96Ptr) (( (ptr) lf←0572)+4)/* var←0397 */ );
};
SOURCEPOP(18883, 33, 18496, 463);
SOURCE(18918, 19);
(void) CloseRecordStream←900();
SOURCEPOP(18918, 19, 18496, 463);
SOURCE(18939, 20);
(* (BIT96Ptr) formal←0398 ) = firstRecord←4166;
XR←PopHandler();
goto lab←0219;
SOURCEPOP(18939, 20, 18496, 463);
XR←PopHandler();
lab←0219: ;
lf←0572 = XR←ExtensionFree(lf←0572);
};
static word LocateStartingPage←1110()
{
word temp130;
register word lf←0573;
register ptr gf←0491 = (ptr) &globalframe;
/* declaration of var←16256 skipped */
word startPage←5002;
word beginPage←5016;
lf←0573 = XR←ExtensionAlloc(6);
XR←PushHandler(lf←0573, 0);
/* LocateStartingPage */
SOURCE(18965, 772);
/* removed dead decl of 4196 */
{
word tmpAddr124;
tmpAddr124 = (word) (( (ptr) lf←0573)+4)/* var←16256 */ ;
(* (ptr) tmpAddr124 ) = (word) ( ((word) (funcPtr) SkipAhead←1578) );
(* (( (ptr) tmpAddr124) + 1) ) = (word) 1;
};
SOURCE(19200, 32);
SOURCEPOP(19200, 32, 18965, 772);
SOURCE(19200, 32);
SOURCEPOP(19200, 32, 18965, 772);
SOURCE(19234, 209);
SOURCE(19278, 35);
if ((0 != (word) OpenPageStream←540(0))) {
SOURCE(19313, 9);
goto lab←100141;
SOURCEPOP(19313, 9, 19278, 35);
};
SOURCEPOP(19278, 35, 19234, 209);
SOURCE(19324, 72);
{
register word var←16272 = 0;
goto lab←100143;
lab←100142: ;
SOURCE(19359, 37);
if ((0 != (word) AdvancePageStream←720())) {
SOURCE(19396, 9);
goto lab←100141;
SOURCEPOP(19396, 9, 19359, 37);
};
SOURCEPOP(19359, 37, 19324, 72);
var←16272 = IOP2( + , var←16272, 1);
lab←100143: ;
if (IOP2( < , var←16272, 40)) {
goto lab←100142;
};
};
SOURCEPOP(19324, 72, 19234, 209);
goto lab←100140;
lab←100141: ;
SOURCE(19430, 11);
{
word pd125;
pd125 = ((word) (( (bytePtr) lf←0573)+16)/* var←16256 */ );
(void) ( *( (funcPtr) ((* (ptr) pd125 ))))(pd125);
};
SOURCEPOP(19430, 11, 19234, 209);
goto lab←100140;
lab←100140: ;
SOURCEPOP(19234, 209, 18965, 772);
SOURCE(19446, 31);
{
word ctmp126;
startPage←5002 = IOP2( + , (* (( (ptr) gf←0491)+59) ), (
ctmp126 = (unsigned) (* (( (ptr) gf←0491)+64) ),
SGNCK(ctmp126)
));
};
SOURCEPOP(19446, 31, 18965, 772);
SOURCE(19479, 41);
lab←100147: ;
SOURCE(19483, 37);
if ((0 != (word) AdvancePageStream←720())) {
SOURCE(19520, 13);
goto lab←100150;
SOURCEPOP(19520, 13, 19483, 37);
};
SOURCEPOP(19483, 37, 19479, 41);
goto lab←100147;
lab←100150: ;
SOURCEPOP(19479, 41, 18965, 772);
SOURCE(19535, 11);
{
word pd127;
pd127 = ((word) (( (bytePtr) lf←0573)+16)/* var←16256 */ );
(void) ( *( (funcPtr) ((* (ptr) pd127 ))))(pd127);
};
SOURCEPOP(19535, 11, 18965, 772);
SOURCE(19548, 31);
{
word ctmp128;
beginPage←5016 = IOP2( + , (* (( (ptr) gf←0491)+59) ), (
ctmp128 = (unsigned) (* (( (ptr) gf←0491)+64) ),
SGNCK(ctmp128)
));
};
SOURCEPOP(19548, 31, 18965, 772);
SOURCE(19581, 108);
lab←100152: ;
{
word ctmp129;
if ((IOP2( + , (* (( (ptr) gf←0491)+59) ), (
ctmp129 = (unsigned) (* (( (ptr) gf←0491)+64) ),
SGNCK(ctmp129)
)) != startPage←5002)) {
}
else {
goto lab←100154;
};
};
SOURCE(19622, 67);
if ((0 != (word) AdvancePageStream←720())) {
SOURCE(19659, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0491)+332), 0);
SOURCEPOP(19659, 30, 19622, 67);
};
SOURCEPOP(19622, 67, 19581, 108);
goto lab←100152;
lab←100154: ;
SOURCEPOP(19581, 108, 18965, 772);
SOURCE(19700, 17);
(void) ClosePageStream←570();
SOURCEPOP(19700, 17, 18965, 772);
SOURCE(19719, 18);
temp130 = beginPage←5016;
lf←0573 = XR←ExtensionFree(lf←0573);
XR←PopHandler();
return(temp130);
SOURCEPOP(19719, 18, 18965, 772);
};
static void SkipAhead←1578(formal←0493)
word formal←0493;
{
register ptr gf←0492 = (ptr) &globalframe;
word nextPage←5046;
formal←0493 = (formal←0493 - 16);
/* SkipAhead */
SOURCE(19018, 177);
SOURCE(19041, 61);
{
word ctmp131;
nextPage←5046 = IOP2( + , IOP2( + , (* (( (ptr) gf←0492)+59) ), (
ctmp131 = (unsigned) (* (( (ptr) gf←0492)+64) ),
SGNCK(ctmp131)
)), 40);
};
SOURCEPOP(19041, 61, 19018, 177);
SOURCE(19104, 17);
(void) ClosePageStream←570();
SOURCEPOP(19104, 17, 19018, 177);
SOURCE(19123, 72);
if ((0 != (word) OpenPageStream←540(nextPage←5046))) {
SOURCE(19165, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0492)+332), 0);
SOURCEPOP(19165, 30, 19123, 72);
};
SOURCEPOP(19123, 72, 19018, 177);
};
static void Get←1140(formal←0445, thisRecord←4226, to←4240)
word formal←0445;
BIT96 thisRecord←4226;
BIT96 to←4240;
{
register word lf←0574;
register ptr gf←0494 = (ptr) &globalframe;
word status←4262;
word wordsRead←4276;
/* declaration of var←16288 skipped */
/* declaration of var←16304 skipped */
/* declaration of chunk←5068 skipped */
/* declaration of pagePtr←5082 skipped */
/* declaration of pagesLeftInChunk←5096 skipped */
word isFirstPage←5152 = 1;
word pageVersion←5166 = 0;
/* declaration of wordInPage←5180 skipped */
lf←0574 = XR←ExtensionAlloc(24);
XR←PushHandler(lf←0574, 0);
/* Get */
SOURCE(19745, 2766);
{
word tmpAddr132;
tmpAddr132 = (word) (( (ptr) lf←0574)+4)/* var←16288 */ ;
(* (ptr) tmpAddr132 ) = (word) ( ((word) (funcPtr) Verify←1698) );
(* (( (ptr) tmpAddr132) + 1) ) = (word) 1;
};
{
word tmpAddr133;
tmpAddr133 = (word) (( (ptr) lf←0574)+6)/* var←16304 */ ;
(* (ptr) tmpAddr133 ) = (word) ( ((word) (funcPtr) GetChunk←1608) );
(* (( (ptr) tmpAddr133) + 1) ) = (word) 1;
};
SOURCE(19876, 31);
{
BIT128 var←16320;
var←16320.f2 = 1;
var←16320.f1 = 0;
var←16320.f3 = 0;
var←16320.f0 = 0;
(* (BIT128Ptr) (( (ptr) lf←0574)+8)/* chunk←5068 */ ) = var←16320;
};
SOURCEPOP(19876, 31, 19745, 2766);
SOURCE(19909, 21);
SOURCEPOP(19909, 21, 19745, 2766);
SOURCE(19932, 26);
SOURCEPOP(19932, 26, 19745, 2766);
SOURCE(20602, 24);
SOURCEPOP(20602, 24, 19745, 2766);
SOURCE(20628, 38);
SOURCEPOP(20628, 38, 19745, 2766);
SOURCE(20668, 20);
SOURCEPOP(20668, 20, 19745, 2766);
SOURCE(20866, 186);
{
word firstPage←5276;
SOURCE(20868, 21);
SOURCEPOP(20868, 21, 20866, 186);
SOURCE(20891, 138);
{
BIT64 var←16368;
{
BIT64 var←16336;
BIT96 words←12922;
word deviceCharacteristics←12936;
BIT96 q←12952;
BIT96 r←12966;
SOURCE(1376, 15);
{
/* declaration of var←0422 skipped */
(void) WordNumberFromRecordID←450((word) (( (bytePtr) lf←0574)+60)/* var←0422 */ , thisRecord←4226);
words←12922 = (* (BIT96Ptr) (( (ptr) lf←0574)+15)/* var←0422 */ );
};
SOURCEPOP(1376, 15, 20891, 138);
SOURCE(1376, 15);
deviceCharacteristics←12936 = (* (ptr) (* (( (ptr) (* (( (ptr) gf←0494)+153)/* var←14704 */ ))+4) ) );
SOURCEPOP(1376, 15, 20891, 138);
{
BIT192 var←16352;
{
/* declaration of var←0427 skipped */
{
BIT96 var←0550;
{
/* declaration of var←0428 skipped */
{
word pd134;
pd134 = (* (( (ptr) (* (( (ptr) gf←0494)+154)/* var←14720 */ ))+6) );
(void) ( *( (funcPtr) ((* (ptr) pd134 ))))((word) (( (bytePtr) lf←0574)+84)/* var←0428 */ , (* (ptr) deviceCharacteristics←12936 ), pd134);
};
var←0550 = (* (BIT96Ptr) (( (ptr) lf←0574)+21)/* var←0428 */ );
};
{
word pd135;
pd135 = (* (( (ptr) (* (( (ptr) gf←0494)+154)/* var←14720 */ ))+14) );
(void) ( *( (funcPtr) ((* (ptr) pd135 ))))((word) (( (bytePtr) lf←0574)+60)/* var←0427 */ , words←12922, var←0550, pd135);
};
};
var←16352 = (* (BIT192Ptr) (( (ptr) lf←0574)+15)/* var←0427 */ );
};
r←12966 = (* (BIT96Ptr) (( (ptr) &var←16352)+3) );
q←12952 = (* (BIT96Ptr) &var←16352 );
};
{
word pd136;
word pd137;
pd136 = (* (( (ptr) (* (( (ptr) gf←0494)+154)/* var←14720 */ ))+9) );
(* (ptr) (word) &var←16336 ) = (word) ( *( (funcPtr) ((* (ptr) pd136 ))))(q←12952, pd136);
pd137 = (* (( (ptr) (* (( (ptr) gf←0494)+154)/* var←14720 */ ))+9) );
(* (( (ptr) (word) &var←16336) + 1) ) = (word) ( *( (funcPtr) ((* (ptr) pd137 ))))(r←12966, pd137);
};
goto lab←100157;
lab←100157: ;
var←16368 = var←16336;
};
(* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ) = var←16368.f1;
firstPage←5276 = var←16368.f0;
};
SOURCEPOP(20891, 138, 20866, 186);
SOURCE(21031, 19);
{
word pd138;
pd138 = ((word) (( (bytePtr) lf←0574)+24)/* var←16304 */ );
(void) ( *( (funcPtr) ((* (ptr) pd138 ))))(firstPage←5276, pd138);
};
SOURCEPOP(21031, 19, 20866, 186);
};
SOURCEPOP(20866, 186, 19745, 2766);
SOURCE(21055, 8);
{
word pd139;
pd139 = ((word) (( (bytePtr) lf←0574)+16)/* var←16288 */ );
(void) ( *( (funcPtr) ((* (ptr) pd139 ))))(pd139);
};
SOURCEPOP(21055, 8, 19745, 2766);
SOURCE(21065, 13);
wordsRead←4276 = 0;
SOURCEPOP(21065, 13, 19745, 2766);
SOURCE(21080, 1431);
lab←100158: ;
SOURCE(21080, 1431);
{
word wordsThisBlock←5298;
word wordsThisCopy←5312;
word hasContinuation←5326;
word isContinuation←5340;
word version←5354;
word var←0551;
SOURCE(21083, 39);
SOURCEPOP(21083, 39, 21080, 1431);
SOURCE(21083, 39);
SOURCEPOP(21083, 39, 21080, 1431);
SOURCE(21124, 37);
SOURCEPOP(21124, 37, 21080, 1431);
SOURCE(21124, 37);
SOURCEPOP(21124, 37, 21080, 1431);
SOURCE(21163, 30);
SOURCEPOP(21163, 30, 21080, 1431);
SOURCE(21203, 125);
SOURCE(21205, 121);
{
word var←16384;
word p←11626;
SOURCE(807, 106);
p←11626 = (* (( (ptr) lf←0574)+12)/* pagePtr←5082 */ );
SOURCEPOP(807, 106, 21205, 121);
SOURCE(892, 21);
var←16384 = p←11626;
goto lab←100163;
SOURCEPOP(892, 21, 21205, 121);
lab←100163: ;
var←0551 = (var←0551 & 4294967294) | ((01 & ( (unsigned) (* (bytePtr) var←16384 ) >> 7)) << 0);
};
if ( ! (var←0551 & 01)) {
SOURCE(21239, 87);
{
word ctmp140;
(void) VerifyGet←480(IOP2( + , (* (( (ptr) lf←0574)+9) ), IOP2( - , (* (( (ptr) lf←0574)+10) ), (
ctmp140 = (unsigned) ((* (( (ptr) lf←0574)+13)/* pagesLeftInChunk←5096 */ ) + 1),
SGNCK(ctmp140)
))), (* (( (ptr) lf←0574)+12)/* pagePtr←5082 */ ));
};
SOURCEPOP(21239, 87, 21205, 121);
};
SOURCEPOP(21205, 121, 21203, 125);
SOURCEPOP(21203, 125, 21080, 1431);
SOURCE(21339, 141);
SOURCE(21340, 138);
{
BIT64 var←16416;
{
word var←16400;
word p←11602;
SOURCE(807, 106);
p←11602 = IOP2( + , (* (( (ptr) lf←0574)+12)/* pagePtr←5082 */ ), (* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ));
SOURCEPOP(807, 106, 21340, 138);
SOURCE(892, 21);
var←16400 = p←11602;
goto lab←100164;
SOURCEPOP(892, 21, 21340, 138);
lab←100164: ;
var←16416 = (* (BIT64Ptr) var←16400 );
};
wordsThisBlock←5298 = var←16416.f1;
isContinuation←5340 = ( (unsigned) (* (bytePtr) &var←16416 ) >> 4 & 01);
hasContinuation←5326 = ( (unsigned) (* (bytePtr) &var←16416 ) >> 5 & 01);
version←5354 = ( (unsigned) (* (bytePtr) &var←16416 ) >> 6 & 01);
};
SOURCEPOP(21340, 138, 21339, 141);
SOURCEPOP(21339, 141, 21080, 1431);
SOURCE(21483, 53);
wordsThisBlock←5298 = (wordsThisBlock←5298 - 8);
SOURCEPOP(21483, 53, 21080, 1431);
SOURCE(21538, 45);
(* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ) = ((* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ) + 8);
SOURCEPOP(21538, 45, 21080, 1431);
SOURCE(21585, 214);
if ((0 != isFirstPage←5152)) {
SOURCE(21607, 53);
if ((0 != isContinuation←5340)) {
SOURCE(21630, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0494)+332), 0);
SOURCEPOP(21630, 30, 21607, 53);
};
SOURCEPOP(21607, 53, 21585, 214);
SOURCE(21662, 21);
pageVersion←5166 = version←5354;
SOURCEPOP(21662, 21, 21585, 214);
SOURCE(21685, 20);
isFirstPage←5152 = 0;
SOURCEPOP(21685, 20, 21585, 214);
}
else {
SOURCE(21714, 85);
if ((0 == isContinuation←5340) || (version←5354 != pageVersion←5166)) {
SOURCE(21768, 31);
(void) XR←RaiseError((word) (( (bytePtr) gf←0494)+332), 0);
SOURCEPOP(21768, 31, 21714, 85);
};
SOURCEPOP(21714, 85, 21585, 214);
};
SOURCEPOP(21585, 214, 21080, 1431);
SOURCE(21802, 709);
lab←100165: ;
SOURCE(21805, 46);
{
word x141;
wordsThisCopy←5312 = (x141 = to←4240.f1,
MIN( (unsigned) , x141, wordsThisBlock←5298));
};
SOURCEPOP(21805, 46, 21802, 709);
SOURCE(21853, 131);
if ((to←4240.f0 != 0)) {
SOURCE(21877, 74);
{
word from←12594;
word to←12608;
SOURCE(21877, 74);
from←12594 = IOP2( + , (* (( (ptr) lf←0574)+12)/* pagePtr←5082 */ ), (* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ));
SOURCEPOP(21877, 74, 21877, 74);
SOURCE(21877, 74);
to←12608 = to←4240.f0;
SOURCEPOP(21877, 74, 21877, 74);
(void) XR←MoveWords(to←12608, from←12594, BCK(wordsThisCopy←5312, 2147483648));
};
SOURCEPOP(21877, 74, 21853, 131);
SOURCE(21953, 31);
to←4240.f0 = IOP2( + , to←4240.f0, wordsThisCopy←5312);
SOURCEPOP(21953, 31, 21853, 131);
};
SOURCEPOP(21853, 131, 21802, 709);
SOURCE(21989, 35);
wordsRead←4276 = (wordsRead←4276 + wordsThisCopy←5312);
SOURCEPOP(21989, 35, 21802, 709);
SOURCE(22026, 485);
if ((wordsThisCopy←5312 != to←4240.f1)) {
SOURCE(22062, 35);
to←4240.f1 = (to←4240.f1 - wordsThisCopy←5312);
SOURCEPOP(22062, 35, 22026, 485);
SOURCE(22099, 81);
if ((0 == hasContinuation←5326)) {
SOURCE(22129, 14);
SOURCE(20213, 83);
{
word pd142;
pd142 = (* (( (ptr) (* (( (ptr) gf←0494)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd142 ))))((* (BIT128Ptr) (( (ptr) lf←0574)+8)/* chunk←5068 */ ), 4, 0, pd142);
};
SOURCEPOP(20213, 83, 22129, 14);
SOURCEPOP(22129, 14, 22099, 81);
SOURCE(22145, 35);
(* (ptr) (word) formal←0445 ) = (word) 2;
(* (( (ptr) (word) formal←0445) + 1) ) = (word) wordsRead←4276;
XR←PopHandler();
goto lab←0220;
SOURCEPOP(22145, 35, 22099, 81);
};
SOURCEPOP(22099, 81, 22026, 485);
SOURCE(22183, 13);
SOURCE(20334, 259);
if (((* (( (ptr) lf←0574)+13)/* pagesLeftInChunk←5096 */ ) == 0)) {
{
word nextPage←5376;
SOURCE(20365, 51);
{
word var←16432;
word p←12290;
BIT64 pr←12306;
SOURCE(1172, 138);
SOURCEPOP(1172, 138, 20365, 51);
SOURCE(1172, 138);
pr←12306 = (* (BIT64Ptr) (( (ptr) lf←0574)+9) );
SOURCEPOP(1172, 138, 20365, 51);
SOURCE(1241, 25);
p←12290 = IOP2( + , pr←12306.f0, pr←12306.f1);
SOURCEPOP(1241, 25, 20365, 51);
SOURCE(1268, 42);
if ((p←12290 == (* (( (ptr) gf←0494)+9)/* logFileSize←1668 */ ))) {
var←16432 = 0;
}
else {
var←16432 = p←12290;
};
goto lab←100171;
SOURCEPOP(1268, 42, 20365, 51);
lab←100171: ;
nextPage←5376 = var←16432;
};
SOURCEPOP(20365, 51, 20334, 259);
SOURCE(20418, 14);
SOURCE(20213, 83);
{
word pd143;
pd143 = (* (( (ptr) (* (( (ptr) gf←0494)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd143 ))))((* (BIT128Ptr) (( (ptr) lf←0574)+8)/* chunk←5068 */ ), 4, 0, pd143);
};
SOURCEPOP(20213, 83, 20418, 14);
SOURCEPOP(20418, 14, 20334, 259);
SOURCE(20434, 48);
if ((nextPage←5376 == 0)) {
SOURCE(20455, 27);
pageVersion←5166 = BCK(IOP2( - , 1, pageVersion←5166), 2);
SOURCEPOP(20455, 27, 20434, 48);
};
SOURCEPOP(20434, 48, 20334, 259);
SOURCE(20484, 18);
{
word pd144;
pd144 = ((word) (( (bytePtr) lf←0574)+24)/* var←16304 */ );
(void) ( *( (funcPtr) ((* (ptr) pd144 ))))(nextPage←5376, pd144);
};
SOURCEPOP(20484, 18, 20334, 259);
};
}
else {
SOURCE(20513, 39);
(* (( (ptr) lf←0574)+12)/* pagePtr←5082 */ ) = IOP2( + , (* (( (ptr) lf←0574)+12)/* pagePtr←5082 */ ), (* (ptr) (* (( (ptr) (* (( (ptr) gf←0494)+153)/* var←14704 */ ))+5) ) ));
SOURCEPOP(20513, 39, 20334, 259);
SOURCE(20554, 39);
(* (( (ptr) lf←0574)+13)/* pagesLeftInChunk←5096 */ ) = ((* (( (ptr) lf←0574)+13)/* pagesLeftInChunk←5096 */ ) - 1);
SOURCEPOP(20554, 39, 20334, 259);
};
SOURCEPOP(20334, 259, 22183, 13);
SOURCEPOP(22183, 13, 22026, 485);
SOURCE(22198, 14);
(* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ) = 0;
SOURCEPOP(22198, 14, 22026, 485);
SOURCE(22214, 14);
goto lab←100170;
SOURCEPOP(22214, 14, 22026, 485);
}
else {
SOURCE(22237, 274);
if ((to←4240.f2 != 0)) {
SOURCE(22267, 105);
SOURCE(22269, 13);
to←4240 = (* (BIT96Ptr) to←4240.f2 );
SOURCEPOP(22269, 13, 22267, 105);
SOURCE(22284, 45);
wordsThisBlock←5298 = (wordsThisBlock←5298 - wordsThisCopy←5312);
SOURCEPOP(22284, 45, 22267, 105);
SOURCE(22331, 39);
(* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ) = ((* (( (ptr) lf←0574)+14)/* wordInPage←5180 */ ) + wordsThisCopy←5312);
SOURCEPOP(22331, 39, 22267, 105);
SOURCEPOP(22267, 105, 22237, 274);
}
else {
SOURCE(22381, 14);
SOURCE(20213, 83);
{
word pd145;
pd145 = (* (( (ptr) (* (( (ptr) gf←0494)+152)/* var←14672 */ ))+12) );
(void) ( *( (funcPtr) ((* (ptr) pd145 ))))((* (BIT128Ptr) (( (ptr) lf←0574)+8)/* chunk←5068 */ ), 4, 0, pd145);
};
SOURCEPOP(20213, 83, 22381, 14);
SOURCEPOP(22381, 14, 22237, 274);
SOURCE(22397, 114);
(* (ptr) (word) formal←0445 ) = (word) ( ( (0 == hasContinuation←5326) ? (wordsThisBlock←5298 == wordsThisCopy←5312) : 0 ) ? 0 : 1 ) ;
(* (( (ptr) (word) formal←0445) + 1) ) = (word) wordsRead←4276;
XR←PopHandler();
goto lab←0220;
SOURCEPOP(22397, 114, 22237, 274);
};
SOURCEPOP(22237, 274, 22026, 485);
};
SOURCEPOP(22026, 485, 21802, 709);
goto lab←100165;
lab←100170: ;
goto lab←100168;
lab←100168: ;
SOURCEPOP(21802, 709, 21080, 1431);
};
SOURCEPOP(21080, 1431, 21080, 1431);
goto lab←100158;
SOURCEPOP(21080, 1431, 19745, 2766);
XR←PopHandler();
lab←0220: ;
lf←0574 = XR←ExtensionFree(lf←0574);
};
static void GetChunk←1608(nextPage←5238, formal←0496)
word nextPage←5238;
word formal←0496;
{
register word lf←0575;
register ptr gf←0495 = (ptr) &globalframe;
formal←0496 = (formal←0496 - 24);
lf←0575 = XR←ExtensionAlloc(8);
XR←PushHandler(lf←0575, 0);
(* (ptr) lf←0575 ) = formal←0496;
/* GetChunk */
SOURCE(19961, 213);
SOURCE(20004, 103);
{
/* declaration of var←0447 skipped */
{
BIT64 var←0552;
{
BIT64 var←16448;
BIT64 pr←12130;
SOURCE(1028, 140);
SOURCEPOP(1028, 140, 20004, 103);
SOURCE(1028, 140);
pr←12130.f1 = 1;
pr←12130.f0 = 0;
SOURCEPOP(1028, 140, 20004, 103);
SOURCE(1103, 65);
{
BIT64 var←16464;
var←16464.f0 = nextPage←5238;
{
word x146;
var←16464.f1 = (x146 = IOP2( - , (* (( (ptr) gf←0495)+9)/* logFileSize←1668 */ ), nextPage←5238),
MIN((int)(word), x146, 4));
};
var←16448 = var←16464;
};
goto lab←100172;
SOURCEPOP(1103, 65, 20004, 103);
lab←100172: ;
var←0552 = var←16448;
};
{
word pd147;
pd147 = (* (( (ptr) (* (( (ptr) gf←0495)+152)/* var←14672 */ ))+8) );
(void) ( *( (funcPtr) ((* (ptr) pd147 ))))((word) (( (bytePtr) lf←0575)+16)/* var←0447 */ , (* (( (ptr) gf←0495)+8)/* logFileHandle←1654 */ ), var←0552, pd147);
};
};
(* (BIT128Ptr) (( (ptr) formal←0496)+8) ) = (* (BIT128Ptr) (( (ptr) lf←0575)+4)/* var←0447 */ );
};
SOURCEPOP(20004, 103, 19961, 213);
SOURCE(20109, 21);
(* (( (ptr) formal←0496)+12) ) = (* (( (ptr) formal←0496)+8) );
SOURCEPOP(20109, 21, 19961, 213);
SOURCE(20132, 42);
(* (( (ptr) formal←0496)+13) ) = IOP2( - , (* (( (ptr) formal←0496)+10) ), 1);
SOURCEPOP(20132, 42, 19961, 213);
XR←PopHandler();
lf←0575 = XR←ExtensionFree(lf←0575);
};
static void Verify←1698(formal←0498)
word formal←0498;
{
register ptr gf←0497 = (ptr) &globalframe;
word w←5390 = 0;
formal←0498 = (formal←0498 - 16);
/* Verify */
SOURCE(20691, 160);
SOURCE(20711, 15);
SOURCEPOP(20711, 15, 20691, 160);
SOURCE(20728, 123);
lab←100173: ;
if ((w←5390 != (* (( (ptr) formal←0498)+14) ))) {
}
else {
goto lab←100175;
};
SOURCE(20760, 35);
SOURCE(20761, 32);
{
word var←0554;
{
word var←0553;
{
word var←16480;
word p←11578;
SOURCE(807, 106);
p←11578 = IOP2( + , (* (( (ptr) formal←0498)+12) ), w←5390);
SOURCEPOP(807, 106, 20761, 32);
SOURCE(892, 21);
var←16480 = p←11578;
goto lab←100178;
SOURCEPOP(892, 21, 20761, 32);
lab←100178: ;
var←0553 = (* (( (ptr) var←16480)+1) );
};
var←0554 = IOP2( + , (
SGNCK( (unsigned) w←5390)
), var←0553);
};
w←5390 = var←0554;
};
SOURCEPOP(20761, 32, 20760, 35);
SOURCEPOP(20760, 35, 20728, 123);
SOURCE(20798, 53);
if ((w←5390 > (* (( (ptr) formal←0498)+14) ))) {
SOURCE(20821, 30);
(void) XR←RaiseError((word) (( (bytePtr) gf←0497)+332), 0);
SOURCEPOP(20821, 30, 20798, 53);
};
SOURCEPOP(20798, 53, 20728, 123);
goto lab←100173;
lab←100175: ;
SOURCEPOP(20728, 123, 20691, 160);
};
static word Ln9(formal←088)
word formal←088;
{
word var←090;
word var←089;
/* intermediary proc for a FORK, nArgs: 1, nRets: 0 */
var←090 = (* (( (ptr) formal←088)+4) );
var←089 = (* (( (ptr) formal←088)+2) );
formal←088 = XR←ExtensionFree(formal←088);
(void) ( *( (funcPtr) ((* (ptr) var←089 ))))(var←090, var←089);
return(0);
};
/* transformed in 6.45 seconds. */
extern void XR←install←YggLogBasicImpl() {
descXenablex100046.proc = (int) (funcPtr) enable←100046;
descXenablex100074.proc = (int) (funcPtr) enable←100074;
YggLogBasicImpl();
};
static void XR←install() {XR←install←YggLogBasicImpl();};
/* installation sequence */
static void XR←load←YggLogBasicImpl() { XR←install←YggLogBasicImpl(); };
static void XR←load() { XR←install←YggLogBasicImpl(); };
static void XR←run←YggLogBasicImpl() { XR←Start(&globalframe); };
static void XR←run() { XR←Start(&globalframe); };