/* 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); };