/* Generated with C2C (Cedar To C)*/
/* Copyright (C) 1993 by Xerox Corporation.  All rights reserved. */
/* time: July 28, 1993 10:13:34 am PDT */
/* C2C version: April 20, 1993 (sun4) */
/* ref-counting: off */
/* file: FunctionCacheImpl, module: FunctionCacheImpl */ 
/* switches: bcfhklnouw */ 
#include <cedar/InstallationSupport.h>
#include <cedar/CedarExtra.h>
static char versionStamp[] = "@(#)mob←version [374557494,436071096] FunctionCacheImpl";
typedef unsigned word, *ptr;
typedef unsigned char byte, *bPt;
typedef unsigned short half, *hPt;
typedef struct {word f0, f1, f2, f3;} W4;
typedef W4 *W4Pt;
typedef word (*fPt)();
typedef struct {word f0, f1, f2, f3, f4, f5, f6, f7;} W8;
typedef struct {word f0, f1;} W2;
typedef struct {W8 f; W2 r;} W10;
typedef struct {W8 f; word r;} W9;
typedef struct {word f0, f1, f2, f3, f4, f5, f6;} W7;
#define SOURCE(p, l) /* source p, l */
#define IOP2(op, x, y)  ( (word) ((x) op (y)) )
static void NoName←Q2880();
static void FunctionCacheImpl←P0();
static word Create←P60();
static word ListCompare←P120();
static word Equal←P180();
static word Eval←P240();
static word refCompare←P1776();
static word fancyCompare←P1836();
static void Insert←P300();
static void Lookup←P360();
static word NoName←Q2940();
static word Any←P420();
static word Obtain←P480();
static word NoName←Q3000();
static void Release←P540();
static void Flush←P600();
static void GetInfo←P660();
static word GetList←P720();
static void SetLimits←P780();
static void SetValueSize←P840();
static void CheckInvariants←P900();
static void EnforceLimits←P1020();
static word GlobalCache←P1080();
static word Example←P1140();
static word compare←P2328();
static void NoName←Q3060();
static void NoName←Q3120();
static struct {unsigned f; char r[16];} string1 = {851984, "\257\300\161\264\233\303\300\026\075\022\161\101\334\000\000"};
static struct {unsigned f; char r[4];} string2 = {131074, "\003\010\000"};
static struct {unsigned f; char r[44];} string3 = {2752556, "\260\006\005\146\151\162\163\164\257\300\161\264\233\303\300\026\075\022\161\101\050\005\004\162\145\163\164\214\257\300\161\264\233\303\300\026\075\022\161\101\050\261\000"};
static struct {unsigned f; char r[4];} string4 = {131074, "\004\027\000"};
static struct {unsigned f; char r[4];} string5 = {65540, "\242\000\000"};
static struct {unsigned f; char r[4];} string6 = {65540, "\256\000\000"};
static struct {unsigned f; char r[4];} string7 = {65540, "\243\000\000"};
static struct {unsigned f; char r[4];} string8 = {65540, "\251\000\000"};
static struct {unsigned f; char r[16];} string9 = {851984, "\257\300\363\223\326\161\300\017\164\046\072\104\304\000\000"};
static struct {unsigned f; char r[24];} string10 = {1376277, "\007\000\001\002\007\020\001\002\000\007\036\002\004\003\002\004\014\016\015\003\001\000\000"};
static struct {unsigned f; char r[20];} string11 = {1179668, "\260\006\005\146\151\162\163\164\217\005\004\162\145\163\164\214\217\261\000"};
static struct {unsigned f; char r[4];} string12 = {131074, "\004\003\000"};
static struct {unsigned f; char r[4];} string13 = {131076, "\216\251\000"};
static struct {unsigned f; char r[4];} string14 = {65537, "\001\000\000"};
static struct {unsigned f; char r[20];} string15 = {1179668, "\260\006\005\146\151\162\163\164\242\005\004\162\145\163\164\214\242\261\000"};
static struct {unsigned f; char r[4];} string16 = {131074, "\003\001\000"};
static struct {unsigned f; char r[16];} string17 = {786448, "SillyExample\000\000\000"};
static struct {unsigned f; char r[16];} string18 = {851984, "\257\300\026\123\113\066\300\031\375\352\270\100\200\000\000"};
static struct {unsigned f; char r[8];} string19 = {458759, "\006\002\034\001@P\001"};
static struct {unsigned f; char r[16];} string20 = {851984, "\257\300\055\153\222\376\300\327\164\352\142\100\150\000\000"};
static struct {unsigned f; char r[16];} string21 = {851984, "\257\300\363\223\326\161\300\017\164\046\072\100\150\000\000"};
static struct {unsigned f; char r[16];} string22 = {851984, "\257\300\161\264\233\303\300\026\075\022\161\100\150\000\000"};
static struct {
   word f0[21]; word f21; word f22; word f23; 
   word f24; word f25; word f26; word f27; 
   word f28; word f29; word f30; word f31; 
   word f32; word f33; word f34; word f35; 
   word f36; word f37; word f38; word f39; 
   word f40; word f41; word f42; word f43; 
   word f44; word f45; word f46; word f47; 
   word f48; word f49; word f50; word f51; 
   word f52; word f53; word f54; word f55; 
   word f56; word f57; word f58[8]; 
   } globalframe = {
   {0}, (word) Example←P1140, 0, (word) GlobalCache←P1080, 
   0, (word) EnforceLimits←P1020, 0, (word) CheckInvariants←P900, 
   0, (word) SetValueSize←P840, 0, (word) SetLimits←P780, 
   0, (word) GetList←P720, 0, (word) GetInfo←P660, 
   0, (word) Flush←P600, 0, (word) Release←P540, 
   0, (word) Obtain←P480, 0, (word) Any←P420, 
   0, (word) Lookup←P360, 0, (word) Insert←P300, 
   0, (word) Eval←P240, 0, (word) Equal←P180, 
   0, (word) ListCompare←P120, 0, (word) Create←P60, 
   0, (word) FunctionCacheImpl←P0, {0}
   };

static void NoName←Q2880()
   {
   register ptr gf←c0195 =  (ptr) &globalframe;
   word var←c16916;
   (* (( (ptr) gf←c0195)+9) ) = (word) XR←GetTypeIndex((word) &string1, 0, (word) &string2);
   (* (( (ptr) gf←c0195)+10) ) = (word) XR←GetTypeIndex((word) &string3, 0, (word) &string4);
   (* (( (ptr) gf←c0195)+12) ) = (word) XR←GetTypeIndexS((word) (&string5));
   (* (( (ptr) gf←c0195)+13) ) = (word) XR←GetTypeIndexS((word) (&string6));
   (* (( (ptr) gf←c0195)+14) ) = (word) XR←GetTypeIndexS((word) (&string7));
   (* (( (ptr) gf←c0195)+15) ) = (word) XR←GetTypeIndexS((word) (&string8));
   (* (( (ptr) gf←c0195)+16) ) = (word) XR←GetTypeIndex((word) &string9, 0, (word) &string10);
   (* (( (ptr) gf←c0195)+17) ) = (word) XR←GetTypeIndex((word) &string11, 0, (word) &string12);
   (* (( (ptr) gf←c0195)+18) ) = (word) XR←GetTypeIndex((word) &string13, 0, (word) &string14);
   (* (( (ptr) gf←c0195)+19) ) = (word) XR←GetTypeIndex((word) &string15, 0, (word) &string16);
   (*  (ptr) (( (bPt) gf←c0195)+80) ) = (word) XR←GetRefLiteral((* (( (ptr) gf←c0195)+18) ), (word) &string17);
   (void) XR←DeclareGlobalFrame((word) "FunctionCacheImpl", &globalframe, (word) XR←GetTypeIndex((word) &string18, 0, (word) &string19)
      , (word) (( (bPt) gf←c0195)+228)/* var←c15380 */ );
   var←c16916 = (word) XR←ImportInterface((word) "Atom", (word) XR←GetTypeIndexS((word) (&string20)), 16);
   (* (( (ptr) gf←c0195)+63)/* var←c15988 */  ) = var←c16916;
   (void) XR←ImportProcS(var←c16916, 67372289);
   var←c16916 = (word) XR←ImportInterface((word) "Rope", (word) XR←GetTypeIndexS((word) (&string21)), 43);
   (* (( (ptr) gf←c0195)+64)/* var←c16052 */  ) = var←c16916;
   (void) XR←ImportProcS(var←c16916, 67896323);
   var←c16916 = (word) XR←ExportInterface((word) "FunctionCache", (word) XR←GetTypeIndexS((word) (&string22)), 14);
   (* (( (ptr) gf←c0195)+65)/* var←c16948 */  ) = var←c16916;
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+220)/* var←c15348 */ , 67633154, (word) "Create");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+196)/* var←c15252 */ , 68419845, (word) "Eval");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+188)/* var←c15220 */ , 1311237, (word) "Insert");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+172)/* var←c15156 */ , 67371777, (word) "Any");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+204)/* var←c15284 */ , 67896323, (word) "Equal");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+180)/* var←c15188 */ , 135005443, (word) "Lookup");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+164)/* var←c15124 */ , 68158980, (word) "Obtain");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+156)/* var←c15092 */ , 526082, (word) "Release");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+148)/* var←c15060 */ , 264193, (word) "Flush");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+140)/* var←c15028 */ , 268699905, (word) "GetInfo");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+132)/* var←c14996 */ , 67373569, (word) "GetList");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+124)/* var←c14964 */ , 789251, (word) "SetLimits");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+116)/* var←c14932 */ , 789507, (word) "SetValueSize");
   (void) XR←ExportProcS(var←c16916, (word) (( (bPt) gf←c0195)+92)/* var←c14836 */ , 67112192, (word) "GlobalCache");
   }

static void FunctionCacheImpl←P0(formal←c035, formal←c034)
   word formal←c035;
   word formal←c034;
   {
   register ptr gf←c16980 =  (ptr) &globalframe;
   /* FunctionCacheImpl: */ 
SOURCE(197, 6754)
SOURCE(5630, 23)
   (* (( (ptr) gf←c16980)+5)/* triggerSize←v3140 */  ) = 8000;
SOURCE(6334, 98)
   (* (( (ptr) gf←c16980)+7)/* globalCache←v3252 */  ) = (word) Create←P60(100, 1000000);
   }

static word Create←P60(maxEntries←v3360, maxTotalSize←v3388)
   word maxEntries←v3360;
   word maxTotalSize←v3388;
   {
   register ptr gf←c17012 =  (ptr) &globalframe;
   word var←c3432;
   /* Create: */ 
SOURCE(331, 218)
SOURCE(408, 141)
   {
      word var←c15540;
      word var←c15572;
      word var←c15508;
      word var←c15604;
      var←c15540 = XR←NewObject(20, (* (( (ptr) gf←c17012)+10) ));
      var←c15572 = var←c15540;
      (*  (W4Pt) var←c15572 ) = (*  (W4Pt) (( (ptr) gf←c17012)+59)/* var←c15444 */  );
      var←c15508 = var←c15540;
      var←c15604 = XR←NewObject(36, (* (( (ptr) gf←c17012)+9) ));
      (* (( (ptr) var←c15604)+5) ) = maxEntries←v3360;
      (* (( (ptr) var←c15604)+7) ) = maxTotalSize←v3388;
      (* (( (ptr) var←c15604)+8) ) = var←c15508;
      return(var←c15604);
      };
   }

static word ListCompare←P120(a←v3592, b←v3620, match←v3648)
   word a←v3592;
   word b←v3620;
   word match←v3648;
   {
   word var←c3692;
   /* ListCompare: */ 
SOURCE(610, 213)
SOURCE(674, 126)
   lab←L100002: ;
   if ( ( (a←v3592 != 0) ? (b←v3620 != 0) : 0 ) ) {
      }
   else {
      goto lab←L100000;
      };
SOURCE(698, 102)
   if (((*  (ptr) a←v3592 ) == (*  (ptr) b←v3620 )) || (0 != (word) Equal←P180((*  (ptr) a←v3592 ), (*  (ptr) b←v3620 ), match←v3648)
   )) {
SOURCE(757, 10)
      a←v3592 = (* (( (ptr) a←v3592)+1) );
SOURCE(769, 10)
      b←v3620 = (* (( (ptr) b←v3620)+1) );
      }
   else {
SOURCE(786, 14)
      return(0);
      };
   goto lab←L100002;
   lab←L100000: ;
SOURCE(811, 12)
   return( (unsigned) (a←v3592 == b←v3620));
   }

static word Equal←P180(a←v3752, b←v3780, match←v3808)
   word a←v3752;
   word b←v3780;
   word match←v3808;
   {
   register ptr gf←c17044 =  (ptr) &globalframe;
   word var←c3852;
   /* Equal: */ 
SOURCE(829, 750)
SOURCE(896, 27)
   if ((a←v3752 == b←v3780)) {
SOURCE(910, 13)
      return(1);
      };
SOURCE(925, 35)
   if ((match←v3808 == 0)) {
SOURCE(946, 14)
      return(0);
      };
SOURCE(962, 583)
   {
      word var←c15636;
      word var←c15668;
      var←c15636 = a←v3752;
      if ((var←c15636 == 0)) {
         goto lab←L100003;
         };
      var←c15668 = XR←GetReferentType(var←c15636);
      {
         word tc29;
         if (((* (( (ptr) gf←c17044)+12) ) == var←c15668)) {
            {
               word x←v5912;
               x←v5912 = var←c15636;
SOURCE(995, 47)
               {
                  word var←c15700;
                  var←c15700 = b←v3780;
                  if ((var←c15700 == 0)) {
                     goto lab←L100004;
                     };
                  if (((* (( (ptr) gf←c17044)+12) ) == XR←GetReferentType(var←c15700))) {
                     {
                        word y←v5968;
                        y←v5968 = var←c15700;
SOURCE(1028, 14)
                        return( (unsigned) ( (int)(*  (ptr) x←v5912 ) ==  (int)(*  (ptr) y←v5968 )));
                        };
                     }
                  else {
                     lab←L100004: ;
                     };
                  };
               };
            goto endif023;
            };
         if (((* (( (ptr) gf←c17044)+13) ) == var←c15668)) {
            {
               word x←v6024;
               x←v6024 = var←c15636;
SOURCE(1068, 48)
               {
                  word var←c15732;
                  var←c15732 = b←v3780;
                  if ((var←c15732 == 0)) {
                     goto lab←L100005;
                     };
                  if (((* (( (ptr) gf←c17044)+13) ) == XR←GetReferentType(var←c15732))) {
                     {
                        word y←v6080;
                        y←v6080 = var←c15732;
SOURCE(1102, 14)
                        {
                           word x24;
                           word x25;
                           return( (unsigned) ((
/*1*/   x24 = (*  (ptr) x←v6024 ),  *(float*)&x24
/*1*/   ) == (
/*1*/   x25 = (*  (ptr) y←v6080 ),  *(float*)&x25
/*1*/   )));
                           };
                        };
                     }
                  else {
                     lab←L100005: ;
                     };
                  };
               };
            goto endif023;
            };
         if (((* (( (ptr) gf←c17044)+14) ) == var←c15668)) {
            {
               word x←v6136;
               x←v6136 = var←c15636;
SOURCE(1142, 110)
               {
                  word var←c15764;
                  var←c15764 = b←v3780;
                  if ((var←c15764 == 0)) {
                     goto lab←L100006;
                     };
                  if (((* (( (ptr) gf←c17044)+14) ) == XR←GetReferentType(var←c15764))) {
                     {
                        word y←v6192;
                        y←v6192 = var←c15764;
SOURCE(1176, 76)
                        {
                           word var←c0214;
                           if ((match←v3808 == 1)) {
/*1*/   var←c0214 =  (unsigned) ((*  (ptr) x←v6136 ) == (*  (ptr) y←v6192 ));
/*1*/   }
                           else {
/*1*/   {
/*1*/      word var←c15828;
/*1*/      word ch←v14756;
/*1*/      word var←c15860;
/*1*/      word ch←v14708;
/*1*/      ch←v14756 = (*  (ptr) x←v6136 );
/*1*/      if (((ch←v14756 - 65) <= 25)) {
/*1*/         var←c15828 = (ch←v14756 + 32);
/*1*/         }
/*1*/      else {
/*1*/         var←c15828 = ch←v14756;
/*1*/         };
/*1*/      ch←v14708 = (*  (ptr) y←v6192 );
/*1*/      if (((ch←v14708 - 65) <= 25)) {
/*1*/         var←c15860 = (ch←v14708 + 32);
/*1*/         }
/*1*/      else {
/*1*/         var←c15860 = ch←v14708;
/*1*/         };
/*1*/      var←c0214 =  (unsigned) (var←c15828 == var←c15860);
/*1*/      };
/*1*/   };
                           return(var←c0214);
                           };
                        };
                     }
                  else {
                     lab←L100006: ;
                     };
                  };
               };
            goto endif023;
            };
         if (((* (( (ptr) gf←c17044)+15) ) == var←c15668)) {
            {
               word x←v6248;
               x←v6248 = var←c15636;
SOURCE(1274, 97)
               {
                  word var←c15892;
                  var←c15892 = b←v3780;
                  if ((var←c15892 == 0)) {
                     goto lab←L100009;
                     };
                  if (((* (( (ptr) gf←c17044)+15) ) == XR←GetReferentType(var←c15892))) {
                     {
                        word y←v6292;
                        y←v6292 = var←c15892;
SOURCE(1304, 67)
                        {
                           word var←c15956;
                           word var←c16020;
                           {
/*1*/   word pd26;
/*1*/   pd26 = (* (( (ptr) (* (( (ptr) gf←c17044)+63)/* var←c15988 */  ))+9) );
/*1*/   var←c15956 = (word) ( *( (fPt) ((*  (ptr) pd26 ))))(x←v6248, pd26);
/*1*/   };
                           {
/*1*/   word pd27;
/*1*/   pd27 = (* (( (ptr) (* (( (ptr) gf←c17044)+63)/* var←c15988 */  ))+9) );
/*1*/   var←c16020 = (word) ( *( (fPt) ((*  (ptr) pd27 ))))(y←v6292, pd27);
/*1*/   };
                           {
/*1*/   word pd28;
/*1*/   pd28 = (* (( (ptr) (* (( (ptr) gf←c17044)+64)/* var←c16052 */  ))+8) );
/*1*/   return((word) ( *( (fPt) ((*  (ptr) pd28 ))))(var←c15956, var←c16020,  (unsigned) (match←v3808 != 2), pd28));
/*1*/   };
                           };
                        };
                     }
                  else {
                     lab←L100009: ;
                     };
                  };
               };
            goto endif023;
            };
         if (((* (( (ptr) gf←c17044)+16) ) == var←c15668)) {
            tc29 =  (word) ( (unsigned) (*(int*)var←c15636<0) == 0);
            }
         else {
            tc29 =  (word) 0;
            };
         if (tc29) {
            {
               word x←v6336;
               x←v6336 = var←c15636;
SOURCE(1393, 67)
               {
                  word var←c16084;
                  var←c16084 = b←v3780;
                  if ((var←c16084 == 0)) {
                     goto lab←L100010;
                     };
                  {
                     word tc30;
                     if (((* (( (ptr) gf←c17044)+16) ) == XR←GetReferentType(var←c16084))) {
                        tc30 =  (word) ( (unsigned) (*(int*)var←c16084<0) == 0);
                        }
                     else {
                        tc30 =  (word) 0;
                        };
                     if (tc30) {
                        {
                           word y←v6380;
                           y←v6380 = var←c16084;
SOURCE(1423, 37)
                           {
/*1*/   word pd31;
/*1*/   pd31 = (* (( (ptr) (* (( (ptr) gf←c17044)+64)/* var←c16052 */  ))+8) );
/*1*/   return((word) ( *( (fPt) ((*  (ptr) pd31 ))))(x←v6336, y←v6380,  (unsigned) (match←v3808 != 2), pd31));
/*1*/   };
                           };
                        }
                     else {
                        lab←L100010: ;
                        };
                     };
                  };
               };
            goto endif023;
            };
         if (((* (( (ptr) gf←c17044)+17) ) == var←c15668)) {
            {
               word x←v6424;
               x←v6424 = var←c15636;
SOURCE(1482, 63)
               {
                  word var←c16148;
                  var←c16148 = b←v3780;
                  if ((var←c16148 == 0)) {
                     goto lab←L100011;
                     };
                  if (((* (( (ptr) gf←c17044)+17) ) == XR←GetReferentType(var←c16148))) {
                     {
                        word y←v6468;
                        y←v6468 = var←c16148;
SOURCE(1512, 33)
                        return((word) ListCompare←P120(x←v6424, y←v6468, match←v3808));
                        };
                     }
                  else {
                     lab←L100011: ;
                     };
                  };
               };
            goto endif023;
            };
         lab←L100003: ;
         goto endif023;
         endif023: ;
         };
      };
SOURCE(1565, 14)
   return(0);
   }

static word Eval←P240(x←v3912, F←v3940, formal←c0225, formal←c0226, clientID←v4024)
   word x←v3912;
   word F←v3940;
   word formal←c0225;
   word formal←c0226;
   word clientID←v4024;
   {
   W10 var←c17076;
   /* declaration of arg←v3968 skipped */ 
   /* declaration of match←v3996 skipped */ 
   word value←v4068;
   /* declaration of var←c16212 skipped */ 
   /* declaration of var←c16244 skipped */ 
   word ok←v6568;
   (* (( (ptr) &var←c17076)+4)/* arg←v3968 */  ) = formal←c0225;
   (* (( (ptr) &var←c17076)+5)/* match←v3996 */  ) = formal←c0226;
   /* Eval: */ 
SOURCE(1585, 475)
   {
      word tmpAddr32;
      tmpAddr32 = (word) (( (ptr) &var←c17076)+6)/* var←c16212 */ ;
      (*  (ptr) tmpAddr32 ) = ( ((word)  (fPt) fancyCompare←P1836) );
      (* (( (ptr) tmpAddr32) + 1) ) = 1;
      };
   {
      word tmpAddr33;
      tmpAddr33 = (word) (( (ptr) &var←c17076)+8)/* var←c16244 */ ;
      (*  (ptr) tmpAddr33 ) = ( ((word)  (fPt) refCompare←P1776) );
      (* (( (ptr) tmpAddr33) + 1) ) = 1;
      };
SOURCE(1585, 475)
   value←v4068 = 0;
SOURCE(1851, 82)
   {
      W2 var←c16276;
      (void) Lookup←P360((word) &var←c16276, x←v3912,  ( ((* (( (ptr) &var←c17076)+5)/* match←v3996 */  ) == 0) ? (word) (( (bPt) &var←c17076)+32)
         /* var←c16244 */  : (word) (( (bPt) &var←c17076)+24)/* var←c16212 */  ) , clientID←v4024);
      ok←v6568 = var←c16276.f1;
      value←v4068 = var←c16276.f0;
      };
SOURCE(1935, 125)
   if ((0 == ok←v6568)) {
SOURCE(1950, 112)
      {
         word size←v6612;
SOURCE(1963, 22)
         {
            W2 var←c16308;
            (void) ( *( (fPt) ((*  (ptr) F←v3940 ))))((word) &var←c16308, (* (( (ptr) &var←c17076)+4)/* arg←v3968 */  ), F←v3940);
            size←v6612 = var←c16308.f1;
            value←v4068 = var←c16308.f0;
            };
SOURCE(1987, 73)
         (void) Insert←P300(x←v3912, (* (( (ptr) &var←c17076)+4)/* arg←v3968 */  ), value←v4068, size←v6612, clientID←v4024);
         };
      };
SOURCE(1585, 475)
   return(value←v4068);
   }

static word refCompare←P1776(argument←v13864, formal←c17108)
   word argument←v13864;
   word formal←c17108;
   {
   word good←v13908;
   formal←c17108 = (formal←c17108 - 32);
   /* refCompare: */ 
SOURCE(1707, 48)
SOURCE(1734, 21)
   good←v13908 =  (unsigned) ((* (( (ptr) formal←c17108)+4) ) == argument←v13864);
SOURCE(1707, 48)
   return(good←v13908);
   }

static word fancyCompare←P1836(argument←v13968, formal←c17140)
   word argument←v13968;
   word formal←c17140;
   {
   word good←v14012;
   formal←c17140 = (formal←c17140 - 24);
   /* fancyCompare: */ 
SOURCE(1758, 80)
SOURCE(1787, 51)
   if (((* (( (ptr) formal←c17140)+4) ) == argument←v13968)) {
      good←v14012 =  (unsigned) 1;
      }
   else {
      good←v14012 =  (unsigned) (0 != (word) Equal←P180((* (( (ptr) formal←c17140)+4) ), argument←v13968, (* (( (ptr) formal←c17140)+5)
          )));
      };
SOURCE(1758, 80)
   return(good←v14012);
   }

static void Insert←P300(x←v4128, argument←v4156, value←v4184, size←v4212, clientID←v4240)
   word x←v4128;
   word argument←v4156;
   word value←v4184;
   word size←v4212;
   word clientID←v4240;
   {
   register ptr gf←c17172 =  (ptr) &globalframe;
   /* Insert: */ 
SOURCE(2069, 289)
   (void) (XR←MonitorEntry(x←v4128));
SOURCE(2173, 109)
   {
      word var←c16340;
      var←c16340 = XR←NewObject(20, (* (( (ptr) gf←c17172)+10) ));
      (*  (ptr) var←c16340 ) = clientID←v4240;
      (* (( (ptr) var←c16340)+1) ) = argument←v4156;
      (* (( (ptr) var←c16340)+2) ) = value←v4184;
      (* (( (ptr) var←c16340)+3) ) = size←v4212;
      (* (( (ptr) var←c16340)+4) ) = (* (( (ptr) (* (( (ptr) x←v4128)+8) ))+4) );
      (* (( (ptr) (* (( (ptr) x←v4128)+8) ))+4) ) = var←c16340;
      };
SOURCE(2284, 27)
   (* (( (ptr) x←v4128)+4) ) = ((* (( (ptr) x←v4128)+4) ) + 1);
SOURCE(2313, 32)
   (* (( (ptr) x←v4128)+6) ) = ((* (( (ptr) x←v4128)+6) ) + size←v4212);
SOURCE(2347, 11)
   {
      word x←v14660;
      x←v14660 = x←v4128;
SOURCE(5474, 32)
      if ((0 != (* (( (ptr) gf←c17172)+4)/* debug←v3084 */  ))) {
SOURCE(5488, 18)
         (void) CheckInvariants←P900(x←v14660);
         };
SOURCE(5508, 82)
      if (( (int)(* (( (ptr) x←v14660)+4) ) >  (int)(* (( (ptr) x←v14660)+5) )) || ( (int)(* (( (ptr) x←v14660)+6) ) >  (int)(* (
         ( (ptr) x←v14660)+7) ))) {
SOURCE(5574, 16)
         (void) EnforceLimits←P1020(x←v14660);
         };
SOURCE(5592, 32)
      if ((0 != (* (( (ptr) gf←c17172)+4)/* debug←v3084 */  ))) {
SOURCE(5606, 18)
         (void) CheckInvariants←P900(x←v14660);
         };
      };
SOURCE(2069, 289)
   (void) (XR←MonitorExit(x←v4128));
   return;
   }

static void Lookup←P360(formal←c0107, formal←c0227, formal←c0228, formal←c0229)
   word formal←c0107;
   word formal←c0227;
   word formal←c0228;
   word formal←c0229;
   {
   W9 var←c17204;
   /* declaration of x←v4300 skipped */ 
   /* declaration of compare←v4328 skipped */ 
   /* declaration of clientID←v4356 skipped */ 
   /* declaration of value←v4400 skipped */ 
   /* declaration of ok←v4428 skipped */ 
   (* (( (ptr) &var←c17204)+4)/* x←v4300 */  ) = formal←c0227;
   (* (( (ptr) &var←c17204)+5)/* compare←v4328 */  ) = formal←c0228;
   (* (( (ptr) &var←c17204)+6)/* clientID←v4356 */  ) = formal←c0229;
   /* Lookup: */ 
SOURCE(2364, 619)
   (void) (XR←MonitorEntry(* (( (ptr) &var←c17204)+4)/* x←v4300 */  ));
SOURCE(2364, 619)
   (* (( (ptr) &var←c17204)+7)/* value←v4400 */  ) = 0;
SOURCE(2486, 497)
   {
      word var←c01;
      {
         word var←c0215;
         var←c0215 = (word) &var←c17204;
         var←c01 = (word) XR←Enable(( ((word)  (fPt) NoName←Q2940) ), ( ((word)  (fPt) NoName←Q3120) ), var←c0215);
         };
      /* removed trivial cond node */ 
      };
   (void) (XR←MonitorExit(* (( (ptr) &var←c17204)+4)/* x←v4300 */  ));
   (*  (ptr) formal←c0107 ) = (* (( (ptr) &var←c17204)+7)/* value←v4400 */  );
   (* (( (ptr) formal←c0107)+1) ) = (* (( (ptr) &var←c17204)+8)/* ok←v4428 */  );
   return;
   }

static word NoName←Q2940(formal←c0202)
   word formal←c0202;
   {
SOURCE(2509, 6)
   {
      word prev←v6656;
      word p←v6684;
SOURCE(2509, 6)
      prev←v6656 = (* (( (ptr) (* (( (ptr) formal←c0202)+4) ))+8) );
SOURCE(2549, 3)
      p←v6684 = (* (( (ptr) prev←v6656)+4) );
SOURCE(2584, 133)
      if ((p←v6684 != 0)) {
SOURCE(2602, 105)
         {
            word tc34;
            word pd35;
            if (((*  (ptr) p←v6684 ) == (* (( (ptr) formal←c0202)+6) ))) {
               pd35 = (* (( (ptr) formal←c0202)+5) );
               tc34 =  (word) (0 != (word) ( *( (fPt) ((*  (ptr) pd35 ))))((* ((( (ptr) p←v6684)+1)) ), pd35));
               }
            else {
               tc34 =  (word) 0;
               };
            if (tc34) {
SOURCE(2668, 39)
               (* (( (ptr) formal←c0202)+7) ) = (* (( (ptr) p←v6684)+2) );
               (* (( (ptr) formal←c0202)+8) ) = 1;
               return(2);
               };
            };
SOURCE(2709, 8)
         prev←v6656 = p←v6684;
         };
SOURCE(2722, 220)
      lab←L100018: ;
      p←v6684 = (* (( (ptr) prev←v6656)+4) );
      if ((p←v6684 != 0)) {
         }
      else {
         goto lab←L100016;
         };
SOURCE(2753, 176)
      {
         word tc36;
         word pd37;
         if (((*  (ptr) p←v6684 ) == (* (( (ptr) formal←c0202)+6) ))) {
            pd37 = (* (( (ptr) formal←c0202)+5) );
            tc36 =  (word) (0 != (word) ( *( (fPt) ((*  (ptr) pd37 ))))((* ((( (ptr) p←v6684)+1)) ), pd37));
            }
         else {
            tc36 =  (word) 0;
            };
         if (tc36) {
SOURCE(2821, 18)
            (* (( (ptr) prev←v6656)+4) ) = (* (( (ptr) p←v6684)+4) );
SOURCE(2841, 25)
            (* (( (ptr) p←v6684)+4) ) = (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c0202)+4) ))+8) ))+4) );
SOURCE(2868, 20)
            (* (( (ptr) (* (( (ptr) (* (( (ptr) formal←c0202)+4) ))+8) ))+4) ) = p←v6684;
SOURCE(2890, 39)
            (* (( (ptr) formal←c0202)+7) ) = (* (( (ptr) p←v6684)+2) );
            (* (( (ptr) formal←c0202)+8) ) = 1;
            return(2);
            };
         };
SOURCE(2934, 8)
      prev←v6656 = p←v6684;
      goto lab←L100018;
      lab←L100016: ;
SOURCE(2953, 30)
      (* (( (ptr) formal←c0202)+7) ) = 0;
      (* (( (ptr) formal←c0202)+8) ) = 0;
      return(2);
      };
   /* c2c skipped dead code */ 
   }

static word Any←P420(argument←v10844)
   word argument←v10844;
   {
   word good←v10888;
   /* Any: */ 
SOURCE(2989, 40)
SOURCE(3016, 13)
   return(1);
   }

static word Obtain←P480(formal←c0230, formal←c0231, formal←c0232, formal←c0233)
   word formal←c0230;
   word formal←c0231;
   word formal←c0232;
   word formal←c0233;
   {
   W9 var←c17236;
   /* declaration of x←v4488 skipped */ 
   /* declaration of compare←v4516 skipped */ 
   /* declaration of limit←v4544 skipped */ 
   /* declaration of clientID←v4572 skipped */ 
   /* declaration of var←c02 skipped */ 
   word var←c4616;
   (* (( (ptr) &var←c17236)+4)/* x←v4488 */  ) = formal←c0230;
   (* (( (ptr) &var←c17236)+5)/* compare←v4516 */  ) = formal←c0231;
   (* (( (ptr) &var←c17236)+6)/* limit←v4544 */  ) = formal←c0232;
   (* (( (ptr) &var←c17236)+7)/* clientID←v4572 */  ) = formal←c0233;
   /* Obtain: */ 
SOURCE(3033, 666)
   (void) (XR←MonitorEntry(* (( (ptr) &var←c17236)+4)/* x←v4488 */  ));
SOURCE(3157, 542)
   {
      word var←c03;
      {
         word var←c0216;
         var←c0216 = (word) &var←c17236;
         var←c03 = (word) XR←Enable(( ((word)  (fPt) NoName←Q3000) ), ( ((word)  (fPt) NoName←Q3060) ), var←c0216);
         };
      /* removed trivial cond node */ 
      };
   return((* (( (ptr) &var←c17236)+8)/* var←c02 */  ));
   }

static word NoName←Q3000(formal←c0204)
   word formal←c0204;
   {
   register ptr gf←c0203 =  (ptr) &globalframe;
SOURCE(3180, 6)
   {
      word list←v6896 = 0;
      word end←v6924 = 0;
      word prev←v6952;
      word p←v6980;
SOURCE(3243, 6)
      prev←v6952 = (* (( (ptr) (* (( (ptr) formal←c0204)+4) ))+8) );
SOURCE(3283, 3)
      p←v6980 = (* (( (ptr) prev←v6952)+4) );
SOURCE(3318, 323)
      lab←L100023: ;
      if ( ( ( (int)(* (( (ptr) formal←c0204)+6) ) !=  (int)0) ? (p←v6980 != 0) : 0 ) ) {
         }
      else {
         goto lab←L100021;
         };
SOURCE(3348, 293)
      {
         word tc38;
         word pd39;
         if (((*  (ptr) p←v6980 ) == (* (( (ptr) formal←c0204)+7) ))) {
            pd39 = (* (( (ptr) formal←c0204)+5) );
            tc38 =  (word) (0 != (word) ( *( (fPt) ((*  (ptr) pd39 ))))((* ((( (ptr) p←v6980)+1)) ), pd39));
            }
         else {
            tc38 =  (word) 0;
            };
         if (tc38) {
SOURCE(3416, 27)
            (* (( (ptr) (* (( (ptr) formal←c0204)+4) ))+4) ) = ((* (( (ptr) (* (( (ptr) formal←c0204)+4) ))+4) ) - 1);
SOURCE(3445, 40)
            (* (( (ptr) (* (( (ptr) formal←c0204)+4) ))+6) ) = ((* (( (ptr) (* (( (ptr) formal←c0204)+4) ))+6) ) - (* (( (ptr) p←v6980)+3)
             ));
SOURCE(3487, 62)
            if ((end←v6924 == 0)) {
SOURCE(3506, 14)
               list←v6896 = p←v6980;
               end←v6924 = p←v6980;
               }
            else {
SOURCE(3528, 12)
               (* (( (ptr) end←v6924)+4) ) = p←v6980;
SOURCE(3542, 7)
               end←v6924 = p←v6980;
               };
SOURCE(3552, 22)
            {
               word var←c16468;
               var←c16468 = (* (( (ptr) p←v6980)+4) );
               (* (( (ptr) prev←v6952)+4) ) = var←c16468;
               p←v6980 = var←c16468;
               };
SOURCE(3576, 14)
            (* (( (ptr) end←v6924)+4) ) = 0;
SOURCE(3592, 15)
            (* (( (ptr) formal←c0204)+6) ) = ((* (( (ptr) formal←c0204)+6) ) - 1);
            }
         else {
SOURCE(3618, 8)
            prev←v6952 = p←v6980;
SOURCE(3628, 13)
            p←v6980 = (* (( (ptr) prev←v6952)+4) );
            };
         };
      goto lab←L100023;
      lab←L100021: ;
SOURCE(3655, 28)
      if ((list←v6896 != 0)) {
SOURCE(3672, 11)
         {
            word x←v14612;
            x←v14612 = (* (( (ptr) formal←c0204)+4) );
SOURCE(5474, 32)
            if ((0 != (* (( (ptr) gf←c0203)+4)/* debug←v3084 */  ))) {
SOURCE(5488, 18)
               (void) CheckInvariants←P900(x←v14612);
               };
SOURCE(5508, 82)
            if (( (int)(* (( (ptr) x←v14612)+4) ) >  (int)(* (( (ptr) x←v14612)+5) )) || ( (int)(* (( (ptr) x←v14612)+6) ) >  (int)(* (
               ( (ptr) x←v14612)+7) ))) {
SOURCE(5574, 16)
               (void) EnforceLimits←P1020(x←v14612);
               };
SOURCE(5592, 32)
            if ((0 != (* (( (ptr) gf←c0203)+4)/* debug←v3084 */  ))) {
SOURCE(5606, 18)
               (void) CheckInvariants←P900(x←v14612);
               };
            };
         };
SOURCE(3685, 14)
      (void) (XR←MonitorExit(* (( (ptr) formal←c0204)+4) ));
      (* (( (ptr) formal←c0204)+8) ) = list←v6896;
      return(1);
      };
   /* c2c skipped dead code */ 
   }

static void Release←P540(x←v4760, list←v4788)
   word x←v4760;
   word list←v4788;
   {
   register ptr gf←c17268 =  (ptr) &globalframe;
   /* Release: */ 
SOURCE(3703, 304)
   (void) (XR←MonitorEntry(x←v4760));
SOURCE(3771, 236)
   if ((list←v4788 != 0)) {
SOURCE(3790, 219)
      {
         word p←v7360;
SOURCE(3792, 3)
         p←v7360 = list←v4788;
SOURCE(3822, 111)
         lab←L100026: ;
SOURCE(3825, 27)
         (* (( (ptr) x←v4760)+4) ) = ((* (( (ptr) x←v4760)+4) ) + 1);
SOURCE(3854, 40)
         (* (( (ptr) x←v4760)+6) ) = ((* (( (ptr) x←v4760)+6) ) + (* (( (ptr) p←v7360)+3) ));
SOURCE(3896, 21)
         if (((* (( (ptr) p←v7360)+4) ) == 0)) {
SOURCE(3917, 4)
            goto lab←L100025;
            };
SOURCE(3923, 10)
         p←v7360 = (* (( (ptr) p←v7360)+4) );
         goto lab←L100026;
         lab←L100025: ;
SOURCE(3944, 25)
         (* (( (ptr) p←v7360)+4) ) = (* (( (ptr) (* (( (ptr) x←v4760)+8) ))+4) );
SOURCE(3971, 23)
         (* (( (ptr) (* (( (ptr) x←v4760)+8) ))+4) ) = list←v4788;
SOURCE(3996, 11)
         {
            word x←v14564;
            x←v14564 = x←v4760;
SOURCE(5474, 32)
            if ((0 != (* (( (ptr) gf←c17268)+4)/* debug←v3084 */  ))) {
SOURCE(5488, 18)
               (void) CheckInvariants←P900(x←v14564);
               };
SOURCE(5508, 82)
            if (( (int)(* (( (ptr) x←v14564)+4) ) >  (int)(* (( (ptr) x←v14564)+5) )) || ( (int)(* (( (ptr) x←v14564)+6) ) >  (int)(* (
               ( (ptr) x←v14564)+7) ))) {
SOURCE(5574, 16)
               (void) EnforceLimits←P1020(x←v14564);
               };
SOURCE(5592, 32)
            if ((0 != (* (( (ptr) gf←c17268)+4)/* debug←v3084 */  ))) {
SOURCE(5606, 18)
               (void) CheckInvariants←P900(x←v14564);
               };
            };
         };
      };
SOURCE(3703, 304)
   (void) (XR←MonitorExit(x←v4760));
   return;
   }

static void Flush←P600(x←v4932)
   word x←v4932;
   {
   word entries←v7488;
   /* Flush: */ 
SOURCE(4016, 243)
   (void) (XR←MonitorEntry(x←v4932));
SOURCE(4056, 9)
   entries←v7488 = (* (( (ptr) (* (( (ptr) x←v4932)+8) ))+4) );
SOURCE(4104, 14)
   (* (( (ptr) x←v4932)+4) ) = 0;
SOURCE(4120, 15)
   (* (( (ptr) x←v4932)+6) ) = 0;
SOURCE(4137, 22)
   (* (( (ptr) (* (( (ptr) x←v4932)+8) ))+4) ) = 0;
SOURCE(4161, 98)
   lab←L100029: ;
   if ((entries←v7488 != 0)) {
      }
   else {
      goto lab←L100027;
      };
   {
      word rest←v7616;
SOURCE(4184, 6)
      rest←v7616 = (* (( (ptr) entries←v7488)+4) );
SOURCE(4225, 18)
      (* (( (ptr) entries←v7488)+4) ) = 0;
SOURCE(4245, 14)
      entries←v7488 = rest←v7616;
      };
   goto lab←L100029;
   lab←L100027: ;
SOURCE(4016, 243)
   (void) (XR←MonitorExit(x←v4932));
   return;
   }

static void GetInfo←P660(formal←c0137, x←v4992)
   word formal←c0137;
   word x←v4992;
   {
   word var←c0235;
   word var←c0236;
   word var←c0237;
   word var←c0238;
   /* GetInfo: */ 
SOURCE(4274, 174)
   /* Return var split */ 
   (void) (XR←MonitorEntry(x←v4992));
SOURCE(4336, 112)
   var←c0235 = (* (( (ptr) x←v4992)+4) );
   var←c0236 = (* (( (ptr) x←v4992)+5) );
   var←c0237 = (* (( (ptr) x←v4992)+6) );
   var←c0238 = (* (( (ptr) x←v4992)+7) );
   /* removed tail goto */ 
   (void) (XR←MonitorExit(x←v4992));
   (* (( (ptr) formal←c0137)+3) ) = var←c0238;
   (* (( (ptr) formal←c0137)+2) ) = var←c0237;
   (* (( (ptr) formal←c0137)+1) ) = var←c0236;
   (*  (ptr) formal←c0137 ) = var←c0235;
   return;
   }

static word GetList←P720(x←v5096)
   word x←v5096;
   {
   register ptr gf←c17300 =  (ptr) &globalframe;
   word list←v5140;
   word end←v7744 = 0;
   /* GetList: */ 
SOURCE(4452, 264)
   (void) (XR←MonitorEntry(x←v5096));
SOURCE(4452, 264)
   list←v5140 = 0;
SOURCE(4560, 156)
   {
      register word p←v7872;
      p←v7872 = (* (( (ptr) x←v5096)+8) );
      lab←L100035: ;
      if ((p←v7872 != 0)) {
         }
      else {
         goto lab←L100032;
         };
SOURCE(4623, 93)
      if ((end←v7744 == 0)) {
SOURCE(4642, 26)
         {
            word var←c16564;
            {
               word var←c16596;
               word var←c16628;
               var←c16596 = XR←NewObject(20, (* (( (ptr) gf←c17300)+10) ));
               var←c16628 = var←c16596;
               (*  (W4Pt) var←c16628 ) = (*  (W4Pt) p←v7872 );
               var←c16564 = var←c16596;
               };
            end←v7744 = var←c16564;
            list←v5140 = var←c16564;
            };
         }
      else {
SOURCE(4676, 24)
         {
            word var←c16660;
            word var←c16692;
            var←c16660 = XR←NewObject(20, (* (( (ptr) gf←c17300)+10) ));
            var←c16692 = var←c16660;
            (*  (W4Pt) var←c16692 ) = (*  (W4Pt) p←v7872 );
            (* (( (ptr) end←v7744)+4) ) = var←c16660;
            };
SOURCE(4702, 14)
         end←v7744 = (* (( (ptr) end←v7744)+4) );
         };
      p←v7872 = (* (( (ptr) p←v7872)+4) );
      goto lab←L100035;
      lab←L100032: ;
      };
SOURCE(4452, 264)
   (void) (XR←MonitorExit(x←v5096));
   return(list←v5140);
   }

static void SetLimits←P780(x←v5284, maxEntries←v5312, maxTotalSize←v5340)
   word x←v5284;
   word maxEntries←v5312;
   word maxTotalSize←v5340;
   {
   register ptr gf←c17332 =  (ptr) &globalframe;
   /* SetLimits: */ 
SOURCE(4732, 149)
   (void) (XR←MonitorEntry(x←v5284));
SOURCE(4812, 25)
   (* (( (ptr) x←v5284)+5) ) = maxEntries←v5312;
SOURCE(4839, 29)
   (* (( (ptr) x←v5284)+7) ) = maxTotalSize←v5340;
SOURCE(4870, 11)
   {
      word x←v14516;
      x←v14516 = x←v5284;
SOURCE(5474, 32)
      if ((0 != (* (( (ptr) gf←c17332)+4)/* debug←v3084 */  ))) {
SOURCE(5488, 18)
         (void) CheckInvariants←P900(x←v14516);
         };
SOURCE(5508, 82)
      if (( (int)(* (( (ptr) x←v14516)+4) ) >  (int)(* (( (ptr) x←v14516)+5) )) || ( (int)(* (( (ptr) x←v14516)+6) ) >  (int)(* (
         ( (ptr) x←v14516)+7) ))) {
SOURCE(5574, 16)
         (void) EnforceLimits←P1020(x←v14516);
         };
SOURCE(5592, 32)
      if ((0 != (* (( (ptr) gf←c17332)+4)/* debug←v3084 */  ))) {
SOURCE(5606, 18)
         (void) CheckInvariants←P900(x←v14516);
         };
      };
SOURCE(4732, 149)
   (void) (XR←MonitorExit(x←v5284));
   return;
   }

static void SetValueSize←P840(x←v5400, value←v5428, size←v5456)
   word x←v5400;
   word value←v5428;
   word size←v5456;
   {
   register ptr gf←c17364 =  (ptr) &globalframe;
   /* SetValueSize: */ 
SOURCE(4887, 267)
   (void) (XR←MonitorEntry(x←v5400));
SOURCE(4959, 170)
   {
      register word p←v8000;
      p←v8000 = (* (( (ptr) (* (( (ptr) x←v5400)+8) ))+4) );
      lab←L100039: ;
      if ((p←v8000 != 0)) {
         }
      else {
         goto lab←L100036;
         };
SOURCE(5029, 100)
      if (((* (( (ptr) p←v8000)+2) ) == value←v5428)) {
SOURCE(5061, 47)
         (* (( (ptr) x←v5400)+6) ) = (((* (( (ptr) x←v5400)+6) ) - (* (( (ptr) p←v8000)+3) )) + size←v5456);
SOURCE(5110, 19)
         (* (( (ptr) p←v8000)+3) ) = size←v5456;
         };
      p←v8000 = (* (( (ptr) p←v8000)+4) );
      goto lab←L100039;
      lab←L100036: ;
      };
SOURCE(5143, 11)
   {
      word x←v14468;
      x←v14468 = x←v5400;
SOURCE(5474, 32)
      if ((0 != (* (( (ptr) gf←c17364)+4)/* debug←v3084 */  ))) {
SOURCE(5488, 18)
         (void) CheckInvariants←P900(x←v14468);
         };
SOURCE(5508, 82)
      if (( (int)(* (( (ptr) x←v14468)+4) ) >  (int)(* (( (ptr) x←v14468)+5) )) || ( (int)(* (( (ptr) x←v14468)+6) ) >  (int)(* (
         ( (ptr) x←v14468)+7) ))) {
SOURCE(5574, 16)
         (void) EnforceLimits←P1020(x←v14468);
         };
SOURCE(5592, 32)
      if ((0 != (* (( (ptr) gf←c17364)+4)/* debug←v3084 */  ))) {
SOURCE(5606, 18)
         (void) CheckInvariants←P900(x←v14468);
         };
      };
SOURCE(4887, 267)
   (void) (XR←MonitorExit(x←v5400));
   return;
   }

static void CheckInvariants←P900(x←v5516)
   word x←v5516;
   {
   word n←v8128 = 0;
   word s←v8156 = 0;
   /* CheckInvariants: */ 
SOURCE(5160, 236)
SOURCE(5230, 101)
   {
      register word p←v8200;
      p←v8200 = (* (( (ptr) (* (( (ptr) x←v5516)+8) ))+4) );
      lab←L100043: ;
      if ((p←v8200 != 0)) {
         }
      else {
         goto lab←L100040;
         };
SOURCE(5300, 9)
      n←v8128 = (n←v8128 + 1);
SOURCE(5311, 20)
      s←v8156 = (s←v8156 + (* (( (ptr) p←v8200)+3) ));
      p←v8200 = (* (( (ptr) p←v8200)+4) );
      goto lab←L100043;
      lab←L100040: ;
      };
SOURCE(5342, 23)
   if (( (int)n←v8128 !=  (int)(* (( (ptr) x←v5516)+4) ))) {
SOURCE(5365, 5)
      (void) XR←RaiseUnnamedError();
      };
SOURCE(5372, 24)
   if (( (int)s←v8156 !=  (int)(* (( (ptr) x←v5516)+6) ))) {
SOURCE(5396, 5)
      (void) XR←RaiseUnnamedError();
      };
   }

static void EnforceLimits←P1020(x←v5636)
   word x←v5636;
   {
   register ptr gf←c17396 =  (ptr) &globalframe;
   word e←v8328 = 0;
   word s←v8356 = 0;
   word emax←v8384;
   word smax←v8412;
   word last←v8440;
   word p←v8468 = 0;
   /* EnforceLimits: */ 
SOURCE(5678, 577)
SOURCE(5746, 24)
   emax←v8384 = (* (( (ptr) x←v5636)+5) );
SOURCE(5772, 26)
   smax←v8412 = (* (( (ptr) x←v5636)+7) );
SOURCE(5800, 6)
   last←v8440 = (* (( (ptr) x←v5636)+8) );
SOURCE(5863, 111)
   lab←L100046: ;
   {
      word tc40;
      word tc41;
      p←v8468 = (* (( (ptr) last←v8440)+4) );
      if ((p←v8468 != 0)) {
         tc41 =  (word) ( (int)(e←v8328 + 1) <=  (int)emax←v8384);
         }
      else {
         tc41 =  (word) 0;
         };
      if (tc41) {
         tc40 =  (word) ( (int)(s←v8356 + (* (( (ptr) p←v8468)+3) )) <=  (int)smax←v8412);
         }
      else {
         tc40 =  (word) 0;
         };
      if (tc40) {
         }
      else {
         goto lab←L100044;
         };
      };
SOURCE(5933, 9)
   e←v8328 = (e←v8328 + 1);
SOURCE(5944, 20)
   s←v8356 = (s←v8356 + (* (( (ptr) p←v8468)+3) ));
SOURCE(5966, 8)
   last←v8440 = p←v8468;
   goto lab←L100046;
   lab←L100044: ;
SOURCE(5985, 43)
   (* (( (ptr) gf←c17396)+6)/* trimmedSize←v3168 */  ) = (((* (( (ptr) x←v5636)+6) ) - s←v8356) + (* (( (ptr) gf←c17396)+6)/* trimmedSize←v3168 */  ));
SOURCE(6030, 15)
   (* (( (ptr) last←v8440)+4) ) = 0;
SOURCE(6047, 14)
   (* (( (ptr) x←v5636)+4) ) = e←v8328;
SOURCE(6063, 15)
   (* (( (ptr) x←v5636)+6) ) = s←v8356;
SOURCE(6080, 113)
   lab←L100049: ;
   if ((p←v8468 != 0)) {
      }
   else {
      goto lab←L100047;
      };
   {
      word t←v8680;
SOURCE(6097, 3)
      t←v8680 = (* (( (ptr) p←v8468)+4) );
SOURCE(6129, 22)
      (* (( (ptr) p←v8468)+1) ) = 0;
SOURCE(6153, 19)
      (* (( (ptr) p←v8468)+2) ) = 0;
SOURCE(6174, 12)
      (* (( (ptr) p←v8468)+4) ) = 0;
SOURCE(6188, 5)
      p←v8468 = t←v8680;
      };
   goto lab←L100049;
   lab←L100047: ;
SOURCE(6204, 51)
   if (( (int)(* (( (ptr) gf←c17396)+6)/* trimmedSize←v3168 */  ) >  (int)(* (( (ptr) gf←c17396)+5)/* triggerSize←v3140 */  ))) {
SOURCE(6240, 15)
      (* (( (ptr) gf←c17396)+6)/* trimmedSize←v3168 */  ) = 0;
      };
   }

static word GlobalCache←P1080()
   {
   register ptr gf←c17428 =  (ptr) &globalframe;
   word var←c5696;
   /* GlobalCache: */ 
SOURCE(6264, 66)
SOURCE(6309, 21)
   return((* (( (ptr) gf←c17428)+7)/* globalCache←v3252 */  ));
   }

static word Example←P1140(formal←c0234)
   word formal←c0234;
   {
   W7 var←c17460;
   /* declaration of n←v5756 skipped */ 
   register ptr gf←c17492 =  (ptr) &globalframe;
   word result←v5800;
   /* declaration of var←c16724 skipped */ 
   word cache←v8808;
   word val←v8864 = 0;
   word ok←v8892;
   var←c17460.f4/* n←v5756 */  = formal←c0234;
   /* Example: */ 
SOURCE(6435, 516)
   {
      word tmpAddr42;
      tmpAddr42 = (word) (( (ptr) &var←c17460)+5)/* var←c16724 */ ;
      (*  (ptr) tmpAddr42 ) = ( ((word)  (fPt) compare←P2328) );
      (* (( (ptr) tmpAddr42) + 1) ) = 1;
      };
SOURCE(6435, 516)
   result←v5800 = 0;
SOURCE(6492, 28)
   cache←v8808 = (word) GlobalCache←P1080();
SOURCE(6661, 49)
   {
      W2 var←c16756;
      (void) Lookup←P360((word) &var←c16756, cache←v8808, (word) (( (bPt) &var←c17460)+20)/* var←c16724 */ , (* (( (ptr) gf←c17492)+20)
          ));
      ok←v8892 = var←c16756.f1;
      val←v8864 = var←c16756.f0;
      };
SOURCE(6712, 239)
   if ((0 != ok←v8892)) {
SOURCE(6723, 26)
      result←v5800 = XR←Narrow(val←v8864, (* (( (ptr) gf←c17492)+19) ));
      }
   else {
SOURCE(6751, 15)
      result←v5800 = 0;
SOURCE(6768, 59)
      {
         register word i←v8948;
         i←v8948 = var←c17460.f4/* n←v5756 */ ;
         if (( (int)1 >  (int)i←v8948)) {
            goto lab←L100050;
            };
         lab←L100053: ;
SOURCE(6803, 24)
         {
            word var←c16788;
            var←c16788 = XR←NewObject(8, (* (( (ptr) gf←c17492)+19) ));
            (*  (ptr) var←c16788 ) = i←v8948;
            (* (( (ptr) var←c16788)+1) ) = result←v5800;
            result←v5800 = var←c16788;
            };
         if (( (int)1 >=  (int)i←v8948)) {
            goto lab←L100050;
            };
         i←v8948 = (i←v8948 - 1);
         goto lab←L100053;
         lab←L100050: ;
         };
SOURCE(6838, 113)
      {
         word var←c16820;
         {
            word var←c16852;
            var←c16852 = XR←NewObject(4, (* (( (ptr) gf←c17492)+12) ));
            (*  (ptr) var←c16852 ) = var←c17460.f4/* n←v5756 */ ;
            var←c16820 = var←c16852;
            };
         (void) Insert←P300(cache←v8808, var←c16820, result←v5800, IOP2( * ,  (int)var←c17460.f4/* n←v5756 */ ,  (int)10), (* (( (ptr) gf←c17492)+20)
             ));
         };
      };
SOURCE(6435, 516)
   return(result←v5800);
   }

static word compare←P2328(argument←v14232, formal←c17556)
   word argument←v14232;
   word formal←c17556;
   {
   register ptr gf←c17524 =  (ptr) &globalframe;
   word good←v14276;
   formal←c17556 = (formal←c17556 - 20);
   /* compare: */ 
SOURCE(6522, 105)
SOURCE(6547, 12)
   good←v14276 = 0;
SOURCE(6561, 66)
   {
      word var←c16884;
      var←c16884 = argument←v14232;
      if ((var←c16884 == 0)) {
         goto lab←L100054;
         };
      if (((* (( (ptr) gf←c17524)+12) ) == XR←GetReferentType(var←c16884))) {
         {
            word i←v9004;
            i←v9004 = var←c16884;
SOURCE(6601, 26)
            if (( (int)(*  (ptr) i←v9004 ) ==  (int)(* (( (ptr) formal←c17556)+4) ))) {
SOURCE(6616, 11)
               good←v14276 = 1;
               };
            };
         }
      else {
         lab←L100054: ;
         };
      };
SOURCE(6522, 105)
   return(good←v14276);
   }

static void NoName←Q3060(formal←c0189, formal←c200004, formal←c200005, formal←c200006, formal←c200007)
   word formal←c0189;
   word formal←c200004;
   word formal←c200005;
   word formal←c200006;
   word formal←c200007;
   {
   if ((formal←c200005 == XR←Unwind)) {
      (void) (XR←MonitorExit(* (( (ptr) formal←c200004)+4) ));
      };
   (*  (ptr) formal←c0189 ) = 0;
   (* (( (ptr) formal←c0189)+1) ) = 0;
   return;
   }

static void NoName←Q3120(formal←c0194, formal←c200000, formal←c200001, formal←c200002, formal←c200003)
   word formal←c0194;
   word formal←c200000;
   word formal←c200001;
   word formal←c200002;
   word formal←c200003;
   {
   if ((formal←c200001 == XR←Unwind)) {
      (void) (XR←MonitorExit(* (( (ptr) formal←c200000)+4) ));
      };
   (*  (ptr) formal←c0194 ) = 0;
   (* (( (ptr) formal←c0194)+1) ) = 0;
   return;
   }

/* file: FunctionCacheImpl, module: FunctionCacheImpl, compiled at: July 28, 1993 10:13:34 am PDT */ 
extern void XR←install←FunctionCacheImpl() {
   NoName←Q2880();
   }
extern void XR←run←FunctionCacheImpl() { XR←Start(&globalframe); }