#include "M3Runtime.h"

#define t2 ADDRESS
#define t28 void
typedef unsigned char t3;
#line 18 "./Convert.i3"
typedef struct { char* elts; int size[1]; } t23;
#line 168 "Convert.m3"
#define t1 t23
PRIVATE void t2_PrintProc ();
#line 461
PRIVATE typecell t2_TC; PRIVATE typecell t2_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,   -2, 0, NIL, 1, 1, (PROC)NIL, (PROC)NIL, t2_PrintProc,
#line 461
  "", 1336334074, 816400397}; PRIVATE TYPE TC2 = &t2_TC;  
#define t6 ADDRESS
typedef int t4; 
#define TC6 TC_ADDRESS
IMPORT TYPE TC_ADDRESS; IMPORT char VS_ADDRESS__30f7308738738b44; 
#define t33 ADDRESS
#define TC33 TC_REFANY
IMPORT TYPE TC_REFANY; IMPORT char VS_REFANY__4b8748e831fc107a; 
#define t34 ADDRESS
#define TC34 TC_NULL
IMPORT TYPE TC_NULL; IMPORT char VS_NULL__fb50c7d53bec30dc; typedef double t5;
#line 450
typedef t5 (*t7)(); typedef float t8;
#line 421
typedef t8 (*t9)(); typedef unsigned char t10;
#line 19 "./Convert.i3"
typedef signed_char t11;
#line 320 "Convert.m3"
typedef t4 (*t12)(); typedef int t13;
#line 168
typedef signed_char t14; typedef struct { t3 elts[101]; } t15;
#line 160
typedef signed_char t16; typedef struct { t3 elts[6]; } t17;
#line 102
typedef signed_char t18; typedef struct { t3 elts[33]; } t19;
#line 14
typedef signed_char t20; typedef struct { t3 elts[16]; } t21;
#line 15 "./CConvert.i3"
typedef t6 (*t22)();
#line 22 "./Convert.i3"
typedef unsigned char t24; typedef t10 (*t25)(); typedef t28 (*t26)(); typedef CLOSURE t27; 
#define t32 ADDRESS
 typedef struct { TYPE self; int private; } t32_methods; 
#define t32_msize (sizeof (t32_methods))
typedef struct { ADDRESS methods; } t32_fields; 
#define t32_size (sizeof (t32_fields))
#define TC32 TC_ROOT
IMPORT TYPE TC_ROOT; IMPORT char VS_ROOT__349f58f628be0ac6; 
#define t32_MapProc TC_ROOT->mapProc
#define t29 ADDRESS
#define TC29 TC_MUTEX
IMPORT TYPE TC_MUTEX; IMPORT char VS_MUTEX__1f9d4e89391ab815; 
#define t29_MapProc TC_MUTEX->mapProc
#define t30 ADDRESS
#define TC30 TC_TEXT
IMPORT TYPE TC_TEXT; IMPORT char VS_TEXT__b7a92447326386f5; 
#define t30_MapProc TC_TEXT->mapProc
#define t31 ADDRESS
 typedef struct { TYPE self; int private; } t31_methods; 
#define t31_msize (sizeof (t31_methods))
typedef struct { ADDRESS methods; } t31_fields; 
#define t31_size (sizeof (t31_fields))
#define TC31 TC_UNTRACED_ROOT
IMPORT TYPE TC_UNTRACED_ROOT; IMPORT char VS_UNTRACED_ROOT__3e0964513fd6da20;
#line 8 "Convert.m3"
IMPORT INITLINK* CConvert__init; IMPORT INITLINK* Word__init; IMPORT INITLINK* Convert__init;  IMPORT t6 sprintf (); IMPORT char VSsprintf__87b5c6bb2a46d93d;
#line 8
IMPORT t5 strtod (); IMPORT char VSstrtod__0d1ea6a8243ce624;   IMPORT t4 _Word__Divide (); IMPORT char VS_Word__Divide__48d9c1b03852635b;
#line 8
IMPORT t4 _Word__Mod (); IMPORT char VS_Word__Mod__93daaa5234221794;   IMPORT EXCEPTION_NAME _Convert__Failed; IMPORT char VS_Convert__Failed__2816e40d3f5c20d1;
#line 8
EXPORT t4 _Convert__FromInt (); EXPORT char VS_Convert__FromInt__ef7d44523e253eab = '\0'; EXPORT t4 _Convert__FromUnsigned ();
#line 8
EXPORT char VS_Convert__FromUnsigned__8fba906a31ad84fa = '\0'; EXPORT t4 _Convert__FromFloat (); EXPORT char VS_Convert__FromFloat__23a5efdb2af5c200 = '\0';
#line 8
EXPORT t4 _Convert__FromLongFloat (); EXPORT char VS_Convert__FromLongFloat__114d507b263cb69e = '\0'; EXPORT t4 _Convert__ToInt ();
#line 8
EXPORT char VS_Convert__ToInt__0308a0ac308d5373 = '\0'; EXPORT t4 _Convert__ToUnsigned (); EXPORT char VS_Convert__ToUnsigned__e3e78ac723cc3b63 = '\0';
#line 8
EXPORT t8 _Convert__ToFloat (); EXPORT char VS_Convert__ToFloat__4e28ff0029a13ad9 = '\0'; EXPORT t5 _Convert__ToLongFloat ();
#line 8
EXPORT char VS_Convert__ToLongFloat__bbb3a4a8226c11b1 = '\0'; PRIVATE t21 _Convert__Digits; PRIVATE t4 _Convert__InternalFromLongFloat ();
#line 8
    
#line 91
PRIVATE EXCEPTION_NAME *raises_2 [] = { & _Convert__Failed, (EXCEPTION_NAME *) NULL};
#line 133
PRIVATE EXCEPTION_NAME *raises_7 [] = { & _Convert__Failed, (EXCEPTION_NAME *) NULL};








PRIVATE EXCEPTION_NAME *raises_8 [] = { & _Convert__Failed, (EXCEPTION_NAME *) NULL};







PRIVATE EXCEPTION_NAME *raises_9 [] = { & _Convert__Failed, (EXCEPTION_NAME *) NULL};
#line 418
PRIVATE EXCEPTION_NAME *raises_5 [] = { & _Convert__Failed, (EXCEPTION_NAME *) NULL};
#line 447
PRIVATE EXCEPTION_NAME *raises_6 [] = { & _Convert__Failed, (EXCEPTION_NAME *) NULL};
#line 18 "Convert.m3"
 EXPORT t4 _Convert__FromInt (_buf, _value, _base, _prefix) t1 * _buf; t4 _value; t11 _base; t10 _prefix; { t10 z2; t4 z1;
t4 z3; t4 z4; t4 z5; t13 z6; t4 z7;
#line 18 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_2, proc_0); { auto t4 _nDigits; auto t10 _minus; auto t10 _bump; auto t4 _i;
#line 18
      auto t4 _j; auto t3 _c; auto t19 _result; auto t4 __result; {





         ZERO1B (& _minus);
         ZERO1B (& _bump);

         ZERO1B (& _c);
         ZERO  (33, & _result);
#line 23
         ZERO1  ((& _nDigits));
         ZERO1B ((& _minus));
         ZERO1B ((& _bump));
#line 18
         CHECKSTACKOVERFLOW;
#line 31
         z2 = (_value ==  0 ); if (z2) {
            (_result.elts[ 0 ]) =  '0' ;
            _nDigits =  1 ; goto if_1_end; }; z2 = (_value <  0 );


            if (z2) {
               z2 = (_value ==  -2147483648 ); if (z2) {

                  _bump =  1 ;
                  _value +=  1 ; goto if_3_end; }; if_3_end: /**/;

               _minus =  1 ;
               z1 = - _value; _value = z1;
               z2 = (_value >  0 ); if (!z2) ASSERTFAULT; goto if_2_end; }; if_2_end: /**/;



            z2 = (_value >  0 ); if (z2) do { z3 = _value;
               z4 = _base; z5 = z3 - (z4 * (IDIV (z3, z4))); z1 = z5; if ((z1 < 0) || (15 < z1)) RANGEFAULT; z5 = _nDigits;
#line 49
               if ((z5 < 0) || (32 < z5)) RANGEFAULT; (_result.elts[z5]) = (_Convert__Digits.elts[z1]);
               z3 = IDIV (_value, _base); _value = z3;
               _nDigits +=  1 ; z2 = (_value >  0 ); } while (z2);



            if (_bump) {
               z3 = _nDigits; if ((z3 < 0) || (32 < z3)) RANGEFAULT; (_result.elts[z3]) =  '0' ;
               _j =  0 ;
               loop_0:; z3 = _j;
                  if ((z3 < 0) || (32 < z3)) RANGEFAULT; _c = (_result.elts[z3]);
                  z2 = (_c <=  '9' ); if (z2) {
                     z3 = _c -  48 ; _i = z3; goto if_5_end; }; z3 = _c -  97 ;
                     z1 = z3 +  10 ; _i = z1; if_5_end: /**/;

                  _i +=  1 ;
                  z2 = (_i < _base); if (z2) { z3 = _i; if ((z3 < 0) || (15 < z3)) RANGEFAULT; z5 = _j; if ((z5 < 0) || (32 < z5)) RANGEFAULT;
#line 65
                     (_result.elts[z5]) = (_Convert__Digits.elts[z3]); goto loop_exit_0; };
                  z3 = _j; if ((z3 < 0) || (32 < z3)) RANGEFAULT; (_result.elts[z3]) =  '0' ;
                  _j +=  1 ; goto loop_0; loop_exit_0: /**/;

               z3 = _j +  1 ; z1 = _nDigits; z4 = z3; if (z1 < z4) z1 = z4; _nDigits = z1; goto if_4_end; }; if_4_end: /**/;
#line 69
 if_1_end: /**/;




         _j = _nDigits;
         if (_minus) { _j +=  1 ; goto if_7_end; }; if_7_end: /**/;
         if (_prefix) { z2 = (_base >  9 ); if (z2) { _j +=  3 ; goto if_9_end; }; _j +=  2 ; if_9_end: /**/; goto if_8_end;
#line 76
 }; if_8_end: /**/;
         z6 = (*_buf).size[0]; z2 = (_j > z6); if (z2) { RAISE (& _Convert__Failed, 0, 0); };


         _j =  0 ;
         if (_minus) { { register t23* array = & (*_buf); z4 =  0 ; if (z4 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z4 * 1));
#line 81
 }; (*(t3*)z3) =  '-' ; _j =  1 ; goto if_11_end; }; if_11_end: /**/;
         if (_prefix) {
            z2 = (_base >  9 ); if (z2) { z3 = _j; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z5 = z3; if (z5 >= (array->size[0])) RANGEFAULT;
#line 83
                  z4 = (int)(array->elts + (z5 * 1)); }; (*(t3*)z4) =  '1' ; _j +=  1 ; goto if_13_end; }; if_13_end: /**/;
            z3 = _base; z4 =  10 ; z5 = z3 - (z4 * (IDIV (z3, z4))); z1 = z5; if ((z1 < 0) || (15 < z1)) RANGEFAULT; z5 = _j;
#line 84
            if (z5 < 0) RANGEFAULT; { register t23* array = & (*_buf); z7 = z5; if (z7 >= (array->size[0])) RANGEFAULT; z4 = (int)(array->elts + (z7 * 1));
#line 84
 }; (*(t3*)z4) = (_Convert__Digits.elts[z1]); _j +=  1 ;
            z3 = _j; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z5 = z3; if (z5 >= (array->size[0])) RANGEFAULT;
#line 85
               z4 = (int)(array->elts + (z5 * 1)); }; (*(t3*)z4) =  '_' ; _j +=  1 ; goto if_12_end; }; if_12_end: /**/;

         { int from, to, index; z3 = _nDigits -  1 ; from = z3; to =  0 ; { auto t4 _k; { for (index = from; index >= to; index += -1) {
#line 87
                     _k = (t4) index;
                     z3 = _k; if (z3 > 32) RANGEFAULT; z5 = _j; if (z5 < 0) RANGEFAULT; { register t23* array = & (*_buf);
#line 88
                        z7 = z5; if (z7 >= (array->size[0])) RANGEFAULT; z4 = (int)(array->elts + (z7 * 1)); }; (*(t3*)z4) = (_result.elts[z3]);
#line 88
                     _j +=  1 ; } } }; };


         __result = _j; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 91
 }; };
#line 95 "Convert.m3"
 EXPORT t4 _Convert__FromUnsigned (_buf, _value, _base, _prefix) t1 * _buf; t4 _value; t11 _base; t10 _prefix; { t10 z2; t4 z3;
t4 z1; t4 z5; t13 z4; t4 z6; t4 z7;
#line 95 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_2, proc_0); { auto t4 _nDigits; auto t4 _j; auto t19 _result; auto t4 __result;
#line 95
      {






         ZERO  (33, & _result);
#line 100
         ZERO1  ((& _nDigits));
#line 95
         CHECKSTACKOVERFLOW;









         z2 = (_value ==  0 ); if (z2) {
            (_result.elts[ 0 ]) =  '0' ;
            _nDigits =  1 ; goto if_14_end; }; z2 = (_value !=  0 );


            if (z2) do { z3 = (unsigned)_value % (unsigned)_base;
               z1 = z3; if ((z1 < 0) || (15 < z1)) RANGEFAULT; z5 = _nDigits; if ((z5 < 0) || (32 < z5)) RANGEFAULT; (_result.elts[z5]) = (_Convert__Digits.elts[z1]);
               z3 = ((unsigned)_value / (unsigned)_base); _value = z3;
               _nDigits +=  1 ; z2 = (_value !=  0 ); } while (z2); if_14_end: /**/;




         _j = _nDigits;
         if (_prefix) { z2 = (_base >  9 ); if (z2) { _j +=  3 ; goto if_16_end; }; _j +=  2 ; if_16_end: /**/; goto if_15_end;
#line 119
 }; if_15_end: /**/;
         z4 = (*_buf).size[0]; z2 = (_j > z4); if (z2) { RAISE (& _Convert__Failed, 0, 0); };


         _j =  0 ;
         if (_prefix) {
            z2 = (_base >  9 ); if (z2) { z3 = _j; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z6 = z3; if (z6 >= (array->size[0])) RANGEFAULT;
#line 125
                  z5 = (int)(array->elts + (z6 * 1)); }; (*(t3*)z5) =  '1' ; _j +=  1 ; goto if_19_end; }; if_19_end: /**/;
            z3 = _base; z5 =  10 ; z6 = z3 - (z5 * (IDIV (z3, z5))); z1 = z6; if ((z1 < 0) || (15 < z1)) RANGEFAULT; z5 = _j;
#line 126
            if (z5 < 0) RANGEFAULT; { register t23* array = & (*_buf); z7 = z5; if (z7 >= (array->size[0])) RANGEFAULT; z6 = (int)(array->elts + (z7 * 1));
#line 126
 }; (*(t3*)z6) = (_Convert__Digits.elts[z1]); _j +=  1 ;
            z3 = _j; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z6 = z3; if (z6 >= (array->size[0])) RANGEFAULT;
#line 127
               z5 = (int)(array->elts + (z6 * 1)); }; (*(t3*)z5) =  '_' ; _j +=  1 ; goto if_18_end; }; if_18_end: /**/;

         { int from, to, index; z3 = _nDigits -  1 ; from = z3; to =  0 ; { auto t4 _k; { for (index = from; index >= to; index += -1) {
#line 129
                     _k = (t4) index;
                     z3 = _k; if (z3 > 32) RANGEFAULT; z5 = _j; if (z5 < 0) RANGEFAULT; { register t23* array = & (*_buf);
#line 130
                        z7 = z5; if (z7 >= (array->size[0])) RANGEFAULT; z6 = (int)(array->elts + (z7 * 1)); }; (*(t3*)z6) = (_result.elts[z3]);
#line 130
                     _j +=  1 ; } } }; };


         __result = _j; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 133
 }; };
#line 137 "Convert.m3"
 EXPORT t4 _Convert__FromFloat (_buf, _v, _p, _style) t1 * _buf; t8 _v; t4 _p; t24 _style; { t5 z3; t4 z6;
#line 137 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_7, proc_0); { auto t4 __result; { CHECKSTACKOVERFLOW;




         z3 = CVTFL (_v); z6 = _Convert__InternalFromLongFloat (&(*_buf), z3, _p, _style,  'E' ); __result = z6; CUT_TO_NEXT_HANDLER (hproc_0);
#line 142
         return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 142
 }; };
#line 145 "Convert.m3"
 EXPORT t4 _Convert__FromLongFloat (_buf, _v, _p, _style) t1 * _buf; t5 _v; t4 _p; t24 _style; { t4 z6;
#line 145 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_8, proc_0); { auto t4 __result; { CHECKSTACKOVERFLOW;




         z6 = _Convert__InternalFromLongFloat (&(*_buf), _v, _p, _style,  'D' ); __result = z6; CUT_TO_NEXT_HANDLER (hproc_0);
#line 150
         return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 150
 }; };
#line 154 "Convert.m3"
 PRIVATE t4 _Convert__InternalFromLongFloat (_buf, _v, _p, _style, _c) t1 * _buf; t5 _v; t4 _p; t24 _style; t3 _c; { t6 z3;
t6 z5; t6 z4; t10 z1; t13 z2; t10 z6; t4 z7; t4 z0; t13 z8; t4 z9; t4 z10;
#line 154 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_9, proc_0); { PRIVATE t17 init0 = {{ '%', '#', '.', '*', 'e' }}; auto t17 _SciFmt;
#line 154
      PRIVATE t17 init1 = {{ '%', '#', '.', '*', 'f' }}; auto t17 _FloFmt; PRIVATE t17 init2 = {{ '%', '.', '*', 'g' }}; auto t17 _MixFmt;
#line 154
      auto t15 _chars; auto t13 _len; auto t13 _i; auto t13 _j; auto t6 _a; auto t4 __result; {








         ZERO  (6, & _SciFmt);
         ZERO  (6, & _FloFmt);
         ZERO  (6, & _MixFmt);


         ZERO  (101, & _chars);
         ZERO1  (& _len);
         ZERO1  (& _i); ZERO1  (& _j);
#line 163
         COPY (& init0, (& _SciFmt), 6);
         COPY (& init1, (& _FloFmt), 6);
         COPY (& init2, (& _MixFmt), 6);



         ZERO1  ((& _len));
         ZERO1  ((& _i)); ZERO1  ((& _j));
         z3 = (char*)(& (_chars.elts[ 0 ])); _a = z3;
#line 154
         CHECKSTACKOVERFLOW;
#line 175
         switch (_style) { case 0: z5 = (char*)(& (_FloFmt.elts[ 0 ]));

            z4 = sprintf (_a, z5, _p, _v); z1 = (z4 != _a); if (z1) { RAISE (& _Convert__Failed, 0, 0); };
            z2 = _len; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); if (z6) do { _len +=  1 ; z2 = _len;
#line 178
               if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); } while (z6); break; case 1: z5 = (char*)(& (_FloFmt.elts[ 0 ]));

            z4 = sprintf (_a, z5, _p, _v); z1 = (z4 != _a); if (z1) { RAISE (& _Convert__Failed, 0, 0); };
            z2 = _i; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); if (z6) do { _i +=  1 ; z2 = _i; if (z2 > 100) RANGEFAULT;
#line 181
               z6 = ((_chars.elts[z2]) !=  '\000' ); } while (z6);
            if ((_i -=  1 ) < 0) RANGEFAULT;
            z2 = _i; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) ==  '0' ); if (z6) do { if ((_i -=  1 ) < 0) RANGEFAULT;
#line 183
               z2 = _i; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) ==  '0' ); } while (z6);
            z7 = _i +  1 ; z0 = z7; if (z0 < 0) RANGEFAULT; _len = z0; break; case 2: z5 = (char*)(& (_SciFmt.elts[ 0 ]));

            z4 = sprintf (_a, z5, _p, _v); z1 = (z4 != _a); if (z1) { RAISE (& _Convert__Failed, 0, 0); };
            z2 = _len; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  'e' ); if (z6) do { _len +=  1 ; z2 = _len; if (z2 > 100) RANGEFAULT;
#line 187
               z6 = ((_chars.elts[z2]) !=  'e' ); } while (z6);
            z8 = _len; if (z8 > 100) RANGEFAULT; (_chars.elts[z8]) = _c;
            z2 = _len; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); if (z6) do { _len +=  1 ; z2 = _len;
#line 189
               if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); } while (z6); break; case 3: z5 = (char*)(& (_SciFmt.elts[ 0 ]));

            z4 = sprintf (_a, z5, _p, _v); z1 = (z4 != _a); if (z1) { RAISE (& _Convert__Failed, 0, 0); };
            z2 = _i; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  'e' ); if (z6) do { _i +=  1 ; z2 = _i; if (z2 > 100) RANGEFAULT;
#line 192
               z6 = ((_chars.elts[z2]) !=  'e' ); } while (z6);
            z8 = _i; if (z8 > 100) RANGEFAULT; (_chars.elts[z8]) = _c;
            z7 = _i -  1 ; z0 = z7; if (z0 < 0) RANGEFAULT; _j = z0;
            z2 = _j; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) ==  '0' ); if (z6) do { if ((_j -=  1 ) < 0) RANGEFAULT;
#line 195
               z2 = _j; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) ==  '0' ); } while (z6);
            _j +=  1 ;
            z2 = _i; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); if (z6) do { z2 = _i; if (z2 > 100) RANGEFAULT;
#line 197
               z8 = _j; if (z8 > 100) RANGEFAULT; (_chars.elts[z8]) = (_chars.elts[z2]); _i +=  1 ; _j +=  1 ; z2 = _i; if (z2 > 100) RANGEFAULT;
#line 197
               z6 = ((_chars.elts[z2]) !=  '\000' ); } while (z6);
            _len = _j; break; case 4: z5 = (char*)(& (_MixFmt.elts[ 0 ]));

            z4 = sprintf (_a, z5, _p, _v); z1 = (z4 != _a); if (z1) { RAISE (& _Convert__Failed, 0, 0); };
            z2 = _len; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  'e' ); z1 = 0; if (z6) { z8 = _len; if (z8 > 100) RANGEFAULT;
#line 201
               z6 = ((_chars.elts[z8]) !=  '\000' ); z1 = z6; }; if (z1) do { _len +=  1 ; z2 = _len; if (z2 > 100) RANGEFAULT;
#line 201
               z6 = ((_chars.elts[z2]) !=  'e' ); z1 = 0; if (z6) { z8 = _len; if (z8 > 100) RANGEFAULT; z6 = ((_chars.elts[z8]) !=  '\000' );
#line 201
                  z1 = z6; }; } while (z1);
            z2 = _len; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) ==  'e' ); if (z6) {
               z8 = _len; if (z8 > 100) RANGEFAULT; (_chars.elts[z8]) = _c;
               z2 = _len; if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); if (z6) do { _len +=  1 ; z2 = _len;
#line 204
                  if (z2 > 100) RANGEFAULT; z6 = ((_chars.elts[z2]) !=  '\000' ); } while (z6); goto if_25_end; }; if_25_end: /**/;
#line 204
            break; default: /**/; };

         z2 = (*_buf).size[0]; z1 = (_len > z2); if (z1) { RAISE (& _Convert__Failed, 0, 0); };
         { int from, to, index; from =  0 ; z7 = _len -  1 ; to = z7; { auto t4 _i; { for (index = from; index <= to; index += 1) {
#line 207
                     _i = (t4) index;
                     z7 = _i; if (z7 > 100) RANGEFAULT; { register t23* array = & (*_buf); z10 = _i; if (z10 >= (array->size[0])) RANGEFAULT;
#line 208
                        z9 = (int)(array->elts + (z10 * 1)); }; (*(t3*)z9) = (_chars.elts[z7]); } } }; };
         __result = _len; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 209
 }; };
#line 216 "Convert.m3"
 EXPORT t4 _Convert__ToInt (_buf, _used, _base) t1 * _buf; t4 * _used; t11 _base; { t13 z0; t10 z2; t4 z3; t4 z1; t4 z4; t5 z5;
t10 z6; t4 z7; t5 z8; t5 z9;
#line 216 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t5 _value; auto t5 _sign; auto t5 _limit; auto t4 _n; auto t4 _z;
#line 216
      auto t5 _val2; auto t5 _rbase; auto t4 _ibase; auto t10 _based; auto t4 _i; auto t4 _j; auto t3 _c; auto t4 __result;
#line 216
      {



         ZERO2  (& _value);
         ZERO2  (& _sign);
         ZERO2  (& _limit);


         ZERO2  (& _val2);
         ZERO2  (& _rbase);

         ZERO1B (& _based);

         ZERO1B (& _c);
#line 220
         ZERO2  ((& _value));
         _sign =  1.0e+0 ;
         _limit =  2.1474836470000e+09 ;
         ZERO1  ((& _n));
         z0 = (*_buf).size[0]; _z = z0;
#line 216
         CHECKSTACKOVERFLOW;
#line 232
         z2 = (_n >= _z); if (z2) { (*_used) =  0 ; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 233
            z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1);


         z2 = (_c ==  '-' ); if (z2) {
            z5 = -  1.0e+0 ; _sign = z5;
            z5 = -  -2.1474836480000e+09 ; _limit = z5;
            _n +=  1 ;
            z2 = (_n >= _z); if (z2) { (*_used) =  0 ; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 241
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_28_end; }; z2 = (_c ==  '+' ); if (z2) {

            _n +=  1 ;
            z2 = (_n >= _z); if (z2) { (*_used) =  0 ; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 245
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_28_end; }; if_28_end: /**/;



         z2 = (_c ==  '0' ); if (z2) do { _n +=  1 ;

            z2 = (_n >= _z); if (z2) { (*_used) = _n; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 252
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); z2 = (_c ==  '0' ); } while (z2);



         z2 = (_c ==  '1' ); z6 = 0; if (z2) { z3 = _n +  3 ; z2 = (z3 < _z); z6 = z2; }; z2 = 0; if (z6) { z4 = _n +  2 ;
#line 256
            z1 = z4; if (z1 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z1; if (z4 >= (array->size[0])) RANGEFAULT;
#line 256
               z3 = (int)(array->elts + (z4 * 1)); }; z6 = ((*(t3*)z3) ==  '_' ); z2 = z6; }; z6 = 0; if (z2) { z4 = _n +  1 ;
#line 256
            z3 = z4; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z7 = z3; if (z7 >= (array->size[0])) RANGEFAULT;
#line 256
               z4 = (int)(array->elts + (z7 * 1)); }; z2 = ( '0'  <= (*(t3*)z4)); z6 = z2; }; z2 = 0; if (z6) { z4 = _n +  1 ;
#line 256
            z1 = z4; if (z1 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z1; if (z4 >= (array->size[0])) RANGEFAULT;
#line 256
               z3 = (int)(array->elts + (z4 * 1)); }; z6 = ((*(t3*)z3) <=  '6' ); z2 = z6; }; if (z2) {


            _based =  1 ;
            z4 = _n +  1 ; z3 = z4; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z7 = z3; if (z7 >= (array->size[0])) RANGEFAULT;
#line 260
               z4 = (int)(array->elts + (z7 * 1)); }; z3 =  10  + (*(t3*)z4); z1 = z3 -  48 ; _ibase = z1;
            _n +=  3 ;
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 262
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_32_end; }; z2 = ( '2'  <= _c); z6 = 0; if (z2) {
#line 262
            z2 = (_c <=  '9' ); z6 = z2; }; z2 = 0; if (z6) { z3 = _n +  2 ; z6 = (z3 < _z); z2 = z6; }; z6 = 0; if (z2) {
#line 262
            z3 = _n +  1 ; z1 = z3; if (z1 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z1; if (z4 >= (array->size[0])) RANGEFAULT;
#line 262
               z3 = (int)(array->elts + (z4 * 1)); }; z2 = ((*(t3*)z3) ==  '_' ); z6 = z2; }; if (z6) {


            _based =  1 ;
            z3 = _c -  48 ; _ibase = z3;
            _n +=  2 ;
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 268
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_32_end; }; _based =  0 ;



            _ibase = _base; if_32_end: /**/;

         z5 = CVTIL (_ibase); _rbase = z5;


         _j = _n;
         loop_1:; z2 = ( '0'  <= _c);
            z6 = 0; if (z2) { z2 = (_c <=  '9' ); z6 = z2; }; if (z6) { z3 = _c -  48 ; _i = z3; goto if_33_end; }; z2 = ( 'A'  <= _c);
#line 279
            z6 = 0; if (z2) { z2 = (_c <=  'F' ); z6 = z2; }; if (z6) {
               z3 = _c -  65 ; z1 = z3 +  10 ; _i = z1; goto if_33_end; }; z2 = ( 'a'  <= _c); z6 = 0; if (z2) { z2 = (_c <=  'f' );
#line 280
               z6 = z2; }; if (z6) {
               z3 = _c -  97 ; z1 = z3 +  10 ; _i = z1; goto if_33_end; }; goto loop_exit_1;
 if_33_end: /**/;

            z2 = (_i >= _ibase); if (z2) { goto loop_exit_1; };
            z5 = _value * _rbase; z8 = CVTIL (_i); z9 = z5 + z8; _val2 = z9;
            z2 = (_val2 > _limit); if (z2) { goto loop_exit_1; };
            _value = _val2;
            _n +=  1 ;
            z2 = (_n >= _z); if (z2) { goto loop_exit_1; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 290
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto loop_1; loop_exit_1: /**/;


         z2 = (_j == _n); z6 = 0; if (z2) { z6 = _based; }; if (z6) {

            z2 = (_ibase <  10 ); if (z2) {
               _n -=  1 ;
               z2 = (_ibase < _base); if (z2) {
                  z5 = CVTIL (_ibase); _value = z5; goto if_39_end; }; _n -=  1 ;

 if_39_end: /**/; goto if_38_end; }; _n -=  1 ;





               z3 = _ibase -  10 ; z2 = (z3 < _base); if (z2) {
                  z3 = _base + _ibase; z1 = z3 -  10 ; z5 = CVTIL (z1); _value = z5; goto if_40_end; }; _n -=  1 ;


                  z5 = CVTIL (_base); _value = z5; if_40_end: /**/; if_38_end: /**/; goto if_37_end; }; if_37_end: /**/;





         (*_used) = _n;
         z5 = _sign * _value; z1 = TRUNC (z5); __result = z1; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0:
#line 317
 CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 320 "Convert.m3"
 EXPORT t4 _Convert__ToUnsigned (_buf, _used, _base) t1 * _buf; t4 * _used; t11 _base; { t13 z0; t10 z2; t4 z3; t4 z1; t4 z4;
t10 z5; t4 z6; t5 z7; t5 z8; t5 z9;
#line 320 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { PRIVATE t5 _lastint = 2.1474836470000e+09; PRIVATE t5 _limit = 4.2949672950000e+09;
#line 320
      auto t5 _value; auto t4 _n; auto t4 _z; auto t5 _val2; auto t5 _rbase; auto t4 _ibase; auto t10 _based; auto t4 _i;
#line 320
      auto t4 _j; auto t3 _c; auto t4 __result; {






         ZERO2  (& _value);


         ZERO2  (& _val2);
         ZERO2  (& _rbase);

         ZERO1B (& _based);

         ZERO1B (& _c);
#line 327
         ZERO2  ((& _value));
         ZERO1  ((& _n));
         z0 = (*_buf).size[0]; _z = z0;
#line 320
         CHECKSTACKOVERFLOW;
#line 337
         z2 = (_n >= _z); if (z2) { (*_used) = _n; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 338
            z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1);


         z2 = (_c ==  '+' ); if (z2) {
            _n +=  1 ;
            z2 = (_n >= _z); if (z2) { (*_used) =  0 ; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 344
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_42_end; }; if_42_end: /**/;



         z2 = (_c ==  '0' ); if (z2) do { _n +=  1 ;

            z2 = (_n >= _z); if (z2) { (*_used) = _n; __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 351
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); z2 = (_c ==  '0' ); } while (z2);



         z2 = (_c ==  '1' ); z5 = 0; if (z2) { z3 = _n +  3 ; z2 = (z3 < _z); z5 = z2; }; z2 = 0; if (z5) { z4 = _n +  2 ;
#line 355
            z1 = z4; if (z1 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z1; if (z4 >= (array->size[0])) RANGEFAULT;
#line 355
               z3 = (int)(array->elts + (z4 * 1)); }; z5 = ((*(t3*)z3) ==  '_' ); z2 = z5; }; z5 = 0; if (z2) { z4 = _n +  1 ;
#line 355
            z3 = z4; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z6 = z3; if (z6 >= (array->size[0])) RANGEFAULT;
#line 355
               z4 = (int)(array->elts + (z6 * 1)); }; z2 = ( '0'  <= (*(t3*)z4)); z5 = z2; }; z2 = 0; if (z5) { z4 = _n +  1 ;
#line 355
            z1 = z4; if (z1 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z1; if (z4 >= (array->size[0])) RANGEFAULT;
#line 355
               z3 = (int)(array->elts + (z4 * 1)); }; z5 = ((*(t3*)z3) <=  '6' ); z2 = z5; }; if (z2) {


            _based =  1 ;
            z4 = _n +  1 ; z3 = z4; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z6 = z3; if (z6 >= (array->size[0])) RANGEFAULT;
#line 359
               z4 = (int)(array->elts + (z6 * 1)); }; z3 =  10  + (*(t3*)z4); z1 = z3 -  48 ; _ibase = z1;
            _n +=  3 ;
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 361
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_45_end; }; z2 = ( '2'  <= _c); z5 = 0; if (z2) {
#line 361
            z2 = (_c <=  '9' ); z5 = z2; }; z2 = 0; if (z5) { z3 = _n +  2 ; z5 = (z3 < _z); z2 = z5; }; z5 = 0; if (z2) {
#line 361
            z3 = _n +  1 ; z1 = z3; if (z1 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z1; if (z4 >= (array->size[0])) RANGEFAULT;
#line 361
               z3 = (int)(array->elts + (z4 * 1)); }; z2 = ((*(t3*)z3) ==  '_' ); z5 = z2; }; if (z5) {


            _based =  1 ;
            z3 = _c -  48 ; _ibase = z3;
            _n +=  2 ;
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 367
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto if_45_end; }; _based =  0 ;



            _ibase = _base; if_45_end: /**/;

         z7 = CVTIL (_ibase); _rbase = z7;

         _j = _n;
         loop_2:; z2 = ( '0'  <= _c);
            z5 = 0; if (z2) { z2 = (_c <=  '9' ); z5 = z2; }; if (z5) { z3 = _c -  48 ; _i = z3; goto if_46_end; }; z2 = ( 'A'  <= _c);
#line 377
            z5 = 0; if (z2) { z2 = (_c <=  'F' ); z5 = z2; }; if (z5) {
               z3 = _c -  65 ; z1 = z3 +  10 ; _i = z1; goto if_46_end; }; z2 = ( 'a'  <= _c); z5 = 0; if (z2) { z2 = (_c <=  'f' );
#line 378
               z5 = z2; }; if (z5) {
               z3 = _c -  97 ; z1 = z3 +  10 ; _i = z1; goto if_46_end; }; goto loop_exit_2;
 if_46_end: /**/;

            z2 = (_i >= _ibase); if (z2) { goto loop_exit_2; };
            z7 = _value * _rbase; z8 = CVTIL (_i); z9 = z7 + z8; _val2 = z9;
            z2 = (_val2 > _limit); if (z2) { goto loop_exit_2; };
            _value = _val2;
            _n +=  1 ;
            z2 = (_n >= _z); if (z2) { goto loop_exit_2; };
            z3 = _n; if (z3 < 0) RANGEFAULT; { register t23* array = & (*_buf); z4 = z3; if (z4 >= (array->size[0])) RANGEFAULT;
#line 388
               z1 = (int)(array->elts + (z4 * 1)); }; _c = (*(t3*)z1); goto loop_2; loop_exit_2: /**/;


         z2 = (_j == _n); z5 = 0; if (z2) { z5 = _based; }; if (z5) {

            z2 = (_ibase <  10 ); if (z2) {
               _n -=  1 ;
               z2 = (_ibase < _base); if (z2) {
                  z7 = CVTIL (_ibase); _value = z7; goto if_52_end; }; _n -=  1 ;

 if_52_end: /**/; goto if_51_end; }; _n -=  1 ;





               z3 = _ibase -  10 ; z2 = (z3 < _base); if (z2) {
                  z3 = _base + _ibase; z1 = z3 -  10 ; z7 = CVTIL (z1); _value = z7; goto if_53_end; }; _n -=  1 ;


                  z7 = CVTIL (_base); _value = z7; if_53_end: /**/; if_51_end: /**/; goto if_50_end; }; if_50_end: /**/;





         (*_used) = _n;
         z2 = (_value > _lastint); if (z2) {
            z7 = _lastint +  1.0e0 ; z8 = z7 -  -2.1474836480000e+09 ; z7 = _value - z8; _value = z7; goto if_54_end; }; if_54_end: /**/;

         z1 = TRUNC (_value); __result = z1; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 418
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 421 "Convert.m3"
 EXPORT t8 _Convert__ToFloat (_buf, _used) t1 * _buf; t4 * _used; { t13 z0; t2 z1; t4 z3; t4 z2; t2 z4; t4 z5; t4 z6; t10 z7;
t6 z8; t5 z9; t8 z10;
#line 421 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_5, proc_0); { auto t6 _eptr; auto t5 _value; auto t2 _chars; auto t4 _nchars;
#line 421
      auto t8 __result; {



         ZERO2  (& _value);
#line 421
         ZERO1  (& __result);





         z0 = (*_buf).size[0]; _nchars = z0;
#line 421
         CHECKSTACKOVERFLOW;
#line 432
         { register t23* ptr; int sz[1]; z3 = _nchars +  1 ; sz[0] = z3; ptr = (t23*) UNEWA(TC2, 8 + sz[0] * 1); ptr->elts = (char*)(& ptr->size[1]);
#line 432
            ptr->size[0] = sz[0]; z1 = (t2) ptr; }; _chars = z1;

         { int from, to, index; from =  0 ; z2 = _nchars -  1 ; to = z2; { auto t4 _i; { for (index = from; index <= to; index += 1) {
#line 434
                     _i = (t4) index; { register t23* array = & (*_buf); z3 = _i; if (z3 >= (array->size[0])) RANGEFAULT;
#line 434
                        z2 = (int)(array->elts + (z3 * 1)); }; NILCHECKB (z4 = _chars); { register t23* array = & (*((t1*) z4));
#line 434
                        z6 = _i; if (z6 >= (array->size[0])) RANGEFAULT; z5 = (int)(array->elts + (z6 * 1)); }; (*(t3*)z5) = (*(t3*)z2);
#line 434
                     } } }; };
         NILCHECKB (z4 = _chars); z3 = _nchars; if (z3 < 0) RANGEFAULT; { register t23* array = & (*((t1*) z4)); z5 = z3;
#line 435
            if (z5 >= (array->size[0])) RANGEFAULT; z2 = (int)(array->elts + (z5 * 1)); }; (*(t3*)z2) =  '\000' ;

         { int from, to, index; from =  0 ; z2 = _nchars -  1 ; to = z2; { auto t4 _i; { for (index = from; index <= to; index += 1) {
#line 437
                     _i = (t4) index;
                     NILCHECKB (z1 = _chars); { register t23* array = & (*((t1*) z1)); z5 = _i; if (z5 >= (array->size[0])) RANGEFAULT;
#line 438
                        z3 = (int)(array->elts + (z5 * 1)); }; z7 = ((*(t3*)z3) ==  'E' ); if (z7) { NILCHECKB (z4 = _chars);
#line 438
                        { register t23* array = & (*((t1*) z4)); z5 = _i; if (z5 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z5 * 1));
#line 438
 }; (*(t3*)z3) =  'e' ; goto for_4; }; } } }; }; for_4: /**/;

         NILCHECKB (z4 = _chars); { register t23* array = & (*((t1*) z4)); z5 =  0 ; if (z5 >= (array->size[0])) RANGEFAULT;
#line 440
            z3 = (int)(array->elts + (z5 * 1)); }; z8 = (char*)(& (*(t3*)z3)); z9 = strtod (z8, &_eptr); _value = z9;
         z2 =  0 ; z7 = (_eptr == (*((t6*)(& z2)))); if (z7) {
            UVDISPOSE(& _chars);
            RAISE (& _Convert__Failed, 0, 0); }; NILCHECKB (z4 = _chars);

            { register t23* array = & (*((t1*) z4)); z5 =  0 ; if (z5 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z5 * 1));
#line 445
 }; z8 = (char*)(& (*(t3*)z3)); z2 = (t4) (((char*)_eptr) - ((char *)z8)); (*_used) = z2;
            UVDISPOSE(& _chars);
            z10 = CVTLF (_value); __result = z10; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 447
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 450 "Convert.m3"
 EXPORT t5 _Convert__ToLongFloat (_buf, _used) t1 * _buf; t4 * _used; { t13 z0; t2 z1; t4 z3; t4 z2; t2 z4; t4 z5; t4 z6;
t10 z7; t10 z8; t6 z9; t5 z10;
#line 450 "Convert.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_6, proc_0); { auto t6 _eptr; auto t5 _value; auto t2 _chars; auto t4 _nchars;
#line 450
      auto t5 __result; {



         ZERO2  (& _value);
#line 450
         ZERO2  (& __result);





         z0 = (*_buf).size[0]; _nchars = z0;
#line 450
         CHECKSTACKOVERFLOW;
#line 461
         { register t23* ptr; int sz[1]; z3 = _nchars +  1 ; sz[0] = z3; ptr = (t23*) UNEWA(TC2, 8 + sz[0] * 1); ptr->elts = (char*)(& ptr->size[1]);
#line 461
            ptr->size[0] = sz[0]; z1 = (t2) ptr; }; _chars = z1;

         { int from, to, index; from =  0 ; z2 = _nchars -  1 ; to = z2; { auto t4 _i; { for (index = from; index <= to; index += 1) {
#line 463
                     _i = (t4) index; { register t23* array = & (*_buf); z3 = _i; if (z3 >= (array->size[0])) RANGEFAULT;
#line 463
                        z2 = (int)(array->elts + (z3 * 1)); }; NILCHECKB (z4 = _chars); { register t23* array = & (*((t1*) z4));
#line 463
                        z6 = _i; if (z6 >= (array->size[0])) RANGEFAULT; z5 = (int)(array->elts + (z6 * 1)); }; (*(t3*)z5) = (*(t3*)z2);
#line 463
                     } } }; };
         NILCHECKB (z4 = _chars); z3 = _nchars; if (z3 < 0) RANGEFAULT; { register t23* array = & (*((t1*) z4)); z5 = z3;
#line 464
            if (z5 >= (array->size[0])) RANGEFAULT; z2 = (int)(array->elts + (z5 * 1)); }; (*(t3*)z2) =  '\000' ;
         { int from, to, index; from =  0 ; z2 = _nchars -  1 ; to = z2; { auto t4 _i; { for (index = from; index <= to; index += 1) {
#line 465
                     _i = (t4) index;
                     NILCHECKB (z1 = _chars); { register t23* array = & (*((t1*) z1)); z5 = _i; if (z5 >= (array->size[0])) RANGEFAULT;
#line 466
                        z3 = (int)(array->elts + (z5 * 1)); }; z7 = ((*(t3*)z3) ==  'D' ); z8 = 1; if (! z7) { NILCHECKB (z1 = _chars);
#line 466
                        { register t23* array = & (*((t1*) z1)); z5 = _i; if (z5 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z5 * 1));
#line 466
 }; z7 = ((*(t3*)z3) ==  'd' ); z8 = z7; }; if (z8) { NILCHECKB (z4 = _chars); { register t23* array = & (*((t1*) z4)); z5 = _i;
#line 466
                           if (z5 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z5 * 1)); }; (*(t3*)z3) =  'e' ;
#line 466
                        goto for_6; }; } } }; }; for_6: /**/;

         NILCHECKB (z4 = _chars); { register t23* array = & (*((t1*) z4)); z5 =  0 ; if (z5 >= (array->size[0])) RANGEFAULT;
#line 468
            z3 = (int)(array->elts + (z5 * 1)); }; z9 = (char*)(& (*(t3*)z3)); z10 = strtod (z9, &_eptr); _value = z10;
         z2 =  0 ; z7 = (_eptr == (*((t6*)(& z2)))); if (z7) {
            UVDISPOSE(& _chars);
            RAISE (& _Convert__Failed, 0, 0); }; NILCHECKB (z4 = _chars);

            { register t23* array = & (*((t1*) z4)); z5 =  0 ; if (z5 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z5 * 1));
#line 473
 }; z9 = (char*)(& (*(t3*)z3)); z2 = (t4) (((char*)_eptr) - ((char *)z9)); (*_used) = z2;
            UVDISPOSE(& _chars);
            __result = _value; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 475
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };  PRIVATE int init_done = -1;
#line 475 "Convert.m3"
 PRIVATE void Convert__initProc (g) int g; { t21 z0;
#line 475 "Convert.m3"
if (init_done >= g) return; init_done = g; INITIALIZE (& Convert__init); INITIALIZE (& CConvert__init); INITIALIZE (& Word__init);
#line 14
ZERO4  (& _Convert__Digits); z0.elts[0] =  '0' ; z0.elts[1] =  '1' ; z0.elts[2] =  '2' ; z0.elts[3] =  '3' ; z0.elts[4] =  '4' ;
#line 14
z0.elts[5] =  '5' ; z0.elts[6] =  '6' ; z0.elts[7] =  '7' ; z0.elts[8] =  '8' ; z0.elts[9] =  '9' ; z0.elts[10] =  'a' ; z0.elts[11] =  'b' ;
#line 14
z0.elts[12] =  'c' ; z0.elts[13] =  'd' ; z0.elts[14] =  'e' ; z0.elts[15] =  'f' ; _Convert__Digits = z0;
#line 475
return; }; 
#line 475 "Convert.m3"
PRIVATE void t2_PrintProc (ref) t1* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC2->brand); fprintf (stderr, "^ = array");
#line 475
   fprintf (stderr, "}\n"); };   PRIVATE INITLINK me_0 ={(INITLINK*)NIL, 0, Convert__initProc}; static char* VSimports[] = {
   &VS_Word__Divide__48d9c1b03852635b, &VS_Word__Mod__93daaa5234221794, &VS_Convert__Failed__2816e40d3f5c20d1, NIL };  void Convert__MLink (phase) int phase; { switch (phase) { case 0: { me_0.link = Convert__init; Convert__init = & me_0; t2_TC = t2_TC_init;
         REGISTERTYPE (TC2); break; }; case 1: { break; }; case 2: { break; }; }; };