#include "M3Runtime.h"

typedef struct { int tc; char* str; int len; } TXT; PRIVATE TXT txt1 = { 3, "types are not assignable", 25}; PRIVATE TXT txt2 = { 3, "value not assignable (range fault)", 35};
PRIVATE TXT txt3 = { 3, "unsafe NARROW", 14}; PRIVATE TXT txt4 = { 3, "cannot assign nested procedures", 32}; PRIVATE TXT txt5 = { 3, "left-hand side is not a designator", 35};
PRIVATE TXT txt6 = { 3, "left-hand side is read-only", 28}; PRIVATE TXT txt7 = { 3, "{\001\012", 4}; PRIVATE TXT txt8 = { 3, "register t@* src;\012", 19};
PRIVATE TXT txt9 = { 3, "register t@* dest;\012", 20}; PRIVATE TXT txt10 = { 3, "src = & @;\012", 12}; PRIVATE TXT txt11 = { 3, "dest = & @;\012", 13};
PRIVATE TXT txt12 = { 3, "COPY (src->elts, dest->elts, ", 30}; PRIVATE TXT txt13 = { 3, ");\012\002};\012", 8}; PRIVATE TXT txt14 = { 3, "register t@* dest;", 19};
PRIVATE TXT txt15 = { 3, "dest = (t@*)", 13}; PRIVATE TXT txt16 = { 3, "(& @);\012", 8}; PRIVATE TXT txt17 = { 3, "COPY (src->elts, dest->elts, @);\012", 34};
PRIVATE TXT txt18 = { 3, "\002};\012", 5}; PRIVATE TXT txt19 = { 3, "src = (t@*)", 12}; PRIVATE TXT txt20 = { 3, "@ = @;\012", 8};
PRIVATE TXT txt21 = { 3, "@ = ", 5}; PRIVATE TXT txt22 = { 3, "(t@) ", 6}; PRIVATE TXT txt23 = { 3, "@;\012", 4}; PRIVATE TXT txt24 = { 3,
   "if (src->size[@] != dest->size[@]) NARROWFAULT;\012", 49 }; PRIVATE TXT txt25 = { 3, "if (src->size[@] != @) NARROWFAULT;\012", 37};
PRIVATE TXT txt26 = { 3, "if (dest->size[@] != @) NARROWFAULT;\012", 38}; PRIVATE TXT txt27 = { 3, "(src->size[@]) * ", 18};
PRIVATE TXT txt28 = { 3, "@", 2};
#line 14 "../Interfaces/Expr.i3"
#define t19 ADDRESS
#define t93 void
#define t91 ADDRESS
 typedef struct { TYPE self; int private; } t91_methods; 
#define t91_msize (sizeof (t91_methods))
typedef struct { ADDRESS methods; } t91_fields; 
#define t91_size (sizeof (t91_fields))
#define TC91 TC_UNTRACED_ROOT
IMPORT TYPE TC_UNTRACED_ROOT; IMPORT char VS_UNTRACED_ROOT__3e0964513fd6da20;
#line 16 "../Interfaces/M3.i3"
#define t12 ADDRESS
#define TC12 TC_M3__Expr
IMPORT TYPE TC_M3__Expr;
#line 16
IMPORT char VS_M3__Expr__8ae39aaa2d432477;
#line 116 ".ROOT/.boots/corelib/Interfaces/Wr.i3"
typedef struct { char* elts; int size[1]; } t80;
#line 14 "../Interfaces/Expr.i3"
#define t70 t80
#define TC19 TC_Expr__List
IMPORT TYPE TC_Expr__List;
#line 14
IMPORT char VS_Expr__List__3f87eceb2b9a246a;
#line 16 "../Interfaces/Type.i3"
#define t26 ADDRESS
typedef int t2;
#line 15 ".ROOT/.boots/corelib/Interfaces/FPrint.i3"
#define t31 t80
#define TC26 TC_Type__Map
IMPORT TYPE TC_Type__Map;
#line 16 "../Interfaces/Type.i3"
IMPORT char VS_Type__Map__41dd9f4b33104fce;
#line 18 "../Interfaces/ProcType.i3"
#define t42 ADDRESS
#define t46 ADDRESS
#define TC46 TC_ADDRESS
IMPORT TYPE TC_ADDRESS; IMPORT char VS_ADDRESS__30f7308738738b44;
#line 13 "../Interfaces/String.i3"
#define t11 ADDRESS
#define TC11 TC_String__T
IMPORT TYPE TC_String__T;
#line 13
IMPORT char VS_String__T__3a6c7dc12615e4ee;
typedef struct { t11 _module; t11 _item; } t44;
#line 15 "../Interfaces/M3.i3"
#define t10 ADDRESS
#define TC10 TC_M3__Value
IMPORT TYPE TC_M3__Value;
#line 15
IMPORT char VS_M3__Value__6f64cf9c2cae25fb;
#line 14 "../Interfaces/ProcType.i3"
typedef struct { t42 _next; t44 _name; t10 _except; } t45;



#define TC42 TC_ProcType__Raisee
IMPORT TYPE TC_ProcType__Raisee;
#line 18
IMPORT char VS_ProcType__Raisee__5fe771ff27c179d9; 
#define t57 ADDRESS
#define TC57 TC_REFANY
IMPORT TYPE TC_REFANY; IMPORT char VS_REFANY__4b8748e831fc107a;
#line 17 "../Interfaces/Scope.i3"
#define t66 ADDRESS
#define t40 t80
#define TC66 TC_Scope__ValueList
IMPORT TYPE TC_Scope__ValueList;
#line 17
IMPORT char VS_Scope__ValueList__64bf053e22e4e53c;
#line 17 "../Interfaces/Type.i3"
#define t72 ADDRESS
#define t3 ADDRESS
#define TC3 TC_M3__Type
IMPORT TYPE TC_M3__Type;
#line 18 "../Interfaces/M3.i3"
IMPORT char VS_M3__Type__4d87bc25311f81d2;
#line 17 "../Interfaces/Type.i3"
typedef struct { t72 _next; t3 _type; } t73; 
#define TC72 TC_Type__List
IMPORT TYPE TC_Type__List;
#line 17
IMPORT char VS_Type__List__5791758e343becc1; 
#define t94 ADDRESS
#define TC94 TC_NULL
IMPORT TYPE TC_NULL; IMPORT char VS_NULL__fb50c7d53bec30dc; typedef unsigned char t1;
#line 271 "AssignStmt.m3"
typedef t93 (*t4)();
#line 19 "../Interfaces/M3.i3"
#define t5 ADDRESS
#define TC5 TC_M3__Temp
IMPORT TYPE TC_M3__Temp;
#line 19
IMPORT char VS_M3__Temp__450b691937f03dae;
#line 16 "./Stmt.i3"
typedef unsigned char t69;
typedef struct { int elts[1]; } t6;
#line 20 "AssignStmt.m3"
#define t7 ADDRESS

#line 20 "./StmtRep.i3"
typedef void (*t8)();
#line 17 "../Interfaces/M3.i3"
#define t15 ADDRESS
#define TC15 TC_M3__Stmt
IMPORT TYPE TC_M3__Stmt;
#line 17
IMPORT char VS_M3__Stmt__376b307627fc1f2f;
#line 20 "AssignStmt.m3"
typedef struct { int filler; } t7_methods; 
#define t7_msize (sizeof (t7_methods))
typedef struct {
#line 20
 t12 _lhs; t12 _rhs; } t7_fields; 
#define t7_size (sizeof (t7_fields))
PRIVATE void t7_InitProc ();
#line 20
PRIVATE void t7_SetupProc (); PRIVATE void t7_PrintProc (); PRIVATE typecell t7_TC; PRIVATE typecell t7_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,
#line 20
  t7_size, t7_msize, NIL, 0, 0, t7_InitProc,   t7_SetupProc,   t7_PrintProc, "", 468758887, 826042919}; PRIVATE TYPE TC7 = &t7_TC; 
#line 18 "../Interfaces/Value.i3"
typedef unsigned char t9;
#line 124 "AssignStmt.m3"
typedef t1 (*t13)();
#line 52
typedef t12 (*t14)();
#line 43
typedef t15 (*t16)();
#line 15 "../Interfaces/Token.i3"
typedef unsigned char t48;
#line 45
typedef struct { int elts[4]; } t17;
#line 14 "../Interfaces/CompareExpr.i3"
typedef unsigned char t18;
#line 31 "../Interfaces/ObjectType.i3"
typedef t2 (*t20)();
#line 14 "../Interfaces/M3.i3"
#define t21 ADDRESS
#define TC21 TC_M3__Scope
IMPORT TYPE TC_M3__Scope;
#line 14
IMPORT char VS_M3__Scope__6e6d8848308d8a2d;
#line 17 "../Interfaces/ObjectType.i3"
typedef t3 (*t22)();
#line 68 "../Interfaces/ValueRep.i3"
typedef t5 (*t23)();
#line 59
typedef t10 (*t24)(); 
#define t58 ADDRESS
 typedef struct { TYPE self; int private; } t58_methods; 
#define t58_msize (sizeof (t58_methods))
typedef struct { ADDRESS methods; } t58_fields; 
#define t58_size (sizeof (t58_fields))
#define TC58 TC_ROOT
IMPORT TYPE TC_ROOT; IMPORT char VS_ROOT__349f58f628be0ac6; 
#define t58_MapProc TC_ROOT->mapProc
#define t25 ADDRESS
#define TC25 TC_Wr__T
IMPORT TYPE TC_Wr__T;
#line 90 ".ROOT/.boots/corelib/Interfaces/Wr.i3"
IMPORT char VS_Wr__T__2555b70b3f7780b1; 
#define t25_MapProc TC_Wr__T->mapProc
typedef t9 (*t27)();
#line 15 ".ROOT/.boots/corelib/Interfaces/FPrint.i3"
typedef signed_char t34; typedef struct { t2 elts[2]; } t28;
#line 16 "../Interfaces/ValueRep.i3"
typedef t1 t29;


#define t30 ADDRESS

#line 19
typedef struct { t4 _bind; t4 _typeCheck; t27 _class; t4 _fingerprint; t23 _load; t4 _write; t24 _select; t13 _declare0; t4 _declare1;
#line 19
   t4 _declare2; t13 _needsDecl; t14 _toExpr; t22 _toType; } t30_methods; 
#define t30_msize (sizeof (t30_methods))
typedef struct {
#line 19
 t2 _origin; t11 _name; t11 _extName; t21 _scope; t3 _type; unsigned _checked : 1; unsigned _incheck : 1; unsigned _readonly : 1;
#line 19
   unsigned _declared : 1; unsigned _bound : 1; unsigned _compiled : 1; unsigned _imported : 1; unsigned _exported : 1; unsigned _external : 1;
#line 19
   unsigned _used : 1; unsigned _usedAtTop : 1; unsigned _unused : 1; unsigned _obsolete : 1; unsigned _inFrame : 1; t28 _fprint;
#line 19
 } t30_fields; 
#define t30_size (sizeof (t30_fields))
#define TC30 TC_M3__Value
#define t32 ADDRESS
#define TC32 TC_TEXT
IMPORT TYPE TC_TEXT; IMPORT char VS_TEXT__b7a92447326386f5; 
#define t32_MapProc TC_TEXT->mapProc
typedef void (*t33)();
#line 37 "../Interfaces/Procedure.i3"
#define t35 t80
#define t36 ADDRESS
#define TC36 TC_Procedure__T
IMPORT TYPE TC_Procedure__T;
#line 15
IMPORT char VS_Procedure__T__be7ead4a3afd8be5;
#line 17 "../Interfaces/CallExpr.i3"
#define t37 ADDRESS
#define TC37 TC_CallExpr__MethodList
IMPORT TYPE TC_CallExpr__MethodList;
#line 17
IMPORT char VS_CallExpr__MethodList__7e87c2d720444b71;
#line 14 "../Interfaces/Decl.i3"
typedef struct { t11 _alias; t1 _isExternal; t1 _isInline; t1 _isUnused; t1 _isObsolete; } t38;
#line 14 "../Interfaces/RefType.i3"
typedef t11 (*t39)();
#line 27 "../Interfaces/ProcType.i3"
typedef t37 (*t41)();
#line 24
typedef t21 (*t43)();
#line 83 ".ROOT/.boots/corelib/Interfaces/Rd.i3"
#define t47 ADDRESS
#define TC47 TC_Rd__T
IMPORT TYPE TC_Rd__T;
#line 83
IMPORT char VS_Rd__T__2555b70b3f7780b1; 
#define t47_MapProc TC_Rd__T->mapProc
typedef struct {
#line 13 "../Interfaces/Scanner.i3"
 t48 _token; t11 _string; t2 _value; t2 _offset; } t49; typedef int t50;
#line 249 ".ROOT/.boots/corelib/Interfaces/Rd.i3"
typedef t50 (*t51)();
#line 220
typedef t32 (*t52)(); typedef unsigned char t53;
#line 189
#define t54 t80
typedef t53 (*t55)();
#line 84
typedef unsigned char t56;
#line 14 "../Interfaces/Module.i3"
#define t59 ADDRESS
#define TC59 TC_Module__T
IMPORT TYPE TC_Module__T;
#line 14
IMPORT char VS_Module__T__be7ead4a3afd8be5;



typedef t59 (*t60)();
#line 63 "../Interfaces/Emit.i3"
typedef t34 (*t61)();
#line 19 "../Interfaces/String.i3"
typedef signed_char t76;
#line 65 "../Interfaces/Token.i3"
#define t74 t80
typedef struct { t11 elts[100]; } t77;
#line 17 "../Interfaces/String.i3"
typedef struct { t2 _top; t77 _stk; } t62;
#line 16 "../Interfaces/Variable.i3"
#define t63 ADDRESS
#define TC63 TC_Variable__T
IMPORT TYPE TC_Variable__T;
#line 16
IMPORT char VS_Variable__T__be7ead4a3afd8be5; typedef double t64;







typedef t63 (*t65)();
#line 13 "./StmtRep.i3"
#define t67 ADDRESS

#line 13
typedef struct { t4 _bind; t4 _check; t4 _precompile; t8 _compile; } t67_methods; 
#define t67_msize (sizeof (t67_methods))
typedef struct {
#line 13
 t15 _next; t2 _origin; } t67_fields; 
#define t67_size (sizeof (t67_fields))
#define TC67 TC_M3__Stmt
typedef unsigned char t68;
#line 121 "../Interfaces/Type.i3"
typedef t26 (*t71)();
#line 65 "../Interfaces/Token.i3"
typedef struct { t11 elts[97]; } t75;
#line 67 ".ROOT/.boots/corelib/Interfaces/Text.i3"
typedef signed_char t78; typedef t78 (*t79)();
#line 91 ".ROOT/.boots/corelib/Interfaces/Wr.i3"
typedef unsigned char t81;
#line 15 ".ROOT/.boots/corelib/Interfaces/Thread.i3"
#define t82 ADDRESS
#define TC82 TC_Thread__T
IMPORT TYPE TC_Thread__T;
#line 15
IMPORT char VS_Thread__T__2555b70b3f7780b1; 
#define t82_MapProc TC_Thread__T->mapProc
typedef t57 (*t83)();



#define t84 ADDRESS
#define TC84 TC_Thread__Condition
IMPORT TYPE TC_Thread__Condition;
#line 21
IMPORT char VS_Thread__Condition__26d5968239e08f4e; 
#define t84_MapProc TC_Thread__Condition->mapProc
#define t85 ADDRESS
#define TC85 TC_MUTEX
IMPORT TYPE TC_MUTEX; IMPORT char VS_MUTEX__1f9d4e89391ab815; 
#define t85_MapProc TC_MUTEX->mapProc
typedef t82 (*t86)();
#line 23
#define t87 ADDRESS

#line 23
typedef struct { t83 _apply; } t87_methods; 
#define t87_msize (sizeof (t87_methods))
typedef struct {
#line 23
 int filler; } t87_fields; 
#define t87_size (sizeof (t87_fields))
#define TC87 TC_Thread__Closure
IMPORT TYPE TC_Thread__Closure;
#line 23
IMPORT char VS_Thread__Closure__7fb5c6232c5a658a; 
#define t87_MapProc TC_Thread__Closure->mapProc
typedef t84 (*t88)();





typedef t85 (*t89)();
#line 28
#define t90 ADDRESS

#line 28
typedef struct { int filler; } t90_methods; 
#define t90_msize (sizeof (t90_methods))
typedef struct {
#line 28
 t50 _stackSize; } t90_fields; 
#define t90_size (sizeof (t90_fields))
#define TC90 TC_Thread__SizedClosure
IMPORT TYPE TC_Thread__SizedClosure;
#line 28
IMPORT char VS_Thread__SizedClosure__8a46717d2eae7b07; 
#define t90_MapProc TC_Thread__SizedClosure->mapProc
typedef CLOSURE t92; typedef float t95;
#line 11 "AssignStmt.m3"
IMPORT INITLINK* SetExpr__init; IMPORT INITLINK* ObjectType__init; IMPORT INITLINK* ProcExpr__init; IMPORT INITLINK* ProcCheckExpr__init;
#line 11
IMPORT INITLINK* ValueRep__init; IMPORT INITLINK* Temp__init; IMPORT INITLINK* Procedure__init; IMPORT INITLINK* Variable__init;
#line 11
IMPORT INITLINK* QualifyExpr__init; IMPORT INITLINK* SetType__init; IMPORT INITLINK* RefType__init; IMPORT INITLINK* NamedExpr__init;
#line 11
IMPORT INITLINK* ProcType__init; IMPORT INITLINK* ArrayType__init; IMPORT INITLINK* Value__init; IMPORT INITLINK* String__init;
#line 11
IMPORT INITLINK* Address__init; IMPORT INITLINK* NarrowExpr__init; IMPORT INITLINK* CheckExpr__init; IMPORT INITLINK* CallStmt__init;
#line 11
IMPORT INITLINK* Scanner__init; IMPORT INITLINK* Token__init; IMPORT INITLINK* Module__init; IMPORT INITLINK* Target__init;
#line 11
IMPORT INITLINK* Error__init; IMPORT INITLINK* Type__init; IMPORT INITLINK* Emit__init; IMPORT INITLINK* Expr__init; IMPORT INITLINK* StmtRep__init;
#line 11
IMPORT INITLINK* Stmt__init; IMPORT INITLINK* AssignStmt__init;  IMPORT t93 _SetExpr__CompileAssign (); IMPORT char VS_SetExpr__CompileAssign__0231eea428cde01e;
#line 11
  IMPORT t1 _ObjectType__Is (); IMPORT char VS_ObjectType__Is__bbf46d51350b1d48;   IMPORT t1 _ProcExpr__Split (); IMPORT char VS_ProcExpr__Split__c6a7b3bc2b61b411;
#line 11
  IMPORT t12 _ProcCheckExpr__New (); IMPORT char VS_ProcCheckExpr__New__6648bc1129c6bd44;   IMPORT TYPE TC_ValueRep__V; IMPORT char VS_ValueRep__V__f28699153c608442;
#line 11
IMPORT t10 _ValueRep__NoDuplicates (); IMPORT char VS_ValueRep__NoDuplicates__ed93f73a247eb7b4; IMPORT t12 _ValueRep__NoExpr ();
#line 11
IMPORT char VS_ValueRep__NoExpr__1297c63d2e046c2c; IMPORT t3 _ValueRep__NoType (); IMPORT char VS_ValueRep__NoType__4061f01226f55ca3;
#line 11
IMPORT t5 _ValueRep__NoLoader (); IMPORT char VS_ValueRep__NoLoader__9a7f0c5b24f526c1; IMPORT t93 _ValueRep__NoWriter ();
#line 11
IMPORT char VS_ValueRep__NoWriter__3b24d43c367f7122; IMPORT t93 _ValueRep__NoDeclarer (); IMPORT char VS_ValueRep__NoDeclarer__22db283420635bde;
#line 11
IMPORT t1 _ValueRep__Never (); IMPORT char VS_ValueRep__Never__39b6ab0628d97589; IMPORT t1 _ValueRep__Always (); IMPORT char VS_ValueRep__Always__1b0a9bbf2173b8b3;
#line 11
  IMPORT TYPE TC_Temp__T; IMPORT char VS_Temp__T__3a6c7dc12615e4ee; IMPORT t93 _Temp__Free (); IMPORT char VS_Temp__Free__3b952a2225c26846;
#line 11
  IMPORT t1 _Procedure__IsNested (); IMPORT char VS_Procedure__IsNested__6138cc692dfd93f7;   IMPORT t1 _Variable__HasClosure ();
#line 11
IMPORT char VS_Variable__HasClosure__cb73a74535f6c26c;   IMPORT t1 _QualifyExpr__Split (); IMPORT char VS_QualifyExpr__Split__036a14cd36bf0f52;
#line 11
  IMPORT t1 _SetType__Split (); IMPORT char VS_SetType__Split__edc8fdf02e117577;   IMPORT t1 _RefType__Is (); IMPORT char VS_RefType__Is__9788d4183ade3fd0;
#line 11
  IMPORT t1 _NamedExpr__Split (); IMPORT char VS_NamedExpr__Split__034b990827a61ddc;   IMPORT t1 _ProcType__Is (); IMPORT char VS_ProcType__Is__3d26c6f7230f52c6;
#line 11
  IMPORT t1 _ArrayType__Split (); IMPORT char VS_ArrayType__Split__b3402f88270f8053; IMPORT t3 _ArrayType__OpenImpl (); IMPORT char VS_ArrayType__OpenImpl__fe61729235c79eff;
#line 11
  IMPORT TYPE TC_Value__T; IMPORT char VS_Value__T__2446b70b3f7780a5; IMPORT t9 _Value__ClassOf (); IMPORT char VS_Value__ClassOf__9c68d87829345fcf;
#line 11
    IMPORT t3 _Address__T; IMPORT char VS_Address__T__8a8b518c29ea7c1d;   IMPORT t12 _NarrowExpr__New (); IMPORT char VS_NarrowExpr__New__e2f1207d3fc97ab9;
#line 11
  IMPORT t12 _CheckExpr__New (); IMPORT char VS_CheckExpr__New__a74553ee326c8302; IMPORT t12 _CheckExpr__NewLower (); IMPORT char VS_CheckExpr__NewLower__5e10e5102119d155;
#line 11
IMPORT t12 _CheckExpr__NewUpper (); IMPORT char VS_CheckExpr__NewUpper__0c1ccd9a3f5bc373;   IMPORT t15 _CallStmt__New ();
#line 11
IMPORT char VS_CallStmt__New__4fcb64892cd81b88;   IMPORT t49 _Scanner__cur; IMPORT char VS_Scanner__cur__929fa6f8367ea415;
#line 11
IMPORT t93 _Scanner__GetToken (); IMPORT char VS_Scanner__GetToken__192100a32c7e576d;   IMPORT t17 _Token__DeclStart; IMPORT char VS_Token__DeclStart__730c82bc2c2001b8;
#line 11
IMPORT t17 _Token__TypeStart; IMPORT char VS_Token__TypeStart__f71616cb38a20d02; IMPORT t17 _Token__ExprStart; IMPORT char VS_Token__ExprStart__21dc8a0a27344836;
#line 11
  IMPORT t1 _Module__IsSafe (); IMPORT char VS_Module__IsSafe__13f026ba31f586b3;   IMPORT char VS_Target__CHARSIZE__bfc83af22ccab4e4;
#line 11
  IMPORT t93 _Error__Msg (); IMPORT char VS_Error__Msg__4d119a332467757f; IMPORT t93 _Error__Str (); IMPORT char VS_Error__Str__2bd0723e3872e90c;
#line 11
IMPORT t93 _Error__Warn (); IMPORT char VS_Error__Warn__38cf6ace3df14804;   IMPORT TYPE TC_Type__T; IMPORT char VS_Type__T__2446b70b3f7780a5;
#line 11
IMPORT t2 _Type__Size (); IMPORT char VS_Type__Size__2f4d980e28adf05b; IMPORT t2 _Type__Number (); IMPORT char VS_Type__Number__f5ca10923ed3cf22;
#line 11
IMPORT t93 _Type__GetBounds (); IMPORT char VS_Type__GetBounds__9a241b2b3c98ad98; IMPORT t3 _Type__Base (); IMPORT char VS_Type__Base__2bebd0333659a92c;
#line 11
IMPORT t1 _Type__IsEqual (); IMPORT char VS_Type__IsEqual__4098bc3f32325d05; IMPORT t2 _Type__Name (); IMPORT char VS_Type__Name__f99416972257a869;
#line 11
IMPORT t1 _Type__IsSubtype (); IMPORT char VS_Type__IsSubtype__8591fba5245cb882;   IMPORT char VS_Emit__MaxStream__cf0a0e8934c9c9f3;
#line 11
IMPORT TYPE TC_Emit__Format; IMPORT char VS_Emit__Format__bc4a2b083b93bbd7; IMPORT t93 _Emit__Op (); IMPORT char VS_Emit__Op__072646cc27c8ae10;
#line 11
IMPORT t93 _Emit__OpI (); IMPORT char VS_Emit__OpI__02cb878634bb9f49; IMPORT t93 _Emit__OpII (); IMPORT char VS_Emit__OpII__2247fe46332f901b;
#line 11
IMPORT t93 _Emit__OpT (); IMPORT char VS_Emit__OpT__764bdffe21d249e8; IMPORT t93 _Emit__OpTT (); IMPORT char VS_Emit__OpTT__cba0ce912431e01c;
#line 11
  IMPORT TYPE TC_Expr__T; IMPORT char VS_Expr__T__2446b70b3f7780a5; IMPORT t12 _Expr__Parse (); IMPORT char VS_Expr__Parse__193c41662e6da77f;
#line 11
IMPORT t93 _Expr__Bind (); IMPORT char VS_Expr__Bind__7e2752da3eaf56eb; IMPORT t3 _Expr__TypeOf (); IMPORT char VS_Expr__TypeOf__fef0a11b388c64fa;
#line 11
IMPORT t93 _Expr__GetBounds (); IMPORT char VS_Expr__GetBounds__b20ec781333da5e4; IMPORT t1 _Expr__IsDesignator (); IMPORT char VS_Expr__IsDesignator__e3556614321cb906;
#line 11
IMPORT t1 _Expr__IsWritable (); IMPORT char VS_Expr__IsWritable__85b9bb292e4a0f55; IMPORT t93 _Expr__TypeCheck (); IMPORT char VS_Expr__TypeCheck__af9aa9073729e7f7;
#line 11
IMPORT t5 _Expr__Compile (); IMPORT char VS_Expr__Compile__a7e0cc4029a2ec76; IMPORT t5 _Expr__CompileLValue (); IMPORT char VS_Expr__CompileLValue__46b9da092357ba5c;
#line 11
  IMPORT t93 _StmtRep__Init (); IMPORT char VS_StmtRep__Init__fe14377c36e397de;   IMPORT TYPE TC_Stmt__T; IMPORT char VS_Stmt__T__2446b70b3f7780a5;
#line 11
  EXPORT t15 _AssignStmt__Parse (); EXPORT char VS_AssignStmt__Parse__00ed87be208c7670 = '\0'; EXPORT t15 _AssignStmt__New ();
#line 11
EXPORT char VS_AssignStmt__New__b079448931a7d41d = '\0'; EXPORT t12 _AssignStmt__CheckRHS (); EXPORT char VS_AssignStmt__CheckRHS__9aaea40f392f387e = '\0';
#line 11
EXPORT t1 _AssignStmt__NeedsClosureCheck (); EXPORT char VS_AssignStmt__NeedsClosureCheck__7e619b1c366ab3f3 = '\0'; PRIVATE TYPE TC_AssignStmt__P;
#line 11
PRIVATE t93 _AssignStmt__Bind (); PRIVATE t93 _AssignStmt__Check (); PRIVATE t93 _AssignStmt__Precompile (); PRIVATE void _AssignStmt__Compile ();
#line 11
PRIVATE t93 _AssignStmt__GenOpenArraySizeChecks (); PRIVATE t93 _AssignStmt__GenOpenArraySize ();  IMPORT char VS_M3__Stmt__8851da472c4ee5cd;
#line 11
IMPORT char VS_M3__Value__6b416d5833e03839;    
#line 30 "AssignStmt.m3"
 EXPORT t15 _AssignStmt__Parse (_fail) t17 * _fail; { t17 z2; t2 z3; t17 z4; t17 z1; t12 z5; t1 z6; t15 z7; t7 z0; t7 z8;
#line 30 "AssignStmt.m3"
{ auto t12 _e; auto t7 _p; auto t15 __result; {
      ZERO1  (& _p);
#line 30
      CHECKSTACKOVERFLOW;


      z2.elts [0] = 0x00000800; z2.elts [1] = 0; z2.elts [2] = 0; z2.elts [3] = 0; z4.elts[0] = (*_fail).elts[0] | z2.elts[0];
#line 33
      z4.elts[1] = (*_fail).elts[1] | z2.elts[1]; z4.elts[2] = (*_fail).elts[2] | z2.elts[2]; z4.elts[3] = (*_fail).elts[3] | z2.elts[3];
#line 33
      z1 = z4; z5 = _Expr__Parse (&z1); _e = z5;
      z6 = ((_Scanner__cur._token) !=  11 ); if (z6) { z7 = _CallStmt__New (_e); __result = z7; return __result; };
      { register char** ptr = (char**) UNEWOBJ (TC7); z0 = (t7) ptr; }; _p = z0;
      _StmtRep__Init (_p);
      _Scanner__GetToken ();
      NILCHECKA (z8 = _p); (((t7_fields*)(z8+(0+t67_size+t91_size)))->_lhs) = _e;
      z5 = _Expr__Parse (&(*_fail)); NILCHECKA (z8 = _p); (((t7_fields*)(z8+(0+t67_size+t91_size)))->_rhs) = z5;
      __result = _p; return __result; } } };
#line 43 "AssignStmt.m3"
 EXPORT t15 _AssignStmt__New (_lhs, _rhs) t12 _lhs; t12 _rhs; { t7 z0; t7 z2;
#line 43 "AssignStmt.m3"
{ auto t7 _p; auto t15 __result; {
      ZERO1  (& _p); { register char** ptr = (char**) UNEWOBJ (TC7); z0 = (t7) ptr; }; _p = z0;
#line 43
      CHECKSTACKOVERFLOW;


      _StmtRep__Init (_p);
      NILCHECKA (z2 = _p); (((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs) = _lhs;
      NILCHECKA (z2 = _p); (((t7_fields*)(z2+(0+t67_size+t91_size)))->_rhs) = _rhs;
      __result = _p; return __result; } } };
#line 52 "AssignStmt.m3"
 EXPORT t12 _AssignStmt__CheckRHS (_tlhs, _rhs, _kind) t3 _tlhs; t12 _rhs; t68 _kind; { t3 z2; t1 z4; t1 z0; t1 z3; t1 z1;
t12 z5; t2 z6; t3 z7;
#line 52 "AssignStmt.m3"
{ auto t3 _trhs; auto t3 _t; auto t3 _index; auto t3 _element; auto t1 _openRHS; auto t1 _openLHS; auto t2 _lmin; auto t2 _lmax;
#line 52
   auto t2 _rmin; auto t2 _rmax; auto t12 _zz; auto t12 __result; {



      ZERO1B (& _openRHS); ZERO1B (& _openLHS);
#line 52
      CHECKSTACKOVERFLOW;







      _zz = _rhs;
      _Expr__TypeCheck (_rhs);
      z2 = _Expr__TypeOf (_rhs); _trhs = z2;

      z2 = _Type__Base (_trhs); _t = z2;
      z4 = _ArrayType__Split (_t, &_index, &_element); z0 = 0; if (z4) { z3 = (_index == 0); z0 = z3; }; _openRHS = z0;
      z2 = _Type__Base (_tlhs); _t = z2;
      z4 = _ArrayType__Split (_t, &_index, &_element); z0 = 0; if (z4) { z3 = (_index == 0); z0 = z3; }; _openLHS = z0;

      z3 = (_tlhs == _trhs); z0 = 1; if (! z3) { z4 = _Type__IsSubtype (_trhs, _tlhs); z0 = z4; }; if (z0) {

         z1 = 1; if (! _openRHS) { z1 = _openLHS; }; if (z1) { goto if_3_end; }; z3 = (_kind ==  0 ); z0 = 0; if (z3) { z3 = _ProcType__Is (_trhs);
#line 71
            z0 = z3; }; z1 = 0; if (z0) { z3 = _AssignStmt__NeedsClosureCheck (_rhs); z1 = z3; }; if (z1) {




            z5 = _ProcCheckExpr__New (_rhs); _rhs = z5; goto if_3_end; }; if_3_end: /**/; goto if_2_end; }; z6 = _Type__Number (_tlhs);
#line 76
      z1 = (z6 >=  0 ); if (z1) {




         z7 = _Type__Base (_tlhs); z3 = _Type__IsSubtype (_trhs, z7); z0 = ! z3; if (z0) {
            _Error__Msg (((ADDRESS)(& txt1.str))); goto if_4_end; }; _Type__GetBounds (_tlhs, &_lmin, &_lmax);



            _Expr__GetBounds (_rhs, &_rmin, &_rmax);
            z3 = (_lmin <= _lmax); z0 = 0; if (z3) { z3 = (_rmin <= _rmax); z0 = z3; }; z1 = 0; if (z0) { z3 = (_lmax < _rmin);
#line 87
               z0 = 1; if (! z3) { z4 = (_rmax < _lmin); z0 = z4; }; z1 = z0; }; if (z1) {


               _Error__Warn ( 2 , ((ADDRESS)(& txt2.str)));
               z5 = _CheckExpr__New (_rhs, _lmin, _lmax); _rhs = z5; goto if_5_end; }; z3 = (_rmin < _lmin); z0 = 0; if (z3) {
#line 91
               z3 = (_rmax > _lmax); z0 = z3; }; if (z0) {

               z5 = _CheckExpr__New (_rhs, _lmin, _lmax); _rhs = z5; goto if_5_end; }; z3 = (_rmin < _lmin); if (z3) {

               z5 = _CheckExpr__NewLower (_rhs, _lmin); _rhs = z5; goto if_5_end; }; z3 = (_rmax > _lmax); if (z3) {

               z5 = _CheckExpr__NewUpper (_rhs, _lmax); _rhs = z5; goto if_5_end; }; if_5_end: /**/; if_4_end: /**/; goto if_2_end;
#line 97
 }; z3 = _Type__IsSubtype (_tlhs, _trhs); if (z3) {




         z3 = _Type__IsEqual (_trhs, _Address__T); if (z3) {

            z1 = _Module__IsSafe (); if (z1) { _Error__Msg (((ADDRESS)(& txt3.str))); goto if_7_end; }; if_7_end: /**/; goto if_6_end;
#line 104
 }; z3 = _RefType__Is (_trhs); z0 = 1; if (! z3) { z3 = _ObjectType__Is (_trhs); z0 = z3; }; if (z0) {


            z5 = _NarrowExpr__New (_rhs, _tlhs); _rhs = z5; goto if_6_end; }; z1 = 1; if (! _openRHS) { z1 = _openLHS; };
#line 107
         if (z1) { goto if_6_end; }; _Error__Msg (((ADDRESS)(& txt1.str)));




 if_6_end: /**/; goto if_2_end; }; _Error__Msg (((ADDRESS)(& txt1.str)));



 if_2_end: /**/;


      z3 = (_rhs != _zz); if (z3) { _Expr__Bind (_rhs); _Expr__TypeCheck (_rhs); goto if_8_end; }; if_8_end: /**/;

      __result = _rhs; return __result; } } };
#line 124 "AssignStmt.m3"
 EXPORT t1 _AssignStmt__NeedsClosureCheck (_e) t12 _e; { t1 z4; t1 z0; t1 z1; t9 z2; t1 z3; t36 z5; t10 z6; t63 z7;
#line 124 "AssignStmt.m3"
{ auto t11 _name; auto t10 _obj; auto t9 _class; auto t1 __result; {
      ZERO1B (& _class);
#line 124
      ZERO1B (& __result); CHECKSTACKOVERFLOW;


      z4 = _NamedExpr__Split (_e, &_name, &_obj); z0 = 1; if (! z4) { z4 = _QualifyExpr__Split (_e, &_obj); z0 = z4; }; z1 = 1;
#line 127
      if (! z0) { z4 = _ProcExpr__Split (_e, &_obj); z1 = z4; }; z0 = ! z1; if (z0) {



         __result =  0 ; return __result; };

      z2 = _Value__ClassOf (_obj); _class = z2;
      z3 = (_class ==  4 ); if (z3) {
         z5 = NARROW (_obj, t36, TC36, z5); z1 = _Procedure__IsNested (z5); if (z1) {
            NILCHECKA (z6 = _obj); _Error__Str ((((t30_fields*)(z6+(0+t91_size)))->_name), ((ADDRESS)(& txt4.str)));
            __result =  0 ; return __result; }; __result =  1 ;

            return __result; }; z3 = (_class ==  1 ); z0 = 0; if (z3) { z7 = NARROW (_obj, t63, TC63, z7); z3 = _Variable__HasClosure (z7);
#line 139
         z0 = z3; }; if (z0) {


         __result =  1 ; return __result; }; __result =  0 ;

         return __result; } } };
#line 149 "AssignStmt.m3"
 PRIVATE t93 _AssignStmt__Bind (_p) t7 _p; { t7 z2;
#line 149 "AssignStmt.m3"
{ { CHECKSTACKOVERFLOW;

      NILCHECKA (z2 = _p); _Expr__Bind ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs));
      NILCHECKA (z2 = _p); _Expr__Bind ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_rhs)); } } };
#line 155 "AssignStmt.m3"
 PRIVATE t93 _AssignStmt__Check (_p) t7 _p; { t7 z2; t3 z3; t1 z4; t1 z0; t7 z5; t12 z6; t7 z1;
#line 155 "AssignStmt.m3"
{ auto t3 _tlhs; { CHECKSTACKOVERFLOW;


      NILCHECKA (z2 = _p); _Expr__TypeCheck ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs));
      NILCHECKA (z2 = _p); z3 = _Expr__TypeOf ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs)); _tlhs = z3;

      NILCHECKA (z2 = _p); z4 = _Expr__IsDesignator ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs)); z0 = ! z4; if (z0) {
         _Error__Msg (((ADDRESS)(& txt5.str))); goto if_12_end; }; NILCHECKA (z2 = _p); z4 = _Expr__IsWritable ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs));
#line 162
      z0 = ! z4; if (z0) {

         _Error__Msg (((ADDRESS)(& txt6.str))); goto if_12_end; }; if_12_end: /**/;


      NILCHECKA (z5 = _p); z6 = _AssignStmt__CheckRHS (_tlhs, (((t7_fields*)(z5+(0+t67_size+t91_size)))->_rhs),  0 ); NILCHECKA (z1 = _p);
#line 167
      (((t7_fields*)(z1+(0+t67_size+t91_size)))->_rhs) = z6; } } };
#line 170 "AssignStmt.m3"
 PRIVATE t93 _AssignStmt__Precompile (_p) t7 _p; {
#line 170 "AssignStmt.m3"
{ { CHECKSTACKOVERFLOW; } } };
#line 174 "AssignStmt.m3"
 PRIVATE void _AssignStmt__Compile (_p, _return) t7 _p; t6* _return; { t7 z3; t3 z4; t3 z1; t1 z5; t1 z0; t7 z2; t5 z6; t3 z7;
t2 z8; t2 z9; t6 z10;
#line 174 "AssignStmt.m3"
{ auto t3 _t; auto t3 _u; auto t3 _t1; auto t3 _t2; auto t3 _t3; auto t3 _t4; auto t3 _range; auto t1 _openLHS; auto t1 _openRHS;
#line 174
   auto t5 _tLHS; auto t5 _tRHS; auto t6 __result; {


      ZERO1B (& _openLHS); ZERO1B (& _openRHS);
#line 174
      CHECKSTACKOVERFLOW;





      NILCHECKA (z3 = _p); z4 = _Expr__TypeOf ((((t7_fields*)(z3+(0+t67_size+t91_size)))->_rhs)); z1 = _Type__Base (z4); _t = z1;
      NILCHECKA (z3 = _p); z4 = _Expr__TypeOf ((((t7_fields*)(z3+(0+t67_size+t91_size)))->_lhs)); z1 = _Type__Base (z4); _u = z1;
      z5 = _ArrayType__Split (_t, &_t1, &_t2); z0 = 0; if (z5) { z5 = (_t1 == 0); z0 = z5; }; _openRHS = z0;
      z5 = _ArrayType__Split (_u, &_t3, &_t4); z0 = 0; if (z5) { z5 = (_t3 == 0); z0 = z5; }; _openLHS = z0;
      NILCHECKA (z2 = _p); z6 = _Expr__Compile ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_rhs)); _tRHS = z6;
      NILCHECKA (z2 = _p); z6 = _Expr__CompileLValue ((((t7_fields*)(z2+(0+t67_size+t91_size)))->_lhs)); _tLHS = z6;
      z5 = 0; if (_openRHS) { z5 = _openLHS; }; if (z5) {
         _Emit__Op (((ADDRESS)(& txt7.str)));
         z7 = _ArrayType__OpenImpl (_t); z8 = _Type__Name (z7); _Emit__OpI (((ADDRESS)(& txt8.str)), z8);
         z7 = _ArrayType__OpenImpl (_u); z8 = _Type__Name (z7); _Emit__OpI (((ADDRESS)(& txt9.str)), z8);
         _Emit__OpT (((ADDRESS)(& txt10.str)), _tRHS);
         _Emit__OpT (((ADDRESS)(& txt11.str)), _tLHS);
         _AssignStmt__GenOpenArraySizeChecks (_t, _u);
         _Emit__Op (((ADDRESS)(& txt12.str)));
         _AssignStmt__GenOpenArraySize (_t, _u);
         _Emit__Op (((ADDRESS)(& txt13.str))); goto if_13_end; }; if (_openRHS) {

         _Emit__Op (((ADDRESS)(& txt7.str)));
         z7 = _ArrayType__OpenImpl (_t); z8 = _Type__Name (z7); _Emit__OpI (((ADDRESS)(& txt8.str)), z8);
         z8 = _Type__Name (_u); _Emit__OpI (((ADDRESS)(& txt14.str)), z8);
         _Emit__OpT (((ADDRESS)(& txt10.str)), _tRHS);
         z8 = _Type__Name (_u); _Emit__OpI (((ADDRESS)(& txt15.str)), z8);
         _Emit__OpT (((ADDRESS)(& txt16.str)), _tLHS);
         _AssignStmt__GenOpenArraySizeChecks (_t, _u);

         z8 = _Type__Size (_u); z9 = IDIV (z8,  8 ); _Emit__OpI (((ADDRESS)(& txt17.str)), z9);
         _Emit__Op (((ADDRESS)(& txt18.str))); goto if_13_end; }; if (_openLHS) {

         _Emit__Op (((ADDRESS)(& txt7.str)));
         z8 = _Type__Name (_t); _Emit__OpI (((ADDRESS)(& txt8.str)), z8);
         z7 = _ArrayType__OpenImpl (_u); z8 = _Type__Name (z7); _Emit__OpI (((ADDRESS)(& txt9.str)), z8);
         z8 = _Type__Name (_t); _Emit__OpI (((ADDRESS)(& txt19.str)), z8);
         _Emit__OpT (((ADDRESS)(& txt16.str)), _tRHS);
         _Emit__OpT (((ADDRESS)(& txt11.str)), _tLHS);
         _AssignStmt__GenOpenArraySizeChecks (_t, _u);

         z8 = _Type__Size (_t); z9 = IDIV (z8,  8 ); _Emit__OpI (((ADDRESS)(& txt17.str)), z9);
         _Emit__Op (((ADDRESS)(& txt18.str))); goto if_13_end; }; z5 = _SetType__Split (_t, &_range); if (z5) {

         _SetExpr__CompileAssign (_range, _tLHS, _tRHS); goto if_13_end; }; z8 = _Type__Name (_t); z9 = _Type__Name (_u);
#line 219
      z0 = (z8 == z9); if (z0) {

         _Emit__OpTT (((ADDRESS)(& txt20.str)), _tLHS, _tRHS); goto if_13_end; }; _Emit__OpT (((ADDRESS)(& txt21.str)), _tLHS);


         z8 = _Type__Name (_u); _Emit__OpI (((ADDRESS)(& txt22.str)), z8);
         _Emit__OpT (((ADDRESS)(& txt23.str)), _tRHS); if_13_end: /**/;

      _Temp__Free (_tLHS);
      _Temp__Free (_tRHS);
      z10.elts [0] = 0x00000001; __result = z10; *_return = __result; return; } } };
#line 232 "AssignStmt.m3"
 PRIVATE t93 _AssignStmt__GenOpenArraySizeChecks (_t, _u) t3 _t; t3 _u; { t1 z4; t1 z2; t1 z0; t1 z3; t1 z1; t2 z5;
#line 232 "AssignStmt.m3"
{ auto t3 _t1; auto t3 _t2; auto t3 _t3; auto t3 _t4; auto t1 _b1; auto t1 _b2; auto t2 _i; auto t2 _j; {
      ZERO1B (& _b1); ZERO1B (& _b2);
#line 232
      CHECKSTACKOVERFLOW;


      { { auto t1 _b; { ZERO1B (& _b); z4 = _ArrayType__Split (_t, &_t1, &_t2); _b = z4;
               if (!_b) ASSERTFAULT; } } };
      { { auto t1 _b; { ZERO1B (& _b); z4 = _ArrayType__Split (_u, &_t3, &_t4); _b = z4;
               if (!_b) ASSERTFAULT; } } };
      _i =  0 ;
      loop_0:; z2 = (_t1 == 0);
         z0 = 0; if (z2) { z3 = (_t3 == 0); z0 = z3; }; if (z0) {
            _Emit__OpII (((ADDRESS)(& txt24.str)), _i, _i);
            z4 = _ArrayType__Split (_t2, &_t1, &_t2); _b1 = z4;
            z4 = _ArrayType__Split (_t4, &_t3, &_t4); _b2 = z4;
            z2 = (_b1 == _b2); if (!z2) ASSERTFAULT;
            z1 = ! _b1; if (z1) { goto loop_exit_0; }; goto if_14_end; }; z2 = (_t1 == 0); if (z2) {


            z5 = _Type__Number (_t3); _Emit__OpII (((ADDRESS)(& txt25.str)), _i, z5);
            z4 = _ArrayType__Split (_t2, &_t1, &_t2); _b1 = z4;
            z4 = _ArrayType__Split (_t4, &_t3, &_t4); _b2 = z4;
            z2 = (_b1 == _b2); if (!z2) ASSERTFAULT;
            z1 = ! _b1; if (z1) { goto loop_exit_0; }; goto if_14_end; }; z2 = (_t3 == 0); if (z2) {


            z5 = _Type__Number (_t1); _Emit__OpII (((ADDRESS)(& txt26.str)), _i, z5);
            z4 = _ArrayType__Split (_t2, &_t1, &_t2); _b1 = z4;
            z4 = _ArrayType__Split (_t4, &_t3, &_t4); _b2 = z4;
            z2 = (_b1 == _b2); if (!z2) ASSERTFAULT;
            z1 = ! _b1; if (z1) { goto loop_exit_0; }; goto if_14_end; }; z5 = _Type__Size (_t2);

            _i = z5;
            z5 = _Type__Size (_t4); _j = z5;
            z2 = (_i == _j); if (!z2) ASSERTFAULT;
            goto loop_exit_0; if_14_end: /**/;

         _i +=  1 ; goto loop_0; loop_exit_0: /**/; } } };
#line 271 "AssignStmt.m3"
 PRIVATE t93 _AssignStmt__GenOpenArraySize (_t, _u) t3 _t; t3 _u; { t1 z4; t1 z2; t1 z0; t1 z3; t1 z1; t2 z5; t2 z6;
#line 271 "AssignStmt.m3"
{ auto t3 _t1; auto t3 _t2; auto t3 _t3; auto t3 _t4; auto t1 _b1; auto t1 _b2; auto t2 _i; {
      ZERO1B (& _b1); ZERO1B (& _b2);
#line 271
      CHECKSTACKOVERFLOW;


      { { auto t1 _b; { ZERO1B (& _b); z4 = _ArrayType__Split (_t, &_t1, &_t2); _b = z4;
               if (!_b) ASSERTFAULT; } } };
      { { auto t1 _b; { ZERO1B (& _b); z4 = _ArrayType__Split (_u, &_t3, &_t4); _b = z4;
               if (!_b) ASSERTFAULT; } } };
      _i =  0 ;
      z2 = (_t1 == 0); z0 = 0; if (z2) { z3 = (_t3 == 0); z0 = z3; }; if (z0) do { _Emit__OpI (((ADDRESS)(& txt27.str)), _i);

         z4 = _ArrayType__Split (_t2, &_t1, &_t2); _b1 = z4;
         z4 = _ArrayType__Split (_t4, &_t3, &_t4); _b2 = z4;
         z2 = (_b1 == _b2); if (!z2) ASSERTFAULT;
         z1 = ! _b1; if (z1) { _t1 = _t2; goto if_18_end; }; if_18_end: /**/;
         _i +=  1 ; z2 = (_t1 == 0); z0 = 0; if (z2) { z3 = (_t3 == 0); z0 = z3; }; } while (z0);

      z2 = (_t1 == 0); if (z2) {
         z5 = _Type__Size (_t4); z6 = IDIV (z5,  8 ); _Emit__OpI (((ADDRESS)(& txt28.str)), z6); goto if_19_end; }; z5 = _Type__Size (_t2);
         z6 = IDIV (z5,  8 ); _Emit__OpI (((ADDRESS)(& txt28.str)), z6); if_19_end: /**/; } } };  PRIVATE int init_done = -1;
#line 289 "AssignStmt.m3"
 PRIVATE void AssignStmt__initProc (g) int g; {
#line 289 "AssignStmt.m3"
if (init_done >= g) return; init_done = g; INITIALIZE (& AssignStmt__init); INITIALIZE (& SetExpr__init); INITIALIZE (& ObjectType__init);
#line 289
INITIALIZE (& ProcExpr__init); INITIALIZE (& ProcCheckExpr__init); INITIALIZE (& ValueRep__init); INITIALIZE (& Temp__init);
#line 289
INITIALIZE (& Procedure__init); INITIALIZE (& Variable__init); INITIALIZE (& QualifyExpr__init); INITIALIZE (& SetType__init);
#line 289
INITIALIZE (& RefType__init); INITIALIZE (& NamedExpr__init); INITIALIZE (& ProcType__init); INITIALIZE (& ArrayType__init);
#line 289
INITIALIZE (& Value__init); INITIALIZE (& String__init); INITIALIZE (& Address__init); INITIALIZE (& NarrowExpr__init); INITIALIZE (& CheckExpr__init);
#line 289
INITIALIZE (& CallStmt__init); INITIALIZE (& Scanner__init); INITIALIZE (& Token__init); INITIALIZE (& Module__init); INITIALIZE (& Target__init);
#line 289
INITIALIZE (& Error__init); INITIALIZE (& Type__init); INITIALIZE (& Emit__init); INITIALIZE (& Expr__init); INITIALIZE (& StmtRep__init);
#line 289
INITIALIZE (& Stmt__init); return; }; 
#line 289 "AssignStmt.m3"
PRIVATE void t7_InitProc (obj) char* obj; { register t7_fields* p;
#line 289 "AssignStmt.m3"
CHECKSTACKOVERFLOW; p = (t7_fields*) (obj + TC15->datasize); }; 
#line 289 "AssignStmt.m3"
PRIVATE void t7_SetupProc () { register int* p;
#line 289 "AssignStmt.m3"
t7_TC.datasize += TC15->datasize; t7_TC.methodsize += TC15->methodsize; p = (int*) UALLOC (t7_TC.methodsize); COPY (TC15->defaultMethods, p, (TC15->methodsize));
#line 289
p[0] = (int)(& t7_TC); p[1] = 0; ((t67_methods*) (((char*)p) + TC91->methodsize))->_bind = _AssignStmt__Bind; ((t67_methods*) (((char*)p) + TC91->methodsize))->_check = _AssignStmt__Check;
#line 289
((t67_methods*) (((char*)p) + TC91->methodsize))->_precompile = _AssignStmt__Precompile; ((t67_methods*) (((char*)p) + TC91->methodsize))->_compile = _AssignStmt__Compile;
#line 289
t7_TC.defaultMethods = (char*) p; }; 
#line 289 "AssignStmt.m3"
PRIVATE void t7_PrintProc (obj) char *obj; { t7_fields* o;
#line 289 "AssignStmt.m3"
CHECKSTACKOVERFLOW; if (TC15->printProc != 0) {TC15->printProc (obj); } fprintf (stderr, "{%s} ", TC7->brand); o = (t7_fields*) (obj + TC15->datasize);
#line 289
fprintf (stderr, "lhs = %#x", o->_lhs); fprintf (stderr, ", "); fprintf (stderr, "rhs = %#x", o->_rhs); fprintf (stderr, ", ");
#line 289
 };   PRIVATE INITLINK me_0 ={(INITLINK*)NIL, 0, AssignStmt__initProc}; static char* VSimports[] = { &VS_SetExpr__CompileAssign__0231eea428cde01e,
&VS_ObjectType__Is__bbf46d51350b1d48, &VS_ProcExpr__Split__c6a7b3bc2b61b411, &VS_ProcCheckExpr__New__6648bc1129c6bd44, &VS_ValueRep__V__f28699153c608442,
&VS_ValueRep__NoDuplicates__ed93f73a247eb7b4, &VS_ValueRep__NoExpr__1297c63d2e046c2c, &VS_ValueRep__NoType__4061f01226f55ca3,
&VS_ValueRep__NoLoader__9a7f0c5b24f526c1, &VS_ValueRep__NoWriter__3b24d43c367f7122, &VS_ValueRep__NoDeclarer__22db283420635bde,
&VS_ValueRep__Never__39b6ab0628d97589, &VS_ValueRep__Always__1b0a9bbf2173b8b3, &VS_Temp__T__3a6c7dc12615e4ee, &VS_Temp__Free__3b952a2225c26846,
&VS_Procedure__T__be7ead4a3afd8be5, &VS_Procedure__IsNested__6138cc692dfd93f7, &VS_Variable__T__be7ead4a3afd8be5, &VS_Variable__HasClosure__cb73a74535f6c26c,
&VS_QualifyExpr__Split__036a14cd36bf0f52, &VS_SetType__Split__edc8fdf02e117577, &VS_RefType__Is__9788d4183ade3fd0, &VS_NamedExpr__Split__034b990827a61ddc,
&VS_ProcType__Raisee__5fe771ff27c179d9, &VS_ProcType__Is__3d26c6f7230f52c6, &VS_ArrayType__Split__b3402f88270f8053, &VS_ArrayType__OpenImpl__fe61729235c79eff,
&VS_Value__T__2446b70b3f7780a5, &VS_Value__ClassOf__9c68d87829345fcf, &VS_String__T__3a6c7dc12615e4ee, &VS_Address__T__8a8b518c29ea7c1d,
&VS_NarrowExpr__New__e2f1207d3fc97ab9, &VS_CheckExpr__New__a74553ee326c8302, &VS_CheckExpr__NewLower__5e10e5102119d155, &VS_CheckExpr__NewUpper__0c1ccd9a3f5bc373,
&VS_CallStmt__New__4fcb64892cd81b88, &VS_Scanner__cur__929fa6f8367ea415, &VS_Scanner__GetToken__192100a32c7e576d, &VS_Token__DeclStart__730c82bc2c2001b8,
&VS_Token__TypeStart__f71616cb38a20d02, &VS_Token__ExprStart__21dc8a0a27344836, &VS_Module__T__be7ead4a3afd8be5, &VS_Module__IsSafe__13f026ba31f586b3,
&VS_Target__CHARSIZE__bfc83af22ccab4e4, &VS_Error__Msg__4d119a332467757f, &VS_Error__Str__2bd0723e3872e90c, &VS_Error__Warn__38cf6ace3df14804,
&VS_Type__T__2446b70b3f7780a5, &VS_Type__Map__41dd9f4b33104fce, &VS_Type__List__5791758e343becc1, &VS_Type__Size__2f4d980e28adf05b,
&VS_Type__Number__f5ca10923ed3cf22, &VS_Type__GetBounds__9a241b2b3c98ad98, &VS_Type__Base__2bebd0333659a92c, &VS_Type__IsEqual__4098bc3f32325d05,
&VS_Type__Name__f99416972257a869, &VS_Type__IsSubtype__8591fba5245cb882, &VS_Emit__MaxStream__cf0a0e8934c9c9f3, &VS_Emit__Format__bc4a2b083b93bbd7,
&VS_Emit__Op__072646cc27c8ae10, &VS_Emit__OpI__02cb878634bb9f49, &VS_Emit__OpII__2247fe46332f901b, &VS_Emit__OpT__764bdffe21d249e8,
&VS_Emit__OpTT__cba0ce912431e01c, &VS_Expr__T__2446b70b3f7780a5, &VS_Expr__List__3f87eceb2b9a246a, &VS_Expr__Parse__193c41662e6da77f,
&VS_Expr__Bind__7e2752da3eaf56eb, &VS_Expr__TypeOf__fef0a11b388c64fa, &VS_Expr__GetBounds__b20ec781333da5e4, &VS_Expr__IsDesignator__e3556614321cb906,
&VS_Expr__IsWritable__85b9bb292e4a0f55, &VS_Expr__TypeCheck__af9aa9073729e7f7, &VS_Expr__Compile__a7e0cc4029a2ec76, &VS_Expr__CompileLValue__46b9da092357ba5c,
&VS_StmtRep__Init__fe14377c36e397de, &VS_Stmt__T__2446b70b3f7780a5, NIL };  void AssignStmt__MLink (phase) int phase; { switch (phase) { case 0: { me_0.link = AssignStmt__init; AssignStmt__init = & me_0;
         t7_TC = t7_TC_init; REGISTERTYPE (TC7); break; }; case 1: { t7_TC.parent = TC_M3__Stmt; break; }; case 2: { break; }; };
 };