#include "M3Runtime.h"

#define t3 ADDRESS
#define t45 void
#define TC3 TC_REFANY
IMPORT TYPE TC_REFANY; IMPORT char VS_REFANY__4b8748e831fc107a;
#line 1179 "List.m3"
#define t6 ADDRESS
typedef double t7;
#line 1179
PRIVATE void t6_PrintProc (); PRIVATE typecell t6_TC; PRIVATE typecell t6_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,   8, 0, NIL,   0, 0, (PROC)NIL, (PROC)NIL, t6_PrintProc,
#line 1179
  "", 1016303358, 682265154}; PRIVATE TYPE TC6 = &t6_TC; 
#line 1177
#define t8 ADDRESS
typedef int t2;
#line 1177
PRIVATE void t8_PrintProc (); PRIVATE typecell t8_TC; PRIVATE typecell t8_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,   4, 0, NIL,   0, 0, (PROC)NIL, (PROC)NIL, t8_PrintProc,
#line 1177
  "", -280641975, 792733071}; PRIVATE TYPE TC8 = &t8_TC; 
#line 1175
#define t9 ADDRESS
typedef unsigned char t10;
#line 1175
PRIVATE void t9_PrintProc (); PRIVATE typecell t9_TC; PRIVATE typecell t9_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,   1, 0, NIL,   0, 0, (PROC)NIL, (PROC)NIL, t9_PrintProc,
#line 1175
  "", -465682409, 854177237}; PRIVATE TYPE TC9 = &t9_TC; 
#line 1173
#define t11 ADDRESS
typedef unsigned char t12;
#line 1173
PRIVATE void t11_PrintProc (); PRIVATE typecell t11_TC; PRIVATE typecell t11_TC_init = {0, 0, 0, 0, 0, (PROC)NIL,   1, 0, NIL,   0, 0, (PROC)NIL, (PROC)NIL, t11_PrintProc,
#line 1173
  "", -319100444, 689771106}; PRIVATE TYPE TC11 = &t11_TC; 
#line 1169
#define t13 ADDRESS
typedef struct {
#line 244 "./List.i3"
   char* elts; int size[1]; } t42;
#line 1169 "List.m3"
#define t14 t42
PRIVATE void t13_MapProc ();
#line 1169
PRIVATE void t13_PrintProc (); PRIVATE typecell t13_TC; PRIVATE typecell t13_TC_init = {0, 0, 0, 0, 0, t13_MapProc,   -2, 0, NIL, 1, 4, (PROC)NIL, (PROC)NIL, t13_PrintProc,
#line 1169
  "", -38782153, 817587111}; PRIVATE TYPE TC13 = &t13_TC; 
#line 32 "./List.i3"
#define t15 ADDRESS
typedef struct { t3 _first; t15 _tail; } t43;
#line 32
#define TC15 TC_List__T
IMPORT TYPE TC_List__T;
#line 32
IMPORT char VS_List__T__c661f0b12f626d56; 
#define t47 ADDRESS
#define TC47 TC_ADDRESS
IMPORT TYPE TC_ADDRESS; IMPORT char VS_ADDRESS__30f7308738738b44; 
#define t48 ADDRESS
#define TC48 TC_NULL
IMPORT TYPE TC_NULL; IMPORT char VS_NULL__fb50c7d53bec30dc;
#line 1036 "List.m3"
#define t1 t42
typedef t2 (*t4)(); 
#define t5 ADDRESS
#define TC5 TC_TEXT
IMPORT TYPE TC_TEXT; IMPORT char VS_TEXT__b7a92447326386f5; 
#define t5_MapProc TC_TEXT->mapProc
typedef int t16;
#line 1138
typedef t13 (*t17)();
#line 1120
typedef t15 (*t18)();
#line 1036
typedef signed_char t19; typedef struct { t15 elts[28]; } t20;
#line 438
typedef signed_char t28;
#line 38 "./List.i3"
typedef t28 (*t21)();
#line 982 "List.m3"
typedef t12 (*t22)();
#line 765
#define t23 ADDRESS

#line 44 "./List.i3"
typedef t45 (*t26)();
#line 23 ".ROOT/.boots/corelib/Interfaces/Thread.i3"
#define t27 ADDRESS
 typedef t3 (*t24)(); 
#define t35 ADDRESS
 typedef struct { TYPE self; int private; } t35_methods; 
#define t35_msize (sizeof (t35_methods))
typedef struct { ADDRESS methods; } t35_fields; 
#define t35_size (sizeof (t35_fields))
#define TC35 TC_ROOT
IMPORT TYPE TC_ROOT; IMPORT char VS_ROOT__349f58f628be0ac6; 
#define t35_MapProc TC_ROOT->mapProc
typedef struct {
#line 23
   t24 _apply; } t27_methods; 
#define t27_msize (sizeof (t27_methods))
typedef struct {
#line 23
 int filler; } t27_fields; 
#define t27_size (sizeof (t27_fields))
#define TC27 TC_Thread__Closure
IMPORT TYPE TC_Thread__Closure;
#line 23
IMPORT char VS_Thread__Closure__7fb5c6232c5a658a; 
#define t27_MapProc TC_Thread__Closure->mapProc
typedef struct {
#line 765 "List.m3"
   int filler; } t23_methods; 
#define t23_msize (sizeof (t23_methods))
typedef struct {
#line 765
 t26 _proc; t3 _arg; t3 _first; } t23_fields; 
#define t23_size (sizeof (t23_fields))
PRIVATE void t23_InitProc ();
#line 765
PRIVATE void t23_SetupProc (); PRIVATE void t23_PrintProc (); PRIVATE void t23_MapProc (); PRIVATE typecell t23_TC; PRIVATE typecell t23_TC_init = {0, 0, 0, 0, 0, t23_MapProc,
#line 765
  t23_size, t23_msize, NIL, 0, 0, t23_InitProc,   t23_SetupProc,   t23_PrintProc, "", 576474158, 695486577}; PRIVATE TYPE TC23 = &t23_TC;
#line 765

#line 15 ".ROOT/.boots/corelib/Interfaces/Thread.i3"
#define t25 ADDRESS
#define TC25 TC_Thread__T
IMPORT TYPE TC_Thread__T;
#line 15
IMPORT char VS_Thread__T__2555b70b3f7780b1; 
#define t25_MapProc TC_Thread__T->mapProc
typedef t16 (*t29)();
#line 52 ".ROOT/.boots/corelib/Interfaces/Text.i3"
#define t30 t42
typedef t5 (*t31)();
#line 23
typedef t10 (*t32)();
#line 83 ".ROOT/.boots/corelib/Interfaces/Rd.i3"
#define t33 ADDRESS
#define TC33 TC_Rd__T
IMPORT TYPE TC_Rd__T;
#line 83
IMPORT char VS_Rd__T__2555b70b3f7780b1; 
#define t33_MapProc TC_Rd__T->mapProc
typedef unsigned char t34;
#line 21 ".ROOT/.boots/corelib/Interfaces/Thread.i3"
#define t36 ADDRESS
#define TC36 TC_Thread__Condition
IMPORT TYPE TC_Thread__Condition;
#line 21
IMPORT char VS_Thread__Condition__26d5968239e08f4e; 
#define t36_MapProc TC_Thread__Condition->mapProc
#define t37 ADDRESS
#define TC37 TC_MUTEX
IMPORT TYPE TC_MUTEX; IMPORT char VS_MUTEX__1f9d4e89391ab815; 
#define t37_MapProc TC_MUTEX->mapProc
typedef t25 (*t38)();






typedef t36 (*t39)();
#line 31
typedef t37 (*t40)();
#line 28
#define t41 ADDRESS

#line 28
typedef struct { int filler; } t41_methods; 
#define t41_msize (sizeof (t41_methods))
typedef struct {
#line 28
 t16 _stackSize; } t41_fields; 
#define t41_size (sizeof (t41_fields))
#define TC41 TC_Thread__SizedClosure
IMPORT TYPE TC_Thread__SizedClosure;
#line 28
IMPORT char VS_Thread__SizedClosure__8a46717d2eae7b07; 
#define t41_MapProc TC_Thread__SizedClosure->mapProc
typedef CLOSURE t44; 
#define t46 ADDRESS
 typedef struct { TYPE self; int private; } t46_methods; 
#define t46_msize (sizeof (t46_methods))
typedef struct { ADDRESS methods; } t46_fields; 
#define t46_size (sizeof (t46_fields))
#define TC46 TC_UNTRACED_ROOT
IMPORT TYPE TC_UNTRACED_ROOT; IMPORT char VS_UNTRACED_ROOT__3e0964513fd6da20; typedef float t49;
#line 9 "List.m3"
IMPORT INITLINK* Thread__init; IMPORT INITLINK* Text__init; IMPORT INITLINK* Rd__init; IMPORT INITLINK* List__init;  IMPORT char VS_Thread__DefaultStackSize__0c949e2e2def4e40;
#line 9
IMPORT TYPE TC_Thread__Mutex; IMPORT char VS_Thread__Mutex__4f5c12072cdeec3e; IMPORT t25 _Thread__Fork (); IMPORT char VS_Thread__Fork__ef3a2f9230b337c8;
#line 9
IMPORT t3 _Thread__Join (); IMPORT char VS_Thread__Join__4341274725ba29c2; IMPORT EXCEPTION_NAME _Thread__Alerted; IMPORT char VS_Thread__Alerted__fc88feb43485af46;
#line 9
  IMPORT TYPE TC_Text__T; IMPORT char VS_Text__T__fc4b369f3ab271fd; IMPORT t12 _Text__Equal (); IMPORT char VS_Text__Equal__f19b6e6f34d36826;
#line 9
IMPORT t10 _Text__GetChar (); IMPORT char VS_Text__GetChar__0f4bd6e72493f4ff; IMPORT t16 _Text__Length (); IMPORT char VS_Text__Length__661a58173d76f41c;
#line 9
IMPORT t12 _Text__Empty (); IMPORT char VS_Text__Empty__f8aa6446353b9de8; IMPORT t28 _Text__Compare (); IMPORT char VS_Text__Compare__920fdd773789443c;
#line 9
  IMPORT EXCEPTION_NAME _Rd__EndOfFile; IMPORT char VS_Rd__EndOfFile__f4a9d2f63b7e105d; IMPORT EXCEPTION_NAME _Rd__Failure;
#line 9
IMPORT char VS_Rd__Failure__e4a829e331222b6d; IMPORT EXCEPTION_NAME _Rd__Error; IMPORT char VS_Rd__Error__5ca07bfe2ba90cfc;
#line 9
  EXPORT t15 _List__New (); EXPORT char VS_List__New__b392c8c8308ae968 = '\0'; EXPORT t15 _List__List1 (); EXPORT char VS_List__List1__b43210672d61aa51 = '\0';
#line 9
EXPORT t15 _List__List2 (); EXPORT char VS_List__List2__88dbdaa322c8e005 = '\0'; EXPORT t15 _List__List3 (); EXPORT char VS_List__List3__f7a1ce313e27ea70 = '\0';
#line 9
EXPORT t15 _List__List4 (); EXPORT char VS_List__List4__b51105113dd5ad99 = '\0'; EXPORT t15 _List__List5 (); EXPORT char VS_List__List5__8c4755db26f6c7e7 = '\0';
#line 9
EXPORT t15 _List__List6 (); EXPORT char VS_List__List6__272a57ae32e0861a = '\0'; EXPORT t15 _List__List7 (); EXPORT char VS_List__List7__8b53f1472bed7643 = '\0';
#line 9
EXPORT t15 _List__List8 (); EXPORT char VS_List__List8__b8baca202098ebd0 = '\0'; EXPORT t15 _List__List9 (); EXPORT char VS_List__List9__abcb231c270e5a52 = '\0';
#line 9
EXPORT t45 _List__Push (); EXPORT char VS_List__Push__699e02922bc37610 = '\0'; EXPORT t3 _List__Pop (); EXPORT char VS_List__Pop__274953c03301d76b = '\0';
#line 9
EXPORT t16 _List__Length (); EXPORT char VS_List__Length__b19324682acef0c9 = '\0'; EXPORT t15 _List__Tail (); EXPORT char VS_List__Tail__0e3232ac20dce80e = '\0';
#line 9
EXPORT t3 _List__First (); EXPORT char VS_List__First__9882edb930d3ab3d = '\0'; EXPORT t3 _List__Second (); EXPORT char VS_List__Second__b0447ebd3f11dcb7 = '\0';
#line 9
EXPORT t3 _List__Third (); EXPORT char VS_List__Third__8f4e931236ba90a4 = '\0'; EXPORT t3 _List__Fourth (); EXPORT char VS_List__Fourth__ea11a97a3dfe5415 = '\0';
#line 9
EXPORT t3 _List__Fifth (); EXPORT char VS_List__Fifth__9c6e1597248e73fb = '\0'; EXPORT t3 _List__Sixth (); EXPORT char VS_List__Sixth__694af67f32a73a3e = '\0';
#line 9
EXPORT t3 _List__Nth (); EXPORT char VS_List__Nth__6b0dc52336cc1c34 = '\0'; EXPORT t45 _List__SetNth (); EXPORT char VS_List__SetNth__41be0c1734f315fe = '\0';
#line 9
EXPORT t15 _List__NthTail (); EXPORT char VS_List__NthTail__0754cd4d3fb9fa8f = '\0'; EXPORT t45 _List__SetNthTail (); EXPORT char VS_List__SetNthTail__bb24006b3b9b95c6 = '\0';
#line 9
EXPORT t3 _List__Last (); EXPORT char VS_List__Last__d477ebbe27c51c74 = '\0'; EXPORT t15 _List__LastTail (); EXPORT char VS_List__LastTail__b8d2597736d549c0 = '\0';
#line 9
EXPORT t15 _List__FirstN (); EXPORT char VS_List__FirstN__08c6b4b93cccee5a = '\0'; EXPORT t12 _List__Equal (); EXPORT char VS_List__Equal__bd377d8229b0d3e1 = '\0';
#line 9
EXPORT t12 _List__EqualQ (); EXPORT char VS_List__EqualQ__eb339ac822d81873 = '\0'; EXPORT t28 _List__Compare (); EXPORT char VS_List__Compare__c321d6ce375f3f11 = '\0';
#line 9
EXPORT t28 _List__CompareQ (); EXPORT char VS_List__CompareQ__5bd01a232382dff3 = '\0'; EXPORT t12 _List__Member (); EXPORT char VS_List__Member__7f5614663119e994 = '\0';
#line 9
EXPORT t12 _List__MemberQ (); EXPORT char VS_List__MemberQ__a2f7904b306e52b9 = '\0'; EXPORT t15 _List__Assoc (); EXPORT char VS_List__Assoc__80751ef539f94e00 = '\0';
#line 9
EXPORT t15 _List__AssocQ (); EXPORT char VS_List__AssocQ__634654ad217647ee = '\0'; EXPORT t15 _List__Append (); EXPORT char VS_List__Append__7300369b29a14ea3 = '\0';
#line 9
EXPORT t15 _List__AppendD (); EXPORT char VS_List__AppendD__943f90283aa07fdb = '\0'; EXPORT t15 _List__Append1 (); EXPORT char VS_List__Append1__75ea15fc21c8b0d9 = '\0';
#line 9
EXPORT t15 _List__Append1D (); EXPORT char VS_List__Append1D__f0a143b02768dfc8 = '\0'; EXPORT t15 _List__Copy (); EXPORT char VS_List__Copy__5a39e47e38bfa1e8 = '\0';
#line 9
EXPORT t15 _List__CopyRecursively (); EXPORT char VS_List__CopyRecursively__f888568f32994d8b = '\0'; EXPORT t15 _List__Reverse ();
#line 9
EXPORT char VS_List__Reverse__6fd9e83d3516d760 = '\0'; EXPORT t15 _List__ReverseD (); EXPORT char VS_List__ReverseD__e857a6402caec3ac = '\0';
#line 9
EXPORT t15 _List__Sort (); EXPORT char VS_List__Sort__5325ae4720a05a49 = '\0'; EXPORT t15 _List__SortD (); EXPORT char VS_List__SortD__e2d5a0eb3ea63d9f = '\0';
#line 9
EXPORT t15 _List__FromVector (); EXPORT char VS_List__FromVector__b68481e6294ccc4d = '\0'; EXPORT t13 _List__ToVector ();
#line 9
EXPORT char VS_List__ToVector__228fff052f4f6a4e = '\0'; EXPORT t15 _List__Map (); EXPORT char VS_List__Map__4668920c27880069 = '\0';
#line 9
EXPORT t45 _List__Walk (); EXPORT char VS_List__Walk__c3d577383c12d621 = '\0'; EXPORT t2 _List__Hash (); EXPORT char VS_List__Hash__a4c3ddf42d0a2087 = '\0';
#line 9
EXPORT t2 _List__HashQ (); EXPORT char VS_List__HashQ__084e8289223c6de1 = '\0'; EXPORT t15 _List__NoDuplicates (); EXPORT char VS_List__NoDuplicates__b1847d573c883d8f = '\0';
#line 9
EXPORT t15 _List__NoDuplicatesQ (); EXPORT char VS_List__NoDuplicatesQ__0a75238433ea6ec6 = '\0'; EXPORT t15 _List__Union ();
#line 9
EXPORT char VS_List__Union__e6ac809f2e608538 = '\0'; EXPORT t15 _List__UnionQ (); EXPORT char VS_List__UnionQ__aad65f4424b059f5 = '\0';
#line 9
EXPORT t15 _List__Union1 (); EXPORT char VS_List__Union1__adb0661d2a0bd7fb = '\0'; EXPORT t15 _List__Union1Q (); EXPORT char VS_List__Union1Q__ff5a3a5d2db6df29 = '\0';
#line 9
EXPORT t15 _List__Intersection (); EXPORT char VS_List__Intersection__035897f4391d37eb = '\0'; EXPORT t15 _List__IntersectionQ ();
#line 9
EXPORT char VS_List__IntersectionQ__bc46d8f92f966533 = '\0'; EXPORT t15 _List__Difference (); EXPORT char VS_List__Difference__8f14f10f202e5259 = '\0';
#line 9
EXPORT t15 _List__DifferenceQ (); EXPORT char VS_List__DifferenceQ__14d9b5213ba6d3dc = '\0'; EXPORT t15 _List__Delete ();
#line 9
EXPORT char VS_List__Delete__5d57832b346ca967 = '\0'; EXPORT t15 _List__DeleteQ (); EXPORT char VS_List__DeleteQ__ad7d96d63075da16 = '\0';
#line 9
EXPORT t12 _List__Subset (); EXPORT char VS_List__Subset__2e25417f235a9225 = '\0'; EXPORT t12 _List__SubsetQ (); EXPORT char VS_List__SubsetQ__1571d9133541b841 = '\0';
#line 9
EXPORT t45 _List__ParWalk (); EXPORT char VS_List__ParWalk__eb95fba93bf0ab4b = '\0'; EXPORT t15 _List__AssocPutD (); EXPORT char VS_List__AssocPutD__5ade1383335f7139 = '\0';
#line 9
EXPORT t15 _List__AssocQPutD (); EXPORT char VS_List__AssocQPutD__334ae9622a7982c2 = '\0'; PRIVATE TYPE TC_List__ParWalkBlock;
#line 9
PRIVATE t3 _List__ForkedParWalk ();     
#line 15 "List.m3"
 EXPORT t15 _List__New (_first, _tail) t3 _first; t15 _tail; { t15 z0; t15 z2;
#line 15 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _new; auto t15 __result; {

         ZERO1  (& _new);
#line 15
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         { register t43* ptr = (t43*) TNEW (TC15); z0 = (t15) ptr; }; _new = z0;
         NILCHECKA (z2 = _new); ((*((t43*) z2))._first) = _first;
         NILCHECKA (z2 = _new); ((*((t43*) z2))._tail) = _tail;
         __result = _new; 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 22
 }; };
#line 25 "List.m3"
 EXPORT t45 _List__Push (_l, _x) t15 * _l; t3 _x; { t15 z3;
#line 25 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { { CHECKSTACKOVERFLOW;

         z3 = _List__New (_x, (*_l)); (*_l) = z3; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 27
 }; };
#line 31 "List.m3"
 EXPORT t3 _List__Pop (_l) t15 * _l; { t15 z1;
#line 31 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 _x; auto t3 __result; {

         ZERO1  (& _x);
#line 31
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         NILCHECKA (z1 = (*_l)); _x = ((*((t43*) z1))._first);
         NILCHECKA (z1 = (*_l)); (*_l) = ((*((t43*) z1))._tail);
         __result = _x; 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 37
 }; };
#line 41 "List.m3"
 EXPORT t16 _List__Length (_l) t15 _l; { t12 z2; t2 z3; t2 z0; t15 z1;
#line 41 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t16 _i; auto t15 _rest; auto t16 __result; {

         ZERO1  (& _i);
         ZERO1  (& _rest);
#line 41
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         _i =  0 ;
         _rest = _l;
         z2 = (_rest != 0); if (z2) do { z3 = _i +  1 ;
            z0 = z3; if (z0 < 0) RANGEFAULT; _i = z0;
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __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 52
 }; };
#line 55 "List.m3"
 EXPORT t3 _List__First (_l) t15 _l; { t15 z1;
#line 55 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); __result = ((*((t43*) z1))._first); CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0:
#line 57
 CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 60 "List.m3"
 EXPORT t3 _List__Second (_l) t15 _l; { t15 z1; t15 z3;
#line 60 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); NILCHECKA (z3 = ((*((t43*) z1))._tail)); __result = ((*((t43*) z3))._first); CUT_TO_NEXT_HANDLER (hproc_0);
#line 62
         return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 62
 }; };
#line 65 "List.m3"
 EXPORT t3 _List__Third (_l) t15 _l; { t15 z1; t15 z3; t15 z2;
#line 65 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); NILCHECKA (z3 = ((*((t43*) z1))._tail)); NILCHECKA (z2 = ((*((t43*) z3))._tail)); __result = ((*((t43*) z2))._first);
#line 67
         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 67
 }; };
#line 70 "List.m3"
 EXPORT t3 _List__Fourth (_l) t15 _l; { t15 z1; t15 z3; t15 z2;
#line 70 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); NILCHECKA (z3 = ((*((t43*) z1))._tail)); NILCHECKA (z2 = ((*((t43*) z3))._tail)); NILCHECKA (z3 = ((*((t43*) z2))._tail));
#line 72
         __result = ((*((t43*) z3))._first); CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 72
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 75 "List.m3"
 EXPORT t3 _List__Fifth (_l) t15 _l; { t15 z1; t15 z3; t15 z2;
#line 75 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); NILCHECKA (z3 = ((*((t43*) z1))._tail)); NILCHECKA (z2 = ((*((t43*) z3))._tail)); NILCHECKA (z3 = ((*((t43*) z2))._tail));
#line 77
         NILCHECKA (z2 = ((*((t43*) z3))._tail)); __result = ((*((t43*) z2))._first); CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 77
         } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 80 "List.m3"
 EXPORT t3 _List__Sixth (_l) t15 _l; { t15 z1; t15 z3; t15 z2;
#line 80 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); NILCHECKA (z3 = ((*((t43*) z1))._tail)); NILCHECKA (z2 = ((*((t43*) z3))._tail)); NILCHECKA (z3 = ((*((t43*) z2))._tail));
#line 82
         NILCHECKA (z2 = ((*((t43*) z3))._tail)); NILCHECKA (z3 = ((*((t43*) z2))._tail)); __result = ((*((t43*) z3))._first);
#line 82
         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 82
 }; };
#line 86 "List.m3"
 EXPORT t15 _List__Tail (_l) t15 _l; { t15 z1;
#line 86 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _l); __result = ((*((t43*) z1))._tail); CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0:
#line 88
 CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 92 "List.m3"
 EXPORT t15 _List__NthTail (_l, _n) t15 _l; t2 _n; { t12 z2; t15 z1; t2 z3;
#line 92 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t2 _i; auto t15 _rest; auto t15 __result; {


         ZERO1  (& _rest);
#line 92
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         _rest = _l;
         _i =  0 ;
         z2 = (_i < _n); if (z2) do { NILCHECKA (z1 = _rest);
            _rest = ((*((t43*) z1))._tail);
            z3 = _i +  1 ; _i = z3; z2 = (_i < _n); } while (z2);

         __result = _rest; 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 103
 }; };
#line 107 "List.m3"
 EXPORT t45 _List__SetNthTail (_l, _n, _x) t15 _l; t16 _n; t15 _x; { t12 z2; t2 z3; t2 z0; t15 z1; t15 z4;
#line 107 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { { CHECKSTACKOVERFLOW;

         z2 = (_n >  1 ); if (z2) do { z3 = _n -  1 ;
            z0 = z3; if (z0 < 0) RANGEFAULT; _n = z0;
            NILCHECKA (z1 = _l); _l = ((*((t43*) z1))._tail); z2 = (_n >  1 ); } while (z2);

         NILCHECKA (z4 = _l); ((*((t43*) z4))._tail) = _x; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 113
 }; };
#line 117 "List.m3"
 EXPORT t3 _List__Nth (_l, _n) t15 _l; t2 _n; { t12 z2; t15 z1; t2 z3;
#line 117 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t2 _i; auto t15 _rest; auto t3 __result; {


         ZERO1  (& _rest);
#line 117
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         _i =  0 ;
         _rest = _l;
         z2 = (_i < _n); if (z2) do { NILCHECKA (z1 = _rest);
            _rest = ((*((t43*) z1))._tail);
            z3 = _i +  1 ; _i = z3; z2 = (_i < _n); } while (z2);

         NILCHECKA (z1 = _rest); __result = ((*((t43*) z1))._first); CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0:
#line 128
 CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 132 "List.m3"
 EXPORT t45 _List__SetNth (_l, _n, _x) t15 _l; t16 _n; t3 _x; { t12 z2; t2 z3; t2 z0; t15 z1; t15 z4;
#line 132 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { { CHECKSTACKOVERFLOW;

         z2 = (_n >  0 ); if (z2) do { z3 = _n -  1 ;
            z0 = z3; if (z0 < 0) RANGEFAULT; _n = z0;
            NILCHECKA (z1 = _l); _l = ((*((t43*) z1))._tail); z2 = (_n >  0 ); } while (z2);

         NILCHECKA (z4 = _l); ((*((t43*) z4))._first) = _x; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 138
 }; };
#line 142 "List.m3"
 EXPORT t3 _List__Last (_l) t15 _l; { t15 z1; t12 z4;
#line 142 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t3 __result; {

         ZERO1  (& _rest);
#line 142
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _rest = _l;
         NILCHECKA (z1 = _rest); z4 = (((*((t43*) z1))._tail) != 0); if (z4) do { NILCHECKA (z1 = _rest);
            _rest = ((*((t43*) z1))._tail); NILCHECKA (z1 = _rest); z4 = (((*((t43*) z1))._tail) != 0); } while (z4);

         NILCHECKA (z1 = _rest); __result = ((*((t43*) z1))._first); CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0:
#line 150
 CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 154 "List.m3"
 EXPORT t15 _List__LastTail (_l) t15 _l; { t15 z1; t12 z4;
#line 154 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t15 __result; {

         ZERO1  (& _rest);
#line 154
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _rest = _l;
         NILCHECKA (z1 = _rest); z4 = (((*((t43*) z1))._tail) != 0); if (z4) do { NILCHECKA (z1 = _rest);
            _rest = ((*((t43*) z1))._tail); NILCHECKA (z1 = _rest); z4 = (((*((t43*) z1))._tail) != 0); } while (z4);

         __result = _rest; 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 162
 }; };
#line 166 "List.m3"
 EXPORT t15 _List__FirstN (_l, _n) t15 _l; t2 _n; { t12 z2; t15 z0; t15 z1; t15 z4; t15 z3; t2 z5;
#line 166 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t2 _i; auto t15 _result; auto t15 _resultEnd; auto t15 _rest;
#line 166
      auto t15 __result; {


         ZERO1  (& _result); ZERO1  (& _resultEnd); ZERO1  (& _rest);
#line 166
         ZERO1  (& __result); CHECKSTACKOVERFLOW;





         z2 = (_n <=  0 ); if (z2) { __result = 0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };

         { register t43* ptr = (t43*) TNEW (TC15); z0 = (t15) ptr; }; _resultEnd = z0;
         NILCHECKA (z1 = _l); NILCHECKA (z4 = _resultEnd); ((*((t43*) z4))._first) = ((*((t43*) z1))._first);
         _result = _resultEnd;
         NILCHECKA (z1 = _l); _rest = ((*((t43*) z1))._tail);
         _i =  2 ;
         loop_0:; z2 = (_i > _n);
            if (z2) { goto loop_exit_0; };
            { register t43* ptr = (t43*) TNEW (TC15); z0 = (t15) ptr; }; NILCHECKA (z3 = _resultEnd); ((*((t43*) z3))._tail) = z0;
            NILCHECKA (z1 = _resultEnd); _resultEnd = ((*((t43*) z1))._tail);
            NILCHECKA (z1 = _rest); NILCHECKA (z4 = _resultEnd); ((*((t43*) z4))._first) = ((*((t43*) z1))._first);
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail);
            z5 = _i +  1 ; _i = z5; goto loop_0; loop_exit_0: /**/;

         __result = _result; 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 187
 }; };
#line 191 "List.m3"
 EXPORT t12 _List__Equal (_x1, _x2) t3 _x1; t3 _x2; { t12 z2; t2 z1; t2 z3; t12 z0; t8 z4; t7 z5; t6 z6; t15 z7; t15 z8; t12 z9;
t13 z10; t16 z11; t16 z12; t2 z13; t2 z14; t11 z15; t11 z16; t9 z17; t9 z18; t8 z19; t6 z20; t5 z21;
#line 191 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _list2; auto t15 _rest1; auto t15 _rest2; auto t13 _vector2;
#line 191
      auto t11 _boolean2; auto t8 _integer2; auto t9 _char2; auto t6 _longReal2; auto t5 _text2; auto t12 __result; {

         ZERO1  (& _list2);
         ZERO1  (& _rest1); ZERO1  (& _rest2);
         ZERO1  (& _vector2);
         ZERO1  (& _boolean2);
         ZERO1  (& _integer2);
         ZERO1  (& _char2);
         ZERO1  (& _longReal2);
         ZERO1  (& _text2);
#line 191
         ZERO1B (& __result); CHECKSTACKOVERFLOW;
#line 202
         z2 = (_x1 == _x2); if (z2) {
            __result =  1 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         z1 = TYPECODE (_x1); z3 = TYPECODE (_x2); z0 = (z1 != z3); if (z0) {
            z2 = (_x1 == 0); if (z2) {
               { register ADDRESS ref = (ADDRESS) _x2; register int tc = TYPECODE (ref); if (ISSUBTYPE (tc, TC5)) goto tc0_0;
#line 206
                  goto tc0_else; tc0_0:; { auto t5 _text2; { ZERO1  (& _text2); _text2 = (t5) ref;
                           z2 = _Text__Empty (_text2); __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } }
#line 207
 tc0_else:; __result =  0 ;

                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; tc0_exit:; }; };


            z2 = (_x2 == 0); if (z2) {
               { register ADDRESS ref = (ADDRESS) _x1; register int tc = TYPECODE (ref); if (ISSUBTYPE (tc, TC5)) goto tc1_0;
#line 213
                  goto tc1_else; tc1_0:; { auto t5 _text1; { ZERO1  (& _text1); _text1 = (t5) ref;
                           z2 = _Text__Empty (_text1); __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } }
#line 214
 tc1_else:; __result =  0 ;

                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; tc1_exit:; }; };


            { register ADDRESS ref = (ADDRESS) _x1; register int tc = TYPECODE (ref); if (tc == (TC8->typecode)) goto tc2_0;
#line 219
               if (tc == (TC6->typecode)) goto tc2_1; goto tc2_else; tc2_0:; { auto t8 _integer1; {
                        ZERO1  (& _integer1);
#line 219
                        _integer1 = (t8) ref;

                        { register ADDRESS ref = (ADDRESS) _x2; register int tc = TYPECODE (ref); if (tc == (TC6->typecode)) goto tc3_0;
#line 221
                           goto tc3_else; tc3_0:; { auto t6 _longReal2; { ZERO1  (& _longReal2); _longReal2 = (t6) ref;
                                    NILCHECKB (z4 = _integer1); z5 = CVTIL ((*((t2*) z4))); NILCHECKB (z6 = _longReal2); z2 = (z5 == (*((t7*) z6)));
#line 222
                                    __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc3_else:; __result =  0 ;

                              CUT_TO_NEXT_HANDLER (hproc_0); return __result; tc3_exit:; }; } } tc2_1:; { auto t6 _longReal1;
#line 224
                     {

                        ZERO1  (& _longReal1);
#line 224
                        _longReal1 = (t6) ref;


                        { register ADDRESS ref = (ADDRESS) _x2; register int tc = TYPECODE (ref); if (tc == (TC8->typecode)) goto tc4_0;
#line 227
                           goto tc4_else; tc4_0:; { auto t8 _integer2; { ZERO1  (& _integer2); _integer2 = (t8) ref;
                                    NILCHECKB (z6 = _longReal1); NILCHECKB (z4 = _integer2); z5 = CVTIL ((*((t2*) z4))); z2 = ((*((t7*) z6)) == z5);
#line 228
                                    __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc4_else:; __result =  0 ;

                              CUT_TO_NEXT_HANDLER (hproc_0); return __result; tc4_exit:; }; } } tc2_else:; __result =  0 ;


                  CUT_TO_NEXT_HANDLER (hproc_0); return __result; tc2_exit:; }; };


         { register ADDRESS ref = (ADDRESS) _x1; register int tc = TYPECODE (ref); if (tc == (TC15->typecode)) goto tc5_0;
#line 236
            if (tc == (TC13->typecode)) goto tc5_1; if (tc == (TC11->typecode)) goto tc5_2; if (tc == (TC9->typecode)) goto tc5_3;
#line 236
            if (tc == (TC8->typecode)) goto tc5_4; if (tc == (TC6->typecode)) goto tc5_5; if (ISSUBTYPE (tc, TC5)) goto tc5_6;
#line 236
            goto tc5_else; tc5_0:; { auto t15 _list1; {
                     ZERO1  (& _list1);
#line 236
                     _list1 = (t15) ref;

                     z7 = NARROW (_x2, t15, TC15, z7); _list2 = z7;
                     _rest1 = _list1;
                     _rest2 = _list2;
                     loop_1:; z2 = (_rest1 == 0);
                        if (z2) {
                           z2 = (_rest2 == 0); if (z2) { __result =  1 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
#line 243
 __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; z2 = (_rest2 == 0); if (z2) {

                           __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };

                        NILCHECKA (z7 = _rest1); NILCHECKA (z8 = _rest2); z9 = (((*((t43*) z7))._first) == ((*((t43*) z8))._first));
#line 247
                        if (z9) { goto if_9_end; }; NILCHECKA (z7 = _rest1); NILCHECKA (z8 = _rest2); z9 = _List__Equal (((*((t43*) z7))._first), ((*((t43*) z8))._first));
#line 247
                        z0 = ! z9; if (z0) {

                           __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; if_9_end: /**/;

                        NILCHECKA (z7 = _rest1); _rest1 = ((*((t43*) z7))._tail);
                        NILCHECKA (z7 = _rest2); _rest2 = ((*((t43*) z7))._tail); goto loop_1; } } tc5_1:; { auto t13 _vector1;
#line 252
                  {

                     ZERO1  (& _vector1);
#line 252
                     _vector1 = (t13) ref;


                     z10 = NARROW (_x2, t13, TC13, z10); _vector2 = z10;
                     NILCHECKB (z10 = _vector1); z11 = (*((t14*) z10)).size[0]; NILCHECKB (z10 = _vector2); z12 = (*((t14*) z10)).size[0];
#line 256
                     z0 = (z11 != z12); if (z0) { __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
                     { int from, to, index; from =  0 ; NILCHECKB (z10 = _vector1); z1 = (*((t14*) z10)).size[0] - 1; to = z1;
#line 257
                        { auto t2 _i; { for (index = from; index <= to; index += 1) { _i = (t2) index;
                                 NILCHECKB (z10 = _vector1); { register t42* array = & (*((t14*) z10)); z13 = _i; if (z13 >= (array->size[0])) RANGEFAULT;
#line 258
                                    z3 = (int)(array->elts + (z13 * 4)); }; NILCHECKB (z10 = _vector2); { register t42* array = & (*((t14*) z10));
#line 258
                                    z14 = _i; if (z14 >= (array->size[0])) RANGEFAULT; z13 = (int)(array->elts + (z14 * 4));
#line 258
 }; z2 = ((*(t3*)z3) == (*(t3*)z13)); if (z2) { goto if_11_end; }; NILCHECKB (z10 = _vector1); { register t42* array = & (*((t14*) z10));
#line 258
                                    z13 = _i; if (z13 >= (array->size[0])) RANGEFAULT; z3 = (int)(array->elts + (z13 * 4));
#line 258
 }; NILCHECKB (z10 = _vector2); { register t42* array = & (*((t14*) z10)); z14 = _i; if (z14 >= (array->size[0])) RANGEFAULT;
#line 258
                                    z13 = (int)(array->elts + (z14 * 4)); }; z9 = _List__Equal ((*(t3*)z3), (*(t3*)z13));
#line 258
                                 z0 = ! z9; if (z0) {

                                    __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; if_11_end: /**/; }
#line 260
                              } }; };


                     __result =  1 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc5_2:; { auto t11 _boolean1; {
                     ZERO1  (& _boolean1);
#line 263
                     _boolean1 = (t11) ref;

                     z15 = NARROW (_x2, t11, TC11, z15); _boolean2 = z15;
                     NILCHECKB (z15 = _boolean1); NILCHECKB (z16 = _boolean2); z2 = ((*((t12*) z15)) == (*((t12*) z16)));
#line 266
                     __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc5_3:; { auto t9 _char1; {
                     ZERO1  (& _char1);
#line 266
                     _char1 = (t9) ref;

                     z17 = NARROW (_x2, t9, TC9, z17); _char2 = z17;
                     NILCHECKB (z17 = _char1); NILCHECKB (z18 = _char2); z2 = ((*((t10*) z17)) == (*((t10*) z18))); __result = z2;
#line 269
                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc5_4:; { auto t8 _integer1; {
                     ZERO1  (& _integer1);
#line 269
                     _integer1 = (t8) ref;

                     z4 = NARROW (_x2, t8, TC8, z4); _integer2 = z4;
                     NILCHECKB (z4 = _integer1); NILCHECKB (z19 = _integer2); z2 = ((*((t2*) z4)) == (*((t2*) z19))); __result = z2;
#line 272
                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc5_5:; { auto t6 _longReal1; {
                     ZERO1  (& _longReal1);
#line 272
                     _longReal1 = (t6) ref;

                     z6 = NARROW (_x2, t6, TC6, z6); _longReal2 = z6;
                     NILCHECKB (z6 = _longReal1); NILCHECKB (z20 = _longReal2); z2 = ((*((t7*) z6)) == (*((t7*) z20))); __result = z2;
#line 275
                     CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } tc5_6:; { auto t5 _text1; {
                     ZERO1  (& _text1);
#line 275
                     _text1 = (t5) ref;

                     z21 = NARROW (_x2, t5, TC5, z21); _text2 = z21;
                     z9 = _Text__Equal (_text1, _text2); __result = z9; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }
#line 278
                  } tc5_else:; __result =  0 ;

               CUT_TO_NEXT_HANDLER (hproc_0); return __result; tc5_exit:; }; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 280
 }; };
#line 285 "List.m3"
 EXPORT t12 _List__EqualQ (_x1, _x2) t3 _x1; t3 _x2; { t12 z2;
#line 285 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t12 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;

         z2 = (_x1 == _x2); __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 287
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 291 "List.m3"
 EXPORT t28 _List__Compare (_arg, _x1, _x2) t3 _arg; t3 _x1; t3 _x2; { t12 z2; t2 z1; t2 z3; t12 z0; t28 z4; t8 z5; t7 z6;
t6 z7; t15 z8; t15 z9; t12 z10; t28 z11; t13 z12; t16 z13; t2 z14; t2 z15; t11 z16; t11 z17; t9 z18; t9 z19; t8 z20; t6 z21;
t5 z22;
#line 291 "List.m3"
{ auto t16 _i; auto t28 _result; auto t15 _list2; auto t15 _rest1; auto t15 _rest2; auto t13 _vector2; auto t11 _boolean2;
#line 291
   auto t8 _integer2; auto t9 _char2; auto t6 _longReal2; auto t5 _text2; auto t7 _lr1; auto t7 _lr2; auto t28 __result; {

      ZERO1  (& _i);
      ZERO1B (& _result);
      ZERO1  (& _list2);
      ZERO1  (& _rest1); ZERO1  (& _rest2);
      ZERO1  (& _vector2);
      ZERO1  (& _boolean2);
      ZERO1  (& _integer2);
      ZERO1  (& _char2);
      ZERO1  (& _longReal2);
      ZERO1  (& _text2);




      ZERO2  (& _lr1); ZERO2  (& _lr2);
#line 291
      ZERO1B (& __result); CHECKSTACKOVERFLOW;
#line 309
      z2 = (_x1 == _x2); if (z2) { __result =  0 ; return __result; };
      z1 = TYPECODE (_x1); z3 = TYPECODE (_x2); z0 = (z1 != z3); if (z0) {
         z2 = (_x1 == 0); if (z2) {
            { register ADDRESS ref = (ADDRESS) _x2; register int tc = TYPECODE (ref); if (ISSUBTYPE (tc, TC5)) goto tc6_0;
#line 312
               goto tc6_else; tc6_0:; { auto t5 _text2; { ZERO1  (& _text2); _text2 = (t5) ref;
                        z4 = _Text__Compare (0, _text2); __result = z4; return __result; } } tc6_else:; z1 = -  1 ;

                  z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; tc6_exit:; }; };


         z2 = (_x2 == 0); if (z2) {
            { register ADDRESS ref = (ADDRESS) _x1; register int tc = TYPECODE (ref); if (ISSUBTYPE (tc, TC5)) goto tc7_0;
#line 319
               goto tc7_else; tc7_0:; { auto t5 _text1; { ZERO1  (& _text1); _text1 = (t5) ref;
                        z4 = _Text__Compare (_text1, 0); __result = z4; return __result; } } tc7_else:; __result =  1 ;

                  return __result; tc7_exit:; }; };


         { register ADDRESS ref = (ADDRESS) _x1; register int tc = TYPECODE (ref); if (tc == (TC8->typecode)) goto tc8_0;
#line 325
            if (tc == (TC6->typecode)) goto tc8_1; goto tc8_else; tc8_0:; { auto t8 _integer1; {
                     ZERO1  (& _integer1);
#line 325
                     _integer1 = (t8) ref;

                     { register ADDRESS ref = (ADDRESS) _x2; register int tc = TYPECODE (ref); if (tc == (TC6->typecode)) goto tc9_0;
#line 327
                        goto tc9_else; tc9_0:; { auto t6 _longReal2; { ZERO1  (& _longReal2); _longReal2 = (t6) ref;
                                 NILCHECKB (z5 = _integer1); z6 = CVTIL ((*((t2*) z5))); _lr1 = z6;
                                 NILCHECKB (z7 = _longReal2); z2 = (_lr1 < (*((t7*) z7))); if (z2) { z1 = -  1 ; z3 = z1;
#line 329
                                    if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z7 = _longReal2);
#line 329
                                 z2 = (_lr1 == (*((t7*) z7))); if (z2) {
                                    __result =  0 ; return __result; }; z1 =  1 ;
                                    if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } tc9_else:;
#line 331


                           z1 =  1 ; if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; tc9_exit:; };
#line 333
                     } } tc8_1:; { auto t6 _longReal1; {

                     ZERO1  (& _longReal1);
#line 333
                     _longReal1 = (t6) ref;


                     { register ADDRESS ref = (ADDRESS) _x2; register int tc = TYPECODE (ref); if (tc == (TC8->typecode)) goto tc10_0;
#line 336
                        goto tc10_else; tc10_0:; { auto t8 _integer2; { ZERO1  (& _integer2); _integer2 = (t8) ref;
                                 NILCHECKB (z5 = _integer2); z6 = CVTIL ((*((t2*) z5))); _lr2 = z6;
                                 NILCHECKB (z7 = _longReal1); z2 = ((*((t7*) z7)) < _lr2); if (z2) { z1 = -  1 ; z3 = z1;
#line 338
                                    if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z7 = _longReal1);
#line 338
                                 z2 = ((*((t7*) z7)) == _lr2); if (z2) {
                                    __result =  0 ; return __result; }; z1 =  1 ;
                                    if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } tc10_else:;
#line 340


                           z1 =  1 ; if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; tc10_exit:; };
#line 342
                     } } tc8_else:; z1 =  1 ;


               if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; tc8_exit:; }; };


      { register ADDRESS ref = (ADDRESS) _x1; register int tc = TYPECODE (ref); if (tc == (TC15->typecode)) goto tc11_0; if (tc == (TC13->typecode)) goto tc11_1;
#line 348
         if (tc == (TC11->typecode)) goto tc11_2; if (tc == (TC9->typecode)) goto tc11_3; if (tc == (TC8->typecode)) goto tc11_4;
#line 348
         if (tc == (TC6->typecode)) goto tc11_5; if (ISSUBTYPE (tc, TC5)) goto tc11_6; goto tc11_else; tc11_0:; { auto t15 _list1;
#line 348
               {
                  ZERO1  (& _list1);
#line 348
                  _list1 = (t15) ref;

                  z8 = NARROW (_x2, t15, TC15, z8); _list2 = z8;
                  _rest1 = _list1;
                  _rest2 = _list2;
                  loop_2:; z2 = (_rest1 == 0);
                     if (z2) {
                        z2 = (_rest2 == 0); if (z2) { __result =  0 ; return __result; }; z1 = -  1 ; z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT;
#line 355
                           __result = z3; return __result; }; z2 = (_rest2 == 0); if (z2) {

                        z1 =  1 ; if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; };

                     NILCHECKA (z8 = _rest1); NILCHECKA (z9 = _rest2); z10 = (((*((t43*) z8))._first) == ((*((t43*) z9))._first));
#line 359
                     if (z10) { goto if_20_end; }; NILCHECKA (z8 = _rest1);

                        NILCHECKA (z9 = _rest2); z11 = _List__Compare (_arg, ((*((t43*) z8))._first), ((*((t43*) z9))._first));
#line 361
                        _result = z11;
                        z2 = (_result !=  0 ); if (z2) { __result = _result; return __result; }; if_20_end: /**/;

                     NILCHECKA (z8 = _rest1); _rest1 = ((*((t43*) z8))._tail);
                     NILCHECKA (z8 = _rest2); _rest2 = ((*((t43*) z8))._tail); goto loop_2; } } tc11_1:; { auto t13 _vector1;
#line 365
               {

                  ZERO1  (& _vector1);
#line 365
                  _vector1 = (t13) ref;


                  z12 = NARROW (_x2, t13, TC13, z12); _vector2 = z12;
                  _i =  0 ;
                  loop_3:; NILCHECKB (z12 = _vector1);
                     z13 = (*((t14*) z12)).size[0]; z2 = (_i >= z13); if (z2) {
                        NILCHECKB (z12 = _vector2); z13 = (*((t14*) z12)).size[0]; z2 = (_i >= z13); if (z2) {
                           __result =  0 ; return __result; }; z1 = -  1 ;

                           z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z12 = _vector2);
#line 375
                     z13 = (*((t14*) z12)).size[0]; z2 = (_i >= z13); if (z2) {


                        z1 =  1 ; if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; };

                     NILCHECKB (z12 = _vector1); { register t42* array = & (*((t14*) z12)); z13 = _i; if (z13 >= (array->size[0])) RANGEFAULT;
#line 380
                        z3 = (int)(array->elts + (z13 * 4)); }; NILCHECKB (z12 = _vector2); { register t42* array = & (*((t14*) z12));
#line 380
                        z13 = _i; if (z13 >= (array->size[0])) RANGEFAULT; z14 = (int)(array->elts + (z13 * 4)); }; z2 = ((*(t3*)z3) == (*(t3*)z14));
#line 380
                     if (z2) { goto if_24_end; }; NILCHECKB (z12 = _vector1);

                        { register t42* array = & (*((t14*) z12)); z13 = _i; if (z13 >= (array->size[0])) RANGEFAULT; z14 = (int)(array->elts + (z13 * 4));
#line 382
 }; NILCHECKB (z12 = _vector2); { register t42* array = & (*((t14*) z12)); z13 = _i; if (z13 >= (array->size[0])) RANGEFAULT;
#line 382
                           z15 = (int)(array->elts + (z13 * 4)); }; z4 = _List__Compare (_arg, (*(t3*)z14), (*(t3*)z15));
#line 382
                        _result = z4;
                        z2 = (_result !=  0 ); if (z2) { __result = _result; return __result; }; if_24_end: /**/;

                     z3 = _i +  1 ; z1 = z3; if (z1 < 0) RANGEFAULT; _i = z1; goto loop_3; } } tc11_2:; { auto t11 _boolean1;
#line 385
               {

                  ZERO1  (& _boolean1);
#line 385
                  _boolean1 = (t11) ref;


                  z16 = NARROW (_x2, t11, TC11, z16); _boolean2 = z16;
                  NILCHECKB (z16 = _boolean1); NILCHECKB (z17 = _boolean2); z2 = ((*((t12*) z16)) < (*((t12*) z17))); if (z2) {
#line 389
                     z1 = -  1 ; z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z16 = _boolean1);
#line 389
                  NILCHECKB (z17 = _boolean2); z2 = ((*((t12*) z16)) == (*((t12*) z17))); if (z2) {
                     __result =  0 ; return __result; }; z1 =  1 ;
                     if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } tc11_3:; { auto t9 _char1;
#line 391
               {
                  ZERO1  (& _char1);
#line 391
                  _char1 = (t9) ref;

                  z18 = NARROW (_x2, t9, TC9, z18); _char2 = z18;
                  NILCHECKB (z18 = _char1); NILCHECKB (z19 = _char2); z2 = ((*((t10*) z18)) < (*((t10*) z19))); if (z2) {
#line 394
                     z1 = -  1 ; z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z18 = _char1);
#line 394
                  NILCHECKB (z19 = _char2); z2 = ((*((t10*) z18)) == (*((t10*) z19))); if (z2) {
                     __result =  0 ; return __result; }; z1 =  1 ;
                     if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } tc11_4:; { auto t8 _integer1;
#line 396
               {
                  ZERO1  (& _integer1);
#line 396
                  _integer1 = (t8) ref;

                  z5 = NARROW (_x2, t8, TC8, z5); _integer2 = z5;
                  NILCHECKB (z5 = _integer1); NILCHECKB (z20 = _integer2); z2 = ((*((t2*) z5)) < (*((t2*) z20))); if (z2) {
#line 399
                     z1 = -  1 ; z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z5 = _integer1);
#line 399
                  NILCHECKB (z20 = _integer2); z2 = ((*((t2*) z5)) == (*((t2*) z20))); if (z2) {
                     __result =  0 ; return __result; }; z1 =  1 ;
                     if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } tc11_5:; { auto t6 _longReal1;
#line 401
               {
                  ZERO1  (& _longReal1);
#line 401
                  _longReal1 = (t6) ref;

                  z7 = NARROW (_x2, t6, TC6, z7); _longReal2 = z7;
                  NILCHECKB (z7 = _longReal1); NILCHECKB (z21 = _longReal2); z2 = ((*((t7*) z7)) < (*((t7*) z21))); if (z2) {
#line 404
                     z1 = -  1 ; z3 = z1; if ((z3 < -1) || (1 < z3)) RANGEFAULT; __result = z3; return __result; }; NILCHECKB (z7 = _longReal1);
#line 404
                  NILCHECKB (z21 = _longReal2); z2 = ((*((t7*) z7)) == (*((t7*) z21))); if (z2) {
                     __result =  0 ; return __result; }; z1 =  1 ;
                     if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } tc11_6:; { auto t5 _text1;
#line 406
               {
                  ZERO1  (& _text1);
#line 406
                  _text1 = (t5) ref;

                  z22 = NARROW (_x2, t5, TC5, z22); _text2 = z22;
                  z4 = _Text__Compare (_text1, _text2); __result = z4; return __result; } } tc11_else:; z1 =  1 ;
#line 433
            if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; tc11_exit:; }; } } };
#line 438 "List.m3"
 EXPORT t28 _List__CompareQ (_arg, _x1, _x2) t3 _arg; t3 _x1; t3 _x2; { t12 z2; t2 z1;
#line 438 "List.m3"
{ auto t28 __result; { ZERO1B (& __result); CHECKSTACKOVERFLOW;

      z2 = (_x1 == _x2); if (z2) {
         __result =  0 ; return __result; }; z1 =  1 ;

         if ((z1 < -1) || (1 < z1)) RANGEFAULT; __result = z1; return __result; } } };
#line 448 "List.m3"
 EXPORT t12 _List__Member (_l, _x) t15 _l; t3 _x; { t12 z2; t15 z3; t12 z5; t15 z1;
#line 448 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t12 __result; {

         ZERO1  (& _rest);
#line 448
         ZERO1B (& __result); CHECKSTACKOVERFLOW;



         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Equal (((*((t43*) z3))._first), _x); if (z5) { __result =  1 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 454
 };
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result =  0 ; 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 457
 }; };
#line 460 "List.m3"
 EXPORT t12 _List__MemberQ (_l, _x) t15 _l; t3 _x; { t12 z2; t15 z1; t12 z4;
#line 460 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t12 __result; {

         ZERO1  (& _rest);
#line 460
         ZERO1B (& __result); CHECKSTACKOVERFLOW;



         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z1 = _rest);
            z4 = (((*((t43*) z1))._first) == _x); if (z4) { __result =  1 ; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 466
 };
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result =  0 ; 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 469
 }; };
#line 473 "List.m3"
 EXPORT t15 _List__Assoc (_l, _x) t15 _l; t3 _x; { t12 z2; t15 z1; t15 z3; t12 z5;
#line 473 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t15 __result; {

         ZERO1  (& _rest);
#line 473
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z1 = _rest);
            { register ADDRESS ref = (ADDRESS) ((*((t43*) z1))._first); register int tc = TYPECODE (ref); if (tc == (TC15->typecode)) goto tc12_0;
#line 479
               goto tc12_else; tc12_0:; { auto t15 _pair; {
                        ZERO1  (& _pair);
#line 479
                        _pair = (t15) ref;

                        NILCHECKA (z3 = _pair); z5 = _List__Equal (((*((t43*) z3))._first), _x); if (z5) { __result = _pair;
#line 481
                           CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; } } goto tc12_exit; tc12_else:; tc12_exit:;
#line 481
 };


            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result = 0; 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 486
 }; };
#line 489 "List.m3"
 EXPORT t15 _List__AssocQ (_l, _x) t15 _l; t3 _x; { t12 z2; t15 z1; t12 z4;
#line 489 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t15 __result; {

         ZERO1  (& _rest);
#line 489
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z1 = _rest);
            { register ADDRESS ref = (ADDRESS) ((*((t43*) z1))._first); register int tc = TYPECODE (ref); if (tc == (TC15->typecode)) goto tc13_0;
#line 495
               goto tc13_else; tc13_0:; { auto t15 _pair; {
                        ZERO1  (& _pair);
#line 495
                        _pair = (t15) ref;

                        NILCHECKA (z1 = _pair); z4 = (((*((t43*) z1))._first) == _x); if (z4) { __result = _pair; CUT_TO_NEXT_HANDLER (hproc_0);
#line 497
                           return __result; }; } } goto tc13_exit; tc13_else:; tc13_exit:; };


            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result = 0; 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 502
 }; };
#line 506 "List.m3"
 EXPORT t15 _List__AssocPutD (_l, _key, _valueTail) t15 _l; t3 _key; t15 _valueTail; { t15 z3; t12 z2; t15 z4;
#line 506 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _tuple; auto t15 __result; {


         ZERO1  (& _tuple);
#line 506
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         z3 = _List__Assoc (_l, _key); _tuple = z3;
         z2 = (_tuple == 0); if (z2) {
            z4 = _List__New (_key, _valueTail); z3 = _List__New (z4, _l); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 513
 }; NILCHECKA (z3 = _tuple);

            ((*((t43*) z3))._tail) = _valueTail;
            __result = _l; 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 516
 }; };
#line 521 "List.m3"
 EXPORT t15 _List__AssocQPutD (_l, _key, _valueTail) t15 _l; t3 _key; t15 _valueTail; { t15 z3; t12 z2; t15 z4;
#line 521 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _tuple; auto t15 __result; {


         ZERO1  (& _tuple);
#line 521
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         z3 = _List__AssocQ (_l, _key); _tuple = z3;
         z2 = (_tuple == 0); if (z2) {
            z4 = _List__New (_key, _valueTail); z3 = _List__New (z4, _l); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 528
 }; NILCHECKA (z3 = _tuple);

            ((*((t43*) z3))._tail) = _valueTail;
            __result = _l; 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 531
 }; };
#line 536 "List.m3"
 EXPORT t15 _List__List9 (_x1, _x2, _x3, _x4, _x5, _x6, _x7, _x8, _x9) t3 _x1; t3 _x2; t3 _x3; t3 _x4; t3 _x5; t3 _x6; t3 _x7;
#line 536
t3 _x8; t3 _x9; { t15 z0; t15 z1; t15 z2; t15 z3; t15 z4; t15 z5; t15 z6; t15 z7; t15 z8;
#line 536 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 538
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x4;
#line 538
                     { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x5; { register t43* ptr = (t43*) TNEW (TC15);
#line 538
                           ptr->_first = _x6; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x7; { register t43* ptr = (t43*) TNEW (TC15);
#line 538
                                 ptr->_first = _x8; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x9; ptr->_tail = 0;
#line 538
                                    z8 = (t15) ptr; }; ptr->_tail = z8; z7 = (t15) ptr; }; ptr->_tail = z7; z6 = (t15) ptr;
#line 538
 }; ptr->_tail = z6; z5 = (t15) ptr; }; ptr->_tail = z5; z4 = (t15) ptr; }; ptr->_tail = z4; z3 = (t15) ptr; }; ptr->_tail = z3;
#line 538
                  z2 = (t15) ptr; }; ptr->_tail = z2; z1 = (t15) ptr; }; ptr->_tail = z1; z0 = (t15) ptr; }; __result = z0;
#line 538
         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 538
 }; };
#line 549 "List.m3"
 EXPORT t15 _List__List8 (_x1, _x2, _x3, _x4, _x5, _x6, _x7, _x8) t3 _x1; t3 _x2; t3 _x3; t3 _x4; t3 _x5; t3 _x6; t3 _x7;
#line 549
t3 _x8; { t15 z0; t15 z1; t15 z2; t15 z3; t15 z4; t15 z5; t15 z6; t15 z7;
#line 549 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 551
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x4;
#line 551
                     { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x5; { register t43* ptr = (t43*) TNEW (TC15);
#line 551
                           ptr->_first = _x6; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x7; { register t43* ptr = (t43*) TNEW (TC15);
#line 551
                                 ptr->_first = _x8; ptr->_tail = 0; z7 = (t15) ptr; }; ptr->_tail = z7; z6 = (t15) ptr; };
#line 551
                           ptr->_tail = z6; z5 = (t15) ptr; }; ptr->_tail = z5; z4 = (t15) ptr; }; ptr->_tail = z4; z3 = (t15) ptr;
#line 551
 }; ptr->_tail = z3; z2 = (t15) ptr; }; ptr->_tail = z2; z1 = (t15) ptr; }; ptr->_tail = z1; z0 = (t15) ptr; }; __result = z0;
#line 551
         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 551
 }; };
#line 561 "List.m3"
 EXPORT t15 _List__List7 (_x1, _x2, _x3, _x4, _x5, _x6, _x7) t3 _x1; t3 _x2; t3 _x3; t3 _x4; t3 _x5; t3 _x6; t3 _x7; { t15 z0;
t15 z1; t15 z2; t15 z3; t15 z4; t15 z5; t15 z6;
#line 561 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 563
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x4;
#line 563
                     { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x5; { register t43* ptr = (t43*) TNEW (TC15);
#line 563
                           ptr->_first = _x6; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x7; ptr->_tail = 0;
#line 563
                              z6 = (t15) ptr; }; ptr->_tail = z6; z5 = (t15) ptr; }; ptr->_tail = z5; z4 = (t15) ptr; }; ptr->_tail = z4;
#line 563
                     z3 = (t15) ptr; }; ptr->_tail = z3; z2 = (t15) ptr; }; ptr->_tail = z2; z1 = (t15) ptr; }; ptr->_tail = z1;
#line 563
            z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 563
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 572 "List.m3"
 EXPORT t15 _List__List6 (_x1, _x2, _x3, _x4, _x5, _x6) t3 _x1; t3 _x2; t3 _x3; t3 _x4; t3 _x5; t3 _x6; { t15 z0; t15 z1;
t15 z2; t15 z3; t15 z4; t15 z5;
#line 572 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 574
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x4;
#line 574
                     { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x5; { register t43* ptr = (t43*) TNEW (TC15);
#line 574
                           ptr->_first = _x6; ptr->_tail = 0; z5 = (t15) ptr; }; ptr->_tail = z5; z4 = (t15) ptr; }; ptr->_tail = z4;
#line 574
                     z3 = (t15) ptr; }; ptr->_tail = z3; z2 = (t15) ptr; }; ptr->_tail = z2; z1 = (t15) ptr; }; ptr->_tail = z1;
#line 574
            z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 574
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 582 "List.m3"
 EXPORT t15 _List__List5 (_x1, _x2, _x3, _x4, _x5) t3 _x1; t3 _x2; t3 _x3; t3 _x4; t3 _x5; { t15 z0; t15 z1; t15 z2; t15 z3;
t15 z4;
#line 582 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 584
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x4;
#line 584
                     { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x5; ptr->_tail = 0; z4 = (t15) ptr; }; ptr->_tail = z4;
#line 584
                     z3 = (t15) ptr; }; ptr->_tail = z3; z2 = (t15) ptr; }; ptr->_tail = z2; z1 = (t15) ptr; }; ptr->_tail = z1;
#line 584
            z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 584
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 591 "List.m3"
 EXPORT t15 _List__List4 (_x1, _x2, _x3, _x4) t3 _x1; t3 _x2; t3 _x3; t3 _x4; { t15 z0; t15 z1; t15 z2; t15 z3;
#line 591 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 593
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x4;
#line 593
                     ptr->_tail = 0; z3 = (t15) ptr; }; ptr->_tail = z3; z2 = (t15) ptr; }; ptr->_tail = z2; z1 = (t15) ptr;
#line 593
 }; ptr->_tail = z1; z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 593
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 599 "List.m3"
 EXPORT t15 _List__List3 (_x1, _x2, _x3) t3 _x1; t3 _x2; t3 _x3; { t15 z0; t15 z1; t15 z2;
#line 599 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 601
               { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x3; ptr->_tail = 0; z2 = (t15) ptr; }; ptr->_tail = z2;
#line 601
               z1 = (t15) ptr; }; ptr->_tail = z1; z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 601
         } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 606 "List.m3"
 EXPORT t15 _List__List2 (_x1, _x2) t3 _x1; t3 _x2; { t15 z0; t15 z1;
#line 606 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x2;
#line 608
               ptr->_tail = 0; z1 = (t15) ptr; }; ptr->_tail = z1; z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0);
#line 608
         return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 608
 }; };
#line 612 "List.m3"
 EXPORT t15 _List__List1 (_x1) t3 _x1; { t15 z0;
#line 612 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         { register t43* ptr = (t43*) TNEW (TC15); ptr->_first = _x1; ptr->_tail = 0; z0 = (t15) ptr; }; __result = z0; CUT_TO_NEXT_HANDLER (hproc_0);
#line 614
         return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception);
#line 614
 }; };
#line 618 "List.m3"
 EXPORT t15 _List__Append (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t15 z5; t15 z1;
#line 618 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _last; auto t15 _rest; auto t15 _result; auto t15 __result;
#line 618
      {

         ZERO1  (& _last); ZERO1  (& _rest); ZERO1  (& _result);
#line 618
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         z2 = (_l1 == 0); if (z2) { __result = _l2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         z2 = (_l2 == 0); if (z2) { __result = _l1; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };

         NILCHECKA (z3 = _l1); z5 = _List__New (((*((t43*) z3))._first), 0); _result = z5;
         _last = _result;
         NILCHECKA (z1 = _l1); _rest = ((*((t43*) z1))._tail);
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__New (((*((t43*) z3))._first), 0); NILCHECKA (z1 = _last); ((*((t43*) z1))._tail) = z5;
            NILCHECKA (z1 = _last); _last = ((*((t43*) z1))._tail);
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         NILCHECKA (z3 = _last); ((*((t43*) z3))._tail) = _l2;

         __result = _result; 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 635
 }; };
#line 639 "List.m3"
 EXPORT t15 _List__AppendD (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z1; t12 z4; t15 z3;
#line 639 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _last; auto t15 __result; {

         ZERO1  (& _last);
#line 639
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         z2 = (_l1 == 0); if (z2) { __result = _l2; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         z2 = (_l2 == 0); if (z2) { __result = _l1; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };

         _last = _l1;
         NILCHECKA (z1 = _last); z4 = (((*((t43*) z1))._tail) != 0); if (z4) do { NILCHECKA (z1 = _last);
            _last = ((*((t43*) z1))._tail); NILCHECKA (z1 = _last); z4 = (((*((t43*) z1))._tail) != 0); } while (z4);

         NILCHECKA (z3 = _last); ((*((t43*) z3))._tail) = _l2;

         __result = _l1; 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 652
 }; };
#line 655 "List.m3"
 EXPORT t15 _List__Append1 (_l1, _x) t15 _l1; t3 _x; { t15 z5; t15 z2;
#line 655 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         z5 = _List__New (_x, 0); z2 = _List__Append (_l1, z5); __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 657
         } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 660 "List.m3"
 EXPORT t15 _List__Append1D (_l1, _x) t15 _l1; t3 _x; { t15 z5; t15 z2;
#line 660 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         z5 = _List__New (_x, 0); z2 = _List__AppendD (_l1, z5); __result = z2; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 662
         } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 665 "List.m3"
 EXPORT t15 _List__Copy (_l) t15 _l; { t12 z2; t15 z3; t15 z5; t15 z1;
#line 665 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _last; auto t15 _rest; auto t15 _result; auto t15 __result;
#line 665
      {

         ZERO1  (& _last); ZERO1  (& _rest); ZERO1  (& _result);
#line 665
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         z2 = (_l == 0); if (z2) { __result = 0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         NILCHECKA (z3 = _l); z5 = _List__New (((*((t43*) z3))._first), 0); _result = z5;
         _last = _result;
         NILCHECKA (z1 = _l); _rest = ((*((t43*) z1))._tail);
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__New (((*((t43*) z3))._first), 0); NILCHECKA (z1 = _last); ((*((t43*) z1))._tail) = z5;
            NILCHECKA (z1 = _last); _last = ((*((t43*) z1))._tail);
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result = _result; 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 678
 }; };
#line 681 "List.m3"
 EXPORT t15 _List__CopyRecursively (_l) t15 _l; { t12 z2; t15 z1; t15 z3; t15 z4; t15 z5;
#line 681 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _last; auto t15 _rest; auto t15 _result; auto t15 __result;
#line 681
      {

         ZERO1  (& _last); ZERO1  (& _rest); ZERO1  (& _result);
#line 681
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         z2 = (_l == 0); if (z2) { __result = 0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         NILCHECKA (z1 = _l); { register ADDRESS ref = (ADDRESS) ((*((t43*) z1))._first); register int tc = TYPECODE (ref);
#line 686
            if (tc == (TC15->typecode)) goto tc14_0; goto tc14_else; tc14_0:; { auto t15 _first; {
                     ZERO1  (& _first);
#line 686
                     _first = (t15) ref;

                     z3 = _List__CopyRecursively (_first); z4 = _List__New (z3, 0); _result = z4; } } goto tc14_exit; tc14_else:;
#line 688


               NILCHECKA (z3 = _l); z5 = _List__New (((*((t43*) z3))._first), 0); _result = z5; tc14_exit:; };

         _last = _result;
         NILCHECKA (z1 = _l); _rest = ((*((t43*) z1))._tail);
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z1 = _rest);
            { register ADDRESS ref = (ADDRESS) ((*((t43*) z1))._first); register int tc = TYPECODE (ref); if (tc == (TC15->typecode)) goto tc15_0;
#line 695
               goto tc15_else; tc15_0:; { auto t15 _first; {
                        ZERO1  (& _first);
#line 695
                        _first = (t15) ref;

                        z3 = _List__CopyRecursively (_first); z4 = _List__New (z3, 0); NILCHECKA (z1 = _last); ((*((t43*) z1))._tail) = z4;
#line 697
                        } } goto tc15_exit; tc15_else:; NILCHECKA (z3 = _rest);

                  z5 = _List__New (((*((t43*) z3))._first), 0); NILCHECKA (z1 = _last); ((*((t43*) z1))._tail) = z5; tc15_exit:;
#line 699
 };

            NILCHECKA (z1 = _last); _last = ((*((t43*) z1))._tail);
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result = _result; 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 704
 }; };
#line 707 "List.m3"
 EXPORT t15 _List__Reverse (_l) t15 _l; { t12 z2; t15 z3; t15 z5; t15 z1;
#line 707 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 707
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__New (((*((t43*) z3))._first), _result); _result = z5;
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result = _result; 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 717
 }; };
#line 720 "List.m3"
 EXPORT t15 _List__ReverseD (_l) t15 _l; { t12 z2; t15 z1; t15 z3;
#line 720 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _current; auto t15 _next; auto t15 _nextTail; auto t15 __result;
#line 720
      {

         ZERO1  (& _current); ZERO1  (& _next); ZERO1  (& _nextTail);
#line 720
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         z2 = (_l == 0); if (z2) { __result = 0; CUT_TO_NEXT_HANDLER (hproc_0); return __result; };
         _current = _l;
         NILCHECKA (z1 = _l); _next = ((*((t43*) z1))._tail);
         NILCHECKA (z3 = _current); ((*((t43*) z3))._tail) = (t15) 0;
         z2 = (_next != 0); if (z2) do { NILCHECKA (z1 = _next);
            _nextTail = ((*((t43*) z1))._tail);
            NILCHECKA (z3 = _next); ((*((t43*) z3))._tail) = _current;
            _current = _next;
            _next = _nextTail; z2 = (_next != 0); } while (z2);

         __result = _current; 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 734
 }; };
#line 738 "List.m3"
 EXPORT t15 _List__Map (_l, _p, _arg) t15 _l; t24 _p; t3 _arg; { t12 z2; t15 z4; t3 z6; t15 z3; t15 z1;
#line 738 "List.m3"
{ auto t15 _rest; auto t15 _result; auto t15 __result; {

      ZERO1  (& _rest); ZERO1  (& _result);
#line 738
      ZERO1  (& __result); CHECKSTACKOVERFLOW;



      _rest = _l;
      _result = (t15) 0;
      z2 = (_rest != 0); if (z2) do { NILCHECKA (z4 = _rest);
         { t24 proc = _p; if (!IS_CLOSURE(proc)) { z6 = proc (_arg, ((*((t43*) z4))._first));  } else { z6 = ((t24) CLOSURE_PROC(proc)) (CLOSURE_FRAME(proc), _arg, ((*((t43*) z4))._first));
#line 745
 }; }; z3 = _List__New (z6, _result); _result = z3;
         NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

      z3 = _List__ReverseD (_result); __result = z3; return __result; } } };
#line 752 "List.m3"
 EXPORT t45 _List__Walk (_l, _p, _arg) t15 _l; t26 _p; t3 _arg; { t12 z2; t15 z3; t15 z1;
#line 752 "List.m3"
{ auto t15 _rest; {

      ZERO1  (& _rest);
#line 752
      CHECKSTACKOVERFLOW;



      _rest = _l;
      z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
         { t26 proc = _p; if (!IS_CLOSURE(proc)) { proc (_arg, ((*((t43*) z3))._first));  } else { ((t26) CLOSURE_PROC(proc)) (CLOSURE_FRAME(proc), _arg, ((*((t43*) z3))._first));
#line 758
 }; };
         NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2); } } };
#line 772 "List.m3"
 EXPORT t45 _List__ParWalk (_l, _p, _arg) t15 _l; t26 _p; t3 _arg; { t12 z2; t23 z0; t24 z3; t26 z4; t15 z5; t25 z6; t15 z1;
t3 z7;
#line 772 "List.m3"
{ auto t15 _rest; auto t15 _result; auto t23 _cl; auto t25 _thread; auto t3 _ignoreMe; {





      ZERO1  (& _rest);
      ZERO1  (& _result);
      ZERO1  (& _cl);
      ZERO1  (& _thread);
      ZERO1  (& _ignoreMe);
#line 772
      CHECKSTACKOVERFLOW;
#line 784
      _rest = _l;
      _result = (t15) 0;
      z2 = (_rest != 0); if (z2) do { {
            register char** ptr = (char**) TNEWOBJ (TC23); z3 = _List__ForkedParWalk; if (IS_CLOSURE (z3)) NARROWFAULT; CLONE_METHOD_SUITE (ptr, TC23);
#line 787
            ((t27_methods*)((*ptr) + (0+t35_msize)))->_apply = z3; z4 = _p; if (IS_CLOSURE (z4)) NARROWFAULT; ((t23_fields*)((char*)ptr + (0+t27_size+t35_size)))->_proc = z4;
#line 787
            ((t23_fields*)((char*)ptr + (0+t27_size+t35_size)))->_arg = _arg; NILCHECKA (z5 = _rest); ((t23_fields*)((char*)ptr + (0+t27_size+t35_size)))->_first = ((*((t43*) z5))._first);
#line 787
            z0 = (t23) ptr; }; _cl = z0;


         z6 = _Thread__Fork (_cl); z5 = _List__New (z6, _result); _result = z5;
         NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);


      _rest = _result;
      z2 = (_rest != 0); if (z2) do { NILCHECKA (z1 = _rest);
         z6 = NARROW (((*((t43*) z1))._first), t25, TC25, z6); _thread = z6;
         z7 = _Thread__Join (_thread); _ignoreMe = z7;
         NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2); } } };
#line 803 "List.m3"
 PRIVATE t3 _List__ForkedParWalk (_self) t23 _self; { t23 z1;
#line 803 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t3 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         NILCHECKA (z1 = _self); (((t23_fields*)(z1+(0+t27_size+t35_size)))->_proc) ((((t23_fields*)(z1+(0+t27_size+t35_size)))->_arg), (((t23_fields*)(z1+(0+t27_size+t35_size)))->_first));
         __result = 0; 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 806
 }; };
#line 810 "List.m3"
 EXPORT t15 _List__Union (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 810 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 810
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l1;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Member (_result, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_44_end; };
#line 818
            if_44_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         _rest = _l2;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Member (_result, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_45_end; };
#line 825
            if_45_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 829
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 832 "List.m3"
 EXPORT t15 _List__UnionQ (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 832 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 832
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l1;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__MemberQ (_result, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_46_end; };
#line 840
            if_46_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         _rest = _l2;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__MemberQ (_result, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_47_end; };
#line 847
            if_47_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 851
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 854 "List.m3"
 EXPORT t15 _List__Union1 (_l, _x) t15 _l; t3 _x; { t12 z3; t12 z0; t15 z4;
#line 854 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         z3 = _List__Member (_l, _x); z0 = ! z3; if (z0) {
            z4 = _List__New (_x, _l); __result = z4; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; __result = _l;

            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 859
 }; };
#line 863 "List.m3"
 EXPORT t15 _List__Union1Q (_l, _x) t15 _l; t3 _x; { t12 z3; t12 z0; t15 z4;
#line 863 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         z3 = _List__MemberQ (_l, _x); z0 = ! z3; if (z0) {
            z4 = _List__New (_x, _l); __result = z4; CUT_TO_NEXT_HANDLER (hproc_0); return __result; }; __result = _l;

            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 868
 }; };
#line 873 "List.m3"
 EXPORT t15 _List__Intersection (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t12 z1; t15 z4; t12 z6; t15 z7;
#line 873 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 873
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l1;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Member (_result, ((*((t43*) z3))._first)); z0 = ! z5; z1 = 0; if (z0) { NILCHECKA (z4 = _rest); z6 = _List__Member (_l2, ((*((t43*) z4))._first));
#line 880
               z1 = z6; }; if (z1) {

               NILCHECKA (z3 = _rest); z7 = _List__New (((*((t43*) z3))._first), _result); _result = z7; goto if_50_end; };
#line 882
            if_50_end: /**/;

            NILCHECKA (z3 = _rest); _rest = ((*((t43*) z3))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 886
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 889 "List.m3"
 EXPORT t15 _List__IntersectionQ (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t12 z1; t15 z4; t12 z6; t15 z7;
#line 889 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 889
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l1;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__MemberQ (_result, ((*((t43*) z3))._first)); z0 = ! z5; z1 = 0; if (z0) { NILCHECKA (z4 = _rest); z6 = _List__MemberQ (_l2, ((*((t43*) z4))._first));
#line 896
               z1 = z6; }; if (z1) {

               NILCHECKA (z3 = _rest); z7 = _List__New (((*((t43*) z3))._first), _result); _result = z7; goto if_51_end; };
#line 898
            if_51_end: /**/;

            NILCHECKA (z3 = _rest); _rest = ((*((t43*) z3))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 902
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 905 "List.m3"
 EXPORT t15 _List__Difference (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 905 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 905
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l1;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Member (_l2, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_52_end; };
#line 913
            if_52_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 917
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 920 "List.m3"
 EXPORT t15 _List__DifferenceQ (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 920 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 920
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l1;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__MemberQ (_l2, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_53_end; };
#line 928
            if_53_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 932
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 936 "List.m3"
 EXPORT t15 _List__Delete (_l, _x) t15 _l; t3 _x; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 936 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result);
         ZERO1  (& _rest);
#line 936
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         _result = (t15) 0;
         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Equal (((*((t43*) z3))._first), _x); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_54_end; };
#line 945
            if_54_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 949
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 953 "List.m3"
 EXPORT t15 _List__DeleteQ (_l, _x) t15 _l; t3 _x; { t12 z2; t15 z1; t12 z4; t15 z3; t15 z5;
#line 953 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result);
         ZERO1  (& _rest);
#line 953
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         _result = (t15) 0;
         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z1 = _rest);
            z4 = (((*((t43*) z1))._first) != _x); if (z4) {
               NILCHECKA (z3 = _rest); z5 = _List__New (((*((t43*) z3))._first), _result); _result = z5; goto if_55_end; };
#line 962
            if_55_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 966
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 970 "List.m3"
 EXPORT t12 _List__Subset (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z1;
#line 970 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t12 __result; {

         ZERO1  (& _rest);
#line 970
         ZERO1B (& __result); CHECKSTACKOVERFLOW;



         _rest = _l2;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Member (_l1, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) { __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0);
#line 976
               return __result; };
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result =  1 ; 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 979
 }; };
#line 982 "List.m3"
 EXPORT t12 _List__SubsetQ (_l1, _l2) t15 _l1; t15 _l2; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z1;
#line 982 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _rest; auto t12 __result; {

         ZERO1  (& _rest);
#line 982
         ZERO1B (& __result); CHECKSTACKOVERFLOW;



         _rest = _l2;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__MemberQ (_l1, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) { __result =  0 ; CUT_TO_NEXT_HANDLER (hproc_0);
#line 988
               return __result; };
            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         __result =  1 ; 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 991
 }; };
#line 994 "List.m3"
 EXPORT t15 _List__NoDuplicates (_l) t15 _l; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 994 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 994
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__Member (_result, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_58_end; };
#line 1002
            if_58_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 1006
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 1009 "List.m3"
 EXPORT t15 _List__NoDuplicatesQ (_l) t15 _l; { t12 z2; t15 z3; t12 z5; t12 z0; t15 z6; t15 z1;
#line 1009 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _result; auto t15 _rest; auto t15 __result; {

         ZERO1  (& _result); ZERO1  (& _rest);
#line 1009
         ZERO1  (& __result); CHECKSTACKOVERFLOW;



         _result = (t15) 0;
         _rest = _l;
         z2 = (_rest != 0); if (z2) do { NILCHECKA (z3 = _rest);
            z5 = _List__MemberQ (_result, ((*((t43*) z3))._first)); z0 = ! z5; if (z0) {
               NILCHECKA (z3 = _rest); z6 = _List__New (((*((t43*) z3))._first), _result); _result = z6; goto if_59_end; };
#line 1017
            if_59_end: /**/;

            NILCHECKA (z1 = _rest); _rest = ((*((t43*) z1))._tail); z2 = (_rest != 0); } while (z2);

         z3 = _List__ReverseD (_result); __result = z3; CUT_TO_NEXT_HANDLER (hproc_0); return __result; } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0);
#line 1021
   if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 1025 "List.m3"
 EXPORT t15 _List__Sort (_l, _c, _arg) t15 _l; t21 _c; t3 _arg; { t15 z3; t15 z4;
#line 1025 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 __result; { ZERO1  (& __result); CHECKSTACKOVERFLOW;

         z3 = _List__Copy (_l); z4 = _List__SortD (z3, _c, _arg); __result = z4; CUT_TO_NEXT_HANDLER (hproc_0); return __result;
#line 1027
         } } proc_0: CUT_TO_NEXT_HANDLER (hproc_0); if (hproc_0.exception != 0) RAISE_FOR_SURE (hproc_0.exception); }; };
#line 1031 "List.m3"
 EXPORT t15 _List__SortD (_l, _c, _arg) t15 _l; t21 _c; t3 _arg; { t12 z2; t21 z1; t15 z0; t15 z3; t15 z6; t28 z8; t2 z4;
t16 z5; t12 z7;
#line 1031 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _l1; auto t15 _l2; auto t15 _lm; auto t15 _lmHead;
#line 1031
      auto t16 _i; auto t16 _iHigh; auto t20 _a; auto t15 __result; {


         ZERO1  (& _l1); ZERO1  (& _l2); ZERO1  (& _lm); ZERO1  (& _lmHead);
         ZERO1  (& _i); ZERO1  (& _iHigh);
         ZERO  (112, & _a);
#line 1031
         ZERO1  (& __result); CHECKSTACKOVERFLOW;
#line 1042
         { char *p1 = (char*)_c; char *f1 = (ADDRESS)  0; char *p2 = (char*)0; char *f2 = (ADDRESS)  0; if (IS_CLOSURE (p1)) {
#line 1042
               f1 = (char*) CLOSURE_FRAME (p1);  p1 = (char*) CLOSURE_PROC (p1); }; z2 = ((p1 == p2) && (f1 == f2)); }; if (z2) {
#line 1042
            z1 = _List__Compare; if (IS_CLOSURE (z1)) NARROWFAULT; _c = z1; goto if_60_end; }; if_60_end: /**/;

         _iHigh =  0 ;
         { register t43* ptr = (t43*) TNEW (TC15); z0 = (t15) ptr; }; _lmHead = z0;


         loop_4:; _l1 = _l;


            z2 = (_l1 == 0); if (z2) { goto loop_exit_4; };
            NILCHECKA (z3 = _l1); _l2 = ((*((t43*) z3))._tail);
            z2 = (_l2 == 0); if (z2) { goto loop_exit_4; };
            NILCHECKA (z3 = _l2); _l = ((*((t43*) z3))._tail);
            NILCHECKA (z3 = _l1); NILCHECKA (z6 = _l2); { t21 proc = _c; if (!IS_CLOSURE(proc)) { z8 = proc (_arg, ((*((t43*) z3))._first), ((*((t43*) z6))._first));
#line 1055
  } else { z8 = ((t21) CLOSURE_PROC(proc)) (CLOSURE_FRAME(proc), _arg, ((*((t43*) z3))._first), ((*((t43*) z6))._first));
#line 1055
 }; }; z4 = -  1 ; z2 = (z8 == z4); if (z2) {
               NILCHECKA (z3 = _l1); ((*((t43*) z3))._tail) = _l2; NILCHECKA (z3 = _l2); ((*((t43*) z3))._tail) = (t15) 0;
#line 1056
               goto if_63_end; }; NILCHECKA (z3 = _l2);

               ((*((t43*) z3))._tail) = _l1; NILCHECKA (z3 = _l1); ((*((t43*) z3))._tail) = (t15) 0; _l1 = _l2; if_63_end: /**/;



            _i =  0 ;
            loop_5:; z5 = _i;
               if (z5 > 27) RANGEFAULT; _l2 = (_a.elts[z5]);
               z2 = (_l2 == 0); if (z2) {
                  z5 = _i; if (z5 > 27) RANGEFAULT; (_a.elts[z5]) = _l1;
                  goto loop_exit_5; }; z5 = _i;


                  if (z5 > 27) RANGEFAULT; (_a.elts[z5]) = (t15) 0;
                  _lm = _lmHead;
                  loop_6:; NILCHECKA (z3 = _l1);

                     NILCHECKA (z6 = _l2); { t21 proc = _c; if (!IS_CLOSURE(proc)) { z8 = proc (_arg, ((*((t43*) z3))._first), ((*((t43*) z6))._first));
#line 1074
  } else { z8 = ((t21) CLOSURE_PROC(proc)) (CLOSURE_FRAME(proc), _arg, ((*((t43*) z3))._first), ((*((t43*) z6))._first));
#line 1074
 }; }; z4 = -  1 ; z2 = (z8 == z4); if (z2) {
                        NILCHECKA (z3 = _lm); ((*((t43*) z3))._tail) = _l1; _lm = _l1; NILCHECKA (z3 = _l1); _l1 = ((*((t43*) z3))._tail);
                        z2 = (_l1 == 0); if (z2) { NILCHECKA (z3 = _lm); ((*((t43*) z3))._tail) = _l2; goto loop_exit_6; };
#line 1076
                        goto if_65_end; }; NILCHECKA (z3 = _lm);

                        ((*((t43*) z3))._tail) = _l2; _lm = _l2; NILCHECKA (z3 = _l2); _l2 = ((*((t43*) z3))._tail);
                        z2 = (_l2 == 0); if (z2) { NILCHECKA (z3 = _lm); ((*((t43*) z3))._tail) = _l1; goto loop_exit_6; };
#line 1079
 if_65_end: /**/; goto loop_6; loop_exit_6: /**/;


                  NILCHECKA (z3 = _lmHead); _l1 = ((*((t43*) z3))._tail);
                  _i +=  1 ;
                  z2 = (_i > _iHigh); if (z2) { _iHigh = _i; goto if_68_end; }; if_68_end: /**/; goto loop_5; loop_exit_5: /**/;
#line 1084
            goto loop_4; loop_exit_4: /**/;





         _i =  0 ;
         z2 = (_l1 == 0); if (z2) {
            z5 = _i; if (z5 > 27) RANGEFAULT; z7 = ((_a.elts[z5]) == 0); z2 = 0; if (z7) { z7 = (_i != _iHigh); z2 = z7; };
#line 1092
            if (z2) do { _i +=  1 ; z5 = _i; if (z5 > 27) RANGEFAULT; z7 = ((_a.elts[z5]) == 0); z2 = 0; if (z7) { z7 = (_i != _iHigh);
#line 1092
                  z2 = z7; }; } while (z2);
            z5 = _i; if (z5 > 27) RANGEFAULT; _l1 = (_a.elts[z5]);
            _i +=  1 ; goto if_69_end; }; if_69_end: /**/;



         z2 = (_i <= _iHigh); if (z2) do { z5 = _i;
            if (z5 > 27) RANGEFAULT; _l2 = (_a.elts[z5]);
            z2 = (_l2 != 0); if (z2) {
               _lm = _lmHead;
               loop_7:; NILCHECKA (z3 = _l1);
                  NILCHECKA (z6 = _l2); { t21 proc = _c; if (!IS_CLOSURE(proc)) { z8 = proc (_arg, ((*((t43*) z3))._first), ((*((t43*) z6))._first));
#line 1103
  } else { z8 = ((t21) CLOSURE_PROC(proc)) (CLOSURE_FRAME(proc), _arg, ((*((t43*) z3))._first), ((*((t43*) z6))._first));
#line 1103
 }; }; z4 = -  1 ; z2 = (z8 == z4); if (z2) {
                     NILCHECKA (z3 = _lm); ((*((t43*) z3))._tail) = _l1; _lm = _l1; NILCHECKA (z3 = _l1); _l1 = ((*((t43*) z3))._tail);
                     z2 = (_l1 == 0); if (z2) { NILCHECKA (z3 = _lm); ((*((t43*) z3))._tail) = _l2; goto loop_exit_7; }; goto if_71_end;
#line 1105
 }; NILCHECKA (z3 = _lm);

                     ((*((t43*) z3))._tail) = _l2; _lm = _l2; NILCHECKA (z3 = _l2); _l2 = ((*((t43*) z3))._tail);
                     z2 = (_l2 == 0); if (z2) { NILCHECKA (z3 = _lm); ((*((t43*) z3))._tail) = _l1; goto loop_exit_7; }; if_71_end: /**/;
#line 1108
                  goto loop_7; loop_exit_7: /**/;


               NILCHECKA (z3 = _lmHead); _l1 = ((*((t43*) z3))._tail); goto if_70_end; }; if_70_end: /**/;

            _i +=  1 ; z2 = (_i <= _iHigh); } while (z2);


         __result = _l1; 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 1116
 }; };
#line 1120 "List.m3"
 EXPORT t15 _List__FromVector (_v) t13 _v; { t16 z0; t13 z2; t12 z3; t15 z1; t2 z4; t2 z5; t15 z6;
#line 1120 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t15 _last; auto t15 _l; auto t15 __result; {

         ZERO1  (& _last);
         ZERO1  (& _l);
#line 1120
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         NILCHECKB (z2 = _v); z0 = (*((t14*) z2)).size[0]; z3 = (z0 ==  0 ); if (z3) { __result = 0; CUT_TO_NEXT_HANDLER (hproc_0);
#line 1125
            return __result; };
         { register t43* ptr = (t43*) TNEW (TC15); z1 = (t15) ptr; }; _last = z1;
         NILCHECKB (z2 = _v); { register t42* array = & (*((t14*) z2)); z5 =  0 ; if (z5 >= (array->size[0])) RANGEFAULT;
#line 1127
            z4 = (int)(array->elts + (z5 * 4)); }; NILCHECKA (z6 = _last); ((*((t43*) z6))._first) = (*(t3*)z4);
         _l = _last;
         { int from, to, index; from =  1 ; NILCHECKB (z2 = _v); z4 = (*((t14*) z2)).size[0] - 1; to = z4; { auto t2 _i; {
#line 1129
                  for (index = from; index <= to; index += 1) { _i = (t2) index;
                     { register t43* ptr = (t43*) TNEW (TC15); z1 = (t15) ptr; }; NILCHECKA (z6 = _last); ((*((t43*) z6))._tail) = z1;
                     NILCHECKA (z1 = _last); _last = ((*((t43*) z1))._tail);
                     NILCHECKB (z2 = _v); { register t42* array = & (*((t14*) z2)); z5 = _i; if (z5 >= (array->size[0])) RANGEFAULT;
#line 1132
                        z4 = (int)(array->elts + (z5 * 4)); }; NILCHECKA (z6 = _last); ((*((t43*) z6))._first) = (*(t3*)z4);
#line 1132
                     } } }; };

         __result = _l; 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 1134
 }; };
#line 1138 "List.m3"
 EXPORT t13 _List__ToVector (_l) t15 _l; { t13 z0; t16 z3; t12 z2; t15 z1; t13 z4; t2 z6; t16 z7; t2 z5;
#line 1138 "List.m3"
{ HANDLER hproc_0; PUSH_RAISES (hproc_0, raises_1, proc_0); { auto t13 _v; auto t16 _i; auto t13 __result; {

         ZERO1  (& _v);
         ZERO1  (& _i);
#line 1138
         ZERO1  (& __result); CHECKSTACKOVERFLOW;




         { register t42* ptr; int sz[1]; z3 = _List__Length (_l); sz[0] = z3; ptr = (t42*) TNEWA(TC13, 8 + sz[0] * 4); ptr->elts = (char*)(& ptr->size[1]);
#line 1143
            ptr->size[0] = sz[0]; z0 = (t13) ptr; }; _v = z0;
         _i =  0 ;
         z2 = (_l != 0); if (z2) do { NILCHECKA (z1 = _l);
            NILCHECKB (z4 = _v); { register t42* array = & (*((t14*) z4)); z7 = _i; if (z7 >= (array->size[0])) RANGEFAULT;
#line 1146
               z6 = (int)(array->elts + (z7 * 4)); }; (*(t3*)z6) = ((*((t43*) z1))._first);
            NILCHECKA (z1 = _l); _l = ((*((t43*) z1))._tail);
            z5 = _i +  1 ; z6 = z5; if (z6 < 0) RANGEFAULT; _i = z6; z2 = (_l != 0); } while (z2);

         __result = _v; 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 1150
 }; };
#line 1154 "List.m3"
 EXPORT t2 _List__Hash (_arg, _x) t3 _arg; t3 _x; { t12 z2; t2 z3; t15 z4; t2 z6; t2 z0; t15 z1; t13 z5; t2 z7; t11 z8; t9 z9;
t8 z10; t49 z11; t49 z12; t6 z13; t16 z14; t10 z15;
#line 1154 "List.m3"
{ auto t2 _result; auto t2 _i; auto t2 __result; { CHECKSTACKOVERFLOW;




      z2 = (_x == 0); if (z2) { __result =  0 ; return __result; };
      _result =  0 ;
      { register ADDRESS ref = (ADDRESS) _x; register int tc = TYPECODE (ref); if (tc == (TC15->typecode)) goto tc16_0; if (tc == (TC13->typecode)) goto tc16_1;
#line 1161
         if (tc == (TC11->typecode)) goto tc16_2; if (tc == (TC9->typecode)) goto tc16_3; if (tc == (TC8->typecode)) goto tc16_4;
#line 1161
         if (tc == (TC6->typecode)) goto tc16_5; if (ISSUBTYPE (tc, TC5)) goto tc16_6; goto tc16_else; tc16_0:; { auto t15 _list;
#line 1161
               {
                  ZERO1  (& _list);
#line 1161
                  _list = (t15) ref;

                  _i =  1 ;
                  z2 = (_list != 0); if (z2) do { z3 = _i * _result;
                     NILCHECKA (z4 = _list); z6 = _List__Hash (_arg, ((*((t43*) z4))._first)); z0 = z3 + z6; _result = z0;
                     z3 = _i +  1 ; _i = z3;
                     NILCHECKA (z1 = _list); _list = ((*((t43*) z1))._tail); z2 = (_list != 0); } while (z2); } } goto tc16_exit;
#line 1167
 tc16_1:; { auto t13 _vector; {

                  ZERO1  (& _vector);
#line 1167
                  _vector = (t13) ref;


                  { int from, to, index; from =  0 ; NILCHECKB (z5 = _vector); z0 = (*((t14*) z5)).size[0] - 1; to = z0; {
#line 1170
                        auto t2 _i; { for (index = from; index <= to; index += 1) { _i = (t2) index;
                              z3 = _i * _result; NILCHECKB (z5 = _vector); { register t42* array = & (*((t14*) z5)); z7 = _i;
#line 1171
                                 if (z7 >= (array->size[0])) RANGEFAULT; z6 = (int)(array->elts + (z7 * 4)); }; z7 = _List__Hash (_arg, (*(t3*)z6));
#line 1171
                              z0 = z3 + z7; _result = z0; } } }; }; } } goto tc16_exit; tc16_2:; { auto t11 _boolean; {

                  ZERO1  (& _boolean);
#line 1171
                  _boolean = (t11) ref;


                  NILCHECKB (z8 = _boolean); _result = (*((t12*) z8)); } } goto tc16_exit; tc16_3:; { auto t9 _char; {
                  ZERO1  (& _char);
#line 1174
                  _char = (t9) ref;

                  NILCHECKB (z9 = _char); _result = (*((t10*) z9)); } } goto tc16_exit; tc16_4:; { auto t8 _integer; {
                  ZERO1  (& _integer);
#line 1176
                  _integer = (t8) ref;

                  NILCHECKB (z10 = _integer); z11 = CVTIF ((*((t2*) z10))); z12 = z11; _result = (*((t2*)(& z12))); } } goto tc16_exit;
#line 1178
 tc16_5:; { auto t6 _longReal; {
                  ZERO1  (& _longReal);
#line 1178
                  _longReal = (t6) ref;

                  NILCHECKB (z13 = _longReal); z11 = CVTLF ((*((t7*) z13))); z12 = z11; _result = (*((t2*)(& z12))); } } goto tc16_exit;
#line 1180
 tc16_6:; { auto t5 _text; {
                  ZERO1  (& _text);
#line 1180
                  _text = (t5) ref;

                  { int from, to, index; from =  0 ; z14 = _Text__Length (_text); z3 = z14 -  1 ; to = z3; { auto t2 _i; {
#line 1182
                           for (index = from; index <= to; index += 1) { _i = (t2) index;
                              z3 = _i * _result; z15 = _Text__GetChar (_text, _i); z0 = z3 + z15; _result = z0; } } }; };
#line 1183
                  } } goto tc16_exit; tc16_else:; _result = (*((t2*)(& _x)));


 tc16_exit:; };


      __result = _result; return __result; } } };
#line 1193 "List.m3"
 EXPORT t2 _List__HashQ (_arg, _x) t3 _arg; t3 _x; {
#line 1193 "List.m3"
{ auto t2 __result; { CHECKSTACKOVERFLOW;

      __result = (*((t2*)(& _x))); return __result; } } };  PRIVATE int init_done = -1;
#line 1195 "List.m3"
 PRIVATE void List__initProc (g) int g; {
#line 1195 "List.m3"
if (init_done >= g) return; init_done = g; INITIALIZE (& List__init); INITIALIZE (& Thread__init); INITIALIZE (& Text__init);
#line 1195
INITIALIZE (& Rd__init); return; }; 
#line 1195 "List.m3"
PRIVATE void t6_PrintProc (ref) t7* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC6->brand); fprintf (stderr, "^ = %g", (*ref));
#line 1195
   fprintf (stderr, "}\n"); }; 
#line 1195 "List.m3"
PRIVATE void t8_PrintProc (ref) t2* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC8->brand); fprintf (stderr, "^ = %d", (*ref));
#line 1195
   fprintf (stderr, "}\n"); }; 
#line 1195 "List.m3"
PRIVATE void t9_PrintProc (ref) t10* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC9->brand); fprintf (stderr, "^ = %d", (*ref));
#line 1195
   fprintf (stderr, "}\n"); }; 
#line 1195 "List.m3"
PRIVATE void t11_PrintProc (ref) t12* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC11->brand); fprintf (stderr, "^ = %d", (*ref));
#line 1195
   fprintf (stderr, "}\n"); }; 
#line 1195 "List.m3"
PRIVATE void t13_PrintProc (ref) t14* ref; { CHECKSTACKOVERFLOW; fprintf (stderr, "%s {", TC13->brand); fprintf (stderr, "^ = array");
#line 1195
   fprintf (stderr, "}\n"); }; 
#line 1195 "List.m3"
PRIVATE void t23_InitProc (obj) char* obj; { register t23_fields* p;
#line 1195 "List.m3"
CHECKSTACKOVERFLOW; p = (t23_fields*) (obj + TC27->datasize); }; 
#line 1195 "List.m3"
PRIVATE void t23_SetupProc () { register int* p;
#line 1195 "List.m3"
t23_TC.datasize += TC27->datasize; t23_TC.methodsize += TC27->methodsize; p = (int*) UALLOC (t23_TC.methodsize); COPY (TC27->defaultMethods, p, (TC27->methodsize));
#line 1195
p[0] = (int)(& t23_TC); p[1] = 0; t23_TC.defaultMethods = (char*) p; }; 
#line 1195 "List.m3"
PRIVATE void t23_PrintProc (obj) char *obj; { t23_fields* o;
#line 1195 "List.m3"
CHECKSTACKOVERFLOW; if (TC27->printProc != 0) {TC27->printProc (obj); } fprintf (stderr, "{%s} ", TC23->brand); o = (t23_fields*) (obj + TC27->datasize);
#line 1195
fprintf (stderr, "proc = %#x", o->_proc); fprintf (stderr, ", "); fprintf (stderr, "arg = %#x", o->_arg); fprintf (stderr, ", ");
#line 1195
fprintf (stderr, "first = %#x", o->_first); };  PRIVATE void t13_MapProc (p, r, c) void (*p) (); register t14* r; ADDRESS c;
#line 1195
{ CHECKSTACKOVERFLOW; { int i1, j; t42* zz; t3* aptr; zz = & ((*r)); j = zz->size[0]; aptr = (t3*) zz->elts; for (i1 = 0; i1 < j; i1++) {
#line 1195
      p (& (aptr[i1]), r, c); }; }; };  PRIVATE void t15_MapProc (p, r, c) void (*p) (); register t43* r; ADDRESS c; { CHECKSTACKOVERFLOW;
#line 1195
p (& ((*r)._first), r, c); p (& ((*r)._tail), r, c); };  PRIVATE void t23_MapProc (p, r, c) void (*p) (); char*  r; ADDRESS c;
#line 1195
{ register t23_fields*  o; CHECKSTACKOVERFLOW; t27_MapProc (p, r, c); o = (t23_fields*) (r + TC27->datasize); p (& (o->_arg), r, c);
#line 1195
p (& (o->_first), r, c); };   PRIVATE INITLINK me_0 ={(INITLINK*)NIL, 0, List__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__Fork__ef3a2f9230b337c8, &VS_Thread__Join__4341274725ba29c2, &VS_Thread__Alerted__fc88feb43485af46,
&VS_Text__T__fc4b369f3ab271fd, &VS_Text__Equal__f19b6e6f34d36826, &VS_Text__GetChar__0f4bd6e72493f4ff, &VS_Text__Length__661a58173d76f41c,
&VS_Text__Empty__f8aa6446353b9de8, &VS_Text__Compare__920fdd773789443c, &VS_Thread__Alerted__fc88feb43485af46, &VS_Rd__T__2555b70b3f7780b1,
&VS_Rd__EndOfFile__f4a9d2f63b7e105d, &VS_Rd__Failure__e4a829e331222b6d, &VS_Rd__Error__5ca07bfe2ba90cfc, &VS_List__T__c661f0b12f626d56,
NIL };  void List__MLink (phase) int phase; { switch (phase) { case 0: { me_0.link = List__init; List__init = & me_0; t6_TC = t6_TC_init;
         REGISTERTYPE (TC6); t8_TC = t8_TC_init; REGISTERTYPE (TC8); t9_TC = t9_TC_init; REGISTERTYPE (TC9); t11_TC = t11_TC_init;
         REGISTERTYPE (TC11); t13_TC = t13_TC_init; REGISTERTYPE (TC13); t23_TC = t23_TC_init; REGISTERTYPE (TC23); break; };
      case 1: { t23_TC.parent = TC_Thread__Closure; break; }; case 2: { break; }; }; };