#include "M3Runtime.h"

typedef struct { int tc; char* str; int len; } TXT; PRIVATE TXT txt1 = { 3, "Who\047s changing rd without the lock?", 36};
#line 27 "./RdClass.i3"
#define t20 ADDRESS
#define t36 void
typedef unsigned char t7;
#line 173 "./Rd.i3"
typedef struct { char* elts; int size[1]; } t24;
#line 259 "RdMove.m3"
#define t11 t24
PRIVATE void t20_PrintProc ();
#line 27 "./RdClass.i3"
PRIVATE typecell t20_TC; PRIVATE typecell t20_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,   -2, 0, NIL, 1, 1, (PROC)NIL, (PROC)NIL, t20_PrintProc,
#line 27
  "", 991118862, 833218118}; PRIVATE TYPE TC20 = &t20_TC;  
#define t26 ADDRESS
#define TC26 TC_REFANY
IMPORT TYPE TC_REFANY; IMPORT char VS_REFANY__4b8748e831fc107a; 
#define t38 ADDRESS
typedef int t10; 
#define TC38 TC_ADDRESS
IMPORT TYPE TC_ADDRESS; IMPORT char VS_ADDRESS__30f7308738738b44; 
#define t39 ADDRESS
#define TC39 TC_NULL
IMPORT TYPE TC_NULL; IMPORT char VS_NULL__fb50c7d53bec30dc; 
#define t23 ADDRESS
 typedef struct { TYPE self; int private; } t23_methods; 
#define t23_msize (sizeof (t23_methods))
typedef struct { ADDRESS methods; } t23_fields; 
#define t23_size (sizeof (t23_fields))
#define TC23 TC_ROOT
IMPORT TYPE TC_ROOT; IMPORT char VS_ROOT__349f58f628be0ac6; 
#define t23_MapProc TC_ROOT->mapProc
#define t1 ADDRESS
#define TC1 TC_Rd__T
IMPORT TYPE TC_Rd__T;
#line 83 "./Rd.i3"
IMPORT char VS_Rd__T__2555b70b3f7780b1; 
#define t1_MapProc TC_Rd__T->mapProc
typedef t36 (*t2)(); typedef int t3;
#line 326 "RdMove.m3"
typedef t3 (*t4)(); typedef unsigned char t5;
#line 310
typedef t5 (*t6)(); 
#define t8 ADDRESS
#define TC8 TC_TEXT
IMPORT TYPE TC_TEXT; IMPORT char VS_TEXT__b7a92447326386f5; 
#define t8_MapProc TC_TEXT->mapProc
typedef t8 (*t9)();
#line 100
typedef t7 (*t12)();
#line 20
#define t13 ADDRESS
 
#define t14 ADDRESS
#define TC14 TC_MUTEX
IMPORT TYPE TC_MUTEX; IMPORT char VS_MUTEX__1f9d4e89391ab815; 
#define t14_MapProc TC_MUTEX->mapProc
typedef struct {
#line 20
   int filler; } t13_methods; 
#define t13_msize (sizeof (t13_methods))
typedef struct {
#line 20
 t10 _next; t10 _stop; } t13_fields; 
#define t13_size (sizeof (t13_fields))
PRIVATE void t13_InitProc ();
#line 20
PRIVATE void t13_SetupProc (); PRIVATE void t13_PrintProc (); PRIVATE void t13_MapProc (); PRIVATE typecell t13_TC; PRIVATE typecell t13_TC_init = {0, 0, 0, 0, 0, t13_MapProc,
#line 20
  t13_size, t13_msize, NIL, 0, 0, t13_InitProc,   t13_SetupProc,   t13_PrintProc, "RdMove#$%^_0002", 768244484, 976067969}; PRIVATE TYPE TC13 = &t13_TC;
#line 20

#line 67 ".ROOT/.boots/corelib/Interfaces/Text.i3"
typedef signed_char t15; typedef t15 (*t16)();
#line 63
typedef t10 (*t17)();
#line 23 "./RdClass.i3"
typedef unsigned char t18;








typedef t18 (*t19)();
#line 26
#define t21 ADDRESS

#line 22
#define t22 ADDRESS
#define TC22 TC_RdClass__Private
IMPORT TYPE TC_RdClass__Private;
#line 22
IMPORT char VS_RdClass__Private__5594af883f1b8361; 
#define t22_MapProc TC_RdClass__Private->mapProc
typedef struct {

   t19 _seek; t4 _length; t2 _close; } t21_methods; 
#define t21_msize (sizeof (t21_methods))
typedef struct {
#line 26
 t20 _buff; t3 _st; t3 _lo; t3 _hi; t3 _cur; t5 _closed; t5 _seekable; t5 _intermittent; } t21_fields; 
#define t21_size (sizeof (t21_fields))
#define TC21 TC_Rd__T
#define t21_MapProc TC_Rd__T->mapProc
typedef unsigned char t25;
#line 15 ".ROOT/.boots/corelib/Interfaces/Thread.i3"
#define t27 ADDRESS
#define TC27 TC_Thread__T
IMPORT TYPE TC_Thread__T;
#line 15
IMPORT char VS_Thread__T__2555b70b3f7780b1; 
#define t27_MapProc TC_Thread__T->mapProc
typedef t26 (*t28)();



#define t29 ADDRESS
#define TC29 TC_Thread__Condition
IMPORT TYPE TC_Thread__Condition;
#line 21
IMPORT char VS_Thread__Condition__26d5968239e08f4e; 
#define t29_MapProc TC_Thread__Condition->mapProc
typedef t27 (*t30)(); 
#define t31 ADDRESS

#line 23
typedef struct { t28 _apply; } t31_methods; 
#define t31_msize (sizeof (t31_methods))
typedef struct {
#line 23
 int filler; } t31_fields; 
#define t31_size (sizeof (t31_fields))
#define TC31 TC_Thread__Closure
IMPORT TYPE TC_Thread__Closure;
#line 23
IMPORT char VS_Thread__Closure__7fb5c6232c5a658a; 
#define t31_MapProc TC_Thread__Closure->mapProc
typedef t29 (*t32)();





typedef t14 (*t33)();
#line 28
#define t34 ADDRESS

#line 28
typedef struct { int filler; } t34_methods; 
#define t34_msize (sizeof (t34_methods))
typedef struct {
#line 28
 t3 _stackSize; } t34_fields; 
#define t34_size (sizeof (t34_fields))
#define TC34 TC_Thread__SizedClosure
IMPORT TYPE TC_Thread__SizedClosure;
#line 28
IMPORT char VS_Thread__SizedClosure__8a46717d2eae7b07; 
#define t34_MapProc TC_Thread__SizedClosure->mapProc
typedef CLOSURE t35; 
#define t37 ADDRESS
 typedef struct { TYPE self; int private; } t37_methods; 
#define t37_msize (sizeof (t37_methods))
typedef struct { ADDRESS methods; } t37_fields; 
#define t37_size (sizeof (t37_fields))
#define TC37 TC_UNTRACED_ROOT
IMPORT TYPE TC_UNTRACED_ROOT; IMPORT char VS_UNTRACED_ROOT__3e0964513fd6da20; typedef double t40; typedef float t41;
#line 14 "RdMove.m3"
IMPORT INITLINK* Thread__init; IMPORT INITLINK* Text__init; IMPORT INITLINK* UnsafeRd__init; IMPORT INITLINK* RdClass__init;
#line 14
IMPORT INITLINK* Rd__init;  IMPORT char VS_Thread__DefaultStackSize__0c949e2e2def4e40; IMPORT TYPE TC_Thread__Mutex; IMPORT char VS_Thread__Mutex__4f5c12072cdeec3e;
#line 14
IMPORT t36 _Thread__Acquire (); IMPORT char VS_Thread__Acquire__4f2412f3260f1927; IMPORT t36 _Thread__Release (); IMPORT char VS_Thread__Release__539a01d7243a726e;
#line 14
IMPORT EXCEPTION_NAME _Thread__Alerted; IMPORT char VS_Thread__Alerted__fc88feb43485af46;   IMPORT TYPE TC_Text__T; IMPORT char VS_Text__T__fc4b369f3ab271fd;
#line 14
IMPORT t8 _Text__FromChar (); IMPORT char VS_Text__FromChar__3896ff8a3ced0505;   IMPORT EXCEPTION_NAME _Rd__EndOfFile; IMPORT char VS_Rd__EndOfFile__f4a9d2f63b7e105d;
#line 14
IMPORT EXCEPTION_NAME _Rd__Error; IMPORT char VS_Rd__Error__5ca07bfe2ba90cfc; IMPORT EXCEPTION_NAME _Rd__Failure; IMPORT char VS_Rd__Failure__e4a829e331222b6d;
#line 14
EXPORT t7 _UnsafeRd__FastGetChar (); EXPORT char VS_UnsafeRd__FastGetChar__d61c45c120a861fa = '\0'; EXPORT t5 _UnsafeRd__FastEOF ();
#line 14
EXPORT char VS_UnsafeRd__FastEOF__8dcdeac33eabb5a2 = '\0'; EXPORT t36 _RdClass__Lock (); EXPORT char VS_RdClass__Lock__18b695322b66d4f7 = '\0';
#line 14
EXPORT t36 _RdClass__Unlock (); EXPORT char VS_RdClass__Unlock__95d99bea22c580a4 = '\0'; EXPORT t3 _RdClass__LengthDefault ();
#line 14
EXPORT char VS_RdClass__LengthDefault__76d0ecc72f6b16a1 = '\0'; EXPORT t36 _RdClass__CloseDefault (); EXPORT char VS_RdClass__CloseDefault__f0ed7e3d26d0db8a = '\0';
#line 14
EXPORT t7 _Rd__GetChar (); EXPORT char VS_Rd__GetChar__b862e140341dc281 = '\0'; EXPORT t5 _Rd__EOF (); EXPORT char VS_Rd__EOF__de1236163464f628 = '\0';
#line 14
EXPORT t36 _Rd__UnGetChar (); EXPORT char VS_Rd__UnGetChar__cfe78aee2242727d = '\0'; EXPORT t3 _Rd__CharsReady (); EXPORT char VS_Rd__CharsReady__c71bd08d36ce98be = '\0';
#line 14
EXPORT t3 _Rd__GetSub (); EXPORT char VS_Rd__GetSub__5bc9bffa25f581d0 = '\0'; EXPORT t3 _Rd__GetSubLine (); EXPORT char VS_Rd__GetSubLine__52bea04823473e53 = '\0';
#line 14
EXPORT t8 _Rd__GetText (); EXPORT char VS_Rd__GetText__aa3f5d9c2ebab9d8 = '\0'; EXPORT t8 _Rd__GetLine (); EXPORT char VS_Rd__GetLine__62ae7a642adcb6a2 = '\0';
#line 14
EXPORT t3 _Rd__GetIndex (); EXPORT char VS_Rd__GetIndex__d7acac963f5a5f40 = '\0'; EXPORT t3 _Rd__GetLength (); EXPORT char VS_Rd__GetLength__b92382e624211e48 = '\0';
#line 14
EXPORT t36 _Rd__Seek (); EXPORT char VS_Rd__Seek__62deb13c3a86d3a1 = '\0'; EXPORT t36 _Rd__Close (); EXPORT char VS_Rd__Close__adf5eb9535b06daa = '\0';
#line 14
EXPORT t5 _Rd__Intermittent (); EXPORT char VS_Rd__Intermittent__cfa32e1234ff87ed = '\0'; EXPORT t5 _Rd__Seekable (); EXPORT char VS_Rd__Seekable__3d75b5ab3bcc7efc = '\0';
#line 14
EXPORT t5 _Rd__Closed (); EXPORT char VS_Rd__Closed__8bfb8a273330b43e = '\0'; PRIVATE t36 _RdMove__MakeValid (); PRIVATE t36 _RdMove__MakeClean ();
#line 14
PRIVATE t7 _RdMove__SlowGetChar (); PRIVATE t5 _RdMove__SlowEOF ();  EXPORT char VS_RdClass__Private__278da0cb3176cc80 = '\0';
#line 14
IMPORT char VS_Rd__T__3cb9710e23a32fd2; IMPORT char VS_Rd__T__425fee3d37f2ccaf;    
#line 97
PRIVATE EXCEPTION_NAME *raises_4 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, & _Rd__EndOfFile, (EXCEPTION_NAME *) NULL};
#line 118
PRIVATE EXCEPTION_NAME *raises_5 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};







PRIVATE EXCEPTION_NAME *raises_18 [] = { & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};
#line 141
PRIVATE EXCEPTION_NAME *raises_6 [] = { & _Rd__Error, (EXCEPTION_NAME *) NULL};
#line 205
PRIVATE EXCEPTION_NAME *raises_12 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};
#line 256
PRIVATE EXCEPTION_NAME *raises_8 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};
#line 267
PRIVATE EXCEPTION_NAME *raises_9 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};
#line 278
PRIVATE EXCEPTION_NAME *raises_10 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, & _Rd__EndOfFile, (EXCEPTION_NAME *) NULL};
#line 323
PRIVATE EXCEPTION_NAME *raises_11 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};





PRIVATE EXCEPTION_NAME *raises_17 [] = { & _Rd__Error, & _Thread__Alerted, & _Rd__Failure, (EXCEPTION_NAME *) NULL};
#line 48 "RdMove.m3"
 PRIVATE t36 _RdMove__MakeValid (_rd) t1 _rd; { t1 z1; t1 z0; t10 z3; t5 z2; t10 z4;
#line 48 "RdMove.m3"
{ { CHECKSTACKOVERFLOW;


      NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = -  1 ; z2 = ((((t13_fields*)(z0+(0)))->_next) != z3); if (z2) {
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = (((t21_fields*)(z0+(0+t13_size)))->_lo) + (((t13_fields*)(z0+(0)))->_next);
#line 52
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z4 = z3 - (((t21_fields*)(z0+(0+t13_size)))->_st); z3 = z4;
#line 52
         if (z3 < 0) RANGEFAULT; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t21_fields*)(z0+(0+t13_size)))->_cur) = z3;
#line 52
         goto if_1_end; }; if_1_end: /**/; } } };
#line 59 "RdMove.m3"
 PRIVATE t36 _RdMove__MakeClean (_rd) t1 _rd; { t1 z1; t1 z0; t5 z3; t5 z2; t5 z4; t10 z5; t10 z6; t8 z7;
#line 59 "RdMove.m3"
{ { CHECKSTACKOVERFLOW;

      NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t21_fields*)(z0+(0+t13_size)))->_lo) <= (((t21_fields*)(z0+(0+t13_size)))->_cur));
#line 61
      z2 = 0; if (z3) { NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z4 = ((((t21_fields*)(z0+(0+t13_size)))->_cur) < (((t21_fields*)(z0+(0+t13_size)))->_hi));
#line 61
         z2 = z4; }; z3 = 0; if (z2) { NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z4 = ((((t21_fields*)(z0+(0+t13_size)))->_buff) != 0);
#line 61
         z3 = z4; }; if (z3) {
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z5 = (((t21_fields*)(z0+(0+t13_size)))->_st) + (((t21_fields*)(z0+(0+t13_size)))->_cur);
#line 62
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z6 = z5 - (((t21_fields*)(z0+(0+t13_size)))->_lo); NILCHECKA (z1 = _rd);
#line 62
         z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_next) = z6;
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z5 = (((t21_fields*)(z0+(0+t13_size)))->_st) + (((t21_fields*)(z0+(0+t13_size)))->_hi);
#line 63
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z6 = z5 - (((t21_fields*)(z0+(0+t13_size)))->_lo); NILCHECKA (z1 = _rd);
#line 63
         z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_stop) = z6;
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t13_fields*)(z0+(0)))->_stop) < (((t13_fields*)(z0+(0)))->_next));
#line 64
         if (z3) {
            z7 = ((ADDRESS)(& txt1.str)); RAISE (& _Rd__Failure, & z7, 4); }; goto if_2_end; }; z5 = -  1 ;


         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_stop) = z5;
         z5 = -  1 ; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_next) = z5; if_2_end: /**/;
#line 69
      } } };
#line 73 "RdMove.m3"
 PRIVATE t7 _RdMove__SlowGetChar (_rd) t1 _rd; { t1 z1; t1 z0; t25 z2; t19 z3; t18 z4; t5 z5; t20 z6; t1 z7; t10 z8; t10 z9;
t10 z10;
#line 73 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_4, proc_0); { auto t7 _res; auto t7 __result; {


         ZERO1B (& _res);
#line 73
         ZERO1B (& __result); CHECKSTACKOVERFLOW;




         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) { z2 =  0 ;
#line 78
            RAISE (& _Rd__Error, & z2, 1); };





         { HANDLER hfinally_0; PUSH_FINALLY (hfinally_0, finally_0);
#line 80
            _RdMove__MakeValid (_rd);
            NILCHECKA (z1 = _rd); z0 = (*(char**)z1) + TC14->methodsize; z3 = ((t21_methods*) (z0+(0+t13_msize)))->_seek;
#line 81
            z4 = z3 (z1,  0 ); z5 = (z4 ==  2 ); if (z5) {
               RAISE (& _Rd__EndOfFile, 0, 0); }; finally_0: CUT_TO_NEXT_HANDLER (hfinally_0);



            _RdMove__MakeClean (_rd); if (hfinally_0.exception != FALL_EXCEPTION) { hproc_0.exception = hfinally_0.exception;
#line 86
               goto proc_0; }; };
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z5 = ((((t13_fields*)(z0+(0)))->_next) == (((t13_fields*)(z0+(0)))->_stop));
#line 87
         if (z5) { z2 =  4 ; RAISE (& _Rd__Error, & z2, 1); };
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; NILCHECKB (z6 = (((t21_fields*)(z0+(0+t13_size)))->_buff));
#line 88
         NILCHECKA (z7 = _rd); z1 = (char*)z7 + TC14->datasize; z8 = (((t13_fields*)(z1+(0)))->_next); if (z8 < 0) RANGEFAULT;
#line 88
         { register t24* array = & (*((t11*) z6)); z10 = z8; if (z10 >= (array->size[0])) RANGEFAULT; z9 = (int)(array->elts + (z10 * 1));
#line 88
 }; _res = (*(t7*)z9);
         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_next) +=  1 ;
         __result = _res; 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 90
 }; };
#line 93 "RdMove.m3"
 EXPORT t7 _Rd__GetChar (_rd) t1 _rd; { t7 z2;
#line 93 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_4, proc_0); { auto t7 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;



         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_0; PUSH_FINALLY (hlock_0, lock_0); z2 = _UnsafeRd__FastGetChar (_rd);
#line 97
               __result = z2; hlock_0.exception = RETURN_EXCEPTION; goto lock_0; lock_0: CUT_TO_NEXT_HANDLER (hlock_0); _Thread__Release (mu);
#line 97
               if (hlock_0.exception != FALL_EXCEPTION) { if (hlock_0.exception == RETURN_EXCEPTION) { CUT_TO_NEXT_HANDLER (hproc_0);
#line 97
                     return __result; }; hproc_0.exception = hlock_0.exception; goto proc_0; }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 97
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 100 "RdMove.m3"
 EXPORT t7 _UnsafeRd__FastGetChar (_rd) t1 _rd; { t1 z1; t1 z0; t5 z3; t20 z2; t1 z4; t10 z5; t10 z6; t10 z7; t7 z8;
#line 100 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_4, proc_0); { auto t7 _res; auto t7 __result; {


         ZERO1B (& _res);
#line 100
         ZERO1B (& __result); CHECKSTACKOVERFLOW;




         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t13_fields*)(z0+(0)))->_next) != (((t13_fields*)(z0+(0)))->_stop));
#line 105
         if (z3) {
            NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; NILCHECKB (z2 = (((t21_fields*)(z0+(0+t13_size)))->_buff));
#line 106
            NILCHECKA (z4 = _rd); z1 = (char*)z4 + TC14->datasize; z5 = (((t13_fields*)(z1+(0)))->_next); if (z5 < 0) RANGEFAULT;
#line 106
            { register t24* array = & (*((t11*) z2)); z7 = z5; if (z7 >= (array->size[0])) RANGEFAULT; z6 = (int)(array->elts + (z7 * 1));
#line 106
 }; _res = (*(t7*)z6);
            NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_next) +=  1 ; goto if_7_end;
#line 107
 }; z8 = _RdMove__SlowGetChar (_rd);

            _res = z8; if_7_end: /**/;

         __result = _res; 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 111
 }; };
#line 114 "RdMove.m3"
 EXPORT t5 _Rd__EOF (_rd) t1 _rd; { t5 z2;
#line 114 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_5, proc_0); { auto t5 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;



         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_1; PUSH_FINALLY (hlock_1, lock_1); z2 = _UnsafeRd__FastEOF (_rd);
#line 118
               __result = z2; hlock_1.exception = RETURN_EXCEPTION; goto lock_1; lock_1: CUT_TO_NEXT_HANDLER (hlock_1); _Thread__Release (mu);
#line 118
               if (hlock_1.exception != FALL_EXCEPTION) { if (hlock_1.exception == RETURN_EXCEPTION) { CUT_TO_NEXT_HANDLER (hproc_0);
#line 118
                     return __result; }; hproc_0.exception = hlock_1.exception; goto proc_0; }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 118
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 121 "RdMove.m3"
 EXPORT t5 _UnsafeRd__FastEOF (_rd) t1 _rd; { t1 z1; t1 z0; t5 z3; t5 z2;
#line 121 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_5, proc_0); { auto t5 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;



         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t13_fields*)(z0+(0)))->_next) != (((t13_fields*)(z0+(0)))->_stop));
#line 125
         if (z3) { __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; z2 = _RdMove__SlowEOF (_rd);
            __result = z2; 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 126
 }; };
#line 130 "RdMove.m3"
 PRIVATE t5 _RdMove__SlowEOF (_rd) t1 _rd; { t1 z1; t1 z0; t25 z2; t19 z3; t18 z4; t5 z5;
#line 130 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_18, proc_0); { auto t5 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;


         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) {
            z2 =  0 ; RAISE (& _Rd__Error, & z2, 1); }; _RdMove__MakeValid (_rd);




            { HANDLER hfinally_1; PUSH_FINALLY (hfinally_1, finally_1);
#line 138
               NILCHECKA (z1 = _rd); z0 = (*(char**)z1) + TC14->methodsize; z3 = ((t21_methods*) (z0+(0+t13_msize)))->_seek;
#line 138
               z4 = z3 (z1,  0 ); z5 = (z4 ==  2 ); __result = z5; hfinally_1.exception = RETURN_EXCEPTION; goto finally_1;
#line 138
 finally_1: CUT_TO_NEXT_HANDLER (hfinally_1);


               _RdMove__MakeClean (_rd); if (hfinally_1.exception != FALL_EXCEPTION) { if (hfinally_1.exception == RETURN_EXCEPTION) {
#line 141
                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; hproc_0.exception = hfinally_1.exception; goto proc_0;
#line 141
 }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 145 "RdMove.m3"
 EXPORT t36 _Rd__UnGetChar (_rd) t1 _rd; { t1 z1; t1 z0; t25 z2; t10 z3; t5 z4; t5 z5;
#line 145 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_6, proc_0); { { CHECKSTACKOVERFLOW;

         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_2; PUSH_FINALLY (hlock_2, lock_2);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) { z2 =  0 ;
#line 148
                  RAISE (& _Rd__Error, & z2, 1); };
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = -  1 ; z4 = ((((t13_fields*)(z0+(0)))->_next) == z3);
#line 149
               z5 = 1; if (! z4) { NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z4 = ((((t13_fields*)(z0+(0)))->_next) == (((t21_fields*)(z0+(0+t13_size)))->_st));
#line 149
                  z5 = z4; }; if (z5) {
                  z2 =  3 ; RAISE (& _Rd__Error, & z2, 1); };


               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_next) -=  1 ; lock_2: CUT_TO_NEXT_HANDLER (hlock_2);
#line 153
               _Thread__Release (mu); if (hlock_2.exception != FALL_EXCEPTION) { hproc_0.exception = hlock_2.exception; goto proc_0;
#line 153
 }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 156 "RdMove.m3"
 EXPORT t3 _Rd__CharsReady (_rd) t1 _rd; { t1 z1; t1 z0; t25 z2; t5 z3; t5 z4; t19 z5; t18 z6; t10 z7; t10 z8;
#line 156 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_11, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;


         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_3; PUSH_FINALLY (hlock_3, lock_3);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) { z2 =  0 ;
#line 160
                  RAISE (& _Rd__Error, & z2, 1); };
               _RdMove__MakeValid (_rd);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t21_fields*)(z0+(0+t13_size)))->_lo) <= (((t21_fields*)(z0+(0+t13_size)))->_cur));
#line 162
               z4 = 0; if (z3) { NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t21_fields*)(z0+(0+t13_size)))->_cur) < (((t21_fields*)(z0+(0+t13_size)))->_hi));
#line 162
                  z4 = z3; }; z3 = ! z4; if (z3) {




                  { HANDLER hfinally_2; PUSH_FINALLY (hfinally_2, finally_2);
#line 164
                     NILCHECKA (z1 = _rd); z0 = (*(char**)z1) + TC14->methodsize; z5 = ((t21_methods*) (z0+(0+t13_msize)))->_seek;
#line 164
                     z6 = z5 (z1,  1 ); z3 = (z6 ==  2 ); if (z3) {
                        __result =  1 ; hfinally_2.exception = RETURN_EXCEPTION; goto finally_2; }; finally_2: CUT_TO_NEXT_HANDLER (hfinally_2);



                     _RdMove__MakeClean (_rd); if (hfinally_2.exception != FALL_EXCEPTION) { if (hfinally_2.exception == RETURN_EXCEPTION) {
#line 169
                           hlock_3.exception = RETURN_EXCEPTION; goto lock_3; }; hlock_3.exception = hfinally_2.exception;
#line 169
                        goto lock_3; }; };
                  NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ((((t21_fields*)(z0+(0+t13_size)))->_cur) > (((t21_fields*)(z0+(0+t13_size)))->_hi));
#line 170
                  if (z3) {
                     z2 =  4 ; RAISE (& _Rd__Error, & z2, 1); }; goto if_13_end; }; if_13_end: /**/;


               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z7 = (((t21_fields*)(z0+(0+t13_size)))->_hi) - (((t21_fields*)(z0+(0+t13_size)))->_cur);
#line 174
               z8 = z7; if (z8 < 0) RANGEFAULT; __result = z8; hlock_3.exception = RETURN_EXCEPTION; goto lock_3; lock_3:
#line 174
 CUT_TO_NEXT_HANDLER (hlock_3); _Thread__Release (mu); if (hlock_3.exception != FALL_EXCEPTION) { if (hlock_3.exception == RETURN_EXCEPTION) {
#line 174
                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; hproc_0.exception = hlock_3.exception; goto proc_0;
#line 174
 }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 178 "RdMove.m3"
 EXPORT t3 _Rd__GetIndex (_rd) t1 _rd; { t1 z1; t1 z0; t25 z2; t5 z3; t10 z4; t5 z5; t1 z6; t1 z7; t4 z8; t3 z9; t3 z10; t3 z11;
#line 178 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_11, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;


         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_4; PUSH_FINALLY (hlock_4, lock_4);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) { z2 =  0 ;
#line 182
                  RAISE (& _Rd__Error, & z2, 1); };
               _RdMove__MakeValid (_rd);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = 0; if ((((t21_fields*)(z0+(0+t13_size)))->_seekable)) {
#line 184
                  NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z4 = -  1 ; z5 = ((((t13_fields*)(z0+(0)))->_next) == z4);
#line 184
                  z3 = z5; }; if (z3) {
                  NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; NILCHECKA (z6 = _rd); z7 = (*(char**)z6) + TC14->methodsize;
#line 185
                  z8 = ((t21_methods*) (z7+(0+t13_msize)))->_length; z9 = z8 (z6); z10 = (((t21_fields*)(z0+(0+t13_size)))->_cur);
#line 185
                  z11 = z9; if (z10 > z11) z10 = z11; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t21_fields*)(z0+(0+t13_size)))->_cur) = z10;
#line 185
                  goto if_17_end; }; if_17_end: /**/;

               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; __result = (((t21_fields*)(z0+(0+t13_size)))->_cur);
#line 187
               hlock_4.exception = RETURN_EXCEPTION; goto lock_4; lock_4: CUT_TO_NEXT_HANDLER (hlock_4); _Thread__Release (mu);
#line 187
               if (hlock_4.exception != FALL_EXCEPTION) { if (hlock_4.exception == RETURN_EXCEPTION) { CUT_TO_NEXT_HANDLER (hproc_0);
#line 187
                     return __result; }; hproc_0.exception = hlock_4.exception; goto proc_0; }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 187
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 191 "RdMove.m3"
 EXPORT t3 _Rd__GetLength (_rd) t1 _rd; { t1 z1; t1 z0; t25 z2; t4 z3; t3 z4;
#line 191 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_11, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;


         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_5; PUSH_FINALLY (hlock_5, lock_5);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) {
                  z2 =  0 ; RAISE (& _Rd__Error, & z2, 1); }; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_intermittent)) {

                  z2 =  2 ; RAISE (& _Rd__Error, & z2, 1); }; {




                     HANDLER hfinally_3; PUSH_FINALLY (hfinally_3, finally_3);
#line 201
                     _RdMove__MakeValid (_rd);
                     NILCHECKA (z1 = _rd); z0 = (*(char**)z1) + TC14->methodsize; z3 = ((t21_methods*) (z0+(0+t13_msize)))->_length;
#line 202
                     z4 = z3 (z1); __result = z4; hfinally_3.exception = RETURN_EXCEPTION; goto finally_3; finally_3: CUT_TO_NEXT_HANDLER (hfinally_3);


                     _RdMove__MakeClean (_rd); if (hfinally_3.exception != FALL_EXCEPTION) { if (hfinally_3.exception == RETURN_EXCEPTION) {
#line 205
                           hlock_5.exception = RETURN_EXCEPTION; goto lock_5; }; hlock_5.exception = hfinally_3.exception;
#line 205
                        goto lock_5; }; }; lock_5: CUT_TO_NEXT_HANDLER (hlock_5); _Thread__Release (mu); if (hlock_5.exception != FALL_EXCEPTION) {
#line 205
                  if (hlock_5.exception == RETURN_EXCEPTION) { CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; hproc_0.exception = hlock_5.exception;
#line 205
                  goto proc_0; }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 205
 }; };
#line 210 "RdMove.m3"
 EXPORT t36 _Rd__Seek (_rd, _n) t1 _rd; t3 _n; { t1 z1; t1 z0; t25 z2; t5 z3; t1 z4;
#line 210 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_12, proc_0); { { CHECKSTACKOVERFLOW;


         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_6; PUSH_FINALLY (hlock_6, lock_6);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; if ((((t21_fields*)(z0+(0+t13_size)))->_closed)) {
                  z2 =  0 ; RAISE (& _Rd__Error, & z2, 1); }; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z3 = ! (((t21_fields*)(z0+(0+t13_size)))->_seekable);
#line 215
               if (z3) {

                  z2 =  1 ; RAISE (& _Rd__Error, & z2, 1); }; NILCHECKA (z4 = _rd);

                  z1 = (char*)z4 + TC14->datasize; (((t21_fields*)(z1+(0+t13_size)))->_cur) = _n;

                  _RdMove__MakeClean (_rd); lock_6: CUT_TO_NEXT_HANDLER (hlock_6); _Thread__Release (mu); if (hlock_6.exception != FALL_EXCEPTION) {
#line 221
                  hproc_0.exception = hlock_6.exception; goto proc_0; }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 221
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 225 "RdMove.m3"
 EXPORT t36 _Rd__Close (_rd) t1 _rd; { t1 z1; t1 z0; t5 z2; t2 z3; t1 z4; t10 z5;
#line 225 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_17, proc_0); { { CHECKSTACKOVERFLOW;

         { register t14 mu = (t14)_rd; _Thread__Acquire (mu); { HANDLER hlock_7; PUSH_FINALLY (hlock_7, lock_7);
               NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; z2 = ! (((t21_fields*)(z0+(0+t13_size)))->_closed);
#line 228
               if (z2) {



                  { HANDLER hfinally_4; PUSH_FINALLY (hfinally_4, finally_4);
#line 230
                     _RdMove__MakeValid (_rd);

                     NILCHECKA (z1 = _rd); z0 = (*(char**)z1) + TC14->methodsize; z3 = ((t21_methods*) (z0+(0+t13_msize)))->_close;
#line 232
                     z3 (z1); finally_4: CUT_TO_NEXT_HANDLER (hfinally_4);
                     NILCHECKA (z4 = _rd); z1 = (char*)z4 + TC14->datasize; (((t21_fields*)(z1+(0+t13_size)))->_closed) =  1 ;
                     z5 = -  1 ; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_next) = z5;
                     z5 = -  1 ; NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; (((t13_fields*)(z0+(0)))->_stop) = z5;
#line 235
                     if (hfinally_4.exception != FALL_EXCEPTION) { hlock_7.exception = hfinally_4.exception; goto lock_7;
#line 235
 }; }; goto if_20_end; }; if_20_end: /**/; lock_7: CUT_TO_NEXT_HANDLER (hlock_7); _Thread__Release (mu); if (hlock_7.exception != FALL_EXCEPTION) {
#line 235
                  hproc_0.exception = hlock_7.exception; goto proc_0; }; }; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 235
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 246 "RdMove.m3"
 EXPORT t3 _Rd__GetSub (_rd, _str) t1 _rd; t11 * _str; { t5 z2; t5 z0; t5 z1; t3 z3; t7 z4; t10 z5;
#line 246 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_8, proc_0); { auto t3 _i; auto t3 __result; {


         ZERO1  (& _i);
#line 246
         ZERO1  (& __result); CHECKSTACKOVERFLOW;





         _i =  0 ;
         z2 = _Rd__EOF (_rd); z0 = ! z2; z1 = 0; if (z0) { z3 = (*_str).size[0]; z2 = (_i != z3); z1 = z2; }; if (z1) do {
#line 253

            z4 = _Rd__GetChar (_rd); { register t24* array = & (*_str); z3 = _i; if (z3 >= (array->size[0])) RANGEFAULT; z5 = (int)(array->elts + (z3 * 1));
#line 254
 }; (*(t7*)z5) = z4;
            _i +=  1 ; z2 = _Rd__EOF (_rd); z0 = ! z2; z1 = 0; if (z0) { z3 = (*_str).size[0]; z2 = (_i != z3); z1 = z2; };
#line 255
 } while (z1);
         __result = _i; 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 256
 }; };
#line 259 "RdMove.m3"
 EXPORT t3 _Rd__GetSubLine (_rd, _str) t1 _rd; t11 * _str; { t5 z2; t5 z0; t5 z1; t3 z3; t5 z4; t10 z5; t10 z6; t10 z7; t7 z8;
#line 259 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_8, proc_0); { auto t3 _i; auto t3 __result; {


         ZERO1  (& _i);
#line 259
         ZERO1  (& __result);


         ZERO1  ((& _i));
#line 259
         CHECKSTACKOVERFLOW;




         z2 = _Rd__EOF (_rd); z0 = ! z2; z1 = 0; if (z0) { z3 = (*_str).size[0]; z2 = (_i != z3); z1 = z2; }; z0 = 0; if (z1) {
#line 264
            z4 = (_i ==  0 ); z1 = 1; if (! z4) { z5 = _i -  1 ; z6 = z5; if (z6 < 0) RANGEFAULT; { register t24* array = & (*_str);
#line 264
                  z7 = z6; if (z7 >= (array->size[0])) RANGEFAULT; z5 = (int)(array->elts + (z7 * 1)); }; z4 = ((*(t7*)z5) !=  '\012' );
#line 264
               z1 = z4; }; z0 = z1; }; if (z0) do { z8 = _Rd__GetChar (_rd);
            { register t24* array = & (*_str); z3 = _i; if (z3 >= (array->size[0])) RANGEFAULT; z5 = (int)(array->elts + (z3 * 1));
#line 265
 }; (*(t7*)z5) = z8;
            _i +=  1 ; z2 = _Rd__EOF (_rd); z0 = ! z2; z1 = 0; if (z0) { z3 = (*_str).size[0]; z2 = (_i != z3); z1 = z2; };
#line 266
            z0 = 0; if (z1) { z4 = (_i ==  0 ); z1 = 1; if (! z4) { z5 = _i -  1 ; z6 = z5; if (z6 < 0) RANGEFAULT; { register t24* array = & (*_str);
#line 266
                     z7 = z6; if (z7 >= (array->size[0])) RANGEFAULT; z5 = (int)(array->elts + (z7 * 1)); }; z4 = ((*(t7*)z5) !=  '\012' );
#line 266
                  z1 = z4; }; z0 = z1; }; } while (z0);
         __result = _i; 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 267
 }; };
#line 270 "RdMove.m3"
 EXPORT t8 _Rd__GetText (_rd, _length) t1 _rd; t10 _length; { t5 z2; t5 z0; t5 z1; t5 z3; t7 z4; t8 z5; t8 z6;
#line 270 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_9, proc_0); { auto t8 _res; auto t8 __result; {


         ZERO1  (& _res);
#line 270
         ZERO1  (& __result);


         ZERO1  ((& _res));
#line 270
         CHECKSTACKOVERFLOW;




         z2 = _Rd__EOF (_rd); z0 = ! z2; z1 = 0; if (z0) { z3 = (_length >  0 ); z1 = z3; }; if (z1) do { z4 = _Rd__GetChar (_rd);
            z5 = _Text__FromChar (z4); z6 = (ADDRESS) _Text__Cat (_res, z5); _res = z6;
            _length -=  1 ; z2 = _Rd__EOF (_rd); z0 = ! z2; z1 = 0; if (z0) { z3 = (_length >  0 ); z1 = z3; }; } while (z1);
         __result = _res; 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 278
 }; };
#line 282 "RdMove.m3"
 EXPORT t8 _Rd__GetLine (_rd) t1 _rd; { t5 z2; t7 z3; t8 z4; t8 z1;
#line 282 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_10, proc_0); { auto t8 _res; auto t7 _ch; auto t8 __result; {

         ZERO1  (& _res);
         ZERO1B (& _ch);
#line 282
         ZERO1  (& __result);

         ZERO1  ((& _res));
         ZERO1B ((& _ch));
#line 282
         CHECKSTACKOVERFLOW;




         z2 = _Rd__EOF (_rd); if (z2) { RAISE (& _Rd__EndOfFile, 0, 0); };

         do { z3 = _Rd__GetChar (_rd);
            _ch = z3;
            z2 = (_ch !=  '\012' ); if (z2) {
               z4 = _Text__FromChar (_ch); z1 = (ADDRESS) _Text__Cat (_res, z4); _res = z1; goto if_22_end; }; __result = _res;

               CUT_TO_NEXT_HANDLER (hproc_0); return __result; if_22_end: /**/; z2 = _Rd__EOF (_rd); } while (! z2);

         __result = _res; 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 296
 }; };
#line 300 "RdMove.m3"
 EXPORT t5 _Rd__Intermittent (_rd) t1 _rd; { t1 z1; t1 z0;
#line 300 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t5 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; __result = (((t21_fields*)(z0+(0+t13_size)))->_intermittent);
#line 302
         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 302
 }; };
#line 305 "RdMove.m3"
 EXPORT t5 _Rd__Seekable (_rd) t1 _rd; { t1 z1; t1 z0;
#line 305 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t5 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; __result = (((t21_fields*)(z0+(0+t13_size)))->_seekable);
#line 307
         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 307
 }; };
#line 310 "RdMove.m3"
 EXPORT t5 _Rd__Closed (_rd) t1 _rd; { t1 z1; t1 z0;
#line 310 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t5 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _rd); z0 = (char*)z1 + TC14->datasize; __result = (((t21_fields*)(z0+(0+t13_size)))->_closed); CUT_TO_NEXT_HANDLER (hproc_0);
#line 312
         return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 312
 }; };
#line 315 "RdMove.m3"
 EXPORT t36 _RdClass__Lock (_rd) t1 _rd; {
#line 315 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { { CHECKSTACKOVERFLOW;

         _Thread__Acquire (_rd);
         _RdMove__MakeValid (_rd); } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 318
 }; };
#line 321 "RdMove.m3"
 EXPORT t36 _RdClass__Unlock (_rd) t1 _rd; {
#line 321 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { { CHECKSTACKOVERFLOW;

         _Thread__Release (_rd); } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 323
 }; };
#line 326 "RdMove.m3"
 EXPORT t3 _RdClass__LengthDefault (_rd) t1 _rd; { t25 z2;
#line 326 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_11, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;


         z2 =  4 ; RAISE (& _Rd__Error, & z2, 1); } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 329
 }; };
#line 333 "RdMove.m3"
 EXPORT t36 _RdClass__CloseDefault (_rd) t1 _rd; { t1 z2; t1 z1;
#line 333 "RdMove.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_17, proc_0); { { CHECKSTACKOVERFLOW;

         NILCHECKA (z2 = _rd); z1 = (char*)z2 + TC14->datasize; (((t21_fields*)(z1+(0+t13_size)))->_buff) = (t20) 0; } } proc_0:
#line 335
 CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };  PRIVATE int init_done = -1;
#line 335 "RdMove.m3"
 PRIVATE void RdMove__initProc (g) int g; {
#line 335 "RdMove.m3"
if (init_done >= g) return; init_done = g; INITIALIZE (& UnsafeRd__init); INITIALIZE (& RdClass__init); INITIALIZE (& Rd__init);
#line 335
INITIALIZE (& Thread__init); INITIALIZE (& Text__init); return; }; 
#line 335 "RdMove.m3"
PRIVATE void t13_InitProc (obj) char* obj; { register t13_fields* p; t10 z1;
#line 335 "RdMove.m3"
CHECKSTACKOVERFLOW; p = (t13_fields*) (obj + TC14->datasize); z1 = -  1 ; p->_next = z1; z1 = -  1 ; p->_stop = z1; }; 
#line 335 "RdMove.m3"
PRIVATE void t13_SetupProc () { register int* p;
#line 335 "RdMove.m3"
t13_TC.datasize += TC14->datasize; t13_TC.methodsize += TC14->methodsize; p = (int*) UALLOC (t13_TC.methodsize); COPY (TC14->defaultMethods, p, (TC14->methodsize));
#line 335
p[0] = (int)(& t13_TC); p[1] = 0; t13_TC.defaultMethods = (char*) p; }; 
#line 335 "RdMove.m3"
PRIVATE void t13_PrintProc (obj) char *obj; { t13_fields* o;
#line 335 "RdMove.m3"
CHECKSTACKOVERFLOW; if (TC14->printProc != 0) {TC14->printProc (obj); } fprintf (stderr, "{%s} ", TC13->brand); o = (t13_fields*) (obj + TC14->datasize);
#line 335
fprintf (stderr, "next = %d", o->_next); fprintf (stderr, ", "); fprintf (stderr, "stop = %d", o->_stop); }; 
#line 335 "RdMove.m3"
PRIVATE void t20_PrintProc (ref) t11* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC20->brand); fprintf (stderr, "^ = array");
#line 335
   fprintf (stderr, "}\n"); };  PRIVATE void t13_MapProc (p, r, c) void (*p) (); char*  r; ADDRESS c; { register t13_fields*  o;
#line 335
   CHECKSTACKOVERFLOW; t14_MapProc (p, r, c); o = (t13_fields*) (r + TC14->datasize); };   PRIVATE INITLINK me_0 ={(INITLINK*)NIL, 0, RdMove__initProc};
#line 335
 PRIVATE INITLINK me_1 ={(INITLINK*)NIL, 0, RdMove__initProc};  PRIVATE INITLINK me_2 ={(INITLINK*)NIL, 0, RdMove__initProc};
static char* VSimports[] = { &VS_Thread__DefaultStackSize__0c949e2e2def4e40, &VS_Thread__T__2555b70b3f7780b1, &VS_Thread__Mutex__4f5c12072cdeec3e,
   &VS_Thread__Condition__26d5968239e08f4e, &VS_Thread__Closure__7fb5c6232c5a658a, &VS_Thread__SizedClosure__8a46717d2eae7b07,
   &VS_Thread__Acquire__4f2412f3260f1927, &VS_Thread__Release__539a01d7243a726e, &VS_Thread__Alerted__fc88feb43485af46, &VS_Text__T__fc4b369f3ab271fd,
   &VS_Text__FromChar__3896ff8a3ced0505, &VS_Rd__EndOfFile__f4a9d2f63b7e105d, &VS_Rd__Error__5ca07bfe2ba90cfc, &VS_Rd__Failure__e4a829e331222b6d,
   &VS_Thread__Alerted__fc88feb43485af46, &VS_RdClass__Private__5594af883f1b8361, &VS_Rd__T__2555b70b3f7780b1, NIL };  void RdMove__MLink (phase) int phase; { switch (phase) { case 0: { me_0.link = UnsafeRd__init; UnsafeRd__init = & me_0;
         me_1.link = RdClass__init; RdClass__init = & me_1; me_2.link = Rd__init; Rd__init = & me_2; t13_TC = t13_TC_init;
         REGISTERTYPE (TC13); t20_TC = t20_TC_init; REGISTERTYPE (TC20); break; }; case 1: { t13_TC.parent = TC_MUTEX;
#line 20 "RdMove.m3"
         IDENTIFYTYPES (TC22, TC13); break; }; case 2: { break; }; }; };