/* Generated with C2C (Cedar To C)*/
/* Copyright (C) 1993 by Xerox Corporation.  All rights reserved. */
/* time: April 20, 1993 3:37:03 pm PDT */
/* C2C version: April 20, 1993 (sun4) */
/* ref-counting: off */
/* file: DRealSupportImpl, module: DRealSupportImpl */ 
/* switches: bcfhklnouw */ 
#include <cedar/InstallationSupport.h>
#include <cedar/CedarExtra.h>
#include <math.h>
static char versionStamp[] = "@(#)mob←version [3951692930,395690052] DRealSupportImpl";
typedef unsigned word, *ptr;
typedef unsigned char byte, *bPt;
typedef unsigned short half, *hPt;
typedef struct {word f0, f1;} W2;
typedef W2 *W2Pt;
typedef struct {word f0, f1, f2;} W3;
#define SOURCE(p, l) /* source p, l */
static double fc4 = 1.0;
#define BCK(idx, lim) ( ((unsigned) idx) >= ((unsigned) lim) ? (XR←RaiseBoundsFault()) : (idx) )
static double fc5 = 0.0;
static double fc6 = -2147483648.0;
static double fc7 = 2147483648.0;
static double fc9 = 0.5;
static double fc10 = 2147483647.0;
#define IOP2(op, x, y)  ( (word) ((x) op (y)) )
static double fc12 = 0.25;
static double fc13 = 2.0;
static double fc14 = 4.0;
static void NoName←Q2112();
static void DRealSupportImpl←P0();
static word Classify←P60();
static void Example←P120();
static word DRealToReal←P180();
static void IntToDReal←P240();
static void CardToDReal←P300();
static void RealToDReal←P360();
static word Fix←P420();
static word Round←P480();
static void Modf←P540();
static void FScale←P600();
static void Neg←P660();
static void Abs←P720();
static void Add←P780();
static void Sub←P840();
static void Mul←P900();
static void Div←P960();
static word Gt←P1020();
static word Ge←P1080();
static word Lt←P1140();
static word Le←P1200();
static word Eq←P1260();
static word Ne←P1320();
static void Min←P1380();
static void Max←P1440();
static void Pwr←P1500();
static void Floor←P1560();
static void Ceiling←P1620();
static struct {unsigned f; char r[16];} string1 = {851984, "\257\300\353\212\014\202\300\027\225\300\104\100\164\000\000"};
static struct {unsigned f; char r[16];} string2 = {851984, "\257\300\150\261\123\070\300\276\161\220\062\100\150\000\000"};
static struct {unsigned f; char r[16];} string3 = {851984, "\257\300\233\213\041\256\300\330\147\331\041\100\150\000\000"};
static struct {
   word f0[4]; word f4; word f5; word f6; 
   word f7; word f8; word f9; word f10; 
   word f11; word f12; word f13; word f14; 
   word f15; word f16; word f17; word f18; 
   word f19; word f20; 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; 
   word f59[3]; 
   } globalframe = {
   {0}, (word) Ceiling←P1620, 0, (word) Floor←P1560, 
   0, (word) Pwr←P1500, 0, (word) Max←P1440, 
   0, (word) Min←P1380, 0, (word) Ne←P1320, 
   0, (word) Eq←P1260, 0, (word) Le←P1200, 
   0, (word) Lt←P1140, 0, (word) Ge←P1080, 
   0, (word) Gt←P1020, 0, (word) Div←P960, 
   0, (word) Mul←P900, 0, (word) Sub←P840, 
   0, (word) Add←P780, 0, (word) Abs←P720, 
   0, (word) Neg←P660, 0, (word) FScale←P600, 
   0, (word) Modf←P540, 0, (word) Round←P480, 
   0, (word) Fix←P420, 0, (word) RealToDReal←P360, 
   0, (word) CardToDReal←P300, 0, (word) IntToDReal←P240, 
   0, (word) DRealToReal←P180, 0, (word) Example←P120, 
   0, (word) Classify←P60, 0, (word) DRealSupportImpl←P0, 
   {0}
   };
#define DRealPtr(x) (*((double *) (x)))
extern word XR←FloatDFloatI (x) W2 *x; {
    float f = DRealPtr(x);
    return (*((ptr) &f));
    }
extern word XR←DRealClassifyI (x) W2 *x; {
    double d = DRealPtr(x);
    word w = fp←class(d);
    switch (w) {
        case fp←zero: return (0);
        case fp←subnormal: return (1);
        case fp←normal: return (2);
        case fp←infinity: return (3);
        case fp←quiet: return (4);
        case fp←signaling: return (5);
        };
    return (6);
    }
#define ex←subnormal←min(x) (DRealPtr(x)=min←subnormal())
#define ex←subnormal←max(x) (DRealPtr(x)=max←subnormal())
#define ex←normal←min(x) (DRealPtr(x)=min←normal())
#define ex←normal←max(x) (DRealPtr(x)=max←normal())
#define ex←infinity(x) (DRealPtr(x)=infinity())
#define ex←quiet(x) (DRealPtr(x)=quiet←nan(0))
#define ex←signaling(x) (DRealPtr(x)=signaling←nan(0))
extern word XR←FloatDRealI (x) W2 *x; {
    float f = DRealPtr(x);
    return (*((ptr) &f));
    }
extern void XR←DFloatInt (ret, x) W2 *ret; word x; {
    DRealPtr(ret) = ((int) x);
    }
extern void XR←DFloatCard (ret, x) W2 *ret; word x; {
    DRealPtr(ret) = ((unsigned) x);
    }
extern void XR←DFloatReal (ret, x) W2 *ret; word x; {
    float f = *((float *) &x);
    DRealPtr(ret) = f;
    }
extern void XR←DRealModfI (x, frac, ip) W2 *x, *frac; double *ip; {
    double d = DRealPtr(x);
    d = modf(d, ip);
    DRealPtr(frac) = d;
    }
extern void XR←DRealNegI (ret, x) W2 *ret, *x; {
    DRealPtr(ret) = - DRealPtr(x);
    }
extern void XR←DRealAbsI (ret, x) W2 *ret, *x; {
    DRealPtr(ret) = fabs(DRealPtr(x));
    }
extern void XR←DRealAddI (ret, x, y) W2 *ret, *x, *y; {
    DRealPtr(ret) = DRealPtr(x) + DRealPtr(y);
    }
extern void XR←DRealSubI (ret, x, y) W2 *ret, *x, *y; {
    DRealPtr(ret) = DRealPtr(x) - DRealPtr(y);
    }
extern void XR←DRealMulI (ret, x, y) W2 *ret, *x, *y; {
    DRealPtr(ret) = DRealPtr(x) * DRealPtr(y);
    }
extern void XR←DRealDivI (ret, x, y) W2 *ret, *x, *y; {
    DRealPtr(ret) = DRealPtr(x) / DRealPtr(y);
    }
extern word XR←DRealGtI (x, y) W2 *x, *y; {
    if ( DRealPtr(x) > DRealPtr(y) ) {return (1);};
    return (0);
    }
extern word XR←DRealGeI (x, y) W2 *x, *y; {
    if ( DRealPtr(x) >= DRealPtr(y) ) {return (1);};
    return (0);
    }
extern word XR←DRealLtI (x, y) W2 *x, *y; {
    if ( DRealPtr(x) < DRealPtr(y) ) {return (1);};
    return (0);
    }
extern word XR←DRealLeI (x, y) W2 *x, *y; {
    if ( DRealPtr(x) <= DRealPtr(y) ) {return (1);};
    return (0);
    }
extern word XR←DRealEqI (x, y) W2 *x, *y; {
    if ( DRealPtr(x) == DRealPtr(y) ) {return (1);};
    return (0);
    }
extern word XR←DRealNeI (x, y) W2 *x, *y; {
    if ( DRealPtr(x) != DRealPtr(y) ) {return (1);};
    return (0);
    }
extern void XR←DRealMinI (ret, x, y) W2 *ret, *x, *y; {
    if ( DRealPtr(x) <= DRealPtr(y) ) {*ret = *x; return;};
    *ret = *y;
    }
extern void XR←DRealMaxI (ret, x, y) W2 *ret, *x, *y; {
    if ( DRealPtr(x) >= DRealPtr(y) ) {*ret = *x; return;};
    *ret = *y;
    }
extern void XR←DRealPwrI (ret, x, y) W2 *ret, *x, *y; {
    DRealPtr(ret) = pow(DRealPtr(x), DRealPtr(y));
    }
extern void XR←DRealFloorI (ret, x) W2 *ret, *x; {
    DRealPtr(ret) = floor(DRealPtr(x));
    }
extern void XR←DRealCeilingI (ret, x) W2 *ret, *x; {
    DRealPtr(ret) = ceil(DRealPtr(x));
    }

static void NoName←Q2112()
   {
   register ptr gf←c0146 =  (ptr) &globalframe;
   word var←c13180;
   (void) XR←DeclareGlobalFrame((word) "DRealSupportImpl", &globalframe, (word) XR←GetTypeIndexS((word) (&string1)), (word) (
         ( (bPt) gf←c0146)+232)/* var←c12668 */ );
   var←c13180 = (word) XR←ImportInterface((word) "FloatingPointCommon", (word) XR←GetTypeIndexS((word) (&string2)), 5);
   (* (( (ptr) gf←c0146)+60)/* var←c12796 */  ) = var←c13180;
   var←c13180 = (word) XR←ExportInterface((word) "DRealSupport", (word) XR←GetTypeIndexS((word) (&string3)), 26);
   (* (( (ptr) gf←c0146)+61)/* var←c13212 */  ) = var←c13180;
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+224)/* var←c12636 */ , 67633153);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+216)/* var←c12604 */ , 134742274);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+208)/* var←c12572 */ , 67633665);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+200)/* var←c12540 */ , 134480641);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+192)/* var←c12508 */ , 134480897);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+184)/* var←c12476 */ , 134481153);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+176)/* var←c12444 */ , 67634689);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+168)/* var←c12412 */ , 67634945);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+152)/* var←c12348 */ , 135006210);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+144)/* var←c12316 */ , 134744321);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+136)/* var←c12284 */ , 134744577);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+128)/* var←c12252 */ , 135269122);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+120)/* var←c12220 */ , 135269378);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+112)/* var←c12188 */ , 135269634);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+104)/* var←c12156 */ , 135269890);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+96)/* var←c12124 */ , 68161282);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+88)/* var←c12092 */ , 68161538);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+80)/* var←c12060 */ , 68161794);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+72)/* var←c12028 */ , 68162050);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+64)/* var←c11996 */ , 68162306);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+56)/* var←c11964 */ , 68162562);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+48)/* var←c11932 */ , 135271682);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+40)/* var←c11900 */ , 135271938);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+32)/* var←c11868 */ , 135272194);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+24)/* var←c11836 */ , 134748161);
   (void) XR←ExportProcS(var←c13180, (word) (( (bPt) gf←c0146)+16)/* var←c11804 */ , 134748417);
   }

static void DRealSupportImpl←P0(formal←c036, formal←c032)
   word formal←c036;
   word formal←c032;
   {
   /* DRealSupportImpl: */ 
SOURCE(72, 11246)
SOURCE(11242, 76)
   {
      W2 dummy←v9900;
      word dummyPtr←v9928;
SOURCE(11244, 18)
      dummy←v9900 = (*  (W2Pt) &fc4 );
SOURCE(11264, 25)
      dummyPtr←v9928 = (word) &dummy←v9900;
SOURCE(11291, 27)
      {
         word var←c12700;
         var←c12700 = (word) XR←FloatDFloatI(dummyPtr←v9928);
         };
      };
   }

static word Classify←P60(d←v4088)
   W2 d←v4088;
   {
   word var←c4132;
   word w←v9972;
   /* Classify: */ 
SOURCE(501, 322)
SOURCE(567, 28)
   w←v9972 = (word) XR←DRealClassifyI((word) (&d←v4088));
SOURCE(626, 21)
   return(BCK(w←v9972, 7));
   }

static void Example←P120(formal←c045, c←v4192, min←v4220)
   word formal←c045;
   word c←v4192;
   word min←v4220;
   {
   W2 var←c4264;
   W2 d←v10016;
   /* Example: */ 
SOURCE(829, 1276)
SOURCE(913, 14)
   d←v10016 = (*  (W2Pt) &fc5 );
SOURCE(929, 1152)
   {
      word var←c12732;
      var←c12732 = c←v4192;
      switch (var←c12732) {
         case 1: 
SOURCE(956, 329)
            if ((0 != min←v4220)) {
SOURCE(968, 156)
SOURCE(1114, 8)
               (void) ex←subnormal←min((word) (&d←v10016));
               }
            else {
SOURCE(1131, 156)
SOURCE(1277, 8)
               (void) ex←subnormal←max((word) (&d←v10016));
               };
            break;
         case 2: 
SOURCE(1300, 311)
            if ((0 != min←v4220)) {
SOURCE(1312, 147)
SOURCE(1449, 8)
               (void) ex←normal←min((word) (&d←v10016));
               }
            else {
SOURCE(1466, 147)
SOURCE(1603, 8)
               (void) ex←normal←max((word) (&d←v10016));
               };
            break;
         case 3: 
SOURCE(1628, 141)
SOURCE(1759, 8)
            (void) ex←infinity((word) (&d←v10016));
            break;
         case 4: 
SOURCE(1781, 137)
SOURCE(1908, 8)
            (void) ex←quiet((word) (&d←v10016));
            break;
         case 5: 
SOURCE(1934, 149)
SOURCE(2073, 8)
            (void) ex←signaling((word) (&d←v10016));
            break;
         };
      };
SOURCE(2095, 10)
   var←c4264 = d←v10016;
   /* removed tail goto */ 
   (*  (W2Pt) formal←c045 ) = var←c4264;
   return;
   }

static word DRealToReal←P180(d←v4324)
   W2 d←v4324;
   {
   word var←c4368;
   /* DRealToReal: */ 
SOURCE(2111, 87)
SOURCE(2174, 24)
   return((word) XR←FloatDRealI((word) (&d←v4324)));
   }

static void IntToDReal←P240(formal←c050, i←v4428)
   word formal←c050;
   word i←v4428;
   {
   W2 ret←v4472;
   /* IntToDReal: */ 
SOURCE(2203, 84)
SOURCE(2269, 18)
   (void) XR←FloatInt((word) &ret←v4472, i←v4428);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c050 ) = ret←v4472;
   return;
   }

static void CardToDReal←P300(formal←c053, c←v4532)
   word formal←c053;
   word c←v4532;
   {
   W2 ret←v4576;
   /* CardToDReal: */ 
SOURCE(2292, 87)
SOURCE(2360, 19)
   (void) XR←DFloatCard((word) &ret←v4576, c←v4532);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c053 ) = ret←v4576;
   return;
   }

static void RealToDReal←P360(formal←c056, r←v4636)
   word formal←c056;
   word r←v4636;
   {
   W2 ret←v4680;
   /* RealToDReal: */ 
SOURCE(2384, 87)
SOURCE(2452, 19)
   (void) XR←DFloatReal((word) &ret←v4680, r←v4636);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c056 ) = ret←v4680;
   return;
   }

static word Fix←P420(x←v4740)
   W2 x←v4740;
   {
   register ptr gf←c13244 =  (ptr) &globalframe;
   word var←c4784;
   word ret←v10844 = 0;
   W2 frac←v10872;
   /* Fix: */ 
SOURCE(2476, 334)
SOURCE(2582, 17)
   frac←v10872 = (*  (W2Pt) &fc5 );
SOURCE(2601, 56)
   if (XR←DRealGtI(&fc6, &x←v4740)) {
SOURCE(2619, 38)
      {
         word var←c061 = 5;
         (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c13244)+60)/* var←c12796 */  ))+4) ), (word) &var←c061);
         };
      };
SOURCE(2659, 64)
   if (XR←DRealGeI(&x←v4740, &fc7)) {
SOURCE(2685, 38)
      {
         word var←c062 = 5;
         (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c13244)+60)/* var←c12796 */  ))+4) ), (word) &var←c062);
         };
      };
SOURCE(2725, 21)
   {
      W3 var←c12828;
      (void) Modf←P540((word) &var←c12828, x←v4740);
      frac←v10872 = (*  (W2Pt) (( (ptr) &var←c12828)+1) );
      ret←v10844 = var←c12828.f0;
      };
SOURCE(2748, 48)
   if (XR←DRealGtI(&fc5, &x←v4740)) {
SOURCE(2764, 32)
      if ( ! XR←DRealEqI(&frac←v10872, &fc5)) {
SOURCE(2783, 13)
         ret←v10844 = (ret←v10844 - 1);
         };
      };
SOURCE(2798, 12)
   return(ret←v10844);
   }

static word Round←P480(x←v4844)
   W2 x←v4844;
   {
   register ptr gf←c13276 =  (ptr) &globalframe;
   word var←c4888;
   word ret←v10972 = 0;
   W2 frac←v11000;
   /* Round: */ 
SOURCE(2815, 494)
SOURCE(2923, 17)
   frac←v11000 = (*  (W2Pt) &fc5 );
SOURCE(2942, 100)
   if (XR←DRealGeI(&fc6, &x←v4844)) {
SOURCE(2963, 39)
      {
         W2 x8;
         XR←DRealAddI(&x8, &x←v4844, &fc9);
         if (XR←DRealGeI(&x8, &fc6)) {
SOURCE(2988, 14)
            return(2147483648);
            };
         };
SOURCE(3004, 38)
      {
         word var←c069 = 5;
         (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c13276)+60)/* var←c12796 */  ))+4) ), (word) &var←c069);
         };
      };
SOURCE(3047, 97)
   if (XR←DRealGeI(&x←v4844, &fc10)) {
SOURCE(3067, 37)
      {
         W2 x11;
         XR←DRealSubI(&x11, &x←v4844, &fc9);
         if (XR←DRealGeI(&fc10, &x11)) {
SOURCE(3091, 13)
            return(2147483647);
            };
         };
SOURCE(3106, 38)
      {
         word var←c070 = 5;
         (void) XR←RaiseError((* (( (ptr) (* (( (ptr) gf←c13276)+60)/* var←c12796 */  ))+4) ), (word) &var←c070);
         };
      };
SOURCE(3149, 21)
   {
      W3 var←c12860;
      (void) Modf←P540((word) &var←c12860, x←v4844);
      frac←v11000 = (*  (W2Pt) (( (ptr) &var←c12860)+1) );
      ret←v10972 = var←c12860.f0;
      };
   if (XR←DRealGtI(&fc9, &frac←v11000)) {
SOURCE(3203, 13)
      ret←v10972 = (ret←v10972 - 1);
      }
   else {
      if (XR←DRealEqI(&frac←v11000, &fc9)) {
SOURCE(3232, 37)
         if (( (int)IOP2( % ,  (int)ret←v10972,  (int)2) !=  (int)0)) {
SOURCE(3256, 13)
            ret←v10972 = (ret←v10972 + 1);
            };
         }
      else {
SOURCE(3282, 13)
         ret←v10972 = (ret←v10972 + 1);
         };
      };
SOURCE(3297, 12)
   return(ret←v10972);
   }

static void Modf←P540(formal←c077, x←v4948)
   word formal←c077;
   W2 x←v4948;
   {
   word int←v4992;
   W2 frac←v5020;
   W2 di←v11072;
   /* Modf: */ 
SOURCE(3315, 404)
SOURCE(3683, 26)
   (void) XR←DRealModfI((word) &x←v4948, (word) &frac←v5020, (word) &di←v11072);
SOURCE(3711, 8)
   int←v4992 = XR←IntDIntI(&di←v11072);
   /* removed tail goto */ 
   (*  (ptr) formal←c077 ) = int←v4992;
   (*  (W2Pt) (( (ptr) formal←c077)+1) ) = frac←v5020;
   return;
   }

static void FScale←P600(formal←c087, a←v5080, scale←v5108)
   word formal←c087;
   W2 a←v5080;
   word scale←v5108;
   {
   W2 var←c5152;
   /* FScale: */ 
SOURCE(3724, 295)
SOURCE(3791, 228)
   {
      word var←c12892;
      var←c12892 = scale←v5108;
      switch (var←c12892) {
         case 4294967294: 
SOURCE(3815, 15)
            XR←DRealMulI(&var←c5152, &a←v5080, &fc12);
            /* removed tail goto */ 
            break;
         case 4294967295: 
SOURCE(3838, 14)
            XR←DRealMulI(&var←c5152, &a←v5080, &fc9);
            /* removed tail goto */ 
            break;
         case 0: 
SOURCE(3859, 10)
            var←c5152 = a←v5080;
            /* removed tail goto */ 
            break;
         case 1: 
SOURCE(3876, 14)
            XR←DRealMulI(&var←c5152, &a←v5080, &fc13);
            /* removed tail goto */ 
            break;
         case 2: 
SOURCE(3897, 14)
            XR←DRealMulI(&var←c5152, &a←v5080, &fc14);
            /* removed tail goto */ 
            break;
         default: 
SOURCE(3924, 97)
            {
               word half←v11244;
               word rem←v11272;
SOURCE(3926, 23)
               half←v11244 = IOP2( / ,  (int)scale←v5108,  (int)2);
SOURCE(3951, 25)
               rem←v11272 = (scale←v5108 - half←v11244);
SOURCE(3978, 41)
               {
                  W2 var←c12956;
                  {
                     W2 var←c085;
                     W2 var←c086;
                     (void) FScale←P600((word) &var←c085, (*  (W2Pt) &fc4 ), half←v11244);
                     (void) FScale←P600((word) &var←c086, a←v5080, rem←v11272);
                     XR←DRealMulI(&var←c12956, &var←c085, &var←c086);
                     };
                  var←c5152 = var←c12956;
                  /* removed tail goto */ 
                  };
               };
            break;
         };
      };
   (*  (W2Pt) formal←c087 ) = var←c5152;
   return;
   }

static void Neg←P660(formal←c090, d←v5212)
   word formal←c090;
   W2 d←v5212;
   {
   W2 ret←v5256;
   /* Neg: */ 
SOURCE(4027, 80)
SOURCE(4088, 19)
   (void) XR←DRealNegI((word) &ret←v5256, (word) &d←v5212);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c090 ) = ret←v5256;
   return;
   }

static void Abs←P720(formal←c093, d←v5316)
   word formal←c093;
   W2 d←v5316;
   {
   W2 ret←v5360;
   /* Abs: */ 
SOURCE(4112, 80)
SOURCE(4173, 19)
   (void) XR←DRealAbsI((word) &ret←v5360, (word) &d←v5316);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c093 ) = ret←v5360;
   return;
   }

static void Add←P780(formal←c097, x←v5420, y←v5448)
   word formal←c097;
   W2 x←v5420;
   W2 y←v5448;
   {
   W2 ret←v5492;
   /* Add: */ 
SOURCE(4197, 87)
SOURCE(4261, 23)
   (void) XR←DRealAddI((word) &ret←v5492, (word) &x←v5420, (word) &y←v5448);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c097 ) = ret←v5492;
   return;
   }

static void Sub←P840(formal←c0101, x←v5552, y←v5580)
   word formal←c0101;
   W2 x←v5552;
   W2 y←v5580;
   {
   W2 ret←v5624;
   /* Sub: */ 
SOURCE(4289, 87)
SOURCE(4353, 23)
   (void) XR←DRealSubI((word) &ret←v5624, (word) &x←v5552, (word) &y←v5580);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0101 ) = ret←v5624;
   return;
   }

static void Mul←P900(formal←c0105, x←v5684, y←v5712)
   word formal←c0105;
   W2 x←v5684;
   W2 y←v5712;
   {
   W2 ret←v5756;
   /* Mul: */ 
SOURCE(4381, 87)
SOURCE(4445, 23)
   (void) XR←DRealMulI((word) &ret←v5756, (word) &x←v5684, (word) &y←v5712);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0105 ) = ret←v5756;
   return;
   }

static void Div←P960(formal←c0109, x←v5816, y←v5844)
   word formal←c0109;
   W2 x←v5816;
   W2 y←v5844;
   {
   W2 ret←v5888;
   /* Div: */ 
SOURCE(4473, 87)
SOURCE(4537, 23)
   (void) XR←DRealDivI((word) &ret←v5888, (word) &x←v5816, (word) &y←v5844);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0109 ) = ret←v5888;
   return;
   }

static word Gt←P1020(x←v5948, y←v5976)
   W2 x←v5948;
   W2 y←v5976;
   {
   word var←c6020;
   /* Gt: */ 
SOURCE(4565, 82)
SOURCE(4622, 25)
   return((word) XR←DRealGtI((word) &x←v5948, (word) &y←v5976));
   }

static word Ge←P1080(x←v6080, y←v6108)
   W2 x←v6080;
   W2 y←v6108;
   {
   word var←c6152;
   /* Ge: */ 
SOURCE(4652, 82)
SOURCE(4709, 25)
   return((word) XR←DRealGeI((word) &x←v6080, (word) &y←v6108));
   }

static word Lt←P1140(x←v6212, y←v6240)
   W2 x←v6212;
   W2 y←v6240;
   {
   word var←c6284;
   /* Lt: */ 
SOURCE(4739, 82)
SOURCE(4796, 25)
   return((word) XR←DRealLtI((word) &x←v6212, (word) &y←v6240));
   }

static word Le←P1200(x←v6344, y←v6372)
   W2 x←v6344;
   W2 y←v6372;
   {
   word var←c6416;
   /* Le: */ 
SOURCE(4826, 82)
SOURCE(4883, 25)
   return((word) XR←DRealLeI((word) &x←v6344, (word) &y←v6372));
   }

static word Eq←P1260(x←v6476, y←v6504)
   W2 x←v6476;
   W2 y←v6504;
   {
   word var←c6548;
   /* Eq: */ 
SOURCE(4913, 82)
SOURCE(4970, 25)
   return((word) XR←DRealEqI((word) &x←v6476, (word) &y←v6504));
   }

static word Ne←P1320(x←v6608, y←v6636)
   W2 x←v6608;
   W2 y←v6636;
   {
   word var←c6680;
   /* Ne: */ 
SOURCE(5000, 82)
SOURCE(5057, 25)
   return((word) XR←DRealNeI((word) &x←v6608, (word) &y←v6636));
   }

static void Min←P1380(formal←c0131, x←v6740, y←v6768)
   word formal←c0131;
   W2 x←v6740;
   W2 y←v6768;
   {
   W2 ret←v6812;
   /* Min: */ 
SOURCE(5087, 87)
SOURCE(5151, 23)
   (void) XR←DRealMinI((word) &ret←v6812, (word) &x←v6740, (word) &y←v6768);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0131 ) = ret←v6812;
   return;
   }

static void Max←P1440(formal←c0135, x←v6872, y←v6900)
   word formal←c0135;
   W2 x←v6872;
   W2 y←v6900;
   {
   W2 ret←v6944;
   /* Max: */ 
SOURCE(5179, 87)
SOURCE(5243, 23)
   (void) XR←DRealMaxI((word) &ret←v6944, (word) &x←v6872, (word) &y←v6900);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0135 ) = ret←v6944;
   return;
   }

static void Pwr←P1500(formal←c0139, x←v7004, y←v7032)
   word formal←c0139;
   W2 x←v7004;
   W2 y←v7032;
   {
   W2 ret←v7076;
   /* Pwr: */ 
SOURCE(5271, 87)
SOURCE(5335, 23)
   (void) XR←DRealPwrI((word) &ret←v7076, (word) &x←v7004, (word) &y←v7032);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0139 ) = ret←v7076;
   return;
   }

static void Floor←P1560(formal←c0142, x←v7136)
   word formal←c0142;
   W2 x←v7136;
   {
   W2 ret←v7180;
   /* Floor: */ 
SOURCE(5363, 84)
SOURCE(5426, 21)
   (void) XR←DRealFloorI((word) &ret←v7180, (word) &x←v7136);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0142 ) = ret←v7180;
   return;
   }

static void Ceiling←P1620(formal←c0145, x←v7240)
   word formal←c0145;
   W2 x←v7240;
   {
   W2 ret←v7284;
   /* Ceiling: */ 
SOURCE(5452, 88)
SOURCE(5517, 23)
   (void) XR←DRealCeilingI((word) &ret←v7284, (word) &x←v7240);
   /* removed tail goto */ 
   (*  (W2Pt) formal←c0145 ) = ret←v7284;
   return;
   }

/* file: DRealSupportImpl, module: DRealSupportImpl, compiled at: April 20, 1993 3:37:02 pm PDT */ 
extern void XR←install←DRealSupportImpl() {
   NoName←Q2112();
   }
extern void XR←run←DRealSupportImpl() { XR←Start(&globalframe); }